diff options
Diffstat (limited to 'source3/autoconf/librpc/gen_ndr/srv_libnetapi.c')
| -rw-r--r-- | source3/autoconf/librpc/gen_ndr/srv_libnetapi.c | 4330 |
1 files changed, 4330 insertions, 0 deletions
diff --git a/source3/autoconf/librpc/gen_ndr/srv_libnetapi.c b/source3/autoconf/librpc/gen_ndr/srv_libnetapi.c new file mode 100644 index 0000000000..92ef93612d --- /dev/null +++ b/source3/autoconf/librpc/gen_ndr/srv_libnetapi.c @@ -0,0 +1,4330 @@ +/* + * Unix SMB/CIFS implementation. + * server auto-generated by pidl. DO NOT MODIFY! + */ + +#include "includes.h" +#include "ntdomain.h" +#include "autoconf/librpc/gen_ndr/srv_libnetapi.h" + +static bool api_NetJoinDomain(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetJoinDomain *r; + + call = &ndr_table_libnetapi.calls[NDR_NETJOINDOMAIN]; + + r = talloc(talloc_tos(), struct NetJoinDomain); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetJoinDomain, NDR_IN, r); + } + + r->out.result = _NetJoinDomain(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetJoinDomain, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetUnjoinDomain(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetUnjoinDomain *r; + + call = &ndr_table_libnetapi.calls[NDR_NETUNJOINDOMAIN]; + + r = talloc(talloc_tos(), struct NetUnjoinDomain); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUnjoinDomain, NDR_IN, r); + } + + r->out.result = _NetUnjoinDomain(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUnjoinDomain, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetGetJoinInformation(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetGetJoinInformation *r; + + call = &ndr_table_libnetapi.calls[NDR_NETGETJOININFORMATION]; + + r = talloc(talloc_tos(), struct NetGetJoinInformation); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGetJoinInformation, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.name_buffer = talloc_zero(r, const char *); + if (r->out.name_buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.name_type = talloc_zero(r, uint16_t); + if (r->out.name_type == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetGetJoinInformation(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGetJoinInformation, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetGetJoinableOUs(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetGetJoinableOUs *r; + + call = &ndr_table_libnetapi.calls[NDR_NETGETJOINABLEOUS]; + + r = talloc(talloc_tos(), struct NetGetJoinableOUs); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGetJoinableOUs, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.ou_count = talloc_zero(r, uint32_t); + if (r->out.ou_count == NULL) { + talloc_free(r); + return false; + } + + r->out.ous = talloc_zero(r, const char * *); + if (r->out.ous == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetGetJoinableOUs(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGetJoinableOUs, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetRenameMachineInDomain(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetRenameMachineInDomain *r; + + call = &ndr_table_libnetapi.calls[NDR_NETRENAMEMACHINEINDOMAIN]; + + r = talloc(talloc_tos(), struct NetRenameMachineInDomain); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetRenameMachineInDomain, NDR_IN, r); + } + + r->out.result = _NetRenameMachineInDomain(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetRenameMachineInDomain, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetServerGetInfo(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetServerGetInfo *r; + + call = &ndr_table_libnetapi.calls[NDR_NETSERVERGETINFO]; + + r = talloc(talloc_tos(), struct NetServerGetInfo); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetServerGetInfo, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.buffer = talloc_zero(r, uint8_t *); + if (r->out.buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetServerGetInfo(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetServerGetInfo, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetServerSetInfo(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetServerSetInfo *r; + + call = &ndr_table_libnetapi.calls[NDR_NETSERVERSETINFO]; + + r = talloc(talloc_tos(), struct NetServerSetInfo); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetServerSetInfo, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.parm_error = talloc_zero(r, uint32_t); + if (r->out.parm_error == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetServerSetInfo(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetServerSetInfo, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetGetDCName(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetGetDCName *r; + + call = &ndr_table_libnetapi.calls[NDR_NETGETDCNAME]; + + r = talloc(talloc_tos(), struct NetGetDCName); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGetDCName, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.buffer = talloc_zero(r, uint8_t *); + if (r->out.buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetGetDCName(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGetDCName, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetGetAnyDCName(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetGetAnyDCName *r; + + call = &ndr_table_libnetapi.calls[NDR_NETGETANYDCNAME]; + + r = talloc(talloc_tos(), struct NetGetAnyDCName); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGetAnyDCName, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.buffer = talloc_zero(r, uint8_t *); + if (r->out.buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetGetAnyDCName(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGetAnyDCName, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_DsGetDcName(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct DsGetDcName *r; + + call = &ndr_table_libnetapi.calls[NDR_DSGETDCNAME]; + + r = talloc(talloc_tos(), struct DsGetDcName); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(DsGetDcName, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.dc_info = talloc_zero(r, struct DOMAIN_CONTROLLER_INFO *); + if (r->out.dc_info == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _DsGetDcName(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(DsGetDcName, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetUserAdd(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetUserAdd *r; + + call = &ndr_table_libnetapi.calls[NDR_NETUSERADD]; + + r = talloc(talloc_tos(), struct NetUserAdd); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUserAdd, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.parm_error = talloc_zero(r, uint32_t); + if (r->out.parm_error == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetUserAdd(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUserAdd, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetUserDel(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetUserDel *r; + + call = &ndr_table_libnetapi.calls[NDR_NETUSERDEL]; + + r = talloc(talloc_tos(), struct NetUserDel); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUserDel, NDR_IN, r); + } + + r->out.result = _NetUserDel(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUserDel, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetUserEnum(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetUserEnum *r; + + call = &ndr_table_libnetapi.calls[NDR_NETUSERENUM]; + + r = talloc(talloc_tos(), struct NetUserEnum); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUserEnum, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.resume_handle = r->in.resume_handle; + r->out.buffer = talloc_zero(r, uint8_t *); + if (r->out.buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.entries_read = talloc_zero(r, uint32_t); + if (r->out.entries_read == NULL) { + talloc_free(r); + return false; + } + + r->out.total_entries = talloc_zero(r, uint32_t); + if (r->out.total_entries == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetUserEnum(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUserEnum, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetUserChangePassword(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetUserChangePassword *r; + + call = &ndr_table_libnetapi.calls[NDR_NETUSERCHANGEPASSWORD]; + + r = talloc(talloc_tos(), struct NetUserChangePassword); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUserChangePassword, NDR_IN, r); + } + + r->out.result = _NetUserChangePassword(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUserChangePassword, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetUserGetInfo(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetUserGetInfo *r; + + call = &ndr_table_libnetapi.calls[NDR_NETUSERGETINFO]; + + r = talloc(talloc_tos(), struct NetUserGetInfo); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUserGetInfo, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.buffer = talloc_zero(r, uint8_t *); + if (r->out.buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetUserGetInfo(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUserGetInfo, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetUserSetInfo(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetUserSetInfo *r; + + call = &ndr_table_libnetapi.calls[NDR_NETUSERSETINFO]; + + r = talloc(talloc_tos(), struct NetUserSetInfo); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUserSetInfo, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.parm_err = talloc_zero(r, uint32_t); + if (r->out.parm_err == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetUserSetInfo(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUserSetInfo, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetUserGetGroups(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetUserGetGroups *r; + + call = &ndr_table_libnetapi.calls[NDR_NETUSERGETGROUPS]; + + r = talloc(talloc_tos(), struct NetUserGetGroups); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUserGetGroups, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.buffer = talloc_zero(r, uint8_t *); + if (r->out.buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.entries_read = talloc_zero(r, uint32_t); + if (r->out.entries_read == NULL) { + talloc_free(r); + return false; + } + + r->out.total_entries = talloc_zero(r, uint32_t); + if (r->out.total_entries == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetUserGetGroups(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUserGetGroups, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetUserSetGroups(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetUserSetGroups *r; + + call = &ndr_table_libnetapi.calls[NDR_NETUSERSETGROUPS]; + + r = talloc(talloc_tos(), struct NetUserSetGroups); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUserSetGroups, NDR_IN, r); + } + + r->out.result = _NetUserSetGroups(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUserSetGroups, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetUserGetLocalGroups(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetUserGetLocalGroups *r; + + call = &ndr_table_libnetapi.calls[NDR_NETUSERGETLOCALGROUPS]; + + r = talloc(talloc_tos(), struct NetUserGetLocalGroups); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUserGetLocalGroups, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.buffer = talloc_zero(r, uint8_t *); + if (r->out.buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.entries_read = talloc_zero(r, uint32_t); + if (r->out.entries_read == NULL) { + talloc_free(r); + return false; + } + + r->out.total_entries = talloc_zero(r, uint32_t); + if (r->out.total_entries == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetUserGetLocalGroups(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUserGetLocalGroups, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetUserModalsGet(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetUserModalsGet *r; + + call = &ndr_table_libnetapi.calls[NDR_NETUSERMODALSGET]; + + r = talloc(talloc_tos(), struct NetUserModalsGet); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUserModalsGet, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.buffer = talloc_zero(r, uint8_t *); + if (r->out.buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetUserModalsGet(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUserModalsGet, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetUserModalsSet(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetUserModalsSet *r; + + call = &ndr_table_libnetapi.calls[NDR_NETUSERMODALSSET]; + + r = talloc(talloc_tos(), struct NetUserModalsSet); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUserModalsSet, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.parm_err = talloc_zero(r, uint32_t); + if (r->out.parm_err == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetUserModalsSet(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetUserModalsSet, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetQueryDisplayInformation(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetQueryDisplayInformation *r; + + call = &ndr_table_libnetapi.calls[NDR_NETQUERYDISPLAYINFORMATION]; + + r = talloc(talloc_tos(), struct NetQueryDisplayInformation); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetQueryDisplayInformation, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.entries_read = talloc_zero(r, uint32_t); + if (r->out.entries_read == NULL) { + talloc_free(r); + return false; + } + + r->out.buffer = talloc_zero(r, void *); + if (r->out.buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetQueryDisplayInformation(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetQueryDisplayInformation, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetGroupAdd(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetGroupAdd *r; + + call = &ndr_table_libnetapi.calls[NDR_NETGROUPADD]; + + r = talloc(talloc_tos(), struct NetGroupAdd); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGroupAdd, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.parm_err = talloc_zero(r, uint32_t); + if (r->out.parm_err == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetGroupAdd(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGroupAdd, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetGroupDel(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetGroupDel *r; + + call = &ndr_table_libnetapi.calls[NDR_NETGROUPDEL]; + + r = talloc(talloc_tos(), struct NetGroupDel); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGroupDel, NDR_IN, r); + } + + r->out.result = _NetGroupDel(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGroupDel, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetGroupEnum(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetGroupEnum *r; + + call = &ndr_table_libnetapi.calls[NDR_NETGROUPENUM]; + + r = talloc(talloc_tos(), struct NetGroupEnum); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGroupEnum, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.resume_handle = r->in.resume_handle; + r->out.buffer = talloc_zero(r, uint8_t *); + if (r->out.buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.entries_read = talloc_zero(r, uint32_t); + if (r->out.entries_read == NULL) { + talloc_free(r); + return false; + } + + r->out.total_entries = talloc_zero(r, uint32_t); + if (r->out.total_entries == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetGroupEnum(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGroupEnum, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetGroupSetInfo(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetGroupSetInfo *r; + + call = &ndr_table_libnetapi.calls[NDR_NETGROUPSETINFO]; + + r = talloc(talloc_tos(), struct NetGroupSetInfo); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGroupSetInfo, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.parm_err = talloc_zero(r, uint32_t); + if (r->out.parm_err == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetGroupSetInfo(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGroupSetInfo, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetGroupGetInfo(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetGroupGetInfo *r; + + call = &ndr_table_libnetapi.calls[NDR_NETGROUPGETINFO]; + + r = talloc(talloc_tos(), struct NetGroupGetInfo); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGroupGetInfo, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.buffer = talloc_zero(r, uint8_t *); + if (r->out.buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetGroupGetInfo(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGroupGetInfo, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetGroupAddUser(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetGroupAddUser *r; + + call = &ndr_table_libnetapi.calls[NDR_NETGROUPADDUSER]; + + r = talloc(talloc_tos(), struct NetGroupAddUser); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGroupAddUser, NDR_IN, r); + } + + r->out.result = _NetGroupAddUser(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGroupAddUser, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetGroupDelUser(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetGroupDelUser *r; + + call = &ndr_table_libnetapi.calls[NDR_NETGROUPDELUSER]; + + r = talloc(talloc_tos(), struct NetGroupDelUser); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGroupDelUser, NDR_IN, r); + } + + r->out.result = _NetGroupDelUser(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGroupDelUser, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetGroupGetUsers(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetGroupGetUsers *r; + + call = &ndr_table_libnetapi.calls[NDR_NETGROUPGETUSERS]; + + r = talloc(talloc_tos(), struct NetGroupGetUsers); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGroupGetUsers, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.resume_handle = r->in.resume_handle; + r->out.buffer = talloc_zero(r, uint8_t *); + if (r->out.buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.entries_read = talloc_zero(r, uint32_t); + if (r->out.entries_read == NULL) { + talloc_free(r); + return false; + } + + r->out.total_entries = talloc_zero(r, uint32_t); + if (r->out.total_entries == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetGroupGetUsers(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGroupGetUsers, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetGroupSetUsers(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetGroupSetUsers *r; + + call = &ndr_table_libnetapi.calls[NDR_NETGROUPSETUSERS]; + + r = talloc(talloc_tos(), struct NetGroupSetUsers); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGroupSetUsers, NDR_IN, r); + } + + r->out.result = _NetGroupSetUsers(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetGroupSetUsers, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetLocalGroupAdd(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetLocalGroupAdd *r; + + call = &ndr_table_libnetapi.calls[NDR_NETLOCALGROUPADD]; + + r = talloc(talloc_tos(), struct NetLocalGroupAdd); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetLocalGroupAdd, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.parm_err = talloc_zero(r, uint32_t); + if (r->out.parm_err == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetLocalGroupAdd(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetLocalGroupAdd, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetLocalGroupDel(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetLocalGroupDel *r; + + call = &ndr_table_libnetapi.calls[NDR_NETLOCALGROUPDEL]; + + r = talloc(talloc_tos(), struct NetLocalGroupDel); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetLocalGroupDel, NDR_IN, r); + } + + r->out.result = _NetLocalGroupDel(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetLocalGroupDel, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetLocalGroupGetInfo(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetLocalGroupGetInfo *r; + + call = &ndr_table_libnetapi.calls[NDR_NETLOCALGROUPGETINFO]; + + r = talloc(talloc_tos(), struct NetLocalGroupGetInfo); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetLocalGroupGetInfo, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.buffer = talloc_zero(r, uint8_t *); + if (r->out.buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetLocalGroupGetInfo(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetLocalGroupGetInfo, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetLocalGroupSetInfo(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetLocalGroupSetInfo *r; + + call = &ndr_table_libnetapi.calls[NDR_NETLOCALGROUPSETINFO]; + + r = talloc(talloc_tos(), struct NetLocalGroupSetInfo); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetLocalGroupSetInfo, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.parm_err = talloc_zero(r, uint32_t); + if (r->out.parm_err == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetLocalGroupSetInfo(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetLocalGroupSetInfo, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetLocalGroupEnum(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetLocalGroupEnum *r; + + call = &ndr_table_libnetapi.calls[NDR_NETLOCALGROUPENUM]; + + r = talloc(talloc_tos(), struct NetLocalGroupEnum); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetLocalGroupEnum, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.resume_handle = r->in.resume_handle; + r->out.buffer = talloc_zero(r, uint8_t *); + if (r->out.buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.entries_read = talloc_zero(r, uint32_t); + if (r->out.entries_read == NULL) { + talloc_free(r); + return false; + } + + r->out.total_entries = talloc_zero(r, uint32_t); + if (r->out.total_entries == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetLocalGroupEnum(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetLocalGroupEnum, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetLocalGroupAddMembers(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetLocalGroupAddMembers *r; + + call = &ndr_table_libnetapi.calls[NDR_NETLOCALGROUPADDMEMBERS]; + + r = talloc(talloc_tos(), struct NetLocalGroupAddMembers); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetLocalGroupAddMembers, NDR_IN, r); + } + + r->out.result = _NetLocalGroupAddMembers(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetLocalGroupAddMembers, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetLocalGroupDelMembers(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetLocalGroupDelMembers *r; + + call = &ndr_table_libnetapi.calls[NDR_NETLOCALGROUPDELMEMBERS]; + + r = talloc(talloc_tos(), struct NetLocalGroupDelMembers); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetLocalGroupDelMembers, NDR_IN, r); + } + + r->out.result = _NetLocalGroupDelMembers(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetLocalGroupDelMembers, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetLocalGroupGetMembers(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetLocalGroupGetMembers *r; + + call = &ndr_table_libnetapi.calls[NDR_NETLOCALGROUPGETMEMBERS]; + + r = talloc(talloc_tos(), struct NetLocalGroupGetMembers); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetLocalGroupGetMembers, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.resume_handle = r->in.resume_handle; + r->out.buffer = talloc_zero(r, uint8_t *); + if (r->out.buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.entries_read = talloc_zero(r, uint32_t); + if (r->out.entries_read == NULL) { + talloc_free(r); + return false; + } + + r->out.total_entries = talloc_zero(r, uint32_t); + if (r->out.total_entries == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetLocalGroupGetMembers(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetLocalGroupGetMembers, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetLocalGroupSetMembers(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetLocalGroupSetMembers *r; + + call = &ndr_table_libnetapi.calls[NDR_NETLOCALGROUPSETMEMBERS]; + + r = talloc(talloc_tos(), struct NetLocalGroupSetMembers); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetLocalGroupSetMembers, NDR_IN, r); + } + + r->out.result = _NetLocalGroupSetMembers(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetLocalGroupSetMembers, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetRemoteTOD(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetRemoteTOD *r; + + call = &ndr_table_libnetapi.calls[NDR_NETREMOTETOD]; + + r = talloc(talloc_tos(), struct NetRemoteTOD); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetRemoteTOD, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.buffer = talloc_zero(r, uint8_t *); + if (r->out.buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetRemoteTOD(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetRemoteTOD, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetShareAdd(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetShareAdd *r; + + call = &ndr_table_libnetapi.calls[NDR_NETSHAREADD]; + + r = talloc(talloc_tos(), struct NetShareAdd); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetShareAdd, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.parm_err = talloc_zero(r, uint32_t); + if (r->out.parm_err == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetShareAdd(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetShareAdd, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetShareDel(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetShareDel *r; + + call = &ndr_table_libnetapi.calls[NDR_NETSHAREDEL]; + + r = talloc(talloc_tos(), struct NetShareDel); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetShareDel, NDR_IN, r); + } + + r->out.result = _NetShareDel(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetShareDel, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetShareEnum(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetShareEnum *r; + + call = &ndr_table_libnetapi.calls[NDR_NETSHAREENUM]; + + r = talloc(talloc_tos(), struct NetShareEnum); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetShareEnum, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.resume_handle = r->in.resume_handle; + r->out.buffer = talloc_zero(r, uint8_t *); + if (r->out.buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.entries_read = talloc_zero(r, uint32_t); + if (r->out.entries_read == NULL) { + talloc_free(r); + return false; + } + + r->out.total_entries = talloc_zero(r, uint32_t); + if (r->out.total_entries == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetShareEnum(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetShareEnum, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetShareGetInfo(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetShareGetInfo *r; + + call = &ndr_table_libnetapi.calls[NDR_NETSHAREGETINFO]; + + r = talloc(talloc_tos(), struct NetShareGetInfo); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetShareGetInfo, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.buffer = talloc_zero(r, uint8_t *); + if (r->out.buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetShareGetInfo(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetShareGetInfo, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetShareSetInfo(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetShareSetInfo *r; + + call = &ndr_table_libnetapi.calls[NDR_NETSHARESETINFO]; + + r = talloc(talloc_tos(), struct NetShareSetInfo); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetShareSetInfo, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.parm_err = talloc_zero(r, uint32_t); + if (r->out.parm_err == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetShareSetInfo(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetShareSetInfo, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetFileClose(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetFileClose *r; + + call = &ndr_table_libnetapi.calls[NDR_NETFILECLOSE]; + + r = talloc(talloc_tos(), struct NetFileClose); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetFileClose, NDR_IN, r); + } + + r->out.result = _NetFileClose(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetFileClose, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetFileGetInfo(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetFileGetInfo *r; + + call = &ndr_table_libnetapi.calls[NDR_NETFILEGETINFO]; + + r = talloc(talloc_tos(), struct NetFileGetInfo); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetFileGetInfo, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.buffer = talloc_zero(r, uint8_t *); + if (r->out.buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetFileGetInfo(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetFileGetInfo, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetFileEnum(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetFileEnum *r; + + call = &ndr_table_libnetapi.calls[NDR_NETFILEENUM]; + + r = talloc(talloc_tos(), struct NetFileEnum); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetFileEnum, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.resume_handle = r->in.resume_handle; + r->out.buffer = talloc_zero(r, uint8_t *); + if (r->out.buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.entries_read = talloc_zero(r, uint32_t); + if (r->out.entries_read == NULL) { + talloc_free(r); + return false; + } + + r->out.total_entries = talloc_zero(r, uint32_t); + if (r->out.total_entries == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _NetFileEnum(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetFileEnum, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetShutdownInit(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetShutdownInit *r; + + call = &ndr_table_libnetapi.calls[NDR_NETSHUTDOWNINIT]; + + r = talloc(talloc_tos(), struct NetShutdownInit); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetShutdownInit, NDR_IN, r); + } + + r->out.result = _NetShutdownInit(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetShutdownInit, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_NetShutdownAbort(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct NetShutdownAbort *r; + + call = &ndr_table_libnetapi.calls[NDR_NETSHUTDOWNABORT]; + + r = talloc(talloc_tos(), struct NetShutdownAbort); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetShutdownAbort, NDR_IN, r); + } + + r->out.result = _NetShutdownAbort(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(NetShutdownAbort, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_I_NetLogonControl(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct I_NetLogonControl *r; + + call = &ndr_table_libnetapi.calls[NDR_I_NETLOGONCONTROL]; + + r = talloc(talloc_tos(), struct I_NetLogonControl); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(I_NetLogonControl, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.buffer = talloc_zero(r, uint8_t *); + if (r->out.buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _I_NetLogonControl(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(I_NetLogonControl, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + +static bool api_I_NetLogonControl2(struct pipes_struct *p) +{ + const struct ndr_interface_call *call; + struct ndr_pull *pull; + struct ndr_push *push; + enum ndr_err_code ndr_err; + struct I_NetLogonControl2 *r; + + call = &ndr_table_libnetapi.calls[NDR_I_NETLOGONCONTROL2]; + + r = talloc(talloc_tos(), struct I_NetLogonControl2); + if (r == NULL) { + return false; + } + + pull = ndr_pull_init_blob(&p->in_data.data, r); + if (pull == NULL) { + talloc_free(r); + return false; + } + + pull->flags |= LIBNDR_FLAG_REF_ALLOC; + if (p->endian) { + pull->flags |= LIBNDR_FLAG_BIGENDIAN; + } + ndr_err = call->ndr_pull(pull, NDR_IN, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(I_NetLogonControl2, NDR_IN, r); + } + + ZERO_STRUCT(r->out); + r->out.buffer = talloc_zero(r, uint8_t *); + if (r->out.buffer == NULL) { + talloc_free(r); + return false; + } + + r->out.result = _I_NetLogonControl2(p, r); + + if (p->fault_state) { + talloc_free(r); + /* Return true here, srv_pipe_hnd.c will take care */ + return true; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_FUNCTION_DEBUG(I_NetLogonControl2, NDR_OUT | NDR_SET_VALUES, r); + } + + push = ndr_push_init_ctx(r); + if (push == NULL) { + talloc_free(r); + return false; + } + + /* + * carry over the pointer count to the reply in case we are + * using full pointer. See NDR specification for full pointers + */ + push->ptr_count = pull->ptr_count; + + ndr_err = call->ndr_push(push, NDR_OUT, r); + if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) { + talloc_free(r); + return false; + } + + p->out_data.rdata = ndr_push_blob(push); + talloc_steal(p->mem_ctx, p->out_data.rdata.data); + + talloc_free(r); + + return true; +} + + +/* Tables */ +static struct api_struct api_libnetapi_cmds[] = +{ + {"NETJOINDOMAIN", NDR_NETJOINDOMAIN, api_NetJoinDomain}, + {"NETUNJOINDOMAIN", NDR_NETUNJOINDOMAIN, api_NetUnjoinDomain}, + {"NETGETJOININFORMATION", NDR_NETGETJOININFORMATION, api_NetGetJoinInformation}, + {"NETGETJOINABLEOUS", NDR_NETGETJOINABLEOUS, api_NetGetJoinableOUs}, + {"NETRENAMEMACHINEINDOMAIN", NDR_NETRENAMEMACHINEINDOMAIN, api_NetRenameMachineInDomain}, + {"NETSERVERGETINFO", NDR_NETSERVERGETINFO, api_NetServerGetInfo}, + {"NETSERVERSETINFO", NDR_NETSERVERSETINFO, api_NetServerSetInfo}, + {"NETGETDCNAME", NDR_NETGETDCNAME, api_NetGetDCName}, + {"NETGETANYDCNAME", NDR_NETGETANYDCNAME, api_NetGetAnyDCName}, + {"DSGETDCNAME", NDR_DSGETDCNAME, api_DsGetDcName}, + {"NETUSERADD", NDR_NETUSERADD, api_NetUserAdd}, + {"NETUSERDEL", NDR_NETUSERDEL, api_NetUserDel}, + {"NETUSERENUM", NDR_NETUSERENUM, api_NetUserEnum}, + {"NETUSERCHANGEPASSWORD", NDR_NETUSERCHANGEPASSWORD, api_NetUserChangePassword}, + {"NETUSERGETINFO", NDR_NETUSERGETINFO, api_NetUserGetInfo}, + {"NETUSERSETINFO", NDR_NETUSERSETINFO, api_NetUserSetInfo}, + {"NETUSERGETGROUPS", NDR_NETUSERGETGROUPS, api_NetUserGetGroups}, + {"NETUSERSETGROUPS", NDR_NETUSERSETGROUPS, api_NetUserSetGroups}, + {"NETUSERGETLOCALGROUPS", NDR_NETUSERGETLOCALGROUPS, api_NetUserGetLocalGroups}, + {"NETUSERMODALSGET", NDR_NETUSERMODALSGET, api_NetUserModalsGet}, + {"NETUSERMODALSSET", NDR_NETUSERMODALSSET, api_NetUserModalsSet}, + {"NETQUERYDISPLAYINFORMATION", NDR_NETQUERYDISPLAYINFORMATION, api_NetQueryDisplayInformation}, + {"NETGROUPADD", NDR_NETGROUPADD, api_NetGroupAdd}, + {"NETGROUPDEL", NDR_NETGROUPDEL, api_NetGroupDel}, + {"NETGROUPENUM", NDR_NETGROUPENUM, api_NetGroupEnum}, + {"NETGROUPSETINFO", NDR_NETGROUPSETINFO, api_NetGroupSetInfo}, + {"NETGROUPGETINFO", NDR_NETGROUPGETINFO, api_NetGroupGetInfo}, + {"NETGROUPADDUSER", NDR_NETGROUPADDUSER, api_NetGroupAddUser}, + {"NETGROUPDELUSER", NDR_NETGROUPDELUSER, api_NetGroupDelUser}, + {"NETGROUPGETUSERS", NDR_NETGROUPGETUSERS, api_NetGroupGetUsers}, + {"NETGROUPSETUSERS", NDR_NETGROUPSETUSERS, api_NetGroupSetUsers}, + {"NETLOCALGROUPADD", NDR_NETLOCALGROUPADD, api_NetLocalGroupAdd}, + {"NETLOCALGROUPDEL", NDR_NETLOCALGROUPDEL, api_NetLocalGroupDel}, + {"NETLOCALGROUPGETINFO", NDR_NETLOCALGROUPGETINFO, api_NetLocalGroupGetInfo}, + {"NETLOCALGROUPSETINFO", NDR_NETLOCALGROUPSETINFO, api_NetLocalGroupSetInfo}, + {"NETLOCALGROUPENUM", NDR_NETLOCALGROUPENUM, api_NetLocalGroupEnum}, + {"NETLOCALGROUPADDMEMBERS", NDR_NETLOCALGROUPADDMEMBERS, api_NetLocalGroupAddMembers}, + {"NETLOCALGROUPDELMEMBERS", NDR_NETLOCALGROUPDELMEMBERS, api_NetLocalGroupDelMembers}, + {"NETLOCALGROUPGETMEMBERS", NDR_NETLOCALGROUPGETMEMBERS, api_NetLocalGroupGetMembers}, + {"NETLOCALGROUPSETMEMBERS", NDR_NETLOCALGROUPSETMEMBERS, api_NetLocalGroupSetMembers}, + {"NETREMOTETOD", NDR_NETREMOTETOD, api_NetRemoteTOD}, + {"NETSHAREADD", NDR_NETSHAREADD, api_NetShareAdd}, + {"NETSHAREDEL", NDR_NETSHAREDEL, api_NetShareDel}, + {"NETSHAREENUM", NDR_NETSHAREENUM, api_NetShareEnum}, + {"NETSHAREGETINFO", NDR_NETSHAREGETINFO, api_NetShareGetInfo}, + {"NETSHARESETINFO", NDR_NETSHARESETINFO, api_NetShareSetInfo}, + {"NETFILECLOSE", NDR_NETFILECLOSE, api_NetFileClose}, + {"NETFILEGETINFO", NDR_NETFILEGETINFO, api_NetFileGetInfo}, + {"NETFILEENUM", NDR_NETFILEENUM, api_NetFileEnum}, + {"NETSHUTDOWNINIT", NDR_NETSHUTDOWNINIT, api_NetShutdownInit}, + {"NETSHUTDOWNABORT", NDR_NETSHUTDOWNABORT, api_NetShutdownAbort}, + {"I_NETLOGONCONTROL", NDR_I_NETLOGONCONTROL, api_I_NetLogonControl}, + {"I_NETLOGONCONTROL2", NDR_I_NETLOGONCONTROL2, api_I_NetLogonControl2}, +}; + +void libnetapi_get_pipe_fns(struct api_struct **fns, int *n_fns) +{ + *fns = api_libnetapi_cmds; + *n_fns = sizeof(api_libnetapi_cmds) / sizeof(struct api_struct); +} + +NTSTATUS rpc_libnetapi_init(const struct rpc_srv_callbacks *rpc_srv_cb) +{ + return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "libnetapi", "libnetapi", &ndr_table_libnetapi, api_libnetapi_cmds, sizeof(api_libnetapi_cmds) / sizeof(struct api_struct), rpc_srv_cb); +} + +NTSTATUS rpc_libnetapi_shutdown(void) +{ + return rpc_srv_unregister(&ndr_table_libnetapi); +} |