sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-03-01 04:58:35 +03:00
Code

changed wks to wkssvc (suggestion from metze). Started adding samr_CreateUser().

Browse Source 
(This used to be commit 04e9269c1e37c9c2984ee2886fa6c0eda5c19669)
This commit is contained in:
Andrew Tridgell 2003-11-18 08:03:06 +00:00
parent 30daed2f7c
commit 20f1530a11
10 changed files with 832 additions and 600 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
source4/librpc/idl/samr.idl
View File

@ -211,7 +211,13 @@
/************************/
/* Function 0x0c */
NTSTATUS samr_CREATE_USER_IN_DOMAIN();
NTSTATUS samr_CreateUser(
[in,ref] policy_handle *handle,
[in] samr_Name *username,
[in] uint32 access_mask,
[out] policy_handle *acct_handle,
[out] uint32 *rid
);
/************************/
/* Function 0x0d */
@ -240,7 +246,22 @@
/************************/
/* Function 0x10 */
NTSTATUS samr_GET_ALIAS_MEMBERSHIP();
typedef struct {
uint32 count;
[size_is(count)] dom_sid2 *sids;
} samr_Sids;
typedef struct {
uint32 count;
[size_is(count)] uint32 *rids;
} samr_Rids;
NTSTATUS samr_GetAliasMembership(
[in,ref] policy_handle *handle,
[in] samr_Sids *sids,
[out] samr_Rids *rids
);
/************************/
/* Function 0x11 */
@ -390,7 +411,9 @@
/************************/
/* Function 0x23 */
NTSTATUS samr_DELETE_DOM_USER();
NTSTATUS samr_DeleteUser(
[in,out] policy_handle *handle
);
/************************/
/* Function 0x24 */

94
source4/librpc/idl/wkssvc.idl
View File

