This makes it a bit more similar to the Samba4 code.
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
NDR_PULL_ALLOC_N(ndr, r->in.data, ndr_get_array_size(ndr, &r->in.data));
}
- memcpy(r->out.data,r->in.data,ndr_get_array_size(ndr, &r->in.data) * sizeof(*r->in.data));
+ memcpy(r->out.data, r->in.data, ndr_get_array_size(ndr, &r->in.data) * sizeof(*r->in.data));
_mem_save_data_1 = NDR_PULL_GET_MEM_CTX(ndr);
NDR_PULL_SET_MEM_CTX(ndr, r->in.data, 0);
for (cntr_data_1 = 0; cntr_data_1 < *r->in.value_length; cntr_data_1++) {
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
}
- memcpy(r->out.data,r->in.data,ndr_get_array_size(ndr, &r->out.data) * sizeof(*r->in.data));
+ memcpy(r->out.data, r->in.data, ndr_get_array_size(ndr, &r->out.data) * sizeof(*r->in.data));
_mem_save_data_1 = NDR_PULL_GET_MEM_CTX(ndr);
NDR_PULL_SET_MEM_CTX(ndr, r->out.data, 0);
for (cntr_data_1 = 0; cntr_data_1 < *r->out.value_length; cntr_data_1++) {
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
NDR_PULL_ALLOC_N(ndr, r->in.values, ndr_get_array_size(ndr, &r->in.values));
}
- memcpy(r->out.values,r->in.values,ndr_get_array_size(ndr, &r->in.values) * sizeof(*r->in.values));
+ memcpy(r->out.values, r->in.values, ndr_get_array_size(ndr, &r->in.values) * sizeof(*r->in.values));
_mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);
NDR_PULL_SET_MEM_CTX(ndr, r->in.values, 0);
for (cntr_values_1 = 0; cntr_values_1 < r->in.num_values; cntr_values_1++) {
if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
NDR_PULL_ALLOC_N(ndr, r->out.values, ndr_get_array_size(ndr, &r->out.values));
}
- memcpy(r->out.values,r->in.values,ndr_get_array_size(ndr, &r->out.values) * sizeof(*r->in.values));
+ memcpy(r->out.values, r->in.values, ndr_get_array_size(ndr, &r->out.values) * sizeof(*r->in.values));
_mem_save_values_1 = NDR_PULL_GET_MEM_CTX(ndr);
NDR_PULL_SET_MEM_CTX(ndr, r->out.values, 0);
for (cntr_values_1 = 0; cntr_values_1 < r->in.num_values; cntr_values_1++) {
return False;
}
- _dfs_GetManagerVersion(p, r.out.exist_flag);
+ _dfs_GetManagerVersion(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(dfs_Add, &r);
- r.out.result = _dfs_Add(p, r.in.path, r.in.server, r.in.share, r.in.comment, r.in.flags);
+ r.out.result = _dfs_Add(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(dfs_Remove, &r);
- r.out.result = _dfs_Remove(p, r.in.path, r.in.server, r.in.share);
+ r.out.result = _dfs_Remove(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(dfs_SetInfo, &r);
- r.out.result = _dfs_SetInfo(p);
+ r.out.result = _dfs_SetInfo(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _dfs_GetInfo(p, r.in.path, r.in.server, r.in.share, r.in.level, r.out.info);
+ r.out.result = _dfs_GetInfo(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
ZERO_STRUCT(r.out);
r.out.info = r.in.info;
r.out.total = r.in.total;
- r.out.result = _dfs_Enum(p, r.in.level, r.in.bufsize, r.in.info, r.in.unknown, r.in.total);
+ r.out.result = _dfs_Enum(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(dfs_Rename, &r);
- r.out.result = _dfs_Rename(p);
+ r.out.result = _dfs_Rename(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(dfs_Move, &r);
- r.out.result = _dfs_Move(p);
+ r.out.result = _dfs_Move(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(dfs_ManagerGetConfigInfo, &r);
- r.out.result = _dfs_ManagerGetConfigInfo(p);
+ r.out.result = _dfs_ManagerGetConfigInfo(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(dfs_ManagerSendSiteInfo, &r);
- r.out.result = _dfs_ManagerSendSiteInfo(p);
+ r.out.result = _dfs_ManagerSendSiteInfo(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(dfs_AddFtRoot, &r);
- r.out.result = _dfs_AddFtRoot(p);
+ r.out.result = _dfs_AddFtRoot(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(dfs_RemoveFtRoot, &r);
- r.out.result = _dfs_RemoveFtRoot(p);
+ r.out.result = _dfs_RemoveFtRoot(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(dfs_AddStdRoot, &r);
- r.out.result = _dfs_AddStdRoot(p);
+ r.out.result = _dfs_AddStdRoot(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(dfs_RemoveStdRoot, &r);
- r.out.result = _dfs_RemoveStdRoot(p);
+ r.out.result = _dfs_RemoveStdRoot(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(dfs_ManagerInitialize, &r);
- r.out.result = _dfs_ManagerInitialize(p);
+ r.out.result = _dfs_ManagerInitialize(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(dfs_AddStdRootForced, &r);
- r.out.result = _dfs_AddStdRootForced(p);
+ r.out.result = _dfs_AddStdRootForced(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(dfs_GetDcAddress, &r);
- r.out.result = _dfs_GetDcAddress(p);
+ r.out.result = _dfs_GetDcAddress(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(dfs_SetDcAddress, &r);
- r.out.result = _dfs_SetDcAddress(p);
+ r.out.result = _dfs_SetDcAddress(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(dfs_FlushFtTable, &r);
- r.out.result = _dfs_FlushFtTable(p);
+ r.out.result = _dfs_FlushFtTable(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(dfs_Add2, &r);
- r.out.result = _dfs_Add2(p);
+ r.out.result = _dfs_Add2(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(dfs_Remove2, &r);
- r.out.result = _dfs_Remove2(p);
+ r.out.result = _dfs_Remove2(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
ZERO_STRUCT(r.out);
r.out.info = r.in.info;
r.out.total = r.in.total;
- r.out.result = _dfs_EnumEx(p, r.in.name, r.in.level, r.in.bufsize, r.in.info, r.in.total);
+ r.out.result = _dfs_EnumEx(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(dfs_SetInfo2, &r);
- r.out.result = _dfs_SetInfo2(p);
+ r.out.result = _dfs_SetInfo2(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
#include "librpc/gen_ndr/ndr_dfs.h"
#ifndef __SRV_NETDFS__
#define __SRV_NETDFS__
-void _dfs_GetManagerVersion(pipes_struct *p, uint32_t *exist_flag);
-WERROR _dfs_Add(pipes_struct *p, const char *path, const char *server, const char *share, const char *comment, uint32_t flags);
-WERROR _dfs_Remove(pipes_struct *p, const char *path, const char *server, const char *share);
-WERROR _dfs_SetInfo(pipes_struct *p);
-WERROR _dfs_GetInfo(pipes_struct *p, const char *path, const char *server, const char *share, uint32_t level, union dfs_Info *info);
-WERROR _dfs_Enum(pipes_struct *p, uint32_t level, uint32_t bufsize, struct dfs_EnumStruct *info, uint32_t *unknown, uint32_t *total);
-WERROR _dfs_Rename(pipes_struct *p);
-WERROR _dfs_Move(pipes_struct *p);
-WERROR _dfs_ManagerGetConfigInfo(pipes_struct *p);
-WERROR _dfs_ManagerSendSiteInfo(pipes_struct *p);
-WERROR _dfs_AddFtRoot(pipes_struct *p);
-WERROR _dfs_RemoveFtRoot(pipes_struct *p);
-WERROR _dfs_AddStdRoot(pipes_struct *p);
-WERROR _dfs_RemoveStdRoot(pipes_struct *p);
-WERROR _dfs_ManagerInitialize(pipes_struct *p);
-WERROR _dfs_AddStdRootForced(pipes_struct *p);
-WERROR _dfs_GetDcAddress(pipes_struct *p);
-WERROR _dfs_SetDcAddress(pipes_struct *p);
-WERROR _dfs_FlushFtTable(pipes_struct *p);
-WERROR _dfs_Add2(pipes_struct *p);
-WERROR _dfs_Remove2(pipes_struct *p);
-WERROR _dfs_EnumEx(pipes_struct *p, const char *name, uint32_t level, uint32_t bufsize, struct dfs_EnumStruct *info, uint32_t *total);
-WERROR _dfs_SetInfo2(pipes_struct *p);
+void _dfs_GetManagerVersion(pipes_struct *p, struct dfs_GetManagerVersion *r);
+WERROR _dfs_Add(pipes_struct *p, struct dfs_Add *r);
+WERROR _dfs_Remove(pipes_struct *p, struct dfs_Remove *r);
+WERROR _dfs_SetInfo(pipes_struct *p, struct dfs_SetInfo *r);
+WERROR _dfs_GetInfo(pipes_struct *p, struct dfs_GetInfo *r);
+WERROR _dfs_Enum(pipes_struct *p, struct dfs_Enum *r);
+WERROR _dfs_Rename(pipes_struct *p, struct dfs_Rename *r);
+WERROR _dfs_Move(pipes_struct *p, struct dfs_Move *r);
+WERROR _dfs_ManagerGetConfigInfo(pipes_struct *p, struct dfs_ManagerGetConfigInfo *r);
+WERROR _dfs_ManagerSendSiteInfo(pipes_struct *p, struct dfs_ManagerSendSiteInfo *r);
+WERROR _dfs_AddFtRoot(pipes_struct *p, struct dfs_AddFtRoot *r);
+WERROR _dfs_RemoveFtRoot(pipes_struct *p, struct dfs_RemoveFtRoot *r);
+WERROR _dfs_AddStdRoot(pipes_struct *p, struct dfs_AddStdRoot *r);
+WERROR _dfs_RemoveStdRoot(pipes_struct *p, struct dfs_RemoveStdRoot *r);
+WERROR _dfs_ManagerInitialize(pipes_struct *p, struct dfs_ManagerInitialize *r);
+WERROR _dfs_AddStdRootForced(pipes_struct *p, struct dfs_AddStdRootForced *r);
+WERROR _dfs_GetDcAddress(pipes_struct *p, struct dfs_GetDcAddress *r);
+WERROR _dfs_SetDcAddress(pipes_struct *p, struct dfs_SetDcAddress *r);
+WERROR _dfs_FlushFtTable(pipes_struct *p, struct dfs_FlushFtTable *r);
+WERROR _dfs_Add2(pipes_struct *p, struct dfs_Add2 *r);
+WERROR _dfs_Remove2(pipes_struct *p, struct dfs_Remove2 *r);
+WERROR _dfs_EnumEx(pipes_struct *p, struct dfs_EnumEx *r);
+WERROR _dfs_SetInfo2(pipes_struct *p, struct dfs_SetInfo2 *r);
void netdfs_get_pipe_fns(struct api_struct **fns, int *n_fns);
NTSTATUS rpc_netdfs_init(void);
#endif /* __SRV_NETDFS__ */
return False;
}
- _echo_AddOne(p, r.in.in_data, r.out.out_data);
+ _echo_AddOne(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- _echo_EchoData(p, r.in.len, r.in.in_data, r.out.out_data);
+ _echo_EchoData(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(echo_SinkData, &r);
- _echo_SinkData(p, r.in.len, r.in.data);
+ _echo_SinkData(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- _echo_SourceData(p, r.in.len, r.out.data);
+ _echo_SourceData(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- _echo_TestCall(p, r.in.s1, r.out.s2);
+ _echo_TestCall(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _echo_TestCall2(p, r.in.level, r.out.info);
+ r.out.result = _echo_TestCall2(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(echo_TestSleep, &r);
- r.out.result = _echo_TestSleep(p, r.in.seconds);
+ r.out.result = _echo_TestSleep(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
r.out.foo1 = r.in.foo1;
r.out.foo2 = r.in.foo2;
r.out.foo3 = r.in.foo3;
- _echo_TestEnum(p, r.in.foo1, r.in.foo2, r.in.foo3);
+ _echo_TestEnum(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
ZERO_STRUCT(r.out);
r.out.data = r.in.data;
- _echo_TestSurrounding(p, r.in.data);
+ _echo_TestSurrounding(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(echo_TestDoublePointer, &r);
- r.out.result = _echo_TestDoublePointer(p, r.in.data);
+ r.out.result = _echo_TestDoublePointer(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
#include "librpc/gen_ndr/ndr_echo.h"
#ifndef __SRV_RPCECHO__
#define __SRV_RPCECHO__
-void _echo_AddOne(pipes_struct *p, uint32_t in_data, uint32_t *out_data);
-void _echo_EchoData(pipes_struct *p, uint32_t len, uint8_t *in_data, uint8_t *out_data);
-void _echo_SinkData(pipes_struct *p, uint32_t len, uint8_t *data);
-void _echo_SourceData(pipes_struct *p, uint32_t len, uint8_t *data);
-void _echo_TestCall(pipes_struct *p, const char *s1, const char **s2);
-NTSTATUS _echo_TestCall2(pipes_struct *p, uint16_t level, union echo_Info *info);
-uint32 _echo_TestSleep(pipes_struct *p, uint32_t seconds);
-void _echo_TestEnum(pipes_struct *p, enum echo_Enum1 *foo1, struct echo_Enum2 *foo2, union echo_Enum3 *foo3);
-void _echo_TestSurrounding(pipes_struct *p, struct echo_Surrounding *data);
-uint16 _echo_TestDoublePointer(pipes_struct *p, uint16_t ***data);
+void _echo_AddOne(pipes_struct *p, struct echo_AddOne *r);
+void _echo_EchoData(pipes_struct *p, struct echo_EchoData *r);
+void _echo_SinkData(pipes_struct *p, struct echo_SinkData *r);
+void _echo_SourceData(pipes_struct *p, struct echo_SourceData *r);
+void _echo_TestCall(pipes_struct *p, struct echo_TestCall *r);
+NTSTATUS _echo_TestCall2(pipes_struct *p, struct echo_TestCall2 *r);
+uint32 _echo_TestSleep(pipes_struct *p, struct echo_TestSleep *r);
+void _echo_TestEnum(pipes_struct *p, struct echo_TestEnum *r);
+void _echo_TestSurrounding(pipes_struct *p, struct echo_TestSurrounding *r);
+uint16 _echo_TestDoublePointer(pipes_struct *p, struct echo_TestDoublePointer *r);
void rpcecho_get_pipe_fns(struct api_struct **fns, int *n_fns);
NTSTATUS rpc_rpcecho_init(void);
#endif /* __SRV_RPCECHO__ */
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(eventlog_ClearEventLogW, &r);
- r.out.result = _eventlog_ClearEventLogW(p, r.in.handle, r.in.unknown);
+ r.out.result = _eventlog_ClearEventLogW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(eventlog_BackupEventLogW, &r);
- r.out.result = _eventlog_BackupEventLogW(p);
+ r.out.result = _eventlog_BackupEventLogW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
ZERO_STRUCT(r.out);
r.out.handle = r.in.handle;
- r.out.result = _eventlog_CloseEventLog(p, r.in.handle);
+ r.out.result = _eventlog_CloseEventLog(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(eventlog_DeregisterEventSource, &r);
- r.out.result = _eventlog_DeregisterEventSource(p);
+ r.out.result = _eventlog_DeregisterEventSource(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _eventlog_GetNumRecords(p, r.in.handle, r.out.number);
+ r.out.result = _eventlog_GetNumRecords(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(eventlog_GetOldestRecord, &r);
- r.out.result = _eventlog_GetOldestRecord(p);
+ r.out.result = _eventlog_GetOldestRecord(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(eventlog_ChangeNotify, &r);
- r.out.result = _eventlog_ChangeNotify(p);
+ r.out.result = _eventlog_ChangeNotify(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _eventlog_OpenEventLogW(p, r.in.unknown0, r.in.logname, r.in.servername, r.in.unknown2, r.in.unknown3, r.out.handle);
+ r.out.result = _eventlog_OpenEventLogW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(eventlog_RegisterEventSourceW, &r);
- r.out.result = _eventlog_RegisterEventSourceW(p);
+ r.out.result = _eventlog_RegisterEventSourceW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(eventlog_OpenBackupEventLogW, &r);
- r.out.result = _eventlog_OpenBackupEventLogW(p);
+ r.out.result = _eventlog_OpenBackupEventLogW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _eventlog_ReadEventLogW(p, r.in.handle, r.in.flags, r.in.offset, r.in.number_of_bytes, r.out.data, r.out.sent_size, r.out.real_size);
+ r.out.result = _eventlog_ReadEventLogW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(eventlog_ReportEventW, &r);
- r.out.result = _eventlog_ReportEventW(p);
+ r.out.result = _eventlog_ReportEventW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(eventlog_ClearEventLogA, &r);
- r.out.result = _eventlog_ClearEventLogA(p);
+ r.out.result = _eventlog_ClearEventLogA(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(eventlog_BackupEventLogA, &r);
- r.out.result = _eventlog_BackupEventLogA(p);
+ r.out.result = _eventlog_BackupEventLogA(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(eventlog_OpenEventLogA, &r);
- r.out.result = _eventlog_OpenEventLogA(p);
+ r.out.result = _eventlog_OpenEventLogA(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(eventlog_RegisterEventSourceA, &r);
- r.out.result = _eventlog_RegisterEventSourceA(p);
+ r.out.result = _eventlog_RegisterEventSourceA(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(eventlog_OpenBackupEventLogA, &r);
- r.out.result = _eventlog_OpenBackupEventLogA(p);
+ r.out.result = _eventlog_OpenBackupEventLogA(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(eventlog_ReadEventLogA, &r);
- r.out.result = _eventlog_ReadEventLogA(p);
+ r.out.result = _eventlog_ReadEventLogA(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(eventlog_ReportEventA, &r);
- r.out.result = _eventlog_ReportEventA(p);
+ r.out.result = _eventlog_ReportEventA(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(eventlog_RegisterClusterSvc, &r);
- r.out.result = _eventlog_RegisterClusterSvc(p);
+ r.out.result = _eventlog_RegisterClusterSvc(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(eventlog_DeregisterClusterSvc, &r);
- r.out.result = _eventlog_DeregisterClusterSvc(p);
+ r.out.result = _eventlog_DeregisterClusterSvc(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(eventlog_WriteClusterEvents, &r);
- r.out.result = _eventlog_WriteClusterEvents(p);
+ r.out.result = _eventlog_WriteClusterEvents(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(eventlog_GetLogIntormation, &r);
- r.out.result = _eventlog_GetLogIntormation(p);
+ r.out.result = _eventlog_GetLogIntormation(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(eventlog_FlushEventLog, &r);
- r.out.result = _eventlog_FlushEventLog(p, r.in.handle);
+ r.out.result = _eventlog_FlushEventLog(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
#include "librpc/gen_ndr/ndr_eventlog.h"
#ifndef __SRV_EVENTLOG__
#define __SRV_EVENTLOG__
-NTSTATUS _eventlog_ClearEventLogW(pipes_struct *p, struct policy_handle *handle, struct lsa_String *unknown);
-NTSTATUS _eventlog_BackupEventLogW(pipes_struct *p);
-NTSTATUS _eventlog_CloseEventLog(pipes_struct *p, struct policy_handle *handle);
-NTSTATUS _eventlog_DeregisterEventSource(pipes_struct *p);
-NTSTATUS _eventlog_GetNumRecords(pipes_struct *p, struct policy_handle *handle, uint32_t *number);
-NTSTATUS _eventlog_GetOldestRecord(pipes_struct *p);
-NTSTATUS _eventlog_ChangeNotify(pipes_struct *p);
-NTSTATUS _eventlog_OpenEventLogW(pipes_struct *p, struct eventlog_OpenUnknown0 *unknown0, struct lsa_String logname, struct lsa_String servername, uint32_t unknown2, uint32_t unknown3, struct policy_handle *handle);
-NTSTATUS _eventlog_RegisterEventSourceW(pipes_struct *p);
-NTSTATUS _eventlog_OpenBackupEventLogW(pipes_struct *p);
-NTSTATUS _eventlog_ReadEventLogW(pipes_struct *p, struct policy_handle *handle, uint32_t flags, uint32_t offset, uint32_t number_of_bytes, uint8_t *data, uint32_t *sent_size, uint32_t *real_size);
-NTSTATUS _eventlog_ReportEventW(pipes_struct *p);
-NTSTATUS _eventlog_ClearEventLogA(pipes_struct *p);
-NTSTATUS _eventlog_BackupEventLogA(pipes_struct *p);
-NTSTATUS _eventlog_OpenEventLogA(pipes_struct *p);
-NTSTATUS _eventlog_RegisterEventSourceA(pipes_struct *p);
-NTSTATUS _eventlog_OpenBackupEventLogA(pipes_struct *p);
-NTSTATUS _eventlog_ReadEventLogA(pipes_struct *p);
-NTSTATUS _eventlog_ReportEventA(pipes_struct *p);
-NTSTATUS _eventlog_RegisterClusterSvc(pipes_struct *p);
-NTSTATUS _eventlog_DeregisterClusterSvc(pipes_struct *p);
-NTSTATUS _eventlog_WriteClusterEvents(pipes_struct *p);
-NTSTATUS _eventlog_GetLogIntormation(pipes_struct *p);
-NTSTATUS _eventlog_FlushEventLog(pipes_struct *p, struct policy_handle *handle);
+NTSTATUS _eventlog_ClearEventLogW(pipes_struct *p, struct eventlog_ClearEventLogW *r);
+NTSTATUS _eventlog_BackupEventLogW(pipes_struct *p, struct eventlog_BackupEventLogW *r);
+NTSTATUS _eventlog_CloseEventLog(pipes_struct *p, struct eventlog_CloseEventLog *r);
+NTSTATUS _eventlog_DeregisterEventSource(pipes_struct *p, struct eventlog_DeregisterEventSource *r);
+NTSTATUS _eventlog_GetNumRecords(pipes_struct *p, struct eventlog_GetNumRecords *r);
+NTSTATUS _eventlog_GetOldestRecord(pipes_struct *p, struct eventlog_GetOldestRecord *r);
+NTSTATUS _eventlog_ChangeNotify(pipes_struct *p, struct eventlog_ChangeNotify *r);
+NTSTATUS _eventlog_OpenEventLogW(pipes_struct *p, struct eventlog_OpenEventLogW *r);
+NTSTATUS _eventlog_RegisterEventSourceW(pipes_struct *p, struct eventlog_RegisterEventSourceW *r);
+NTSTATUS _eventlog_OpenBackupEventLogW(pipes_struct *p, struct eventlog_OpenBackupEventLogW *r);
+NTSTATUS _eventlog_ReadEventLogW(pipes_struct *p, struct eventlog_ReadEventLogW *r);
+NTSTATUS _eventlog_ReportEventW(pipes_struct *p, struct eventlog_ReportEventW *r);
+NTSTATUS _eventlog_ClearEventLogA(pipes_struct *p, struct eventlog_ClearEventLogA *r);
+NTSTATUS _eventlog_BackupEventLogA(pipes_struct *p, struct eventlog_BackupEventLogA *r);
+NTSTATUS _eventlog_OpenEventLogA(pipes_struct *p, struct eventlog_OpenEventLogA *r);
+NTSTATUS _eventlog_RegisterEventSourceA(pipes_struct *p, struct eventlog_RegisterEventSourceA *r);
+NTSTATUS _eventlog_OpenBackupEventLogA(pipes_struct *p, struct eventlog_OpenBackupEventLogA *r);
+NTSTATUS _eventlog_ReadEventLogA(pipes_struct *p, struct eventlog_ReadEventLogA *r);
+NTSTATUS _eventlog_ReportEventA(pipes_struct *p, struct eventlog_ReportEventA *r);
+NTSTATUS _eventlog_RegisterClusterSvc(pipes_struct *p, struct eventlog_RegisterClusterSvc *r);
+NTSTATUS _eventlog_DeregisterClusterSvc(pipes_struct *p, struct eventlog_DeregisterClusterSvc *r);
+NTSTATUS _eventlog_WriteClusterEvents(pipes_struct *p, struct eventlog_WriteClusterEvents *r);
+NTSTATUS _eventlog_GetLogIntormation(pipes_struct *p, struct eventlog_GetLogIntormation *r);
+NTSTATUS _eventlog_FlushEventLog(pipes_struct *p, struct eventlog_FlushEventLog *r);
void eventlog_get_pipe_fns(struct api_struct **fns, int *n_fns);
NTSTATUS rpc_eventlog_init(void);
#endif /* __SRV_EVENTLOG__ */
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(initshutdown_Init, &r);
- r.out.result = _initshutdown_Init(p, r.in.hostname, r.in.message, r.in.timeout, r.in.force_apps, r.in.reboot);
+ r.out.result = _initshutdown_Init(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(initshutdown_Abort, &r);
- r.out.result = _initshutdown_Abort(p, r.in.server);
+ r.out.result = _initshutdown_Abort(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(initshutdown_InitEx, &r);
- r.out.result = _initshutdown_InitEx(p, r.in.hostname, r.in.message, r.in.timeout, r.in.force_apps, r.in.reboot, r.in.reason);
+ r.out.result = _initshutdown_InitEx(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
#include "librpc/gen_ndr/ndr_initshutdown.h"
#ifndef __SRV_INITSHUTDOWN__
#define __SRV_INITSHUTDOWN__
-WERROR _initshutdown_Init(pipes_struct *p, uint16_t *hostname, struct initshutdown_String *message, uint32_t timeout, uint8_t force_apps, uint8_t reboot);
-WERROR _initshutdown_Abort(pipes_struct *p, uint16_t *server);
-WERROR _initshutdown_InitEx(pipes_struct *p, uint16_t *hostname, struct initshutdown_String *message, uint32_t timeout, uint8_t force_apps, uint8_t reboot, uint32_t reason);
+WERROR _initshutdown_Init(pipes_struct *p, struct initshutdown_Init *r);
+WERROR _initshutdown_Abort(pipes_struct *p, struct initshutdown_Abort *r);
+WERROR _initshutdown_InitEx(pipes_struct *p, struct initshutdown_InitEx *r);
void initshutdown_get_pipe_fns(struct api_struct **fns, int *n_fns);
NTSTATUS rpc_initshutdown_init(void);
#endif /* __SRV_INITSHUTDOWN__ */
ZERO_STRUCT(r.out);
r.out.handle = r.in.handle;
- r.out.result = _lsa_Close(p, r.in.handle);
+ r.out.result = _lsa_Close(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_Delete, &r);
- r.out.result = _lsa_Delete(p, r.in.handle);
+ r.out.result = _lsa_Delete(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_EnumPrivs(p, r.in.handle, r.in.resume_handle, r.in.max_count, r.out.privs);
+ r.out.result = _lsa_EnumPrivs(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_QuerySecurity(p, r.in.handle, r.in.sec_info, r.out.sdbuf);
+ r.out.result = _lsa_QuerySecurity(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_SetSecObj, &r);
- r.out.result = _lsa_SetSecObj(p);
+ r.out.result = _lsa_SetSecObj(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_ChangePassword, &r);
- r.out.result = _lsa_ChangePassword(p);
+ r.out.result = _lsa_ChangePassword(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_OpenPolicy(p, r.in.system_name, r.in.attr, r.in.access_mask, r.out.handle);
+ r.out.result = _lsa_OpenPolicy(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_QueryInfoPolicy(p, r.in.handle, r.in.level, r.out.info);
+ r.out.result = _lsa_QueryInfoPolicy(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_SetInfoPolicy, &r);
- r.out.result = _lsa_SetInfoPolicy(p);
+ r.out.result = _lsa_SetInfoPolicy(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_ClearAuditLog, &r);
- r.out.result = _lsa_ClearAuditLog(p);
+ r.out.result = _lsa_ClearAuditLog(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_CreateAccount(p, r.in.handle, r.in.sid, r.in.access_mask, r.out.acct_handle);
+ r.out.result = _lsa_CreateAccount(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_EnumAccounts(p, r.in.handle, r.in.resume_handle, r.in.num_entries, r.out.sids);
+ r.out.result = _lsa_EnumAccounts(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_CreateTrustedDomain(p, r.in.handle, r.in.info, r.in.access_mask, r.out.trustdom_handle);
+ r.out.result = _lsa_CreateTrustedDomain(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_EnumTrustDom(p, r.in.handle, r.in.resume_handle, r.in.max_size, r.out.domains);
+ r.out.result = _lsa_EnumTrustDom(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
r.out.sids = r.in.sids;
r.out.count = r.in.count;
- r.out.result = _lsa_LookupNames(p, r.in.handle, r.in.num_names, r.in.names, r.out.domains, r.in.sids, r.in.level, r.in.count);
+ r.out.result = _lsa_LookupNames(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
r.out.names = r.in.names;
r.out.count = r.in.count;
- r.out.result = _lsa_LookupSids(p, r.in.handle, r.in.sids, r.out.domains, r.in.names, r.in.level, r.in.count);
+ r.out.result = _lsa_LookupSids(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_CreateSecret(p, r.in.handle, r.in.name, r.in.access_mask, r.out.sec_handle);
+ r.out.result = _lsa_CreateSecret(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_OpenAccount(p, r.in.handle, r.in.sid, r.in.access_mask, r.out.acct_handle);
+ r.out.result = _lsa_OpenAccount(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_EnumPrivsAccount(p, r.in.handle, r.out.privs);
+ r.out.result = _lsa_EnumPrivsAccount(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_AddPrivilegesToAccount, &r);
- r.out.result = _lsa_AddPrivilegesToAccount(p, r.in.handle, r.in.privs);
+ r.out.result = _lsa_AddPrivilegesToAccount(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_RemovePrivilegesFromAccount, &r);
- r.out.result = _lsa_RemovePrivilegesFromAccount(p, r.in.handle, r.in.remove_all, r.in.privs);
+ r.out.result = _lsa_RemovePrivilegesFromAccount(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_GetQuotasForAccount, &r);
- r.out.result = _lsa_GetQuotasForAccount(p);
+ r.out.result = _lsa_GetQuotasForAccount(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_SetQuotasForAccount, &r);
- r.out.result = _lsa_SetQuotasForAccount(p);
+ r.out.result = _lsa_SetQuotasForAccount(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_GetSystemAccessAccount, &r);
- r.out.result = _lsa_GetSystemAccessAccount(p);
+ r.out.result = _lsa_GetSystemAccessAccount(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_SetSystemAccessAccount, &r);
- r.out.result = _lsa_SetSystemAccessAccount(p);
+ r.out.result = _lsa_SetSystemAccessAccount(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_OpenTrustedDomain(p, r.in.handle, r.in.sid, r.in.access_mask, r.out.trustdom_handle);
+ r.out.result = _lsa_OpenTrustedDomain(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_QueryTrustedDomainInfo(p, r.in.trustdom_handle, r.in.level, r.out.info);
+ r.out.result = _lsa_QueryTrustedDomainInfo(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_SetInformationTrustedDomain, &r);
- r.out.result = _lsa_SetInformationTrustedDomain(p);
+ r.out.result = _lsa_SetInformationTrustedDomain(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_OpenSecret(p, r.in.handle, r.in.name, r.in.access_mask, r.out.sec_handle);
+ r.out.result = _lsa_OpenSecret(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_SetSecret, &r);
- r.out.result = _lsa_SetSecret(p, r.in.sec_handle, r.in.new_val, r.in.old_val);
+ r.out.result = _lsa_SetSecret(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
r.out.new_mtime = r.in.new_mtime;
r.out.old_val = r.in.old_val;
r.out.old_mtime = r.in.old_mtime;
- r.out.result = _lsa_QuerySecret(p, r.in.sec_handle, r.in.new_val, r.in.new_mtime, r.in.old_val, r.in.old_mtime);
+ r.out.result = _lsa_QuerySecret(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_LookupPrivValue(p, r.in.handle, r.in.name, r.out.luid);
+ r.out.result = _lsa_LookupPrivValue(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_LookupPrivName(p, r.in.handle, r.in.luid, r.out.name);
+ r.out.result = _lsa_LookupPrivName(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
}
r.out.language_id = r.in.language_id;
- r.out.result = _lsa_LookupPrivDisplayName(p, r.in.handle, r.in.name, r.out.disp_name, r.in.language_id, r.in.unknown);
+ r.out.result = _lsa_LookupPrivDisplayName(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_DeleteObject, &r);
- r.out.result = _lsa_DeleteObject(p);
+ r.out.result = _lsa_DeleteObject(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_EnumAccountsWithUserRight(p, r.in.handle, r.in.name, r.out.sids);
+ r.out.result = _lsa_EnumAccountsWithUserRight(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_EnumAccountRights(p, r.in.handle, r.in.sid, r.out.rights);
+ r.out.result = _lsa_EnumAccountRights(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_AddAccountRights, &r);
- r.out.result = _lsa_AddAccountRights(p, r.in.handle, r.in.sid, r.in.rights);
+ r.out.result = _lsa_AddAccountRights(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_RemoveAccountRights, &r);
- r.out.result = _lsa_RemoveAccountRights(p, r.in.handle, r.in.sid, r.in.unknown, r.in.rights);
+ r.out.result = _lsa_RemoveAccountRights(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_QueryTrustedDomainInfoBySid(p, r.in.handle, r.in.dom_sid, r.in.level, r.out.info);
+ r.out.result = _lsa_QueryTrustedDomainInfoBySid(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_SetTrustedDomainInfo, &r);
- r.out.result = _lsa_SetTrustedDomainInfo(p);
+ r.out.result = _lsa_SetTrustedDomainInfo(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_DeleteTrustedDomain, &r);
- r.out.result = _lsa_DeleteTrustedDomain(p, r.in.handle, r.in.dom_sid);
+ r.out.result = _lsa_DeleteTrustedDomain(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_StorePrivateData, &r);
- r.out.result = _lsa_StorePrivateData(p);
+ r.out.result = _lsa_StorePrivateData(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_RetrievePrivateData, &r);
- r.out.result = _lsa_RetrievePrivateData(p);
+ r.out.result = _lsa_RetrievePrivateData(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_OpenPolicy2(p, r.in.system_name, r.in.attr, r.in.access_mask, r.out.handle);
+ r.out.result = _lsa_OpenPolicy2(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
ZERO_STRUCT(r.out);
r.out.account_name = r.in.account_name;
r.out.authority_name = r.in.authority_name;
- r.out.result = _lsa_GetUserName(p, r.in.system_name, r.in.account_name, r.in.authority_name);
+ r.out.result = _lsa_GetUserName(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_QueryInfoPolicy2(p, r.in.handle, r.in.level, r.out.info);
+ r.out.result = _lsa_QueryInfoPolicy2(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_SetInfoPolicy2, &r);
- r.out.result = _lsa_SetInfoPolicy2(p);
+ r.out.result = _lsa_SetInfoPolicy2(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_QueryTrustedDomainInfoByName(p, r.in.handle, r.in.trusted_domain, r.in.level, r.out.info);
+ r.out.result = _lsa_QueryTrustedDomainInfoByName(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_SetTrustedDomainInfoByName, &r);
- r.out.result = _lsa_SetTrustedDomainInfoByName(p, r.in.handle, r.in.trusted_domain, r.in.level, r.in.info);
+ r.out.result = _lsa_SetTrustedDomainInfoByName(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_EnumTrustedDomainsEx(p, r.in.handle, r.in.resume_handle, r.out.domains, r.in.max_size);
+ r.out.result = _lsa_EnumTrustedDomainsEx(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomainEx, &r);
- r.out.result = _lsa_CreateTrustedDomainEx(p);
+ r.out.result = _lsa_CreateTrustedDomainEx(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
ZERO_STRUCT(r.out);
r.out.handle = r.in.handle;
- r.out.result = _lsa_CloseTrustedDomainEx(p, r.in.handle);
+ r.out.result = _lsa_CloseTrustedDomainEx(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_QueryDomainInformationPolicy(p, r.in.handle, r.in.level, r.out.info);
+ r.out.result = _lsa_QueryDomainInformationPolicy(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_SetDomainInformationPolicy, &r);
- r.out.result = _lsa_SetDomainInformationPolicy(p, r.in.handle, r.in.level, r.in.info);
+ r.out.result = _lsa_SetDomainInformationPolicy(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _lsa_OpenTrustedDomainByName(p, r.in.handle, r.in.name, r.in.access_mask, r.out.trustdom_handle);
+ r.out.result = _lsa_OpenTrustedDomainByName(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_TestCall, &r);
- r.out.result = _lsa_TestCall(p);
+ r.out.result = _lsa_TestCall(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
r.out.names = r.in.names;
r.out.count = r.in.count;
- r.out.result = _lsa_LookupSids2(p, r.in.handle, r.in.sids, r.out.domains, r.in.names, r.in.level, r.in.count, r.in.unknown1, r.in.unknown2);
+ r.out.result = _lsa_LookupSids2(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
r.out.sids = r.in.sids;
r.out.count = r.in.count;
- r.out.result = _lsa_LookupNames2(p, r.in.handle, r.in.num_names, r.in.names, r.out.domains, r.in.sids, r.in.level, r.in.count, r.in.unknown1, r.in.unknown2);
+ r.out.result = _lsa_LookupNames2(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomainEx2, &r);
- r.out.result = _lsa_CreateTrustedDomainEx2(p);
+ r.out.result = _lsa_CreateTrustedDomainEx2(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_CREDRWRITE, &r);
- r.out.result = _lsa_CREDRWRITE(p);
+ r.out.result = _lsa_CREDRWRITE(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_CREDRREAD, &r);
- r.out.result = _lsa_CREDRREAD(p);
+ r.out.result = _lsa_CREDRREAD(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_CREDRENUMERATE, &r);
- r.out.result = _lsa_CREDRENUMERATE(p);
+ r.out.result = _lsa_CREDRENUMERATE(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_CREDRWRITEDOMAINCREDENTIALS, &r);
- r.out.result = _lsa_CREDRWRITEDOMAINCREDENTIALS(p);
+ r.out.result = _lsa_CREDRWRITEDOMAINCREDENTIALS(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_CREDRREADDOMAINCREDENTIALS, &r);
- r.out.result = _lsa_CREDRREADDOMAINCREDENTIALS(p);
+ r.out.result = _lsa_CREDRREADDOMAINCREDENTIALS(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_CREDRDELETE, &r);
- r.out.result = _lsa_CREDRDELETE(p);
+ r.out.result = _lsa_CREDRDELETE(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_CREDRGETTARGETINFO, &r);
- r.out.result = _lsa_CREDRGETTARGETINFO(p);
+ r.out.result = _lsa_CREDRGETTARGETINFO(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_CREDRPROFILELOADED, &r);
- r.out.result = _lsa_CREDRPROFILELOADED(p);
+ r.out.result = _lsa_CREDRPROFILELOADED(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
r.out.sids = r.in.sids;
r.out.count = r.in.count;
- r.out.result = _lsa_LookupNames3(p, r.in.handle, r.in.num_names, r.in.names, r.out.domains, r.in.sids, r.in.level, r.in.count, r.in.unknown1, r.in.unknown2);
+ r.out.result = _lsa_LookupNames3(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_CREDRGETSESSIONTYPES, &r);
- r.out.result = _lsa_CREDRGETSESSIONTYPES(p);
+ r.out.result = _lsa_CREDRGETSESSIONTYPES(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_LSARREGISTERAUDITEVENT, &r);
- r.out.result = _lsa_LSARREGISTERAUDITEVENT(p);
+ r.out.result = _lsa_LSARREGISTERAUDITEVENT(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_LSARGENAUDITEVENT, &r);
- r.out.result = _lsa_LSARGENAUDITEVENT(p);
+ r.out.result = _lsa_LSARGENAUDITEVENT(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_LSARUNREGISTERAUDITEVENT, &r);
- r.out.result = _lsa_LSARUNREGISTERAUDITEVENT(p);
+ r.out.result = _lsa_LSARUNREGISTERAUDITEVENT(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_LSARQUERYFORESTTRUSTINFORMATION, &r);
- r.out.result = _lsa_LSARQUERYFORESTTRUSTINFORMATION(p);
+ r.out.result = _lsa_LSARQUERYFORESTTRUSTINFORMATION(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_LSARSETFORESTTRUSTINFORMATION, &r);
- r.out.result = _lsa_LSARSETFORESTTRUSTINFORMATION(p);
+ r.out.result = _lsa_LSARSETFORESTTRUSTINFORMATION(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_CREDRRENAME, &r);
- r.out.result = _lsa_CREDRRENAME(p);
+ r.out.result = _lsa_CREDRRENAME(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
r.out.names = r.in.names;
r.out.count = r.in.count;
- r.out.result = _lsa_LookupSids3(p, r.in.sids, r.out.domains, r.in.names, r.in.level, r.in.count, r.in.unknown1, r.in.unknown2);
+ r.out.result = _lsa_LookupSids3(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
r.out.sids = r.in.sids;
r.out.count = r.in.count;
- r.out.result = _lsa_LookupNames4(p, r.in.num_names, r.in.names, r.out.domains, r.in.sids, r.in.level, r.in.count, r.in.unknown1, r.in.unknown2);
+ r.out.result = _lsa_LookupNames4(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_LSAROPENPOLICYSCE, &r);
- r.out.result = _lsa_LSAROPENPOLICYSCE(p);
+ r.out.result = _lsa_LSAROPENPOLICYSCE(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_LSARADTREGISTERSECURITYEVENTSOURCE, &r);
- r.out.result = _lsa_LSARADTREGISTERSECURITYEVENTSOURCE(p);
+ r.out.result = _lsa_LSARADTREGISTERSECURITYEVENTSOURCE(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE, &r);
- r.out.result = _lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(p);
+ r.out.result = _lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(lsa_LSARADTREPORTSECURITYEVENT, &r);
- r.out.result = _lsa_LSARADTREPORTSECURITYEVENT(p);
+ r.out.result = _lsa_LSARADTREPORTSECURITYEVENT(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
#include "librpc/gen_ndr/ndr_lsa.h"
#ifndef __SRV_LSARPC__
#define __SRV_LSARPC__
-NTSTATUS _lsa_Close(pipes_struct *p, struct policy_handle *handle);
-NTSTATUS _lsa_Delete(pipes_struct *p, struct policy_handle *handle);
-NTSTATUS _lsa_EnumPrivs(pipes_struct *p, struct policy_handle *handle, uint32_t *resume_handle, uint32_t max_count, struct lsa_PrivArray *privs);
-NTSTATUS _lsa_QuerySecurity(pipes_struct *p, struct policy_handle *handle, uint32_t sec_info, struct sec_desc_buf *sdbuf);
-NTSTATUS _lsa_SetSecObj(pipes_struct *p);
-NTSTATUS _lsa_ChangePassword(pipes_struct *p);
-NTSTATUS _lsa_OpenPolicy(pipes_struct *p, uint16_t *system_name, struct lsa_ObjectAttribute *attr, uint32_t access_mask, struct policy_handle *handle);
-NTSTATUS _lsa_QueryInfoPolicy(pipes_struct *p, struct policy_handle *handle, uint16_t level, union lsa_PolicyInformation *info);
-NTSTATUS _lsa_SetInfoPolicy(pipes_struct *p);
-NTSTATUS _lsa_ClearAuditLog(pipes_struct *p);
-NTSTATUS _lsa_CreateAccount(pipes_struct *p, struct policy_handle *handle, struct dom_sid2 *sid, uint32_t access_mask, struct policy_handle *acct_handle);
-NTSTATUS _lsa_EnumAccounts(pipes_struct *p, struct policy_handle *handle, uint32_t *resume_handle, uint32_t num_entries, struct lsa_SidArray *sids);
-NTSTATUS _lsa_CreateTrustedDomain(pipes_struct *p, struct policy_handle *handle, struct lsa_DomainInfo *info, uint32_t access_mask, struct policy_handle *trustdom_handle);
-NTSTATUS _lsa_EnumTrustDom(pipes_struct *p, struct policy_handle *handle, uint32_t *resume_handle, uint32_t max_size, struct lsa_DomainList *domains);
-NTSTATUS _lsa_LookupNames(pipes_struct *p, struct policy_handle *handle, uint32_t num_names, struct lsa_String *names, struct lsa_RefDomainList *domains, struct lsa_TransSidArray *sids, uint16_t level, uint32_t *count);
-NTSTATUS _lsa_LookupSids(pipes_struct *p, struct policy_handle *handle, struct lsa_SidArray *sids, struct lsa_RefDomainList *domains, struct lsa_TransNameArray *names, uint16_t level, uint32_t *count);
-NTSTATUS _lsa_CreateSecret(pipes_struct *p, struct policy_handle *handle, struct lsa_String name, uint32_t access_mask, struct policy_handle *sec_handle);
-NTSTATUS _lsa_OpenAccount(pipes_struct *p, struct policy_handle *handle, struct dom_sid2 *sid, uint32_t access_mask, struct policy_handle *acct_handle);
-NTSTATUS _lsa_EnumPrivsAccount(pipes_struct *p, struct policy_handle *handle, struct lsa_PrivilegeSet *privs);
-NTSTATUS _lsa_AddPrivilegesToAccount(pipes_struct *p, struct policy_handle *handle, struct lsa_PrivilegeSet *privs);
-NTSTATUS _lsa_RemovePrivilegesFromAccount(pipes_struct *p, struct policy_handle *handle, uint8_t remove_all, struct lsa_PrivilegeSet *privs);
-NTSTATUS _lsa_GetQuotasForAccount(pipes_struct *p);
-NTSTATUS _lsa_SetQuotasForAccount(pipes_struct *p);
-NTSTATUS _lsa_GetSystemAccessAccount(pipes_struct *p);
-NTSTATUS _lsa_SetSystemAccessAccount(pipes_struct *p);
-NTSTATUS _lsa_OpenTrustedDomain(pipes_struct *p, struct policy_handle *handle, struct dom_sid2 *sid, uint32_t access_mask, struct policy_handle *trustdom_handle);
-NTSTATUS _lsa_QueryTrustedDomainInfo(pipes_struct *p, struct policy_handle *trustdom_handle, enum lsa_TrustDomInfoEnum level, union lsa_TrustedDomainInfo *info);
-NTSTATUS _lsa_SetInformationTrustedDomain(pipes_struct *p);
-NTSTATUS _lsa_OpenSecret(pipes_struct *p, struct policy_handle *handle, struct lsa_String name, uint32_t access_mask, struct policy_handle *sec_handle);
-NTSTATUS _lsa_SetSecret(pipes_struct *p, struct policy_handle *sec_handle, struct lsa_DATA_BUF *new_val, struct lsa_DATA_BUF *old_val);
-NTSTATUS _lsa_QuerySecret(pipes_struct *p, struct policy_handle *sec_handle, struct lsa_DATA_BUF_PTR *new_val, NTTIME *new_mtime, struct lsa_DATA_BUF_PTR *old_val, NTTIME *old_mtime);
-NTSTATUS _lsa_LookupPrivValue(pipes_struct *p, struct policy_handle *handle, struct lsa_String *name, struct lsa_LUID *luid);
-NTSTATUS _lsa_LookupPrivName(pipes_struct *p, struct policy_handle *handle, struct lsa_LUID *luid, struct lsa_StringLarge *name);
-NTSTATUS _lsa_LookupPrivDisplayName(pipes_struct *p, struct policy_handle *handle, struct lsa_String *name, struct lsa_StringLarge *disp_name, uint16_t *language_id, uint16_t unknown);
-NTSTATUS _lsa_DeleteObject(pipes_struct *p);
-NTSTATUS _lsa_EnumAccountsWithUserRight(pipes_struct *p, struct policy_handle *handle, struct lsa_String *name, struct lsa_SidArray *sids);
-NTSTATUS _lsa_EnumAccountRights(pipes_struct *p, struct policy_handle *handle, struct dom_sid2 *sid, struct lsa_RightSet *rights);
-NTSTATUS _lsa_AddAccountRights(pipes_struct *p, struct policy_handle *handle, struct dom_sid2 *sid, struct lsa_RightSet *rights);
-NTSTATUS _lsa_RemoveAccountRights(pipes_struct *p, struct policy_handle *handle, struct dom_sid2 *sid, uint32_t unknown, struct lsa_RightSet *rights);
-NTSTATUS _lsa_QueryTrustedDomainInfoBySid(pipes_struct *p, struct policy_handle *handle, struct dom_sid2 *dom_sid, enum lsa_TrustDomInfoEnum level, union lsa_TrustedDomainInfo *info);
-NTSTATUS _lsa_SetTrustedDomainInfo(pipes_struct *p);
-NTSTATUS _lsa_DeleteTrustedDomain(pipes_struct *p, struct policy_handle *handle, struct dom_sid2 *dom_sid);
-NTSTATUS _lsa_StorePrivateData(pipes_struct *p);
-NTSTATUS _lsa_RetrievePrivateData(pipes_struct *p);
-NTSTATUS _lsa_OpenPolicy2(pipes_struct *p, const char *system_name, struct lsa_ObjectAttribute *attr, uint32_t access_mask, struct policy_handle *handle);
-NTSTATUS _lsa_GetUserName(pipes_struct *p, const char *system_name, struct lsa_String *account_name, struct lsa_StringPointer *authority_name);
-NTSTATUS _lsa_QueryInfoPolicy2(pipes_struct *p, struct policy_handle *handle, uint16_t level, union lsa_PolicyInformation *info);
-NTSTATUS _lsa_SetInfoPolicy2(pipes_struct *p);
-NTSTATUS _lsa_QueryTrustedDomainInfoByName(pipes_struct *p, struct policy_handle *handle, struct lsa_String trusted_domain, enum lsa_TrustDomInfoEnum level, union lsa_TrustedDomainInfo *info);
-NTSTATUS _lsa_SetTrustedDomainInfoByName(pipes_struct *p, struct policy_handle *handle, struct lsa_String trusted_domain, enum lsa_TrustDomInfoEnum level, union lsa_TrustedDomainInfo *info);
-NTSTATUS _lsa_EnumTrustedDomainsEx(pipes_struct *p, struct policy_handle *handle, uint32_t *resume_handle, struct lsa_DomainListEx *domains, uint32_t max_size);
-NTSTATUS _lsa_CreateTrustedDomainEx(pipes_struct *p);
-NTSTATUS _lsa_CloseTrustedDomainEx(pipes_struct *p, struct policy_handle *handle);
-NTSTATUS _lsa_QueryDomainInformationPolicy(pipes_struct *p, struct policy_handle *handle, uint16_t level, union lsa_DomainInformationPolicy *info);
-NTSTATUS _lsa_SetDomainInformationPolicy(pipes_struct *p, struct policy_handle *handle, uint16_t level, union lsa_DomainInformationPolicy *info);
-NTSTATUS _lsa_OpenTrustedDomainByName(pipes_struct *p, struct policy_handle *handle, struct lsa_String name, uint32_t access_mask, struct policy_handle *trustdom_handle);
-NTSTATUS _lsa_TestCall(pipes_struct *p);
-NTSTATUS _lsa_LookupSids2(pipes_struct *p, struct policy_handle *handle, struct lsa_SidArray *sids, struct lsa_RefDomainList *domains, struct lsa_TransNameArray2 *names, uint16_t level, uint32_t *count, uint32_t unknown1, uint32_t unknown2);
-NTSTATUS _lsa_LookupNames2(pipes_struct *p, struct policy_handle *handle, uint32_t num_names, struct lsa_String *names, struct lsa_RefDomainList *domains, struct lsa_TransSidArray2 *sids, uint16_t level, uint32_t *count, uint32_t unknown1, uint32_t unknown2);
-NTSTATUS _lsa_CreateTrustedDomainEx2(pipes_struct *p);
-NTSTATUS _lsa_CREDRWRITE(pipes_struct *p);
-NTSTATUS _lsa_CREDRREAD(pipes_struct *p);
-NTSTATUS _lsa_CREDRENUMERATE(pipes_struct *p);
-NTSTATUS _lsa_CREDRWRITEDOMAINCREDENTIALS(pipes_struct *p);
-NTSTATUS _lsa_CREDRREADDOMAINCREDENTIALS(pipes_struct *p);
-NTSTATUS _lsa_CREDRDELETE(pipes_struct *p);
-NTSTATUS _lsa_CREDRGETTARGETINFO(pipes_struct *p);
-NTSTATUS _lsa_CREDRPROFILELOADED(pipes_struct *p);
-NTSTATUS _lsa_LookupNames3(pipes_struct *p, struct policy_handle *handle, uint32_t num_names, struct lsa_String *names, struct lsa_RefDomainList *domains, struct lsa_TransSidArray3 *sids, uint16_t level, uint32_t *count, uint32_t unknown1, uint32_t unknown2);
-NTSTATUS _lsa_CREDRGETSESSIONTYPES(pipes_struct *p);
-NTSTATUS _lsa_LSARREGISTERAUDITEVENT(pipes_struct *p);
-NTSTATUS _lsa_LSARGENAUDITEVENT(pipes_struct *p);
-NTSTATUS _lsa_LSARUNREGISTERAUDITEVENT(pipes_struct *p);
-NTSTATUS _lsa_LSARQUERYFORESTTRUSTINFORMATION(pipes_struct *p);
-NTSTATUS _lsa_LSARSETFORESTTRUSTINFORMATION(pipes_struct *p);
-NTSTATUS _lsa_CREDRRENAME(pipes_struct *p);
-NTSTATUS _lsa_LookupSids3(pipes_struct *p, struct lsa_SidArray *sids, struct lsa_RefDomainList *domains, struct lsa_TransNameArray2 *names, uint16_t level, uint32_t *count, uint32_t unknown1, uint32_t unknown2);
-NTSTATUS _lsa_LookupNames4(pipes_struct *p, uint32_t num_names, struct lsa_String *names, struct lsa_RefDomainList *domains, struct lsa_TransSidArray3 *sids, uint16_t level, uint32_t *count, uint32_t unknown1, uint32_t unknown2);
-NTSTATUS _lsa_LSAROPENPOLICYSCE(pipes_struct *p);
-NTSTATUS _lsa_LSARADTREGISTERSECURITYEVENTSOURCE(pipes_struct *p);
-NTSTATUS _lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(pipes_struct *p);
-NTSTATUS _lsa_LSARADTREPORTSECURITYEVENT(pipes_struct *p);
+NTSTATUS _lsa_Close(pipes_struct *p, struct lsa_Close *r);
+NTSTATUS _lsa_Delete(pipes_struct *p, struct lsa_Delete *r);
+NTSTATUS _lsa_EnumPrivs(pipes_struct *p, struct lsa_EnumPrivs *r);
+NTSTATUS _lsa_QuerySecurity(pipes_struct *p, struct lsa_QuerySecurity *r);
+NTSTATUS _lsa_SetSecObj(pipes_struct *p, struct lsa_SetSecObj *r);
+NTSTATUS _lsa_ChangePassword(pipes_struct *p, struct lsa_ChangePassword *r);
+NTSTATUS _lsa_OpenPolicy(pipes_struct *p, struct lsa_OpenPolicy *r);
+NTSTATUS _lsa_QueryInfoPolicy(pipes_struct *p, struct lsa_QueryInfoPolicy *r);
+NTSTATUS _lsa_SetInfoPolicy(pipes_struct *p, struct lsa_SetInfoPolicy *r);
+NTSTATUS _lsa_ClearAuditLog(pipes_struct *p, struct lsa_ClearAuditLog *r);
+NTSTATUS _lsa_CreateAccount(pipes_struct *p, struct lsa_CreateAccount *r);
+NTSTATUS _lsa_EnumAccounts(pipes_struct *p, struct lsa_EnumAccounts *r);
+NTSTATUS _lsa_CreateTrustedDomain(pipes_struct *p, struct lsa_CreateTrustedDomain *r);
+NTSTATUS _lsa_EnumTrustDom(pipes_struct *p, struct lsa_EnumTrustDom *r);
+NTSTATUS _lsa_LookupNames(pipes_struct *p, struct lsa_LookupNames *r);
+NTSTATUS _lsa_LookupSids(pipes_struct *p, struct lsa_LookupSids *r);
+NTSTATUS _lsa_CreateSecret(pipes_struct *p, struct lsa_CreateSecret *r);
+NTSTATUS _lsa_OpenAccount(pipes_struct *p, struct lsa_OpenAccount *r);
+NTSTATUS _lsa_EnumPrivsAccount(pipes_struct *p, struct lsa_EnumPrivsAccount *r);
+NTSTATUS _lsa_AddPrivilegesToAccount(pipes_struct *p, struct lsa_AddPrivilegesToAccount *r);
+NTSTATUS _lsa_RemovePrivilegesFromAccount(pipes_struct *p, struct lsa_RemovePrivilegesFromAccount *r);
+NTSTATUS _lsa_GetQuotasForAccount(pipes_struct *p, struct lsa_GetQuotasForAccount *r);
+NTSTATUS _lsa_SetQuotasForAccount(pipes_struct *p, struct lsa_SetQuotasForAccount *r);
+NTSTATUS _lsa_GetSystemAccessAccount(pipes_struct *p, struct lsa_GetSystemAccessAccount *r);
+NTSTATUS _lsa_SetSystemAccessAccount(pipes_struct *p, struct lsa_SetSystemAccessAccount *r);
+NTSTATUS _lsa_OpenTrustedDomain(pipes_struct *p, struct lsa_OpenTrustedDomain *r);
+NTSTATUS _lsa_QueryTrustedDomainInfo(pipes_struct *p, struct lsa_QueryTrustedDomainInfo *r);
+NTSTATUS _lsa_SetInformationTrustedDomain(pipes_struct *p, struct lsa_SetInformationTrustedDomain *r);
+NTSTATUS _lsa_OpenSecret(pipes_struct *p, struct lsa_OpenSecret *r);
+NTSTATUS _lsa_SetSecret(pipes_struct *p, struct lsa_SetSecret *r);
+NTSTATUS _lsa_QuerySecret(pipes_struct *p, struct lsa_QuerySecret *r);
+NTSTATUS _lsa_LookupPrivValue(pipes_struct *p, struct lsa_LookupPrivValue *r);
+NTSTATUS _lsa_LookupPrivName(pipes_struct *p, struct lsa_LookupPrivName *r);
+NTSTATUS _lsa_LookupPrivDisplayName(pipes_struct *p, struct lsa_LookupPrivDisplayName *r);
+NTSTATUS _lsa_DeleteObject(pipes_struct *p, struct lsa_DeleteObject *r);
+NTSTATUS _lsa_EnumAccountsWithUserRight(pipes_struct *p, struct lsa_EnumAccountsWithUserRight *r);
+NTSTATUS _lsa_EnumAccountRights(pipes_struct *p, struct lsa_EnumAccountRights *r);
+NTSTATUS _lsa_AddAccountRights(pipes_struct *p, struct lsa_AddAccountRights *r);
+NTSTATUS _lsa_RemoveAccountRights(pipes_struct *p, struct lsa_RemoveAccountRights *r);
+NTSTATUS _lsa_QueryTrustedDomainInfoBySid(pipes_struct *p, struct lsa_QueryTrustedDomainInfoBySid *r);
+NTSTATUS _lsa_SetTrustedDomainInfo(pipes_struct *p, struct lsa_SetTrustedDomainInfo *r);
+NTSTATUS _lsa_DeleteTrustedDomain(pipes_struct *p, struct lsa_DeleteTrustedDomain *r);
+NTSTATUS _lsa_StorePrivateData(pipes_struct *p, struct lsa_StorePrivateData *r);
+NTSTATUS _lsa_RetrievePrivateData(pipes_struct *p, struct lsa_RetrievePrivateData *r);
+NTSTATUS _lsa_OpenPolicy2(pipes_struct *p, struct lsa_OpenPolicy2 *r);
+NTSTATUS _lsa_GetUserName(pipes_struct *p, struct lsa_GetUserName *r);
+NTSTATUS _lsa_QueryInfoPolicy2(pipes_struct *p, struct lsa_QueryInfoPolicy2 *r);
+NTSTATUS _lsa_SetInfoPolicy2(pipes_struct *p, struct lsa_SetInfoPolicy2 *r);
+NTSTATUS _lsa_QueryTrustedDomainInfoByName(pipes_struct *p, struct lsa_QueryTrustedDomainInfoByName *r);
+NTSTATUS _lsa_SetTrustedDomainInfoByName(pipes_struct *p, struct lsa_SetTrustedDomainInfoByName *r);
+NTSTATUS _lsa_EnumTrustedDomainsEx(pipes_struct *p, struct lsa_EnumTrustedDomainsEx *r);
+NTSTATUS _lsa_CreateTrustedDomainEx(pipes_struct *p, struct lsa_CreateTrustedDomainEx *r);
+NTSTATUS _lsa_CloseTrustedDomainEx(pipes_struct *p, struct lsa_CloseTrustedDomainEx *r);
+NTSTATUS _lsa_QueryDomainInformationPolicy(pipes_struct *p, struct lsa_QueryDomainInformationPolicy *r);
+NTSTATUS _lsa_SetDomainInformationPolicy(pipes_struct *p, struct lsa_SetDomainInformationPolicy *r);
+NTSTATUS _lsa_OpenTrustedDomainByName(pipes_struct *p, struct lsa_OpenTrustedDomainByName *r);
+NTSTATUS _lsa_TestCall(pipes_struct *p, struct lsa_TestCall *r);
+NTSTATUS _lsa_LookupSids2(pipes_struct *p, struct lsa_LookupSids2 *r);
+NTSTATUS _lsa_LookupNames2(pipes_struct *p, struct lsa_LookupNames2 *r);
+NTSTATUS _lsa_CreateTrustedDomainEx2(pipes_struct *p, struct lsa_CreateTrustedDomainEx2 *r);
+NTSTATUS _lsa_CREDRWRITE(pipes_struct *p, struct lsa_CREDRWRITE *r);
+NTSTATUS _lsa_CREDRREAD(pipes_struct *p, struct lsa_CREDRREAD *r);
+NTSTATUS _lsa_CREDRENUMERATE(pipes_struct *p, struct lsa_CREDRENUMERATE *r);
+NTSTATUS _lsa_CREDRWRITEDOMAINCREDENTIALS(pipes_struct *p, struct lsa_CREDRWRITEDOMAINCREDENTIALS *r);
+NTSTATUS _lsa_CREDRREADDOMAINCREDENTIALS(pipes_struct *p, struct lsa_CREDRREADDOMAINCREDENTIALS *r);
+NTSTATUS _lsa_CREDRDELETE(pipes_struct *p, struct lsa_CREDRDELETE *r);
+NTSTATUS _lsa_CREDRGETTARGETINFO(pipes_struct *p, struct lsa_CREDRGETTARGETINFO *r);
+NTSTATUS _lsa_CREDRPROFILELOADED(pipes_struct *p, struct lsa_CREDRPROFILELOADED *r);
+NTSTATUS _lsa_LookupNames3(pipes_struct *p, struct lsa_LookupNames3 *r);
+NTSTATUS _lsa_CREDRGETSESSIONTYPES(pipes_struct *p, struct lsa_CREDRGETSESSIONTYPES *r);
+NTSTATUS _lsa_LSARREGISTERAUDITEVENT(pipes_struct *p, struct lsa_LSARREGISTERAUDITEVENT *r);
+NTSTATUS _lsa_LSARGENAUDITEVENT(pipes_struct *p, struct lsa_LSARGENAUDITEVENT *r);
+NTSTATUS _lsa_LSARUNREGISTERAUDITEVENT(pipes_struct *p, struct lsa_LSARUNREGISTERAUDITEVENT *r);
+NTSTATUS _lsa_LSARQUERYFORESTTRUSTINFORMATION(pipes_struct *p, struct lsa_LSARQUERYFORESTTRUSTINFORMATION *r);
+NTSTATUS _lsa_LSARSETFORESTTRUSTINFORMATION(pipes_struct *p, struct lsa_LSARSETFORESTTRUSTINFORMATION *r);
+NTSTATUS _lsa_CREDRRENAME(pipes_struct *p, struct lsa_CREDRRENAME *r);
+NTSTATUS _lsa_LookupSids3(pipes_struct *p, struct lsa_LookupSids3 *r);
+NTSTATUS _lsa_LookupNames4(pipes_struct *p, struct lsa_LookupNames4 *r);
+NTSTATUS _lsa_LSAROPENPOLICYSCE(pipes_struct *p, struct lsa_LSAROPENPOLICYSCE *r);
+NTSTATUS _lsa_LSARADTREGISTERSECURITYEVENTSOURCE(pipes_struct *p, struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r);
+NTSTATUS _lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(pipes_struct *p, struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r);
+NTSTATUS _lsa_LSARADTREPORTSECURITYEVENT(pipes_struct *p, struct lsa_LSARADTREPORTSECURITYEVENT *r);
void lsarpc_get_pipe_fns(struct api_struct **fns, int *n_fns);
NTSTATUS rpc_lsarpc_init(void);
#endif /* __SRV_LSARPC__ */
return False;
}
- r.out.result = _netr_LogonUasLogon(p, r.in.server_name, r.in.account_name, r.in.workstation, r.out.info);
+ r.out.result = _netr_LogonUasLogon(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _netr_LogonUasLogoff(p, r.in.server_name, r.in.account_name, r.in.workstation, r.out.info);
+ r.out.result = _netr_LogonUasLogoff(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _netr_LogonSamLogon(p, r.in.server_name, r.in.computer_name, r.in.credential, r.in.return_authenticator, r.in.logon_level, r.in.logon, r.in.validation_level, r.out.validation, r.out.authoritative);
+ r.out.result = _netr_LogonSamLogon(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
ZERO_STRUCT(r.out);
r.out.return_authenticator = r.in.return_authenticator;
- r.out.result = _netr_LogonSamLogoff(p, r.in.server_name, r.in.computer_name, r.in.credential, r.in.return_authenticator, r.in.logon_level, r.in.logon);
+ r.out.result = _netr_LogonSamLogoff(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
ZERO_STRUCT(r.out);
r.out.credentials = r.in.credentials;
- r.out.result = _netr_ServerReqChallenge(p, r.in.server_name, r.in.computer_name, r.in.credentials);
+ r.out.result = _netr_ServerReqChallenge(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
ZERO_STRUCT(r.out);
r.out.credentials = r.in.credentials;
- r.out.result = _netr_ServerAuthenticate(p, r.in.server_name, r.in.account_name, r.in.secure_channel_type, r.in.computer_name, r.in.credentials);
+ r.out.result = _netr_ServerAuthenticate(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _netr_ServerPasswordSet(p, r.in.server_name, r.in.account_name, r.in.secure_channel_type, r.in.computer_name, r.in.credential, r.in.new_password, r.out.return_authenticator);
+ r.out.result = _netr_ServerPasswordSet(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _netr_DatabaseDeltas(p, r.in.logon_server, r.in.computername, r.in.credential, r.in.return_authenticator, r.in.database_id, r.in.sequence_num, r.in.preferredmaximumlength, r.out.delta_enum_array);
+ r.out.result = _netr_DatabaseDeltas(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _netr_DatabaseSync(p, r.in.logon_server, r.in.computername, r.in.credential, r.in.return_authenticator, r.in.database_id, r.in.sync_context, r.in.preferredmaximumlength, r.out.delta_enum_array);
+ r.out.result = _netr_DatabaseSync(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _netr_AccountDeltas(p, r.in.logon_server, r.in.computername, r.in.credential, r.in.return_authenticator, r.in.uas, r.in.count, r.in.level, r.in.buffersize, r.out.buffer, r.out.count_returned, r.out.total_entries, r.out.recordid);
+ r.out.result = _netr_AccountDeltas(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
}
r.out.recordid = r.in.recordid;
- r.out.result = _netr_AccountSync(p, r.in.logon_server, r.in.computername, r.in.credential, r.in.return_authenticator, r.in.reference, r.in.level, r.in.buffersize, r.out.buffer, r.out.count_returned, r.out.total_entries, r.out.next_reference, r.in.recordid);
+ r.out.result = _netr_AccountSync(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _netr_GetDcName(p, r.in.logon_server, r.in.domainname, r.out.dcname);
+ r.out.result = _netr_GetDcName(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _netr_LogonControl(p, r.in.logon_server, r.in.function_code, r.in.level, r.out.info);
+ r.out.result = _netr_LogonControl(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _netr_GetAnyDCName(p, r.in.logon_server, r.in.domainname, r.out.dcname);
+ r.out.result = _netr_GetAnyDCName(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _netr_LogonControl2(p, r.in.logon_server, r.in.function_code, r.in.level, r.in.data, r.out.query);
+ r.out.result = _netr_LogonControl2(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
ZERO_STRUCT(r.out);
r.out.credentials = r.in.credentials;
r.out.negotiate_flags = r.in.negotiate_flags;
- r.out.result = _netr_ServerAuthenticate2(p, r.in.server_name, r.in.account_name, r.in.secure_channel_type, r.in.computer_name, r.in.credentials, r.in.negotiate_flags);
+ r.out.result = _netr_ServerAuthenticate2(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _netr_DatabaseSync2(p, r.in.logon_server, r.in.computername, r.in.credential, r.in.return_authenticator, r.in.database_id, r.in.restart_state, r.in.sync_context, r.in.preferredmaximumlength, r.out.delta_enum_array);
+ r.out.result = _netr_DatabaseSync2(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _netr_DatabaseRedo(p, r.in.logon_server, r.in.computername, r.in.credential, r.in.return_authenticator, r.in.change_log_entry, r.in.change_log_entry_size, r.out.delta_enum_array);
+ r.out.result = _netr_DatabaseRedo(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _netr_LogonControl2Ex(p, r.in.logon_server, r.in.function_code, r.in.level, r.in.data, r.out.query);
+ r.out.result = _netr_LogonControl2Ex(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(netr_NETRENUMERATETRUSTEDDOMAINS, &r);
- r.out.result = _netr_NETRENUMERATETRUSTEDDOMAINS(p);
+ r.out.result = _netr_NETRENUMERATETRUSTEDDOMAINS(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _netr_DsRGetDCName(p, r.in.server_unc, r.in.domain_name, r.in.domain_guid, r.in.site_guid, r.in.flags, r.out.info);
+ r.out.result = _netr_DsRGetDCName(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(netr_NETRLOGONDUMMYROUTINE1, &r);
- r.out.result = _netr_NETRLOGONDUMMYROUTINE1(p);
+ r.out.result = _netr_NETRLOGONDUMMYROUTINE1(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(netr_NETRLOGONSETSERVICEBITS, &r);
- r.out.result = _netr_NETRLOGONSETSERVICEBITS(p);
+ r.out.result = _netr_NETRLOGONSETSERVICEBITS(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(netr_NETRLOGONGETTRUSTRID, &r);
- r.out.result = _netr_NETRLOGONGETTRUSTRID(p);
+ r.out.result = _netr_NETRLOGONGETTRUSTRID(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(netr_NETRLOGONCOMPUTESERVERDIGEST, &r);
- r.out.result = _netr_NETRLOGONCOMPUTESERVERDIGEST(p);
+ r.out.result = _netr_NETRLOGONCOMPUTESERVERDIGEST(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(netr_NETRLOGONCOMPUTECLIENTDIGEST, &r);
- r.out.result = _netr_NETRLOGONCOMPUTECLIENTDIGEST(p);
+ r.out.result = _netr_NETRLOGONCOMPUTECLIENTDIGEST(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _netr_ServerAuthenticate3(p, r.in.server_name, r.in.account_name, r.in.secure_channel_type, r.in.computer_name, r.in.credentials, r.in.negotiate_flags, r.out.rid);
+ r.out.result = _netr_ServerAuthenticate3(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _netr_DsRGetDCNameEx(p, r.in.server_unc, r.in.domain_name, r.in.domain_guid, r.in.site_name, r.in.flags, r.out.info);
+ r.out.result = _netr_DsRGetDCNameEx(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _netr_DsRGetSiteName(p, r.in.computer_name, r.out.site);
+ r.out.result = _netr_DsRGetSiteName(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _netr_LogonGetDomainInfo(p, r.in.server_name, r.in.computer_name, r.in.credential, r.in.return_authenticator, r.in.level, r.in.query, r.out.info);
+ r.out.result = _netr_LogonGetDomainInfo(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _netr_ServerPasswordSet2(p, r.in.server_name, r.in.account_name, r.in.secure_channel_type, r.in.computer_name, r.in.credential, r.in.new_password, r.out.return_authenticator);
+ r.out.result = _netr_ServerPasswordSet2(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(netr_NETRSERVERPASSWORDGET, &r);
- r.out.result = _netr_NETRSERVERPASSWORDGET(p);
+ r.out.result = _netr_NETRSERVERPASSWORDGET(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(netr_NETRLOGONSENDTOSAM, &r);
- r.out.result = _netr_NETRLOGONSENDTOSAM(p);
+ r.out.result = _netr_NETRLOGONSENDTOSAM(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(netr_DSRADDRESSTOSITENAMESW, &r);
- r.out.result = _netr_DSRADDRESSTOSITENAMESW(p);
+ r.out.result = _netr_DSRADDRESSTOSITENAMESW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _netr_DsRGetDCNameEx2(p, r.in.server_unc, r.in.client_account, r.in.mask, r.in.domain_name, r.in.domain_guid, r.in.site_name, r.in.flags, r.out.info);
+ r.out.result = _netr_DsRGetDCNameEx2(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN, &r);
- r.out.result = _netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN(p);
+ r.out.result = _netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(netr_NETRENUMERATETRUSTEDDOMAINSEX, &r);
- r.out.result = _netr_NETRENUMERATETRUSTEDDOMAINSEX(p);
+ r.out.result = _netr_NETRENUMERATETRUSTEDDOMAINSEX(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(netr_DSRADDRESSTOSITENAMESEXW, &r);
- r.out.result = _netr_DSRADDRESSTOSITENAMESEXW(p);
+ r.out.result = _netr_DSRADDRESSTOSITENAMESEXW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(netr_DSRGETDCSITECOVERAGEW, &r);
- r.out.result = _netr_DSRGETDCSITECOVERAGEW(p);
+ r.out.result = _netr_DSRGETDCSITECOVERAGEW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
}
r.out.flags = r.in.flags;
- r.out.result = _netr_LogonSamLogonEx(p, r.in.server_name, r.in.computer_name, r.in.logon_level, r.in.logon, r.in.validation_level, r.out.validation, r.out.authoritative, r.in.flags);
+ r.out.result = _netr_LogonSamLogonEx(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _netr_DsrEnumerateDomainTrusts(p, r.in.server_name, r.in.trust_flags, r.out.count, r.out.trusts);
+ r.out.result = _netr_DsrEnumerateDomainTrusts(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(netr_DSRDEREGISTERDNSHOSTRECORDS, &r);
- r.out.result = _netr_DSRDEREGISTERDNSHOSTRECORDS(p);
+ r.out.result = _netr_DSRDEREGISTERDNSHOSTRECORDS(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(netr_NETRSERVERTRUSTPASSWORDSGET, &r);
- r.out.result = _netr_NETRSERVERTRUSTPASSWORDSGET(p);
+ r.out.result = _netr_NETRSERVERTRUSTPASSWORDSGET(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(netr_DSRGETFORESTTRUSTINFORMATION, &r);
- r.out.result = _netr_DSRGETFORESTTRUSTINFORMATION(p);
+ r.out.result = _netr_DSRGETFORESTTRUSTINFORMATION(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(netr_NETRGETFORESTTRUSTINFORMATION, &r);
- r.out.result = _netr_NETRGETFORESTTRUSTINFORMATION(p);
+ r.out.result = _netr_NETRGETFORESTTRUSTINFORMATION(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
}
r.out.flags = r.in.flags;
- r.out.result = _netr_LogonSamLogonWithFlags(p, r.in.server_name, r.in.computer_name, r.in.credential, r.in.return_authenticator, r.in.logon_level, r.in.logon, r.in.validation_level, r.out.validation, r.out.authoritative, r.in.flags);
+ r.out.result = _netr_LogonSamLogonWithFlags(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(netr_NETRSERVERGETTRUSTINFO, &r);
- r.out.result = _netr_NETRSERVERGETTRUSTINFO(p);
+ r.out.result = _netr_NETRSERVERGETTRUSTINFO(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
#include "librpc/gen_ndr/ndr_netlogon.h"
#ifndef __SRV_NETLOGON__
#define __SRV_NETLOGON__
-WERROR _netr_LogonUasLogon(pipes_struct *p, const char *server_name, const char *account_name, const char *workstation, struct netr_UasInfo *info);
-WERROR _netr_LogonUasLogoff(pipes_struct *p, const char *server_name, const char *account_name, const char *workstation, struct netr_UasLogoffInfo *info);
-NTSTATUS _netr_LogonSamLogon(pipes_struct *p, const char *server_name, const char *computer_name, struct netr_Authenticator *credential, struct netr_Authenticator *return_authenticator, uint16_t logon_level, union netr_LogonLevel logon, uint16_t validation_level, union netr_Validation *validation, uint8_t *authoritative);
-NTSTATUS _netr_LogonSamLogoff(pipes_struct *p, const char *server_name, const char *computer_name, struct netr_Authenticator *credential, struct netr_Authenticator *return_authenticator, uint16_t logon_level, union netr_LogonLevel logon);
-NTSTATUS _netr_ServerReqChallenge(pipes_struct *p, const char *server_name, const char *computer_name, struct netr_Credential *credentials);
-NTSTATUS _netr_ServerAuthenticate(pipes_struct *p, const char *server_name, const char *account_name, enum netr_SchannelType secure_channel_type, const char *computer_name, struct netr_Credential *credentials);
-NTSTATUS _netr_ServerPasswordSet(pipes_struct *p, const char *server_name, const char *account_name, enum netr_SchannelType secure_channel_type, const char *computer_name, struct netr_Authenticator credential, struct samr_Password new_password, struct netr_Authenticator *return_authenticator);
-NTSTATUS _netr_DatabaseDeltas(pipes_struct *p, const char *logon_server, const char *computername, struct netr_Authenticator credential, struct netr_Authenticator *return_authenticator, enum netr_SamDatabaseID database_id, uint64_t *sequence_num, uint32_t preferredmaximumlength, struct netr_DELTA_ENUM_ARRAY *delta_enum_array);
-NTSTATUS _netr_DatabaseSync(pipes_struct *p, const char *logon_server, const char *computername, struct netr_Authenticator credential, struct netr_Authenticator *return_authenticator, enum netr_SamDatabaseID database_id, uint32_t *sync_context, uint32_t preferredmaximumlength, struct netr_DELTA_ENUM_ARRAY *delta_enum_array);
-NTSTATUS _netr_AccountDeltas(pipes_struct *p, const char *logon_server, const char *computername, struct netr_Authenticator credential, struct netr_Authenticator *return_authenticator, struct netr_UAS_INFO_0 uas, uint32_t count, uint32_t level, uint32_t buffersize, struct netr_AccountBuffer *buffer, uint32_t *count_returned, uint32_t *total_entries, struct netr_UAS_INFO_0 *recordid);
-NTSTATUS _netr_AccountSync(pipes_struct *p, const char *logon_server, const char *computername, struct netr_Authenticator credential, struct netr_Authenticator *return_authenticator, uint32_t reference, uint32_t level, uint32_t buffersize, struct netr_AccountBuffer *buffer, uint32_t *count_returned, uint32_t *total_entries, uint32_t *next_reference, struct netr_UAS_INFO_0 *recordid);
-NTSTATUS _netr_GetDcName(pipes_struct *p, const char *logon_server, const char *domainname, const char **dcname);
-WERROR _netr_LogonControl(pipes_struct *p, const char *logon_server, enum netr_LogonControlCode function_code, uint32_t level, union netr_CONTROL_QUERY_INFORMATION *info);
-WERROR _netr_GetAnyDCName(pipes_struct *p, const char *logon_server, const char *domainname, const char **dcname);
-WERROR _netr_LogonControl2(pipes_struct *p, const char *logon_server, uint32_t function_code, uint32_t level, union netr_CONTROL_DATA_INFORMATION data, union netr_CONTROL_QUERY_INFORMATION *query);
-NTSTATUS _netr_ServerAuthenticate2(pipes_struct *p, const char *server_name, const char *account_name, enum netr_SchannelType secure_channel_type, const char *computer_name, struct netr_Credential *credentials, uint32_t *negotiate_flags);
-NTSTATUS _netr_DatabaseSync2(pipes_struct *p, const char *logon_server, const char *computername, struct netr_Authenticator credential, struct netr_Authenticator *return_authenticator, enum netr_SamDatabaseID database_id, uint16_t restart_state, uint32_t *sync_context, uint32_t preferredmaximumlength, struct netr_DELTA_ENUM_ARRAY *delta_enum_array);
-NTSTATUS _netr_DatabaseRedo(pipes_struct *p, const char *logon_server, const char *computername, struct netr_Authenticator credential, struct netr_Authenticator *return_authenticator, uint8_t *change_log_entry, uint32_t change_log_entry_size, struct netr_DELTA_ENUM_ARRAY *delta_enum_array);
-WERROR _netr_LogonControl2Ex(pipes_struct *p, const char *logon_server, uint32_t function_code, uint32_t level, union netr_CONTROL_DATA_INFORMATION data, union netr_CONTROL_QUERY_INFORMATION *query);
-WERROR _netr_NETRENUMERATETRUSTEDDOMAINS(pipes_struct *p);
-WERROR _netr_DsRGetDCName(pipes_struct *p, const char *server_unc, const char *domain_name, struct GUID *domain_guid, struct GUID *site_guid, uint32_t flags, struct netr_DsRGetDCNameInfo *info);
-WERROR _netr_NETRLOGONDUMMYROUTINE1(pipes_struct *p);
-WERROR _netr_NETRLOGONSETSERVICEBITS(pipes_struct *p);
-WERROR _netr_NETRLOGONGETTRUSTRID(pipes_struct *p);
-WERROR _netr_NETRLOGONCOMPUTESERVERDIGEST(pipes_struct *p);
-WERROR _netr_NETRLOGONCOMPUTECLIENTDIGEST(pipes_struct *p);
-NTSTATUS _netr_ServerAuthenticate3(pipes_struct *p, const char *server_name, const char *account_name, enum netr_SchannelType secure_channel_type, const char *computer_name, struct netr_Credential *credentials, uint32_t *negotiate_flags, uint32_t *rid);
-WERROR _netr_DsRGetDCNameEx(pipes_struct *p, const char *server_unc, const char *domain_name, struct GUID *domain_guid, const char *site_name, uint32_t flags, struct netr_DsRGetDCNameInfo *info);
-WERROR _netr_DsRGetSiteName(pipes_struct *p, const char *computer_name, const char **site);
-NTSTATUS _netr_LogonGetDomainInfo(pipes_struct *p, const char *server_name, const char *computer_name, struct netr_Authenticator *credential, struct netr_Authenticator *return_authenticator, uint32_t level, union netr_DomainQuery query, union netr_DomainInfo *info);
-NTSTATUS _netr_ServerPasswordSet2(pipes_struct *p, const char *server_name, const char *account_name, enum netr_SchannelType secure_channel_type, const char *computer_name, struct netr_Authenticator credential, struct netr_CryptPassword new_password, struct netr_Authenticator *return_authenticator);
-WERROR _netr_NETRSERVERPASSWORDGET(pipes_struct *p);
-WERROR _netr_NETRLOGONSENDTOSAM(pipes_struct *p);
-WERROR _netr_DSRADDRESSTOSITENAMESW(pipes_struct *p);
-WERROR _netr_DsRGetDCNameEx2(pipes_struct *p, const char *server_unc, const char *client_account, uint32_t mask, const char *domain_name, struct GUID *domain_guid, const char *site_name, uint32_t flags, struct netr_DsRGetDCNameInfo *info);
-WERROR _netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN(pipes_struct *p);
-WERROR _netr_NETRENUMERATETRUSTEDDOMAINSEX(pipes_struct *p);
-WERROR _netr_DSRADDRESSTOSITENAMESEXW(pipes_struct *p);
-WERROR _netr_DSRGETDCSITECOVERAGEW(pipes_struct *p);
-NTSTATUS _netr_LogonSamLogonEx(pipes_struct *p, const char *server_name, const char *computer_name, uint16_t logon_level, union netr_LogonLevel logon, uint16_t validation_level, union netr_Validation *validation, uint8_t *authoritative, uint32_t *flags);
-WERROR _netr_DsrEnumerateDomainTrusts(pipes_struct *p, const char *server_name, uint32_t trust_flags, uint32_t *count, struct netr_DomainTrust **trusts);
-WERROR _netr_DSRDEREGISTERDNSHOSTRECORDS(pipes_struct *p);
-WERROR _netr_NETRSERVERTRUSTPASSWORDSGET(pipes_struct *p);
-WERROR _netr_DSRGETFORESTTRUSTINFORMATION(pipes_struct *p);
-WERROR _netr_NETRGETFORESTTRUSTINFORMATION(pipes_struct *p);
-NTSTATUS _netr_LogonSamLogonWithFlags(pipes_struct *p, const char *server_name, const char *computer_name, struct netr_Authenticator *credential, struct netr_Authenticator *return_authenticator, uint16_t logon_level, union netr_LogonLevel logon, uint16_t validation_level, union netr_Validation *validation, uint8_t *authoritative, uint32_t *flags);
-WERROR _netr_NETRSERVERGETTRUSTINFO(pipes_struct *p);
+WERROR _netr_LogonUasLogon(pipes_struct *p, struct netr_LogonUasLogon *r);
+WERROR _netr_LogonUasLogoff(pipes_struct *p, struct netr_LogonUasLogoff *r);
+NTSTATUS _netr_LogonSamLogon(pipes_struct *p, struct netr_LogonSamLogon *r);
+NTSTATUS _netr_LogonSamLogoff(pipes_struct *p, struct netr_LogonSamLogoff *r);
+NTSTATUS _netr_ServerReqChallenge(pipes_struct *p, struct netr_ServerReqChallenge *r);
+NTSTATUS _netr_ServerAuthenticate(pipes_struct *p, struct netr_ServerAuthenticate *r);
+NTSTATUS _netr_ServerPasswordSet(pipes_struct *p, struct netr_ServerPasswordSet *r);
+NTSTATUS _netr_DatabaseDeltas(pipes_struct *p, struct netr_DatabaseDeltas *r);
+NTSTATUS _netr_DatabaseSync(pipes_struct *p, struct netr_DatabaseSync *r);
+NTSTATUS _netr_AccountDeltas(pipes_struct *p, struct netr_AccountDeltas *r);
+NTSTATUS _netr_AccountSync(pipes_struct *p, struct netr_AccountSync *r);
+NTSTATUS _netr_GetDcName(pipes_struct *p, struct netr_GetDcName *r);
+WERROR _netr_LogonControl(pipes_struct *p, struct netr_LogonControl *r);
+WERROR _netr_GetAnyDCName(pipes_struct *p, struct netr_GetAnyDCName *r);
+WERROR _netr_LogonControl2(pipes_struct *p, struct netr_LogonControl2 *r);
+NTSTATUS _netr_ServerAuthenticate2(pipes_struct *p, struct netr_ServerAuthenticate2 *r);
+NTSTATUS _netr_DatabaseSync2(pipes_struct *p, struct netr_DatabaseSync2 *r);
+NTSTATUS _netr_DatabaseRedo(pipes_struct *p, struct netr_DatabaseRedo *r);
+WERROR _netr_LogonControl2Ex(pipes_struct *p, struct netr_LogonControl2Ex *r);
+WERROR _netr_NETRENUMERATETRUSTEDDOMAINS(pipes_struct *p, struct netr_NETRENUMERATETRUSTEDDOMAINS *r);
+WERROR _netr_DsRGetDCName(pipes_struct *p, struct netr_DsRGetDCName *r);
+WERROR _netr_NETRLOGONDUMMYROUTINE1(pipes_struct *p, struct netr_NETRLOGONDUMMYROUTINE1 *r);
+WERROR _netr_NETRLOGONSETSERVICEBITS(pipes_struct *p, struct netr_NETRLOGONSETSERVICEBITS *r);
+WERROR _netr_NETRLOGONGETTRUSTRID(pipes_struct *p, struct netr_NETRLOGONGETTRUSTRID *r);
+WERROR _netr_NETRLOGONCOMPUTESERVERDIGEST(pipes_struct *p, struct netr_NETRLOGONCOMPUTESERVERDIGEST *r);
+WERROR _netr_NETRLOGONCOMPUTECLIENTDIGEST(pipes_struct *p, struct netr_NETRLOGONCOMPUTECLIENTDIGEST *r);
+NTSTATUS _netr_ServerAuthenticate3(pipes_struct *p, struct netr_ServerAuthenticate3 *r);
+WERROR _netr_DsRGetDCNameEx(pipes_struct *p, struct netr_DsRGetDCNameEx *r);
+WERROR _netr_DsRGetSiteName(pipes_struct *p, struct netr_DsRGetSiteName *r);
+NTSTATUS _netr_LogonGetDomainInfo(pipes_struct *p, struct netr_LogonGetDomainInfo *r);
+NTSTATUS _netr_ServerPasswordSet2(pipes_struct *p, struct netr_ServerPasswordSet2 *r);
+WERROR _netr_NETRSERVERPASSWORDGET(pipes_struct *p, struct netr_NETRSERVERPASSWORDGET *r);
+WERROR _netr_NETRLOGONSENDTOSAM(pipes_struct *p, struct netr_NETRLOGONSENDTOSAM *r);
+WERROR _netr_DSRADDRESSTOSITENAMESW(pipes_struct *p, struct netr_DSRADDRESSTOSITENAMESW *r);
+WERROR _netr_DsRGetDCNameEx2(pipes_struct *p, struct netr_DsRGetDCNameEx2 *r);
+WERROR _netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN(pipes_struct *p, struct netr_NETRLOGONGETTIMESERVICEPARENTDOMAIN *r);
+WERROR _netr_NETRENUMERATETRUSTEDDOMAINSEX(pipes_struct *p, struct netr_NETRENUMERATETRUSTEDDOMAINSEX *r);
+WERROR _netr_DSRADDRESSTOSITENAMESEXW(pipes_struct *p, struct netr_DSRADDRESSTOSITENAMESEXW *r);
+WERROR _netr_DSRGETDCSITECOVERAGEW(pipes_struct *p, struct netr_DSRGETDCSITECOVERAGEW *r);
+NTSTATUS _netr_LogonSamLogonEx(pipes_struct *p, struct netr_LogonSamLogonEx *r);
+WERROR _netr_DsrEnumerateDomainTrusts(pipes_struct *p, struct netr_DsrEnumerateDomainTrusts *r);
+WERROR _netr_DSRDEREGISTERDNSHOSTRECORDS(pipes_struct *p, struct netr_DSRDEREGISTERDNSHOSTRECORDS *r);
+WERROR _netr_NETRSERVERTRUSTPASSWORDSGET(pipes_struct *p, struct netr_NETRSERVERTRUSTPASSWORDSGET *r);
+WERROR _netr_DSRGETFORESTTRUSTINFORMATION(pipes_struct *p, struct netr_DSRGETFORESTTRUSTINFORMATION *r);
+WERROR _netr_NETRGETFORESTTRUSTINFORMATION(pipes_struct *p, struct netr_NETRGETFORESTTRUSTINFORMATION *r);
+NTSTATUS _netr_LogonSamLogonWithFlags(pipes_struct *p, struct netr_LogonSamLogonWithFlags *r);
+WERROR _netr_NETRSERVERGETTRUSTINFO(pipes_struct *p, struct netr_NETRSERVERGETTRUSTINFO *r);
void netlogon_get_pipe_fns(struct api_struct **fns, int *n_fns);
NTSTATUS rpc_netlogon_init(void);
#endif /* __SRV_NETLOGON__ */
}
r.out.resume_handle = r.in.resume_handle;
- r.out.result = _srvsvc_NetCharDevEnum(p, r.in.server_unc, r.in.level, r.in.ctr, r.in.max_buffer, r.out.totalentries, r.in.resume_handle);
+ r.out.result = _srvsvc_NetCharDevEnum(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _srvsvc_NetCharDevGetInfo(p, r.in.server_unc, r.in.device_name, r.in.level, r.out.info);
+ r.out.result = _srvsvc_NetCharDevGetInfo(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevControl, &r);
- r.out.result = _srvsvc_NetCharDevControl(p, r.in.server_unc, r.in.device_name, r.in.opcode);
+ r.out.result = _srvsvc_NetCharDevControl(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
}
r.out.resume_handle = r.in.resume_handle;
- r.out.result = _srvsvc_NetCharDevQEnum(p, r.in.server_unc, r.in.user, r.in.level, r.in.ctr, r.in.max_buffer, r.out.totalentries, r.in.resume_handle);
+ r.out.result = _srvsvc_NetCharDevQEnum(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _srvsvc_NetCharDevQGetInfo(p, r.in.server_unc, r.in.queue_name, r.in.user, r.in.level, r.out.info);
+ r.out.result = _srvsvc_NetCharDevQGetInfo(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
ZERO_STRUCT(r.out);
r.out.parm_error = r.in.parm_error;
- r.out.result = _srvsvc_NetCharDevQSetInfo(p, r.in.server_unc, r.in.queue_name, r.in.level, r.in.info, r.in.parm_error);
+ r.out.result = _srvsvc_NetCharDevQSetInfo(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQPurge, &r);
- r.out.result = _srvsvc_NetCharDevQPurge(p, r.in.server_unc, r.in.queue_name);
+ r.out.result = _srvsvc_NetCharDevQPurge(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQPurgeSelf, &r);
- r.out.result = _srvsvc_NetCharDevQPurgeSelf(p, r.in.server_unc, r.in.queue_name, r.in.computer_name);
+ r.out.result = _srvsvc_NetCharDevQPurgeSelf(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
}
r.out.resume_handle = r.in.resume_handle;
- r.out.result = _srvsvc_NetConnEnum(p, r.in.server_unc, r.in.path, r.in.level, r.in.ctr, r.in.max_buffer, r.out.totalentries, r.in.resume_handle);
+ r.out.result = _srvsvc_NetConnEnum(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
}
r.out.resume_handle = r.in.resume_handle;
- r.out.result = _srvsvc_NetFileEnum(p, r.in.server_unc, r.in.path, r.in.user, r.in.level, r.in.ctr, r.in.max_buffer, r.out.totalentries, r.in.resume_handle);
+ r.out.result = _srvsvc_NetFileEnum(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _srvsvc_NetFileGetInfo(p, r.in.server_unc, r.in.fid, r.in.level, r.out.info);
+ r.out.result = _srvsvc_NetFileGetInfo(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NetFileClose, &r);
- r.out.result = _srvsvc_NetFileClose(p, r.in.server_unc, r.in.fid);
+ r.out.result = _srvsvc_NetFileClose(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
}
r.out.resume_handle = r.in.resume_handle;
- r.out.result = _srvsvc_NetSessEnum(p, r.in.server_unc, r.in.client, r.in.user, r.in.level, r.in.ctr, r.in.max_buffer, r.out.totalentries, r.in.resume_handle);
+ r.out.result = _srvsvc_NetSessEnum(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NetSessDel, &r);
- r.out.result = _srvsvc_NetSessDel(p, r.in.server_unc, r.in.client, r.in.user);
+ r.out.result = _srvsvc_NetSessDel(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
ZERO_STRUCT(r.out);
r.out.parm_error = r.in.parm_error;
- r.out.result = _srvsvc_NetShareAdd(p, r.in.server_unc, r.in.level, r.in.info, r.in.parm_error);
+ r.out.result = _srvsvc_NetShareAdd(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
}
r.out.resume_handle = r.in.resume_handle;
- r.out.result = _srvsvc_NetShareEnumAll(p, r.in.server_unc, r.in.level, r.in.ctr, r.in.max_buffer, r.out.totalentries, r.in.resume_handle);
+ r.out.result = _srvsvc_NetShareEnumAll(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _srvsvc_NetShareGetInfo(p, r.in.server_unc, r.in.share_name, r.in.level, r.out.info);
+ r.out.result = _srvsvc_NetShareGetInfo(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
ZERO_STRUCT(r.out);
r.out.parm_error = r.in.parm_error;
- r.out.result = _srvsvc_NetShareSetInfo(p, r.in.server_unc, r.in.share_name, r.in.level, r.in.info, r.in.parm_error);
+ r.out.result = _srvsvc_NetShareSetInfo(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NetShareDel, &r);
- r.out.result = _srvsvc_NetShareDel(p, r.in.server_unc, r.in.share_name, r.in.reserved);
+ r.out.result = _srvsvc_NetShareDel(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NetShareDelSticky, &r);
- r.out.result = _srvsvc_NetShareDelSticky(p, r.in.server_unc, r.in.share_name, r.in.reserved);
+ r.out.result = _srvsvc_NetShareDelSticky(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _srvsvc_NetShareCheck(p, r.in.server_unc, r.in.device_name, r.out.type);
+ r.out.result = _srvsvc_NetShareCheck(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _srvsvc_NetSrvGetInfo(p, r.in.server_unc, r.in.level, r.out.info);
+ r.out.result = _srvsvc_NetSrvGetInfo(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
ZERO_STRUCT(r.out);
r.out.parm_error = r.in.parm_error;
- r.out.result = _srvsvc_NetSrvSetInfo(p, r.in.server_unc, r.in.level, r.in.info, r.in.parm_error);
+ r.out.result = _srvsvc_NetSrvSetInfo(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
}
r.out.resume_handle = r.in.resume_handle;
- r.out.result = _srvsvc_NetDiskEnum(p, r.in.server_unc, r.in.level, r.in.info, r.in.maxlen, r.out.totalentries, r.in.resume_handle);
+ r.out.result = _srvsvc_NetDiskEnum(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _srvsvc_NetServerStatisticsGet(p, r.in.server_unc, r.in.service, r.in.level, r.in.options, r.out.stats);
+ r.out.result = _srvsvc_NetServerStatisticsGet(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NetTransportAdd, &r);
- r.out.result = _srvsvc_NetTransportAdd(p, r.in.server_unc, r.in.level, r.in.info);
+ r.out.result = _srvsvc_NetTransportAdd(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
}
r.out.resume_handle = r.in.resume_handle;
- r.out.result = _srvsvc_NetTransportEnum(p, r.in.server_unc, r.in.level, r.in.transports, r.in.max_buffer, r.out.totalentries, r.in.resume_handle);
+ r.out.result = _srvsvc_NetTransportEnum(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NetTransportDel, &r);
- r.out.result = _srvsvc_NetTransportDel(p, r.in.server_unc, r.in.unknown, r.in.transport);
+ r.out.result = _srvsvc_NetTransportDel(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _srvsvc_NetRemoteTOD(p, r.in.server_unc, r.out.info);
+ r.out.result = _srvsvc_NetRemoteTOD(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NetSetServiceBits, &r);
- r.out.result = _srvsvc_NetSetServiceBits(p, r.in.server_unc, r.in.transport, r.in.servicebits, r.in.updateimmediately);
+ r.out.result = _srvsvc_NetSetServiceBits(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _srvsvc_NetPathType(p, r.in.server_unc, r.in.path, r.in.pathflags, r.out.pathtype);
+ r.out.result = _srvsvc_NetPathType(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
}
r.out.pathtype = r.in.pathtype;
- r.out.result = _srvsvc_NetPathCanonicalize(p, r.in.server_unc, r.in.path, r.out.can_path, r.in.maxbuf, r.in.prefix, r.in.pathtype, r.in.pathflags);
+ r.out.result = _srvsvc_NetPathCanonicalize(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NetPathCompare, &r);
- r.out.result = _srvsvc_NetPathCompare(p, r.in.server_unc, r.in.path1, r.in.path2, r.in.pathtype, r.in.pathflags);
+ r.out.result = _srvsvc_NetPathCompare(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NetNameValidate, &r);
- r.out.result = _srvsvc_NetNameValidate(p, r.in.server_unc, r.in.name, r.in.name_type, r.in.flags);
+ r.out.result = _srvsvc_NetNameValidate(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NETRPRNAMECANONICALIZE, &r);
- r.out.result = _srvsvc_NETRPRNAMECANONICALIZE(p);
+ r.out.result = _srvsvc_NETRPRNAMECANONICALIZE(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NetPRNameCompare, &r);
- r.out.result = _srvsvc_NetPRNameCompare(p, r.in.server_unc, r.in.name1, r.in.name2, r.in.name_type, r.in.flags);
+ r.out.result = _srvsvc_NetPRNameCompare(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
}
r.out.resume_handle = r.in.resume_handle;
- r.out.result = _srvsvc_NetShareEnum(p, r.in.server_unc, r.in.level, r.in.ctr, r.in.max_buffer, r.out.totalentries, r.in.resume_handle);
+ r.out.result = _srvsvc_NetShareEnum(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _srvsvc_NetShareDelStart(p, r.in.server_unc, r.in.share, r.in.reserved, r.out.hnd);
+ r.out.result = _srvsvc_NetShareDelStart(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
ZERO_STRUCT(r.out);
r.out.hnd = r.in.hnd;
- r.out.result = _srvsvc_NetShareDelCommit(p, r.in.hnd);
+ r.out.result = _srvsvc_NetShareDelCommit(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _srvsvc_NetGetFileSecurity(p, r.in.server_unc, r.in.share, r.in.file, r.in.securityinformation, r.out.sd_buf);
+ r.out.result = _srvsvc_NetGetFileSecurity(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NetSetFileSecurity, &r);
- r.out.result = _srvsvc_NetSetFileSecurity(p, r.in.server_unc, r.in.share, r.in.file, r.in.securityinformation, r.in.sd_buf);
+ r.out.result = _srvsvc_NetSetFileSecurity(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NetServerTransportAddEx, &r);
- r.out.result = _srvsvc_NetServerTransportAddEx(p, r.in.server_unc, r.in.level, r.in.info);
+ r.out.result = _srvsvc_NetServerTransportAddEx(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NetServerSetServiceBitsEx, &r);
- r.out.result = _srvsvc_NetServerSetServiceBitsEx(p, r.in.server_unc, r.in.emulated_server_unc, r.in.transport, r.in.servicebitsofinterest, r.in.servicebits, r.in.updateimmediately);
+ r.out.result = _srvsvc_NetServerSetServiceBitsEx(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSGETVERSION, &r);
- r.out.result = _srvsvc_NETRDFSGETVERSION(p);
+ r.out.result = _srvsvc_NETRDFSGETVERSION(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSCREATELOCALPARTITION, &r);
- r.out.result = _srvsvc_NETRDFSCREATELOCALPARTITION(p);
+ r.out.result = _srvsvc_NETRDFSCREATELOCALPARTITION(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSDELETELOCALPARTITION, &r);
- r.out.result = _srvsvc_NETRDFSDELETELOCALPARTITION(p);
+ r.out.result = _srvsvc_NETRDFSDELETELOCALPARTITION(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSSETLOCALVOLUMESTATE, &r);
- r.out.result = _srvsvc_NETRDFSSETLOCALVOLUMESTATE(p);
+ r.out.result = _srvsvc_NETRDFSSETLOCALVOLUMESTATE(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSSETSERVERINFO, &r);
- r.out.result = _srvsvc_NETRDFSSETSERVERINFO(p);
+ r.out.result = _srvsvc_NETRDFSSETSERVERINFO(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSCREATEEXITPOINT, &r);
- r.out.result = _srvsvc_NETRDFSCREATEEXITPOINT(p);
+ r.out.result = _srvsvc_NETRDFSCREATEEXITPOINT(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSDELETEEXITPOINT, &r);
- r.out.result = _srvsvc_NETRDFSDELETEEXITPOINT(p);
+ r.out.result = _srvsvc_NETRDFSDELETEEXITPOINT(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSMODIFYPREFIX, &r);
- r.out.result = _srvsvc_NETRDFSMODIFYPREFIX(p);
+ r.out.result = _srvsvc_NETRDFSMODIFYPREFIX(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSFIXLOCALVOLUME, &r);
- r.out.result = _srvsvc_NETRDFSFIXLOCALVOLUME(p);
+ r.out.result = _srvsvc_NETRDFSFIXLOCALVOLUME(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSMANAGERREPORTSITEINFO, &r);
- r.out.result = _srvsvc_NETRDFSMANAGERREPORTSITEINFO(p);
+ r.out.result = _srvsvc_NETRDFSMANAGERREPORTSITEINFO(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(srvsvc_NETRSERVERTRANSPORTDELEX, &r);
- r.out.result = _srvsvc_NETRSERVERTRANSPORTDELEX(p);
+ r.out.result = _srvsvc_NETRSERVERTRANSPORTDELEX(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
#include "librpc/gen_ndr/ndr_srvsvc.h"
#ifndef __SRV_SRVSVC__
#define __SRV_SRVSVC__
-WERROR _srvsvc_NetCharDevEnum(pipes_struct *p, const char *server_unc, uint32_t *level, union srvsvc_NetCharDevCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle);
-WERROR _srvsvc_NetCharDevGetInfo(pipes_struct *p, const char *server_unc, const char *device_name, uint32_t level, union srvsvc_NetCharDevInfo *info);
-WERROR _srvsvc_NetCharDevControl(pipes_struct *p, const char *server_unc, const char *device_name, uint32_t opcode);
-WERROR _srvsvc_NetCharDevQEnum(pipes_struct *p, const char *server_unc, const char *user, uint32_t *level, union srvsvc_NetCharDevQCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle);
-WERROR _srvsvc_NetCharDevQGetInfo(pipes_struct *p, const char *server_unc, const char *queue_name, const char *user, uint32_t level, union srvsvc_NetCharDevQInfo *info);
-WERROR _srvsvc_NetCharDevQSetInfo(pipes_struct *p, const char *server_unc, const char *queue_name, uint32_t level, union srvsvc_NetCharDevQInfo info, uint32_t *parm_error);
-WERROR _srvsvc_NetCharDevQPurge(pipes_struct *p, const char *server_unc, const char *queue_name);
-WERROR _srvsvc_NetCharDevQPurgeSelf(pipes_struct *p, const char *server_unc, const char *queue_name, const char *computer_name);
-WERROR _srvsvc_NetConnEnum(pipes_struct *p, const char *server_unc, const char *path, uint32_t *level, union srvsvc_NetConnCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle);
-WERROR _srvsvc_NetFileEnum(pipes_struct *p, const char *server_unc, const char *path, const char *user, uint32_t *level, union srvsvc_NetFileCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle);
-WERROR _srvsvc_NetFileGetInfo(pipes_struct *p, const char *server_unc, uint32_t fid, uint32_t level, union srvsvc_NetFileInfo *info);
-WERROR _srvsvc_NetFileClose(pipes_struct *p, const char *server_unc, uint32_t fid);
-WERROR _srvsvc_NetSessEnum(pipes_struct *p, const char *server_unc, const char *client, const char *user, uint32_t *level, union srvsvc_NetSessCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle);
-WERROR _srvsvc_NetSessDel(pipes_struct *p, const char *server_unc, const char *client, const char *user);
-WERROR _srvsvc_NetShareAdd(pipes_struct *p, const char *server_unc, uint32_t level, union srvsvc_NetShareInfo info, uint32_t *parm_error);
-WERROR _srvsvc_NetShareEnumAll(pipes_struct *p, const char *server_unc, uint32_t *level, union srvsvc_NetShareCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle);
-WERROR _srvsvc_NetShareGetInfo(pipes_struct *p, const char *server_unc, const char *share_name, uint32_t level, union srvsvc_NetShareInfo *info);
-WERROR _srvsvc_NetShareSetInfo(pipes_struct *p, const char *server_unc, const char *share_name, uint32_t level, union srvsvc_NetShareInfo info, uint32_t *parm_error);
-WERROR _srvsvc_NetShareDel(pipes_struct *p, const char *server_unc, const char *share_name, uint32_t reserved);
-WERROR _srvsvc_NetShareDelSticky(pipes_struct *p, const char *server_unc, const char *share_name, uint32_t reserved);
-WERROR _srvsvc_NetShareCheck(pipes_struct *p, const char *server_unc, const char *device_name, enum srvsvc_ShareType *type);
-WERROR _srvsvc_NetSrvGetInfo(pipes_struct *p, const char *server_unc, uint32_t level, union srvsvc_NetSrvInfo *info);
-WERROR _srvsvc_NetSrvSetInfo(pipes_struct *p, const char *server_unc, uint32_t level, union srvsvc_NetSrvInfo info, uint32_t *parm_error);
-WERROR _srvsvc_NetDiskEnum(pipes_struct *p, const char *server_unc, uint32_t level, struct srvsvc_NetDiskInfo *info, uint32_t maxlen, uint32_t *totalentries, uint32_t *resume_handle);
-WERROR _srvsvc_NetServerStatisticsGet(pipes_struct *p, const char *server_unc, const char *service, uint32_t level, uint32_t options, struct srvsvc_Statistics *stats);
-WERROR _srvsvc_NetTransportAdd(pipes_struct *p, const char *server_unc, uint32_t level, union srvsvc_NetTransportInfo info);
-WERROR _srvsvc_NetTransportEnum(pipes_struct *p, const char *server_unc, uint32_t *level, union srvsvc_NetTransportCtr *transports, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle);
-WERROR _srvsvc_NetTransportDel(pipes_struct *p, const char *server_unc, uint32_t unknown, struct srvsvc_NetTransportInfo0 transport);
-WERROR _srvsvc_NetRemoteTOD(pipes_struct *p, const char *server_unc, struct srvsvc_NetRemoteTODInfo *info);
-WERROR _srvsvc_NetSetServiceBits(pipes_struct *p, const char *server_unc, const char *transport, uint32_t servicebits, uint32_t updateimmediately);
-WERROR _srvsvc_NetPathType(pipes_struct *p, const char *server_unc, const char *path, uint32_t pathflags, uint32_t *pathtype);
-WERROR _srvsvc_NetPathCanonicalize(pipes_struct *p, const char *server_unc, const char *path, uint8_t *can_path, uint32_t maxbuf, const char *prefix, uint32_t *pathtype, uint32_t pathflags);
-WERROR _srvsvc_NetPathCompare(pipes_struct *p, const char *server_unc, const char *path1, const char *path2, uint32_t pathtype, uint32_t pathflags);
-WERROR _srvsvc_NetNameValidate(pipes_struct *p, const char *server_unc, const char *name, uint32_t name_type, uint32_t flags);
-WERROR _srvsvc_NETRPRNAMECANONICALIZE(pipes_struct *p);
-WERROR _srvsvc_NetPRNameCompare(pipes_struct *p, const char *server_unc, const char *name1, const char *name2, uint32_t name_type, uint32_t flags);
-WERROR _srvsvc_NetShareEnum(pipes_struct *p, const char *server_unc, uint32_t *level, union srvsvc_NetShareCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle);
-WERROR _srvsvc_NetShareDelStart(pipes_struct *p, const char *server_unc, const char *share, uint32_t reserved, struct policy_handle *hnd);
-WERROR _srvsvc_NetShareDelCommit(pipes_struct *p, struct policy_handle *hnd);
-WERROR _srvsvc_NetGetFileSecurity(pipes_struct *p, const char *server_unc, const char *share, const char *file, uint32_t securityinformation, struct sec_desc_buf *sd_buf);
-WERROR _srvsvc_NetSetFileSecurity(pipes_struct *p, const char *server_unc, const char *share, const char *file, uint32_t securityinformation, struct sec_desc_buf sd_buf);
-WERROR _srvsvc_NetServerTransportAddEx(pipes_struct *p, const char *server_unc, uint32_t level, union srvsvc_NetTransportInfo info);
-WERROR _srvsvc_NetServerSetServiceBitsEx(pipes_struct *p, const char *server_unc, const char *emulated_server_unc, const char *transport, uint32_t servicebitsofinterest, uint32_t servicebits, uint32_t updateimmediately);
-WERROR _srvsvc_NETRDFSGETVERSION(pipes_struct *p);
-WERROR _srvsvc_NETRDFSCREATELOCALPARTITION(pipes_struct *p);
-WERROR _srvsvc_NETRDFSDELETELOCALPARTITION(pipes_struct *p);
-WERROR _srvsvc_NETRDFSSETLOCALVOLUMESTATE(pipes_struct *p);
-WERROR _srvsvc_NETRDFSSETSERVERINFO(pipes_struct *p);
-WERROR _srvsvc_NETRDFSCREATEEXITPOINT(pipes_struct *p);
-WERROR _srvsvc_NETRDFSDELETEEXITPOINT(pipes_struct *p);
-WERROR _srvsvc_NETRDFSMODIFYPREFIX(pipes_struct *p);
-WERROR _srvsvc_NETRDFSFIXLOCALVOLUME(pipes_struct *p);
-WERROR _srvsvc_NETRDFSMANAGERREPORTSITEINFO(pipes_struct *p);
-WERROR _srvsvc_NETRSERVERTRANSPORTDELEX(pipes_struct *p);
+WERROR _srvsvc_NetCharDevEnum(pipes_struct *p, struct srvsvc_NetCharDevEnum *r);
+WERROR _srvsvc_NetCharDevGetInfo(pipes_struct *p, struct srvsvc_NetCharDevGetInfo *r);
+WERROR _srvsvc_NetCharDevControl(pipes_struct *p, struct srvsvc_NetCharDevControl *r);
+WERROR _srvsvc_NetCharDevQEnum(pipes_struct *p, struct srvsvc_NetCharDevQEnum *r);
+WERROR _srvsvc_NetCharDevQGetInfo(pipes_struct *p, struct srvsvc_NetCharDevQGetInfo *r);
+WERROR _srvsvc_NetCharDevQSetInfo(pipes_struct *p, struct srvsvc_NetCharDevQSetInfo *r);
+WERROR _srvsvc_NetCharDevQPurge(pipes_struct *p, struct srvsvc_NetCharDevQPurge *r);
+WERROR _srvsvc_NetCharDevQPurgeSelf(pipes_struct *p, struct srvsvc_NetCharDevQPurgeSelf *r);
+WERROR _srvsvc_NetConnEnum(pipes_struct *p, struct srvsvc_NetConnEnum *r);
+WERROR _srvsvc_NetFileEnum(pipes_struct *p, struct srvsvc_NetFileEnum *r);
+WERROR _srvsvc_NetFileGetInfo(pipes_struct *p, struct srvsvc_NetFileGetInfo *r);
+WERROR _srvsvc_NetFileClose(pipes_struct *p, struct srvsvc_NetFileClose *r);
+WERROR _srvsvc_NetSessEnum(pipes_struct *p, struct srvsvc_NetSessEnum *r);
+WERROR _srvsvc_NetSessDel(pipes_struct *p, struct srvsvc_NetSessDel *r);
+WERROR _srvsvc_NetShareAdd(pipes_struct *p, struct srvsvc_NetShareAdd *r);
+WERROR _srvsvc_NetShareEnumAll(pipes_struct *p, struct srvsvc_NetShareEnumAll *r);
+WERROR _srvsvc_NetShareGetInfo(pipes_struct *p, struct srvsvc_NetShareGetInfo *r);
+WERROR _srvsvc_NetShareSetInfo(pipes_struct *p, struct srvsvc_NetShareSetInfo *r);
+WERROR _srvsvc_NetShareDel(pipes_struct *p, struct srvsvc_NetShareDel *r);
+WERROR _srvsvc_NetShareDelSticky(pipes_struct *p, struct srvsvc_NetShareDelSticky *r);
+WERROR _srvsvc_NetShareCheck(pipes_struct *p, struct srvsvc_NetShareCheck *r);
+WERROR _srvsvc_NetSrvGetInfo(pipes_struct *p, struct srvsvc_NetSrvGetInfo *r);
+WERROR _srvsvc_NetSrvSetInfo(pipes_struct *p, struct srvsvc_NetSrvSetInfo *r);
+WERROR _srvsvc_NetDiskEnum(pipes_struct *p, struct srvsvc_NetDiskEnum *r);
+WERROR _srvsvc_NetServerStatisticsGet(pipes_struct *p, struct srvsvc_NetServerStatisticsGet *r);
+WERROR _srvsvc_NetTransportAdd(pipes_struct *p, struct srvsvc_NetTransportAdd *r);
+WERROR _srvsvc_NetTransportEnum(pipes_struct *p, struct srvsvc_NetTransportEnum *r);
+WERROR _srvsvc_NetTransportDel(pipes_struct *p, struct srvsvc_NetTransportDel *r);
+WERROR _srvsvc_NetRemoteTOD(pipes_struct *p, struct srvsvc_NetRemoteTOD *r);
+WERROR _srvsvc_NetSetServiceBits(pipes_struct *p, struct srvsvc_NetSetServiceBits *r);
+WERROR _srvsvc_NetPathType(pipes_struct *p, struct srvsvc_NetPathType *r);
+WERROR _srvsvc_NetPathCanonicalize(pipes_struct *p, struct srvsvc_NetPathCanonicalize *r);
+WERROR _srvsvc_NetPathCompare(pipes_struct *p, struct srvsvc_NetPathCompare *r);
+WERROR _srvsvc_NetNameValidate(pipes_struct *p, struct srvsvc_NetNameValidate *r);
+WERROR _srvsvc_NETRPRNAMECANONICALIZE(pipes_struct *p, struct srvsvc_NETRPRNAMECANONICALIZE *r);
+WERROR _srvsvc_NetPRNameCompare(pipes_struct *p, struct srvsvc_NetPRNameCompare *r);
+WERROR _srvsvc_NetShareEnum(pipes_struct *p, struct srvsvc_NetShareEnum *r);
+WERROR _srvsvc_NetShareDelStart(pipes_struct *p, struct srvsvc_NetShareDelStart *r);
+WERROR _srvsvc_NetShareDelCommit(pipes_struct *p, struct srvsvc_NetShareDelCommit *r);
+WERROR _srvsvc_NetGetFileSecurity(pipes_struct *p, struct srvsvc_NetGetFileSecurity *r);
+WERROR _srvsvc_NetSetFileSecurity(pipes_struct *p, struct srvsvc_NetSetFileSecurity *r);
+WERROR _srvsvc_NetServerTransportAddEx(pipes_struct *p, struct srvsvc_NetServerTransportAddEx *r);
+WERROR _srvsvc_NetServerSetServiceBitsEx(pipes_struct *p, struct srvsvc_NetServerSetServiceBitsEx *r);
+WERROR _srvsvc_NETRDFSGETVERSION(pipes_struct *p, struct srvsvc_NETRDFSGETVERSION *r);
+WERROR _srvsvc_NETRDFSCREATELOCALPARTITION(pipes_struct *p, struct srvsvc_NETRDFSCREATELOCALPARTITION *r);
+WERROR _srvsvc_NETRDFSDELETELOCALPARTITION(pipes_struct *p, struct srvsvc_NETRDFSDELETELOCALPARTITION *r);
+WERROR _srvsvc_NETRDFSSETLOCALVOLUMESTATE(pipes_struct *p, struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r);
+WERROR _srvsvc_NETRDFSSETSERVERINFO(pipes_struct *p, struct srvsvc_NETRDFSSETSERVERINFO *r);
+WERROR _srvsvc_NETRDFSCREATEEXITPOINT(pipes_struct *p, struct srvsvc_NETRDFSCREATEEXITPOINT *r);
+WERROR _srvsvc_NETRDFSDELETEEXITPOINT(pipes_struct *p, struct srvsvc_NETRDFSDELETEEXITPOINT *r);
+WERROR _srvsvc_NETRDFSMODIFYPREFIX(pipes_struct *p, struct srvsvc_NETRDFSMODIFYPREFIX *r);
+WERROR _srvsvc_NETRDFSFIXLOCALVOLUME(pipes_struct *p, struct srvsvc_NETRDFSFIXLOCALVOLUME *r);
+WERROR _srvsvc_NETRDFSMANAGERREPORTSITEINFO(pipes_struct *p, struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r);
+WERROR _srvsvc_NETRSERVERTRANSPORTDELEX(pipes_struct *p, struct srvsvc_NETRSERVERTRANSPORTDELEX *r);
void srvsvc_get_pipe_fns(struct api_struct **fns, int *n_fns);
NTSTATUS rpc_srvsvc_init(void);
#endif /* __SRV_SRVSVC__ */
ZERO_STRUCT(r.out);
r.out.handle = r.in.handle;
- r.out.result = _svcctl_CloseServiceHandle(p, r.in.handle);
+ r.out.result = _svcctl_CloseServiceHandle(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _svcctl_ControlService(p, r.in.handle, r.in.control, r.out.status);
+ r.out.result = _svcctl_ControlService(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(svcctl_DeleteService, &r);
- r.out.result = _svcctl_DeleteService(p, r.in.handle);
+ r.out.result = _svcctl_DeleteService(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _svcctl_LockServiceDatabase(p, r.in.handle, r.out.lock);
+ r.out.result = _svcctl_LockServiceDatabase(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(svcctl_QueryServiceObjectSecurity, &r);
- r.out.result = _svcctl_QueryServiceObjectSecurity(p);
+ r.out.result = _svcctl_QueryServiceObjectSecurity(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(svcctl_SetServiceObjectSecurity, &r);
- r.out.result = _svcctl_SetServiceObjectSecurity(p);
+ r.out.result = _svcctl_SetServiceObjectSecurity(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _svcctl_QueryServiceStatus(p, r.in.handle, r.out.status);
+ r.out.result = _svcctl_QueryServiceStatus(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(svcctl_SetServiceStatus, &r);
- r.out.result = _svcctl_SetServiceStatus(p);
+ r.out.result = _svcctl_SetServiceStatus(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
ZERO_STRUCT(r.out);
r.out.lock = r.in.lock;
- r.out.result = _svcctl_UnlockServiceDatabase(p, r.in.lock);
+ r.out.result = _svcctl_UnlockServiceDatabase(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(svcctl_NotifyBootConfigStatus, &r);
- r.out.result = _svcctl_NotifyBootConfigStatus(p);
+ r.out.result = _svcctl_NotifyBootConfigStatus(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(svcctl_SCSetServiceBitsW, &r);
- r.out.result = _svcctl_SCSetServiceBitsW(p, r.in.handle, r.in.bits, r.in.bitson, r.in.immediate);
+ r.out.result = _svcctl_SCSetServiceBitsW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _svcctl_ChangeServiceConfigW(p, r.in.handle, r.in.type, r.in.start, r.in.error, r.in.binary_path, r.in.load_order_group, r.out.tag_id, r.in.dependencies, r.in.service_start_name, r.in.password, r.in.display_name);
+ r.out.result = _svcctl_ChangeServiceConfigW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _svcctl_CreateServiceW(p, r.in.scmanager_handle, r.in.ServiceName, r.in.DisplayName, r.in.desired_access, r.in.type, r.in.start_type, r.in.error_control, r.in.binary_path, r.in.LoadOrderGroupKey, r.in.TagId, r.in.dependencies, r.in.dependencies_size, r.in.service_start_name, r.in.password, r.in.password_size, r.out.handle);
+ r.out.result = _svcctl_CreateServiceW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _svcctl_EnumDependentServicesW(p, r.in.service, r.in.state, r.out.status, r.in.buf_size, r.out.bytes_needed, r.out.services_returned);
+ r.out.result = _svcctl_EnumDependentServicesW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
}
r.out.resume_handle = r.in.resume_handle;
- r.out.result = _svcctl_EnumServicesStatusW(p, r.in.handle, r.in.type, r.in.state, r.in.buf_size, r.out.service, r.out.bytes_needed, r.out.services_returned, r.in.resume_handle);
+ r.out.result = _svcctl_EnumServicesStatusW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _svcctl_OpenSCManagerW(p, r.in.MachineName, r.in.DatabaseName, r.in.access_mask, r.out.handle);
+ r.out.result = _svcctl_OpenSCManagerW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _svcctl_OpenServiceW(p, r.in.scmanager_handle, r.in.ServiceName, r.in.access_mask, r.out.handle);
+ r.out.result = _svcctl_OpenServiceW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _svcctl_QueryServiceConfigW(p, r.in.handle, r.out.query, r.in.buf_size, r.out.bytes_needed);
+ r.out.result = _svcctl_QueryServiceConfigW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _svcctl_QueryServiceLockStatusW(p, r.in.handle, r.in.buf_size, r.out.status, r.out.required_buf_size);
+ r.out.result = _svcctl_QueryServiceLockStatusW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(svcctl_StartServiceW, &r);
- r.out.result = _svcctl_StartServiceW(p, r.in.handle, r.in.NumArgs, r.in.Arguments);
+ r.out.result = _svcctl_StartServiceW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
}
r.out.display_name_length = r.in.display_name_length;
- r.out.result = _svcctl_GetServiceDisplayNameW(p, r.in.handle, r.in.service_name, r.out.display_name, r.in.display_name_length);
+ r.out.result = _svcctl_GetServiceDisplayNameW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
}
r.out.display_name_length = r.in.display_name_length;
- r.out.result = _svcctl_GetServiceKeyNameW(p, r.in.handle, r.in.service_name, r.out.key_name, r.in.display_name_length);
+ r.out.result = _svcctl_GetServiceKeyNameW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(svcctl_SCSetServiceBitsA, &r);
- r.out.result = _svcctl_SCSetServiceBitsA(p, r.in.handle, r.in.bits, r.in.bitson, r.in.immediate);
+ r.out.result = _svcctl_SCSetServiceBitsA(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _svcctl_ChangeServiceConfigA(p, r.in.handle, r.in.type, r.in.start, r.in.error, r.in.binary_path, r.in.load_order_group, r.out.tag_id, r.in.dependencies, r.in.service_start_name, r.in.password, r.in.display_name);
+ r.out.result = _svcctl_ChangeServiceConfigA(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _svcctl_CreateServiceA(p, r.in.handle, r.in.ServiceName, r.in.DisplayName, r.in.desired_access, r.in.type, r.in.start_type, r.in.error_control, r.in.binary_path, r.in.LoadOrderGroupKey, r.out.TagId, r.in.dependencies, r.in.service_start_name, r.in.password);
+ r.out.result = _svcctl_CreateServiceA(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _svcctl_EnumDependentServicesA(p, r.in.service, r.in.state, r.out.status, r.in.buf_size, r.out.bytes_needed, r.out.services_returned);
+ r.out.result = _svcctl_EnumDependentServicesA(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
}
r.out.resume_handle = r.in.resume_handle;
- r.out.result = _svcctl_EnumServicesStatusA(p, r.in.handle, r.in.type, r.in.state, r.in.buf_size, r.out.service, r.out.bytes_needed, r.out.services_returned, r.in.resume_handle);
+ r.out.result = _svcctl_EnumServicesStatusA(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _svcctl_OpenSCManagerA(p, r.in.MachineName, r.in.DatabaseName, r.in.access_mask, r.out.handle);
+ r.out.result = _svcctl_OpenSCManagerA(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(svcctl_OpenServiceA, &r);
- r.out.result = _svcctl_OpenServiceA(p, r.in.scmanager_handle, r.in.ServiceName, r.in.access_mask);
+ r.out.result = _svcctl_OpenServiceA(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _svcctl_QueryServiceConfigA(p, r.in.handle, r.out.query, r.in.buf_size, r.out.bytes_needed);
+ r.out.result = _svcctl_QueryServiceConfigA(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _svcctl_QueryServiceLockStatusA(p, r.in.handle, r.in.buf_size, r.out.status, r.out.required_buf_size);
+ r.out.result = _svcctl_QueryServiceLockStatusA(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(svcctl_StartServiceA, &r);
- r.out.result = _svcctl_StartServiceA(p, r.in.handle, r.in.NumArgs, r.in.Arguments);
+ r.out.result = _svcctl_StartServiceA(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
}
r.out.display_name_length = r.in.display_name_length;
- r.out.result = _svcctl_GetServiceDisplayNameA(p, r.in.handle, r.in.service_name, r.out.display_name, r.in.display_name_length);
+ r.out.result = _svcctl_GetServiceDisplayNameA(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
}
r.out.display_name_length = r.in.display_name_length;
- r.out.result = _svcctl_GetServiceKeyNameA(p, r.in.handle, r.in.service_name, r.out.key_name, r.in.display_name_length);
+ r.out.result = _svcctl_GetServiceKeyNameA(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(svcctl_GetCurrentGroupeStateW, &r);
- r.out.result = _svcctl_GetCurrentGroupeStateW(p);
+ r.out.result = _svcctl_GetCurrentGroupeStateW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(svcctl_EnumServiceGroupW, &r);
- r.out.result = _svcctl_EnumServiceGroupW(p);
+ r.out.result = _svcctl_EnumServiceGroupW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfig2A, &r);
- r.out.result = _svcctl_ChangeServiceConfig2A(p, r.in.handle, r.in.info_level, r.in.info);
+ r.out.result = _svcctl_ChangeServiceConfig2A(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(svcctl_ChangeServiceConfig2W, &r);
- r.out.result = _svcctl_ChangeServiceConfig2W(p, r.in.handle, r.in.info_level, r.in.info);
+ r.out.result = _svcctl_ChangeServiceConfig2W(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _svcctl_QueryServiceConfig2A(p, r.in.handle, r.in.info_level, r.out.buffer, r.in.buf_size, r.out.bytes_needed);
+ r.out.result = _svcctl_QueryServiceConfig2A(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _svcctl_QueryServiceConfig2W(p, r.in.handle, r.in.info_level, r.out.buffer, r.in.buf_size, r.out.bytes_needed);
+ r.out.result = _svcctl_QueryServiceConfig2W(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _svcctl_QueryServiceStatusEx(p, r.in.handle, r.in.info_level, r.out.buffer, r.in.buf_size, r.out.bytes_needed);
+ r.out.result = _svcctl_QueryServiceStatusEx(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _EnumServicesStatusExA(p, r.in.scmanager, r.in.info_level, r.in.type, r.in.state, r.out.services, r.in.buf_size, r.out.bytes_needed, r.out.service_returned, r.in.resume_handle, r.out.group_name);
+ r.out.result = _EnumServicesStatusExA(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _EnumServicesStatusExW(p, r.in.scmanager, r.in.info_level, r.in.type, r.in.state, r.out.services, r.in.buf_size, r.out.bytes_needed, r.out.service_returned, r.in.resume_handle, r.out.group_name);
+ r.out.result = _EnumServicesStatusExW(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(svcctl_SCSendTSMessage, &r);
- r.out.result = _svcctl_SCSendTSMessage(p);
+ r.out.result = _svcctl_SCSendTSMessage(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
#include "librpc/gen_ndr/ndr_svcctl.h"
#ifndef __SRV_SVCCTL__
#define __SRV_SVCCTL__
-WERROR _svcctl_CloseServiceHandle(pipes_struct *p, struct policy_handle *handle);
-WERROR _svcctl_ControlService(pipes_struct *p, struct policy_handle *handle, uint32_t control, struct SERVICE_STATUS *status);
-WERROR _svcctl_DeleteService(pipes_struct *p, struct policy_handle *handle);
-WERROR _svcctl_LockServiceDatabase(pipes_struct *p, struct policy_handle *handle, struct policy_handle *lock);
-WERROR _svcctl_QueryServiceObjectSecurity(pipes_struct *p);
-WERROR _svcctl_SetServiceObjectSecurity(pipes_struct *p);
-WERROR _svcctl_QueryServiceStatus(pipes_struct *p, struct policy_handle *handle, struct SERVICE_STATUS *status);
-WERROR _svcctl_SetServiceStatus(pipes_struct *p);
-WERROR _svcctl_UnlockServiceDatabase(pipes_struct *p, struct policy_handle *lock);
-WERROR _svcctl_NotifyBootConfigStatus(pipes_struct *p);
-WERROR _svcctl_SCSetServiceBitsW(pipes_struct *p, struct policy_handle *handle, uint32_t bits, uint32_t bitson, uint32_t immediate);
-WERROR _svcctl_ChangeServiceConfigW(pipes_struct *p, struct policy_handle *handle, uint32_t type, uint32_t start, uint32_t error, const char *binary_path, const char *load_order_group, uint32_t *tag_id, const char *dependencies, const char *service_start_name, const char *password, const char *display_name);
-WERROR _svcctl_CreateServiceW(pipes_struct *p, struct policy_handle *scmanager_handle, const char *ServiceName, const char *DisplayName, uint32_t desired_access, uint32_t type, uint32_t start_type, uint32_t error_control, const char *binary_path, const char *LoadOrderGroupKey, uint32_t *TagId, uint8_t *dependencies, uint32_t dependencies_size, const char *service_start_name, uint8_t *password, uint32_t password_size, struct policy_handle *handle);
-WERROR _svcctl_EnumDependentServicesW(pipes_struct *p, struct policy_handle *service, uint32_t state, struct ENUM_SERVICE_STATUS *status, uint32_t buf_size, uint32_t *bytes_needed, uint32_t *services_returned);
-WERROR _svcctl_EnumServicesStatusW(pipes_struct *p, struct policy_handle *handle, uint32_t type, uint32_t state, uint32_t buf_size, uint8_t *service, uint32_t *bytes_needed, uint32_t *services_returned, uint32_t *resume_handle);
-WERROR _svcctl_OpenSCManagerW(pipes_struct *p, const char *MachineName, const char *DatabaseName, uint32_t access_mask, struct policy_handle *handle);
-WERROR _svcctl_OpenServiceW(pipes_struct *p, struct policy_handle *scmanager_handle, const char *ServiceName, uint32_t access_mask, struct policy_handle *handle);
-WERROR _svcctl_QueryServiceConfigW(pipes_struct *p, struct policy_handle *handle, uint8_t *query, uint32_t buf_size, uint32_t *bytes_needed);
-WERROR _svcctl_QueryServiceLockStatusW(pipes_struct *p, struct policy_handle *handle, uint32_t buf_size, struct SERVICE_LOCK_STATUS *status, uint32_t *required_buf_size);
-WERROR _svcctl_StartServiceW(pipes_struct *p, struct policy_handle *handle, uint32_t NumArgs, const char *Arguments);
-WERROR _svcctl_GetServiceDisplayNameW(pipes_struct *p, struct policy_handle *handle, const char *service_name, const char **display_name, uint32_t *display_name_length);
-WERROR _svcctl_GetServiceKeyNameW(pipes_struct *p, struct policy_handle *handle, const char *service_name, const char **key_name, uint32_t *display_name_length);
-WERROR _svcctl_SCSetServiceBitsA(pipes_struct *p, struct policy_handle *handle, uint32_t bits, uint32_t bitson, uint32_t immediate);
-WERROR _svcctl_ChangeServiceConfigA(pipes_struct *p, struct policy_handle *handle, uint32_t type, uint32_t start, uint32_t error, const char *binary_path, const char *load_order_group, uint32_t *tag_id, const char *dependencies, const char *service_start_name, const char *password, const char *display_name);
-WERROR _svcctl_CreateServiceA(pipes_struct *p, struct policy_handle *handle, const char *ServiceName, const char *DisplayName, uint32_t desired_access, uint32_t type, uint32_t start_type, uint32_t error_control, const char *binary_path, const char *LoadOrderGroupKey, uint32_t *TagId, const char *dependencies, const char *service_start_name, const char *password);
-WERROR _svcctl_EnumDependentServicesA(pipes_struct *p, struct policy_handle *service, uint32_t state, struct ENUM_SERVICE_STATUS *status, uint32_t buf_size, uint32_t *bytes_needed, uint32_t *services_returned);
-WERROR _svcctl_EnumServicesStatusA(pipes_struct *p, struct policy_handle *handle, uint32_t type, uint32_t state, uint32_t buf_size, uint8_t *service, uint32_t *bytes_needed, uint32_t *services_returned, uint32_t *resume_handle);
-WERROR _svcctl_OpenSCManagerA(pipes_struct *p, const char *MachineName, const char *DatabaseName, uint32_t access_mask, struct policy_handle *handle);
-WERROR _svcctl_OpenServiceA(pipes_struct *p, struct policy_handle *scmanager_handle, const char *ServiceName, uint32_t access_mask);
-WERROR _svcctl_QueryServiceConfigA(pipes_struct *p, struct policy_handle *handle, uint8_t *query, uint32_t buf_size, uint32_t *bytes_needed);
-WERROR _svcctl_QueryServiceLockStatusA(pipes_struct *p, struct policy_handle *handle, uint32_t buf_size, struct SERVICE_LOCK_STATUS *status, uint32_t *required_buf_size);
-WERROR _svcctl_StartServiceA(pipes_struct *p, struct policy_handle *handle, uint32_t NumArgs, const char *Arguments);
-WERROR _svcctl_GetServiceDisplayNameA(pipes_struct *p, struct policy_handle *handle, const char *service_name, const char **display_name, uint32_t *display_name_length);
-WERROR _svcctl_GetServiceKeyNameA(pipes_struct *p, struct policy_handle *handle, const char *service_name, const char **key_name, uint32_t *display_name_length);
-WERROR _svcctl_GetCurrentGroupeStateW(pipes_struct *p);
-WERROR _svcctl_EnumServiceGroupW(pipes_struct *p);
-WERROR _svcctl_ChangeServiceConfig2A(pipes_struct *p, struct policy_handle *handle, uint32_t info_level, uint8_t *info);
-WERROR _svcctl_ChangeServiceConfig2W(pipes_struct *p, struct policy_handle *handle, uint32_t info_level, uint8_t *info);
-WERROR _svcctl_QueryServiceConfig2A(pipes_struct *p, struct policy_handle *handle, uint32_t info_level, uint8_t *buffer, uint32_t buf_size, uint32_t *bytes_needed);
-WERROR _svcctl_QueryServiceConfig2W(pipes_struct *p, struct policy_handle *handle, uint32_t info_level, uint8_t *buffer, uint32_t buf_size, uint32_t *bytes_needed);
-WERROR _svcctl_QueryServiceStatusEx(pipes_struct *p, struct policy_handle *handle, uint32_t info_level, uint8_t *buffer, uint32_t buf_size, uint32_t *bytes_needed);
-WERROR _EnumServicesStatusExA(pipes_struct *p, struct policy_handle *scmanager, uint32_t info_level, uint32_t type, uint32_t state, uint8_t *services, uint32_t buf_size, uint32_t *bytes_needed, uint32_t *service_returned, uint32_t *resume_handle, const char **group_name);
-WERROR _EnumServicesStatusExW(pipes_struct *p, struct policy_handle *scmanager, uint32_t info_level, uint32_t type, uint32_t state, uint8_t *services, uint32_t buf_size, uint32_t *bytes_needed, uint32_t *service_returned, uint32_t *resume_handle, const char **group_name);
-WERROR _svcctl_SCSendTSMessage(pipes_struct *p);
+WERROR _svcctl_CloseServiceHandle(pipes_struct *p, struct svcctl_CloseServiceHandle *r);
+WERROR _svcctl_ControlService(pipes_struct *p, struct svcctl_ControlService *r);
+WERROR _svcctl_DeleteService(pipes_struct *p, struct svcctl_DeleteService *r);
+WERROR _svcctl_LockServiceDatabase(pipes_struct *p, struct svcctl_LockServiceDatabase *r);
+WERROR _svcctl_QueryServiceObjectSecurity(pipes_struct *p, struct svcctl_QueryServiceObjectSecurity *r);
+WERROR _svcctl_SetServiceObjectSecurity(pipes_struct *p, struct svcctl_SetServiceObjectSecurity *r);
+WERROR _svcctl_QueryServiceStatus(pipes_struct *p, struct svcctl_QueryServiceStatus *r);
+WERROR _svcctl_SetServiceStatus(pipes_struct *p, struct svcctl_SetServiceStatus *r);
+WERROR _svcctl_UnlockServiceDatabase(pipes_struct *p, struct svcctl_UnlockServiceDatabase *r);
+WERROR _svcctl_NotifyBootConfigStatus(pipes_struct *p, struct svcctl_NotifyBootConfigStatus *r);
+WERROR _svcctl_SCSetServiceBitsW(pipes_struct *p, struct svcctl_SCSetServiceBitsW *r);
+WERROR _svcctl_ChangeServiceConfigW(pipes_struct *p, struct svcctl_ChangeServiceConfigW *r);
+WERROR _svcctl_CreateServiceW(pipes_struct *p, struct svcctl_CreateServiceW *r);
+WERROR _svcctl_EnumDependentServicesW(pipes_struct *p, struct svcctl_EnumDependentServicesW *r);
+WERROR _svcctl_EnumServicesStatusW(pipes_struct *p, struct svcctl_EnumServicesStatusW *r);
+WERROR _svcctl_OpenSCManagerW(pipes_struct *p, struct svcctl_OpenSCManagerW *r);
+WERROR _svcctl_OpenServiceW(pipes_struct *p, struct svcctl_OpenServiceW *r);
+WERROR _svcctl_QueryServiceConfigW(pipes_struct *p, struct svcctl_QueryServiceConfigW *r);
+WERROR _svcctl_QueryServiceLockStatusW(pipes_struct *p, struct svcctl_QueryServiceLockStatusW *r);
+WERROR _svcctl_StartServiceW(pipes_struct *p, struct svcctl_StartServiceW *r);
+WERROR _svcctl_GetServiceDisplayNameW(pipes_struct *p, struct svcctl_GetServiceDisplayNameW *r);
+WERROR _svcctl_GetServiceKeyNameW(pipes_struct *p, struct svcctl_GetServiceKeyNameW *r);
+WERROR _svcctl_SCSetServiceBitsA(pipes_struct *p, struct svcctl_SCSetServiceBitsA *r);
+WERROR _svcctl_ChangeServiceConfigA(pipes_struct *p, struct svcctl_ChangeServiceConfigA *r);
+WERROR _svcctl_CreateServiceA(pipes_struct *p, struct svcctl_CreateServiceA *r);
+WERROR _svcctl_EnumDependentServicesA(pipes_struct *p, struct svcctl_EnumDependentServicesA *r);
+WERROR _svcctl_EnumServicesStatusA(pipes_struct *p, struct svcctl_EnumServicesStatusA *r);
+WERROR _svcctl_OpenSCManagerA(pipes_struct *p, struct svcctl_OpenSCManagerA *r);
+WERROR _svcctl_OpenServiceA(pipes_struct *p, struct svcctl_OpenServiceA *r);
+WERROR _svcctl_QueryServiceConfigA(pipes_struct *p, struct svcctl_QueryServiceConfigA *r);
+WERROR _svcctl_QueryServiceLockStatusA(pipes_struct *p, struct svcctl_QueryServiceLockStatusA *r);
+WERROR _svcctl_StartServiceA(pipes_struct *p, struct svcctl_StartServiceA *r);
+WERROR _svcctl_GetServiceDisplayNameA(pipes_struct *p, struct svcctl_GetServiceDisplayNameA *r);
+WERROR _svcctl_GetServiceKeyNameA(pipes_struct *p, struct svcctl_GetServiceKeyNameA *r);
+WERROR _svcctl_GetCurrentGroupeStateW(pipes_struct *p, struct svcctl_GetCurrentGroupeStateW *r);
+WERROR _svcctl_EnumServiceGroupW(pipes_struct *p, struct svcctl_EnumServiceGroupW *r);
+WERROR _svcctl_ChangeServiceConfig2A(pipes_struct *p, struct svcctl_ChangeServiceConfig2A *r);
+WERROR _svcctl_ChangeServiceConfig2W(pipes_struct *p, struct svcctl_ChangeServiceConfig2W *r);
+WERROR _svcctl_QueryServiceConfig2A(pipes_struct *p, struct svcctl_QueryServiceConfig2A *r);
+WERROR _svcctl_QueryServiceConfig2W(pipes_struct *p, struct svcctl_QueryServiceConfig2W *r);
+WERROR _svcctl_QueryServiceStatusEx(pipes_struct *p, struct svcctl_QueryServiceStatusEx *r);
+WERROR _EnumServicesStatusExA(pipes_struct *p, struct EnumServicesStatusExA *r);
+WERROR _EnumServicesStatusExW(pipes_struct *p, struct EnumServicesStatusExW *r);
+WERROR _svcctl_SCSendTSMessage(pipes_struct *p, struct svcctl_SCSendTSMessage *r);
void svcctl_get_pipe_fns(struct api_struct **fns, int *n_fns);
NTSTATUS rpc_svcctl_init(void);
#endif /* __SRV_SVCCTL__ */
return False;
}
- r.out.result = _unixinfo_SidToUid(p, r.in.sid, r.out.uid);
+ r.out.result = _unixinfo_SidToUid(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _unixinfo_UidToSid(p, r.in.uid, r.out.sid);
+ r.out.result = _unixinfo_UidToSid(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _unixinfo_SidToGid(p, r.in.sid, r.out.gid);
+ r.out.result = _unixinfo_SidToGid(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _unixinfo_GidToSid(p, r.in.gid, r.out.sid);
+ r.out.result = _unixinfo_GidToSid(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _unixinfo_GetPWUid(p, r.in.count, r.in.uids, r.out.infos);
+ r.out.result = _unixinfo_GetPWUid(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
#include "librpc/gen_ndr/ndr_unixinfo.h"
#ifndef __SRV_UNIXINFO__
#define __SRV_UNIXINFO__
-NTSTATUS _unixinfo_SidToUid(pipes_struct *p, struct dom_sid sid, uint64_t *uid);
-NTSTATUS _unixinfo_UidToSid(pipes_struct *p, uint64_t uid, struct dom_sid *sid);
-NTSTATUS _unixinfo_SidToGid(pipes_struct *p, struct dom_sid sid, uint64_t *gid);
-NTSTATUS _unixinfo_GidToSid(pipes_struct *p, uint64_t gid, struct dom_sid *sid);
-NTSTATUS _unixinfo_GetPWUid(pipes_struct *p, uint32_t *count, uint64_t *uids, struct unixinfo_GetPWUidInfo *infos);
+NTSTATUS _unixinfo_SidToUid(pipes_struct *p, struct unixinfo_SidToUid *r);
+NTSTATUS _unixinfo_UidToSid(pipes_struct *p, struct unixinfo_UidToSid *r);
+NTSTATUS _unixinfo_SidToGid(pipes_struct *p, struct unixinfo_SidToGid *r);
+NTSTATUS _unixinfo_GidToSid(pipes_struct *p, struct unixinfo_GidToSid *r);
+NTSTATUS _unixinfo_GetPWUid(pipes_struct *p, struct unixinfo_GetPWUid *r);
void unixinfo_get_pipe_fns(struct api_struct **fns, int *n_fns);
NTSTATUS rpc_unixinfo_init(void);
#endif /* __SRV_UNIXINFO__ */
return False;
}
- r.out.result = _winreg_OpenHKCR(p, r.in.system_name, r.in.access_mask, r.out.handle);
+ r.out.result = _winreg_OpenHKCR(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _winreg_OpenHKCU(p, r.in.system_name, r.in.access_mask, r.out.handle);
+ r.out.result = _winreg_OpenHKCU(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _winreg_OpenHKLM(p, r.in.system_name, r.in.access_mask, r.out.handle);
+ r.out.result = _winreg_OpenHKLM(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _winreg_OpenHKPD(p, r.in.system_name, r.in.access_mask, r.out.handle);
+ r.out.result = _winreg_OpenHKPD(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _winreg_OpenHKU(p, r.in.system_name, r.in.access_mask, r.out.handle);
+ r.out.result = _winreg_OpenHKU(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
ZERO_STRUCT(r.out);
r.out.handle = r.in.handle;
- r.out.result = _winreg_CloseKey(p, r.in.handle);
+ r.out.result = _winreg_CloseKey(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
}
r.out.action_taken = r.in.action_taken;
- r.out.result = _winreg_CreateKey(p, r.in.handle, r.in.name, r.in.keyclass, r.in.options, r.in.access_mask, r.in.secdesc, r.out.new_handle, r.in.action_taken);
+ r.out.result = _winreg_CreateKey(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(winreg_DeleteKey, &r);
- r.out.result = _winreg_DeleteKey(p, r.in.handle, r.in.key);
+ r.out.result = _winreg_DeleteKey(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(winreg_DeleteValue, &r);
- r.out.result = _winreg_DeleteValue(p, r.in.handle, r.in.value);
+ r.out.result = _winreg_DeleteValue(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
r.out.name = r.in.name;
r.out.keyclass = r.in.keyclass;
r.out.last_changed_time = r.in.last_changed_time;
- r.out.result = _winreg_EnumKey(p, r.in.handle, r.in.enum_index, r.in.name, r.in.keyclass, r.in.last_changed_time);
+ r.out.result = _winreg_EnumKey(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
r.out.data = r.in.data;
r.out.data_size = r.in.data_size;
r.out.value_length = r.in.value_length;
- r.out.result = _winreg_EnumValue(p, r.in.handle, r.in.enum_index, r.in.name, r.in.type, r.in.data, r.in.data_size, r.in.value_length);
+ r.out.result = _winreg_EnumValue(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(winreg_FlushKey, &r);
- r.out.result = _winreg_FlushKey(p, r.in.handle);
+ r.out.result = _winreg_FlushKey(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
ZERO_STRUCT(r.out);
r.out.sd = r.in.sd;
- r.out.result = _winreg_GetKeySecurity(p, r.in.handle, r.in.sec_info, r.in.sd);
+ r.out.result = _winreg_GetKeySecurity(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(winreg_LoadKey, &r);
- r.out.result = _winreg_LoadKey(p, r.in.handle, r.in.keyname, r.in.filename);
+ r.out.result = _winreg_LoadKey(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(winreg_NotifyChangeKeyValue, &r);
- r.out.result = _winreg_NotifyChangeKeyValue(p, r.in.handle, r.in.watch_subtree, r.in.notify_filter, r.in.unknown, r.in.string1, r.in.string2, r.in.unknown2);
+ r.out.result = _winreg_NotifyChangeKeyValue(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _winreg_OpenKey(p, r.in.parent_handle, r.in.keyname, r.in.unknown, r.in.access_mask, r.out.handle);
+ r.out.result = _winreg_OpenKey(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
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_classlen, 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);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
r.out.data = r.in.data;
r.out.data_size = r.in.data_size;
r.out.value_length = r.in.value_length;
- r.out.result = _winreg_QueryValue(p, r.in.handle, r.in.value_name, r.in.type, r.in.data, r.in.data_size, r.in.value_length);
+ r.out.result = _winreg_QueryValue(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(winreg_ReplaceKey, &r);
- r.out.result = _winreg_ReplaceKey(p);
+ r.out.result = _winreg_ReplaceKey(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(winreg_RestoreKey, &r);
- r.out.result = _winreg_RestoreKey(p, r.in.handle, r.in.filename, r.in.flags);
+ r.out.result = _winreg_RestoreKey(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(winreg_SaveKey, &r);
- r.out.result = _winreg_SaveKey(p, r.in.handle, r.in.filename, r.in.sec_attrib);
+ r.out.result = _winreg_SaveKey(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(winreg_SetKeySecurity, &r);
- r.out.result = _winreg_SetKeySecurity(p, r.in.handle, r.in.access_mask, r.in.sd);
+ r.out.result = _winreg_SetKeySecurity(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(winreg_SetValue, &r);
- r.out.result = _winreg_SetValue(p, r.in.handle, r.in.name, r.in.type, r.in.data, r.in.size);
+ r.out.result = _winreg_SetValue(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(winreg_UnLoadKey, &r);
- r.out.result = _winreg_UnLoadKey(p);
+ r.out.result = _winreg_UnLoadKey(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(winreg_InitiateSystemShutdown, &r);
- r.out.result = _winreg_InitiateSystemShutdown(p, r.in.hostname, r.in.message, r.in.timeout, r.in.force_apps, r.in.reboot);
+ r.out.result = _winreg_InitiateSystemShutdown(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(winreg_AbortSystemShutdown, &r);
- r.out.result = _winreg_AbortSystemShutdown(p, r.in.server);
+ r.out.result = _winreg_AbortSystemShutdown(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _winreg_GetVersion(p, r.in.handle, r.out.version);
+ r.out.result = _winreg_GetVersion(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _winreg_OpenHKCC(p, r.in.system_name, r.in.access_mask, r.out.handle);
+ r.out.result = _winreg_OpenHKCC(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _winreg_OpenHKDD(p, r.in.system_name, r.in.access_mask, r.out.handle);
+ r.out.result = _winreg_OpenHKDD(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
r.out.values = r.in.values;
r.out.buffer = r.in.buffer;
r.out.buffer_size = r.in.buffer_size;
- r.out.result = _winreg_QueryMultipleValues(p, r.in.key_handle, r.in.values, r.in.num_values, r.in.buffer, r.in.buffer_size);
+ r.out.result = _winreg_QueryMultipleValues(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(winreg_InitiateSystemShutdownEx, &r);
- r.out.result = _winreg_InitiateSystemShutdownEx(p, r.in.hostname, r.in.message, r.in.timeout, r.in.force_apps, r.in.reboot, r.in.reason);
+ r.out.result = _winreg_InitiateSystemShutdownEx(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(winreg_SaveKeyEx, &r);
- r.out.result = _winreg_SaveKeyEx(p);
+ r.out.result = _winreg_SaveKeyEx(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _winreg_OpenHKPT(p, r.in.system_name, r.in.access_mask, r.out.handle);
+ r.out.result = _winreg_OpenHKPT(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
return False;
}
- r.out.result = _winreg_OpenHKPN(p, r.in.system_name, r.in.access_mask, r.out.handle);
+ r.out.result = _winreg_OpenHKPN(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(winreg_QueryMultipleValues2, &r);
- r.out.result = _winreg_QueryMultipleValues2(p);
+ r.out.result = _winreg_QueryMultipleValues2(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
#include "librpc/gen_ndr/ndr_winreg.h"
#ifndef __SRV_WINREG__
#define __SRV_WINREG__
-WERROR _winreg_OpenHKCR(pipes_struct *p, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle);
-WERROR _winreg_OpenHKCU(pipes_struct *p, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle);
-WERROR _winreg_OpenHKLM(pipes_struct *p, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle);
-WERROR _winreg_OpenHKPD(pipes_struct *p, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle);
-WERROR _winreg_OpenHKU(pipes_struct *p, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle);
-WERROR _winreg_CloseKey(pipes_struct *p, struct policy_handle *handle);
-WERROR _winreg_CreateKey(pipes_struct *p, struct policy_handle *handle, struct winreg_String name, struct winreg_String keyclass, uint32_t options, uint32_t access_mask, struct winreg_SecBuf *secdesc, struct policy_handle *new_handle, enum winreg_CreateAction *action_taken);
-WERROR _winreg_DeleteKey(pipes_struct *p, struct policy_handle *handle, struct winreg_String key);
-WERROR _winreg_DeleteValue(pipes_struct *p, struct policy_handle *handle, struct winreg_String value);
-WERROR _winreg_EnumKey(pipes_struct *p, struct policy_handle *handle, uint32_t enum_index, struct winreg_StringBuf *name, struct winreg_StringBuf *keyclass, NTTIME *last_changed_time);
-WERROR _winreg_EnumValue(pipes_struct *p, struct policy_handle *handle, uint32_t enum_index, struct winreg_ValNameBuf *name, enum winreg_Type *type, uint8_t **data, uint32_t *data_size, uint32_t *value_length);
-WERROR _winreg_FlushKey(pipes_struct *p, struct policy_handle *handle);
-WERROR _winreg_GetKeySecurity(pipes_struct *p, struct policy_handle *handle, uint32_t sec_info, struct KeySecurityData *sd);
-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_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);
-WERROR _winreg_SaveKey(pipes_struct *p, struct policy_handle *handle, struct winreg_String *filename, struct KeySecurityAttribute *sec_attrib);
-WERROR _winreg_SetKeySecurity(pipes_struct *p, struct policy_handle *handle, uint32_t access_mask, struct KeySecurityData *sd);
-WERROR _winreg_SetValue(pipes_struct *p, struct policy_handle *handle, struct winreg_String name, enum winreg_Type type, uint8_t *data, uint32_t size);
-WERROR _winreg_UnLoadKey(pipes_struct *p);
-WERROR _winreg_InitiateSystemShutdown(pipes_struct *p, uint16_t *hostname, struct initshutdown_String *message, uint32_t timeout, uint8_t force_apps, uint8_t reboot);
-WERROR _winreg_AbortSystemShutdown(pipes_struct *p, uint16_t *server);
-WERROR _winreg_GetVersion(pipes_struct *p, struct policy_handle *handle, uint32_t *version);
-WERROR _winreg_OpenHKCC(pipes_struct *p, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle);
-WERROR _winreg_OpenHKDD(pipes_struct *p, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle);
-WERROR _winreg_QueryMultipleValues(pipes_struct *p, struct policy_handle *key_handle, struct QueryMultipleValue *values, uint32_t num_values, uint8_t *buffer, uint32_t *buffer_size);
-WERROR _winreg_InitiateSystemShutdownEx(pipes_struct *p, uint16_t *hostname, struct initshutdown_String *message, uint32_t timeout, uint8_t force_apps, uint8_t reboot, uint32_t reason);
-WERROR _winreg_SaveKeyEx(pipes_struct *p);
-WERROR _winreg_OpenHKPT(pipes_struct *p, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle);
-WERROR _winreg_OpenHKPN(pipes_struct *p, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle);
-WERROR _winreg_QueryMultipleValues2(pipes_struct *p);
+WERROR _winreg_OpenHKCR(pipes_struct *p, struct winreg_OpenHKCR *r);
+WERROR _winreg_OpenHKCU(pipes_struct *p, struct winreg_OpenHKCU *r);
+WERROR _winreg_OpenHKLM(pipes_struct *p, struct winreg_OpenHKLM *r);
+WERROR _winreg_OpenHKPD(pipes_struct *p, struct winreg_OpenHKPD *r);
+WERROR _winreg_OpenHKU(pipes_struct *p, struct winreg_OpenHKU *r);
+WERROR _winreg_CloseKey(pipes_struct *p, struct winreg_CloseKey *r);
+WERROR _winreg_CreateKey(pipes_struct *p, struct winreg_CreateKey *r);
+WERROR _winreg_DeleteKey(pipes_struct *p, struct winreg_DeleteKey *r);
+WERROR _winreg_DeleteValue(pipes_struct *p, struct winreg_DeleteValue *r);
+WERROR _winreg_EnumKey(pipes_struct *p, struct winreg_EnumKey *r);
+WERROR _winreg_EnumValue(pipes_struct *p, struct winreg_EnumValue *r);
+WERROR _winreg_FlushKey(pipes_struct *p, struct winreg_FlushKey *r);
+WERROR _winreg_GetKeySecurity(pipes_struct *p, struct winreg_GetKeySecurity *r);
+WERROR _winreg_LoadKey(pipes_struct *p, struct winreg_LoadKey *r);
+WERROR _winreg_NotifyChangeKeyValue(pipes_struct *p, struct winreg_NotifyChangeKeyValue *r);
+WERROR _winreg_OpenKey(pipes_struct *p, struct winreg_OpenKey *r);
+WERROR _winreg_QueryInfoKey(pipes_struct *p, struct winreg_QueryInfoKey *r);
+WERROR _winreg_QueryValue(pipes_struct *p, struct winreg_QueryValue *r);
+WERROR _winreg_ReplaceKey(pipes_struct *p, struct winreg_ReplaceKey *r);
+WERROR _winreg_RestoreKey(pipes_struct *p, struct winreg_RestoreKey *r);
+WERROR _winreg_SaveKey(pipes_struct *p, struct winreg_SaveKey *r);
+WERROR _winreg_SetKeySecurity(pipes_struct *p, struct winreg_SetKeySecurity *r);
+WERROR _winreg_SetValue(pipes_struct *p, struct winreg_SetValue *r);
+WERROR _winreg_UnLoadKey(pipes_struct *p, struct winreg_UnLoadKey *r);
+WERROR _winreg_InitiateSystemShutdown(pipes_struct *p, struct winreg_InitiateSystemShutdown *r);
+WERROR _winreg_AbortSystemShutdown(pipes_struct *p, struct winreg_AbortSystemShutdown *r);
+WERROR _winreg_GetVersion(pipes_struct *p, struct winreg_GetVersion *r);
+WERROR _winreg_OpenHKCC(pipes_struct *p, struct winreg_OpenHKCC *r);
+WERROR _winreg_OpenHKDD(pipes_struct *p, struct winreg_OpenHKDD *r);
+WERROR _winreg_QueryMultipleValues(pipes_struct *p, struct winreg_QueryMultipleValues *r);
+WERROR _winreg_InitiateSystemShutdownEx(pipes_struct *p, struct winreg_InitiateSystemShutdownEx *r);
+WERROR _winreg_SaveKeyEx(pipes_struct *p, struct winreg_SaveKeyEx *r);
+WERROR _winreg_OpenHKPT(pipes_struct *p, struct winreg_OpenHKPT *r);
+WERROR _winreg_OpenHKPN(pipes_struct *p, struct winreg_OpenHKPN *r);
+WERROR _winreg_QueryMultipleValues2(pipes_struct *p, struct winreg_QueryMultipleValues2 *r);
void winreg_get_pipe_fns(struct api_struct **fns, int *n_fns);
NTSTATUS rpc_winreg_init(void);
#endif /* __SRV_WINREG__ */
return False;
}
- r.out.result = _wkssvc_NetWkstaGetInfo(p, r.in.server_name, r.in.level, r.out.info);
+ r.out.result = _wkssvc_NetWkstaGetInfo(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
ZERO_STRUCT(r.out);
r.out.parm_error = r.in.parm_error;
- r.out.result = _wkssvc_NetWkstaSetInfo(p, r.in.server_name, r.in.level, r.in.info, r.in.parm_error);
+ r.out.result = _wkssvc_NetWkstaSetInfo(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
}
r.out.resumehandle = r.in.resumehandle;
- r.out.result = _wkssvc_NetWkstaEnumUsers(p, r.in.server_name, r.in.level, r.in.users, r.in.prefmaxlen, r.out.entriesread, r.out.totalentries, r.in.resumehandle);
+ r.out.result = _wkssvc_NetWkstaEnumUsers(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(WKSSVC_NETRWKSTAUSERGETINFO, &r);
- r.out.result = _WKSSVC_NETRWKSTAUSERGETINFO(p);
+ r.out.result = _WKSSVC_NETRWKSTAUSERGETINFO(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(WKSSVC_NETRWKSTAUSERSETINFO, &r);
- r.out.result = _WKSSVC_NETRWKSTAUSERSETINFO(p);
+ r.out.result = _WKSSVC_NETRWKSTAUSERSETINFO(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
}
r.out.resume_handle = r.in.resume_handle;
- r.out.result = _wkssvc_NetWkstaTransportEnum(p, r.in.server_name, r.in.level, r.in.ctr, r.in.max_buffer, r.out.totalentries, r.in.resume_handle);
+ r.out.result = _wkssvc_NetWkstaTransportEnum(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(WKSSVC_NETRWKSTATRANSPORTADD, &r);
- r.out.result = _WKSSVC_NETRWKSTATRANSPORTADD(p);
+ r.out.result = _WKSSVC_NETRWKSTATRANSPORTADD(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(WKSSVC_NETRWKSTATRANSPORTDEL, &r);
- r.out.result = _WKSSVC_NETRWKSTATRANSPORTDEL(p);
+ r.out.result = _WKSSVC_NETRWKSTATRANSPORTDEL(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(WKSSVC_NETRUSEADD, &r);
- r.out.result = _WKSSVC_NETRUSEADD(p);
+ r.out.result = _WKSSVC_NETRUSEADD(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(WKSSVC_NETRUSEGETINFO, &r);
- r.out.result = _WKSSVC_NETRUSEGETINFO(p);
+ r.out.result = _WKSSVC_NETRUSEGETINFO(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(WKSSVC_NETRUSEDEL, &r);
- r.out.result = _WKSSVC_NETRUSEDEL(p);
+ r.out.result = _WKSSVC_NETRUSEDEL(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(WKSSVC_NETRUSEENUM, &r);
- r.out.result = _WKSSVC_NETRUSEENUM(p);
+ r.out.result = _WKSSVC_NETRUSEENUM(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(WKSSVC_NETRMESSAGEBUFFERSEND, &r);
- r.out.result = _WKSSVC_NETRMESSAGEBUFFERSEND(p);
+ r.out.result = _WKSSVC_NETRMESSAGEBUFFERSEND(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(WKSSVC_NETRWORKSTATIONSTATISTICSGET, &r);
- r.out.result = _WKSSVC_NETRWORKSTATIONSTATISTICSGET(p);
+ r.out.result = _WKSSVC_NETRWORKSTATIONSTATISTICSGET(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(WKSSVC_NETRLOGONDOMAINNAMEADD, &r);
- r.out.result = _WKSSVC_NETRLOGONDOMAINNAMEADD(p);
+ r.out.result = _WKSSVC_NETRLOGONDOMAINNAMEADD(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(WKSSVC_NETRLOGONDOMAINNAMEDEL, &r);
- r.out.result = _WKSSVC_NETRLOGONDOMAINNAMEDEL(p);
+ r.out.result = _WKSSVC_NETRLOGONDOMAINNAMEDEL(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(WKSSVC_NETRJOINDOMAIN, &r);
- r.out.result = _WKSSVC_NETRJOINDOMAIN(p);
+ r.out.result = _WKSSVC_NETRJOINDOMAIN(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(WKSSVC_NETRUNJOINDOMAIN, &r);
- r.out.result = _WKSSVC_NETRUNJOINDOMAIN(p);
+ r.out.result = _WKSSVC_NETRUNJOINDOMAIN(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(WKSSVC_NETRRENAMEMACHINEINDOMAIN, &r);
- r.out.result = _WKSSVC_NETRRENAMEMACHINEINDOMAIN(p);
+ r.out.result = _WKSSVC_NETRRENAMEMACHINEINDOMAIN(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(WKSSVC_NETRVALIDATENAME, &r);
- r.out.result = _WKSSVC_NETRVALIDATENAME(p);
+ r.out.result = _WKSSVC_NETRVALIDATENAME(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(WKSSVC_NETRGETJOININFORMATION, &r);
- r.out.result = _WKSSVC_NETRGETJOININFORMATION(p);
+ r.out.result = _WKSSVC_NETRGETJOININFORMATION(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(WKSSVC_NETRGETJOINABLEOUS, &r);
- r.out.result = _WKSSVC_NETRGETJOINABLEOUS(p);
+ r.out.result = _WKSSVC_NETRGETJOINABLEOUS(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(wkssvc_NetrJoinDomain2, &r);
- r.out.result = _wkssvc_NetrJoinDomain2(p, r.in.server_name, r.in.domain_name, r.in.account_name, r.in.admin_account, r.in.encrypted_password, r.in.join_flags);
+ r.out.result = _wkssvc_NetrJoinDomain2(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(wkssvc_NetrUnjoinDomain2, &r);
- r.out.result = _wkssvc_NetrUnjoinDomain2(p, r.in.server_name, r.in.account, r.in.encrypted_password, r.in.unjoin_flags);
+ r.out.result = _wkssvc_NetrUnjoinDomain2(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(wkssvc_NetrRenameMachineInDomain2, &r);
- r.out.result = _wkssvc_NetrRenameMachineInDomain2(p, r.in.server_name, r.in.NewMachineName, r.in.Account, r.in.EncryptedPassword, r.in.RenameOptions);
+ r.out.result = _wkssvc_NetrRenameMachineInDomain2(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(WKSSVC_NETRVALIDATENAME2, &r);
- r.out.result = _WKSSVC_NETRVALIDATENAME2(p);
+ r.out.result = _WKSSVC_NETRVALIDATENAME2(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(WKSSVC_NETRGETJOINABLEOUS2, &r);
- r.out.result = _WKSSVC_NETRGETJOINABLEOUS2(p);
+ r.out.result = _WKSSVC_NETRGETJOINABLEOUS2(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(wkssvc_NetrAddAlternateComputerName, &r);
- r.out.result = _wkssvc_NetrAddAlternateComputerName(p, r.in.server_name, r.in.NewAlternateMachineName, r.in.Account, r.in.EncryptedPassword, r.in.Reserved);
+ r.out.result = _wkssvc_NetrAddAlternateComputerName(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(wkssvc_NetrRemoveAlternateComputerName, &r);
- r.out.result = _wkssvc_NetrRemoveAlternateComputerName(p, r.in.server_name, r.in.AlternateMachineNameToRemove, r.in.Account, r.in.EncryptedPassword, r.in.Reserved);
+ r.out.result = _wkssvc_NetrRemoveAlternateComputerName(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(WKSSVC_NETRSETPRIMARYCOMPUTERNAME, &r);
- r.out.result = _WKSSVC_NETRSETPRIMARYCOMPUTERNAME(p);
+ r.out.result = _WKSSVC_NETRSETPRIMARYCOMPUTERNAME(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
if (DEBUGLEVEL >= 10)
NDR_PRINT_IN_DEBUG(WKSSVC_NETRENUMERATECOMPUTERNAMES, &r);
- r.out.result = _WKSSVC_NETRENUMERATECOMPUTERNAMES(p);
+ r.out.result = _WKSSVC_NETRENUMERATECOMPUTERNAMES(p, &r);
if (p->rng_fault_state) {
talloc_free(mem_ctx);
#include "librpc/gen_ndr/ndr_wkssvc.h"
#ifndef __SRV_WKSSVC__
#define __SRV_WKSSVC__
-WERROR _wkssvc_NetWkstaGetInfo(pipes_struct *p, const char *server_name, uint32_t level, union wkssvc_NetWkstaInfo *info);
-WERROR _wkssvc_NetWkstaSetInfo(pipes_struct *p, const char *server_name, uint32_t level, union wkssvc_NetWkstaInfo *info, uint32_t *parm_error);
-WERROR _wkssvc_NetWkstaEnumUsers(pipes_struct *p, const char *server_name, uint32_t level, union WKS_USER_ENUM_UNION *users, uint32_t prefmaxlen, uint32_t *entriesread, uint32_t *totalentries, uint32_t *resumehandle);
-WERROR _WKSSVC_NETRWKSTAUSERGETINFO(pipes_struct *p);
-WERROR _WKSSVC_NETRWKSTAUSERSETINFO(pipes_struct *p);
-WERROR _wkssvc_NetWkstaTransportEnum(pipes_struct *p, const char *server_name, uint32_t *level, union wkssvc_NetWkstaTransportCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle);
-WERROR _WKSSVC_NETRWKSTATRANSPORTADD(pipes_struct *p);
-WERROR _WKSSVC_NETRWKSTATRANSPORTDEL(pipes_struct *p);
-WERROR _WKSSVC_NETRUSEADD(pipes_struct *p);
-WERROR _WKSSVC_NETRUSEGETINFO(pipes_struct *p);
-WERROR _WKSSVC_NETRUSEDEL(pipes_struct *p);
-WERROR _WKSSVC_NETRUSEENUM(pipes_struct *p);
-WERROR _WKSSVC_NETRMESSAGEBUFFERSEND(pipes_struct *p);
-WERROR _WKSSVC_NETRWORKSTATIONSTATISTICSGET(pipes_struct *p);
-WERROR _WKSSVC_NETRLOGONDOMAINNAMEADD(pipes_struct *p);
-WERROR _WKSSVC_NETRLOGONDOMAINNAMEDEL(pipes_struct *p);
-WERROR _WKSSVC_NETRJOINDOMAIN(pipes_struct *p);
-WERROR _WKSSVC_NETRUNJOINDOMAIN(pipes_struct *p);
-WERROR _WKSSVC_NETRRENAMEMACHINEINDOMAIN(pipes_struct *p);
-WERROR _WKSSVC_NETRVALIDATENAME(pipes_struct *p);
-WERROR _WKSSVC_NETRGETJOININFORMATION(pipes_struct *p);
-WERROR _WKSSVC_NETRGETJOINABLEOUS(pipes_struct *p);
-WERROR _wkssvc_NetrJoinDomain2(pipes_struct *p, const char *server_name, const char *domain_name, const char *account_name, const char *admin_account, struct wkssvc_PasswordBuffer *encrypted_password, uint32_t join_flags);
-WERROR _wkssvc_NetrUnjoinDomain2(pipes_struct *p, const char *server_name, const char *account, struct wkssvc_PasswordBuffer *encrypted_password, uint32_t unjoin_flags);
-WERROR _wkssvc_NetrRenameMachineInDomain2(pipes_struct *p, const char *server_name, const char *NewMachineName, const char *Account, struct wkssvc_PasswordBuffer *EncryptedPassword, uint32_t RenameOptions);
-WERROR _WKSSVC_NETRVALIDATENAME2(pipes_struct *p);
-WERROR _WKSSVC_NETRGETJOINABLEOUS2(pipes_struct *p);
-WERROR _wkssvc_NetrAddAlternateComputerName(pipes_struct *p, const char *server_name, const char *NewAlternateMachineName, const char *Account, struct wkssvc_PasswordBuffer *EncryptedPassword, uint32_t Reserved);
-WERROR _wkssvc_NetrRemoveAlternateComputerName(pipes_struct *p, const char *server_name, const char *AlternateMachineNameToRemove, const char *Account, struct wkssvc_PasswordBuffer *EncryptedPassword, uint32_t Reserved);
-WERROR _WKSSVC_NETRSETPRIMARYCOMPUTERNAME(pipes_struct *p);
-WERROR _WKSSVC_NETRENUMERATECOMPUTERNAMES(pipes_struct *p);
+WERROR _wkssvc_NetWkstaGetInfo(pipes_struct *p, struct wkssvc_NetWkstaGetInfo *r);
+WERROR _wkssvc_NetWkstaSetInfo(pipes_struct *p, struct wkssvc_NetWkstaSetInfo *r);
+WERROR _wkssvc_NetWkstaEnumUsers(pipes_struct *p, struct wkssvc_NetWkstaEnumUsers *r);
+WERROR _WKSSVC_NETRWKSTAUSERGETINFO(pipes_struct *p, struct WKSSVC_NETRWKSTAUSERGETINFO *r);
+WERROR _WKSSVC_NETRWKSTAUSERSETINFO(pipes_struct *p, struct WKSSVC_NETRWKSTAUSERSETINFO *r);
+WERROR _wkssvc_NetWkstaTransportEnum(pipes_struct *p, struct wkssvc_NetWkstaTransportEnum *r);
+WERROR _WKSSVC_NETRWKSTATRANSPORTADD(pipes_struct *p, struct WKSSVC_NETRWKSTATRANSPORTADD *r);
+WERROR _WKSSVC_NETRWKSTATRANSPORTDEL(pipes_struct *p, struct WKSSVC_NETRWKSTATRANSPORTDEL *r);
+WERROR _WKSSVC_NETRUSEADD(pipes_struct *p, struct WKSSVC_NETRUSEADD *r);
+WERROR _WKSSVC_NETRUSEGETINFO(pipes_struct *p, struct WKSSVC_NETRUSEGETINFO *r);
+WERROR _WKSSVC_NETRUSEDEL(pipes_struct *p, struct WKSSVC_NETRUSEDEL *r);
+WERROR _WKSSVC_NETRUSEENUM(pipes_struct *p, struct WKSSVC_NETRUSEENUM *r);
+WERROR _WKSSVC_NETRMESSAGEBUFFERSEND(pipes_struct *p, struct WKSSVC_NETRMESSAGEBUFFERSEND *r);
+WERROR _WKSSVC_NETRWORKSTATIONSTATISTICSGET(pipes_struct *p, struct WKSSVC_NETRWORKSTATIONSTATISTICSGET *r);
+WERROR _WKSSVC_NETRLOGONDOMAINNAMEADD(pipes_struct *p, struct WKSSVC_NETRLOGONDOMAINNAMEADD *r);
+WERROR _WKSSVC_NETRLOGONDOMAINNAMEDEL(pipes_struct *p, struct WKSSVC_NETRLOGONDOMAINNAMEDEL *r);
+WERROR _WKSSVC_NETRJOINDOMAIN(pipes_struct *p, struct WKSSVC_NETRJOINDOMAIN *r);
+WERROR _WKSSVC_NETRUNJOINDOMAIN(pipes_struct *p, struct WKSSVC_NETRUNJOINDOMAIN *r);
+WERROR _WKSSVC_NETRRENAMEMACHINEINDOMAIN(pipes_struct *p, struct WKSSVC_NETRRENAMEMACHINEINDOMAIN *r);
+WERROR _WKSSVC_NETRVALIDATENAME(pipes_struct *p, struct WKSSVC_NETRVALIDATENAME *r);
+WERROR _WKSSVC_NETRGETJOININFORMATION(pipes_struct *p, struct WKSSVC_NETRGETJOININFORMATION *r);
+WERROR _WKSSVC_NETRGETJOINABLEOUS(pipes_struct *p, struct WKSSVC_NETRGETJOINABLEOUS *r);
+WERROR _wkssvc_NetrJoinDomain2(pipes_struct *p, struct wkssvc_NetrJoinDomain2 *r);
+WERROR _wkssvc_NetrUnjoinDomain2(pipes_struct *p, struct wkssvc_NetrUnjoinDomain2 *r);
+WERROR _wkssvc_NetrRenameMachineInDomain2(pipes_struct *p, struct wkssvc_NetrRenameMachineInDomain2 *r);
+WERROR _WKSSVC_NETRVALIDATENAME2(pipes_struct *p, struct WKSSVC_NETRVALIDATENAME2 *r);
+WERROR _WKSSVC_NETRGETJOINABLEOUS2(pipes_struct *p, struct WKSSVC_NETRGETJOINABLEOUS2 *r);
+WERROR _wkssvc_NetrAddAlternateComputerName(pipes_struct *p, struct wkssvc_NetrAddAlternateComputerName *r);
+WERROR _wkssvc_NetrRemoveAlternateComputerName(pipes_struct *p, struct wkssvc_NetrRemoveAlternateComputerName *r);
+WERROR _WKSSVC_NETRSETPRIMARYCOMPUTERNAME(pipes_struct *p, struct WKSSVC_NETRSETPRIMARYCOMPUTERNAME *r);
+WERROR _WKSSVC_NETRENUMERATECOMPUTERNAMES(pipes_struct *p, struct WKSSVC_NETRENUMERATECOMPUTERNAMES *r);
void wkssvc_get_pipe_fns(struct api_struct **fns, int *n_fns);
NTSTATUS rpc_wkssvc_init(void);
#endif /* __SRV_WKSSVC__ */
/* This function does not return a WERROR or NTSTATUS code but rather 1 if
dfs exists, or 0 otherwise. */
-void _dfs_GetManagerVersion(pipes_struct *p, uint32 *exists)
+void _dfs_GetManagerVersion(pipes_struct *p, struct dfs_GetManagerVersion *r)
{
if(lp_host_msdfs())
- *exists = 1;
+ *r->out.exist_flag = 1;
else
- *exists = 0;
+ *r->out.exist_flag = 0;
}
-WERROR _dfs_Add(pipes_struct *p, const char *path, const char *server, const char *share, const char *comment, uint32_t flags)
+WERROR _dfs_Add(pipes_struct *p, struct dfs_Add *r)
{
struct junction_map jn;
struct referral* old_referral_list = NULL;
}
DEBUG(5,("init_reply_dfs_add: Request to add %s -> %s\\%s.\n",
- path, server, share));
+ r->in.path, r->in.server, r->in.share));
- pstrcpy(altpath, server);
+ pstrcpy(altpath, r->in.server);
pstrcat(altpath, "\\");
- pstrcat(altpath, share);
+ pstrcat(altpath, r->in.share);
/* The following call can change the cwd. */
- if(get_referred_path(p->mem_ctx, path, &jn, NULL, NULL)) {
+ if(get_referred_path(p->mem_ctx, r->in.path, &jn, NULL, NULL)) {
exists = True;
jn.referral_count += 1;
old_referral_list = jn.referral_list;
return WERR_OK;
}
-WERROR _dfs_Remove(pipes_struct *p, const char *path, const char *server, const char *share)
+WERROR _dfs_Remove(pipes_struct *p, struct dfs_Remove *r)
{
struct junction_map jn;
BOOL found = False;
return WERR_ACCESS_DENIED;
}
- if(server && share) {
- pstrcpy(altpath, server);
+ if (r->in.server && r->in.share) {
+ pstrcpy(altpath, r->in.server);
pstrcat(altpath, "\\");
- pstrcat(altpath, share);
+ pstrcat(altpath, r->in.share);
strlower_m(altpath);
}
DEBUG(5,("init_reply_dfs_remove: Request to remove %s -> %s\\%s.\n",
- path, server, share));
+ r->in.path, r->in.server, r->in.share));
- if(!get_referred_path(p->mem_ctx, path, &jn, NULL, NULL)) {
+ if(!get_referred_path(p->mem_ctx, r->in.path, &jn, NULL, NULL)) {
return WERR_DFS_NO_SUCH_VOL;
}
/* if no server-share pair given, remove the msdfs link completely */
- if(!server && !share) {
+ if(!r->in.server && !r->in.share) {
if(!remove_msdfs_link(&jn)) {
vfs_ChDir(p->conn,p->conn->connectpath);
return WERR_DFS_NO_SUCH_VOL;
}
-WERROR _dfs_Enum(pipes_struct *p, uint32_t level, uint32_t bufsize, struct dfs_EnumStruct *info, uint32_t *unknown, uint32_t *total)
+WERROR _dfs_Enum(pipes_struct *p, struct dfs_Enum *r)
{
struct junction_map jn[MAX_MSDFS_JUNCTIONS];
int num_jn = 0;
num_jn = enum_msdfs_links(p->mem_ctx, jn, ARRAY_SIZE(jn));
vfs_ChDir(p->conn,p->conn->connectpath);
- DEBUG(5,("_dfs_Enum: %d junctions found in Dfs, doing level %d\n", num_jn, level));
+ DEBUG(5,("_dfs_Enum: %d junctions found in Dfs, doing level %d\n", num_jn, r->in.level));
- *total = num_jn;
+ *r->out.total = num_jn;
/* Create the return array */
- switch (level) {
+ switch (r->in.level) {
case 1:
- if ((info->e.info1->s = TALLOC_ARRAY(p->mem_ctx, struct dfs_Info1, num_jn)) == NULL) {
+ if ((r->out.info->e.info1->s = TALLOC_ARRAY(p->mem_ctx, struct dfs_Info1, num_jn)) == NULL) {
return WERR_NOMEM;
}
- info->e.info1->count = num_jn;
+ r->out.info->e.info1->count = num_jn;
break;
case 2:
- if ((info->e.info2->s = TALLOC_ARRAY(p->mem_ctx, struct dfs_Info2, num_jn)) == NULL) {
+ if ((r->out.info->e.info2->s = TALLOC_ARRAY(p->mem_ctx, struct dfs_Info2, num_jn)) == NULL) {
return WERR_NOMEM;
}
- info->e.info2->count = num_jn;
+ r->out.info->e.info2->count = num_jn;
break;
case 3:
- if ((info->e.info3->s = TALLOC_ARRAY(p->mem_ctx, struct dfs_Info3, num_jn)) == NULL) {
+ if ((r->out.info->e.info3->s = TALLOC_ARRAY(p->mem_ctx, struct dfs_Info3, num_jn)) == NULL) {
return WERR_NOMEM;
}
- info->e.info3->count = num_jn;
+ r->out.info->e.info3->count = num_jn;
break;
default:
return WERR_INVALID_PARAM;
}
for (i = 0; i < num_jn; i++) {
- switch (level) {
+ switch (r->in.level) {
case 1:
- init_reply_dfs_info_1(p->mem_ctx, &jn[i], &info->e.info1->s[i]);
+ init_reply_dfs_info_1(p->mem_ctx, &jn[i], &r->out.info->e.info1->s[i]);
break;
case 2:
- init_reply_dfs_info_2(p->mem_ctx, &jn[i], &info->e.info2->s[i]);
+ init_reply_dfs_info_2(p->mem_ctx, &jn[i], &r->out.info->e.info2->s[i]);
break;
case 3:
- init_reply_dfs_info_3(p->mem_ctx, &jn[i], &info->e.info3->s[i]);
+ init_reply_dfs_info_3(p->mem_ctx, &jn[i], &r->out.info->e.info3->s[i]);
break;
default:
return WERR_INVALID_PARAM;
return WERR_OK;
}
-WERROR _dfs_GetInfo(pipes_struct *p, const char *path, const char *server, const char *share, uint32_t level, union dfs_Info *info)
+WERROR _dfs_GetInfo(pipes_struct *p, struct dfs_GetInfo *r)
{
int consumedcnt = sizeof(pstring);
struct junction_map jn;
BOOL ret;
- if(!create_junction(path, &jn))
+ if(!create_junction(r->in.path, &jn))
return WERR_DFS_NO_SUCH_SERVER;
/* The following call can change the cwd. */
- if(!get_referred_path(p->mem_ctx, path, &jn, &consumedcnt, NULL) || consumedcnt < strlen(path)) {
+ if(!get_referred_path(p->mem_ctx, r->in.path, &jn, &consumedcnt, NULL) || consumedcnt < strlen(r->in.path)) {
vfs_ChDir(p->conn,p->conn->connectpath);
return WERR_DFS_NO_SUCH_VOL;
}
vfs_ChDir(p->conn,p->conn->connectpath);
- switch (level) {
- case 1: ret = init_reply_dfs_info_1(p->mem_ctx, &jn, info->info1); break;
- case 2: ret = init_reply_dfs_info_2(p->mem_ctx, &jn, info->info2); break;
- case 3: ret = init_reply_dfs_info_3(p->mem_ctx, &jn, info->info3); break;
- case 100: ret = init_reply_dfs_info_100(p->mem_ctx, &jn, info->info100); break;
+ switch (r->in.level) {
+ case 1: ret = init_reply_dfs_info_1(p->mem_ctx, &jn, r->out.info->info1); break;
+ case 2: ret = init_reply_dfs_info_2(p->mem_ctx, &jn, r->out.info->info2); break;
+ case 3: ret = init_reply_dfs_info_3(p->mem_ctx, &jn, r->out.info->info3); break;
+ case 100: ret = init_reply_dfs_info_100(p->mem_ctx, &jn, r->out.info->info100); break;
default:
- info->info1 = NULL;
+ r->out.info->info1 = NULL;
return WERR_INVALID_PARAM;
}
return WERR_OK;
}
-WERROR _dfs_SetInfo(pipes_struct *p)
+WERROR _dfs_SetInfo(pipes_struct *p, struct dfs_SetInfo *r)
{
/* FIXME: Implement your code here */
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _dfs_Rename(pipes_struct *p)
+WERROR _dfs_Rename(pipes_struct *p, struct dfs_Rename *r)
{
/* FIXME: Implement your code here */
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _dfs_Move(pipes_struct *p)
+WERROR _dfs_Move(pipes_struct *p, struct dfs_Move *r)
{
/* FIXME: Implement your code here */
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _dfs_ManagerGetConfigInfo(pipes_struct *p)
+WERROR _dfs_ManagerGetConfigInfo(pipes_struct *p, struct dfs_ManagerGetConfigInfo *r)
{
/* FIXME: Implement your code here */
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _dfs_ManagerSendSiteInfo(pipes_struct *p)
+WERROR _dfs_ManagerSendSiteInfo(pipes_struct *p, struct dfs_ManagerSendSiteInfo *r)
{
/* FIXME: Implement your code here */
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _dfs_AddFtRoot(pipes_struct *p)
+WERROR _dfs_AddFtRoot(pipes_struct *p, struct dfs_AddFtRoot *r)
{
/* FIXME: Implement your code here */
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _dfs_RemoveFtRoot(pipes_struct *p)
+WERROR _dfs_RemoveFtRoot(pipes_struct *p, struct dfs_RemoveFtRoot *r)
{
/* FIXME: Implement your code here */
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _dfs_AddStdRoot(pipes_struct *p)
+WERROR _dfs_AddStdRoot(pipes_struct *p, struct dfs_AddStdRoot *r)
{
/* FIXME: Implement your code here */
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _dfs_RemoveStdRoot(pipes_struct *p)
+WERROR _dfs_RemoveStdRoot(pipes_struct *p, struct dfs_RemoveStdRoot *r)
{
/* FIXME: Implement your code here */
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _dfs_ManagerInitialize(pipes_struct *p)
+WERROR _dfs_ManagerInitialize(pipes_struct *p, struct dfs_ManagerInitialize *r)
{
/* FIXME: Implement your code here */
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _dfs_AddStdRootForced(pipes_struct *p)
+WERROR _dfs_AddStdRootForced(pipes_struct *p, struct dfs_AddStdRootForced *r)
{
/* FIXME: Implement your code here */
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _dfs_GetDcAddress(pipes_struct *p)
+WERROR _dfs_GetDcAddress(pipes_struct *p, struct dfs_GetDcAddress *r)
{
/* FIXME: Implement your code here */
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _dfs_SetDcAddress(pipes_struct *p)
+WERROR _dfs_SetDcAddress(pipes_struct *p, struct dfs_SetDcAddress *r)
{
/* FIXME: Implement your code here */
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _dfs_FlushFtTable(pipes_struct *p)
+WERROR _dfs_FlushFtTable(pipes_struct *p, struct dfs_FlushFtTable *r)
{
/* FIXME: Implement your code here */
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _dfs_Add2(pipes_struct *p)
+WERROR _dfs_Add2(pipes_struct *p, struct dfs_Add2 *r)
{
/* FIXME: Implement your code here */
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _dfs_Remove2(pipes_struct *p)
+WERROR _dfs_Remove2(pipes_struct *p, struct dfs_Remove2 *r)
{
/* FIXME: Implement your code here */
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _dfs_EnumEx(pipes_struct *p, const char *name, uint32_t level, uint32_t bufsize, struct dfs_EnumStruct *info, uint32_t *total)
+WERROR _dfs_EnumEx(pipes_struct *p, struct dfs_EnumEx *r)
{
/* FIXME: Implement your code here */
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _dfs_SetInfo2(pipes_struct *p)
+WERROR _dfs_SetInfo2(pipes_struct *p, struct dfs_SetInfo2 *r)
{
/* FIXME: Implement your code here */
p->rng_fault_state = True;
/* Add one to the input and return it */
-void _echo_AddOne(pipes_struct *p, uint32_t in_data, uint32_t *out_data)
+void _echo_AddOne(pipes_struct *p, struct echo_AddOne *r)
{
DEBUG(10, ("_echo_add_one\n"));
- *out_data = in_data + 1;
+ *r->out.out_data = r->in.in_data + 1;
}
/* Echo back an array of data */
-void _echo_EchoData(pipes_struct *p, uint32_t len, uint8_t *in_data, uint8_t *out_data)
+void _echo_EchoData(pipes_struct *p, struct echo_EchoData *r)
{
DEBUG(10, ("_echo_data\n"));
- memcpy(out_data, in_data, len);
+ memcpy(r->out.out_data, r->in.in_data, r->in.len);
}
/* Sink an array of data */
-void _echo_SinkData(pipes_struct *p, uint32_t len, uint8_t *data)
+void _echo_SinkData(pipes_struct *p, struct echo_SinkData *r)
{
DEBUG(10, ("_sink_data\n"));
/* Source an array of data */
-void _echo_SourceData(pipes_struct *p, uint32_t len, uint8_t *data)
+void _echo_SourceData(pipes_struct *p, struct echo_SourceData *r)
{
uint32 i;
DEBUG(10, ("_source_data\n"));
- for (i = 0; i < len; i++)
- data[i] = i & 0xff;
+ for (i = 0; i < r->in.len; i++)
+ r->out.data[i] = i & 0xff;
}
-void _echo_TestCall(pipes_struct *p, const char *s1, const char **s2)
+void _echo_TestCall(pipes_struct *p, struct echo_TestCall *r)
{
- *s2 = talloc_strdup(p->mem_ctx, s1);
+ *r->out.s2 = talloc_strdup(p->mem_ctx, r->in.s1);
}
-NTSTATUS _echo_TestCall2(pipes_struct *p, uint16_t level, union echo_Info *info)
+NTSTATUS _echo_TestCall2(pipes_struct *p, struct echo_TestCall2 *r)
{
- switch (level) {
+ switch (r->in.level) {
case 1:
- info->info1.v = 10;
+ r->out.info->info1.v = 10;
break;
case 2:
- info->info2.v = 20;
+ r->out.info->info2.v = 20;
break;
case 3:
- info->info3.v = 30;
+ r->out.info->info3.v = 30;
break;
case 4:
- info->info4.v = 40;
+ r->out.info->info4.v = 40;
break;
case 5:
- info->info5.v1 = 50;
- info->info5.v2 = 60;
+ r->out.info->info5.v1 = 50;
+ r->out.info->info5.v2 = 60;
break;
case 6:
- info->info6.v1 = 70;
- info->info6.info1.v= 80;
+ r->out.info->info6.v1 = 70;
+ r->out.info->info6.info1.v= 80;
break;
case 7:
- info->info7.v1 = 80;
- info->info7.info4.v = 90;
+ r->out.info->info7.v1 = 80;
+ r->out.info->info7.info4.v = 90;
break;
default:
return NT_STATUS_INVALID_LEVEL;
return NT_STATUS_OK;
}
-uint32 _echo_TestSleep(pipes_struct *p, uint32_t seconds)
+uint32 _echo_TestSleep(pipes_struct *p, struct echo_TestSleep *r)
{
- sleep(seconds);
- return seconds;
+ sleep(r->in.seconds);
+ return r->in.seconds;
}
-void _echo_TestEnum(pipes_struct *p, enum echo_Enum1 *foo1, struct echo_Enum2 *foo2, union echo_Enum3 *foo3)
+void _echo_TestEnum(pipes_struct *p, struct echo_TestEnum *r)
{
}
-void _echo_TestSurrounding(pipes_struct *p, struct echo_Surrounding *data)
+void _echo_TestSurrounding(pipes_struct *p, struct echo_TestSurrounding *r)
{
- data->x *= 2;
- data->surrounding = talloc_zero_array(p->mem_ctx, uint16_t, data->x);
+ r->out.data->x *= 2;
+ r->out.data->surrounding = talloc_zero_array(p->mem_ctx, uint16_t, r->in.data->x);
}
-uint16 _echo_TestDoublePointer(pipes_struct *p, uint16_t ***data)
+uint16 _echo_TestDoublePointer(pipes_struct *p, struct echo_TestDoublePointer *r)
{
- if (!*data)
+ if (!*r->in.data)
return 0;
- if (!**data)
+ if (!**r->in.data)
return 0;
- return ***data;
+ return ***r->in.data;
}
#endif /* DEVELOPER */
/*******************************************************************
********************************************************************/
-WERROR _initshutdown_Init(pipes_struct *p, uint16_t *hostname, struct initshutdown_String *message, uint32_t timeout, uint8_t force_apps, uint8_t reboot)
+WERROR _initshutdown_Init(pipes_struct *p, struct initshutdown_Init *r)
{
- uint32_t reason = 0;
+ struct winreg_InitiateSystemShutdownEx s;
+
+ s.in.hostname = r->in.hostname;
+ s.in.message = r->in.message;
+ s.in.timeout = r->in.timeout;
+ s.in.force_apps = r->in.force_apps;
+ s.in.reboot = r->in.reboot;
+ s.in.reason = 0;
/* thunk down to _winreg_InitiateSystemShutdownEx()
(just returns a status) */
- return _winreg_InitiateSystemShutdownEx( p, hostname, message, timeout,
- force_apps, reboot, reason );
+ return _winreg_InitiateSystemShutdownEx( p, &s );
}
/*******************************************************************
********************************************************************/
-WERROR _initshutdown_InitEx(pipes_struct *p, uint16_t *hostname, struct initshutdown_String *message, uint32_t timeout, uint8_t force_apps, uint8_t reboot, uint32_t reason)
+WERROR _initshutdown_InitEx(pipes_struct *p, struct initshutdown_InitEx *r)
{
- return _winreg_InitiateSystemShutdownEx( p, hostname, message, timeout,
- force_apps, reboot, reason );
+ struct winreg_InitiateSystemShutdownEx s;
+ s.in.hostname = r->in.hostname;
+ s.in.message = r->in.message;
+ s.in.timeout = r->in.timeout;
+ s.in.force_apps = r->in.force_apps;
+ s.in.reboot = r->in.reboot;
+ s.in.reason = r->in.reason;
+
+ return _winreg_InitiateSystemShutdownEx( p, &s);
}
reg_abort_shutdwon
********************************************************************/
-WERROR _initshutdown_Abort(pipes_struct *p, uint16_t *server)
+WERROR _initshutdown_Abort(pipes_struct *p, struct initshutdown_Abort *r)
{
- return _winreg_AbortSystemShutdown( p, server );
+ struct winreg_AbortSystemShutdown s;
+ s.in.server = r->in.server;
+ return _winreg_AbortSystemShutdown( p, &s );
}
_lsa_close. Also weird - needs to check if lsa handle is correct. JRA.
***************************************************************************/
-NTSTATUS _lsa_Close(pipes_struct *p, struct policy_handle *handle)
+NTSTATUS _lsa_Close(pipes_struct *p, struct lsa_Close *r)
{
- if (!find_policy_by_hnd(p, handle, NULL)) {
+ if (!find_policy_by_hnd(p, r->in.handle, NULL)) {
return NT_STATUS_INVALID_HANDLE;
}
- close_policy_hnd(p, handle);
+ close_policy_hnd(p, r->in.handle);
return NT_STATUS_OK;
}
/***************************************************************************
***************************************************************************/
-NTSTATUS _lsa_OpenSecret(pipes_struct *p, struct policy_handle *handle,
- struct lsa_String name, uint32_t access_mask,
- struct policy_handle *sec_handle)
+NTSTATUS _lsa_OpenSecret(pipes_struct *p, struct lsa_OpenSecret *r)
{
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
}
/***************************************************************************
***************************************************************************/
-NTSTATUS _lsa_OpenTrustedDomain(pipes_struct *p, struct policy_handle *handle,
- struct dom_sid2 *sid, uint32_t access_mask,
- struct policy_handle *trustdom_handle)
+NTSTATUS _lsa_OpenTrustedDomain(pipes_struct *p, struct lsa_OpenTrustedDomain *r)
{
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
}
/***************************************************************************
***************************************************************************/
-NTSTATUS _lsa_CreateTrustedDomain(pipes_struct *p,
- struct policy_handle *handle,
- struct lsa_DomainInfo *info,
- uint32_t access_mask,
- struct policy_handle *trustdom_handle)
+NTSTATUS _lsa_CreateTrustedDomain(pipes_struct *p, struct lsa_CreateTrustedDomain *r)
{
return NT_STATUS_ACCESS_DENIED;
}
/***************************************************************************
***************************************************************************/
-NTSTATUS _lsa_CreateSecret(pipes_struct *p, struct policy_handle *handle,
- struct lsa_String name, uint32_t access_mask,
- struct policy_handle *sec_handle)
+NTSTATUS _lsa_CreateSecret(pipes_struct *p, struct lsa_CreateSecret *r)
{
return NT_STATUS_ACCESS_DENIED;
}
/***************************************************************************
***************************************************************************/
-NTSTATUS _lsa_SetSecret(pipes_struct *p, struct policy_handle *sec_handle,
- struct lsa_DATA_BUF *new_val,
- struct lsa_DATA_BUF *old_val)
+NTSTATUS _lsa_SetSecret(pipes_struct *p, struct lsa_SetSecret *r)
{
return NT_STATUS_ACCESS_DENIED;
}
* pulling the server stubs across one by one.
*/
-NTSTATUS _lsa_Delete(pipes_struct *p, struct policy_handle *handle)
+NTSTATUS _lsa_Delete(pipes_struct *p, struct lsa_Delete *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_EnumPrivs(pipes_struct *p, struct policy_handle *handle, uint32_t *resume_handle, uint32_t max_count, struct lsa_PrivArray *_privs)
+NTSTATUS _lsa_EnumPrivs(pipes_struct *p, struct lsa_EnumPrivs *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_QuerySecurity(pipes_struct *p, struct policy_handle *handle, uint32_t sec_info, struct sec_desc_buf *sdbuf)
+NTSTATUS _lsa_QuerySecurity(pipes_struct *p, struct lsa_QuerySecurity *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_SetSecObj(pipes_struct *p)
+NTSTATUS _lsa_SetSecObj(pipes_struct *p, struct lsa_SetSecObj *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_ChangePassword(pipes_struct *p)
+NTSTATUS _lsa_ChangePassword(pipes_struct *p, struct lsa_ChangePassword *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_OpenPolicy(pipes_struct *p, uint16_t *system_name, struct lsa_ObjectAttribute *attr, uint32_t access_mask, struct policy_handle *handle)
+NTSTATUS _lsa_OpenPolicy(pipes_struct *p, struct lsa_OpenPolicy *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_QueryInfoPolicy(pipes_struct *p, struct policy_handle *handle, uint16_t level, union lsa_PolicyInformation *info)
+NTSTATUS _lsa_QueryInfoPolicy(pipes_struct *p, struct lsa_QueryInfoPolicy *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_SetInfoPolicy(pipes_struct *p)
+NTSTATUS _lsa_SetInfoPolicy(pipes_struct *p, struct lsa_SetInfoPolicy *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_ClearAuditLog(pipes_struct *p)
+NTSTATUS _lsa_ClearAuditLog(pipes_struct *p, struct lsa_ClearAuditLog *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_CreateAccount(pipes_struct *p, struct policy_handle *handle, struct dom_sid2 *sid, uint32_t access_mask, struct policy_handle *acct_handle)
+NTSTATUS _lsa_CreateAccount(pipes_struct *p, struct lsa_CreateAccount *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_EnumAccounts(pipes_struct *p, struct policy_handle *handle, uint32_t *resume_handle, uint32_t num_entries, struct lsa_SidArray *sids)
+NTSTATUS _lsa_EnumAccounts(pipes_struct *p, struct lsa_EnumAccounts *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_EnumTrustDom(pipes_struct *p, struct policy_handle *handle, uint32_t *resume_handle, uint32_t max_size, struct lsa_DomainList *domains)
+NTSTATUS _lsa_EnumTrustDom(pipes_struct *p, struct lsa_EnumTrustDom *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_LookupNames(pipes_struct *p, struct policy_handle *handle, uint32_t num_names, struct lsa_String *names, struct lsa_RefDomainList *domains, struct lsa_TransSidArray *sids, uint16_t level, uint32_t *count)
+NTSTATUS _lsa_LookupNames(pipes_struct *p, struct lsa_LookupNames *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_LookupSids(pipes_struct *p, struct policy_handle *handle, struct lsa_SidArray *sids, struct lsa_RefDomainList *domains, struct lsa_TransNameArray *names, uint16_t level, uint32_t *count)
+NTSTATUS _lsa_LookupSids(pipes_struct *p, struct lsa_LookupSids *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_OpenAccount(pipes_struct *p, struct policy_handle *handle, struct dom_sid2 *sid, uint32_t access_mask, struct policy_handle *acct_handle)
+NTSTATUS _lsa_OpenAccount(pipes_struct *p, struct lsa_OpenAccount *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_EnumPrivsAccount(pipes_struct *p, struct policy_handle *handle, struct lsa_PrivilegeSet *_privs)
+NTSTATUS _lsa_EnumPrivsAccount(pipes_struct *p, struct lsa_EnumPrivsAccount *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_AddPrivilegesToAccount(pipes_struct *p, struct policy_handle *handle, struct lsa_PrivilegeSet *_privs)
+NTSTATUS _lsa_AddPrivilegesToAccount(pipes_struct *p, struct lsa_AddPrivilegesToAccount *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_RemovePrivilegesFromAccount(pipes_struct *p, struct policy_handle *handle, uint8_t remove_all, struct lsa_PrivilegeSet *_privs)
+NTSTATUS _lsa_RemovePrivilegesFromAccount(pipes_struct *p, struct lsa_RemovePrivilegesFromAccount *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_GetQuotasForAccount(pipes_struct *p)
+NTSTATUS _lsa_GetQuotasForAccount(pipes_struct *p, struct lsa_GetQuotasForAccount *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_SetQuotasForAccount(pipes_struct *p)
+NTSTATUS _lsa_SetQuotasForAccount(pipes_struct *p, struct lsa_SetQuotasForAccount *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_GetSystemAccessAccount(pipes_struct *p)
+NTSTATUS _lsa_GetSystemAccessAccount(pipes_struct *p, struct lsa_GetSystemAccessAccount *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_SetSystemAccessAccount(pipes_struct *p)
+NTSTATUS _lsa_SetSystemAccessAccount(pipes_struct *p, struct lsa_SetSystemAccessAccount *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_QueryTrustedDomainInfo(pipes_struct *p, struct policy_handle *trustdom_handle, enum lsa_TrustDomInfoEnum level, union lsa_TrustedDomainInfo *info)
+NTSTATUS _lsa_QueryTrustedDomainInfo(pipes_struct *p, struct lsa_QueryTrustedDomainInfo *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_SetInformationTrustedDomain(pipes_struct *p)
+NTSTATUS _lsa_SetInformationTrustedDomain(pipes_struct *p, struct lsa_SetInformationTrustedDomain *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_QuerySecret(pipes_struct *p, struct policy_handle *sec_handle, struct lsa_DATA_BUF_PTR *new_val, NTTIME *new_mtime, struct lsa_DATA_BUF_PTR *old_val, NTTIME *old_mtime)
+NTSTATUS _lsa_QuerySecret(pipes_struct *p, struct lsa_QuerySecret *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_LookupPrivValue(pipes_struct *p, struct policy_handle *handle, struct lsa_String *name, struct lsa_LUID *luid)
+NTSTATUS _lsa_LookupPrivValue(pipes_struct *p, struct lsa_LookupPrivValue *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_LookupPrivName(pipes_struct *p, struct policy_handle *handle, struct lsa_LUID *luid, struct lsa_StringLarge *name)
+NTSTATUS _lsa_LookupPrivName(pipes_struct *p, struct lsa_LookupPrivName *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_LookupPrivDisplayName(pipes_struct *p, struct policy_handle *handle, struct lsa_String *name, struct lsa_StringLarge *disp_name, uint16_t *language_id, uint16_t unknown)
+NTSTATUS _lsa_LookupPrivDisplayName(pipes_struct *p, struct lsa_LookupPrivDisplayName *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_DeleteObject(pipes_struct *p)
+NTSTATUS _lsa_DeleteObject(pipes_struct *p, struct lsa_DeleteObject *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_EnumAccountsWithUserRight(pipes_struct *p, struct policy_handle *handle, struct lsa_String *name, struct lsa_SidArray *sids)
+NTSTATUS _lsa_EnumAccountsWithUserRight(pipes_struct *p, struct lsa_EnumAccountsWithUserRight *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_EnumAccountRights(pipes_struct *p, struct policy_handle *handle, struct dom_sid2 *sid, struct lsa_RightSet *rights)
+NTSTATUS _lsa_EnumAccountRights(pipes_struct *p, struct lsa_EnumAccountRights *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_AddAccountRights(pipes_struct *p, struct policy_handle *handle, struct dom_sid2 *sid, struct lsa_RightSet *rights)
+NTSTATUS _lsa_AddAccountRights(pipes_struct *p, struct lsa_AddAccountRights *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_RemoveAccountRights(pipes_struct *p, struct policy_handle *handle, struct dom_sid2 *sid, uint32_t unknown, struct lsa_RightSet *rights)
+NTSTATUS _lsa_RemoveAccountRights(pipes_struct *p, struct lsa_RemoveAccountRights *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_QueryTrustedDomainInfoBySid(pipes_struct *p, struct policy_handle *handle, struct dom_sid2 *dom_sid, enum lsa_TrustDomInfoEnum level, union lsa_TrustedDomainInfo *info)
+NTSTATUS _lsa_QueryTrustedDomainInfoBySid(pipes_struct *p, struct lsa_QueryTrustedDomainInfoBySid *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_SetTrustedDomainInfo(pipes_struct *p)
+NTSTATUS _lsa_SetTrustedDomainInfo(pipes_struct *p, struct lsa_SetTrustedDomainInfo *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_DeleteTrustedDomain(pipes_struct *p, struct policy_handle *handle, struct dom_sid2 *dom_sid)
+NTSTATUS _lsa_DeleteTrustedDomain(pipes_struct *p, struct lsa_DeleteTrustedDomain *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_StorePrivateData(pipes_struct *p)
+NTSTATUS _lsa_StorePrivateData(pipes_struct *p, struct lsa_StorePrivateData *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_RetrievePrivateData(pipes_struct *p)
+NTSTATUS _lsa_RetrievePrivateData(pipes_struct *p, struct lsa_RetrievePrivateData *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_OpenPolicy2(pipes_struct *p, const char *system_name, struct lsa_ObjectAttribute *attr, uint32_t access_mask, struct policy_handle *handle)
+NTSTATUS _lsa_OpenPolicy2(pipes_struct *p, struct lsa_OpenPolicy2 *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_GetUserName(pipes_struct *p, const char *system_name, struct lsa_String *account_name, struct lsa_StringPointer *authority_name)
+NTSTATUS _lsa_GetUserName(pipes_struct *p, struct lsa_GetUserName *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_QueryInfoPolicy2(pipes_struct *p, struct policy_handle *handle, uint16_t level, union lsa_PolicyInformation *info)
+NTSTATUS _lsa_QueryInfoPolicy2(pipes_struct *p, struct lsa_QueryInfoPolicy2 *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_SetInfoPolicy2(pipes_struct *p)
+NTSTATUS _lsa_SetInfoPolicy2(pipes_struct *p, struct lsa_SetInfoPolicy2 *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_QueryTrustedDomainInfoByName(pipes_struct *p, struct policy_handle *handle, struct lsa_String trusted_domain, enum lsa_TrustDomInfoEnum level, union lsa_TrustedDomainInfo *info)
+NTSTATUS _lsa_QueryTrustedDomainInfoByName(pipes_struct *p, struct lsa_QueryTrustedDomainInfoByName *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_SetTrustedDomainInfoByName(pipes_struct *p, struct policy_handle *handle, struct lsa_String trusted_domain, enum lsa_TrustDomInfoEnum level, union lsa_TrustedDomainInfo *info)
+NTSTATUS _lsa_SetTrustedDomainInfoByName(pipes_struct *p, struct lsa_SetTrustedDomainInfoByName *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_EnumTrustedDomainsEx(pipes_struct *p, struct policy_handle *handle, uint32_t *resume_handle, struct lsa_DomainListEx *domains, uint32_t max_size)
+NTSTATUS _lsa_EnumTrustedDomainsEx(pipes_struct *p, struct lsa_EnumTrustedDomainsEx *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_CreateTrustedDomainEx(pipes_struct *p)
+NTSTATUS _lsa_CreateTrustedDomainEx(pipes_struct *p, struct lsa_CreateTrustedDomainEx *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_CloseTrustedDomainEx(pipes_struct *p, struct policy_handle *handle)
+NTSTATUS _lsa_CloseTrustedDomainEx(pipes_struct *p, struct lsa_CloseTrustedDomainEx *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_QueryDomainInformationPolicy(pipes_struct *p, struct policy_handle *handle, uint16_t level, union lsa_DomainInformationPolicy *info)
+NTSTATUS _lsa_QueryDomainInformationPolicy(pipes_struct *p, struct lsa_QueryDomainInformationPolicy *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_SetDomainInformationPolicy(pipes_struct *p, struct policy_handle *handle, uint16_t level, union lsa_DomainInformationPolicy *info)
+NTSTATUS _lsa_SetDomainInformationPolicy(pipes_struct *p, struct lsa_SetDomainInformationPolicy *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_OpenTrustedDomainByName(pipes_struct *p, struct policy_handle *handle, struct lsa_String name, uint32_t access_mask, struct policy_handle *trustdom_handle)
+NTSTATUS _lsa_OpenTrustedDomainByName(pipes_struct *p, struct lsa_OpenTrustedDomainByName *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_TestCall(pipes_struct *p)
+NTSTATUS _lsa_TestCall(pipes_struct *p, struct lsa_TestCall *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_LookupSids2(pipes_struct *p, struct policy_handle *handle, struct lsa_SidArray *sids, struct lsa_RefDomainList *domains, struct lsa_TransNameArray2 *names, uint16_t level, uint32_t *count, uint32_t unknown1, uint32_t unknown2)
+NTSTATUS _lsa_LookupSids2(pipes_struct *p, struct lsa_LookupSids2 *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_LookupNames2(pipes_struct *p, struct policy_handle *handle, uint32_t num_names, struct lsa_String *names, struct lsa_RefDomainList *domains, struct lsa_TransSidArray2 *sids, uint16_t level, uint32_t *count, uint32_t unknown1, uint32_t unknown2)
+NTSTATUS _lsa_LookupNames2(pipes_struct *p, struct lsa_LookupNames2 *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_CreateTrustedDomainEx2(pipes_struct *p)
+NTSTATUS _lsa_CreateTrustedDomainEx2(pipes_struct *p, struct lsa_CreateTrustedDomainEx2 *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_CREDRWRITE(pipes_struct *p)
+NTSTATUS _lsa_CREDRWRITE(pipes_struct *p, struct lsa_CREDRWRITE *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_CREDRREAD(pipes_struct *p)
+NTSTATUS _lsa_CREDRREAD(pipes_struct *p, struct lsa_CREDRREAD *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_CREDRENUMERATE(pipes_struct *p)
+NTSTATUS _lsa_CREDRENUMERATE(pipes_struct *p, struct lsa_CREDRENUMERATE *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_CREDRWRITEDOMAINCREDENTIALS(pipes_struct *p)
+NTSTATUS _lsa_CREDRWRITEDOMAINCREDENTIALS(pipes_struct *p, struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_CREDRREADDOMAINCREDENTIALS(pipes_struct *p)
+NTSTATUS _lsa_CREDRREADDOMAINCREDENTIALS(pipes_struct *p, struct lsa_CREDRREADDOMAINCREDENTIALS *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_CREDRDELETE(pipes_struct *p)
+NTSTATUS _lsa_CREDRDELETE(pipes_struct *p, struct lsa_CREDRDELETE *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_CREDRGETTARGETINFO(pipes_struct *p)
+NTSTATUS _lsa_CREDRGETTARGETINFO(pipes_struct *p, struct lsa_CREDRGETTARGETINFO *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_CREDRPROFILELOADED(pipes_struct *p)
+NTSTATUS _lsa_CREDRPROFILELOADED(pipes_struct *p, struct lsa_CREDRPROFILELOADED *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_LookupNames3(pipes_struct *p, struct policy_handle *handle, uint32_t num_names, struct lsa_String *names, struct lsa_RefDomainList *domains, struct lsa_TransSidArray3 *sids, uint16_t level, uint32_t *count, uint32_t unknown1, uint32_t unknown2)
+NTSTATUS _lsa_LookupNames3(pipes_struct *p, struct lsa_LookupNames3 *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_CREDRGETSESSIONTYPES(pipes_struct *p)
+NTSTATUS _lsa_CREDRGETSESSIONTYPES(pipes_struct *p, struct lsa_CREDRGETSESSIONTYPES *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_LSARREGISTERAUDITEVENT(pipes_struct *p)
+NTSTATUS _lsa_LSARREGISTERAUDITEVENT(pipes_struct *p, struct lsa_LSARREGISTERAUDITEVENT *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_LSARGENAUDITEVENT(pipes_struct *p)
+NTSTATUS _lsa_LSARGENAUDITEVENT(pipes_struct *p, struct lsa_LSARGENAUDITEVENT *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_LSARUNREGISTERAUDITEVENT(pipes_struct *p)
+NTSTATUS _lsa_LSARUNREGISTERAUDITEVENT(pipes_struct *p, struct lsa_LSARUNREGISTERAUDITEVENT *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_LSARQUERYFORESTTRUSTINFORMATION(pipes_struct *p)
+NTSTATUS _lsa_LSARQUERYFORESTTRUSTINFORMATION(pipes_struct *p, struct lsa_LSARQUERYFORESTTRUSTINFORMATION *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_LSARSETFORESTTRUSTINFORMATION(pipes_struct *p)
+NTSTATUS _lsa_LSARSETFORESTTRUSTINFORMATION(pipes_struct *p, struct lsa_LSARSETFORESTTRUSTINFORMATION *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_CREDRRENAME(pipes_struct *p)
+NTSTATUS _lsa_CREDRRENAME(pipes_struct *p, struct lsa_CREDRRENAME *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_LookupSids3(pipes_struct *p, struct lsa_SidArray *sids, struct lsa_RefDomainList *domains, struct lsa_TransNameArray2 *names, uint16_t level, uint32_t *count, uint32_t unknown1, uint32_t unknown2)
+NTSTATUS _lsa_LookupSids3(pipes_struct *p, struct lsa_LookupSids3 *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_LookupNames4(pipes_struct *p, uint32_t num_names, struct lsa_String *names, struct lsa_RefDomainList *domains, struct lsa_TransSidArray3 *sids, uint16_t level, uint32_t *count, uint32_t unknown1, uint32_t unknown2)
+NTSTATUS _lsa_LookupNames4(pipes_struct *p, struct lsa_LookupNames4 *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_LSAROPENPOLICYSCE(pipes_struct *p)
+NTSTATUS _lsa_LSAROPENPOLICYSCE(pipes_struct *p, struct lsa_LSAROPENPOLICYSCE *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_LSARADTREGISTERSECURITYEVENTSOURCE(pipes_struct *p)
+NTSTATUS _lsa_LSARADTREGISTERSECURITYEVENTSOURCE(pipes_struct *p, struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(pipes_struct *p)
+NTSTATUS _lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(pipes_struct *p, struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
}
-NTSTATUS _lsa_LSARADTREPORTSECURITYEVENT(pipes_struct *p)
+NTSTATUS _lsa_LSARADTREPORTSECURITYEVENT(pipes_struct *p, struct lsa_LSARADTREPORTSECURITYEVENT *r)
{
p->rng_fault_state = True;
return NT_STATUS_NOT_IMPLEMENTED;
/*******************************************************************
*******************************************************************/
-WERROR _srvsvc_NetFileEnum(pipes_struct *p, const char *server_unc, const char *path, const char *user, uint32_t *level, union srvsvc_NetFileCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle)
+WERROR _srvsvc_NetFileEnum(pipes_struct *p, struct srvsvc_NetFileEnum *r)
{
- switch ( *level ) {
+ switch ( *r->in.level ) {
case 3:
- return net_file_enum_3(p, ctr, resume_handle, totalentries );
+ return net_file_enum_3(p, r->in.ctr, r->in.resume_handle, r->out.totalentries );
default:
return WERR_UNKNOWN_LEVEL;
}
net server get info
********************************************************************/
-WERROR _srvsvc_NetSrvGetInfo(pipes_struct *p, const char *server_unc, uint32_t level, union srvsvc_NetSrvInfo *info)
+WERROR _srvsvc_NetSrvGetInfo(pipes_struct *p, struct srvsvc_NetSrvGetInfo *r)
{
WERROR status = WERR_OK;
- ZERO_STRUCTP(info);
+ ZERO_STRUCTP(r->out.info);
DEBUG(5,("srv_net_srv_get_info: %d\n", __LINE__));
return WERR_ACCESS_DENIED;
}
- switch (level) {
+ switch (r->in.level) {
/* Technically level 102 should only be available to
Administrators but there isn't anything super-secret
here, as most of it is made up. */
case 102:
- info->info102 = talloc_zero(p->mem_ctx, struct srvsvc_NetSrvInfo102);
-
- info->info102->platform_id = 500;
- info->info102->version_major = lp_major_announce_version();
- info->info102->version_minor = lp_minor_announce_version();
- info->info102->server_name = global_myname();
- info->info102->server_type = lp_default_server_announce();
- info->info102->userpath = "C:\\";
- info->info102->licenses = 10000;
- info->info102->anndelta = 3000;
- info->info102->disc = 0xf;
- info->info102->users = 0xffffffff;
- info->info102->hidden = 0;
- info->info102->announce = 240;
- info->info102->comment = lp_serverstring();
+ r->out.info->info102 = talloc_zero(p->mem_ctx, struct srvsvc_NetSrvInfo102);
+
+ r->out.info->info102->platform_id = 500;
+ r->out.info->info102->version_major = lp_major_announce_version();
+ r->out.info->info102->version_minor = lp_minor_announce_version();
+ r->out.info->info102->server_name = global_myname();
+ r->out.info->info102->server_type = lp_default_server_announce();
+ r->out.info->info102->userpath = "C:\\";
+ r->out.info->info102->licenses = 10000;
+ r->out.info->info102->anndelta = 3000;
+ r->out.info->info102->disc = 0xf;
+ r->out.info->info102->users = 0xffffffff;
+ r->out.info->info102->hidden = 0;
+ r->out.info->info102->announce = 240;
+ r->out.info->info102->comment = lp_serverstring();
break;
case 101:
- info->info101 = talloc_zero(p->mem_ctx, struct srvsvc_NetSrvInfo101);
- info->info101->platform_id = 500;
- info->info101->server_name = global_myname();
- info->info101->version_major = lp_major_announce_version();
- info->info101->version_minor = lp_minor_announce_version();
- info->info101->server_type = lp_default_server_announce();
- info->info101->comment = lp_serverstring();
+ r->out.info->info101 = talloc_zero(p->mem_ctx, struct srvsvc_NetSrvInfo101);
+ r->out.info->info101->platform_id = 500;
+ r->out.info->info101->server_name = global_myname();
+ r->out.info->info101->version_major = lp_major_announce_version();
+ r->out.info->info101->version_minor = lp_minor_announce_version();
+ r->out.info->info101->server_type = lp_default_server_announce();
+ r->out.info->info101->comment = lp_serverstring();
break;
case 100:
- info->info100 = talloc_zero(p->mem_ctx, struct srvsvc_NetSrvInfo100);
- info->info100->platform_id = 500;
- info->info100->server_name = global_myname();
+ r->out.info->info100 = talloc_zero(p->mem_ctx, struct srvsvc_NetSrvInfo100);
+ r->out.info->info100->platform_id = 500;
+ r->out.info->info100->server_name = global_myname();
break;
default:
return WERR_UNKNOWN_LEVEL;
net server set info
********************************************************************/
-WERROR _srvsvc_NetSrvSetInfo(pipes_struct *p, const char *server_unc, uint32_t level, union srvsvc_NetSrvInfo info, uint32_t *parm_error)
+WERROR _srvsvc_NetSrvSetInfo(pipes_struct *p, struct srvsvc_NetSrvSetInfo *r)
{
/* Set up the net server set info structure. */
- if (parm_error) {
- *parm_error = 0;
+ if (r->out.parm_error) {
+ *r->out.parm_error = 0;
}
return WERR_OK;
}
net conn enum
********************************************************************/
-WERROR _srvsvc_NetConnEnum(pipes_struct *p, const char *server_unc, const char *path, uint32_t *level, union srvsvc_NetConnCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle)
+WERROR _srvsvc_NetConnEnum(pipes_struct *p, struct srvsvc_NetConnEnum *r)
{
DEBUG(5,("srv_net_conn_enum: %d\n", __LINE__));
- ZERO_STRUCTP(ctr);
+ ZERO_STRUCTP(r->out.ctr);
/* set up the */
- return init_srv_conn_info_ctr(p, ctr, *level, resume_handle, totalentries);
+ return init_srv_conn_info_ctr(p, r->out.ctr, *r->in.level, r->in.resume_handle, r->out.totalentries);
}
/*******************************************************************
net sess enum
********************************************************************/
-WERROR _srvsvc_NetSessEnum(pipes_struct *p, const char *server_unc, const char *client, const char *user, uint32_t *level, union srvsvc_NetSessCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle)
+WERROR _srvsvc_NetSessEnum(pipes_struct *p, struct srvsvc_NetSessEnum *r)
{
DEBUG(5,("_srv_net_sess_enum: %d\n", __LINE__));
- ZERO_STRUCTP(ctr);
+ ZERO_STRUCTP(r->out.ctr);
/* set up the */
- return init_srv_sess_info_ctr(p, ctr,
- *level,
- resume_handle,
- totalentries);
+ return init_srv_sess_info_ctr(p, r->out.ctr,
+ *r->in.level,
+ r->in.resume_handle,
+ r->out.totalentries);
}
/*******************************************************************
net sess del
********************************************************************/
-WERROR _srvsvc_NetSessDel(pipes_struct *p, const char *server_unc, const char *client, const char *user)
+WERROR _srvsvc_NetSessDel(pipes_struct *p, struct srvsvc_NetSessDel *r)
{
struct sessionid *session_list;
int num_sessions, snum;
WERROR status;
- char *machine = talloc_strdup(p->mem_ctx, server_unc);
+ char *machine = talloc_strdup(p->mem_ctx, r->in.server_unc);
/* strip leading backslashes if any */
while (machine[0] == '\\') {
for (snum = 0; snum < num_sessions; snum++) {
- if ((strequal(session_list[snum].username, user) || user[0] == '\0' ) &&
- strequal(session_list[snum].remote_machine, machine)) {
+ if ((strequal(session_list[snum].username, r->in.user) || r->in.user[0] == '\0' ) &&
+ strequal(session_list[snum].remote_machine, machine)) {
if (message_send_pid(pid_to_procid(session_list[snum].pid), MSG_SHUTDOWN, NULL, 0, False))
status = WERR_OK;
Net share enum all.
********************************************************************/
-WERROR _srvsvc_NetShareEnumAll(pipes_struct *p, const char *server_unc, uint32_t *level, union srvsvc_NetShareCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle)
+WERROR _srvsvc_NetShareEnumAll(pipes_struct *p, struct srvsvc_NetShareEnumAll *r)
{
DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
}
/* Create the list of shares for the response. */
- return init_srv_share_info_ctr(p, ctr, *level,
- resume_handle, totalentries, True);
+ return init_srv_share_info_ctr(p, r->out.ctr, *r->in.level,
+ r->in.resume_handle, r->out.totalentries, True);
}
/*******************************************************************
Net share enum.
********************************************************************/
-WERROR _srvsvc_NetShareEnum(pipes_struct *p, const char *server_unc, uint32_t *level, union srvsvc_NetShareCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle)
+WERROR _srvsvc_NetShareEnum(pipes_struct *p, struct srvsvc_NetShareEnum *r)
{
DEBUG(5,("_srv_net_share_enum: %d\n", __LINE__));
}
/* Create the list of shares for the response. */
- return init_srv_share_info_ctr(p, ctr, *level,
- resume_handle, totalentries, False);
+ return init_srv_share_info_ctr(p, r->out.ctr, *r->in.level,
+ r->in.resume_handle, r->out.totalentries, False);
}
/*******************************************************************
Net share get info.
********************************************************************/
-WERROR _srvsvc_NetShareGetInfo(pipes_struct *p, const char *server_unc, const char *share_name, uint32_t level, union srvsvc_NetShareInfo *info)
+WERROR _srvsvc_NetShareGetInfo(pipes_struct *p, struct srvsvc_NetShareGetInfo *r)
{
const struct share_params *params;
- params = get_share_params(p->mem_ctx, share_name);
+ params = get_share_params(p->mem_ctx, r->in.share_name);
if (params != NULL) {
- switch (level) {
+ switch (r->in.level) {
case 0:
- info->info0 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo0);
- init_srv_share_info_0(p, info->info0,
- params);
+ r->out.info->info0 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo0);
+ init_srv_share_info_0(p, r->out.info->info0, params);
break;
case 1:
- info->info1 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1);
- init_srv_share_info_1(p, info->info1,
- params);
+ r->out.info->info1 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1);
+ init_srv_share_info_1(p, r->out.info->info1, params);
break;
case 2:
- info->info2 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo2);
- init_srv_share_info_2(p, info->info2,
- params);
+ r->out.info->info2 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo2);
+ init_srv_share_info_2(p, r->out.info->info2, params);
break;
case 501:
- info->info501 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo501);
- init_srv_share_info_501(p, info->info501,
- params);
+ r->out.info->info501 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo501);
+ init_srv_share_info_501(p, r->out.info->info501, params);
break;
case 502:
- info->info502 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo502);
- init_srv_share_info_502(p, info->info502,
- params);
+ r->out.info->info502 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo502);
+ init_srv_share_info_502(p, r->out.info->info502, params);
break;
/* here for completeness */
case 1004:
- info->info1004 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1004);
- init_srv_share_info_1004(p, info->info1004,
- params);
+ r->out.info->info1004 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1004);
+ init_srv_share_info_1004(p, r->out.info->info1004, params);
break;
case 1005:
- info->info1005 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1005);
- init_srv_share_info_1005(p, info->info1005,
- params);
+ r->out.info->info1005 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1005);
+ init_srv_share_info_1005(p, r->out.info->info1005, params);
break;
/* here for completeness 1006 - 1501 */
case 1006:
- info->info1006 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1006);
- init_srv_share_info_1006(p, info->info1006,
+ r->out.info->info1006 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1006);
+ init_srv_share_info_1006(p, r->out.info->info1006,
params);
break;
case 1007:
- info->info1007 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1007);
- init_srv_share_info_1007(p, info->info1007,
+ r->out.info->info1007 = talloc(p->mem_ctx, struct srvsvc_NetShareInfo1007);
+ init_srv_share_info_1007(p, r->out.info->info1007,
params);
break;
case 1501:
- info->info1501 = talloc(p->mem_ctx, struct sec_desc_buf);
- init_srv_share_info_1501(p, info->info1501,
+ r->out.info->info1501 = talloc(p->mem_ctx, struct sec_desc_buf);
+ init_srv_share_info_1501(p, r->out.info->info1501,
params);
break;
default:
DEBUG(5,("init_srv_net_share_get_info: unsupported "
- "switch value %d\n", level));
+ "switch value %d\n", r->in.level));
return WERR_UNKNOWN_LEVEL;
break;
}
Net share set info. Modify share details.
********************************************************************/
-WERROR _srvsvc_NetShareSetInfo(pipes_struct *p, const char *server_unc,
- const char *share_name, uint32_t level,
- union srvsvc_NetShareInfo info,
- uint32_t *parm_error)
+WERROR _srvsvc_NetShareSetInfo(pipes_struct *p, struct srvsvc_NetShareSetInfo *r)
{
pstring comment;
pstring pathname;
DEBUG(5,("_srv_net_share_set_info: %d\n", __LINE__));
- if (parm_error) {
- *parm_error = 0;
+ if (r->out.parm_error) {
+ *r->out.parm_error = 0;
}
- if ( strequal(share_name,"IPC$")
- || ( lp_enable_asu_support() && strequal(share_name,"ADMIN$") )
- || strequal(share_name,"global") )
+ if ( strequal(r->in.share_name,"IPC$")
+ || ( lp_enable_asu_support() && strequal(r->in.share_name,"ADMIN$") )
+ || strequal(r->in.share_name,"global") )
{
return WERR_ACCESS_DENIED;
}
- fstrcpy(tmp_share_name, share_name);
+ fstrcpy(tmp_share_name, r->in.share_name);
snum = find_service(tmp_share_name);
/* Does this share exist ? */
if ( p->pipe_user.ut.uid != sec_initial_uid() && !is_disk_op )
return WERR_ACCESS_DENIED;
- switch (level) {
+ switch (r->in.level) {
case 1:
pstrcpy(pathname, lp_pathname(snum));
- pstrcpy(comment, info.info1->comment);
- type = info.info1->type;
+ pstrcpy(comment, r->in.info.info1->comment);
+ type = r->in.info.info1->type;
psd = NULL;
break;
case 2:
- pstrcpy(comment, info.info2->comment);
- pstrcpy(pathname, info.info2->path);
- type = info.info2->type;
- max_connections = (info.info2->max_users == 0xffffffff) ?
- 0 : info.info2->max_users;
+ pstrcpy(comment, r->in.info.info2->comment);
+ pstrcpy(pathname, r->in.info.info2->path);
+ type = r->in.info.info2->type;
+ max_connections = (r->in.info.info2->max_users == 0xffffffff) ?
+ 0 : r->in.info.info2->max_users;
psd = NULL;
break;
case 502:
- pstrcpy(comment, info.info502->comment);
- pstrcpy(pathname, info.info502->path);
- type = info.info502->type;
- psd = info.info502->sd;
+ pstrcpy(comment, r->in.info.info502->comment);
+ pstrcpy(pathname, r->in.info.info502->path);
+ type = r->in.info.info502->type;
+ psd = r->in.info.info502->sd;
map_generic_share_sd_bits(psd);
break;
case 1004:
pstrcpy(pathname, lp_pathname(snum));
- pstrcpy(comment, info.info1004->comment);
+ pstrcpy(comment, r->in.info.info1004->comment);
type = STYPE_DISKTREE;
break;
case 1005:
user, so we must compare it to see if it's what is set in
smb.conf, so that we can contine other ops like setting
ACLs on a share */
- if (((info.info1005->dfs_flags &
+ if (((r->in.info.info1005->dfs_flags &
SHARE_1005_CSC_POLICY_MASK) >>
SHARE_1005_CSC_POLICY_SHIFT) == lp_csc_policy(snum))
return WERR_OK;
case 1501:
pstrcpy(pathname, lp_pathname(snum));
pstrcpy(comment, lp_comment(snum));
- psd = info.info1501->sd;
+ psd = r->in.info.info1501->sd;
map_generic_share_sd_bits(psd);
type = STYPE_DISKTREE;
break;
default:
DEBUG(5,("_srv_net_share_set_info: unsupported switch value "
- "%d\n", level));
+ "%d\n", r->in.level));
return WERR_UNKNOWN_LEVEL;
}
&sd_size);
if (old_sd && !sec_desc_equal(old_sd, psd)) {
- if (!set_share_security(share_name, psd)) {
+ if (!set_share_security(r->in.share_name, psd)) {
DEBUG(0,("_srv_net_share_set_info: Failed to "
"change security info in share %s.\n",
- share_name ));
+ r->in.share_name ));
}
}
}
"comment" "max connections = "
********************************************************************/
-WERROR _srvsvc_NetShareAdd(pipes_struct *p, const char *server_unc,
- uint32_t level, union srvsvc_NetShareInfo info,
- uint32_t *parm_error)
+WERROR _srvsvc_NetShareAdd(pipes_struct *p, struct srvsvc_NetShareAdd *r)
{
pstring share_name;
pstring comment;
DEBUG(5,("_srv_net_share_add: %d\n", __LINE__));
- if (parm_error) {
- *parm_error = 0;
+ if (r->out.parm_error) {
+ *r->out.parm_error = 0;
}
is_disk_op = user_has_privileges( p->pipe_user.nt_user_token,
if (p->pipe_user.ut.uid != sec_initial_uid() && !is_disk_op )
return WERR_ACCESS_DENIED;
- switch (level) {
+ switch (r->in.level) {
case 0:
/* No path. Not enough info in a level 0 to do anything. */
return WERR_ACCESS_DENIED;
/* Not enough info in a level 1 to do anything. */
return WERR_ACCESS_DENIED;
case 2:
- pstrcpy(share_name, info.info2->name);
- pstrcpy(comment, info.info2->comment);
- pstrcpy(pathname, info.info2->path);
- max_connections = (info.info2->max_users == 0xffffffff) ?
- 0 : info.info2->max_users;
- type = info.info2->type;
+ pstrcpy(share_name, r->in.info.info2->name);
+ pstrcpy(comment, r->in.info.info2->comment);
+ pstrcpy(pathname, r->in.info.info2->path);
+ max_connections = (r->in.info.info2->max_users == 0xffffffff) ?
+ 0 : r->in.info.info2->max_users;
+ type = r->in.info.info2->type;
break;
case 501:
/* No path. Not enough info in a level 501 to do anything. */
return WERR_ACCESS_DENIED;
case 502:
- pstrcpy(share_name, info.info502->name);
- pstrcpy(comment, info.info502->comment);
- pstrcpy(pathname, info.info502->path);
- type = info.info502->type;
- psd = info.info502->sd;
+ pstrcpy(share_name, r->in.info.info502->name);
+ pstrcpy(comment, r->in.info.info502->comment);
+ pstrcpy(pathname, r->in.info.info502->path);
+ type = r->in.info.info502->type;
+ psd = r->in.info.info502->sd;
map_generic_share_sd_bits(psd);
break;
return WERR_ACCESS_DENIED;
default:
DEBUG(5,("_srv_net_share_add: unsupported switch value %d\n",
- level));
+ r->in.level));
return WERR_UNKNOWN_LEVEL;
}
a parameter.
********************************************************************/
-WERROR _srvsvc_NetShareDel(pipes_struct *p, const char *server_unc,
- const char *share_name, uint32_t reserved)
+WERROR _srvsvc_NetShareDel(pipes_struct *p, struct srvsvc_NetShareDel *r)
{
struct share_params *params;
SE_PRIV se_diskop = SE_DISK_OPERATOR;
DEBUG(5,("_srv_net_share_del: %d\n", __LINE__));
- if ( strequal(share_name,"IPC$")
- || ( lp_enable_asu_support() && strequal(share_name,"ADMIN$") )
- || strequal(share_name,"global") )
+ if ( strequal(r->in.share_name, "IPC$")
+ || ( lp_enable_asu_support() && strequal(r->in.share_name,"ADMIN$") )
+ || strequal(r->in.share_name, "global") )
{
return WERR_ACCESS_DENIED;
}
- if (!(params = get_share_params(p->mem_ctx, share_name))) {
+ if (!(params = get_share_params(p->mem_ctx, r->in.share_name))) {
return WERR_NO_SUCH_SHARE;
}
return WERR_OK;
}
-WERROR _srvsvc_NetShareDelSticky(pipes_struct *p, const char *server_unc,
- const char *share_name, uint32_t reserved)
+WERROR _srvsvc_NetShareDelSticky(pipes_struct *p, struct srvsvc_NetShareDelSticky *r)
{
+ struct srvsvc_NetShareDel s;
+
DEBUG(5,("_srv_net_share_del_stick: %d\n", __LINE__));
- return _srvsvc_NetShareDel(p, server_unc, share_name, reserved);
+ s.in.server_unc = r->in.server_unc;
+ s.in.share_name = r->in.share_name;
+ s.in.reserved = r->in.reserved;
+
+ return _srvsvc_NetShareDel(p, &s);
}
/*******************************************************************
time of day
********************************************************************/
-WERROR _srvsvc_NetRemoteTOD(pipes_struct *p, const char *server_unc, struct srvsvc_NetRemoteTODInfo *tod)
+WERROR _srvsvc_NetRemoteTOD(pipes_struct *p, struct srvsvc_NetRemoteTOD *r)
{
struct tm *t;
time_t unixdate = time(NULL);
t = gmtime(&unixdate);
/* set up the */
- tod->elapsed = unixdate;
- tod->msecs = 0;
- tod->hours = t->tm_hour;
- tod->mins = t->tm_min;
- tod->secs = t->tm_sec;
- tod->hunds = 0;
- tod->timezone = zone;
- tod->tinterval = 10000;
- tod->day = t->tm_mday;
- tod->month = t->tm_mon + 1;
- tod->year = 1900+t->tm_year;
- tod->weekday = t->tm_wday;
+ r->out.info->elapsed = unixdate;
+ r->out.info->msecs = 0;
+ r->out.info->hours = t->tm_hour;
+ r->out.info->mins = t->tm_min;
+ r->out.info->secs = t->tm_sec;
+ r->out.info->hunds = 0;
+ r->out.info->timezone = zone;
+ r->out.info->tinterval = 10000;
+ r->out.info->day = t->tm_mday;
+ r->out.info->month = t->tm_mon + 1;
+ r->out.info->year = 1900+t->tm_year;
+ r->out.info->weekday = t->tm_wday;
DEBUG(5,("_srv_net_remote_tod: %d\n", __LINE__));
Win9x NT tools get security descriptor.
***********************************************************************************/
-WERROR _srvsvc_NetGetFileSecurity(pipes_struct *p, const char *server_unc, const char *share, const char *file, uint32_t securityinformation, struct sec_desc_buf *sd_buf)
+WERROR _srvsvc_NetGetFileSecurity(pipes_struct *p, struct srvsvc_NetGetFileSecurity *r)
{
SEC_DESC *psd = NULL;
size_t sd_size;
null_pw = data_blob(NULL, 0);
become_root();
- conn = make_connection(share, null_pw, "A:", p->pipe_user.vuid, &nt_status);
+ conn = make_connection(r->in.share, null_pw, "A:", p->pipe_user.vuid, &nt_status);
unbecome_root();
if (conn == NULL) {
- DEBUG(3,("_srv_net_file_query_secdesc: Unable to connect to %s\n", share));
+ DEBUG(3,("_srv_net_file_query_secdesc: Unable to connect to %s\n", r->in.share));
status = ntstatus_to_werror(nt_status);
goto error_exit;
}
}
became_user = True;
- pstrcpy(tmp_file, file);
+ pstrcpy(tmp_file, r->in.file);
nt_status = unix_convert(conn, tmp_file, False, NULL, &st);
if (!NT_STATUS_IS_OK(nt_status)) {
- DEBUG(3,("_srv_net_file_query_secdesc: bad pathname %s\n", file));
+ DEBUG(3,("_srv_net_file_query_secdesc: bad pathname %s\n", r->in.file));
status = WERR_ACCESS_DENIED;
goto error_exit;
}
- nt_status = check_name(conn, file);
+ nt_status = check_name(conn, r->in.file);
if (!NT_STATUS_IS_OK(nt_status)) {
- DEBUG(3,("_srv_net_file_query_secdesc: can't access %s\n", file));
+ DEBUG(3,("_srv_net_file_query_secdesc: can't access %s\n", r->in.file));
status = WERR_ACCESS_DENIED;
goto error_exit;
}
- nt_status = open_file_stat(conn, file, &st, &fsp);
+ nt_status = open_file_stat(conn, r->in.file, &st, &fsp);
if (!NT_STATUS_IS_OK(nt_status)) {
/* Perhaps it is a directory */
if (NT_STATUS_EQUAL(nt_status, NT_STATUS_FILE_IS_A_DIRECTORY))
- nt_status = open_directory(conn, file, &st,
+ nt_status = open_directory(conn, r->in.file, &st,
READ_CONTROL_ACCESS,
FILE_SHARE_READ|FILE_SHARE_WRITE,
FILE_OPEN,
NULL, &fsp);
if (!NT_STATUS_IS_OK(nt_status)) {
- DEBUG(3,("_srv_net_file_query_secdesc: Unable to open file %s\n", file));
+ DEBUG(3,("_srv_net_file_query_secdesc: Unable to open file %s\n", r->in.file));
status = WERR_ACCESS_DENIED;
goto error_exit;
}
sd_size = SMB_VFS_GET_NT_ACL(fsp, fsp->fsp_name, (OWNER_SECURITY_INFORMATION|GROUP_SECURITY_INFORMATION|DACL_SECURITY_INFORMATION), &psd);
if (sd_size == 0) {
- DEBUG(3,("_srv_net_file_query_secdesc: Unable to get NT ACL for file %s\n", file));
+ DEBUG(3,("_srv_net_file_query_secdesc: Unable to get NT ACL for file %s\n", r->in.file));
status = WERR_ACCESS_DENIED;
goto error_exit;
}
- sd_buf->sd_size= sd_size;
- sd_buf->sd = psd;
+ r->out.sd_buf->sd_size= sd_size;
+ r->out.sd_buf->sd = psd;
psd->dacl->revision = (uint16) NT4_ACL_REVISION;
Win9x NT tools set security descriptor.
***********************************************************************************/
-WERROR _srvsvc_NetSetFileSecurity(pipes_struct *p, const char *server_unc, const char *share, const char *file, uint32_t securityinformation, struct sec_desc_buf sd_buf)
+WERROR _srvsvc_NetSetFileSecurity(pipes_struct *p, struct srvsvc_NetSetFileSecurity *r)
{
BOOL ret;
DATA_BLOB null_pw;
null_pw = data_blob(NULL, 0);
become_root();
- conn = make_connection(share, null_pw, "A:", p->pipe_user.vuid, &nt_status);
+ conn = make_connection(r->in.share, null_pw, "A:", p->pipe_user.vuid, &nt_status);
unbecome_root();
if (conn == NULL) {
- DEBUG(3,("_srv_net_file_set_secdesc: Unable to connect to %s\n", share));
+ DEBUG(3,("_srv_net_file_set_secdesc: Unable to connect to %s\n", r->in.share));
status = ntstatus_to_werror(nt_status);
goto error_exit;
}
}
became_user = True;
- pstrcpy(tmp_file, file);
+ pstrcpy(tmp_file, r->in.file);
nt_status = unix_convert(conn, tmp_file, False, NULL, &st);
if (!NT_STATUS_IS_OK(nt_status)) {
- DEBUG(3,("_srv_net_file_set_secdesc: bad pathname %s\n", file));
+ DEBUG(3,("_srv_net_file_set_secdesc: bad pathname %s\n", r->in.file));
status = WERR_ACCESS_DENIED;
goto error_exit;
}
- nt_status = check_name(conn, file);
+ nt_status = check_name(conn, r->in.file);
if (!NT_STATUS_IS_OK(nt_status)) {
- DEBUG(3,("_srv_net_file_set_secdesc: can't access %s\n", file));
+ DEBUG(3,("_srv_net_file_set_secdesc: can't access %s\n", r->in.file));
status = WERR_ACCESS_DENIED;
goto error_exit;
}
- nt_status = open_file_stat(conn, file, &st, &fsp);
+ nt_status = open_file_stat(conn, r->in.file, &st, &fsp);
if (!NT_STATUS_IS_OK(nt_status)) {
/* Perhaps it is a directory */
if (NT_STATUS_EQUAL(nt_status, NT_STATUS_FILE_IS_A_DIRECTORY))
- nt_status = open_directory(conn, file, &st,
+ nt_status = open_directory(conn, r->in.file, &st,
FILE_READ_ATTRIBUTES,
FILE_SHARE_READ|FILE_SHARE_WRITE,
FILE_OPEN,
NULL, &fsp);
if (!NT_STATUS_IS_OK(nt_status)) {
- DEBUG(3,("_srv_net_file_set_secdesc: Unable to open file %s\n", file));
+ DEBUG(3,("_srv_net_file_set_secdesc: Unable to open file %s\n", r->in.file));
status = WERR_ACCESS_DENIED;
goto error_exit;
}
}
- ret = SMB_VFS_SET_NT_ACL(fsp, fsp->fsp_name, securityinformation, sd_buf.sd);
+ ret = SMB_VFS_SET_NT_ACL(fsp, fsp->fsp_name, r->in.securityinformation, r->in.sd_buf.sd);
if (ret == False) {
- DEBUG(3,("_srv_net_file_set_secdesc: Unable to set NT ACL on file %s\n", file));
+ DEBUG(3,("_srv_net_file_set_secdesc: Unable to set NT ACL on file %s\n", r->in.file));
status = WERR_ACCESS_DENIED;
goto error_exit;
}
return disk;
}
-WERROR _srvsvc_NetDiskEnum(pipes_struct *p, const char *server_unc, uint32_t level, struct srvsvc_NetDiskInfo *info, uint32_t maxlen, uint32_t *totalentries, uint32_t *resume_handle)
+WERROR _srvsvc_NetDiskEnum(pipes_struct *p, struct srvsvc_NetDiskEnum *r)
{
uint32 i;
const char *disk_name;
WERROR status = WERR_OK;
- *totalentries = init_server_disk_enum(resume_handle);
- info->count = 0;
+ *r->out.totalentries = init_server_disk_enum(r->in.resume_handle);
+ r->out.info->count = 0;
- if(!(info->disks = TALLOC_ARRAY(p->mem_ctx, struct srvsvc_NetDiskInfo0, MAX_SERVER_DISK_ENTRIES))) {
+ if(!(r->out.info->disks = TALLOC_ARRAY(p->mem_ctx, struct srvsvc_NetDiskInfo0, MAX_SERVER_DISK_ENTRIES))) {
return WERR_NOMEM;
}
/*allow one struct srvsvc_NetDiskInfo0 for null terminator*/
- for(i = 0; i < MAX_SERVER_DISK_ENTRIES -1 && (disk_name = next_server_disk_enum(resume_handle)); i++) {
+ for(i = 0; i < MAX_SERVER_DISK_ENTRIES -1 && (disk_name = next_server_disk_enum(r->in.resume_handle)); i++) {
- info->count++;
- (*totalentries)++;
+ r->out.info->count++;
+ (*r->out.totalentries)++;
/*copy disk name into a unicode string*/
- info->disks[i].disk = disk_name;
+ r->out.info->disks[i].disk = disk_name;
}
/* add a terminating null string. Is this there if there is more data to come? */
- info->count++;
- (*totalentries)++;
+ r->out.info->count++;
+ (*r->out.totalentries)++;
- info->disks[i].disk = "";
+ r->out.info->disks[i].disk = "";
return status;
}
/********************************************************************
********************************************************************/
-WERROR _srvsvc_NetNameValidate(pipes_struct *p, const char *server_unc, const char *name, uint32_t name_type, uint32_t flags)
+WERROR _srvsvc_NetNameValidate(pipes_struct *p, struct srvsvc_NetNameValidate *r)
{
int len;
- if ((flags != 0x0) && (flags != 0x80000000)) {
+ if ((r->in.flags != 0x0) && (r->in.flags != 0x80000000)) {
return WERR_INVALID_PARAM;
}
- switch ( name_type ) {
+ switch ( r->in.name_type ) {
case 0x9:
- len = strlen_m(name);
+ len = strlen_m(r->in.name);
- if ((flags == 0x0) && (len > 81)) {
- DEBUG(5,("_srv_net_name_validate: share name too long (%s > 81 chars)\n", name));
+ if ((r->in.flags == 0x0) && (len > 81)) {
+ DEBUG(5,("_srv_net_name_validate: share name too long (%s > 81 chars)\n", r->in.name));
return WERR_INVALID_NAME;
}
- if ((flags == 0x80000000) && (len > 13)) {
- DEBUG(5,("_srv_net_name_validate: share name too long (%s > 13 chars)\n", name));
+ if ((r->in.flags == 0x80000000) && (len > 13)) {
+ DEBUG(5,("_srv_net_name_validate: share name too long (%s > 13 chars)\n", r->in.name));
return WERR_INVALID_NAME;
}
- if ( ! validate_net_name( name, INVALID_SHARENAME_CHARS, sizeof(name) ) ) {
- DEBUG(5,("_srv_net_name_validate: Bad sharename \"%s\"\n", name));
+ if ( ! validate_net_name( r->in.name, INVALID_SHARENAME_CHARS, sizeof(r->in.name) ) ) {
+ DEBUG(5,("_srv_net_name_validate: Bad sharename \"%s\"\n", r->in.name));
return WERR_INVALID_NAME;
}
break;
/********************************************************************
********************************************************************/
-WERROR _srvsvc_NetFileClose(pipes_struct *p, const char *server_unc, uint32_t fid)
+WERROR _srvsvc_NetFileClose(pipes_struct *p, struct srvsvc_NetFileClose *r)
{
return WERR_ACCESS_DENIED;
}
-WERROR _srvsvc_NetCharDevEnum(pipes_struct *p, const char *server_unc, uint32_t *level, union srvsvc_NetCharDevCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle)
+WERROR _srvsvc_NetCharDevEnum(pipes_struct *p, struct srvsvc_NetCharDevEnum *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NetCharDevGetInfo(pipes_struct *p, const char *server_unc, const char *device_name, uint32_t level, union srvsvc_NetCharDevInfo *info)
+WERROR _srvsvc_NetCharDevGetInfo(pipes_struct *p, struct srvsvc_NetCharDevGetInfo *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NetCharDevControl(pipes_struct *p, const char *server_unc, const char *device_name, uint32_t opcode)
+WERROR _srvsvc_NetCharDevControl(pipes_struct *p, struct srvsvc_NetCharDevControl *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NetCharDevQEnum(pipes_struct *p, const char *server_unc, const char *user, uint32_t *level, union srvsvc_NetCharDevQCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle)
+WERROR _srvsvc_NetCharDevQEnum(pipes_struct *p, struct srvsvc_NetCharDevQEnum *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NetCharDevQGetInfo(pipes_struct *p, const char *server_unc, const char *queue_name, const char *user, uint32_t level, union srvsvc_NetCharDevQInfo *info)
+WERROR _srvsvc_NetCharDevQGetInfo(pipes_struct *p, struct srvsvc_NetCharDevQGetInfo *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NetCharDevQSetInfo(pipes_struct *p, const char *server_unc, const char *queue_name, uint32_t level, union srvsvc_NetCharDevQInfo info, uint32_t *parm_error)
+WERROR _srvsvc_NetCharDevQSetInfo(pipes_struct *p, struct srvsvc_NetCharDevQSetInfo *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NetCharDevQPurge(pipes_struct *p, const char *server_unc, const char *queue_name)
+WERROR _srvsvc_NetCharDevQPurge(pipes_struct *p, struct srvsvc_NetCharDevQPurge *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NetCharDevQPurgeSelf(pipes_struct *p, const char *server_unc, const char *queue_name, const char *computer_name)
+WERROR _srvsvc_NetCharDevQPurgeSelf(pipes_struct *p, struct srvsvc_NetCharDevQPurgeSelf *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NetFileGetInfo(pipes_struct *p, const char *server_unc, uint32_t fid, uint32_t level, union srvsvc_NetFileInfo *info)
+WERROR _srvsvc_NetFileGetInfo(pipes_struct *p, struct srvsvc_NetFileGetInfo *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NetShareCheck(pipes_struct *p, const char *server_unc, const char *device_name, enum srvsvc_ShareType *type)
+WERROR _srvsvc_NetShareCheck(pipes_struct *p, struct srvsvc_NetShareCheck *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NetServerStatisticsGet(pipes_struct *p, const char *server_unc, const char *service, uint32_t level, uint32_t options, struct srvsvc_Statistics *stats)
+WERROR _srvsvc_NetServerStatisticsGet(pipes_struct *p, struct srvsvc_NetServerStatisticsGet *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NetTransportAdd(pipes_struct *p, const char *server_unc, uint32_t level, union srvsvc_NetTransportInfo info)
+WERROR _srvsvc_NetTransportAdd(pipes_struct *p, struct srvsvc_NetTransportAdd *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NetTransportEnum(pipes_struct *p, const char *server_unc, uint32_t *level, union srvsvc_NetTransportCtr *transports, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle)
+WERROR _srvsvc_NetTransportEnum(pipes_struct *p, struct srvsvc_NetTransportEnum *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NetTransportDel(pipes_struct *p, const char *server_unc, uint32_t unknown, struct srvsvc_NetTransportInfo0 transport)
+WERROR _srvsvc_NetTransportDel(pipes_struct *p, struct srvsvc_NetTransportDel *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NetSetServiceBits(pipes_struct *p, const char *server_unc, const char *transport, uint32_t servicebits, uint32_t updateimmediately)
+WERROR _srvsvc_NetSetServiceBits(pipes_struct *p, struct srvsvc_NetSetServiceBits *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NetPathType(pipes_struct *p, const char *server_unc, const char *path, uint32_t pathflags, uint32_t *pathtype)
+WERROR _srvsvc_NetPathType(pipes_struct *p, struct srvsvc_NetPathType *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NetPathCanonicalize(pipes_struct *p, const char *server_unc, const char *path, uint8_t *can_path, uint32_t maxbuf, const char *prefix, uint32_t *pathtype, uint32_t pathflags)
+WERROR _srvsvc_NetPathCanonicalize(pipes_struct *p, struct srvsvc_NetPathCanonicalize *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NetPathCompare(pipes_struct *p, const char *server_unc, const char *path1, const char *path2, uint32_t pathtype, uint32_t pathflags)
+WERROR _srvsvc_NetPathCompare(pipes_struct *p, struct srvsvc_NetPathCompare *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NETRPRNAMECANONICALIZE(pipes_struct *p)
+WERROR _srvsvc_NETRPRNAMECANONICALIZE(pipes_struct *p, struct srvsvc_NETRPRNAMECANONICALIZE *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NetPRNameCompare(pipes_struct *p, const char *server_unc, const char *name1, const char *name2, uint32_t name_type, uint32_t flags)
+WERROR _srvsvc_NetPRNameCompare(pipes_struct *p, struct srvsvc_NetPRNameCompare *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NetShareDelStart(pipes_struct *p, const char *server_unc, const char *share, uint32_t reserved, struct policy_handle *hnd)
+WERROR _srvsvc_NetShareDelStart(pipes_struct *p, struct srvsvc_NetShareDelStart *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NetShareDelCommit(pipes_struct *p, struct policy_handle *hnd)
+WERROR _srvsvc_NetShareDelCommit(pipes_struct *p, struct srvsvc_NetShareDelCommit *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NetServerTransportAddEx(pipes_struct *p, const char *server_unc, uint32_t level, union srvsvc_NetTransportInfo info)
+WERROR _srvsvc_NetServerTransportAddEx(pipes_struct *p, struct srvsvc_NetServerTransportAddEx *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NetServerSetServiceBitsEx(pipes_struct *p, const char *server_unc, const char *emulated_server_unc, const char *transport, uint32_t servicebitsofinterest, uint32_t servicebits, uint32_t updateimmediately)
+WERROR _srvsvc_NetServerSetServiceBitsEx(pipes_struct *p, struct srvsvc_NetServerSetServiceBitsEx *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NETRDFSGETVERSION(pipes_struct *p)
+WERROR _srvsvc_NETRDFSGETVERSION(pipes_struct *p, struct srvsvc_NETRDFSGETVERSION *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NETRDFSCREATELOCALPARTITION(pipes_struct *p)
+WERROR _srvsvc_NETRDFSCREATELOCALPARTITION(pipes_struct *p, struct srvsvc_NETRDFSCREATELOCALPARTITION *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NETRDFSDELETELOCALPARTITION(pipes_struct *p)
+WERROR _srvsvc_NETRDFSDELETELOCALPARTITION(pipes_struct *p, struct srvsvc_NETRDFSDELETELOCALPARTITION *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NETRDFSSETLOCALVOLUMESTATE(pipes_struct *p)
+WERROR _srvsvc_NETRDFSSETLOCALVOLUMESTATE(pipes_struct *p, struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *R)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NETRDFSSETSERVERINFO(pipes_struct *p)
+WERROR _srvsvc_NETRDFSSETSERVERINFO(pipes_struct *p, struct srvsvc_NETRDFSSETSERVERINFO *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NETRDFSCREATEEXITPOINT(pipes_struct *p)
+WERROR _srvsvc_NETRDFSCREATEEXITPOINT(pipes_struct *p, struct srvsvc_NETRDFSCREATEEXITPOINT *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NETRDFSDELETEEXITPOINT(pipes_struct *p)
+WERROR _srvsvc_NETRDFSDELETEEXITPOINT(pipes_struct *p, struct srvsvc_NETRDFSDELETEEXITPOINT *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NETRSERVERTRANSPORTDELEX(pipes_struct *p)
+WERROR _srvsvc_NETRSERVERTRANSPORTDELEX(pipes_struct *p, struct srvsvc_NETRSERVERTRANSPORTDELEX *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NETRDFSMANAGERREPORTSITEINFO(pipes_struct *p)
+WERROR _srvsvc_NETRDFSMANAGERREPORTSITEINFO(pipes_struct *p, struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NETRDFSMODIFYPREFIX(pipes_struct *p)
+WERROR _srvsvc_NETRDFSMODIFYPREFIX(pipes_struct *p, struct srvsvc_NETRDFSMODIFYPREFIX *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
}
-WERROR _srvsvc_NETRDFSFIXLOCALVOLUME(pipes_struct *p)
+WERROR _srvsvc_NETRDFSFIXLOCALVOLUME(pipes_struct *p, struct srvsvc_NETRDFSFIXLOCALVOLUME *r)
{
p->rng_fault_state = True;
return WERR_NOT_SUPPORTED;
/* Map a sid to a uid */
-NTSTATUS _unixinfo_SidToUid(pipes_struct *p, struct dom_sid sid, uint64_t *uid)
+NTSTATUS _unixinfo_SidToUid(pipes_struct *p, struct unixinfo_SidToUid *r)
{
uid_t real_uid;
NTSTATUS status;
- *uid = 0;
+ *r->out.uid = 0;
- status = sid_to_uid(&sid, &real_uid) ? NT_STATUS_OK : NT_STATUS_NONE_MAPPED;
+ status = sid_to_uid(&r->in.sid, &real_uid) ? NT_STATUS_OK : NT_STATUS_NONE_MAPPED;
if (NT_STATUS_IS_OK(status))
- *uid = real_uid;
+ *r->out.uid = real_uid;
return status;
}
/* Map a uid to a sid */
-NTSTATUS _unixinfo_UidToSid(pipes_struct *p, uint64_t uid, struct dom_sid *sid)
+NTSTATUS _unixinfo_UidToSid(pipes_struct *p, struct unixinfo_UidToSid *r)
{
NTSTATUS status = NT_STATUS_NO_SUCH_USER;
- uid_to_sid(sid, (uid_t)uid);
+ uid_to_sid(r->out.sid, (uid_t)r->in.uid);
status = NT_STATUS_OK;
return status;
/* Map a sid to a gid */
-NTSTATUS _unixinfo_SidToGid(pipes_struct *p, struct dom_sid sid, uint64_t *gid)
+NTSTATUS _unixinfo_SidToGid(pipes_struct *p, struct unixinfo_SidToGid *r)
{
gid_t real_gid;
NTSTATUS status;
- *gid = 0;
+ *r->out.gid = 0;
- status = sid_to_gid(&sid, &real_gid) ? NT_STATUS_OK : NT_STATUS_NONE_MAPPED;
+ status = sid_to_gid(&r->in.sid, &real_gid) ? NT_STATUS_OK : NT_STATUS_NONE_MAPPED;
if (NT_STATUS_IS_OK(status))
- *gid = real_gid;
+ *r->out.gid = real_gid;
return status;
}
/* Map a gid to a sid */
-NTSTATUS _unixinfo_GidToSid(pipes_struct *p, uint64_t gid, struct dom_sid *sid)
+NTSTATUS _unixinfo_GidToSid(pipes_struct *p, struct unixinfo_GidToSid *r)
{
NTSTATUS status = NT_STATUS_NO_SUCH_GROUP;
- gid_to_sid(sid, (gid_t)gid);
+ gid_to_sid(r->out.sid, (gid_t)r->in.gid);
status = NT_STATUS_OK;
return status;
/* Get unix struct passwd information */
-NTSTATUS _unixinfo_GetPWUid(pipes_struct *p, uint32_t *count, uint64_t *uids,
- struct unixinfo_GetPWUidInfo *infos)
+NTSTATUS _unixinfo_GetPWUid(pipes_struct *p, struct unixinfo_GetPWUid *r)
{
int i;
NTSTATUS status;
- if (*count > 1023)
+ if (*r->in.count > 1023)
return NT_STATUS_INVALID_PARAMETER;
status = NT_STATUS_OK;
- for (i=0; i<*count; i++) {
+ for (i=0; i<*r->in.count; i++) {
struct passwd *pw;
char *homedir, *shell;
ssize_t len1, len2;
- infos[i].status = NT_STATUS_NO_SUCH_USER;
- infos[i].homedir = "";
- infos[i].shell = "";
+ r->out.infos[i].status = NT_STATUS_NO_SUCH_USER;
+ r->out.infos[i].homedir = "";
+ r->out.infos[i].shell = "";
- pw = getpwuid(uids[i]);
+ pw = getpwuid(r->in.uids[i]);
if (pw == NULL) {
DEBUG(10, ("Did not find uid %lld\n",
- (long long int)uids[i]));
+ (long long int)r->in.uids[i]));
continue;
}
if ((len1 < 0) || (len2 < 0) || (homedir == NULL) ||
(shell == NULL)) {
DEBUG(3, ("push_utf8_talloc failed\n"));
- infos[i].status = NT_STATUS_NO_MEMORY;
+ r->out.infos[i].status = NT_STATUS_NO_MEMORY;
continue;
}
- infos[i].status = NT_STATUS_OK;
- infos[i].homedir = homedir;
- infos[i].shell = shell;
+ r->out.infos[i].status = NT_STATUS_OK;
+ r->out.infos[i].homedir = homedir;
+ r->out.infos[i].shell = shell;
}
return status;
reg_close
********************************************************************/
-WERROR _winreg_CloseKey(pipes_struct *p, struct policy_handle *handle)
+WERROR _winreg_CloseKey(pipes_struct *p, struct winreg_CloseKey *r)
{
/* close the policy handle */
- if (!close_registry_key(p, handle))
+ if (!close_registry_key(p, r->in.handle))
return WERR_BADFID;
- ZERO_STRUCTP(handle);
+ ZERO_STRUCTP(r->out.handle);
return WERR_OK;
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_OpenHKLM(pipes_struct *p, uint16_t *system_name, uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKLM(pipes_struct *p, struct winreg_OpenHKLM *r)
{
- return open_registry_key(p, handle, NULL, KEY_HKLM, access_mask);
+ return open_registry_key(p, r->out.handle, NULL, KEY_HKLM, r->in.access_mask);
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_OpenHKPD(pipes_struct *p, uint16_t *system_name,
- uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKPD(pipes_struct *p, struct winreg_OpenHKPD *r)
{
- return open_registry_key(p, handle, NULL, KEY_HKPD, access_mask);
+ return open_registry_key(p, r->out.handle, NULL, KEY_HKPD, r->in.access_mask);
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_OpenHKPT(pipes_struct *p, uint16_t *system_name,
- uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKPT(pipes_struct *p, struct winreg_OpenHKPT *r)
{
- return open_registry_key(p, handle, NULL, KEY_HKPT, access_mask);
+ return open_registry_key(p, r->out.handle, NULL, KEY_HKPT, r->in.access_mask);
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_OpenHKCR(pipes_struct *p, uint16_t *system_name,
- uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKCR(pipes_struct *p, struct winreg_OpenHKCR *r)
{
- return open_registry_key(p, handle, NULL, KEY_HKCR, access_mask);
+ return open_registry_key(p, r->out.handle, NULL, KEY_HKCR, r->in.access_mask);
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_OpenHKU(pipes_struct *p, uint16_t *system_name,
- uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKU(pipes_struct *p, struct winreg_OpenHKU *r)
{
- return open_registry_key(p, handle, NULL, KEY_HKU, access_mask);
+ return open_registry_key(p, r->out.handle, NULL, KEY_HKU, r->in.access_mask);
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_OpenHKCU(pipes_struct *p, uint16_t *system_name,
- uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKCU(pipes_struct *p, struct winreg_OpenHKCU *r)
{
- return open_registry_key(p, handle, NULL, KEY_HKCU, access_mask);
+ return open_registry_key(p, r->out.handle, NULL, KEY_HKCU, r->in.access_mask);
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_OpenHKCC(pipes_struct *p, uint16_t *system_name,
- uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKCC(pipes_struct *p, struct winreg_OpenHKCC *r)
{
- return open_registry_key(p, handle, NULL, KEY_HKCC, access_mask);
+ return open_registry_key(p, r->out.handle, NULL, KEY_HKCC, r->in.access_mask);
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_OpenHKDD(pipes_struct *p, uint16_t *system_name,
- uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKDD(pipes_struct *p, struct winreg_OpenHKDD *r)
{
- return open_registry_key(p, handle, NULL, KEY_HKDD, access_mask);
+ return open_registry_key(p, r->out.handle, NULL, KEY_HKDD, r->in.access_mask);
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_OpenHKPN(pipes_struct *p, uint16_t *system_name,
- uint32_t access_mask, struct policy_handle *handle)
+WERROR _winreg_OpenHKPN(pipes_struct *p, struct winreg_OpenHKPN *r)
{
- return open_registry_key(p, handle, NULL, KEY_HKPN, access_mask);
+ return open_registry_key(p, r->out.handle, NULL, KEY_HKPN, r->in.access_mask);
}
/*******************************************************************
reg_reply_open_entry
********************************************************************/
-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_OpenKey(pipes_struct *p, struct winreg_OpenKey *r)
{
- struct registry_key *parent = find_regkey_by_hnd(p, parent_handle );
+ struct registry_key *parent = find_regkey_by_hnd(p, r->in.parent_handle );
if ( !parent )
return WERR_BADFID;
- return open_registry_key(p, handle, parent, keyname.name, access_mask);
+ return open_registry_key(p, r->out.handle, parent, r->in.keyname.name, r->in.access_mask);
}
/*******************************************************************
reg_reply_info
********************************************************************/
-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_QueryValue(pipes_struct *p, struct winreg_QueryValue *r)
{
WERROR status = WERR_BADFILE;
- struct registry_key *regkey = find_regkey_by_hnd( p, handle );
+ struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
prs_struct prs_hkpd;
uint8_t *outbuf;
if ( !regkey )
return WERR_BADFID;
- *value_length = *type = 0;
+ *r->out.value_length = *r->out.type = 0;
DEBUG(7,("_reg_info: policy key name = [%s]\n", regkey->key->name));
DEBUG(7,("_reg_info: policy key type = [%08x]\n", regkey->key->type));
/* Handle QueryValue calls on HKEY_PERFORMANCE_DATA */
if(regkey->key->type == REG_KEY_HKPD)
{
- if(strequal(value_name.name, "Global")) {
- prs_init(&prs_hkpd, *data_size, p->mem_ctx, MARSHALL);
+ if(strequal(r->in.value_name.name, "Global")) {
+ prs_init(&prs_hkpd, *r->in.data_size, p->mem_ctx, MARSHALL);
status = reg_perfcount_get_hkpd(
- &prs_hkpd, *data_size, &outbuf_size, NULL);
+ &prs_hkpd, *r->in.data_size, &outbuf_size, NULL);
outbuf = (uint8_t *)prs_hkpd.data_p;
free_prs = True;
}
- else if(strequal(value_name.name, "Counter 009")) {
+ else if(strequal(r->in.value_name.name, "Counter 009")) {
outbuf_size = reg_perfcount_get_counter_names(
reg_perfcount_get_base_index(),
(char **)(void *)&outbuf);
free_buf = True;
}
- else if(strequal(value_name.name, "Explain 009")) {
+ else if(strequal(r->in.value_name.name, "Explain 009")) {
outbuf_size = reg_perfcount_get_counter_help(
reg_perfcount_get_base_index(),
(char **)(void *)&outbuf);
free_buf = True;
}
- else if(isdigit(value_name.name[0])) {
+ else if(isdigit(r->in.value_name.name[0])) {
/* we probably have a request for a specific object
* here */
- prs_init(&prs_hkpd, *data_size, p->mem_ctx, MARSHALL);
+ prs_init(&prs_hkpd, *r->in.data_size, p->mem_ctx, MARSHALL);
status = reg_perfcount_get_hkpd(
- &prs_hkpd, *data_size, &outbuf_size,
- value_name.name);
+ &prs_hkpd, *r->in.data_size, &outbuf_size,
+ r->in.value_name.name);
outbuf = (uint8_t *)prs_hkpd.data_p;
free_prs = True;
}
else {
DEBUG(3,("Unsupported key name [%s] for HKPD.\n",
- value_name.name));
+ r->in.value_name.name));
return WERR_BADFILE;
}
- *type = REG_BINARY;
+ *r->out.type = REG_BINARY;
}
else {
struct registry_value *val;
- status = reg_queryvalue(p->mem_ctx, regkey, value_name.name,
+ status = reg_queryvalue(p->mem_ctx, regkey, r->in.value_name.name,
&val);
if (!W_ERROR_IS_OK(status)) {
- if (data_size) {
- *data_size = 0;
+ if (r->out.data_size) {
+ *r->out.data_size = 0;
}
- if (value_length) {
- *value_length = 0;
+ if (r->out.value_length) {
+ *r->out.value_length = 0;
}
return status;
}
outbuf = val_blob.data;
outbuf_size = val_blob.length;
- *type = val->type;
+ *r->out.type = val->type;
}
- *value_length = outbuf_size;
+ *r->out.value_length = outbuf_size;
- if ( *data_size == 0 || !data ) {
+ if ( *r->in.data_size == 0 || !r->out.data ) {
status = WERR_OK;
- } else if ( *value_length > *data_size ) {
+ } else if ( *r->out.value_length > *r->in.data_size ) {
status = WERR_MORE_DATA;
} else {
- memcpy( data, outbuf, *value_length );
+ memcpy( r->out.data, outbuf, *r->out.value_length );
status = WERR_OK;
}
- *data_size = *value_length;
+ *r->out.data_size = *r->out.value_length;
if (free_prs) prs_mem_free(&prs_hkpd);
if (free_buf) SAFE_FREE(outbuf);
Implementation of REG_QUERY_KEY
****************************************************************************/
-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 winreg_QueryInfoKey *r)
{
WERROR status = WERR_OK;
- struct registry_key *regkey = find_regkey_by_hnd( p, handle );
+ struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
if ( !regkey )
return WERR_BADFID;
- classname->name = NULL;
+ r->out.classname->name = NULL;
- status = reg_queryinfokey(regkey, num_subkeys, max_subkeylen,
- max_subkeysize, num_values, max_valnamelen,
- max_valbufsize, secdescsize,
- last_changed_time);
+ status = reg_queryinfokey(regkey, 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 (!W_ERROR_IS_OK(status)) {
return status;
}
* UTF-16. They are inexact at best, but so far they worked.
*/
- *max_subkeylen *= 2;
+ *r->out.max_subkeylen *= 2;
- *max_valnamelen += 1;
- *max_valnamelen *= 2;
+ *r->out.max_valnamelen += 1;
+ *r->out.max_valnamelen *= 2;
return WERR_OK;
}
Implementation of REG_GETVERSION
****************************************************************************/
-WERROR _winreg_GetVersion(pipes_struct *p, struct policy_handle *handle, uint32_t *version)
+WERROR _winreg_GetVersion(pipes_struct *p, struct winreg_GetVersion *r)
{
- struct registry_key *regkey = find_regkey_by_hnd( p, handle );
+ struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
if ( !regkey )
return WERR_BADFID;
- *version = 0x00000005; /* Windows 2000 registry API version */
+ *r->out.version = 0x00000005; /* Windows 2000 registry API version */
return WERR_OK;
}
Implementation of REG_ENUM_KEY
****************************************************************************/
-WERROR _winreg_EnumKey(pipes_struct *p, struct policy_handle *handle, uint32_t enum_index, struct winreg_StringBuf *name, struct winreg_StringBuf *keyclass, NTTIME *last_changed_time)
+WERROR _winreg_EnumKey(pipes_struct *p, struct winreg_EnumKey *r)
{
WERROR err;
- struct registry_key *key = find_regkey_by_hnd( p, handle );
+ struct registry_key *key = find_regkey_by_hnd( p, r->in.handle );
if ( !key )
return WERR_BADFID;
- if ( !name || !keyclass )
+ if ( !r->in.name || !r->in.keyclass )
return WERR_INVALID_PARAM;
DEBUG(8,("_reg_enum_key: enumerating key [%s]\n", key->key->name));
- err = reg_enumkey(p->mem_ctx, key, enum_index, (char **)&name->name,
- last_changed_time);
+ err = reg_enumkey(p->mem_ctx, key, r->in.enum_index, (char **)&r->out.name->name,
+ r->out.last_changed_time);
if (!W_ERROR_IS_OK(err)) {
return err;
}
- keyclass->name = "";
+ r->out.keyclass->name = "";
return WERR_OK;
}
Implementation of REG_ENUM_VALUE
****************************************************************************/
-WERROR _winreg_EnumValue(pipes_struct *p, struct policy_handle *handle,
- uint32_t enum_index, struct winreg_ValNameBuf *name,
- enum winreg_Type *type, uint8_t **data,
- uint32_t *data_size, uint32_t *value_length)
+WERROR _winreg_EnumValue(pipes_struct *p, struct winreg_EnumValue *r)
{
WERROR err;
- struct registry_key *key = find_regkey_by_hnd( p, handle );
+ struct registry_key *key = find_regkey_by_hnd( p, r->in.handle );
char *valname;
struct registry_value *val;
DATA_BLOB value_blob;
if ( !key )
return WERR_BADFID;
- if ( !name )
+ if ( !r->in.name )
return WERR_INVALID_PARAM;
DEBUG(8,("_winreg_EnumValue: enumerating values for key [%s]\n",
key->key->name));
- err = reg_enumvalue(p->mem_ctx, key, enum_index, &valname, &val);
+ err = reg_enumvalue(p->mem_ctx, key, r->in.enum_index, &valname, &val);
if (!W_ERROR_IS_OK(err)) {
return err;
}
return err;
}
- if (name != NULL) {
- name->name = valname;
+ if (r->out.name != NULL) {
+ r->out.name->name = valname;
}
- if (type != NULL) {
- *type = val->type;
+ if (r->out.type != NULL) {
+ *r->out.type = val->type;
}
- if (data != NULL) {
- if ((data_size == NULL) || (value_length == NULL)) {
+ if (r->out.data != NULL) {
+ if ((r->out.data_size == NULL) || (r->out.value_length == NULL)) {
return WERR_INVALID_PARAM;
}
- if (value_blob.length > *data_size) {
+ if (value_blob.length > *r->out.data_size) {
return WERR_MORE_DATA;
}
- memcpy( data, value_blob.data, value_blob.length );
+ memcpy( r->out.data, value_blob.data, value_blob.length );
}
- if (value_length != NULL) {
- *value_length = value_blob.length;
+ if (r->out.value_length != NULL) {
+ *r->out.value_length = value_blob.length;
}
- if (data_size != NULL) {
- *data_size = value_blob.length;
+ if (r->out.data_size != NULL) {
+ *r->out.data_size = value_blob.length;
}
return WERR_OK;
reg_shutdwon
********************************************************************/
-WERROR _winreg_InitiateSystemShutdown(pipes_struct *p, uint16_t *hostname, struct initshutdown_String *message, uint32_t timeout, uint8_t force_apps, uint8_t reboot)
+WERROR _winreg_InitiateSystemShutdown(pipes_struct *p, struct winreg_InitiateSystemShutdown *r)
{
- uint32_t reason = 0;
+ struct winreg_InitiateSystemShutdownEx s;
+
+ s.in.hostname = r->in.hostname;
+ s.in.message = r->in.message;
+ s.in.timeout = r->in.timeout;
+ s.in.force_apps = r->in.force_apps;
+ s.in.reboot = r->in.reboot;
+ s.in.reason = 0;
/* thunk down to _winreg_InitiateSystemShutdownEx()
(just returns a status) */
- return _winreg_InitiateSystemShutdownEx( p, hostname, message, timeout,
- force_apps, reboot, reason );
+ return _winreg_InitiateSystemShutdownEx( p, &s );
}
/*******************************************************************
#define SHUTDOWN_F_STRING "-f"
-WERROR _winreg_InitiateSystemShutdownEx(pipes_struct *p, uint16_t *hostname, struct initshutdown_String *message, uint32_t timeout, uint8_t force_apps, uint8_t reboot, uint32_t reason)
+WERROR _winreg_InitiateSystemShutdownEx(pipes_struct *p, struct winreg_InitiateSystemShutdownEx *r)
{
pstring shutdown_script;
char *msg = NULL;
pstring chkmsg;
fstring str_timeout;
fstring str_reason;
- fstring r;
+ fstring reboot;
fstring f;
int ret;
BOOL can_shutdown;
chkmsg[0] = '\0';
- if ( message && message->name && message->name->name ) {
- if ( (msg = talloc_strdup(p->mem_ctx, message->name->name )) == NULL ) {
+ if ( r->in.message && r->in.message->name && r->in.message->name->name ) {
+ if ( (msg = talloc_strdup(p->mem_ctx, r->in.message->name->name )) == NULL ) {
return WERR_NOMEM;
}
alpha_strcpy (chkmsg, msg, NULL, sizeof(chkmsg));
}
- fstr_sprintf(str_timeout, "%d", timeout);
- fstr_sprintf(r, reboot ? SHUTDOWN_R_STRING : "");
- fstr_sprintf(f, force_apps ? SHUTDOWN_F_STRING : "");
- fstr_sprintf(str_reason, "%d", reason );
+ fstr_sprintf(str_timeout, "%d", r->in.timeout);
+ fstr_sprintf(reboot, r->in.reboot ? SHUTDOWN_R_STRING : "");
+ fstr_sprintf(f, r->in.force_apps ? SHUTDOWN_F_STRING : "");
+ fstr_sprintf(str_reason, "%d", r->in.reason );
all_string_sub( shutdown_script, "%z", chkmsg, sizeof(shutdown_script) );
all_string_sub( shutdown_script, "%t", str_timeout, sizeof(shutdown_script) );
- all_string_sub( shutdown_script, "%r", r, sizeof(shutdown_script) );
+ all_string_sub( shutdown_script, "%r", reboot, sizeof(shutdown_script) );
all_string_sub( shutdown_script, "%f", f, sizeof(shutdown_script) );
all_string_sub( shutdown_script, "%x", str_reason, sizeof(shutdown_script) );
reg_abort_shutdwon
********************************************************************/
-WERROR _winreg_AbortSystemShutdown(pipes_struct *p, uint16_t *server)
+WERROR _winreg_AbortSystemShutdown(pipes_struct *p, struct winreg_AbortSystemShutdown *r)
{
pstring abort_shutdown_script;
int ret;
/*******************************************************************
********************************************************************/
-WERROR _winreg_RestoreKey(pipes_struct *p, struct policy_handle *handle, struct winreg_String *filename, uint32_t flags)
+WERROR _winreg_RestoreKey(pipes_struct *p, struct winreg_RestoreKey *r)
{
- struct registry_key *regkey = find_regkey_by_hnd( p, handle );
+ struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
pstring fname;
int snum;
if ( !regkey )
return WERR_BADFID;
- if ( !filename || !filename->name )
+ if ( !r->in.filename || !r->in.filename->name )
return WERR_INVALID_PARAM;
- pstrcpy( fname, filename->name );
+ pstrcpy( fname, r->in.filename->name );
DEBUG(8,("_winreg_RestoreKey: verifying restore of key [%s] from "
"\"%s\"\n", regkey->key->name, fname));
/*******************************************************************
********************************************************************/
-WERROR _winreg_SaveKey(pipes_struct *p, struct policy_handle *handle, struct winreg_String *filename, struct KeySecurityAttribute *sec_attrib)
+WERROR _winreg_SaveKey(pipes_struct *p, struct winreg_SaveKey *r)
{
- struct registry_key *regkey = find_regkey_by_hnd( p, handle );
+ struct registry_key *regkey = find_regkey_by_hnd( p, r->in.handle );
pstring fname;
int snum;
if ( !regkey )
return WERR_BADFID;
- if ( !filename || !filename->name )
+ if ( !r->in.filename || !r->in.filename->name )
return WERR_INVALID_PARAM;
- pstrcpy( fname, filename->name );
+ pstrcpy( fname, r->in.filename->name );
DEBUG(8,("_winreg_SaveKey: verifying backup of key [%s] to \"%s\"\n",
regkey->key->name, fname));
/*******************************************************************
********************************************************************/
-WERROR _winreg_SaveKeyEx(pipes_struct *p)
+WERROR _winreg_SaveKeyEx(pipes_struct *p, struct winreg_SaveKeyEx *r)
{
/* fill in your code here if you think this call should
do anything */
/*******************************************************************
********************************************************************/
-WERROR _winreg_CreateKey( pipes_struct *p, struct policy_handle *handle,
- struct winreg_String keyname,
- struct winreg_String keyclass,
- uint32_t options, uint32_t access_mask,
- struct winreg_SecBuf *secdesc,
- struct policy_handle *new_handle,
- enum winreg_CreateAction *action_taken )
+WERROR _winreg_CreateKey( pipes_struct *p, struct winreg_CreateKey *r)
{
- struct registry_key *parent = find_regkey_by_hnd(p, handle);
+ struct registry_key *parent = find_regkey_by_hnd(p, r->in.handle);
struct registry_key *new_key;
WERROR result;
if ( !parent )
return WERR_BADFID;
- result = reg_createkey(NULL, parent, keyname.name, access_mask,
- &new_key, action_taken);
+ result = reg_createkey(NULL, parent, r->in.name.name, r->in.access_mask,
+ &new_key, r->out.action_taken);
if (!W_ERROR_IS_OK(result)) {
return result;
}
- if (!create_policy_hnd(p, new_handle, free_regkey, new_key)) {
+ if (!create_policy_hnd(p, r->out.new_handle, free_regkey, new_key)) {
TALLOC_FREE(new_key);
return WERR_BADFILE;
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_SetValue(pipes_struct *p, struct policy_handle *handle,
- struct winreg_String name, enum winreg_Type type,
- uint8_t *data, uint32_t size)
+WERROR _winreg_SetValue(pipes_struct *p, struct winreg_SetValue *r)
{
- struct registry_key *key = find_regkey_by_hnd(p, handle);
+ struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
struct registry_value *val;
WERROR status;
if ( !key )
return WERR_BADFID;
- DEBUG(8,("_reg_set_value: Setting value for [%s:%s]\n", key->key->name,
- name.name));
+ DEBUG(8,("_reg_set_value: Setting value for [%s:%s]\n",
+ key->key->name, r->in.name.name));
- status = registry_pull_value(p->mem_ctx, &val, type, data, size, size);
+ status = registry_pull_value(p->mem_ctx, &val, r->in.type, r->in.data,
+ r->in.size, r->in.size);
if (!W_ERROR_IS_OK(status)) {
return status;
}
- return reg_setvalue(key, name.name, val);
+ return reg_setvalue(key, r->in.name.name, val);
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_DeleteKey(pipes_struct *p, struct policy_handle *handle,
- struct winreg_String key)
+WERROR _winreg_DeleteKey(pipes_struct *p, struct winreg_DeleteKey *r)
{
- struct registry_key *parent = find_regkey_by_hnd(p, handle);
+ struct registry_key *parent = find_regkey_by_hnd(p, r->in.handle);
if ( !parent )
return WERR_BADFID;
- return reg_deletekey(parent, key.name);
+ return reg_deletekey(parent, r->in.key.name);
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_DeleteValue(pipes_struct *p, struct policy_handle *handle,
- struct winreg_String value)
+WERROR _winreg_DeleteValue(pipes_struct *p, struct winreg_DeleteValue *r)
{
- struct registry_key *key = find_regkey_by_hnd(p, handle);
+ struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
if ( !key )
return WERR_BADFID;
- return reg_deletevalue(key, value.name);
+ return reg_deletevalue(key, r->in.value.name);
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_GetKeySecurity(pipes_struct *p, struct policy_handle *handle,
- uint32_t sec_info, struct KeySecurityData *sd)
+WERROR _winreg_GetKeySecurity(pipes_struct *p, struct winreg_GetKeySecurity *r)
{
- struct registry_key *key = find_regkey_by_hnd(p, handle);
+ struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
WERROR err;
struct security_descriptor *secdesc;
uint8 *data;
return err;
}
- if (len > sd->size) {
- sd->size = len;
+ if (len > r->out.sd->size) {
+ r->out.sd->size = len;
return WERR_INSUFFICIENT_BUFFER;
}
- sd->size = len;
- sd->len = len;
- sd->data = data;
+ r->out.sd->size = len;
+ r->out.sd->len = len;
+ r->out.sd->data = data;
return WERR_OK;
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_SetKeySecurity(pipes_struct *p, struct policy_handle *handle, uint32_t access_mask, struct KeySecurityData *sd)
+WERROR _winreg_SetKeySecurity(pipes_struct *p, struct winreg_SetKeySecurity *r)
{
- struct registry_key *key = find_regkey_by_hnd(p, handle);
+ struct registry_key *key = find_regkey_by_hnd(p, r->in.handle);
struct security_descriptor *secdesc;
WERROR err;
if ( !(key->key->access_granted & STD_RIGHT_WRITE_DAC_ACCESS) )
return WERR_ACCESS_DENIED;
- err = ntstatus_to_werror(unmarshall_sec_desc(p->mem_ctx, sd->data,
- sd->len, &secdesc));
+ err = ntstatus_to_werror(unmarshall_sec_desc(p->mem_ctx, r->in.sd->data,
+ r->in.sd->len, &secdesc));
if (!W_ERROR_IS_OK(err)) {
return err;
}
/*******************************************************************
********************************************************************/
-WERROR _winreg_FlushKey(pipes_struct *p, struct policy_handle *handle)
+WERROR _winreg_FlushKey(pipes_struct *p, struct winreg_FlushKey *r)
{
/* I'm just replying OK because there's not a lot
here I see to do i --jerry */
/*******************************************************************
********************************************************************/
-WERROR _winreg_UnLoadKey(pipes_struct *p)
+WERROR _winreg_UnLoadKey(pipes_struct *p, struct winreg_UnLoadKey *r)
{
/* fill in your code here if you think this call should
do anything */
/*******************************************************************
********************************************************************/
-WERROR _winreg_ReplaceKey(pipes_struct *p)
+WERROR _winreg_ReplaceKey(pipes_struct *p, struct winreg_ReplaceKey *r)
{
/* fill in your code here if you think this call should
do anything */
/*******************************************************************
********************************************************************/
-WERROR _winreg_LoadKey(pipes_struct *p, struct policy_handle *handle, struct winreg_String *keyname, struct winreg_String *filename)
+WERROR _winreg_LoadKey(pipes_struct *p, struct winreg_LoadKey *r)
{
/* fill in your code here if you think this call should
do anything */
/*******************************************************************
********************************************************************/
-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_NotifyChangeKeyValue(pipes_struct *p, struct winreg_NotifyChangeKeyValue *r)
{
/* fill in your code here if you think this call should
do anything */
/*******************************************************************
********************************************************************/
-WERROR _winreg_QueryMultipleValues(pipes_struct *p, struct policy_handle *key_handle, struct QueryMultipleValue *values, uint32_t num_values, uint8_t *buffer, uint32_t *buffer_size)
+WERROR _winreg_QueryMultipleValues(pipes_struct *p, struct winreg_QueryMultipleValues *r)
{
/* fill in your code here if you think this call should
do anything */
/*******************************************************************
********************************************************************/
-WERROR _winreg_QueryMultipleValues2(pipes_struct *p)
+WERROR _winreg_QueryMultipleValues2(pipes_struct *p, struct winreg_QueryMultipleValues2 *r)
{
/* fill in your code here if you think this call should
do anything */
only supports info level 100 at the moment.
********************************************************************/
-WERROR _wkssvc_NetWkstaGetInfo( pipes_struct *p, const char *server_name, uint32_t level,
- union wkssvc_NetWkstaInfo *info )
+WERROR _wkssvc_NetWkstaGetInfo( pipes_struct *p, struct wkssvc_NetWkstaGetInfo *r)
{
struct wkssvc_NetWkstaInfo100 *wks100 = NULL;
/* We only support info level 100 currently */
- if ( level != 100 ) {
+ if ( r->in.level != 100 ) {
return WERR_UNKNOWN_LEVEL;
}
create_wks_info_100( wks100 );
- info->info100 = wks100;
+ r->out.info->info100 = wks100;
return WERR_OK;
}
/********************************************************************
********************************************************************/
-WERROR _wkssvc_NetWkstaSetInfo( pipes_struct *p, const char *server_name,
- uint32_t level, union wkssvc_NetWkstaInfo *info,
- uint32_t *parm_error )
+WERROR _wkssvc_NetWkstaSetInfo( pipes_struct *p, struct wkssvc_NetWkstaSetInfo *r)
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _wkssvc_NetWkstaEnumUsers( pipes_struct *p, const char *server_name,
- uint32_t level,
- union WKS_USER_ENUM_UNION *users,
- uint32_t prefmaxlen, uint32_t *entriesread,
- uint32_t *totalentries,
- uint32_t *resumehandle )
+WERROR _wkssvc_NetWkstaEnumUsers( pipes_struct *p, struct wkssvc_NetWkstaEnumUsers *r)
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _WKSSVC_NETRWKSTAUSERGETINFO( pipes_struct *p )
+WERROR _WKSSVC_NETRWKSTAUSERGETINFO( pipes_struct *p, struct WKSSVC_NETRWKSTAUSERGETINFO *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _WKSSVC_NETRWKSTAUSERSETINFO( pipes_struct *p )
+WERROR _WKSSVC_NETRWKSTAUSERSETINFO( pipes_struct *p, struct WKSSVC_NETRWKSTAUSERSETINFO *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _wkssvc_NetWkstaTransportEnum( pipes_struct *p, const char *server_name, uint32_t *level, union wkssvc_NetWkstaTransportCtr *ctr, uint32_t max_buffer, uint32_t *totalentries, uint32_t *resume_handle)
+WERROR _wkssvc_NetWkstaTransportEnum( pipes_struct *p, struct wkssvc_NetWkstaTransportEnum *r)
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _WKSSVC_NETRWKSTATRANSPORTADD( pipes_struct *p )
+WERROR _WKSSVC_NETRWKSTATRANSPORTADD( pipes_struct *p, struct WKSSVC_NETRWKSTATRANSPORTADD *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _WKSSVC_NETRWKSTATRANSPORTDEL( pipes_struct *p )
+WERROR _WKSSVC_NETRWKSTATRANSPORTDEL( pipes_struct *p, struct WKSSVC_NETRWKSTATRANSPORTDEL *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _WKSSVC_NETRUSEADD( pipes_struct *p )
+WERROR _WKSSVC_NETRUSEADD( pipes_struct *p, struct WKSSVC_NETRUSEADD *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _WKSSVC_NETRUSEGETINFO( pipes_struct *p )
+WERROR _WKSSVC_NETRUSEGETINFO( pipes_struct *p, struct WKSSVC_NETRUSEGETINFO *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _WKSSVC_NETRUSEDEL( pipes_struct *p )
+WERROR _WKSSVC_NETRUSEDEL( pipes_struct *p, struct WKSSVC_NETRUSEDEL *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _WKSSVC_NETRUSEENUM( pipes_struct *p )
+WERROR _WKSSVC_NETRUSEENUM( pipes_struct *p, struct WKSSVC_NETRUSEENUM *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _WKSSVC_NETRMESSAGEBUFFERSEND( pipes_struct *p )
+WERROR _WKSSVC_NETRMESSAGEBUFFERSEND( pipes_struct *p, struct WKSSVC_NETRMESSAGEBUFFERSEND *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _WKSSVC_NETRWORKSTATIONSTATISTICSGET( pipes_struct *p )
+WERROR _WKSSVC_NETRWORKSTATIONSTATISTICSGET( pipes_struct *p, struct WKSSVC_NETRWORKSTATIONSTATISTICSGET *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _WKSSVC_NETRLOGONDOMAINNAMEADD( pipes_struct *p )
+WERROR _WKSSVC_NETRLOGONDOMAINNAMEADD( pipes_struct *p, struct WKSSVC_NETRLOGONDOMAINNAMEADD *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _WKSSVC_NETRLOGONDOMAINNAMEDEL( pipes_struct *p )
+WERROR _WKSSVC_NETRLOGONDOMAINNAMEDEL( pipes_struct *p, struct WKSSVC_NETRLOGONDOMAINNAMEDEL *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _WKSSVC_NETRJOINDOMAIN( pipes_struct *p )
+WERROR _WKSSVC_NETRJOINDOMAIN( pipes_struct *p, struct WKSSVC_NETRJOINDOMAIN *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _WKSSVC_NETRUNJOINDOMAIN( pipes_struct *p )
+WERROR _WKSSVC_NETRUNJOINDOMAIN( pipes_struct *p, struct WKSSVC_NETRUNJOINDOMAIN *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _WKSSVC_NETRRENAMEMACHINEINDOMAIN( pipes_struct *p )
+WERROR _WKSSVC_NETRRENAMEMACHINEINDOMAIN( pipes_struct *p, struct WKSSVC_NETRRENAMEMACHINEINDOMAIN *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _WKSSVC_NETRVALIDATENAME( pipes_struct *p )
+WERROR _WKSSVC_NETRVALIDATENAME( pipes_struct *p, struct WKSSVC_NETRVALIDATENAME *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _WKSSVC_NETRGETJOININFORMATION( pipes_struct *p )
+WERROR _WKSSVC_NETRGETJOININFORMATION( pipes_struct *p, struct WKSSVC_NETRGETJOININFORMATION *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _WKSSVC_NETRGETJOINABLEOUS( pipes_struct *p )
+WERROR _WKSSVC_NETRGETJOINABLEOUS( pipes_struct *p, struct WKSSVC_NETRGETJOINABLEOUS *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _wkssvc_NetrJoinDomain2(pipes_struct *p, const char *server_name, const char *domain_name, const char *account_name, const char *admin_account, struct wkssvc_PasswordBuffer *encrypted_password, uint32_t join_flags)
+WERROR _wkssvc_NetrJoinDomain2(pipes_struct *p, struct wkssvc_NetrJoinDomain2 *r)
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _wkssvc_NetrUnjoinDomain2(pipes_struct *p, const char *server_name, const char *account, struct wkssvc_PasswordBuffer *encrypted_password, uint32_t unjoin_flags)
+WERROR _wkssvc_NetrUnjoinDomain2(pipes_struct *p, struct wkssvc_NetrUnjoinDomain2 *r)
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _wkssvc_NetrRenameMachineInDomain2(pipes_struct *p, const char *server_name, const char *NewMachineName, const char *Account, struct wkssvc_PasswordBuffer *EncryptedPassword, uint32_t RenameOptions)
+WERROR _wkssvc_NetrRenameMachineInDomain2(pipes_struct *p, struct wkssvc_NetrRenameMachineInDomain2 *r)
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _WKSSVC_NETRVALIDATENAME2( pipes_struct *p )
+WERROR _WKSSVC_NETRVALIDATENAME2( pipes_struct *p, struct WKSSVC_NETRVALIDATENAME2 *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _WKSSVC_NETRGETJOINABLEOUS2( pipes_struct *p )
+WERROR _WKSSVC_NETRGETJOINABLEOUS2( pipes_struct *p, struct WKSSVC_NETRGETJOINABLEOUS2 *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _wkssvc_NetrAddAlternateComputerName(pipes_struct *p, const char *server_name, const char *NewAlternateMachineName, const char *Account, struct wkssvc_PasswordBuffer *EncryptedPassword, uint32_t Reserved)
+WERROR _wkssvc_NetrAddAlternateComputerName(pipes_struct *p, struct wkssvc_NetrAddAlternateComputerName *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _wkssvc_NetrRemoveAlternateComputerName(pipes_struct *p, const char *server_name, const char *AlternateMachineNameToRemove, const char *Account, struct wkssvc_PasswordBuffer *EncryptedPassword, uint32_t Reserved)
+WERROR _wkssvc_NetrRemoveAlternateComputerName(pipes_struct *p, struct wkssvc_NetrRemoveAlternateComputerName *r)
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _WKSSVC_NETRSETPRIMARYCOMPUTERNAME( pipes_struct *p )
+WERROR _WKSSVC_NETRSETPRIMARYCOMPUTERNAME( pipes_struct *p, struct WKSSVC_NETRSETPRIMARYCOMPUTERNAME *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
/********************************************************************
********************************************************************/
-WERROR _WKSSVC_NETRENUMERATECOMPUTERNAMES( pipes_struct *p )
+WERROR _WKSSVC_NETRENUMERATECOMPUTERNAMES( pipes_struct *p, struct WKSSVC_NETRENUMERATECOMPUTERNAMES *r )
{
/* FIXME: Add implementation code here */
p->rng_fault_state = True;
git.samba.org / ira / wip.git / commitdiff