}
hnd->status =
- rpccli_winreg_connect( pipe_hnd, mem_ctx, op->in.root,
+ rpccli_winreg_Connect( pipe_hnd, mem_ctx, op->in.root,
op->in.access, key );
if ( !NT_STATUS_IS_OK( hnd->status ) ) {
resume_idx = op->out.resume_idx;
do {
+#if 0 /* FIXME!!! */
+
hnd->status =
- rpccli_winreg_enum_key( pipe_hnd, mem_ctx, op->in.key,
+ rpccli_winreg_EnumKey( pipe_hnd, mem_ctx, op->in.key,
resume_idx, key_name_in,
class_name_in,
&mod_times_out
[num_keys_out] );
+#endif
if ( !NT_STATUS_IS_OK( hnd->status ) ) {
/*don't increment any values */
break;
struct winreg_String key_string;
NTSTATUS status;
+#if 0 /* FIXME!!! */
status = rpccli_winreg_enum_key( pipe_hnd, mem_ctx, key,
cur_key, subkey_name,
class_buf, &mod_time_buf );
+#endif
if ( !NT_STATUS_IS_OK( status ) )
break;
do {
ZERO_STRUCT( val_buf );
+#if 0
hnd->status =
rpccli_winreg_enum_val( pipe_hnd, mem_ctx, op->in.key,
resume_idx, val_name_buf,
&types_out[num_values_out],
&val_buf );
+#endif
if ( !NT_STATUS_IS_OK( hnd->status ) )
break;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_GETMANAGERVERSION, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_GetManagerVersion, (ndr_push_flags_fn_t)ndr_push_dfs_GetManagerVersion);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_GetManagerVersion, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_ADD, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_Add, (ndr_push_flags_fn_t)ndr_push_dfs_Add);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_Add, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_REMOVE, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_Remove, (ndr_push_flags_fn_t)ndr_push_dfs_Remove);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_Remove, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_SETINFO, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_SetInfo, (ndr_push_flags_fn_t)ndr_push_dfs_SetInfo);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_SetInfo, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_GETINFO, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_GetInfo, (ndr_push_flags_fn_t)ndr_push_dfs_GetInfo);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_GetInfo, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_ENUM, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_Enum, (ndr_push_flags_fn_t)ndr_push_dfs_Enum);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_Enum, &r);
}
/* Return variables */
- *info = *r.out.info;
- *total = *r.out.total;
+ if ( info ) {
+ *info = *r.out.info;
+ }
+ if ( total ) {
+ *total = *r.out.total;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_RENAME, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_Rename, (ndr_push_flags_fn_t)ndr_push_dfs_Rename);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_Rename, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_MOVE, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_Move, (ndr_push_flags_fn_t)ndr_push_dfs_Move);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_Move, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_MANAGERGETCONFIGINFO, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_ManagerGetConfigInfo, (ndr_push_flags_fn_t)ndr_push_dfs_ManagerGetConfigInfo);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_ManagerGetConfigInfo, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_MANAGERSENDSITEINFO, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_ManagerSendSiteInfo, (ndr_push_flags_fn_t)ndr_push_dfs_ManagerSendSiteInfo);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_ManagerSendSiteInfo, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_ADDFTROOT, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_AddFtRoot, (ndr_push_flags_fn_t)ndr_push_dfs_AddFtRoot);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_AddFtRoot, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_REMOVEFTROOT, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_RemoveFtRoot, (ndr_push_flags_fn_t)ndr_push_dfs_RemoveFtRoot);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_RemoveFtRoot, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_ADDSTDROOT, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_AddStdRoot, (ndr_push_flags_fn_t)ndr_push_dfs_AddStdRoot);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_AddStdRoot, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_REMOVESTDROOT, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_RemoveStdRoot, (ndr_push_flags_fn_t)ndr_push_dfs_RemoveStdRoot);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_RemoveStdRoot, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_MANAGERINITIALIZE, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_ManagerInitialize, (ndr_push_flags_fn_t)ndr_push_dfs_ManagerInitialize);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_ManagerInitialize, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_ADDSTDROOTFORCED, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_AddStdRootForced, (ndr_push_flags_fn_t)ndr_push_dfs_AddStdRootForced);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_AddStdRootForced, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_GETDCADDRESS, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_GetDcAddress, (ndr_push_flags_fn_t)ndr_push_dfs_GetDcAddress);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_GetDcAddress, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_SETDCADDRESS, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_SetDcAddress, (ndr_push_flags_fn_t)ndr_push_dfs_SetDcAddress);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_SetDcAddress, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_FLUSHFTTABLE, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_FlushFtTable, (ndr_push_flags_fn_t)ndr_push_dfs_FlushFtTable);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_FlushFtTable, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_ADD2, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_Add2, (ndr_push_flags_fn_t)ndr_push_dfs_Add2);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_Add2, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_REMOVE2, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_Remove2, (ndr_push_flags_fn_t)ndr_push_dfs_Remove2);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_Remove2, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_ENUMEX, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_EnumEx, (ndr_push_flags_fn_t)ndr_push_dfs_EnumEx);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_EnumEx, &r);
}
/* Return variables */
- *info = *r.out.info;
- *total = *r.out.total;
+ if ( info ) {
+ *info = *r.out.info;
+ }
+ if ( total ) {
+ *total = *r.out.total;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETDFS, DCERPC_DFS_SETINFO2, &r, (ndr_pull_flags_fn_t)ndr_pull_dfs_SetInfo2, (ndr_push_flags_fn_t)ndr_push_dfs_SetInfo2);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(dfs_SetInfo2, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_RPCECHO, DCERPC_ECHO_ADDONE, &r, (ndr_pull_flags_fn_t)ndr_pull_echo_AddOne, (ndr_push_flags_fn_t)ndr_push_echo_AddOne);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(echo_AddOne, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_RPCECHO, DCERPC_ECHO_ECHODATA, &r, (ndr_pull_flags_fn_t)ndr_pull_echo_EchoData, (ndr_push_flags_fn_t)ndr_push_echo_EchoData);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(echo_EchoData, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_RPCECHO, DCERPC_ECHO_SINKDATA, &r, (ndr_pull_flags_fn_t)ndr_pull_echo_SinkData, (ndr_push_flags_fn_t)ndr_push_echo_SinkData);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(echo_SinkData, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_RPCECHO, DCERPC_ECHO_SOURCEDATA, &r, (ndr_pull_flags_fn_t)ndr_pull_echo_SourceData, (ndr_push_flags_fn_t)ndr_push_echo_SourceData);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(echo_SourceData, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_RPCECHO, DCERPC_ECHO_TESTCALL, &r, (ndr_pull_flags_fn_t)ndr_pull_echo_TestCall, (ndr_push_flags_fn_t)ndr_push_echo_TestCall);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(echo_TestCall, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_RPCECHO, DCERPC_ECHO_TESTCALL2, &r, (ndr_pull_flags_fn_t)ndr_pull_echo_TestCall2, (ndr_push_flags_fn_t)ndr_push_echo_TestCall2);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(echo_TestCall2, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_RPCECHO, DCERPC_ECHO_TESTSLEEP, &r, (ndr_pull_flags_fn_t)ndr_pull_echo_TestSleep, (ndr_push_flags_fn_t)ndr_push_echo_TestSleep);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(echo_TestSleep, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_RPCECHO, DCERPC_ECHO_TESTENUM, &r, (ndr_pull_flags_fn_t)ndr_pull_echo_TestEnum, (ndr_push_flags_fn_t)ndr_push_echo_TestEnum);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(echo_TestEnum, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_RPCECHO, DCERPC_ECHO_TESTSURROUNDING, &r, (ndr_pull_flags_fn_t)ndr_pull_echo_TestSurrounding, (ndr_push_flags_fn_t)ndr_push_echo_TestSurrounding);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(echo_TestSurrounding, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_RPCECHO, DCERPC_ECHO_TESTDOUBLEPOINTER, &r, (ndr_pull_flags_fn_t)ndr_pull_echo_TestDoublePointer, (ndr_push_flags_fn_t)ndr_push_echo_TestDoublePointer);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(echo_TestDoublePointer, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_CLEAREVENTLOGW, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_ClearEventLogW, (ndr_push_flags_fn_t)ndr_push_eventlog_ClearEventLogW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_ClearEventLogW, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_BACKUPEVENTLOGW, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_BackupEventLogW, (ndr_push_flags_fn_t)ndr_push_eventlog_BackupEventLogW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_BackupEventLogW, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_CLOSEEVENTLOG, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_CloseEventLog, (ndr_push_flags_fn_t)ndr_push_eventlog_CloseEventLog);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_CloseEventLog, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_DEREGISTEREVENTSOURCE, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_DeregisterEventSource, (ndr_push_flags_fn_t)ndr_push_eventlog_DeregisterEventSource);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_DeregisterEventSource, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_GETNUMRECORDS, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_GetNumRecords, (ndr_push_flags_fn_t)ndr_push_eventlog_GetNumRecords);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_GetNumRecords, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_GETOLDESTRECORD, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_GetOldestRecord, (ndr_push_flags_fn_t)ndr_push_eventlog_GetOldestRecord);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_GetOldestRecord, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_CHANGENOTIFY, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_ChangeNotify, (ndr_push_flags_fn_t)ndr_push_eventlog_ChangeNotify);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_ChangeNotify, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_OPENEVENTLOGW, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_OpenEventLogW, (ndr_push_flags_fn_t)ndr_push_eventlog_OpenEventLogW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_OpenEventLogW, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_REGISTEREVENTSOURCEW, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_RegisterEventSourceW, (ndr_push_flags_fn_t)ndr_push_eventlog_RegisterEventSourceW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_RegisterEventSourceW, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_OPENBACKUPEVENTLOGW, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_OpenBackupEventLogW, (ndr_push_flags_fn_t)ndr_push_eventlog_OpenBackupEventLogW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_OpenBackupEventLogW, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_READEVENTLOGW, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_ReadEventLogW, (ndr_push_flags_fn_t)ndr_push_eventlog_ReadEventLogW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_ReadEventLogW, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_REPORTEVENTW, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_ReportEventW, (ndr_push_flags_fn_t)ndr_push_eventlog_ReportEventW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_ReportEventW, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_CLEAREVENTLOGA, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_ClearEventLogA, (ndr_push_flags_fn_t)ndr_push_eventlog_ClearEventLogA);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_ClearEventLogA, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_BACKUPEVENTLOGA, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_BackupEventLogA, (ndr_push_flags_fn_t)ndr_push_eventlog_BackupEventLogA);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_BackupEventLogA, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_OPENEVENTLOGA, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_OpenEventLogA, (ndr_push_flags_fn_t)ndr_push_eventlog_OpenEventLogA);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_OpenEventLogA, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_REGISTEREVENTSOURCEA, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_RegisterEventSourceA, (ndr_push_flags_fn_t)ndr_push_eventlog_RegisterEventSourceA);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_RegisterEventSourceA, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_OPENBACKUPEVENTLOGA, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_OpenBackupEventLogA, (ndr_push_flags_fn_t)ndr_push_eventlog_OpenBackupEventLogA);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_OpenBackupEventLogA, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_READEVENTLOGA, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_ReadEventLogA, (ndr_push_flags_fn_t)ndr_push_eventlog_ReadEventLogA);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_ReadEventLogA, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_REPORTEVENTA, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_ReportEventA, (ndr_push_flags_fn_t)ndr_push_eventlog_ReportEventA);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_ReportEventA, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_REGISTERCLUSTERSVC, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_RegisterClusterSvc, (ndr_push_flags_fn_t)ndr_push_eventlog_RegisterClusterSvc);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_RegisterClusterSvc, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_DEREGISTERCLUSTERSVC, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_DeregisterClusterSvc, (ndr_push_flags_fn_t)ndr_push_eventlog_DeregisterClusterSvc);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_DeregisterClusterSvc, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_WRITECLUSTEREVENTS, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_WriteClusterEvents, (ndr_push_flags_fn_t)ndr_push_eventlog_WriteClusterEvents);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_WriteClusterEvents, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_GETLOGINTORMATION, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_GetLogIntormation, (ndr_push_flags_fn_t)ndr_push_eventlog_GetLogIntormation);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_GetLogIntormation, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_EVENTLOG, DCERPC_EVENTLOG_FLUSHEVENTLOG, &r, (ndr_pull_flags_fn_t)ndr_pull_eventlog_FlushEventLog, (ndr_push_flags_fn_t)ndr_push_eventlog_FlushEventLog);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(eventlog_FlushEventLog, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_INITSHUTDOWN, DCERPC_INITSHUTDOWN_INIT, &r, (ndr_pull_flags_fn_t)ndr_pull_initshutdown_Init, (ndr_push_flags_fn_t)ndr_push_initshutdown_Init);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(initshutdown_Init, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_INITSHUTDOWN, DCERPC_INITSHUTDOWN_ABORT, &r, (ndr_pull_flags_fn_t)ndr_pull_initshutdown_Abort, (ndr_push_flags_fn_t)ndr_push_initshutdown_Abort);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(initshutdown_Abort, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_INITSHUTDOWN, DCERPC_INITSHUTDOWN_INITEX, &r, (ndr_pull_flags_fn_t)ndr_pull_initshutdown_InitEx, (ndr_push_flags_fn_t)ndr_push_initshutdown_InitEx);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(initshutdown_InitEx, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_CLOSE, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_Close, (ndr_push_flags_fn_t)ndr_push_lsa_Close);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_Close, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_DELETE, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_Delete, (ndr_push_flags_fn_t)ndr_push_lsa_Delete);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_Delete, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_ENUMPRIVS, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_EnumPrivs, (ndr_push_flags_fn_t)ndr_push_lsa_EnumPrivs);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_EnumPrivs, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_QUERYSECURITY, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_QuerySecurity, (ndr_push_flags_fn_t)ndr_push_lsa_QuerySecurity);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_QuerySecurity, &r);
}
/* Return variables */
- *sdbuf = *r.out.sdbuf;
+ if ( sdbuf ) {
+ *sdbuf = *r.out.sdbuf;
+ }
/* Return result */
return r.out.result;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_SETSECOBJ, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_SetSecObj, (ndr_push_flags_fn_t)ndr_push_lsa_SetSecObj);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_SetSecObj, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_CHANGEPASSWORD, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_ChangePassword, (ndr_push_flags_fn_t)ndr_push_lsa_ChangePassword);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_ChangePassword, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_OPENPOLICY, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_OpenPolicy, (ndr_push_flags_fn_t)ndr_push_lsa_OpenPolicy);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_OpenPolicy, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_QUERYINFOPOLICY, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_QueryInfoPolicy, (ndr_push_flags_fn_t)ndr_push_lsa_QueryInfoPolicy);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_QueryInfoPolicy, &r);
}
/* Return variables */
- *info = *r.out.info;
+ if ( info ) {
+ *info = *r.out.info;
+ }
/* Return result */
return r.out.result;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_SETINFOPOLICY, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_SetInfoPolicy, (ndr_push_flags_fn_t)ndr_push_lsa_SetInfoPolicy);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_SetInfoPolicy, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_CLEARAUDITLOG, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_ClearAuditLog, (ndr_push_flags_fn_t)ndr_push_lsa_ClearAuditLog);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_ClearAuditLog, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_CREATEACCOUNT, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_CreateAccount, (ndr_push_flags_fn_t)ndr_push_lsa_CreateAccount);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_CreateAccount, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_ENUMACCOUNTS, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_EnumAccounts, (ndr_push_flags_fn_t)ndr_push_lsa_EnumAccounts);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_EnumAccounts, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_CREATETRUSTEDDOMAIN, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_CreateTrustedDomain, (ndr_push_flags_fn_t)ndr_push_lsa_CreateTrustedDomain);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomain, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_ENUMTRUSTDOM, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_EnumTrustDom, (ndr_push_flags_fn_t)ndr_push_lsa_EnumTrustDom);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_EnumTrustDom, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_LOOKUPNAMES, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_LookupNames, (ndr_push_flags_fn_t)ndr_push_lsa_LookupNames);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_LookupNames, &r);
}
/* Return variables */
- *domains = *r.out.domains;
+ if ( domains ) {
+ *domains = *r.out.domains;
+ }
*sids = *r.out.sids;
*count = *r.out.count;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_LOOKUPSIDS, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_LookupSids, (ndr_push_flags_fn_t)ndr_push_lsa_LookupSids);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_LookupSids, &r);
}
/* Return variables */
- *domains = *r.out.domains;
+ if ( domains ) {
+ *domains = *r.out.domains;
+ }
*names = *r.out.names;
*count = *r.out.count;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_CREATESECRET, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_CreateSecret, (ndr_push_flags_fn_t)ndr_push_lsa_CreateSecret);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_CreateSecret, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_OPENACCOUNT, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_OpenAccount, (ndr_push_flags_fn_t)ndr_push_lsa_OpenAccount);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_OpenAccount, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_ENUMPRIVSACCOUNT, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_EnumPrivsAccount, (ndr_push_flags_fn_t)ndr_push_lsa_EnumPrivsAccount);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_EnumPrivsAccount, &r);
}
/* Return variables */
- *privs = *r.out.privs;
+ if ( privs ) {
+ *privs = *r.out.privs;
+ }
/* Return result */
return r.out.result;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_ADDPRIVILEGESTOACCOUNT, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_AddPrivilegesToAccount, (ndr_push_flags_fn_t)ndr_push_lsa_AddPrivilegesToAccount);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_AddPrivilegesToAccount, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_REMOVEPRIVILEGESFROMACCOUNT, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_RemovePrivilegesFromAccount, (ndr_push_flags_fn_t)ndr_push_lsa_RemovePrivilegesFromAccount);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_RemovePrivilegesFromAccount, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_GETQUOTASFORACCOUNT, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_GetQuotasForAccount, (ndr_push_flags_fn_t)ndr_push_lsa_GetQuotasForAccount);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_GetQuotasForAccount, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_SETQUOTASFORACCOUNT, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_SetQuotasForAccount, (ndr_push_flags_fn_t)ndr_push_lsa_SetQuotasForAccount);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_SetQuotasForAccount, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_GETSYSTEMACCESSACCOUNT, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_GetSystemAccessAccount, (ndr_push_flags_fn_t)ndr_push_lsa_GetSystemAccessAccount);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_GetSystemAccessAccount, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_SETSYSTEMACCESSACCOUNT, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_SetSystemAccessAccount, (ndr_push_flags_fn_t)ndr_push_lsa_SetSystemAccessAccount);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_SetSystemAccessAccount, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_OPENTRUSTEDDOMAIN, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_OpenTrustedDomain, (ndr_push_flags_fn_t)ndr_push_lsa_OpenTrustedDomain);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_OpenTrustedDomain, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_QUERYTRUSTEDDOMAININFO, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_QueryTrustedDomainInfo, (ndr_push_flags_fn_t)ndr_push_lsa_QueryTrustedDomainInfo);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfo, &r);
}
/* Return variables */
- *info = *r.out.info;
+ if ( info ) {
+ *info = *r.out.info;
+ }
/* Return result */
return r.out.result;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_SETINFORMATIONTRUSTEDDOMAIN, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_SetInformationTrustedDomain, (ndr_push_flags_fn_t)ndr_push_lsa_SetInformationTrustedDomain);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_SetInformationTrustedDomain, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_OPENSECRET, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_OpenSecret, (ndr_push_flags_fn_t)ndr_push_lsa_OpenSecret);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_OpenSecret, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_SETSECRET, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_SetSecret, (ndr_push_flags_fn_t)ndr_push_lsa_SetSecret);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_SetSecret, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_QUERYSECRET, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_QuerySecret, (ndr_push_flags_fn_t)ndr_push_lsa_QuerySecret);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_QuerySecret, &r);
}
/* Return variables */
- *new_val = *r.out.new_val;
- *new_mtime = *r.out.new_mtime;
- *old_val = *r.out.old_val;
- *old_mtime = *r.out.old_mtime;
+ if ( new_val ) {
+ *new_val = *r.out.new_val;
+ }
+ if ( new_mtime ) {
+ *new_mtime = *r.out.new_mtime;
+ }
+ if ( old_val ) {
+ *old_val = *r.out.old_val;
+ }
+ if ( old_mtime ) {
+ *old_mtime = *r.out.old_mtime;
+ }
/* Return result */
return r.out.result;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_LOOKUPPRIVVALUE, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_LookupPrivValue, (ndr_push_flags_fn_t)ndr_push_lsa_LookupPrivValue);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_LookupPrivValue, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_LOOKUPPRIVNAME, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_LookupPrivName, (ndr_push_flags_fn_t)ndr_push_lsa_LookupPrivName);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_LookupPrivName, &r);
}
/* Return variables */
- *name = *r.out.name;
+ if ( name ) {
+ *name = *r.out.name;
+ }
/* Return result */
return r.out.result;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_LOOKUPPRIVDISPLAYNAME, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_LookupPrivDisplayName, (ndr_push_flags_fn_t)ndr_push_lsa_LookupPrivDisplayName);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_LookupPrivDisplayName, &r);
}
/* Return variables */
- *disp_name = *r.out.disp_name;
+ if ( disp_name ) {
+ *disp_name = *r.out.disp_name;
+ }
*language_id = *r.out.language_id;
/* Return result */
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_DELETEOBJECT, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_DeleteObject, (ndr_push_flags_fn_t)ndr_push_lsa_DeleteObject);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_DeleteObject, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_ENUMACCOUNTSWITHUSERRIGHT, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_EnumAccountsWithUserRight, (ndr_push_flags_fn_t)ndr_push_lsa_EnumAccountsWithUserRight);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_EnumAccountsWithUserRight, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_ENUMACCOUNTRIGHTS, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_EnumAccountRights, (ndr_push_flags_fn_t)ndr_push_lsa_EnumAccountRights);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_EnumAccountRights, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_ADDACCOUNTRIGHTS, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_AddAccountRights, (ndr_push_flags_fn_t)ndr_push_lsa_AddAccountRights);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_AddAccountRights, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_REMOVEACCOUNTRIGHTS, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_RemoveAccountRights, (ndr_push_flags_fn_t)ndr_push_lsa_RemoveAccountRights);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_RemoveAccountRights, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_QUERYTRUSTEDDOMAININFOBYSID, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_QueryTrustedDomainInfoBySid, (ndr_push_flags_fn_t)ndr_push_lsa_QueryTrustedDomainInfoBySid);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfoBySid, &r);
}
/* Return variables */
- *info = *r.out.info;
+ if ( info ) {
+ *info = *r.out.info;
+ }
/* Return result */
return r.out.result;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_SETTRUSTEDDOMAININFO, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_SetTrustedDomainInfo, (ndr_push_flags_fn_t)ndr_push_lsa_SetTrustedDomainInfo);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_SetTrustedDomainInfo, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_DELETETRUSTEDDOMAIN, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_DeleteTrustedDomain, (ndr_push_flags_fn_t)ndr_push_lsa_DeleteTrustedDomain);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_DeleteTrustedDomain, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_STOREPRIVATEDATA, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_StorePrivateData, (ndr_push_flags_fn_t)ndr_push_lsa_StorePrivateData);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_StorePrivateData, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_RETRIEVEPRIVATEDATA, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_RetrievePrivateData, (ndr_push_flags_fn_t)ndr_push_lsa_RetrievePrivateData);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_RetrievePrivateData, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_OPENPOLICY2, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_OpenPolicy2, (ndr_push_flags_fn_t)ndr_push_lsa_OpenPolicy2);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_OpenPolicy2, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_GETUSERNAME, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_GetUserName, (ndr_push_flags_fn_t)ndr_push_lsa_GetUserName);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_GetUserName, &r);
}
/* Return variables */
- *account_name = *r.out.account_name;
- *authority_name = *r.out.authority_name;
+ if ( account_name ) {
+ *account_name = *r.out.account_name;
+ }
+ if ( authority_name ) {
+ *authority_name = *r.out.authority_name;
+ }
/* Return result */
return r.out.result;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_QUERYINFOPOLICY2, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_QueryInfoPolicy2, (ndr_push_flags_fn_t)ndr_push_lsa_QueryInfoPolicy2);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_QueryInfoPolicy2, &r);
}
/* Return variables */
- *info = *r.out.info;
+ if ( info ) {
+ *info = *r.out.info;
+ }
/* Return result */
return r.out.result;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_SETINFOPOLICY2, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_SetInfoPolicy2, (ndr_push_flags_fn_t)ndr_push_lsa_SetInfoPolicy2);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_SetInfoPolicy2, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_QUERYTRUSTEDDOMAININFOBYNAME, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_QueryTrustedDomainInfoByName, (ndr_push_flags_fn_t)ndr_push_lsa_QueryTrustedDomainInfoByName);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_QueryTrustedDomainInfoByName, &r);
}
/* Return variables */
- *info = *r.out.info;
+ if ( info ) {
+ *info = *r.out.info;
+ }
/* Return result */
return r.out.result;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_SETTRUSTEDDOMAININFOBYNAME, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_SetTrustedDomainInfoByName, (ndr_push_flags_fn_t)ndr_push_lsa_SetTrustedDomainInfoByName);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_SetTrustedDomainInfoByName, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_ENUMTRUSTEDDOMAINSEX, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_EnumTrustedDomainsEx, (ndr_push_flags_fn_t)ndr_push_lsa_EnumTrustedDomainsEx);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_EnumTrustedDomainsEx, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_CREATETRUSTEDDOMAINEX, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_CreateTrustedDomainEx, (ndr_push_flags_fn_t)ndr_push_lsa_CreateTrustedDomainEx);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomainEx, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_CLOSETRUSTEDDOMAINEX, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_CloseTrustedDomainEx, (ndr_push_flags_fn_t)ndr_push_lsa_CloseTrustedDomainEx);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_CloseTrustedDomainEx, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_QUERYDOMAININFORMATIONPOLICY, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_QueryDomainInformationPolicy, (ndr_push_flags_fn_t)ndr_push_lsa_QueryDomainInformationPolicy);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_QueryDomainInformationPolicy, &r);
}
/* Return variables */
- *info = *r.out.info;
+ if ( info ) {
+ *info = *r.out.info;
+ }
/* Return result */
return r.out.result;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_SETDOMAININFORMATIONPOLICY, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_SetDomainInformationPolicy, (ndr_push_flags_fn_t)ndr_push_lsa_SetDomainInformationPolicy);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_SetDomainInformationPolicy, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_OPENTRUSTEDDOMAINBYNAME, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_OpenTrustedDomainByName, (ndr_push_flags_fn_t)ndr_push_lsa_OpenTrustedDomainByName);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_OpenTrustedDomainByName, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_TESTCALL, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_TestCall, (ndr_push_flags_fn_t)ndr_push_lsa_TestCall);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_TestCall, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_LOOKUPSIDS2, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_LookupSids2, (ndr_push_flags_fn_t)ndr_push_lsa_LookupSids2);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_LookupSids2, &r);
}
/* Return variables */
- *domains = *r.out.domains;
+ if ( domains ) {
+ *domains = *r.out.domains;
+ }
*names = *r.out.names;
*count = *r.out.count;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_LOOKUPNAMES2, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_LookupNames2, (ndr_push_flags_fn_t)ndr_push_lsa_LookupNames2);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_LookupNames2, &r);
}
/* Return variables */
- *domains = *r.out.domains;
+ if ( domains ) {
+ *domains = *r.out.domains;
+ }
*sids = *r.out.sids;
*count = *r.out.count;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_CREATETRUSTEDDOMAINEX2, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_CreateTrustedDomainEx2, (ndr_push_flags_fn_t)ndr_push_lsa_CreateTrustedDomainEx2);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_CreateTrustedDomainEx2, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_CREDRWRITE, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_CREDRWRITE, (ndr_push_flags_fn_t)ndr_push_lsa_CREDRWRITE);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_CREDRWRITE, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_CREDRREAD, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_CREDRREAD, (ndr_push_flags_fn_t)ndr_push_lsa_CREDRREAD);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_CREDRREAD, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_CREDRENUMERATE, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_CREDRENUMERATE, (ndr_push_flags_fn_t)ndr_push_lsa_CREDRENUMERATE);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_CREDRENUMERATE, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_CREDRWRITEDOMAINCREDENTIALS, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_CREDRWRITEDOMAINCREDENTIALS, (ndr_push_flags_fn_t)ndr_push_lsa_CREDRWRITEDOMAINCREDENTIALS);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_CREDRWRITEDOMAINCREDENTIALS, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_CREDRREADDOMAINCREDENTIALS, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_CREDRREADDOMAINCREDENTIALS, (ndr_push_flags_fn_t)ndr_push_lsa_CREDRREADDOMAINCREDENTIALS);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_CREDRREADDOMAINCREDENTIALS, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_CREDRDELETE, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_CREDRDELETE, (ndr_push_flags_fn_t)ndr_push_lsa_CREDRDELETE);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_CREDRDELETE, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_CREDRGETTARGETINFO, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_CREDRGETTARGETINFO, (ndr_push_flags_fn_t)ndr_push_lsa_CREDRGETTARGETINFO);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_CREDRGETTARGETINFO, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_CREDRPROFILELOADED, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_CREDRPROFILELOADED, (ndr_push_flags_fn_t)ndr_push_lsa_CREDRPROFILELOADED);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_CREDRPROFILELOADED, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_LOOKUPNAMES3, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_LookupNames3, (ndr_push_flags_fn_t)ndr_push_lsa_LookupNames3);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_LookupNames3, &r);
}
/* Return variables */
- *domains = *r.out.domains;
+ if ( domains ) {
+ *domains = *r.out.domains;
+ }
*sids = *r.out.sids;
*count = *r.out.count;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_CREDRGETSESSIONTYPES, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_CREDRGETSESSIONTYPES, (ndr_push_flags_fn_t)ndr_push_lsa_CREDRGETSESSIONTYPES);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_CREDRGETSESSIONTYPES, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_LSARREGISTERAUDITEVENT, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_LSARREGISTERAUDITEVENT, (ndr_push_flags_fn_t)ndr_push_lsa_LSARREGISTERAUDITEVENT);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_LSARREGISTERAUDITEVENT, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_LSARGENAUDITEVENT, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_LSARGENAUDITEVENT, (ndr_push_flags_fn_t)ndr_push_lsa_LSARGENAUDITEVENT);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_LSARGENAUDITEVENT, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_LSARUNREGISTERAUDITEVENT, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_LSARUNREGISTERAUDITEVENT, (ndr_push_flags_fn_t)ndr_push_lsa_LSARUNREGISTERAUDITEVENT);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_LSARUNREGISTERAUDITEVENT, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_LSARQUERYFORESTTRUSTINFORMATION, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_LSARQUERYFORESTTRUSTINFORMATION, (ndr_push_flags_fn_t)ndr_push_lsa_LSARQUERYFORESTTRUSTINFORMATION);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_LSARQUERYFORESTTRUSTINFORMATION, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_LSARSETFORESTTRUSTINFORMATION, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_LSARSETFORESTTRUSTINFORMATION, (ndr_push_flags_fn_t)ndr_push_lsa_LSARSETFORESTTRUSTINFORMATION);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_LSARSETFORESTTRUSTINFORMATION, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_CREDRRENAME, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_CREDRRENAME, (ndr_push_flags_fn_t)ndr_push_lsa_CREDRRENAME);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_CREDRRENAME, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_LOOKUPSIDS3, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_LookupSids3, (ndr_push_flags_fn_t)ndr_push_lsa_LookupSids3);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_LookupSids3, &r);
}
/* Return variables */
- *domains = *r.out.domains;
+ if ( domains ) {
+ *domains = *r.out.domains;
+ }
*names = *r.out.names;
*count = *r.out.count;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_LOOKUPNAMES4, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_LookupNames4, (ndr_push_flags_fn_t)ndr_push_lsa_LookupNames4);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_LookupNames4, &r);
}
/* Return variables */
- *domains = *r.out.domains;
+ if ( domains ) {
+ *domains = *r.out.domains;
+ }
*sids = *r.out.sids;
*count = *r.out.count;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_LSAROPENPOLICYSCE, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_LSAROPENPOLICYSCE, (ndr_push_flags_fn_t)ndr_push_lsa_LSAROPENPOLICYSCE);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_LSAROPENPOLICYSCE, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_LSARADTREGISTERSECURITYEVENTSOURCE, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_LSARADTREGISTERSECURITYEVENTSOURCE, (ndr_push_flags_fn_t)ndr_push_lsa_LSARADTREGISTERSECURITYEVENTSOURCE);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_LSARADTREGISTERSECURITYEVENTSOURCE, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE, (ndr_push_flags_fn_t)ndr_push_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_LSARPC, DCERPC_LSA_LSARADTREPORTSECURITYEVENT, &r, (ndr_pull_flags_fn_t)ndr_pull_lsa_LSARADTREPORTSECURITYEVENT, (ndr_push_flags_fn_t)ndr_push_lsa_LSARADTREPORTSECURITYEVENT);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(lsa_LSARADTREPORTSECURITYEVENT, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_LOGONUASLOGON, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_LogonUasLogon, (ndr_push_flags_fn_t)ndr_push_netr_LogonUasLogon);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_LogonUasLogon, &r);
}
/* Return variables */
- *info = *r.out.info;
+ if ( info ) {
+ *info = *r.out.info;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_LOGONUASLOGOFF, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_LogonUasLogoff, (ndr_push_flags_fn_t)ndr_push_netr_LogonUasLogoff);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_LogonUasLogoff, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_LOGONSAMLOGON, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_LogonSamLogon, (ndr_push_flags_fn_t)ndr_push_netr_LogonSamLogon);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_LogonSamLogon, &r);
}
/* Return variables */
- *return_authenticator = *r.out.return_authenticator;
+ if ( return_authenticator ) {
+ *return_authenticator = *r.out.return_authenticator;
+ }
*validation = *r.out.validation;
*authoritative = *r.out.authoritative;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_LOGONSAMLOGOFF, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_LogonSamLogoff, (ndr_push_flags_fn_t)ndr_push_netr_LogonSamLogoff);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_LogonSamLogoff, &r);
}
/* Return variables */
- *return_authenticator = *r.out.return_authenticator;
+ if ( return_authenticator ) {
+ *return_authenticator = *r.out.return_authenticator;
+ }
/* Return result */
return r.out.result;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_SERVERREQCHALLENGE, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_ServerReqChallenge, (ndr_push_flags_fn_t)ndr_push_netr_ServerReqChallenge);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_ServerReqChallenge, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_SERVERAUTHENTICATE, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_ServerAuthenticate, (ndr_push_flags_fn_t)ndr_push_netr_ServerAuthenticate);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_ServerAuthenticate, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_SERVERPASSWORDSET, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_ServerPasswordSet, (ndr_push_flags_fn_t)ndr_push_netr_ServerPasswordSet);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_ServerPasswordSet, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_DATABASEDELTAS, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_DatabaseDeltas, (ndr_push_flags_fn_t)ndr_push_netr_DatabaseDeltas);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_DatabaseDeltas, &r);
/* Return variables */
*return_authenticator = *r.out.return_authenticator;
*sequence_num = *r.out.sequence_num;
- *delta_enum_array = *r.out.delta_enum_array;
+ if ( delta_enum_array ) {
+ *delta_enum_array = *r.out.delta_enum_array;
+ }
/* Return result */
return r.out.result;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_DATABASESYNC, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_DatabaseSync, (ndr_push_flags_fn_t)ndr_push_netr_DatabaseSync);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_DatabaseSync, &r);
/* Return variables */
*return_authenticator = *r.out.return_authenticator;
*sync_context = *r.out.sync_context;
- *delta_enum_array = *r.out.delta_enum_array;
+ if ( delta_enum_array ) {
+ *delta_enum_array = *r.out.delta_enum_array;
+ }
/* Return result */
return r.out.result;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_ACCOUNTDELTAS, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_AccountDeltas, (ndr_push_flags_fn_t)ndr_push_netr_AccountDeltas);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_AccountDeltas, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_ACCOUNTSYNC, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_AccountSync, (ndr_push_flags_fn_t)ndr_push_netr_AccountSync);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_AccountSync, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_GETDCNAME, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_GetDcName, (ndr_push_flags_fn_t)ndr_push_netr_GetDcName);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_GetDcName, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_LOGONCONTROL, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_LogonControl, (ndr_push_flags_fn_t)ndr_push_netr_LogonControl);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_LogonControl, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_GETANYDCNAME, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_GetAnyDCName, (ndr_push_flags_fn_t)ndr_push_netr_GetAnyDCName);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_GetAnyDCName, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_LOGONCONTROL2, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_LogonControl2, (ndr_push_flags_fn_t)ndr_push_netr_LogonControl2);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_LogonControl2, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_SERVERAUTHENTICATE2, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_ServerAuthenticate2, (ndr_push_flags_fn_t)ndr_push_netr_ServerAuthenticate2);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_ServerAuthenticate2, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_DATABASESYNC2, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_DatabaseSync2, (ndr_push_flags_fn_t)ndr_push_netr_DatabaseSync2);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_DatabaseSync2, &r);
/* Return variables */
*return_authenticator = *r.out.return_authenticator;
*sync_context = *r.out.sync_context;
- *delta_enum_array = *r.out.delta_enum_array;
+ if ( delta_enum_array ) {
+ *delta_enum_array = *r.out.delta_enum_array;
+ }
/* Return result */
return r.out.result;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_DATABASEREDO, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_DatabaseRedo, (ndr_push_flags_fn_t)ndr_push_netr_DatabaseRedo);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_DatabaseRedo, &r);
/* Return variables */
*return_authenticator = *r.out.return_authenticator;
- *delta_enum_array = *r.out.delta_enum_array;
+ if ( delta_enum_array ) {
+ *delta_enum_array = *r.out.delta_enum_array;
+ }
/* Return result */
return r.out.result;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_LOGONCONTROL2EX, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_LogonControl2Ex, (ndr_push_flags_fn_t)ndr_push_netr_LogonControl2Ex);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_LogonControl2Ex, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_NETRENUMERATETRUSTEDDOMAINS, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_NETRENUMERATETRUSTEDDOMAINS, (ndr_push_flags_fn_t)ndr_push_netr_NETRENUMERATETRUSTEDDOMAINS);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_NETRENUMERATETRUSTEDDOMAINS, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_DSRGETDCNAME, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_DsRGetDCName, (ndr_push_flags_fn_t)ndr_push_netr_DsRGetDCName);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_DsRGetDCName, &r);
}
/* Return variables */
- *info = *r.out.info;
+ if ( info ) {
+ *info = *r.out.info;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_NETRLOGONDUMMYROUTINE1, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_NETRLOGONDUMMYROUTINE1, (ndr_push_flags_fn_t)ndr_push_netr_NETRLOGONDUMMYROUTINE1);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_NETRLOGONDUMMYROUTINE1, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_NETRLOGONSETSERVICEBITS, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_NETRLOGONSETSERVICEBITS, (ndr_push_flags_fn_t)ndr_push_netr_NETRLOGONSETSERVICEBITS);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_NETRLOGONSETSERVICEBITS, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_NETRLOGONGETTRUSTRID, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_NETRLOGONGETTRUSTRID, (ndr_push_flags_fn_t)ndr_push_netr_NETRLOGONGETTRUSTRID);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_NETRLOGONGETTRUSTRID, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_NETRLOGONCOMPUTESERVERDIGEST, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_NETRLOGONCOMPUTESERVERDIGEST, (ndr_push_flags_fn_t)ndr_push_netr_NETRLOGONCOMPUTESERVERDIGEST);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_NETRLOGONCOMPUTESERVERDIGEST, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_NETRLOGONCOMPUTECLIENTDIGEST, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_NETRLOGONCOMPUTECLIENTDIGEST, (ndr_push_flags_fn_t)ndr_push_netr_NETRLOGONCOMPUTECLIENTDIGEST);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_NETRLOGONCOMPUTECLIENTDIGEST, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_SERVERAUTHENTICATE3, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_ServerAuthenticate3, (ndr_push_flags_fn_t)ndr_push_netr_ServerAuthenticate3);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_ServerAuthenticate3, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_DSRGETDCNAMEEX, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_DsRGetDCNameEx, (ndr_push_flags_fn_t)ndr_push_netr_DsRGetDCNameEx);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_DsRGetDCNameEx, &r);
}
/* Return variables */
- *info = *r.out.info;
+ if ( info ) {
+ *info = *r.out.info;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_DSRGETSITENAME, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_DsRGetSiteName, (ndr_push_flags_fn_t)ndr_push_netr_DsRGetSiteName);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_DsRGetSiteName, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_LOGONGETDOMAININFO, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_LogonGetDomainInfo, (ndr_push_flags_fn_t)ndr_push_netr_LogonGetDomainInfo);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_LogonGetDomainInfo, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_SERVERPASSWORDSET2, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_ServerPasswordSet2, (ndr_push_flags_fn_t)ndr_push_netr_ServerPasswordSet2);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_ServerPasswordSet2, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_NETRSERVERPASSWORDGET, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_NETRSERVERPASSWORDGET, (ndr_push_flags_fn_t)ndr_push_netr_NETRSERVERPASSWORDGET);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_NETRSERVERPASSWORDGET, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_NETRLOGONSENDTOSAM, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_NETRLOGONSENDTOSAM, (ndr_push_flags_fn_t)ndr_push_netr_NETRLOGONSENDTOSAM);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_NETRLOGONSENDTOSAM, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_DSRADDRESSTOSITENAMESW, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_DSRADDRESSTOSITENAMESW, (ndr_push_flags_fn_t)ndr_push_netr_DSRADDRESSTOSITENAMESW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_DSRADDRESSTOSITENAMESW, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_DSRGETDCNAMEEX2, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_DsRGetDCNameEx2, (ndr_push_flags_fn_t)ndr_push_netr_DsRGetDCNameEx2);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_DsRGetDCNameEx2, &r);
}
/* Return variables */
- *info = *r.out.info;
+ if ( info ) {
+ *info = *r.out.info;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_NETRLOGONGETTIMESERVICEPARENTDOMAIN, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN, (ndr_push_flags_fn_t)ndr_push_netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_NETRENUMERATETRUSTEDDOMAINSEX, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_NETRENUMERATETRUSTEDDOMAINSEX, (ndr_push_flags_fn_t)ndr_push_netr_NETRENUMERATETRUSTEDDOMAINSEX);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_NETRENUMERATETRUSTEDDOMAINSEX, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_DSRADDRESSTOSITENAMESEXW, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_DSRADDRESSTOSITENAMESEXW, (ndr_push_flags_fn_t)ndr_push_netr_DSRADDRESSTOSITENAMESEXW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_DSRADDRESSTOSITENAMESEXW, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_DSRGETDCSITECOVERAGEW, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_DSRGETDCSITECOVERAGEW, (ndr_push_flags_fn_t)ndr_push_netr_DSRGETDCSITECOVERAGEW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_DSRGETDCSITECOVERAGEW, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_LOGONSAMLOGONEX, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_LogonSamLogonEx, (ndr_push_flags_fn_t)ndr_push_netr_LogonSamLogonEx);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_LogonSamLogonEx, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_DSRENUMERATEDOMAINTRUSTS, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_DsrEnumerateDomainTrusts, (ndr_push_flags_fn_t)ndr_push_netr_DsrEnumerateDomainTrusts);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_DsrEnumerateDomainTrusts, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_DSRDEREGISTERDNSHOSTRECORDS, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_DSRDEREGISTERDNSHOSTRECORDS, (ndr_push_flags_fn_t)ndr_push_netr_DSRDEREGISTERDNSHOSTRECORDS);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_DSRDEREGISTERDNSHOSTRECORDS, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_NETRSERVERTRUSTPASSWORDSGET, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_NETRSERVERTRUSTPASSWORDSGET, (ndr_push_flags_fn_t)ndr_push_netr_NETRSERVERTRUSTPASSWORDSGET);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_NETRSERVERTRUSTPASSWORDSGET, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_DSRGETFORESTTRUSTINFORMATION, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_DSRGETFORESTTRUSTINFORMATION, (ndr_push_flags_fn_t)ndr_push_netr_DSRGETFORESTTRUSTINFORMATION);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_DSRGETFORESTTRUSTINFORMATION, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_NETRGETFORESTTRUSTINFORMATION, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_NETRGETFORESTTRUSTINFORMATION, (ndr_push_flags_fn_t)ndr_push_netr_NETRGETFORESTTRUSTINFORMATION);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_NETRGETFORESTTRUSTINFORMATION, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_LOGONSAMLOGONWITHFLAGS, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_LogonSamLogonWithFlags, (ndr_push_flags_fn_t)ndr_push_netr_LogonSamLogonWithFlags);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_LogonSamLogonWithFlags, &r);
}
/* Return variables */
- *return_authenticator = *r.out.return_authenticator;
+ if ( return_authenticator ) {
+ *return_authenticator = *r.out.return_authenticator;
+ }
*validation = *r.out.validation;
*authoritative = *r.out.authoritative;
*flags = *r.out.flags;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_NETLOGON, DCERPC_NETR_NETRSERVERGETTRUSTINFO, &r, (ndr_pull_flags_fn_t)ndr_pull_netr_NETRSERVERGETTRUSTINFO, (ndr_push_flags_fn_t)ndr_push_netr_NETRSERVERGETTRUSTINFO);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(netr_NETRSERVERGETTRUSTINFO, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETCHARDEVENUM, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetCharDevEnum, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetCharDevEnum);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevEnum, &r);
*level = *r.out.level;
*ctr = *r.out.ctr;
*totalentries = *r.out.totalentries;
- *resume_handle = *r.out.resume_handle;
+ if ( resume_handle ) {
+ *resume_handle = *r.out.resume_handle;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETCHARDEVGETINFO, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetCharDevGetInfo, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetCharDevGetInfo);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevGetInfo, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETCHARDEVCONTROL, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetCharDevControl, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetCharDevControl);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevControl, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETCHARDEVQENUM, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetCharDevQEnum, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetCharDevQEnum);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQEnum, &r);
*level = *r.out.level;
*ctr = *r.out.ctr;
*totalentries = *r.out.totalentries;
- *resume_handle = *r.out.resume_handle;
+ if ( resume_handle ) {
+ *resume_handle = *r.out.resume_handle;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETCHARDEVQGETINFO, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetCharDevQGetInfo, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetCharDevQGetInfo);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQGetInfo, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETCHARDEVQSETINFO, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetCharDevQSetInfo, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetCharDevQSetInfo);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQSetInfo, &r);
}
/* Return variables */
- *parm_error = *r.out.parm_error;
+ if ( parm_error ) {
+ *parm_error = *r.out.parm_error;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETCHARDEVQPURGE, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetCharDevQPurge, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetCharDevQPurge);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQPurge, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETCHARDEVQPURGESELF, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetCharDevQPurgeSelf, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetCharDevQPurgeSelf);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQPurgeSelf, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETCONNENUM, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetConnEnum, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetConnEnum);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetConnEnum, &r);
*level = *r.out.level;
*ctr = *r.out.ctr;
*totalentries = *r.out.totalentries;
- *resume_handle = *r.out.resume_handle;
+ if ( resume_handle ) {
+ *resume_handle = *r.out.resume_handle;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETFILEENUM, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetFileEnum, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetFileEnum);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetFileEnum, &r);
*level = *r.out.level;
*ctr = *r.out.ctr;
*totalentries = *r.out.totalentries;
- *resume_handle = *r.out.resume_handle;
+ if ( resume_handle ) {
+ *resume_handle = *r.out.resume_handle;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETFILEGETINFO, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetFileGetInfo, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetFileGetInfo);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetFileGetInfo, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETFILECLOSE, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetFileClose, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetFileClose);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetFileClose, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETSESSENUM, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetSessEnum, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetSessEnum);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetSessEnum, &r);
*level = *r.out.level;
*ctr = *r.out.ctr;
*totalentries = *r.out.totalentries;
- *resume_handle = *r.out.resume_handle;
+ if ( resume_handle ) {
+ *resume_handle = *r.out.resume_handle;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETSESSDEL, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetSessDel, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetSessDel);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetSessDel, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETSHAREADD, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetShareAdd, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetShareAdd);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetShareAdd, &r);
}
/* Return variables */
- *parm_error = *r.out.parm_error;
+ if ( parm_error ) {
+ *parm_error = *r.out.parm_error;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETSHAREENUMALL, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetShareEnumAll, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetShareEnumAll);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetShareEnumAll, &r);
*level = *r.out.level;
*ctr = *r.out.ctr;
*totalentries = *r.out.totalentries;
- *resume_handle = *r.out.resume_handle;
+ if ( resume_handle ) {
+ *resume_handle = *r.out.resume_handle;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETSHAREGETINFO, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetShareGetInfo, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetShareGetInfo);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetShareGetInfo, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETSHARESETINFO, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetShareSetInfo, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetShareSetInfo);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetShareSetInfo, &r);
}
/* Return variables */
- *parm_error = *r.out.parm_error;
+ if ( parm_error ) {
+ *parm_error = *r.out.parm_error;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETSHAREDEL, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetShareDel, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetShareDel);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDel, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETSHAREDELSTICKY, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetShareDelSticky, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetShareDelSticky);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDelSticky, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETSHARECHECK, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetShareCheck, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetShareCheck);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetShareCheck, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETSRVGETINFO, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetSrvGetInfo, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetSrvGetInfo);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetSrvGetInfo, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETSRVSETINFO, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetSrvSetInfo, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetSrvSetInfo);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetSrvSetInfo, &r);
}
/* Return variables */
- *parm_error = *r.out.parm_error;
+ if ( parm_error ) {
+ *parm_error = *r.out.parm_error;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETDISKENUM, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetDiskEnum, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetDiskEnum);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetDiskEnum, &r);
/* Return variables */
*info = *r.out.info;
*totalentries = *r.out.totalentries;
- *resume_handle = *r.out.resume_handle;
+ if ( resume_handle ) {
+ *resume_handle = *r.out.resume_handle;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETSERVERSTATISTICSGET, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetServerStatisticsGet, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetServerStatisticsGet);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetServerStatisticsGet, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETTRANSPORTADD, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetTransportAdd, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetTransportAdd);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetTransportAdd, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETTRANSPORTENUM, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetTransportEnum, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetTransportEnum);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetTransportEnum, &r);
*level = *r.out.level;
*transports = *r.out.transports;
*totalentries = *r.out.totalentries;
- *resume_handle = *r.out.resume_handle;
+ if ( resume_handle ) {
+ *resume_handle = *r.out.resume_handle;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETTRANSPORTDEL, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetTransportDel, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetTransportDel);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetTransportDel, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETREMOTETOD, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetRemoteTOD, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetRemoteTOD);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetRemoteTOD, &r);
}
/* Return variables */
- *info = *r.out.info;
+ if ( info ) {
+ *info = *r.out.info;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETSETSERVICEBITS, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetSetServiceBits, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetSetServiceBits);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetSetServiceBits, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETPATHTYPE, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetPathType, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetPathType);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetPathType, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETPATHCANONICALIZE, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetPathCanonicalize, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetPathCanonicalize);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetPathCanonicalize, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETPATHCOMPARE, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetPathCompare, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetPathCompare);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetPathCompare, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETNAMEVALIDATE, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetNameValidate, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetNameValidate);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetNameValidate, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETRPRNAMECANONICALIZE, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NETRPRNAMECANONICALIZE, (ndr_push_flags_fn_t)ndr_push_srvsvc_NETRPRNAMECANONICALIZE);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NETRPRNAMECANONICALIZE, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETPRNAMECOMPARE, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetPRNameCompare, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetPRNameCompare);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetPRNameCompare, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETSHAREENUM, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetShareEnum, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetShareEnum);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetShareEnum, &r);
*level = *r.out.level;
*ctr = *r.out.ctr;
*totalentries = *r.out.totalentries;
- *resume_handle = *r.out.resume_handle;
+ if ( resume_handle ) {
+ *resume_handle = *r.out.resume_handle;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETSHAREDELSTART, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetShareDelStart, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetShareDelStart);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDelStart, &r);
}
/* Return variables */
- *hnd = *r.out.hnd;
+ if ( hnd ) {
+ *hnd = *r.out.hnd;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETSHAREDELCOMMIT, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetShareDelCommit, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetShareDelCommit);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDelCommit, &r);
}
/* Return variables */
- *hnd = *r.out.hnd;
+ if ( hnd ) {
+ *hnd = *r.out.hnd;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETGETFILESECURITY, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetGetFileSecurity, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetGetFileSecurity);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetGetFileSecurity, &r);
}
/* Return variables */
- *sd_buf = *r.out.sd_buf;
+ if ( sd_buf ) {
+ *sd_buf = *r.out.sd_buf;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETSETFILESECURITY, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetSetFileSecurity, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetSetFileSecurity);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetSetFileSecurity, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETSERVERTRANSPORTADDEX, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetServerTransportAddEx, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetServerTransportAddEx);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetServerTransportAddEx, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETSERVERSETSERVICEBITSEX, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NetServerSetServiceBitsEx, (ndr_push_flags_fn_t)ndr_push_srvsvc_NetServerSetServiceBitsEx);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NetServerSetServiceBitsEx, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETRDFSGETVERSION, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NETRDFSGETVERSION, (ndr_push_flags_fn_t)ndr_push_srvsvc_NETRDFSGETVERSION);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSGETVERSION, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETRDFSCREATELOCALPARTITION, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NETRDFSCREATELOCALPARTITION, (ndr_push_flags_fn_t)ndr_push_srvsvc_NETRDFSCREATELOCALPARTITION);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSCREATELOCALPARTITION, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETRDFSDELETELOCALPARTITION, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NETRDFSDELETELOCALPARTITION, (ndr_push_flags_fn_t)ndr_push_srvsvc_NETRDFSDELETELOCALPARTITION);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSDELETELOCALPARTITION, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETRDFSSETLOCALVOLUMESTATE, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NETRDFSSETLOCALVOLUMESTATE, (ndr_push_flags_fn_t)ndr_push_srvsvc_NETRDFSSETLOCALVOLUMESTATE);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSSETLOCALVOLUMESTATE, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETRDFSSETSERVERINFO, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NETRDFSSETSERVERINFO, (ndr_push_flags_fn_t)ndr_push_srvsvc_NETRDFSSETSERVERINFO);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSSETSERVERINFO, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETRDFSCREATEEXITPOINT, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NETRDFSCREATEEXITPOINT, (ndr_push_flags_fn_t)ndr_push_srvsvc_NETRDFSCREATEEXITPOINT);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSCREATEEXITPOINT, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETRDFSDELETEEXITPOINT, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NETRDFSDELETEEXITPOINT, (ndr_push_flags_fn_t)ndr_push_srvsvc_NETRDFSDELETEEXITPOINT);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSDELETEEXITPOINT, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETRDFSMODIFYPREFIX, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NETRDFSMODIFYPREFIX, (ndr_push_flags_fn_t)ndr_push_srvsvc_NETRDFSMODIFYPREFIX);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSMODIFYPREFIX, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETRDFSFIXLOCALVOLUME, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NETRDFSFIXLOCALVOLUME, (ndr_push_flags_fn_t)ndr_push_srvsvc_NETRDFSFIXLOCALVOLUME);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSFIXLOCALVOLUME, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETRDFSMANAGERREPORTSITEINFO, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NETRDFSMANAGERREPORTSITEINFO, (ndr_push_flags_fn_t)ndr_push_srvsvc_NETRDFSMANAGERREPORTSITEINFO);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSMANAGERREPORTSITEINFO, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SRVSVC, DCERPC_SRVSVC_NETRSERVERTRANSPORTDELEX, &r, (ndr_pull_flags_fn_t)ndr_pull_srvsvc_NETRSERVERTRANSPORTDELEX, (ndr_push_flags_fn_t)ndr_push_srvsvc_NETRSERVERTRANSPORTDELEX);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(srvsvc_NETRSERVERTRANSPORTDELEX, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_CLOSESERVICEHANDLE, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_CloseServiceHandle, (ndr_push_flags_fn_t)ndr_push_svcctl_CloseServiceHandle);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_CloseServiceHandle, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_CONTROLSERVICE, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_ControlService, (ndr_push_flags_fn_t)ndr_push_svcctl_ControlService);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_ControlService, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_DELETESERVICE, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_DeleteService, (ndr_push_flags_fn_t)ndr_push_svcctl_DeleteService);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_DeleteService, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_LOCKSERVICEDATABASE, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_LockServiceDatabase, (ndr_push_flags_fn_t)ndr_push_svcctl_LockServiceDatabase);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_LockServiceDatabase, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_QUERYSERVICEOBJECTSECURITY, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_QueryServiceObjectSecurity, (ndr_push_flags_fn_t)ndr_push_svcctl_QueryServiceObjectSecurity);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceObjectSecurity, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_SETSERVICEOBJECTSECURITY, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_SetServiceObjectSecurity, (ndr_push_flags_fn_t)ndr_push_svcctl_SetServiceObjectSecurity);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_SetServiceObjectSecurity, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_QUERYSERVICESTATUS, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_QueryServiceStatus, (ndr_push_flags_fn_t)ndr_push_svcctl_QueryServiceStatus);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceStatus, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_SETSERVICESTATUS, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_SetServiceStatus, (ndr_push_flags_fn_t)ndr_push_svcctl_SetServiceStatus);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_SetServiceStatus, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_UNLOCKSERVICEDATABASE, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_UnlockServiceDatabase, (ndr_push_flags_fn_t)ndr_push_svcctl_UnlockServiceDatabase);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_UnlockServiceDatabase, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_NOTIFYBOOTCONFIGSTATUS, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_NotifyBootConfigStatus, (ndr_push_flags_fn_t)ndr_push_svcctl_NotifyBootConfigStatus);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_NotifyBootConfigStatus, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_SCSETSERVICEBITSW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_SCSetServiceBitsW, (ndr_push_flags_fn_t)ndr_push_svcctl_SCSetServiceBitsW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_SCSetServiceBitsW, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_CHANGESERVICECONFIGW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_ChangeServiceConfigW, (ndr_push_flags_fn_t)ndr_push_svcctl_ChangeServiceConfigW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfigW, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_CREATESERVICEW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_CreateServiceW, (ndr_push_flags_fn_t)ndr_push_svcctl_CreateServiceW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_CreateServiceW, &r);
}
/* Return variables */
- *TagId = *r.out.TagId;
+ if ( TagId ) {
+ *TagId = *r.out.TagId;
+ }
*handle = *r.out.handle;
/* Return result */
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_ENUMDEPENDENTSERVICESW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_EnumDependentServicesW, (ndr_push_flags_fn_t)ndr_push_svcctl_EnumDependentServicesW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_EnumDependentServicesW, &r);
}
/* Return variables */
- *status = *r.out.status;
+ if ( status ) {
+ *status = *r.out.status;
+ }
*bytes_needed = *r.out.bytes_needed;
*services_returned = *r.out.services_returned;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_ENUMSERVICESSTATUSW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_EnumServicesStatusW, (ndr_push_flags_fn_t)ndr_push_svcctl_EnumServicesStatusW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_EnumServicesStatusW, &r);
*service = *r.out.service;
*bytes_needed = *r.out.bytes_needed;
*services_returned = *r.out.services_returned;
- *resume_handle = *r.out.resume_handle;
+ if ( resume_handle ) {
+ *resume_handle = *r.out.resume_handle;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_OPENSCMANAGERW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_OpenSCManagerW, (ndr_push_flags_fn_t)ndr_push_svcctl_OpenSCManagerW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_OpenSCManagerW, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_OPENSERVICEW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_OpenServiceW, (ndr_push_flags_fn_t)ndr_push_svcctl_OpenServiceW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_OpenServiceW, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_QUERYSERVICECONFIGW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_QueryServiceConfigW, (ndr_push_flags_fn_t)ndr_push_svcctl_QueryServiceConfigW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfigW, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_QUERYSERVICELOCKSTATUSW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_QueryServiceLockStatusW, (ndr_push_flags_fn_t)ndr_push_svcctl_QueryServiceLockStatusW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceLockStatusW, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_STARTSERVICEW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_StartServiceW, (ndr_push_flags_fn_t)ndr_push_svcctl_StartServiceW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_StartServiceW, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_GETSERVICEDISPLAYNAMEW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_GetServiceDisplayNameW, (ndr_push_flags_fn_t)ndr_push_svcctl_GetServiceDisplayNameW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_GetServiceDisplayNameW, &r);
/* Return variables */
*display_name = *r.out.display_name;
- *display_name_length = *r.out.display_name_length;
+ if ( display_name_length ) {
+ *display_name_length = *r.out.display_name_length;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_GETSERVICEKEYNAMEW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_GetServiceKeyNameW, (ndr_push_flags_fn_t)ndr_push_svcctl_GetServiceKeyNameW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_GetServiceKeyNameW, &r);
/* Return variables */
*key_name = *r.out.key_name;
- *display_name_length = *r.out.display_name_length;
+ if ( display_name_length ) {
+ *display_name_length = *r.out.display_name_length;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_SCSETSERVICEBITSA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_SCSetServiceBitsA, (ndr_push_flags_fn_t)ndr_push_svcctl_SCSetServiceBitsA);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_SCSetServiceBitsA, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_CHANGESERVICECONFIGA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_ChangeServiceConfigA, (ndr_push_flags_fn_t)ndr_push_svcctl_ChangeServiceConfigA);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfigA, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_CREATESERVICEA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_CreateServiceA, (ndr_push_flags_fn_t)ndr_push_svcctl_CreateServiceA);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_CreateServiceA, &r);
}
/* Return variables */
- *TagId = *r.out.TagId;
+ if ( TagId ) {
+ *TagId = *r.out.TagId;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_ENUMDEPENDENTSERVICESA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_EnumDependentServicesA, (ndr_push_flags_fn_t)ndr_push_svcctl_EnumDependentServicesA);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_EnumDependentServicesA, &r);
}
/* Return variables */
- *status = *r.out.status;
+ if ( status ) {
+ *status = *r.out.status;
+ }
*bytes_needed = *r.out.bytes_needed;
*services_returned = *r.out.services_returned;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_ENUMSERVICESSTATUSA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_EnumServicesStatusA, (ndr_push_flags_fn_t)ndr_push_svcctl_EnumServicesStatusA);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_EnumServicesStatusA, &r);
*service = *r.out.service;
*bytes_needed = *r.out.bytes_needed;
*services_returned = *r.out.services_returned;
- *resume_handle = *r.out.resume_handle;
+ if ( resume_handle ) {
+ *resume_handle = *r.out.resume_handle;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_OPENSCMANAGERA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_OpenSCManagerA, (ndr_push_flags_fn_t)ndr_push_svcctl_OpenSCManagerA);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_OpenSCManagerA, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_OPENSERVICEA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_OpenServiceA, (ndr_push_flags_fn_t)ndr_push_svcctl_OpenServiceA);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_OpenServiceA, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_QUERYSERVICECONFIGA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_QueryServiceConfigA, (ndr_push_flags_fn_t)ndr_push_svcctl_QueryServiceConfigA);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfigA, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_QUERYSERVICELOCKSTATUSA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_QueryServiceLockStatusA, (ndr_push_flags_fn_t)ndr_push_svcctl_QueryServiceLockStatusA);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceLockStatusA, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_STARTSERVICEA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_StartServiceA, (ndr_push_flags_fn_t)ndr_push_svcctl_StartServiceA);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_StartServiceA, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_GETSERVICEDISPLAYNAMEA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_GetServiceDisplayNameA, (ndr_push_flags_fn_t)ndr_push_svcctl_GetServiceDisplayNameA);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_GetServiceDisplayNameA, &r);
/* Return variables */
*display_name = *r.out.display_name;
- *display_name_length = *r.out.display_name_length;
+ if ( display_name_length ) {
+ *display_name_length = *r.out.display_name_length;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_GETSERVICEKEYNAMEA, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_GetServiceKeyNameA, (ndr_push_flags_fn_t)ndr_push_svcctl_GetServiceKeyNameA);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_GetServiceKeyNameA, &r);
/* Return variables */
*key_name = *r.out.key_name;
- *display_name_length = *r.out.display_name_length;
+ if ( display_name_length ) {
+ *display_name_length = *r.out.display_name_length;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_GETCURRENTGROUPESTATEW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_GetCurrentGroupeStateW, (ndr_push_flags_fn_t)ndr_push_svcctl_GetCurrentGroupeStateW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_GetCurrentGroupeStateW, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_ENUMSERVICEGROUPW, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_EnumServiceGroupW, (ndr_push_flags_fn_t)ndr_push_svcctl_EnumServiceGroupW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_EnumServiceGroupW, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_CHANGESERVICECONFIG2A, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_ChangeServiceConfig2A, (ndr_push_flags_fn_t)ndr_push_svcctl_ChangeServiceConfig2A);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfig2A, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_CHANGESERVICECONFIG2W, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_ChangeServiceConfig2W, (ndr_push_flags_fn_t)ndr_push_svcctl_ChangeServiceConfig2W);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_ChangeServiceConfig2W, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_QUERYSERVICECONFIG2A, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_QueryServiceConfig2A, (ndr_push_flags_fn_t)ndr_push_svcctl_QueryServiceConfig2A);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfig2A, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_QUERYSERVICECONFIG2W, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_QueryServiceConfig2W, (ndr_push_flags_fn_t)ndr_push_svcctl_QueryServiceConfig2W);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceConfig2W, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_QUERYSERVICESTATUSEX, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_QueryServiceStatusEx, (ndr_push_flags_fn_t)ndr_push_svcctl_QueryServiceStatusEx);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_QueryServiceStatusEx, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_ENUMSERVICESSTATUSEXA, &r, (ndr_pull_flags_fn_t)ndr_pull_EnumServicesStatusExA, (ndr_push_flags_fn_t)ndr_push_EnumServicesStatusExA);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(EnumServicesStatusExA, &r);
*services = *r.out.services;
*bytes_needed = *r.out.bytes_needed;
*service_returned = *r.out.service_returned;
- *resume_handle = *r.out.resume_handle;
+ if ( resume_handle ) {
+ *resume_handle = *r.out.resume_handle;
+ }
*group_name = *r.out.group_name;
/* Return result */
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_ENUMSERVICESSTATUSEXW, &r, (ndr_pull_flags_fn_t)ndr_pull_EnumServicesStatusExW, (ndr_push_flags_fn_t)ndr_push_EnumServicesStatusExW);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(EnumServicesStatusExW, &r);
*services = *r.out.services;
*bytes_needed = *r.out.bytes_needed;
*service_returned = *r.out.service_returned;
- *resume_handle = *r.out.resume_handle;
+ if ( resume_handle ) {
+ *resume_handle = *r.out.resume_handle;
+ }
*group_name = *r.out.group_name;
/* Return result */
status = cli_do_rpc_ndr(cli, mem_ctx, PI_SVCCTL, DCERPC_SVCCTL_SCSENDTSMESSAGE, &r, (ndr_pull_flags_fn_t)ndr_pull_svcctl_SCSendTSMessage, (ndr_push_flags_fn_t)ndr_push_svcctl_SCSendTSMessage);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(svcctl_SCSendTSMessage, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_UNIXINFO, DCERPC_UNIXINFO_SIDTOUID, &r, (ndr_pull_flags_fn_t)ndr_pull_unixinfo_SidToUid, (ndr_push_flags_fn_t)ndr_push_unixinfo_SidToUid);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(unixinfo_SidToUid, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_UNIXINFO, DCERPC_UNIXINFO_UIDTOSID, &r, (ndr_pull_flags_fn_t)ndr_pull_unixinfo_UidToSid, (ndr_push_flags_fn_t)ndr_push_unixinfo_UidToSid);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(unixinfo_UidToSid, &r);
}
/* Return variables */
- *sid = *r.out.sid;
+ if ( sid ) {
+ *sid = *r.out.sid;
+ }
/* Return result */
return r.out.result;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_UNIXINFO, DCERPC_UNIXINFO_SIDTOGID, &r, (ndr_pull_flags_fn_t)ndr_pull_unixinfo_SidToGid, (ndr_push_flags_fn_t)ndr_push_unixinfo_SidToGid);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(unixinfo_SidToGid, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_UNIXINFO, DCERPC_UNIXINFO_GIDTOSID, &r, (ndr_pull_flags_fn_t)ndr_pull_unixinfo_GidToSid, (ndr_push_flags_fn_t)ndr_push_unixinfo_GidToSid);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(unixinfo_GidToSid, &r);
}
/* Return variables */
- *sid = *r.out.sid;
+ if ( sid ) {
+ *sid = *r.out.sid;
+ }
/* Return result */
return r.out.result;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_UNIXINFO, DCERPC_UNIXINFO_GETPWUID, &r, (ndr_pull_flags_fn_t)ndr_pull_unixinfo_GetPWUid, (ndr_push_flags_fn_t)ndr_push_unixinfo_GetPWUid);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(unixinfo_GetPWUid, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_OPENHKCR, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_OpenHKCR, (ndr_push_flags_fn_t)ndr_push_winreg_OpenHKCR);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_OpenHKCR, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_OPENHKCU, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_OpenHKCU, (ndr_push_flags_fn_t)ndr_push_winreg_OpenHKCU);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_OpenHKCU, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_OPENHKLM, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_OpenHKLM, (ndr_push_flags_fn_t)ndr_push_winreg_OpenHKLM);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_OpenHKLM, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_OPENHKPD, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_OpenHKPD, (ndr_push_flags_fn_t)ndr_push_winreg_OpenHKPD);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_OpenHKPD, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_OPENHKU, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_OpenHKU, (ndr_push_flags_fn_t)ndr_push_winreg_OpenHKU);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_OpenHKU, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_CLOSEKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_CloseKey, (ndr_push_flags_fn_t)ndr_push_winreg_CloseKey);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_CloseKey, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_CREATEKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_CreateKey, (ndr_push_flags_fn_t)ndr_push_winreg_CreateKey);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_CreateKey, &r);
/* Return variables */
*new_handle = *r.out.new_handle;
- *action_taken = *r.out.action_taken;
+ if ( action_taken ) {
+ *action_taken = *r.out.action_taken;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_DELETEKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_DeleteKey, (ndr_push_flags_fn_t)ndr_push_winreg_DeleteKey);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_DeleteKey, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_DELETEVALUE, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_DeleteValue, (ndr_push_flags_fn_t)ndr_push_winreg_DeleteValue);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_DeleteValue, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_ENUMKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_EnumKey, (ndr_push_flags_fn_t)ndr_push_winreg_EnumKey);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_EnumKey, &r);
/* Return variables */
*name = *r.out.name;
- *keyclass = *r.out.keyclass;
- *last_changed_time = *r.out.last_changed_time;
+ if ( keyclass ) {
+ *keyclass = *r.out.keyclass;
+ }
+ if ( last_changed_time ) {
+ *last_changed_time = *r.out.last_changed_time;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_ENUMVALUE, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_EnumValue, (ndr_push_flags_fn_t)ndr_push_winreg_EnumValue);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_EnumValue, &r);
/* Return variables */
*name = *r.out.name;
- *type = *r.out.type;
- *data = *r.out.data;
- *data_size = *r.out.data_size;
- *value_length = *r.out.value_length;
+ if ( type ) {
+ *type = *r.out.type;
+ }
+ if ( data ) {
+ *data = *r.out.data;
+ }
+ if ( data_size ) {
+ *data_size = *r.out.data_size;
+ }
+ if ( value_length ) {
+ *value_length = *r.out.value_length;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_FLUSHKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_FlushKey, (ndr_push_flags_fn_t)ndr_push_winreg_FlushKey);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_FlushKey, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_GETKEYSECURITY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_GetKeySecurity, (ndr_push_flags_fn_t)ndr_push_winreg_GetKeySecurity);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_GetKeySecurity, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_LOADKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_LoadKey, (ndr_push_flags_fn_t)ndr_push_winreg_LoadKey);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_LoadKey, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_NOTIFYCHANGEKEYVALUE, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_NotifyChangeKeyValue, (ndr_push_flags_fn_t)ndr_push_winreg_NotifyChangeKeyValue);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_NotifyChangeKeyValue, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_OPENKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_OpenKey, (ndr_push_flags_fn_t)ndr_push_winreg_OpenKey);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_OpenKey, &r);
return werror_to_ntstatus(r.out.result);
}
-NTSTATUS rpccli_winreg_QueryInfoKey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, struct winreg_String *classname, uint32_t *num_subkeys, uint32_t *max_subkeylen, uint32_t *max_subkeysize, uint32_t *num_values, uint32_t *max_valnamelen, uint32_t *max_valbufsize, uint32_t *secdescsize, NTTIME *last_changed_time)
+NTSTATUS rpccli_winreg_QueryInfoKey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, struct winreg_String *classname, uint32_t *num_subkeys, uint32_t *max_subkeylen, uint32_t *max_classlen, uint32_t *num_values, uint32_t *max_valnamelen, uint32_t *max_valbufsize, uint32_t *secdescsize, NTTIME *last_changed_time)
{
struct winreg_QueryInfoKey r;
NTSTATUS status;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_QUERYINFOKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_QueryInfoKey, (ndr_push_flags_fn_t)ndr_push_winreg_QueryInfoKey);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_QueryInfoKey, &r);
*classname = *r.out.classname;
*num_subkeys = *r.out.num_subkeys;
*max_subkeylen = *r.out.max_subkeylen;
- *max_subkeysize = *r.out.max_subkeysize;
+ *max_classlen = *r.out.max_classlen;
*num_values = *r.out.num_values;
*max_valnamelen = *r.out.max_valnamelen;
*max_valbufsize = *r.out.max_valbufsize;
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_QUERYVALUE, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_QueryValue, (ndr_push_flags_fn_t)ndr_push_winreg_QueryValue);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_QueryValue, &r);
}
/* Return variables */
- *type = *r.out.type;
- *data = *r.out.data;
- *data_size = *r.out.data_size;
- *value_length = *r.out.value_length;
+ if ( type ) {
+ *type = *r.out.type;
+ }
+ if ( data ) {
+ *data = *r.out.data;
+ }
+ if ( data_size ) {
+ *data_size = *r.out.data_size;
+ }
+ if ( value_length ) {
+ *value_length = *r.out.value_length;
+ }
/* Return result */
return werror_to_ntstatus(r.out.result);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_REPLACEKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_ReplaceKey, (ndr_push_flags_fn_t)ndr_push_winreg_ReplaceKey);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_ReplaceKey, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_RESTOREKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_RestoreKey, (ndr_push_flags_fn_t)ndr_push_winreg_RestoreKey);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_RestoreKey, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_SAVEKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_SaveKey, (ndr_push_flags_fn_t)ndr_push_winreg_SaveKey);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_SaveKey, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_SETKEYSECURITY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_SetKeySecurity, (ndr_push_flags_fn_t)ndr_push_winreg_SetKeySecurity);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_SetKeySecurity, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_SETVALUE, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_SetValue, (ndr_push_flags_fn_t)ndr_push_winreg_SetValue);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_SetValue, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_UNLOADKEY, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_UnLoadKey, (ndr_push_flags_fn_t)ndr_push_winreg_UnLoadKey);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_UnLoadKey, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_INITIATESYSTEMSHUTDOWN, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_InitiateSystemShutdown, (ndr_push_flags_fn_t)ndr_push_winreg_InitiateSystemShutdown);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_InitiateSystemShutdown, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_ABORTSYSTEMSHUTDOWN, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_AbortSystemShutdown, (ndr_push_flags_fn_t)ndr_push_winreg_AbortSystemShutdown);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_AbortSystemShutdown, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_GETVERSION, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_GetVersion, (ndr_push_flags_fn_t)ndr_push_winreg_GetVersion);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_GetVersion, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_OPENHKCC, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_OpenHKCC, (ndr_push_flags_fn_t)ndr_push_winreg_OpenHKCC);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_OpenHKCC, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_OPENHKDD, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_OpenHKDD, (ndr_push_flags_fn_t)ndr_push_winreg_OpenHKDD);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_OpenHKDD, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_QUERYMULTIPLEVALUES, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_QueryMultipleValues, (ndr_push_flags_fn_t)ndr_push_winreg_QueryMultipleValues);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_QueryMultipleValues, &r);
/* Return variables */
*values = *r.out.values;
- *buffer = *r.out.buffer;
+ if ( buffer ) {
+ *buffer = *r.out.buffer;
+ }
*buffer_size = *r.out.buffer_size;
/* Return result */
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_INITIATESYSTEMSHUTDOWNEX, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_InitiateSystemShutdownEx, (ndr_push_flags_fn_t)ndr_push_winreg_InitiateSystemShutdownEx);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_InitiateSystemShutdownEx, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_SAVEKEYEX, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_SaveKeyEx, (ndr_push_flags_fn_t)ndr_push_winreg_SaveKeyEx);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_SaveKeyEx, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_OPENHKPT, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_OpenHKPT, (ndr_push_flags_fn_t)ndr_push_winreg_OpenHKPT);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_OpenHKPT, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_OPENHKPN, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_OpenHKPN, (ndr_push_flags_fn_t)ndr_push_winreg_OpenHKPN);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_OpenHKPN, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WINREG, DCERPC_WINREG_QUERYMULTIPLEVALUES2, &r, (ndr_pull_flags_fn_t)ndr_pull_winreg_QueryMultipleValues2, (ndr_push_flags_fn_t)ndr_push_winreg_QueryMultipleValues2);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_QueryMultipleValues2, &r);
NTSTATUS rpccli_winreg_LoadKey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, struct winreg_String *keyname, struct winreg_String *filename);
NTSTATUS rpccli_winreg_NotifyChangeKeyValue(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, uint8_t watch_subtree, uint32_t notify_filter, uint32_t unknown, struct winreg_String string1, struct winreg_String string2, uint32_t unknown2);
NTSTATUS rpccli_winreg_OpenKey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *parent_handle, struct winreg_String keyname, uint32_t unknown, uint32_t access_mask, struct policy_handle *handle);
-NTSTATUS rpccli_winreg_QueryInfoKey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, struct winreg_String *classname, uint32_t *num_subkeys, uint32_t *max_subkeylen, uint32_t *max_subkeysize, uint32_t *num_values, uint32_t *max_valnamelen, uint32_t *max_valbufsize, uint32_t *secdescsize, NTTIME *last_changed_time);
+NTSTATUS rpccli_winreg_QueryInfoKey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, struct winreg_String *classname, uint32_t *num_subkeys, uint32_t *max_subkeylen, uint32_t *max_classlen, uint32_t *num_values, uint32_t *max_valnamelen, uint32_t *max_valbufsize, uint32_t *secdescsize, NTTIME *last_changed_time);
NTSTATUS rpccli_winreg_QueryValue(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, struct winreg_String value_name, enum winreg_Type *type, uint8_t *data, uint32_t *data_size, uint32_t *value_length);
NTSTATUS rpccli_winreg_ReplaceKey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx);
NTSTATUS rpccli_winreg_RestoreKey(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle, struct winreg_String *filename, uint32_t flags);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETWKSTAGETINFO, &r, (ndr_pull_flags_fn_t)ndr_pull_wkssvc_NetWkstaGetInfo, (ndr_push_flags_fn_t)ndr_push_wkssvc_NetWkstaGetInfo);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaGetInfo, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETWKSTASETINFO, &r, (ndr_pull_flags_fn_t)ndr_pull_wkssvc_NetWkstaSetInfo, (ndr_push_flags_fn_t)ndr_push_wkssvc_NetWkstaSetInfo);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaSetInfo, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETWKSTAENUMUSERS, &r, (ndr_pull_flags_fn_t)ndr_pull_wkssvc_NetWkstaEnumUsers, (ndr_push_flags_fn_t)ndr_push_wkssvc_NetWkstaEnumUsers);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaEnumUsers, &r);
/* Return variables */
*users = *r.out.users;
- *entriesread = *r.out.entriesread;
- *totalentries = *r.out.totalentries;
+ if ( entriesread ) {
+ *entriesread = *r.out.entriesread;
+ }
+ if ( totalentries ) {
+ *totalentries = *r.out.totalentries;
+ }
*resumehandle = *r.out.resumehandle;
/* Return result */
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRWKSTAUSERGETINFO, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRWKSTAUSERGETINFO, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRWKSTAUSERGETINFO);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWKSTAUSERGETINFO, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRWKSTAUSERSETINFO, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRWKSTAUSERSETINFO, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRWKSTAUSERSETINFO);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWKSTAUSERSETINFO, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETWKSTATRANSPORTENUM, &r, (ndr_pull_flags_fn_t)ndr_pull_wkssvc_NetWkstaTransportEnum, (ndr_push_flags_fn_t)ndr_push_wkssvc_NetWkstaTransportEnum);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaTransportEnum, &r);
/* Return variables */
*level = *r.out.level;
*ctr = *r.out.ctr;
- *totalentries = *r.out.totalentries;
+ if ( totalentries ) {
+ *totalentries = *r.out.totalentries;
+ }
*resume_handle = *r.out.resume_handle;
/* Return result */
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRWKSTATRANSPORTADD, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRWKSTATRANSPORTADD, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRWKSTATRANSPORTADD);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWKSTATRANSPORTADD, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRWKSTATRANSPORTDEL, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRWKSTATRANSPORTDEL, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRWKSTATRANSPORTDEL);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWKSTATRANSPORTDEL, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRUSEADD, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRUSEADD, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRUSEADD);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUSEADD, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRUSEGETINFO, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRUSEGETINFO, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRUSEGETINFO);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUSEGETINFO, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRUSEDEL, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRUSEDEL, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRUSEDEL);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUSEDEL, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRUSEENUM, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRUSEENUM, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRUSEENUM);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUSEENUM, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRMESSAGEBUFFERSEND, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRMESSAGEBUFFERSEND, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRMESSAGEBUFFERSEND);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRMESSAGEBUFFERSEND, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRWORKSTATIONSTATISTICSGET, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRWORKSTATIONSTATISTICSGET, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRWORKSTATIONSTATISTICSGET);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWORKSTATIONSTATISTICSGET, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRLOGONDOMAINNAMEADD, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRLOGONDOMAINNAMEADD, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRLOGONDOMAINNAMEADD);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRLOGONDOMAINNAMEADD, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRLOGONDOMAINNAMEDEL, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRLOGONDOMAINNAMEDEL, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRLOGONDOMAINNAMEDEL);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRLOGONDOMAINNAMEDEL, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRJOINDOMAIN, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRJOINDOMAIN, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRJOINDOMAIN);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRJOINDOMAIN, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRUNJOINDOMAIN, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRUNJOINDOMAIN, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRUNJOINDOMAIN);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUNJOINDOMAIN, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRRENAMEMACHINEINDOMAIN, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRRENAMEMACHINEINDOMAIN, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRRENAMEMACHINEINDOMAIN);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRRENAMEMACHINEINDOMAIN, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRVALIDATENAME, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRVALIDATENAME, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRVALIDATENAME);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRVALIDATENAME, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRGETJOININFORMATION, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRGETJOININFORMATION, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRGETJOININFORMATION);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRGETJOININFORMATION, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRGETJOINABLEOUS, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRGETJOINABLEOUS, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRGETJOINABLEOUS);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRGETJOINABLEOUS, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRJOINDOMAIN2, &r, (ndr_pull_flags_fn_t)ndr_pull_wkssvc_NetrJoinDomain2, (ndr_push_flags_fn_t)ndr_push_wkssvc_NetrJoinDomain2);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(wkssvc_NetrJoinDomain2, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRUNJOINDOMAIN2, &r, (ndr_pull_flags_fn_t)ndr_pull_wkssvc_NetrUnjoinDomain2, (ndr_push_flags_fn_t)ndr_push_wkssvc_NetrUnjoinDomain2);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(wkssvc_NetrUnjoinDomain2, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRRENAMEMACHINEINDOMAIN2, &r, (ndr_pull_flags_fn_t)ndr_pull_wkssvc_NetrRenameMachineInDomain2, (ndr_push_flags_fn_t)ndr_push_wkssvc_NetrRenameMachineInDomain2);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(wkssvc_NetrRenameMachineInDomain2, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRVALIDATENAME2, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRVALIDATENAME2, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRVALIDATENAME2);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRVALIDATENAME2, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRGETJOINABLEOUS2, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRGETJOINABLEOUS2, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRGETJOINABLEOUS2);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRGETJOINABLEOUS2, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRADDALTERNATECOMPUTERNAME, &r, (ndr_pull_flags_fn_t)ndr_pull_wkssvc_NetrAddAlternateComputerName, (ndr_push_flags_fn_t)ndr_push_wkssvc_NetrAddAlternateComputerName);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(wkssvc_NetrAddAlternateComputerName, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME, &r, (ndr_pull_flags_fn_t)ndr_pull_wkssvc_NetrRemoveAlternateComputerName, (ndr_push_flags_fn_t)ndr_push_wkssvc_NetrRemoveAlternateComputerName);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(wkssvc_NetrRemoveAlternateComputerName, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRSETPRIMARYCOMPUTERNAME, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRSETPRIMARYCOMPUTERNAME, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRSETPRIMARYCOMPUTERNAME);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRSETPRIMARYCOMPUTERNAME, &r);
status = cli_do_rpc_ndr(cli, mem_ctx, PI_WKSSVC, DCERPC_WKSSVC_NETRENUMERATECOMPUTERNAMES, &r, (ndr_pull_flags_fn_t)ndr_pull_WKSSVC_NETRENUMERATECOMPUTERNAMES, (ndr_push_flags_fn_t)ndr_push_WKSSVC_NETRENUMERATECOMPUTERNAMES);
+ if ( !NT_STATUS_IS_OK(status) ) {
+ return status;
+ }
+
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRENUMERATECOMPUTERNAMES, &r);
{
if (ndr_flags & NDR_SCALARS) {
NDR_CHECK(ndr_push_align(ndr, 4));
- NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m_term(r->name)*2));
+ NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, strlen_m(r->name)*2));
NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
}
if (r->name) {
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size/2));
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
- NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m_term(r->name)*2/2));
- NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, strlen_m_term(r->name)*2/2, sizeof(uint16_t), CH_UTF16));
+ NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, strlen_m(r->name)*2/2));
+ NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, strlen_m(r->name)*2/2, sizeof(uint16_t), CH_UTF16));
}
}
return NT_STATUS_OK;
{
ndr_print_struct(ndr, name, "winreg_StringBuf");
ndr->depth++;
- ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m_term(r->name)*2:r->length);
+ ndr_print_uint16(ndr, "length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?strlen_m(r->name)*2:r->length);
ndr_print_uint16(ndr, "size", r->size);
ndr_print_ptr(ndr, "name", r->name);
ndr->depth++;
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_subkeys));
if (r->out.max_subkeylen == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_subkeylen));
- if (r->out.max_subkeysize == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
- NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_subkeysize));
+ if (r->out.max_classlen == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
+ NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.max_classlen));
if (r->out.num_values == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_values));
if (r->out.max_valnamelen == NULL) return NT_STATUS_INVALID_PARAMETER_MIX;
TALLOC_CTX *_mem_save_classname_0;
TALLOC_CTX *_mem_save_num_subkeys_0;
TALLOC_CTX *_mem_save_max_subkeylen_0;
- TALLOC_CTX *_mem_save_max_subkeysize_0;
+ TALLOC_CTX *_mem_save_max_classlen_0;
TALLOC_CTX *_mem_save_num_values_0;
TALLOC_CTX *_mem_save_max_valnamelen_0;
TALLOC_CTX *_mem_save_max_valbufsize_0;
ZERO_STRUCTP(r->out.num_subkeys);
NDR_PULL_ALLOC(ndr, r->out.max_subkeylen);
ZERO_STRUCTP(r->out.max_subkeylen);
- NDR_PULL_ALLOC(ndr, r->out.max_subkeysize);
- ZERO_STRUCTP(r->out.max_subkeysize);
+ NDR_PULL_ALLOC(ndr, r->out.max_classlen);
+ ZERO_STRUCTP(r->out.max_classlen);
NDR_PULL_ALLOC(ndr, r->out.num_values);
ZERO_STRUCTP(r->out.num_values);
NDR_PULL_ALLOC(ndr, r->out.max_valnamelen);
NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_subkeylen));
NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_subkeylen_0, LIBNDR_FLAG_REF_ALLOC);
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
- NDR_PULL_ALLOC(ndr, r->out.max_subkeysize);
+ NDR_PULL_ALLOC(ndr, r->out.max_classlen);
}
- _mem_save_max_subkeysize_0 = NDR_PULL_GET_MEM_CTX(ndr);
- NDR_PULL_SET_MEM_CTX(ndr, r->out.max_subkeysize, LIBNDR_FLAG_REF_ALLOC);
- NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_subkeysize));
- NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_subkeysize_0, LIBNDR_FLAG_REF_ALLOC);
+ _mem_save_max_classlen_0 = NDR_PULL_GET_MEM_CTX(ndr);
+ NDR_PULL_SET_MEM_CTX(ndr, r->out.max_classlen, LIBNDR_FLAG_REF_ALLOC);
+ NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.max_classlen));
+ NDR_PULL_SET_MEM_CTX(ndr, _mem_save_max_classlen_0, LIBNDR_FLAG_REF_ALLOC);
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
NDR_PULL_ALLOC(ndr, r->out.num_values);
}
ndr->depth++;
ndr_print_uint32(ndr, "max_subkeylen", *r->out.max_subkeylen);
ndr->depth--;
- ndr_print_ptr(ndr, "max_subkeysize", r->out.max_subkeysize);
+ ndr_print_ptr(ndr, "max_classlen", r->out.max_classlen);
ndr->depth++;
- ndr_print_uint32(ndr, "max_subkeysize", *r->out.max_subkeysize);
+ ndr_print_uint32(ndr, "max_classlen", *r->out.max_classlen);
ndr->depth--;
ndr_print_ptr(ndr, "num_values", r->out.num_values);
ndr->depth++;
return False;
}
- r.out.max_subkeysize = talloc_zero_size(mem_ctx, sizeof(*r.out.max_subkeysize));
- if (r.out.max_subkeysize == NULL) {
+ r.out.max_classlen = talloc_zero_size(mem_ctx, sizeof(*r.out.max_classlen));
+ if (r.out.max_classlen == NULL) {
talloc_free(mem_ctx);
return False;
}
return False;
}
- r.out.result = _winreg_QueryInfoKey(p, r.in.handle, r.in.classname, r.out.num_subkeys, r.out.max_subkeylen, r.out.max_subkeysize, r.out.num_values, r.out.max_valnamelen, r.out.max_valbufsize, r.out.secdescsize, r.out.last_changed_time);
+ r.out.result = _winreg_QueryInfoKey(p, r.in.handle, r.in.classname, r.out.num_subkeys, r.out.max_subkeylen, r.out.max_classlen, r.out.num_values, r.out.max_valnamelen, r.out.max_valbufsize, r.out.secdescsize, r.out.last_changed_time);
if (DEBUGLEVEL >= 10)
NDR_PRINT_OUT_DEBUG(winreg_QueryInfoKey, &r);
WERROR _winreg_LoadKey(pipes_struct *p, struct policy_handle *handle, struct winreg_String *keyname, struct winreg_String *filename);
WERROR _winreg_NotifyChangeKeyValue(pipes_struct *p, struct policy_handle *handle, uint8_t watch_subtree, uint32_t notify_filter, uint32_t unknown, struct winreg_String string1, struct winreg_String string2, uint32_t unknown2);
WERROR _winreg_OpenKey(pipes_struct *p, struct policy_handle *parent_handle, struct winreg_String keyname, uint32_t unknown, uint32_t access_mask, struct policy_handle *handle);
-WERROR _winreg_QueryInfoKey(pipes_struct *p, struct policy_handle *handle, struct winreg_String *classname, uint32_t *num_subkeys, uint32_t *max_subkeylen, uint32_t *max_subkeysize, uint32_t *num_values, uint32_t *max_valnamelen, uint32_t *max_valbufsize, uint32_t *secdescsize, NTTIME *last_changed_time);
+WERROR _winreg_QueryInfoKey(pipes_struct *p, struct policy_handle *handle, struct winreg_String *classname, uint32_t *num_subkeys, uint32_t *max_subkeylen, uint32_t *max_classlen, uint32_t *num_values, uint32_t *max_valnamelen, uint32_t *max_valbufsize, uint32_t *secdescsize, NTTIME *last_changed_time);
WERROR _winreg_QueryValue(pipes_struct *p, struct policy_handle *handle, struct winreg_String value_name, enum winreg_Type *type, uint8_t *data, uint32_t *data_size, uint32_t *value_length);
WERROR _winreg_ReplaceKey(pipes_struct *p);
WERROR _winreg_RestoreKey(pipes_struct *p, struct policy_handle *handle, struct winreg_String *filename, uint32_t flags);
};
struct winreg_StringBuf {
- uint16_t length;/* [value(strlen_m_term(name)*2)] */
+ uint16_t length;/* [value(strlen_m(name)*2)] */
uint16_t size;
const char *name;/* [unique,length_is(length/2),charset(UTF16),size_is(size/2)] */
};
struct winreg_String *classname;/* [ref] */
uint32_t *num_subkeys;/* [ref] */
uint32_t *max_subkeylen;/* [ref] */
- uint32_t *max_subkeysize;/* [ref] */
+ uint32_t *max_classlen;/* [ref] */
uint32_t *num_values;/* [ref] */
uint32_t *max_valnamelen;/* [ref] */
uint32_t *max_valbufsize;/* [ref] */
);
typedef struct {
- [value(strlen_m_term(name)*2)] uint16 length;
+ [value(strlen_m(name)*2)] uint16 length;
/* size cannot be auto-set by value() as it is the
amount of space the server is allowed to use for this
string in the reply, not its current size */
[size_is(size/2),length_is(length/2),charset(UTF16)] uint16 *name;
} winreg_StringBuf;
+
+ /******************/
+ /* Function: 0x09 */
WERROR winreg_EnumKey(
[in,ref] policy_handle *handle,
[in] uint32 enum_index,
[in,out,ref] winreg_String *classname,
[out,ref] uint32 *num_subkeys,
[out,ref] uint32 *max_subkeylen,
- [out,ref] uint32 *max_subkeysize,
+ [out,ref] uint32 *max_classlen,
[out,ref] uint32 *num_values,
[out,ref] uint32 *max_valnamelen,
[out,ref] uint32 *max_valbufsize,
connect to a registry hive root (open a registry policy)
*******************************************************************/
-NTSTATUS rpccli_winreg_connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
+NTSTATUS rpccli_winreg_Connect(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
uint32 reg_type, uint32 access_mask,
POLICY_HND *reg_hnd)
{
return NT_STATUS_INVALID_PARAMETER;
}
-/****************************************************************************
-****************************************************************************/
-
-NTSTATUS rpccli_winreg_query_key(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
- POLICY_HND *hnd,
- char *key_class, uint32 *class_len,
- uint32 *num_subkeys, uint32 *max_subkeylen,
- uint32 *max_subkeysize, uint32 *num_values,
- uint32 *max_valnamelen, uint32 *max_valbufsize,
- uint32 *secdescsize, NTTIME *mod_time)
-{
- NTSTATUS status;
- struct winreg_String classname;
-
- classname.name = key_class;
- status = rpccli_winreg_QueryInfoKey( cli, mem_ctx, hnd,
- &classname, num_subkeys,
- max_subkeylen, max_subkeysize, num_values,
- max_valnamelen, max_valbufsize, secdescsize,
- mod_time );
-
- /* The old code would check for INSUFFICIENT_BUFFER.
- Will have to work this out. */
-
- return status;
-}
-
-
-/****************************************************************************
-****************************************************************************/
-
-NTSTATUS rpccli_winreg_enum_val(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
- POLICY_HND *hnd, int idx,
- fstring val_name, uint32 *type, REGVAL_BUFFER *value)
-{
- NTSTATUS status = NT_STATUS_INVALID_PARAMETER;
-
- /* do rpc */
-
-
- return status;
-}
-
-/****************************************************************************
-****************************************************************************/
-
-NTSTATUS rpccli_winreg_enum_key(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx,
- POLICY_HND *hnd, int key_index, fstring key_name,
- fstring class_name, time_t *mod_time)
-{
- NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
-
- return status;
-}
-
/*
*
* Utility functions
/* INCLUDE FILES */
#include "utils/net_proto.h"
+#include "libmsrpc.h"
+
/* MACROS & DEFINES */
uint32 idx;
NTSTATUS status;
struct winreg_String subkeyname;
+ struct winreg_String classname;
+ uint32 num_subkeys, max_subkeylen, max_classlen;
+ uint32 num_values, max_valnamelen, max_valbufsize;
+ uint32 secdescsize;
+ NTTIME last_changed_time;
+ struct winreg_StringBuf subkey_namebuf;
+ char *name_buffer;
+ uint8 *value_buffer;
if (argc != 1 ) {
d_printf("Usage: net rpc enumerate <path> [recurse]\n");
/* open the top level hive and then the registry key */
- status = rpccli_winreg_connect(pipe_hnd, mem_ctx, hive, MAXIMUM_ALLOWED_ACCESS, &pol_hive );
+ status = rpccli_winreg_Connect(pipe_hnd, mem_ctx, hive, MAXIMUM_ALLOWED_ACCESS, &pol_hive );
if ( !NT_STATUS_IS_OK(status) ) {
d_fprintf(stderr, "Unable to connect to remote registry: "
- "%s\n", dos_errstr(result));
+ "%s\n", nt_errstr(status));
return status;
}
0, MAXIMUM_ALLOWED_ACCESS, &pol_key );
if ( !NT_STATUS_IS_OK(status) ) {
d_fprintf(stderr, "Unable to open [%s]: %s\n", argv[0],
- dos_errstr(result));
+ nt_errstr(status));
return werror_to_ntstatus(result);
}
-
+
+ classname.name = NULL;
+ status = rpccli_winreg_QueryInfoKey( pipe_hnd, mem_ctx, &pol_key,
+ &classname, &num_subkeys, &max_subkeylen,
+ &max_classlen, &num_values, &max_valnamelen,
+ &max_valbufsize, &secdescsize, &last_changed_time );
+
+ if ( !NT_STATUS_IS_OK(status) ) {
+ d_fprintf(stderr, "Unable to determine subkeys (%s)\n",
+ nt_errstr(status));
+ return status;
+ }
+
+ /* values do not include the terminating NULL */
+
+ max_subkeylen += 2;
+ max_valnamelen += 2;
+
+ if ( (name_buffer = TALLOC_ARRAY( mem_ctx, char, max_subkeylen )) == NULL ) {
+ d_fprintf(stderr, "Memory allocation error.\n");
+ return NT_STATUS_NO_MEMORY;
+ }
+
/* get the subkeys */
status = NT_STATUS_OK;
idx = 0;
while ( NT_STATUS_IS_OK(status) ) {
- time_t modtime;
- fstring keyname, classname;
-
- status = rpccli_winreg_enum_key(pipe_hnd, mem_ctx, &pol_key, idx,
- keyname, classname, &modtime );
+ struct winreg_StringBuf class_namebuf;
+ fstring kname;
+ NTTIME modtime;
+
+ class_namebuf.name = NULL;
+ class_namebuf.size = 0;
+ class_namebuf.length = 0;
+
+ /* zero out each time */
+
+ subkey_namebuf.length = 0;
+ subkey_namebuf.size = max_subkeylen;
+ memset( name_buffer, 0x0, max_subkeylen );
+ subkey_namebuf.name = name_buffer;
+
+ status = rpccli_winreg_EnumKey(pipe_hnd, mem_ctx, &pol_key, idx,
+ &subkey_namebuf, &class_namebuf, &modtime);
if ( W_ERROR_EQUAL(ntstatus_to_werror(status), WERR_NO_MORE_ITEMS) ) {
status = NT_STATUS_OK;
break;
}
-
- d_printf("Keyname = %s\n", keyname );
- d_printf("Classname = %s\n", classname );
- d_printf("Modtime = %s\n", http_timestring(modtime) );
+
+ if ( !NT_STATUS_IS_OK(status) )
+ goto out;
+
+ StrnCpy( kname, subkey_namebuf.name, MIN(subkey_namebuf.length,sizeof(kname))-1 );
+ kname[MIN(subkey_namebuf.length,sizeof(kname))-1] = '\0';
+ d_printf("Keyname = %s\n", kname);
+ d_printf("Modtime = %s\n",
+ http_timestring(nt_time_to_unix(modtime)) );
d_printf("\n" );
idx++;
if ( !NT_STATUS_IS_OK(status) )
goto out;
-
+
+ /* TALLOC_FREE( name_buffer ); */
+
+ if ( (name_buffer = TALLOC_ARRAY( mem_ctx, char, max_valnamelen )) == NULL ) {
+ d_fprintf(stderr, "Memory allocation error.\n");
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ if ( (value_buffer = TALLOC_ARRAY( mem_ctx, uint8, max_valbufsize )) == NULL ) {
+ d_fprintf(stderr, "Memory allocation error.\n");
+ return NT_STATUS_NO_MEMORY;
+ }
+
/* get the values */
status = NT_STATUS_OK;
idx = 0;
while ( NT_STATUS_IS_OK(status) ) {
- uint32 type;
+ enum winreg_Type type;
fstring name;
+ uint8 *data;
+ uint32 data_size, value_length;
+ struct winreg_StringBuf value_namebuf;
REGVAL_BUFFER value;
fstrcpy( name, "" );
ZERO_STRUCT( value );
-
- status = rpccli_winreg_enum_val(pipe_hnd, mem_ctx, &pol_key, idx,
- name, &type, &value );
+
+ memset( name_buffer, 0x0, max_valnamelen );
+ value_namebuf.name = name_buffer;
+ value_namebuf.length = 0;
+ value_namebuf.size = max_valnamelen;
+
+ memset( value_buffer, 0x0, max_valbufsize );
+ data = value_buffer;
+ data_size = max_valbufsize;
+ value_length = 0;
+
+ status = rpccli_winreg_EnumValue(pipe_hnd, mem_ctx, &pol_key, idx,
+ &value_namebuf, &type, data, &data_size, &value_length );
if ( W_ERROR_EQUAL(ntstatus_to_werror(status), WERR_NO_MORE_ITEMS) ) {
status = NT_STATUS_OK;
break;
}
+
+ if ( !NT_STATUS_IS_OK(status) )
+ goto out;
+
+ init_regval_buffer( &value, data, value_length );
+ StrnCpy( name, value_namebuf.name, MIN(max_valnamelen, sizeof(name)-1) );
+ name[MIN(max_valnamelen, sizeof(name)-1)] = '\0';
+
d_printf("Valuename = %s\n", name );
d_printf("Type = %s\n", reg_type_lookup(type));
d_printf("Data = " );
idx++;
}
-
out:
/* cleanup */
/* open the top level hive and then the registry key */
- status = rpccli_winreg_connect(pipe_hnd, mem_ctx, hive, MAXIMUM_ALLOWED_ACCESS, &pol_hive );
+ status = rpccli_winreg_Connect(pipe_hnd, mem_ctx, hive, MAXIMUM_ALLOWED_ACCESS, &pol_hive );
if ( !NT_STATUS_IS_OK(status) ) {
d_fprintf(stderr, "Unable to connect to remote registry\n");
return status;
git.samba.org / samba.git / commitdiff