@ -15,7 +15,7 @@
unistr *domain;
uint32 ver_major;
uint32 ver_minor;
} wks_Info100;
} wkssvc_Info100;
typedef struct {
uint32 platform_id;
@ -24,7 +24,7 @@
uint32 ver_major;
uint32 ver_minor;
unistr *lan_root;
} wks_Info101;
} wkssvc_Info101;
typedef struct {
uint32 platform_id;
@ -34,36 +34,36 @@
uint32 ver_minor;
unistr *lan_root;
uint32 logged_on_users;
} wks_Info102;
} wkssvc_Info102;
typedef union {
case (100) wks_Info100 *info100;
case (101) wks_Info101 *info101;
case (102) wks_Info102 *info102;
} wks_Info;
case (100) wkssvc_Info100 *info100;
case (101) wkssvc_Info101 *info101;
case (102) wkssvc_Info102 *info102;
} wkssvc_Info;
WERROR wks_QueryInfo(
WERROR wkssvc_QueryInfo(
[in] unistr *server_name,
[in] uint32 level,
[out,switch_is(level)] wks_Info info
[out,switch_is(level)] wkssvc_Info info
);
/******************/
/* Function: 0x01 */
WERROR wks_SetInfo();
WERROR wkssvc_SetInfo();
/*****************************/
/* Function 0x02 */
WERROR WKS_NETRWKSTAUSERENUM ();
WERROR WKSSVC_NETRWKSTAUSERENUM ();
/*****************************/
/* Function 0x03 */
WERROR WKS_NETRWKSTAUSERGETINFO ();
WERROR WKSSVC_NETRWKSTAUSERGETINFO ();
/*****************************/
/* Function 0x04 */
WERROR WKS_NETRWKSTAUSERSETINFO ();
WERROR WKSSVC_NETRWKSTAUSERSETINFO ();
/*****************************/
@ -75,25 +75,25 @@
unistr *name;
unistr *address;
uint32 wan_link;
} wks_TransportInfo0;
} wkssvc_TransportInfo0;
typedef struct {
uint32 count;
[size_is(count)] wks_TransportInfo0 *transports;
} wks_TransportInfoArray;
[size_is(count)] wkssvc_TransportInfo0 *transports;
} wkssvc_TransportInfoArray;
typedef union {
case(0) wks_TransportInfoArray *array;
} wks_TransportUnion;
case(0) wkssvc_TransportInfoArray *array;
} wkssvc_TransportUnion;
typedef struct {
uint32 level;
[switch_is(level)] wks_TransportUnion u;
} wks_TransportInfo;
[switch_is(level)] wkssvc_TransportUnion u;
} wkssvc_TransportInfo;
WERROR wks_TransportEnum (
WERROR wkssvc_TransportEnum (
[in] unistr *server_name,
[in,out,ref] wks_TransportInfo *info,
[in,out,ref] wkssvc_TransportInfo *info,
[in] uint32 max_buffer,
[out] uint32 unknown,
[in,out] uint32 *resume_handle
@ -102,101 +102,101 @@
/*****************************/
/* Function 0x06 */
WERROR WKS_NETRWKSTATRANSPORTADD ();
WERROR WKSSVC_NETRWKSTATRANSPORTADD ();
/*****************************/
/* Function 0x07 */
WERROR WKS_NETRWKSTATRANSPORTDEL ();
WERROR WKSSVC_NETRWKSTATRANSPORTDEL ();
/*****************************/
/* Function 0x08 */
WERROR WKS_NETRUSEADD ();
WERROR WKSSVC_NETRUSEADD ();
/*****************************/
/* Function 0x09 */
WERROR WKS_NETRUSEGETINFO ();
WERROR WKSSVC_NETRUSEGETINFO ();
/*****************************/
/* Function 0x0a */
WERROR WKS_NETRUSEDEL ();
WERROR WKSSVC_NETRUSEDEL ();
/*****************************/
/* Function 0x0b */
WERROR WKS_NETRUSEENUM ();
WERROR WKSSVC_NETRUSEENUM ();
/*****************************/
/* Function 0x0c */
WERROR WKS_NETRMESSAGEBUFFERSEND ();
WERROR WKSSVC_NETRMESSAGEBUFFERSEND ();
/*****************************/
/* Function 0x0d */
WERROR WKS_NETRWORKSTATIONSTATISTICSGET ();
WERROR WKSSVC_NETRWORKSTATIONSTATISTICSGET ();
/*****************************/
/* Function 0x0e */
WERROR WKS_NETRLOGONDOMAINNAMEADD ();
WERROR WKSSVC_NETRLOGONDOMAINNAMEADD ();
/*****************************/
/* Function 0x0f */
WERROR WKS_NETRLOGONDOMAINNAMEDEL ();
WERROR WKSSVC_NETRLOGONDOMAINNAMEDEL ();
/*****************************/
/* Function 0x10 */
WERROR WKS_NETRJOINDOMAIN ();
WERROR WKSSVC_NETRJOINDOMAIN ();
/*****************************/
/* Function 0x11 */
WERROR WKS_NETRUNJOINDOMAIN ();
WERROR WKSSVC_NETRUNJOINDOMAIN ();
/*****************************/
/* Function 0x12 */
WERROR WKS_NETRRENAMEMACHINEINDOMAIN ();
WERROR WKSSVC_NETRRENAMEMACHINEINDOMAIN ();
/*****************************/
/* Function 0x13 */
WERROR WKS_NETRVALIDATENAME ();
WERROR WKSSVC_NETRVALIDATENAME ();
/*****************************/
/* Function 0x14 */
WERROR WKS_NETRGETJOININFORMATION ();
WERROR WKSSVC_NETRGETJOININFORMATION ();
/*****************************/
/* Function 0x15 */
WERROR WKS_NETRGETJOINABLEOUS ();
WERROR WKSSVC_NETRGETJOINABLEOUS ();
/*****************************/
/* Function 0x16 */
WERROR WKS_NETRJOINDOMAIN2 ();
WERROR WKSSVC_NETRJOINDOMAIN2 ();
/*****************************/
/* Function 0x17 */
WERROR WKS_NETRUNJOINDOMAIN2 ();
WERROR WKSSVC_NETRUNJOINDOMAIN2 ();
/*****************************/
/* Function 0x18 */
WERROR WKS_NETRRENAMEMACHINEINDOMAIN2 ();
WERROR WKSSVC_NETRRENAMEMACHINEINDOMAIN2 ();
/*****************************/
/* Function 0x19 */
WERROR WKS_NETRVALIDATENAME2 ();
WERROR WKSSVC_NETRVALIDATENAME2 ();
/*****************************/
/* Function 0x1a */
WERROR WKS_NETRGETJOINABLEOUS2 ();
WERROR WKSSVC_NETRGETJOINABLEOUS2 ();
/*****************************/
/* Function 0x1b */
WERROR WKS_NETRADDALTERNATECOMPUTERNAME ();
WERROR WKSSVC_NETRADDALTERNATECOMPUTERNAME ();
/*****************************/
/* Function 0x1c */
WERROR WKS_NETRREMOVEALTERNATECOMPUTERNAME ();
WERROR WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME ();
/*****************************/
/* Function 0x1d */
WERROR WKS_NETRSETPRIMARYCOMPUTERNAME ();
WERROR WKSSVC_NETRSETPRIMARYCOMPUTERNAME ();
/*****************************/
/* Function 0x1e */
WERROR WKS_NETRENUMERATECOMPUTERNAMES ();
WERROR WKSSVC_NETRENUMERATECOMPUTERNAMES ();
}

219
source4/librpc/ndr/ndr_samr.c
View File

@ -113,8 +113,14 @@ NTSTATUS ndr_push_samr_EnumDomainGroups(struct ndr_push *ndr, struct samr_EnumDo
return NT_STATUS_OK;
}
NTSTATUS ndr_push_samr_CREATE_USER_IN_DOMAIN(struct ndr_push *ndr, struct samr_CREATE_USER_IN_DOMAIN *r)
NTSTATUS ndr_push_samr_CreateUser(struct ndr_push *ndr, struct samr_CreateUser *r)
{
NDR_CHECK(ndr_push_policy_handle(ndr, r->in.handle));
NDR_CHECK(ndr_push_ptr(ndr, r->in.username));
if (r->in.username) {
NDR_CHECK(ndr_push_samr_Name(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.username));
}
NDR_CHECK(ndr_push_uint32(ndr, r->in.access_mask));
return NT_STATUS_OK;
}
@ -144,8 +150,31 @@ NTSTATUS ndr_push_samr_EnumDomainAliases(struct ndr_push *ndr, struct samr_EnumD
return NT_STATUS_OK;
}
NTSTATUS ndr_push_samr_GET_ALIAS_MEMBERSHIP(struct ndr_push *ndr, struct samr_GET_ALIAS_MEMBERSHIP *r)
NTSTATUS ndr_push_samr_Sids(struct ndr_push *ndr, int ndr_flags, struct samr_Sids *r)
{
if (!(ndr_flags & NDR_SCALARS)) goto buffers;
NDR_CHECK(ndr_push_struct_start(ndr));
NDR_CHECK(ndr_push_align(ndr, 4));
NDR_CHECK(ndr_push_uint32(ndr, r->count));
NDR_CHECK(ndr_push_ptr(ndr, r->sids));
ndr_push_struct_end(ndr);
buffers:
if (!(ndr_flags & NDR_BUFFERS)) goto done;
if (r->sids) {
NDR_CHECK(ndr_push_uint32(ndr, r->count));
NDR_CHECK(ndr_push_array(ndr, NDR_SCALARS|NDR_BUFFERS, r->sids, sizeof(r->sids[0]), r->count, (ndr_push_flags_fn_t)ndr_push_dom_sid2));
}
done:
return NT_STATUS_OK;
}
NTSTATUS ndr_push_samr_GetAliasMembership(struct ndr_push *ndr, struct samr_GetAliasMembership *r)
{
NDR_CHECK(ndr_push_policy_handle(ndr, r->in.handle));
NDR_CHECK(ndr_push_ptr(ndr, r->in.sids));
if (r->in.sids) {
NDR_CHECK(ndr_push_samr_Sids(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.sids));
}
return NT_STATUS_OK;
}
@ -271,8 +300,12 @@ NTSTATUS ndr_push_samr_OpenUser(struct ndr_push *ndr, struct samr_OpenUser *r)
return NT_STATUS_OK;
}
NTSTATUS ndr_push_samr_DELETE_DOM_USER(struct ndr_push *ndr, struct samr_DELETE_DOM_USER *r)
NTSTATUS ndr_push_samr_DeleteUser(struct ndr_push *ndr, struct samr_DeleteUser *r)
{
NDR_CHECK(ndr_push_ptr(ndr, r->in.handle));
if (r->in.handle) {
NDR_CHECK(ndr_push_policy_handle(ndr, r->in.handle));
}
return NT_STATUS_OK;
}
@ -1015,8 +1048,28 @@ NTSTATUS ndr_pull_samr_EnumDomainGroups(struct ndr_pull *ndr, struct samr_EnumDo
return NT_STATUS_OK;
}
NTSTATUS ndr_pull_samr_CREATE_USER_IN_DOMAIN(struct ndr_pull *ndr, struct samr_CREATE_USER_IN_DOMAIN *r)
NTSTATUS ndr_pull_samr_CreateUser(struct ndr_pull *ndr, struct samr_CreateUser *r)
{
uint32 _ptr_acct_handle;
uint32 _ptr_rid;
NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_acct_handle));
if (_ptr_acct_handle) {
NDR_ALLOC(ndr, r->out.acct_handle);
} else {
r->out.acct_handle = NULL;
}
if (r->out.acct_handle) {
NDR_CHECK(ndr_pull_policy_handle(ndr, r->out.acct_handle));
}
NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_rid));
if (_ptr_rid) {
NDR_ALLOC(ndr, r->out.rid);
} else {
r->out.rid = NULL;
}
if (r->out.rid) {
NDR_CHECK(ndr_pull_uint32(ndr, r->out.rid));
}
NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
return NT_STATUS_OK;
@ -1067,8 +1120,49 @@ NTSTATUS ndr_pull_samr_EnumDomainAliases(struct ndr_pull *ndr, struct samr_EnumD
return NT_STATUS_OK;
}
NTSTATUS ndr_pull_samr_GET_ALIAS_MEMBERSHIP(struct ndr_pull *ndr, struct samr_GET_ALIAS_MEMBERSHIP *r)
NTSTATUS ndr_pull_samr_Rids(struct ndr_pull *ndr, int ndr_flags, struct samr_Rids *r)
{
uint32 _ptr_rids;
NDR_CHECK(ndr_pull_struct_start(ndr));
if (!(ndr_flags & NDR_SCALARS)) goto buffers;
NDR_CHECK(ndr_pull_align(ndr, 4));
NDR_CHECK(ndr_pull_uint32(ndr, &r->count));
NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_rids));
if (_ptr_rids) {
NDR_ALLOC(ndr, r->rids);
} else {
r->rids = NULL;
}
ndr_pull_struct_end(ndr);
buffers:
if (!(ndr_flags & NDR_BUFFERS)) goto done;
if (r->rids) {
{
uint32 _array_size;
NDR_CHECK(ndr_pull_uint32(ndr, &_array_size));
if (r->count > _array_size) {
return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should be %u", _array_size, r->count);
}
}
NDR_ALLOC_N_SIZE(ndr, r->rids, r->count, sizeof(r->rids[0]));
NDR_CHECK(ndr_pull_array_uint32(ndr, NDR_SCALARS|NDR_BUFFERS, r->rids, r->count));
}
done:
return NT_STATUS_OK;
}
NTSTATUS ndr_pull_samr_GetAliasMembership(struct ndr_pull *ndr, struct samr_GetAliasMembership *r)
{
uint32 _ptr_rids;
NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_rids));
if (_ptr_rids) {
NDR_ALLOC(ndr, r->out.rids);
} else {
r->out.rids = NULL;
}
if (r->out.rids) {
NDR_CHECK(ndr_pull_samr_Rids(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.rids));
}
NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
return NT_STATUS_OK;
@ -1429,8 +1523,18 @@ NTSTATUS ndr_pull_samr_OpenUser(struct ndr_pull *ndr, struct samr_OpenUser *r)
return NT_STATUS_OK;
}
NTSTATUS ndr_pull_samr_DELETE_DOM_USER(struct ndr_pull *ndr, struct samr_DELETE_DOM_USER *r)
NTSTATUS ndr_pull_samr_DeleteUser(struct ndr_pull *ndr, struct samr_DeleteUser *r)
{
uint32 _ptr_handle;
NDR_CHECK(ndr_pull_uint32(ndr, &_ptr_handle));
if (_ptr_handle) {
NDR_ALLOC(ndr, r->out.handle);
} else {
r->out.handle = NULL;
}
if (r->out.handle) {
NDR_CHECK(ndr_pull_policy_handle(ndr, r->out.handle));
}
NDR_CHECK(ndr_pull_NTSTATUS(ndr, &r->out.result));
return NT_STATUS_OK;
@ -2858,18 +2962,41 @@ void ndr_print_samr_EnumDomainGroups(struct ndr_print *ndr, const char *name, in
ndr->depth--;
}
void ndr_print_samr_CREATE_USER_IN_DOMAIN(struct ndr_print *ndr, const char *name, int flags, struct samr_CREATE_USER_IN_DOMAIN *r)
void ndr_print_samr_CreateUser(struct ndr_print *ndr, const char *name, int flags, struct samr_CreateUser *r)
{
ndr_print_struct(ndr, name, "samr_CREATE_USER_IN_DOMAIN");
ndr_print_struct(ndr, name, "samr_CreateUser");
ndr->depth++;
if (flags & NDR_IN) {
ndr_print_struct(ndr, "in", "samr_CREATE_USER_IN_DOMAIN");
ndr_print_struct(ndr, "in", "samr_CreateUser");
ndr->depth++;
ndr_print_ptr(ndr, "handle", r->in.handle);
ndr->depth++;
ndr_print_policy_handle(ndr, "handle", r->in.handle);
ndr->depth--;
ndr_print_ptr(ndr, "username", r->in.username);
ndr->depth++;
if (r->in.username) {
ndr_print_samr_Name(ndr, "username", r->in.username);
}
ndr->depth--;
ndr_print_uint32(ndr, "access_mask", r->in.access_mask);
ndr->depth--;
}
if (flags & NDR_OUT) {
ndr_print_struct(ndr, "out", "samr_CREATE_USER_IN_DOMAIN");
ndr_print_struct(ndr, "out", "samr_CreateUser");
ndr->depth++;
ndr_print_ptr(ndr, "acct_handle", r->out.acct_handle);
ndr->depth++;
if (r->out.acct_handle) {
ndr_print_policy_handle(ndr, "acct_handle", r->out.acct_handle);
}
ndr->depth--;
ndr_print_ptr(ndr, "rid", r->out.rid);
ndr->depth++;
if (r->out.rid) {
ndr_print_uint32(ndr, "rid", *r->out.rid);
}
ndr->depth--;
ndr_print_NTSTATUS(ndr, "result", &r->out.result);
ndr->depth--;
}
@ -2971,18 +3098,62 @@ void ndr_print_samr_EnumDomainAliases(struct ndr_print *ndr, const char *name, i
ndr->depth--;
}
void ndr_print_samr_GET_ALIAS_MEMBERSHIP(struct ndr_print *ndr, const char *name, int flags, struct samr_GET_ALIAS_MEMBERSHIP *r)
void ndr_print_samr_Sids(struct ndr_print *ndr, const char *name, struct samr_Sids *r)
{
ndr_print_struct(ndr, name, "samr_GET_ALIAS_MEMBERSHIP");
ndr_print_struct(ndr, name, "samr_Sids");
ndr->depth++;
ndr_print_uint32(ndr, "count", r->count);
ndr_print_ptr(ndr, "sids", r->sids);
ndr->depth++;
if (r->sids) {
ndr_print_array(ndr, "sids", r->sids, sizeof(r->sids[0]), r->count, (ndr_print_fn_t)ndr_print_dom_sid2);
}
ndr->depth--;
ndr->depth--;
}
void ndr_print_samr_Rids(struct ndr_print *ndr, const char *name, struct samr_Rids *r)
{
ndr_print_struct(ndr, name, "samr_Rids");
ndr->depth++;
ndr_print_uint32(ndr, "count", r->count);
ndr_print_ptr(ndr, "rids", r->rids);
ndr->depth++;
if (r->rids) {
ndr_print_array_uint32(ndr, "rids", r->rids, r->count);
}
ndr->depth--;
ndr->depth--;
}
void ndr_print_samr_GetAliasMembership(struct ndr_print *ndr, const char *name, int flags, struct samr_GetAliasMembership *r)
{
ndr_print_struct(ndr, name, "samr_GetAliasMembership");
ndr->depth++;
if (flags & NDR_IN) {
ndr_print_struct(ndr, "in", "samr_GET_ALIAS_MEMBERSHIP");
ndr_print_struct(ndr, "in", "samr_GetAliasMembership");
ndr->depth++;
ndr_print_ptr(ndr, "handle", r->in.handle);
ndr->depth++;
ndr_print_policy_handle(ndr, "handle", r->in.handle);
ndr->depth--;
ndr_print_ptr(ndr, "sids", r->in.sids);
ndr->depth++;
if (r->in.sids) {
ndr_print_samr_Sids(ndr, "sids", r->in.sids);
}
ndr->depth--;
ndr->depth--;
}
if (flags & NDR_OUT) {
ndr_print_struct(ndr, "out", "samr_GET_ALIAS_MEMBERSHIP");
ndr_print_struct(ndr, "out", "samr_GetAliasMembership");
ndr->depth++;
ndr_print_ptr(ndr, "rids", r->out.rids);
ndr->depth++;
if (r->out.rids) {
ndr_print_samr_Rids(ndr, "rids", r->out.rids);
}
ndr->depth--;
ndr_print_NTSTATUS(ndr, "result", &r->out.result);
ndr->depth--;
}
@ -3472,18 +3643,30 @@ void ndr_print_samr_OpenUser(struct ndr_print *ndr, const char *name, int flags,
ndr->depth--;
}
void ndr_print_samr_DELETE_DOM_USER(struct ndr_print *ndr, const char *name, int flags, struct samr_DELETE_DOM_USER *r)
void ndr_print_samr_DeleteUser(struct ndr_print *ndr, const char *name, int flags, struct samr_DeleteUser *r)
{
ndr_print_struct(ndr, name, "samr_DELETE_DOM_USER");
ndr_print_struct(ndr, name, "samr_DeleteUser");
ndr->depth++;
if (flags & NDR_IN) {
ndr_print_struct(ndr, "in", "samr_DELETE_DOM_USER");
ndr_print_struct(ndr, "in", "samr_DeleteUser");
ndr->depth++;
ndr_print_ptr(ndr, "handle", r->in.handle);
ndr->depth++;
if (r->in.handle) {
ndr_print_policy_handle(ndr, "handle", r->in.handle);
}
ndr->depth--;
ndr->depth--;
}
if (flags & NDR_OUT) {
ndr_print_struct(ndr, "out", "samr_DELETE_DOM_USER");
ndr_print_struct(ndr, "out", "samr_DeleteUser");
ndr->depth++;
ndr_print_ptr(ndr, "handle", r->out.handle);
ndr->depth++;
if (r->out.handle) {
ndr_print_policy_handle(ndr, "handle", r->out.handle);
}
ndr->depth--;
ndr_print_NTSTATUS(ndr, "result", &r->out.result);
ndr->depth--;
}

32
source4/librpc/ndr/ndr_samr.h
View File

@ -16,11 +16,11 @@
#define DCERPC_SAMR_SET_DOMAIN_INFO 9
#define DCERPC_SAMR_CREATE_DOM_GROUP 10
#define DCERPC_SAMR_ENUMDOMAINGROUPS 11
#define DCERPC_SAMR_CREATE_USER_IN_DOMAIN 12
#define DCERPC_SAMR_CREATEUSER 12
#define DCERPC_SAMR_ENUMDOMAINUSERS 13
#define DCERPC_SAMR_CREATE_DOM_ALIAS 14
#define DCERPC_SAMR_ENUMDOMAINALIASES 15
#define DCERPC_SAMR_GET_ALIAS_MEMBERSHIP 16
#define DCERPC_SAMR_GETALIASMEMBERSHIP 16
#define DCERPC_SAMR_LOOKUP_NAMES 17
#define DCERPC_SAMR_LOOKUP_RIDS 18
#define DCERPC_SAMR_OPENGROUP 19
@ -39,7 +39,7 @@
#define DCERPC_SAMR_DEL_ALIASMEM 32
#define DCERPC_SAMR_GET_MEMBERS_IN_ALIAS 33
#define DCERPC_SAMR_OPENUSER 34
#define DCERPC_SAMR_DELETE_DOM_USER 35
#define DCERPC_SAMR_DELETEUSER 35
#define DCERPC_SAMR_QUERYUSERINFO 36
#define DCERPC_SAMR_SET_USERINFO 37
#define DCERPC_SAMR_CHANGE_PASSWORD_USER 38
@ -337,11 +337,16 @@ struct samr_EnumDomainGroups {
};
struct samr_CREATE_USER_IN_DOMAIN {
struct samr_CreateUser {
struct {
struct policy_handle *handle;
struct samr_Name *username;
uint32 access_mask;
} in;
struct {
struct policy_handle *acct_handle;
uint32 *rid;
NTSTATUS result;
} out;
@ -390,11 +395,24 @@ struct samr_EnumDomainAliases {
};
struct samr_GET_ALIAS_MEMBERSHIP {
struct samr_Sids {
uint32 count;
struct dom_sid2 *sids;
};
struct samr_Rids {
uint32 count;
uint32 *rids;
};
struct samr_GetAliasMembership {
struct {
struct policy_handle *handle;
struct samr_Sids *sids;
} in;
struct {
struct samr_Rids *rids;
NTSTATUS result;
} out;
@ -644,11 +662,13 @@ struct samr_OpenUser {
};
struct samr_DELETE_DOM_USER {
struct samr_DeleteUser {
struct {
struct policy_handle *handle;
} in;
struct {
struct policy_handle *handle;
NTSTATUS result;
} out;

474
source4/librpc/ndr/ndr_wkssvc.c
View File

File diff suppressed because it is too large Load Diff

158
source4/librpc/ndr/ndr_wkssvc.h
View File

@ -4,40 +4,40 @@
#define DCERPC_WKSSVC_VERSION 1.0
#define DCERPC_WKSSVC_NAME "wkssvc"
#define DCERPC_WKS_QUERYINFO 0
#define DCERPC_WKS_SETINFO 1
#define DCERPC_WKS_NETRWKSTAUSERENUM 2
#define DCERPC_WKS_NETRWKSTAUSERGETINFO 3
#define DCERPC_WKS_NETRWKSTAUSERSETINFO 4
#define DCERPC_WKS_TRANSPORTENUM 5
#define DCERPC_WKS_NETRWKSTATRANSPORTADD 6
#define DCERPC_WKS_NETRWKSTATRANSPORTDEL 7
#define DCERPC_WKS_NETRUSEADD 8
#define DCERPC_WKS_NETRUSEGETINFO 9
#define DCERPC_WKS_NETRUSEDEL 10
#define DCERPC_WKS_NETRUSEENUM 11
#define DCERPC_WKS_NETRMESSAGEBUFFERSEND 12
#define DCERPC_WKS_NETRWORKSTATIONSTATISTICSGET 13
#define DCERPC_WKS_NETRLOGONDOMAINNAMEADD 14
#define DCERPC_WKS_NETRLOGONDOMAINNAMEDEL 15
#define DCERPC_WKS_NETRJOINDOMAIN 16
#define DCERPC_WKS_NETRUNJOINDOMAIN 17
#define DCERPC_WKS_NETRRENAMEMACHINEINDOMAIN 18
#define DCERPC_WKS_NETRVALIDATENAME 19
#define DCERPC_WKS_NETRGETJOININFORMATION 20
#define DCERPC_WKS_NETRGETJOINABLEOUS 21
#define DCERPC_WKS_NETRJOINDOMAIN2 22
#define DCERPC_WKS_NETRUNJOINDOMAIN2 23
#define DCERPC_WKS_NETRRENAMEMACHINEINDOMAIN2 24
#define DCERPC_WKS_NETRVALIDATENAME2 25
#define DCERPC_WKS_NETRGETJOINABLEOUS2 26
#define DCERPC_WKS_NETRADDALTERNATECOMPUTERNAME 27
#define DCERPC_WKS_NETRREMOVEALTERNATECOMPUTERNAME 28
#define DCERPC_WKS_NETRSETPRIMARYCOMPUTERNAME 29
#define DCERPC_WKS_NETRENUMERATECOMPUTERNAMES 30
#define DCERPC_WKSSVC_QUERYINFO 0
#define DCERPC_WKSSVC_SETINFO 1
#define DCERPC_WKSSVC_NETRWKSTAUSERENUM 2
#define DCERPC_WKSSVC_NETRWKSTAUSERGETINFO 3
#define DCERPC_WKSSVC_NETRWKSTAUSERSETINFO 4
#define DCERPC_WKSSVC_TRANSPORTENUM 5
#define DCERPC_WKSSVC_NETRWKSTATRANSPORTADD 6
#define DCERPC_WKSSVC_NETRWKSTATRANSPORTDEL 7
#define DCERPC_WKSSVC_NETRUSEADD 8
#define DCERPC_WKSSVC_NETRUSEGETINFO 9
#define DCERPC_WKSSVC_NETRUSEDEL 10
#define DCERPC_WKSSVC_NETRUSEENUM 11
#define DCERPC_WKSSVC_NETRMESSAGEBUFFERSEND 12
#define DCERPC_WKSSVC_NETRWORKSTATIONSTATISTICSGET 13
#define DCERPC_WKSSVC_NETRLOGONDOMAINNAMEADD 14
#define DCERPC_WKSSVC_NETRLOGONDOMAINNAMEDEL 15
#define DCERPC_WKSSVC_NETRJOINDOMAIN 16
#define DCERPC_WKSSVC_NETRUNJOINDOMAIN 17
#define DCERPC_WKSSVC_NETRRENAMEMACHINEINDOMAIN 18
#define DCERPC_WKSSVC_NETRVALIDATENAME 19
#define DCERPC_WKSSVC_NETRGETJOININFORMATION 20
#define DCERPC_WKSSVC_NETRGETJOINABLEOUS 21
#define DCERPC_WKSSVC_NETRJOINDOMAIN2 22
#define DCERPC_WKSSVC_NETRUNJOINDOMAIN2 23
#define DCERPC_WKSSVC_NETRRENAMEMACHINEINDOMAIN2 24
#define DCERPC_WKSSVC_NETRVALIDATENAME2 25
#define DCERPC_WKSSVC_NETRGETJOINABLEOUS2 26
#define DCERPC_WKSSVC_NETRADDALTERNATECOMPUTERNAME 27
#define DCERPC_WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME 28
#define DCERPC_WKSSVC_NETRSETPRIMARYCOMPUTERNAME 29
#define DCERPC_WKSSVC_NETRENUMERATECOMPUTERNAMES 30
struct wks_Info100 {
struct wkssvc_Info100 {
uint32 platform_id;
const char *server;
const char *domain;
@ -45,7 +45,7 @@ struct wks_Info100 {
uint32 ver_minor;
};
struct wks_Info101 {
struct wkssvc_Info101 {
uint32 platform_id;
const char *server;
const char *domain;
@ -54,7 +54,7 @@ struct wks_Info101 {
const char *lan_root;
};
struct wks_Info102 {
struct wkssvc_Info102 {
uint32 platform_id;
const char *server;
const char *domain;
@ -64,26 +64,26 @@ struct wks_Info102 {
uint32 logged_on_users;
};
union wks_Info {
/* [case(100)] */ struct wks_Info100 *info100;
/* [case(101)] */ struct wks_Info101 *info101;
/* [case(102)] */ struct wks_Info102 *info102;
union wkssvc_Info {
/* [case(100)] */ struct wkssvc_Info100 *info100;
/* [case(101)] */ struct wkssvc_Info101 *info101;
/* [case(102)] */ struct wkssvc_Info102 *info102;
};
struct wks_QueryInfo {
struct wkssvc_QueryInfo {
struct {
const char *server_name;
uint32 level;
} in;
struct {
union wks_Info info;
union wkssvc_Info info;
WERROR result;
} out;
};
struct wks_SetInfo {
struct wkssvc_SetInfo {
struct {
} in;
@ -93,7 +93,7 @@ struct wks_SetInfo {
};
struct WKS_NETRWKSTAUSERENUM {
struct WKSSVC_NETRWKSTAUSERENUM {
struct {
} in;
@ -103,7 +103,7 @@ struct WKS_NETRWKSTAUSERENUM {
};
struct WKS_NETRWKSTAUSERGETINFO {
struct WKSSVC_NETRWKSTAUSERGETINFO {
struct {
} in;
@ -113,7 +113,7 @@ struct WKS_NETRWKSTAUSERGETINFO {
};
struct WKS_NETRWKSTAUSERSETINFO {
struct WKSSVC_NETRWKSTAUSERSETINFO {
struct {
} in;
@ -123,7 +123,7 @@ struct WKS_NETRWKSTAUSERSETINFO {
};
struct wks_TransportInfo0 {
struct wkssvc_TransportInfo0 {
uint32 quality_of_service;
uint32 vc_count;
const char *name;
@ -131,30 +131,30 @@ struct wks_TransportInfo0 {
uint32 wan_link;
};
struct wks_TransportInfoArray {
struct wkssvc_TransportInfoArray {
uint32 count;
struct wks_TransportInfo0 *transports;
struct wkssvc_TransportInfo0 *transports;
};
union wks_TransportUnion {
/* [case(0)] */ struct wks_TransportInfoArray *array;
union wkssvc_TransportUnion {
/* [case(0)] */ struct wkssvc_TransportInfoArray *array;
};
struct wks_TransportInfo {
struct wkssvc_TransportInfo {
uint32 level;
union wks_TransportUnion u;
union wkssvc_TransportUnion u;
};
struct wks_TransportEnum {
struct wkssvc_TransportEnum {
struct {
const char *server_name;
struct wks_TransportInfo *info;
struct wkssvc_TransportInfo *info;
uint32 max_buffer;
uint32 *resume_handle;
} in;
struct {
struct wks_TransportInfo *info;
struct wkssvc_TransportInfo *info;
uint32 unknown;
uint32 *resume_handle;
WERROR result;
@ -162,7 +162,7 @@ struct wks_TransportEnum {
};
struct WKS_NETRWKSTATRANSPORTADD {
struct WKSSVC_NETRWKSTATRANSPORTADD {
struct {
} in;
@ -172,7 +172,7 @@ struct WKS_NETRWKSTATRANSPORTADD {
};
struct WKS_NETRWKSTATRANSPORTDEL {
struct WKSSVC_NETRWKSTATRANSPORTDEL {
struct {
} in;
@ -182,7 +182,7 @@ struct WKS_NETRWKSTATRANSPORTDEL {
};
struct WKS_NETRUSEADD {
struct WKSSVC_NETRUSEADD {
struct {
} in;
@ -192,7 +192,7 @@ struct WKS_NETRUSEADD {
};
struct WKS_NETRUSEGETINFO {
struct WKSSVC_NETRUSEGETINFO {
struct {
} in;
@ -202,7 +202,7 @@ struct WKS_NETRUSEGETINFO {
};
struct WKS_NETRUSEDEL {
struct WKSSVC_NETRUSEDEL {
struct {
} in;
@ -212,7 +212,7 @@ struct WKS_NETRUSEDEL {
};
struct WKS_NETRUSEENUM {
struct WKSSVC_NETRUSEENUM {
struct {
} in;
@ -222,7 +222,7 @@ struct WKS_NETRUSEENUM {
};
struct WKS_NETRMESSAGEBUFFERSEND {
struct WKSSVC_NETRMESSAGEBUFFERSEND {
struct {
} in;
@ -232,7 +232,7 @@ struct WKS_NETRMESSAGEBUFFERSEND {
};
struct WKS_NETRWORKSTATIONSTATISTICSGET {
struct WKSSVC_NETRWORKSTATIONSTATISTICSGET {
struct {
} in;
@ -242,7 +242,7 @@ struct WKS_NETRWORKSTATIONSTATISTICSGET {
};
struct WKS_NETRLOGONDOMAINNAMEADD {
struct WKSSVC_NETRLOGONDOMAINNAMEADD {
struct {
} in;
@ -252,7 +252,7 @@ struct WKS_NETRLOGONDOMAINNAMEADD {
};
struct WKS_NETRLOGONDOMAINNAMEDEL {
struct WKSSVC_NETRLOGONDOMAINNAMEDEL {
struct {
} in;
@ -262,7 +262,7 @@ struct WKS_NETRLOGONDOMAINNAMEDEL {
};
struct WKS_NETRJOINDOMAIN {
struct WKSSVC_NETRJOINDOMAIN {
struct {
} in;
@ -272,7 +272,7 @@ struct WKS_NETRJOINDOMAIN {
};
struct WKS_NETRUNJOINDOMAIN {
struct WKSSVC_NETRUNJOINDOMAIN {
struct {
} in;
@ -282,7 +282,7 @@ struct WKS_NETRUNJOINDOMAIN {
};
struct WKS_NETRRENAMEMACHINEINDOMAIN {
struct WKSSVC_NETRRENAMEMACHINEINDOMAIN {
struct {
} in;
@ -292,7 +292,7 @@ struct WKS_NETRRENAMEMACHINEINDOMAIN {
};
struct WKS_NETRVALIDATENAME {
struct WKSSVC_NETRVALIDATENAME {
struct {
} in;
@ -302,7 +302,7 @@ struct WKS_NETRVALIDATENAME {
};
struct WKS_NETRGETJOININFORMATION {
struct WKSSVC_NETRGETJOININFORMATION {
struct {
} in;
@ -312,7 +312,7 @@ struct WKS_NETRGETJOININFORMATION {
};
struct WKS_NETRGETJOINABLEOUS {
struct WKSSVC_NETRGETJOINABLEOUS {
struct {
} in;
@ -322,7 +322,7 @@ struct WKS_NETRGETJOINABLEOUS {
};
struct WKS_NETRJOINDOMAIN2 {
struct WKSSVC_NETRJOINDOMAIN2 {
struct {
} in;
@ -332,7 +332,7 @@ struct WKS_NETRJOINDOMAIN2 {
};
struct WKS_NETRUNJOINDOMAIN2 {
struct WKSSVC_NETRUNJOINDOMAIN2 {
struct {
} in;
@ -342,7 +342,7 @@ struct WKS_NETRUNJOINDOMAIN2 {
};
struct WKS_NETRRENAMEMACHINEINDOMAIN2 {
struct WKSSVC_NETRRENAMEMACHINEINDOMAIN2 {
struct {
} in;
@ -352,7 +352,7 @@ struct WKS_NETRRENAMEMACHINEINDOMAIN2 {
};
struct WKS_NETRVALIDATENAME2 {
struct WKSSVC_NETRVALIDATENAME2 {
struct {
} in;
@ -362,7 +362,7 @@ struct WKS_NETRVALIDATENAME2 {
};
struct WKS_NETRGETJOINABLEOUS2 {
struct WKSSVC_NETRGETJOINABLEOUS2 {
struct {
} in;
@ -372,7 +372,7 @@ struct WKS_NETRGETJOINABLEOUS2 {
};
struct WKS_NETRADDALTERNATECOMPUTERNAME {
struct WKSSVC_NETRADDALTERNATECOMPUTERNAME {
struct {
} in;
@ -382,7 +382,7 @@ struct WKS_NETRADDALTERNATECOMPUTERNAME {
};
struct WKS_NETRREMOVEALTERNATECOMPUTERNAME {
struct WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME {
struct {
} in;
@ -392,7 +392,7 @@ struct WKS_NETRREMOVEALTERNATECOMPUTERNAME {
};
struct WKS_NETRSETPRIMARYCOMPUTERNAME {
struct WKSSVC_NETRSETPRIMARYCOMPUTERNAME {
struct {
} in;
@ -402,7 +402,7 @@ struct WKS_NETRSETPRIMARYCOMPUTERNAME {
};
struct WKS_NETRENUMERATECOMPUTERNAMES {
struct WKSSVC_NETRENUMERATECOMPUTERNAMES {
struct {
} in;

36
source4/librpc/rpc/rpc_samr.c
View File

@ -255,21 +255,21 @@ NTSTATUS dcerpc_samr_EnumDomainGroups(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx
return status;
}
NTSTATUS dcerpc_samr_CREATE_USER_IN_DOMAIN(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_CREATE_USER_IN_DOMAIN *r)
NTSTATUS dcerpc_samr_CreateUser(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_CreateUser *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(samr_CREATE_USER_IN_DOMAIN, r);
NDR_PRINT_IN_DEBUG(samr_CreateUser, r);
}
status = dcerpc_ndr_request(p, DCERPC_SAMR_CREATE_USER_IN_DOMAIN, mem_ctx,
(ndr_push_fn_t) ndr_push_samr_CREATE_USER_IN_DOMAIN,
(ndr_pull_fn_t) ndr_pull_samr_CREATE_USER_IN_DOMAIN,
status = dcerpc_ndr_request(p, DCERPC_SAMR_CREATEUSER, mem_ctx,
(ndr_push_fn_t) ndr_push_samr_CreateUser,
(ndr_pull_fn_t) ndr_pull_samr_CreateUser,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(samr_CREATE_USER_IN_DOMAIN, r);
NDR_PRINT_OUT_DEBUG(samr_CreateUser, r);
}
if (NT_STATUS_IS_OK(status)) status = r->out.result;
@ -339,21 +339,21 @@ NTSTATUS dcerpc_samr_EnumDomainAliases(struct dcerpc_pipe *p, TALLOC_CTX *mem_ct
return status;
}
NTSTATUS dcerpc_samr_GET_ALIAS_MEMBERSHIP(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_GET_ALIAS_MEMBERSHIP *r)
NTSTATUS dcerpc_samr_GetAliasMembership(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_GetAliasMembership *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(samr_GET_ALIAS_MEMBERSHIP, r);
NDR_PRINT_IN_DEBUG(samr_GetAliasMembership, r);
}
status = dcerpc_ndr_request(p, DCERPC_SAMR_GET_ALIAS_MEMBERSHIP, mem_ctx,
(ndr_push_fn_t) ndr_push_samr_GET_ALIAS_MEMBERSHIP,
(ndr_pull_fn_t) ndr_pull_samr_GET_ALIAS_MEMBERSHIP,
status = dcerpc_ndr_request(p, DCERPC_SAMR_GETALIASMEMBERSHIP, mem_ctx,
(ndr_push_fn_t) ndr_push_samr_GetAliasMembership,
(ndr_pull_fn_t) ndr_pull_samr_GetAliasMembership,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(samr_GET_ALIAS_MEMBERSHIP, r);
NDR_PRINT_OUT_DEBUG(samr_GetAliasMembership, r);
}
if (NT_STATUS_IS_OK(status)) status = r->out.result;
@ -738,21 +738,21 @@ NTSTATUS dcerpc_samr_OpenUser(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct
return status;
}
NTSTATUS dcerpc_samr_DELETE_DOM_USER(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_DELETE_DOM_USER *r)
NTSTATUS dcerpc_samr_DeleteUser(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct samr_DeleteUser *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(samr_DELETE_DOM_USER, r);
NDR_PRINT_IN_DEBUG(samr_DeleteUser, r);
}
status = dcerpc_ndr_request(p, DCERPC_SAMR_DELETE_DOM_USER, mem_ctx,
(ndr_push_fn_t) ndr_push_samr_DELETE_DOM_USER,
(ndr_pull_fn_t) ndr_pull_samr_DELETE_DOM_USER,
status = dcerpc_ndr_request(p, DCERPC_SAMR_DELETEUSER, mem_ctx,
(ndr_push_fn_t) ndr_push_samr_DeleteUser,
(ndr_pull_fn_t) ndr_pull_samr_DeleteUser,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(samr_DELETE_DOM_USER, r);
NDR_PRINT_OUT_DEBUG(samr_DeleteUser, r);
}
if (NT_STATUS_IS_OK(status)) status = r->out.result;

372
source4/librpc/rpc/rpc_wkssvc.c
View File

@ -3,621 +3,621 @@
#include "includes.h"
NTSTATUS dcerpc_wks_QueryInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct wks_QueryInfo *r)
NTSTATUS dcerpc_wkssvc_QueryInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct wkssvc_QueryInfo *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(wks_QueryInfo, r);
NDR_PRINT_IN_DEBUG(wkssvc_QueryInfo, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_QUERYINFO, mem_ctx,
(ndr_push_fn_t) ndr_push_wks_QueryInfo,
(ndr_pull_fn_t) ndr_pull_wks_QueryInfo,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_QUERYINFO, mem_ctx,
(ndr_push_fn_t) ndr_push_wkssvc_QueryInfo,
(ndr_pull_fn_t) ndr_pull_wkssvc_QueryInfo,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(wks_QueryInfo, r);
NDR_PRINT_OUT_DEBUG(wkssvc_QueryInfo, r);
}
return status;
}
NTSTATUS dcerpc_wks_SetInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct wks_SetInfo *r)
NTSTATUS dcerpc_wkssvc_SetInfo(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct wkssvc_SetInfo *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(wks_SetInfo, r);
NDR_PRINT_IN_DEBUG(wkssvc_SetInfo, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_SETINFO, mem_ctx,
(ndr_push_fn_t) ndr_push_wks_SetInfo,
(ndr_pull_fn_t) ndr_pull_wks_SetInfo,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_SETINFO, mem_ctx,
(ndr_push_fn_t) ndr_push_wkssvc_SetInfo,
(ndr_pull_fn_t) ndr_pull_wkssvc_SetInfo,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(wks_SetInfo, r);
NDR_PRINT_OUT_DEBUG(wkssvc_SetInfo, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRWKSTAUSERENUM(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRWKSTAUSERENUM *r)
NTSTATUS dcerpc_WKSSVC_NETRWKSTAUSERENUM(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRWKSTAUSERENUM *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRWKSTAUSERENUM, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRWKSTAUSERENUM, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRWKSTAUSERENUM, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRWKSTAUSERENUM,
(ndr_pull_fn_t) ndr_pull_WKS_NETRWKSTAUSERENUM,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRWKSTAUSERENUM, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRWKSTAUSERENUM,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRWKSTAUSERENUM,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRWKSTAUSERENUM, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWKSTAUSERENUM, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRWKSTAUSERGETINFO(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRWKSTAUSERGETINFO *r)
NTSTATUS dcerpc_WKSSVC_NETRWKSTAUSERGETINFO(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRWKSTAUSERGETINFO *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRWKSTAUSERGETINFO, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRWKSTAUSERGETINFO, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRWKSTAUSERGETINFO, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRWKSTAUSERGETINFO,
(ndr_pull_fn_t) ndr_pull_WKS_NETRWKSTAUSERGETINFO,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRWKSTAUSERGETINFO, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRWKSTAUSERGETINFO,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRWKSTAUSERGETINFO,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRWKSTAUSERGETINFO, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWKSTAUSERGETINFO, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRWKSTAUSERSETINFO(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRWKSTAUSERSETINFO *r)
NTSTATUS dcerpc_WKSSVC_NETRWKSTAUSERSETINFO(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRWKSTAUSERSETINFO *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRWKSTAUSERSETINFO, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRWKSTAUSERSETINFO, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRWKSTAUSERSETINFO, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRWKSTAUSERSETINFO,
(ndr_pull_fn_t) ndr_pull_WKS_NETRWKSTAUSERSETINFO,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRWKSTAUSERSETINFO, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRWKSTAUSERSETINFO,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRWKSTAUSERSETINFO,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRWKSTAUSERSETINFO, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWKSTAUSERSETINFO, r);
}
return status;
}
NTSTATUS dcerpc_wks_TransportEnum(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct wks_TransportEnum *r)
NTSTATUS dcerpc_wkssvc_TransportEnum(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct wkssvc_TransportEnum *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(wks_TransportEnum, r);
NDR_PRINT_IN_DEBUG(wkssvc_TransportEnum, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_TRANSPORTENUM, mem_ctx,
(ndr_push_fn_t) ndr_push_wks_TransportEnum,
(ndr_pull_fn_t) ndr_pull_wks_TransportEnum,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_TRANSPORTENUM, mem_ctx,
(ndr_push_fn_t) ndr_push_wkssvc_TransportEnum,
(ndr_pull_fn_t) ndr_pull_wkssvc_TransportEnum,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(wks_TransportEnum, r);
NDR_PRINT_OUT_DEBUG(wkssvc_TransportEnum, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRWKSTATRANSPORTADD(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRWKSTATRANSPORTADD *r)
NTSTATUS dcerpc_WKSSVC_NETRWKSTATRANSPORTADD(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRWKSTATRANSPORTADD *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRWKSTATRANSPORTADD, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRWKSTATRANSPORTADD, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRWKSTATRANSPORTADD, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRWKSTATRANSPORTADD,
(ndr_pull_fn_t) ndr_pull_WKS_NETRWKSTATRANSPORTADD,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRWKSTATRANSPORTADD, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRWKSTATRANSPORTADD,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRWKSTATRANSPORTADD,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRWKSTATRANSPORTADD, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWKSTATRANSPORTADD, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRWKSTATRANSPORTDEL(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRWKSTATRANSPORTDEL *r)
NTSTATUS dcerpc_WKSSVC_NETRWKSTATRANSPORTDEL(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRWKSTATRANSPORTDEL *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRWKSTATRANSPORTDEL, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRWKSTATRANSPORTDEL, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRWKSTATRANSPORTDEL, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRWKSTATRANSPORTDEL,
(ndr_pull_fn_t) ndr_pull_WKS_NETRWKSTATRANSPORTDEL,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRWKSTATRANSPORTDEL, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRWKSTATRANSPORTDEL,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRWKSTATRANSPORTDEL,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRWKSTATRANSPORTDEL, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWKSTATRANSPORTDEL, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRUSEADD(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRUSEADD *r)
NTSTATUS dcerpc_WKSSVC_NETRUSEADD(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRUSEADD *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRUSEADD, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRUSEADD, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRUSEADD, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRUSEADD,
(ndr_pull_fn_t) ndr_pull_WKS_NETRUSEADD,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRUSEADD, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRUSEADD,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRUSEADD,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRUSEADD, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUSEADD, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRUSEGETINFO(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRUSEGETINFO *r)
NTSTATUS dcerpc_WKSSVC_NETRUSEGETINFO(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRUSEGETINFO *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRUSEGETINFO, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRUSEGETINFO, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRUSEGETINFO, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRUSEGETINFO,
(ndr_pull_fn_t) ndr_pull_WKS_NETRUSEGETINFO,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRUSEGETINFO, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRUSEGETINFO,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRUSEGETINFO,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRUSEGETINFO, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUSEGETINFO, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRUSEDEL(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRUSEDEL *r)
NTSTATUS dcerpc_WKSSVC_NETRUSEDEL(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRUSEDEL *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRUSEDEL, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRUSEDEL, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRUSEDEL, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRUSEDEL,
(ndr_pull_fn_t) ndr_pull_WKS_NETRUSEDEL,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRUSEDEL, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRUSEDEL,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRUSEDEL,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRUSEDEL, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUSEDEL, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRUSEENUM(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRUSEENUM *r)
NTSTATUS dcerpc_WKSSVC_NETRUSEENUM(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRUSEENUM *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRUSEENUM, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRUSEENUM, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRUSEENUM, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRUSEENUM,
(ndr_pull_fn_t) ndr_pull_WKS_NETRUSEENUM,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRUSEENUM, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRUSEENUM,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRUSEENUM,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRUSEENUM, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUSEENUM, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRMESSAGEBUFFERSEND(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRMESSAGEBUFFERSEND *r)
NTSTATUS dcerpc_WKSSVC_NETRMESSAGEBUFFERSEND(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRMESSAGEBUFFERSEND *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRMESSAGEBUFFERSEND, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRMESSAGEBUFFERSEND, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRMESSAGEBUFFERSEND, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRMESSAGEBUFFERSEND,
(ndr_pull_fn_t) ndr_pull_WKS_NETRMESSAGEBUFFERSEND,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRMESSAGEBUFFERSEND, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRMESSAGEBUFFERSEND,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRMESSAGEBUFFERSEND,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRMESSAGEBUFFERSEND, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRMESSAGEBUFFERSEND, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRWORKSTATIONSTATISTICSGET(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRWORKSTATIONSTATISTICSGET *r)
NTSTATUS dcerpc_WKSSVC_NETRWORKSTATIONSTATISTICSGET(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRWORKSTATIONSTATISTICSGET *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRWORKSTATIONSTATISTICSGET, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRWORKSTATIONSTATISTICSGET, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRWORKSTATIONSTATISTICSGET, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRWORKSTATIONSTATISTICSGET,
(ndr_pull_fn_t) ndr_pull_WKS_NETRWORKSTATIONSTATISTICSGET,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRWORKSTATIONSTATISTICSGET, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRWORKSTATIONSTATISTICSGET,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRWORKSTATIONSTATISTICSGET,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRWORKSTATIONSTATISTICSGET, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRWORKSTATIONSTATISTICSGET, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRLOGONDOMAINNAMEADD(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRLOGONDOMAINNAMEADD *r)
NTSTATUS dcerpc_WKSSVC_NETRLOGONDOMAINNAMEADD(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRLOGONDOMAINNAMEADD *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRLOGONDOMAINNAMEADD, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRLOGONDOMAINNAMEADD, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRLOGONDOMAINNAMEADD, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRLOGONDOMAINNAMEADD,
(ndr_pull_fn_t) ndr_pull_WKS_NETRLOGONDOMAINNAMEADD,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRLOGONDOMAINNAMEADD, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRLOGONDOMAINNAMEADD,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRLOGONDOMAINNAMEADD,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRLOGONDOMAINNAMEADD, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRLOGONDOMAINNAMEADD, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRLOGONDOMAINNAMEDEL(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRLOGONDOMAINNAMEDEL *r)
NTSTATUS dcerpc_WKSSVC_NETRLOGONDOMAINNAMEDEL(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRLOGONDOMAINNAMEDEL *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRLOGONDOMAINNAMEDEL, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRLOGONDOMAINNAMEDEL, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRLOGONDOMAINNAMEDEL, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRLOGONDOMAINNAMEDEL,
(ndr_pull_fn_t) ndr_pull_WKS_NETRLOGONDOMAINNAMEDEL,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRLOGONDOMAINNAMEDEL, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRLOGONDOMAINNAMEDEL,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRLOGONDOMAINNAMEDEL,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRLOGONDOMAINNAMEDEL, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRLOGONDOMAINNAMEDEL, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRJOINDOMAIN(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRJOINDOMAIN *r)
NTSTATUS dcerpc_WKSSVC_NETRJOINDOMAIN(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRJOINDOMAIN *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRJOINDOMAIN, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRJOINDOMAIN, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRJOINDOMAIN, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRJOINDOMAIN,
(ndr_pull_fn_t) ndr_pull_WKS_NETRJOINDOMAIN,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRJOINDOMAIN, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRJOINDOMAIN,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRJOINDOMAIN,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRJOINDOMAIN, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRJOINDOMAIN, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRUNJOINDOMAIN(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRUNJOINDOMAIN *r)
NTSTATUS dcerpc_WKSSVC_NETRUNJOINDOMAIN(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRUNJOINDOMAIN *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRUNJOINDOMAIN, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRUNJOINDOMAIN, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRUNJOINDOMAIN, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRUNJOINDOMAIN,
(ndr_pull_fn_t) ndr_pull_WKS_NETRUNJOINDOMAIN,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRUNJOINDOMAIN, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRUNJOINDOMAIN,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRUNJOINDOMAIN,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRUNJOINDOMAIN, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUNJOINDOMAIN, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRRENAMEMACHINEINDOMAIN(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRRENAMEMACHINEINDOMAIN *r)
NTSTATUS dcerpc_WKSSVC_NETRRENAMEMACHINEINDOMAIN(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRRENAMEMACHINEINDOMAIN *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRRENAMEMACHINEINDOMAIN, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRRENAMEMACHINEINDOMAIN, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRRENAMEMACHINEINDOMAIN, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRRENAMEMACHINEINDOMAIN,
(ndr_pull_fn_t) ndr_pull_WKS_NETRRENAMEMACHINEINDOMAIN,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRRENAMEMACHINEINDOMAIN, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRRENAMEMACHINEINDOMAIN,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRRENAMEMACHINEINDOMAIN,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRRENAMEMACHINEINDOMAIN, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRRENAMEMACHINEINDOMAIN, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRVALIDATENAME(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRVALIDATENAME *r)
NTSTATUS dcerpc_WKSSVC_NETRVALIDATENAME(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRVALIDATENAME *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRVALIDATENAME, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRVALIDATENAME, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRVALIDATENAME, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRVALIDATENAME,
(ndr_pull_fn_t) ndr_pull_WKS_NETRVALIDATENAME,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRVALIDATENAME, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRVALIDATENAME,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRVALIDATENAME,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRVALIDATENAME, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRVALIDATENAME, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRGETJOININFORMATION(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRGETJOININFORMATION *r)
NTSTATUS dcerpc_WKSSVC_NETRGETJOININFORMATION(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRGETJOININFORMATION *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRGETJOININFORMATION, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRGETJOININFORMATION, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRGETJOININFORMATION, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRGETJOININFORMATION,
(ndr_pull_fn_t) ndr_pull_WKS_NETRGETJOININFORMATION,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRGETJOININFORMATION, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRGETJOININFORMATION,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRGETJOININFORMATION,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRGETJOININFORMATION, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRGETJOININFORMATION, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRGETJOINABLEOUS(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRGETJOINABLEOUS *r)
NTSTATUS dcerpc_WKSSVC_NETRGETJOINABLEOUS(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRGETJOINABLEOUS *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRGETJOINABLEOUS, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRGETJOINABLEOUS, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRGETJOINABLEOUS, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRGETJOINABLEOUS,
(ndr_pull_fn_t) ndr_pull_WKS_NETRGETJOINABLEOUS,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRGETJOINABLEOUS, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRGETJOINABLEOUS,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRGETJOINABLEOUS,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRGETJOINABLEOUS, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRGETJOINABLEOUS, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRJOINDOMAIN2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRJOINDOMAIN2 *r)
NTSTATUS dcerpc_WKSSVC_NETRJOINDOMAIN2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRJOINDOMAIN2 *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRJOINDOMAIN2, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRJOINDOMAIN2, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRJOINDOMAIN2, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRJOINDOMAIN2,
(ndr_pull_fn_t) ndr_pull_WKS_NETRJOINDOMAIN2,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRJOINDOMAIN2, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRJOINDOMAIN2,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRJOINDOMAIN2,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRJOINDOMAIN2, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRJOINDOMAIN2, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRUNJOINDOMAIN2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRUNJOINDOMAIN2 *r)
NTSTATUS dcerpc_WKSSVC_NETRUNJOINDOMAIN2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRUNJOINDOMAIN2 *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRUNJOINDOMAIN2, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRUNJOINDOMAIN2, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRUNJOINDOMAIN2, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRUNJOINDOMAIN2,
(ndr_pull_fn_t) ndr_pull_WKS_NETRUNJOINDOMAIN2,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRUNJOINDOMAIN2, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRUNJOINDOMAIN2,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRUNJOINDOMAIN2,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRUNJOINDOMAIN2, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRUNJOINDOMAIN2, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRRENAMEMACHINEINDOMAIN2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRRENAMEMACHINEINDOMAIN2 *r)
NTSTATUS dcerpc_WKSSVC_NETRRENAMEMACHINEINDOMAIN2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRRENAMEMACHINEINDOMAIN2 *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRRENAMEMACHINEINDOMAIN2, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRRENAMEMACHINEINDOMAIN2, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRRENAMEMACHINEINDOMAIN2, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRRENAMEMACHINEINDOMAIN2,
(ndr_pull_fn_t) ndr_pull_WKS_NETRRENAMEMACHINEINDOMAIN2,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRRENAMEMACHINEINDOMAIN2, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRRENAMEMACHINEINDOMAIN2,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRRENAMEMACHINEINDOMAIN2,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRRENAMEMACHINEINDOMAIN2, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRRENAMEMACHINEINDOMAIN2, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRVALIDATENAME2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRVALIDATENAME2 *r)
NTSTATUS dcerpc_WKSSVC_NETRVALIDATENAME2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRVALIDATENAME2 *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRVALIDATENAME2, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRVALIDATENAME2, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRVALIDATENAME2, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRVALIDATENAME2,
(ndr_pull_fn_t) ndr_pull_WKS_NETRVALIDATENAME2,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRVALIDATENAME2, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRVALIDATENAME2,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRVALIDATENAME2,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRVALIDATENAME2, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRVALIDATENAME2, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRGETJOINABLEOUS2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRGETJOINABLEOUS2 *r)
NTSTATUS dcerpc_WKSSVC_NETRGETJOINABLEOUS2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRGETJOINABLEOUS2 *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRGETJOINABLEOUS2, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRGETJOINABLEOUS2, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRGETJOINABLEOUS2, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRGETJOINABLEOUS2,
(ndr_pull_fn_t) ndr_pull_WKS_NETRGETJOINABLEOUS2,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRGETJOINABLEOUS2, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRGETJOINABLEOUS2,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRGETJOINABLEOUS2,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRGETJOINABLEOUS2, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRGETJOINABLEOUS2, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRADDALTERNATECOMPUTERNAME(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRADDALTERNATECOMPUTERNAME *r)
NTSTATUS dcerpc_WKSSVC_NETRADDALTERNATECOMPUTERNAME(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRADDALTERNATECOMPUTERNAME *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRADDALTERNATECOMPUTERNAME, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRADDALTERNATECOMPUTERNAME, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRADDALTERNATECOMPUTERNAME, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRADDALTERNATECOMPUTERNAME,
(ndr_pull_fn_t) ndr_pull_WKS_NETRADDALTERNATECOMPUTERNAME,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRADDALTERNATECOMPUTERNAME, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRADDALTERNATECOMPUTERNAME,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRADDALTERNATECOMPUTERNAME,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRADDALTERNATECOMPUTERNAME, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRADDALTERNATECOMPUTERNAME, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRREMOVEALTERNATECOMPUTERNAME(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRREMOVEALTERNATECOMPUTERNAME *r)
NTSTATUS dcerpc_WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRREMOVEALTERNATECOMPUTERNAME, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRREMOVEALTERNATECOMPUTERNAME, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRREMOVEALTERNATECOMPUTERNAME,
(ndr_pull_fn_t) ndr_pull_WKS_NETRREMOVEALTERNATECOMPUTERNAME,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRREMOVEALTERNATECOMPUTERNAME, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRSETPRIMARYCOMPUTERNAME(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRSETPRIMARYCOMPUTERNAME *r)
NTSTATUS dcerpc_WKSSVC_NETRSETPRIMARYCOMPUTERNAME(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRSETPRIMARYCOMPUTERNAME *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRSETPRIMARYCOMPUTERNAME, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRSETPRIMARYCOMPUTERNAME, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRSETPRIMARYCOMPUTERNAME, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRSETPRIMARYCOMPUTERNAME,
(ndr_pull_fn_t) ndr_pull_WKS_NETRSETPRIMARYCOMPUTERNAME,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRSETPRIMARYCOMPUTERNAME, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRSETPRIMARYCOMPUTERNAME,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRSETPRIMARYCOMPUTERNAME,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRSETPRIMARYCOMPUTERNAME, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRSETPRIMARYCOMPUTERNAME, r);
}
return status;
}
NTSTATUS dcerpc_WKS_NETRENUMERATECOMPUTERNAMES(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKS_NETRENUMERATECOMPUTERNAMES *r)
NTSTATUS dcerpc_WKSSVC_NETRENUMERATECOMPUTERNAMES(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct WKSSVC_NETRENUMERATECOMPUTERNAMES *r)
{
NTSTATUS status;
if (p->flags & DCERPC_DEBUG_PRINT_IN) {
NDR_PRINT_IN_DEBUG(WKS_NETRENUMERATECOMPUTERNAMES, r);
NDR_PRINT_IN_DEBUG(WKSSVC_NETRENUMERATECOMPUTERNAMES, r);
}
status = dcerpc_ndr_request(p, DCERPC_WKS_NETRENUMERATECOMPUTERNAMES, mem_ctx,
(ndr_push_fn_t) ndr_push_WKS_NETRENUMERATECOMPUTERNAMES,
(ndr_pull_fn_t) ndr_pull_WKS_NETRENUMERATECOMPUTERNAMES,
status = dcerpc_ndr_request(p, DCERPC_WKSSVC_NETRENUMERATECOMPUTERNAMES, mem_ctx,
(ndr_push_fn_t) ndr_push_WKSSVC_NETRENUMERATECOMPUTERNAMES,
(ndr_pull_fn_t) ndr_pull_WKSSVC_NETRENUMERATECOMPUTERNAMES,
r);
if (NT_STATUS_IS_OK(status) && (p->flags & DCERPC_DEBUG_PRINT_OUT)) {
NDR_PRINT_OUT_DEBUG(WKS_NETRENUMERATECOMPUTERNAMES, r);
NDR_PRINT_OUT_DEBUG(WKSSVC_NETRENUMERATECOMPUTERNAMES, r);
}
return status;

6
source4/torture/rpc/samr.c
View File

@ -400,6 +400,12 @@ static BOOL test_OpenDomain(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
return False;
}
#if 0
if (!test_CreateUser(p, mem_ctx, &domain_handle)) {
ret = False;
}
#endif
if (!test_QuerySecurity(p, mem_ctx, &domain_handle)) {
ret = False;
}

12
source4/torture/rpc/wkssvc.c
View File

@ -26,7 +26,7 @@ static BOOL test_QueryInfo(struct dcerpc_pipe *p,
TALLOC_CTX *mem_ctx)
{
NTSTATUS status;
struct wks_QueryInfo r;
struct wkssvc_QueryInfo r;
uint16 levels[] = {100, 101, 102};
int i;
BOOL ret = True;
@ -36,7 +36,7 @@ static BOOL test_QueryInfo(struct dcerpc_pipe *p,
for (i=0;i<ARRAY_SIZE(levels);i++) {
r.in.level = levels[i];
printf("testing QueryInfo level %u\n", r.in.level);
status = dcerpc_wks_QueryInfo(p, mem_ctx, &r);
status = dcerpc_wkssvc_QueryInfo(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
printf("QueryInfo level %u failed - %s\n", r.in.level, nt_errstr(status));
ret = False;
@ -51,11 +51,11 @@ static BOOL test_TransportEnum(struct dcerpc_pipe *p,
TALLOC_CTX *mem_ctx)
{
NTSTATUS status;
struct wks_TransportEnum r;
struct wkssvc_TransportEnum r;
BOOL ret = True;
struct wks_TransportInfo info;
struct wkssvc_TransportInfo info;
uint32 resume_handle = 0;
struct wks_TransportInfoArray info_array;
struct wkssvc_TransportInfoArray info_array;
ZERO_STRUCT(info);
ZERO_STRUCT(info_array);
@ -70,7 +70,7 @@ static BOOL test_TransportEnum(struct dcerpc_pipe *p,
r.out.resume_handle = &resume_handle;
printf("testing TransportEnum\n");
status = dcerpc_wks_TransportEnum(p, mem_ctx, &r);
status = dcerpc_wkssvc_TransportEnum(p, mem_ctx, &r);
if (!NT_STATUS_IS_OK(status)) {
printf("TransportEnum failed - %s\n", nt_errstr(status));
ret = False;