From 3abe59cb2df9d2394d37f68c413d9098fa0a368f Mon Sep 17 00:00:00 2001 From: Stefan Metzmacher Date: Thu, 30 Jul 2009 18:56:42 +0200 Subject: librpc: rerun "make idl" metze --- librpc/gen_ndr/cli_wkssvc.c | 3985 ++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 3900 insertions(+), 85 deletions(-) (limited to 'librpc/gen_ndr/cli_wkssvc.c') diff --git a/librpc/gen_ndr/cli_wkssvc.c b/librpc/gen_ndr/cli_wkssvc.c index c143058942..f40238af54 100644 --- a/librpc/gen_ndr/cli_wkssvc.c +++ b/librpc/gen_ndr/cli_wkssvc.c @@ -6,6 +6,129 @@ #include "includes.h" #include "../librpc/gen_ndr/cli_wkssvc.h" +struct rpccli_wkssvc_NetWkstaGetInfo_state { + struct wkssvc_NetWkstaGetInfo orig; + struct wkssvc_NetWkstaGetInfo tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetWkstaGetInfo_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetWkstaGetInfo_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + uint32_t _level /* [in] */, + union wkssvc_NetWkstaInfo *_info /* [out] [ref,switch_is(level)] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetWkstaGetInfo_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetWkstaGetInfo_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.level = _level; + + /* Out parameters */ + state->orig.out.info = _info; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaGetInfo, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_wkssvc_NetWkstaGetInfo_out_memory"); + if (tevent_req_nomem(state->out_mem_ctx, req)) { + return tevent_req_post(req, ev); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETWKSTAGETINFO, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetWkstaGetInfo_done, req); + return req; +} + +static void rpccli_wkssvc_NetWkstaGetInfo_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetWkstaGetInfo_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetWkstaGetInfo_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + *state->orig.out.info = *state->tmp.out.info; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaGetInfo, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetWkstaGetInfo_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetWkstaGetInfo_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetWkstaGetInfo_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetWkstaGetInfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name /* [in] [unique,charset(UTF16)] */, @@ -53,6 +176,132 @@ NTSTATUS rpccli_wkssvc_NetWkstaGetInfo(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetWkstaSetInfo_state { + struct wkssvc_NetWkstaSetInfo orig; + struct wkssvc_NetWkstaSetInfo tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetWkstaSetInfo_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetWkstaSetInfo_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + uint32_t _level /* [in] */, + union wkssvc_NetWkstaInfo *_info /* [in] [ref,switch_is(level)] */, + uint32_t *_parm_error /* [in,out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetWkstaSetInfo_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetWkstaSetInfo_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.level = _level; + state->orig.in.info = _info; + state->orig.in.parm_error = _parm_error; + + /* Out parameters */ + state->orig.out.parm_error = _parm_error; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaSetInfo, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_wkssvc_NetWkstaSetInfo_out_memory"); + if (tevent_req_nomem(state->out_mem_ctx, req)) { + return tevent_req_post(req, ev); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETWKSTASETINFO, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetWkstaSetInfo_done, req); + return req; +} + +static void rpccli_wkssvc_NetWkstaSetInfo_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetWkstaSetInfo_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetWkstaSetInfo_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + *state->orig.out.parm_error = *state->tmp.out.parm_error; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaSetInfo, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetWkstaSetInfo_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetWkstaSetInfo_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetWkstaSetInfo_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetWkstaSetInfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name /* [in] [unique,charset(UTF16)] */, @@ -103,6 +352,139 @@ NTSTATUS rpccli_wkssvc_NetWkstaSetInfo(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetWkstaEnumUsers_state { + struct wkssvc_NetWkstaEnumUsers orig; + struct wkssvc_NetWkstaEnumUsers tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetWkstaEnumUsers_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetWkstaEnumUsers_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + struct wkssvc_NetWkstaEnumUsersInfo *_info /* [in,out] [ref] */, + uint32_t _prefmaxlen /* [in] */, + uint32_t *_entries_read /* [out] [ref] */, + uint32_t *_resume_handle /* [in,out] [unique] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetWkstaEnumUsers_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetWkstaEnumUsers_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.info = _info; + state->orig.in.prefmaxlen = _prefmaxlen; + state->orig.in.resume_handle = _resume_handle; + + /* Out parameters */ + state->orig.out.info = _info; + state->orig.out.entries_read = _entries_read; + state->orig.out.resume_handle = _resume_handle; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaEnumUsers, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_wkssvc_NetWkstaEnumUsers_out_memory"); + if (tevent_req_nomem(state->out_mem_ctx, req)) { + return tevent_req_post(req, ev); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETWKSTAENUMUSERS, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetWkstaEnumUsers_done, req); + return req; +} + +static void rpccli_wkssvc_NetWkstaEnumUsers_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetWkstaEnumUsers_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetWkstaEnumUsers_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + *state->orig.out.info = *state->tmp.out.info; + *state->orig.out.entries_read = *state->tmp.out.entries_read; + if (state->orig.out.resume_handle && state->tmp.out.resume_handle) { + *state->orig.out.resume_handle = *state->tmp.out.resume_handle; + } + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaEnumUsers, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetWkstaEnumUsers_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetWkstaEnumUsers_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetWkstaEnumUsers_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetWkstaEnumUsers(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name /* [in] [unique,charset(UTF16)] */, @@ -158,6 +540,129 @@ NTSTATUS rpccli_wkssvc_NetWkstaEnumUsers(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrWkstaUserGetInfo_state { + struct wkssvc_NetrWkstaUserGetInfo orig; + struct wkssvc_NetrWkstaUserGetInfo tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrWkstaUserGetInfo_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrWkstaUserGetInfo_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_unknown /* [in] [unique,charset(UTF16)] */, + uint32_t _level /* [in] */, + union wkssvc_NetrWkstaUserInfo *_info /* [out] [ref,switch_is(level)] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrWkstaUserGetInfo_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrWkstaUserGetInfo_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.unknown = _unknown; + state->orig.in.level = _level; + + /* Out parameters */ + state->orig.out.info = _info; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrWkstaUserGetInfo, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_wkssvc_NetrWkstaUserGetInfo_out_memory"); + if (tevent_req_nomem(state->out_mem_ctx, req)) { + return tevent_req_post(req, ev); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRWKSTAUSERGETINFO, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrWkstaUserGetInfo_done, req); + return req; +} + +static void rpccli_wkssvc_NetrWkstaUserGetInfo_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrWkstaUserGetInfo_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrWkstaUserGetInfo_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + *state->orig.out.info = *state->tmp.out.info; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrWkstaUserGetInfo, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrWkstaUserGetInfo_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrWkstaUserGetInfo_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrWkstaUserGetInfo_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrWkstaUserGetInfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *unknown /* [in] [unique,charset(UTF16)] */, @@ -205,6 +710,134 @@ NTSTATUS rpccli_wkssvc_NetrWkstaUserGetInfo(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrWkstaUserSetInfo_state { + struct wkssvc_NetrWkstaUserSetInfo orig; + struct wkssvc_NetrWkstaUserSetInfo tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrWkstaUserSetInfo_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrWkstaUserSetInfo_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_unknown /* [in] [unique,charset(UTF16)] */, + uint32_t _level /* [in] */, + union wkssvc_NetrWkstaUserInfo *_info /* [in] [ref,switch_is(level)] */, + uint32_t *_parm_err /* [in,out] [unique] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrWkstaUserSetInfo_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrWkstaUserSetInfo_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.unknown = _unknown; + state->orig.in.level = _level; + state->orig.in.info = _info; + state->orig.in.parm_err = _parm_err; + + /* Out parameters */ + state->orig.out.parm_err = _parm_err; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrWkstaUserSetInfo, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_wkssvc_NetrWkstaUserSetInfo_out_memory"); + if (tevent_req_nomem(state->out_mem_ctx, req)) { + return tevent_req_post(req, ev); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRWKSTAUSERSETINFO, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrWkstaUserSetInfo_done, req); + return req; +} + +static void rpccli_wkssvc_NetrWkstaUserSetInfo_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrWkstaUserSetInfo_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrWkstaUserSetInfo_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + if (state->orig.out.parm_err && state->tmp.out.parm_err) { + *state->orig.out.parm_err = *state->tmp.out.parm_err; + } + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrWkstaUserSetInfo, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrWkstaUserSetInfo_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrWkstaUserSetInfo_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrWkstaUserSetInfo_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrWkstaUserSetInfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *unknown /* [in] [unique,charset(UTF16)] */, @@ -257,40 +890,173 @@ NTSTATUS rpccli_wkssvc_NetrWkstaUserSetInfo(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } -NTSTATUS rpccli_wkssvc_NetWkstaTransportEnum(struct rpc_pipe_client *cli, - TALLOC_CTX *mem_ctx, - const char *server_name /* [in] [unique,charset(UTF16)] */, - struct wkssvc_NetWkstaTransportInfo *info /* [in,out] [ref] */, - uint32_t max_buffer /* [in] */, - uint32_t *total_entries /* [out] [ref] */, - uint32_t *resume_handle /* [in,out] [unique] */, - WERROR *werror) +struct rpccli_wkssvc_NetWkstaTransportEnum_state { + struct wkssvc_NetWkstaTransportEnum orig; + struct wkssvc_NetWkstaTransportEnum tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetWkstaTransportEnum_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetWkstaTransportEnum_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + struct wkssvc_NetWkstaTransportInfo *_info /* [in,out] [ref] */, + uint32_t _max_buffer /* [in] */, + uint32_t *_total_entries /* [out] [ref] */, + uint32_t *_resume_handle /* [in,out] [unique] */) { - struct wkssvc_NetWkstaTransportEnum r; - NTSTATUS status; + struct tevent_req *req; + struct rpccli_wkssvc_NetWkstaTransportEnum_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetWkstaTransportEnum_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; /* In parameters */ - r.in.server_name = server_name; - r.in.info = info; - r.in.max_buffer = max_buffer; - r.in.resume_handle = resume_handle; + state->orig.in.server_name = _server_name; + state->orig.in.info = _info; + state->orig.in.max_buffer = _max_buffer; + state->orig.in.resume_handle = _resume_handle; - if (DEBUGLEVEL >= 10) { - NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaTransportEnum, &r); - } + /* Out parameters */ + state->orig.out.info = _info; + state->orig.out.total_entries = _total_entries; + state->orig.out.resume_handle = _resume_handle; - status = cli->dispatch(cli, - mem_ctx, - &ndr_table_wkssvc, - NDR_WKSSVC_NETWKSTATRANSPORTENUM, - &r); + /* Result */ + ZERO_STRUCT(state->orig.out.result); - if (!NT_STATUS_IS_OK(status)) { - return status; + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaTransportEnum, &state->orig); } - if (DEBUGLEVEL >= 10) { - NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaTransportEnum, &r); + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_wkssvc_NetWkstaTransportEnum_out_memory"); + if (tevent_req_nomem(state->out_mem_ctx, req)) { + return tevent_req_post(req, ev); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETWKSTATRANSPORTENUM, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetWkstaTransportEnum_done, req); + return req; +} + +static void rpccli_wkssvc_NetWkstaTransportEnum_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetWkstaTransportEnum_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetWkstaTransportEnum_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + *state->orig.out.info = *state->tmp.out.info; + *state->orig.out.total_entries = *state->tmp.out.total_entries; + if (state->orig.out.resume_handle && state->tmp.out.resume_handle) { + *state->orig.out.resume_handle = *state->tmp.out.resume_handle; + } + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaTransportEnum, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetWkstaTransportEnum_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetWkstaTransportEnum_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetWkstaTransportEnum_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + +NTSTATUS rpccli_wkssvc_NetWkstaTransportEnum(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + const char *server_name /* [in] [unique,charset(UTF16)] */, + struct wkssvc_NetWkstaTransportInfo *info /* [in,out] [ref] */, + uint32_t max_buffer /* [in] */, + uint32_t *total_entries /* [out] [ref] */, + uint32_t *resume_handle /* [in,out] [unique] */, + WERROR *werror) +{ + struct wkssvc_NetWkstaTransportEnum r; + NTSTATUS status; + + /* In parameters */ + r.in.server_name = server_name; + r.in.info = info; + r.in.max_buffer = max_buffer; + r.in.resume_handle = resume_handle; + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaTransportEnum, &r); + } + + status = cli->dispatch(cli, + mem_ctx, + &ndr_table_wkssvc, + NDR_WKSSVC_NETWKSTATRANSPORTENUM, + &r); + + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaTransportEnum, &r); } if (NT_STATUS_IS_ERR(status)) { @@ -312,6 +1078,134 @@ NTSTATUS rpccli_wkssvc_NetWkstaTransportEnum(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrWkstaTransportAdd_state { + struct wkssvc_NetrWkstaTransportAdd orig; + struct wkssvc_NetrWkstaTransportAdd tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrWkstaTransportAdd_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrWkstaTransportAdd_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + uint32_t _level /* [in] */, + struct wkssvc_NetWkstaTransportInfo0 *_info0 /* [in] [ref] */, + uint32_t *_parm_err /* [in,out] [unique] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrWkstaTransportAdd_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrWkstaTransportAdd_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.level = _level; + state->orig.in.info0 = _info0; + state->orig.in.parm_err = _parm_err; + + /* Out parameters */ + state->orig.out.parm_err = _parm_err; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrWkstaTransportAdd, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_wkssvc_NetrWkstaTransportAdd_out_memory"); + if (tevent_req_nomem(state->out_mem_ctx, req)) { + return tevent_req_post(req, ev); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRWKSTATRANSPORTADD, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrWkstaTransportAdd_done, req); + return req; +} + +static void rpccli_wkssvc_NetrWkstaTransportAdd_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrWkstaTransportAdd_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrWkstaTransportAdd_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + if (state->orig.out.parm_err && state->tmp.out.parm_err) { + *state->orig.out.parm_err = *state->tmp.out.parm_err; + } + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrWkstaTransportAdd, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrWkstaTransportAdd_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrWkstaTransportAdd_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrWkstaTransportAdd_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrWkstaTransportAdd(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name /* [in] [unique,charset(UTF16)] */, @@ -364,6 +1258,122 @@ NTSTATUS rpccli_wkssvc_NetrWkstaTransportAdd(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrWkstaTransportDel_state { + struct wkssvc_NetrWkstaTransportDel orig; + struct wkssvc_NetrWkstaTransportDel tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrWkstaTransportDel_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrWkstaTransportDel_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + const char *_transport_name /* [in] [unique,charset(UTF16)] */, + uint32_t _unknown3 /* [in] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrWkstaTransportDel_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrWkstaTransportDel_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.transport_name = _transport_name; + state->orig.in.unknown3 = _unknown3; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrWkstaTransportDel, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRWKSTATRANSPORTDEL, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrWkstaTransportDel_done, req); + return req; +} + +static void rpccli_wkssvc_NetrWkstaTransportDel_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrWkstaTransportDel_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrWkstaTransportDel_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrWkstaTransportDel, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrWkstaTransportDel_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrWkstaTransportDel_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrWkstaTransportDel_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrWkstaTransportDel(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name /* [in] [unique,charset(UTF16)] */, @@ -411,6 +1421,134 @@ NTSTATUS rpccli_wkssvc_NetrWkstaTransportDel(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrUseAdd_state { + struct wkssvc_NetrUseAdd orig; + struct wkssvc_NetrUseAdd tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrUseAdd_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrUseAdd_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + uint32_t _level /* [in] */, + union wkssvc_NetrUseGetInfoCtr *_ctr /* [in] [ref,switch_is(level)] */, + uint32_t *_parm_err /* [in,out] [unique] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrUseAdd_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrUseAdd_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.level = _level; + state->orig.in.ctr = _ctr; + state->orig.in.parm_err = _parm_err; + + /* Out parameters */ + state->orig.out.parm_err = _parm_err; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrUseAdd, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_wkssvc_NetrUseAdd_out_memory"); + if (tevent_req_nomem(state->out_mem_ctx, req)) { + return tevent_req_post(req, ev); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRUSEADD, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrUseAdd_done, req); + return req; +} + +static void rpccli_wkssvc_NetrUseAdd_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrUseAdd_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrUseAdd_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + if (state->orig.out.parm_err && state->tmp.out.parm_err) { + *state->orig.out.parm_err = *state->tmp.out.parm_err; + } + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrUseAdd, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrUseAdd_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrUseAdd_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrUseAdd_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrUseAdd(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name /* [in] [unique,charset(UTF16)] */, @@ -463,6 +1601,131 @@ NTSTATUS rpccli_wkssvc_NetrUseAdd(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrUseGetInfo_state { + struct wkssvc_NetrUseGetInfo orig; + struct wkssvc_NetrUseGetInfo tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrUseGetInfo_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrUseGetInfo_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + const char *_use_name /* [in] [ref,charset(UTF16)] */, + uint32_t _level /* [in] */, + union wkssvc_NetrUseGetInfoCtr *_ctr /* [out] [ref,switch_is(level)] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrUseGetInfo_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrUseGetInfo_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.use_name = _use_name; + state->orig.in.level = _level; + + /* Out parameters */ + state->orig.out.ctr = _ctr; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrUseGetInfo, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_wkssvc_NetrUseGetInfo_out_memory"); + if (tevent_req_nomem(state->out_mem_ctx, req)) { + return tevent_req_post(req, ev); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRUSEGETINFO, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrUseGetInfo_done, req); + return req; +} + +static void rpccli_wkssvc_NetrUseGetInfo_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrUseGetInfo_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrUseGetInfo_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + *state->orig.out.ctr = *state->tmp.out.ctr; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrUseGetInfo, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrUseGetInfo_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrUseGetInfo_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrUseGetInfo_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrUseGetInfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name /* [in] [unique,charset(UTF16)] */, @@ -512,14 +1775,130 @@ NTSTATUS rpccli_wkssvc_NetrUseGetInfo(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } -NTSTATUS rpccli_wkssvc_NetrUseDel(struct rpc_pipe_client *cli, - TALLOC_CTX *mem_ctx, - const char *server_name /* [in] [unique,charset(UTF16)] */, - const char *use_name /* [in] [ref,charset(UTF16)] */, - uint32_t force_cond /* [in] */, - WERROR *werror) +struct rpccli_wkssvc_NetrUseDel_state { + struct wkssvc_NetrUseDel orig; + struct wkssvc_NetrUseDel tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrUseDel_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrUseDel_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + const char *_use_name /* [in] [ref,charset(UTF16)] */, + uint32_t _force_cond /* [in] */) { - struct wkssvc_NetrUseDel r; + struct tevent_req *req; + struct rpccli_wkssvc_NetrUseDel_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrUseDel_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.use_name = _use_name; + state->orig.in.force_cond = _force_cond; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrUseDel, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRUSEDEL, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrUseDel_done, req); + return req; +} + +static void rpccli_wkssvc_NetrUseDel_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrUseDel_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrUseDel_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrUseDel, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrUseDel_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrUseDel_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrUseDel_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + +NTSTATUS rpccli_wkssvc_NetrUseDel(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + const char *server_name /* [in] [unique,charset(UTF16)] */, + const char *use_name /* [in] [ref,charset(UTF16)] */, + uint32_t force_cond /* [in] */, + WERROR *werror) +{ + struct wkssvc_NetrUseDel r; NTSTATUS status; /* In parameters */ @@ -559,6 +1938,139 @@ NTSTATUS rpccli_wkssvc_NetrUseDel(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrUseEnum_state { + struct wkssvc_NetrUseEnum orig; + struct wkssvc_NetrUseEnum tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrUseEnum_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrUseEnum_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + struct wkssvc_NetrUseEnumInfo *_info /* [in,out] [ref] */, + uint32_t _prefmaxlen /* [in] */, + uint32_t *_entries_read /* [out] [ref] */, + uint32_t *_resume_handle /* [in,out] [unique] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrUseEnum_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrUseEnum_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.info = _info; + state->orig.in.prefmaxlen = _prefmaxlen; + state->orig.in.resume_handle = _resume_handle; + + /* Out parameters */ + state->orig.out.info = _info; + state->orig.out.entries_read = _entries_read; + state->orig.out.resume_handle = _resume_handle; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrUseEnum, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_wkssvc_NetrUseEnum_out_memory"); + if (tevent_req_nomem(state->out_mem_ctx, req)) { + return tevent_req_post(req, ev); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRUSEENUM, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrUseEnum_done, req); + return req; +} + +static void rpccli_wkssvc_NetrUseEnum_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrUseEnum_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrUseEnum_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + *state->orig.out.info = *state->tmp.out.info; + *state->orig.out.entries_read = *state->tmp.out.entries_read; + if (state->orig.out.resume_handle && state->tmp.out.resume_handle) { + *state->orig.out.resume_handle = *state->tmp.out.resume_handle; + } + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrUseEnum, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrUseEnum_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrUseEnum_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrUseEnum_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrUseEnum(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name /* [in] [unique,charset(UTF16)] */, @@ -614,6 +2126,126 @@ NTSTATUS rpccli_wkssvc_NetrUseEnum(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrMessageBufferSend_state { + struct wkssvc_NetrMessageBufferSend orig; + struct wkssvc_NetrMessageBufferSend tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrMessageBufferSend_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrMessageBufferSend_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + const char *_message_name /* [in] [ref,charset(UTF16)] */, + const char *_message_sender_name /* [in] [unique,charset(UTF16)] */, + uint8_t *_message_buffer /* [in] [ref,size_is(message_size)] */, + uint32_t _message_size /* [in] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrMessageBufferSend_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrMessageBufferSend_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.message_name = _message_name; + state->orig.in.message_sender_name = _message_sender_name; + state->orig.in.message_buffer = _message_buffer; + state->orig.in.message_size = _message_size; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrMessageBufferSend, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRMESSAGEBUFFERSEND, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrMessageBufferSend_done, req); + return req; +} + +static void rpccli_wkssvc_NetrMessageBufferSend_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrMessageBufferSend_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrMessageBufferSend_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrMessageBufferSend, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrMessageBufferSend_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrMessageBufferSend_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrMessageBufferSend_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrMessageBufferSend(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name /* [in] [unique,charset(UTF16)] */, @@ -665,6 +2297,133 @@ NTSTATUS rpccli_wkssvc_NetrMessageBufferSend(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrWorkstationStatisticsGet_state { + struct wkssvc_NetrWorkstationStatisticsGet orig; + struct wkssvc_NetrWorkstationStatisticsGet tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrWorkstationStatisticsGet_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrWorkstationStatisticsGet_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + const char *_unknown2 /* [in] [unique,charset(UTF16)] */, + uint32_t _unknown3 /* [in] */, + uint32_t _unknown4 /* [in] */, + struct wkssvc_NetrWorkstationStatistics **_info /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrWorkstationStatisticsGet_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrWorkstationStatisticsGet_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.unknown2 = _unknown2; + state->orig.in.unknown3 = _unknown3; + state->orig.in.unknown4 = _unknown4; + + /* Out parameters */ + state->orig.out.info = _info; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrWorkstationStatisticsGet, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_wkssvc_NetrWorkstationStatisticsGet_out_memory"); + if (tevent_req_nomem(state->out_mem_ctx, req)) { + return tevent_req_post(req, ev); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRWORKSTATIONSTATISTICSGET, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrWorkstationStatisticsGet_done, req); + return req; +} + +static void rpccli_wkssvc_NetrWorkstationStatisticsGet_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrWorkstationStatisticsGet_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrWorkstationStatisticsGet_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + *state->orig.out.info = *state->tmp.out.info; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrWorkstationStatisticsGet, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrWorkstationStatisticsGet_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrWorkstationStatisticsGet_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrWorkstationStatisticsGet_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrWorkstationStatisticsGet(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name /* [in] [unique,charset(UTF16)] */, @@ -716,6 +2475,118 @@ NTSTATUS rpccli_wkssvc_NetrWorkstationStatisticsGet(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrLogonDomainNameAdd_state { + struct wkssvc_NetrLogonDomainNameAdd orig; + struct wkssvc_NetrLogonDomainNameAdd tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrLogonDomainNameAdd_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrLogonDomainNameAdd_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_domain_name /* [in] [ref,charset(UTF16)] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrLogonDomainNameAdd_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrLogonDomainNameAdd_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.domain_name = _domain_name; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrLogonDomainNameAdd, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRLOGONDOMAINNAMEADD, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrLogonDomainNameAdd_done, req); + return req; +} + +static void rpccli_wkssvc_NetrLogonDomainNameAdd_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrLogonDomainNameAdd_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrLogonDomainNameAdd_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrLogonDomainNameAdd, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrLogonDomainNameAdd_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrLogonDomainNameAdd_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrLogonDomainNameAdd_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrLogonDomainNameAdd(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *domain_name /* [in] [ref,charset(UTF16)] */, @@ -759,6 +2630,118 @@ NTSTATUS rpccli_wkssvc_NetrLogonDomainNameAdd(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrLogonDomainNameDel_state { + struct wkssvc_NetrLogonDomainNameDel orig; + struct wkssvc_NetrLogonDomainNameDel tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrLogonDomainNameDel_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrLogonDomainNameDel_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_domain_name /* [in] [ref,charset(UTF16)] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrLogonDomainNameDel_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrLogonDomainNameDel_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.domain_name = _domain_name; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrLogonDomainNameDel, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRLOGONDOMAINNAMEDEL, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrLogonDomainNameDel_done, req); + return req; +} + +static void rpccli_wkssvc_NetrLogonDomainNameDel_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrLogonDomainNameDel_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrLogonDomainNameDel_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrLogonDomainNameDel, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrLogonDomainNameDel_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrLogonDomainNameDel_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrLogonDomainNameDel_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrLogonDomainNameDel(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *domain_name /* [in] [ref,charset(UTF16)] */, @@ -802,6 +2785,128 @@ NTSTATUS rpccli_wkssvc_NetrLogonDomainNameDel(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrJoinDomain_state { + struct wkssvc_NetrJoinDomain orig; + struct wkssvc_NetrJoinDomain tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrJoinDomain_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrJoinDomain_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + const char *_domain_name /* [in] [ref,charset(UTF16)] */, + const char *_account_ou /* [in] [unique,charset(UTF16)] */, + const char *_Account /* [in] [unique,charset(UTF16)] */, + const char *_password /* [in] [unique,charset(UTF16)] */, + uint32_t _join_flags /* [in] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrJoinDomain_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrJoinDomain_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.domain_name = _domain_name; + state->orig.in.account_ou = _account_ou; + state->orig.in.Account = _Account; + state->orig.in.password = _password; + state->orig.in.join_flags = _join_flags; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrJoinDomain, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRJOINDOMAIN, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrJoinDomain_done, req); + return req; +} + +static void rpccli_wkssvc_NetrJoinDomain_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrJoinDomain_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrJoinDomain_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrJoinDomain, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrJoinDomain_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrJoinDomain_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrJoinDomain_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrJoinDomain(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name /* [in] [unique,charset(UTF16)] */, @@ -855,6 +2960,124 @@ NTSTATUS rpccli_wkssvc_NetrJoinDomain(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrUnjoinDomain_state { + struct wkssvc_NetrUnjoinDomain orig; + struct wkssvc_NetrUnjoinDomain tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrUnjoinDomain_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrUnjoinDomain_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + const char *_Account /* [in] [unique,charset(UTF16)] */, + const char *_password /* [in] [unique,charset(UTF16)] */, + uint32_t _unjoin_flags /* [in] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrUnjoinDomain_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrUnjoinDomain_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.Account = _Account; + state->orig.in.password = _password; + state->orig.in.unjoin_flags = _unjoin_flags; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrUnjoinDomain, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRUNJOINDOMAIN, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrUnjoinDomain_done, req); + return req; +} + +static void rpccli_wkssvc_NetrUnjoinDomain_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrUnjoinDomain_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrUnjoinDomain_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrUnjoinDomain, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrUnjoinDomain_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrUnjoinDomain_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrUnjoinDomain_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrUnjoinDomain(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name /* [in] [unique,charset(UTF16)] */, @@ -904,6 +3127,126 @@ NTSTATUS rpccli_wkssvc_NetrUnjoinDomain(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrRenameMachineInDomain_state { + struct wkssvc_NetrRenameMachineInDomain orig; + struct wkssvc_NetrRenameMachineInDomain tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrRenameMachineInDomain_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrRenameMachineInDomain_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + const char *_NewMachineName /* [in] [unique,charset(UTF16)] */, + const char *_Account /* [in] [unique,charset(UTF16)] */, + const char *_password /* [in] [unique,charset(UTF16)] */, + uint32_t _RenameOptions /* [in] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrRenameMachineInDomain_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrRenameMachineInDomain_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.NewMachineName = _NewMachineName; + state->orig.in.Account = _Account; + state->orig.in.password = _password; + state->orig.in.RenameOptions = _RenameOptions; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrRenameMachineInDomain, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrRenameMachineInDomain_done, req); + return req; +} + +static void rpccli_wkssvc_NetrRenameMachineInDomain_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrRenameMachineInDomain_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrRenameMachineInDomain_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrRenameMachineInDomain, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrRenameMachineInDomain_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrRenameMachineInDomain_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrRenameMachineInDomain_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrRenameMachineInDomain(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name /* [in] [unique,charset(UTF16)] */, @@ -952,58 +3295,303 @@ NTSTATUS rpccli_wkssvc_NetrRenameMachineInDomain(struct rpc_pipe_client *cli, *werror = r.out.result; } - return werror_to_ntstatus(r.out.result); + return werror_to_ntstatus(r.out.result); +} + +struct rpccli_wkssvc_NetrValidateName_state { + struct wkssvc_NetrValidateName orig; + struct wkssvc_NetrValidateName tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrValidateName_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrValidateName_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + const char *_name /* [in] [ref,charset(UTF16)] */, + const char *_Account /* [in] [unique,charset(UTF16)] */, + const char *_Password /* [in] [unique,charset(UTF16)] */, + enum wkssvc_NetValidateNameType _name_type /* [in] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrValidateName_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrValidateName_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.name = _name; + state->orig.in.Account = _Account; + state->orig.in.Password = _Password; + state->orig.in.name_type = _name_type; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrValidateName, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRVALIDATENAME, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrValidateName_done, req); + return req; +} + +static void rpccli_wkssvc_NetrValidateName_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrValidateName_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrValidateName_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrValidateName, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrValidateName_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrValidateName_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrValidateName_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + +NTSTATUS rpccli_wkssvc_NetrValidateName(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + const char *server_name /* [in] [unique,charset(UTF16)] */, + const char *name /* [in] [ref,charset(UTF16)] */, + const char *Account /* [in] [unique,charset(UTF16)] */, + const char *Password /* [in] [unique,charset(UTF16)] */, + enum wkssvc_NetValidateNameType name_type /* [in] */, + WERROR *werror) +{ + struct wkssvc_NetrValidateName r; + NTSTATUS status; + + /* In parameters */ + r.in.server_name = server_name; + r.in.name = name; + r.in.Account = Account; + r.in.Password = Password; + r.in.name_type = name_type; + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrValidateName, &r); + } + + status = cli->dispatch(cli, + mem_ctx, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRVALIDATENAME, + &r); + + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrValidateName, &r); + } + + if (NT_STATUS_IS_ERR(status)) { + return status; + } + + /* Return variables */ + + /* Return result */ + if (werror) { + *werror = r.out.result; + } + + return werror_to_ntstatus(r.out.result); +} + +struct rpccli_wkssvc_NetrGetJoinInformation_state { + struct wkssvc_NetrGetJoinInformation orig; + struct wkssvc_NetrGetJoinInformation tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrGetJoinInformation_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrGetJoinInformation_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + const char **_name_buffer /* [in,out] [ref,charset(UTF16)] */, + enum wkssvc_NetJoinStatus *_name_type /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrGetJoinInformation_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrGetJoinInformation_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.name_buffer = _name_buffer; + + /* Out parameters */ + state->orig.out.name_buffer = _name_buffer; + state->orig.out.name_type = _name_type; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrGetJoinInformation, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_wkssvc_NetrGetJoinInformation_out_memory"); + if (tevent_req_nomem(state->out_mem_ctx, req)) { + return tevent_req_post(req, ev); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRGETJOININFORMATION, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrGetJoinInformation_done, req); + return req; } -NTSTATUS rpccli_wkssvc_NetrValidateName(struct rpc_pipe_client *cli, - TALLOC_CTX *mem_ctx, - const char *server_name /* [in] [unique,charset(UTF16)] */, - const char *name /* [in] [ref,charset(UTF16)] */, - const char *Account /* [in] [unique,charset(UTF16)] */, - const char *Password /* [in] [unique,charset(UTF16)] */, - enum wkssvc_NetValidateNameType name_type /* [in] */, - WERROR *werror) +static void rpccli_wkssvc_NetrGetJoinInformation_done(struct tevent_req *subreq) { - struct wkssvc_NetrValidateName r; + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrGetJoinInformation_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrGetJoinInformation_state); NTSTATUS status; + TALLOC_CTX *mem_ctx; - /* In parameters */ - r.in.server_name = server_name; - r.in.name = name; - r.in.Account = Account; - r.in.Password = Password; - r.in.name_type = name_type; - - if (DEBUGLEVEL >= 10) { - NDR_PRINT_IN_DEBUG(wkssvc_NetrValidateName, &r); + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; } - status = cli->dispatch(cli, - mem_ctx, - &ndr_table_wkssvc, - NDR_WKSSVC_NETRVALIDATENAME, - &r); - + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); if (!NT_STATUS_IS_OK(status)) { - return status; + tevent_req_nterror(req, status); + return; } + /* Copy out parameters */ + *state->orig.out.name_buffer = *state->tmp.out.name_buffer; + *state->orig.out.name_type = *state->tmp.out.name_type; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + if (DEBUGLEVEL >= 10) { - NDR_PRINT_OUT_DEBUG(wkssvc_NetrValidateName, &r); + NDR_PRINT_OUT_DEBUG(wkssvc_NetrGetJoinInformation, &state->orig); } - if (NT_STATUS_IS_ERR(status)) { + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrGetJoinInformation_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrGetJoinInformation_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrGetJoinInformation_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); return status; } - /* Return variables */ + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); /* Return result */ - if (werror) { - *werror = r.out.result; - } + *result = state->orig.out.result; - return werror_to_ntstatus(r.out.result); + tevent_req_received(req); + return NT_STATUS_OK; } NTSTATUS rpccli_wkssvc_NetrGetJoinInformation(struct rpc_pipe_client *cli, @@ -1054,6 +3642,137 @@ NTSTATUS rpccli_wkssvc_NetrGetJoinInformation(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrGetJoinableOus_state { + struct wkssvc_NetrGetJoinableOus orig; + struct wkssvc_NetrGetJoinableOus tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrGetJoinableOus_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrGetJoinableOus_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + const char *_domain_name /* [in] [ref,charset(UTF16)] */, + const char *_Account /* [in] [unique,charset(UTF16)] */, + const char *_unknown /* [in] [unique,charset(UTF16)] */, + uint32_t *_num_ous /* [in,out] [ref] */, + const char ***_ous /* [out] [ref,charset(UTF16),size_is(,*num_ous)] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrGetJoinableOus_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrGetJoinableOus_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.domain_name = _domain_name; + state->orig.in.Account = _Account; + state->orig.in.unknown = _unknown; + state->orig.in.num_ous = _num_ous; + + /* Out parameters */ + state->orig.out.num_ous = _num_ous; + state->orig.out.ous = _ous; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrGetJoinableOus, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_wkssvc_NetrGetJoinableOus_out_memory"); + if (tevent_req_nomem(state->out_mem_ctx, req)) { + return tevent_req_post(req, ev); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRGETJOINABLEOUS, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrGetJoinableOus_done, req); + return req; +} + +static void rpccli_wkssvc_NetrGetJoinableOus_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrGetJoinableOus_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrGetJoinableOus_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + *state->orig.out.num_ous = *state->tmp.out.num_ous; + *state->orig.out.ous = *state->tmp.out.ous; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrGetJoinableOus, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrGetJoinableOus_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrGetJoinableOus_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrGetJoinableOus_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrGetJoinableOus(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name /* [in] [unique,charset(UTF16)] */, @@ -1108,6 +3827,128 @@ NTSTATUS rpccli_wkssvc_NetrGetJoinableOus(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrJoinDomain2_state { + struct wkssvc_NetrJoinDomain2 orig; + struct wkssvc_NetrJoinDomain2 tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrJoinDomain2_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrJoinDomain2_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + const char *_domain_name /* [in] [ref,charset(UTF16)] */, + const char *_account_ou /* [in] [unique,charset(UTF16)] */, + const char *_admin_account /* [in] [unique,charset(UTF16)] */, + struct wkssvc_PasswordBuffer *_encrypted_password /* [in] [unique] */, + uint32_t _join_flags /* [in] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrJoinDomain2_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrJoinDomain2_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.domain_name = _domain_name; + state->orig.in.account_ou = _account_ou; + state->orig.in.admin_account = _admin_account; + state->orig.in.encrypted_password = _encrypted_password; + state->orig.in.join_flags = _join_flags; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrJoinDomain2, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRJOINDOMAIN2, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrJoinDomain2_done, req); + return req; +} + +static void rpccli_wkssvc_NetrJoinDomain2_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrJoinDomain2_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrJoinDomain2_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrJoinDomain2, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrJoinDomain2_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrJoinDomain2_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrJoinDomain2_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrJoinDomain2(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name /* [in] [unique,charset(UTF16)] */, @@ -1161,6 +4002,124 @@ NTSTATUS rpccli_wkssvc_NetrJoinDomain2(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrUnjoinDomain2_state { + struct wkssvc_NetrUnjoinDomain2 orig; + struct wkssvc_NetrUnjoinDomain2 tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrUnjoinDomain2_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrUnjoinDomain2_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + const char *_account /* [in] [unique,charset(UTF16)] */, + struct wkssvc_PasswordBuffer *_encrypted_password /* [in] [unique] */, + uint32_t _unjoin_flags /* [in] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrUnjoinDomain2_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrUnjoinDomain2_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.account = _account; + state->orig.in.encrypted_password = _encrypted_password; + state->orig.in.unjoin_flags = _unjoin_flags; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrUnjoinDomain2, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRUNJOINDOMAIN2, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrUnjoinDomain2_done, req); + return req; +} + +static void rpccli_wkssvc_NetrUnjoinDomain2_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrUnjoinDomain2_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrUnjoinDomain2_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrUnjoinDomain2, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrUnjoinDomain2_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrUnjoinDomain2_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrUnjoinDomain2_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrUnjoinDomain2(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name /* [in] [unique,charset(UTF16)] */, @@ -1210,6 +4169,126 @@ NTSTATUS rpccli_wkssvc_NetrUnjoinDomain2(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrRenameMachineInDomain2_state { + struct wkssvc_NetrRenameMachineInDomain2 orig; + struct wkssvc_NetrRenameMachineInDomain2 tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrRenameMachineInDomain2_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrRenameMachineInDomain2_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + const char *_NewMachineName /* [in] [unique,charset(UTF16)] */, + const char *_Account /* [in] [unique,charset(UTF16)] */, + struct wkssvc_PasswordBuffer *_EncryptedPassword /* [in] [unique] */, + uint32_t _RenameOptions /* [in] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrRenameMachineInDomain2_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrRenameMachineInDomain2_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.NewMachineName = _NewMachineName; + state->orig.in.Account = _Account; + state->orig.in.EncryptedPassword = _EncryptedPassword; + state->orig.in.RenameOptions = _RenameOptions; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrRenameMachineInDomain2, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN2, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrRenameMachineInDomain2_done, req); + return req; +} + +static void rpccli_wkssvc_NetrRenameMachineInDomain2_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrRenameMachineInDomain2_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrRenameMachineInDomain2_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrRenameMachineInDomain2, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrRenameMachineInDomain2_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrRenameMachineInDomain2_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrRenameMachineInDomain2_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrRenameMachineInDomain2(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name /* [in] [unique,charset(UTF16)] */, @@ -1223,42 +4302,162 @@ NTSTATUS rpccli_wkssvc_NetrRenameMachineInDomain2(struct rpc_pipe_client *cli, NTSTATUS status; /* In parameters */ - r.in.server_name = server_name; - r.in.NewMachineName = NewMachineName; - r.in.Account = Account; - r.in.EncryptedPassword = EncryptedPassword; - r.in.RenameOptions = RenameOptions; + r.in.server_name = server_name; + r.in.NewMachineName = NewMachineName; + r.in.Account = Account; + r.in.EncryptedPassword = EncryptedPassword; + r.in.RenameOptions = RenameOptions; + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrRenameMachineInDomain2, &r); + } + + status = cli->dispatch(cli, + mem_ctx, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN2, + &r); + + if (!NT_STATUS_IS_OK(status)) { + return status; + } + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrRenameMachineInDomain2, &r); + } + + if (NT_STATUS_IS_ERR(status)) { + return status; + } + + /* Return variables */ + + /* Return result */ + if (werror) { + *werror = r.out.result; + } + + return werror_to_ntstatus(r.out.result); +} + +struct rpccli_wkssvc_NetrValidateName2_state { + struct wkssvc_NetrValidateName2 orig; + struct wkssvc_NetrValidateName2 tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrValidateName2_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrValidateName2_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + const char *_name /* [in] [ref,charset(UTF16)] */, + const char *_Account /* [in] [unique,charset(UTF16)] */, + struct wkssvc_PasswordBuffer *_EncryptedPassword /* [in] [unique] */, + enum wkssvc_NetValidateNameType _name_type /* [in] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrValidateName2_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrValidateName2_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.name = _name; + state->orig.in.Account = _Account; + state->orig.in.EncryptedPassword = _EncryptedPassword; + state->orig.in.name_type = _name_type; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); if (DEBUGLEVEL >= 10) { - NDR_PRINT_IN_DEBUG(wkssvc_NetrRenameMachineInDomain2, &r); + NDR_PRINT_IN_DEBUG(wkssvc_NetrValidateName2, &state->orig); } - status = cli->dispatch(cli, - mem_ctx, - &ndr_table_wkssvc, - NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN2, - &r); + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRVALIDATENAME2, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrValidateName2_done, req); + return req; +} + +static void rpccli_wkssvc_NetrValidateName2_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrValidateName2_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrValidateName2_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); if (!NT_STATUS_IS_OK(status)) { - return status; + tevent_req_nterror(req, status); + return; } + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + if (DEBUGLEVEL >= 10) { - NDR_PRINT_OUT_DEBUG(wkssvc_NetrRenameMachineInDomain2, &r); + NDR_PRINT_OUT_DEBUG(wkssvc_NetrValidateName2, &state->orig); } - if (NT_STATUS_IS_ERR(status)) { + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrValidateName2_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrValidateName2_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrValidateName2_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); return status; } - /* Return variables */ + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); /* Return result */ - if (werror) { - *werror = r.out.result; - } + *result = state->orig.out.result; - return werror_to_ntstatus(r.out.result); + tevent_req_received(req); + return NT_STATUS_OK; } NTSTATUS rpccli_wkssvc_NetrValidateName2(struct rpc_pipe_client *cli, @@ -1312,6 +4511,137 @@ NTSTATUS rpccli_wkssvc_NetrValidateName2(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrGetJoinableOus2_state { + struct wkssvc_NetrGetJoinableOus2 orig; + struct wkssvc_NetrGetJoinableOus2 tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrGetJoinableOus2_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrGetJoinableOus2_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + const char *_domain_name /* [in] [ref,charset(UTF16)] */, + const char *_Account /* [in] [unique,charset(UTF16)] */, + struct wkssvc_PasswordBuffer *_EncryptedPassword /* [in] [unique] */, + uint32_t *_num_ous /* [in,out] [ref] */, + const char ***_ous /* [out] [ref,charset(UTF16),size_is(,*num_ous)] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrGetJoinableOus2_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrGetJoinableOus2_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.domain_name = _domain_name; + state->orig.in.Account = _Account; + state->orig.in.EncryptedPassword = _EncryptedPassword; + state->orig.in.num_ous = _num_ous; + + /* Out parameters */ + state->orig.out.num_ous = _num_ous; + state->orig.out.ous = _ous; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrGetJoinableOus2, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_wkssvc_NetrGetJoinableOus2_out_memory"); + if (tevent_req_nomem(state->out_mem_ctx, req)) { + return tevent_req_post(req, ev); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRGETJOINABLEOUS2, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrGetJoinableOus2_done, req); + return req; +} + +static void rpccli_wkssvc_NetrGetJoinableOus2_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrGetJoinableOus2_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrGetJoinableOus2_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + *state->orig.out.num_ous = *state->tmp.out.num_ous; + *state->orig.out.ous = *state->tmp.out.ous; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrGetJoinableOus2, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrGetJoinableOus2_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrGetJoinableOus2_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrGetJoinableOus2_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrGetJoinableOus2(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name /* [in] [unique,charset(UTF16)] */, @@ -1366,6 +4696,126 @@ NTSTATUS rpccli_wkssvc_NetrGetJoinableOus2(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrAddAlternateComputerName_state { + struct wkssvc_NetrAddAlternateComputerName orig; + struct wkssvc_NetrAddAlternateComputerName tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrAddAlternateComputerName_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrAddAlternateComputerName_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + const char *_NewAlternateMachineName /* [in] [unique,charset(UTF16)] */, + const char *_Account /* [in] [unique,charset(UTF16)] */, + struct wkssvc_PasswordBuffer *_EncryptedPassword /* [in] [unique] */, + uint32_t _Reserved /* [in] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrAddAlternateComputerName_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrAddAlternateComputerName_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.NewAlternateMachineName = _NewAlternateMachineName; + state->orig.in.Account = _Account; + state->orig.in.EncryptedPassword = _EncryptedPassword; + state->orig.in.Reserved = _Reserved; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrAddAlternateComputerName, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRADDALTERNATECOMPUTERNAME, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrAddAlternateComputerName_done, req); + return req; +} + +static void rpccli_wkssvc_NetrAddAlternateComputerName_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrAddAlternateComputerName_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrAddAlternateComputerName_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrAddAlternateComputerName, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrAddAlternateComputerName_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrAddAlternateComputerName_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrAddAlternateComputerName_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrAddAlternateComputerName(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name /* [in] [unique,charset(UTF16)] */, @@ -1417,6 +4867,126 @@ NTSTATUS rpccli_wkssvc_NetrAddAlternateComputerName(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrRemoveAlternateComputerName_state { + struct wkssvc_NetrRemoveAlternateComputerName orig; + struct wkssvc_NetrRemoveAlternateComputerName tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrRemoveAlternateComputerName_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrRemoveAlternateComputerName_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + const char *_AlternateMachineNameToRemove /* [in] [unique,charset(UTF16)] */, + const char *_Account /* [in] [unique,charset(UTF16)] */, + struct wkssvc_PasswordBuffer *_EncryptedPassword /* [in] [unique] */, + uint32_t _Reserved /* [in] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrRemoveAlternateComputerName_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrRemoveAlternateComputerName_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.AlternateMachineNameToRemove = _AlternateMachineNameToRemove; + state->orig.in.Account = _Account; + state->orig.in.EncryptedPassword = _EncryptedPassword; + state->orig.in.Reserved = _Reserved; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrRemoveAlternateComputerName, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrRemoveAlternateComputerName_done, req); + return req; +} + +static void rpccli_wkssvc_NetrRemoveAlternateComputerName_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrRemoveAlternateComputerName_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrRemoveAlternateComputerName_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrRemoveAlternateComputerName, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrRemoveAlternateComputerName_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrRemoveAlternateComputerName_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrRemoveAlternateComputerName_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrRemoveAlternateComputerName(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name /* [in] [unique,charset(UTF16)] */, @@ -1468,6 +5038,126 @@ NTSTATUS rpccli_wkssvc_NetrRemoveAlternateComputerName(struct rpc_pipe_client *c return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrSetPrimaryComputername_state { + struct wkssvc_NetrSetPrimaryComputername orig; + struct wkssvc_NetrSetPrimaryComputername tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrSetPrimaryComputername_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrSetPrimaryComputername_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + const char *_primary_name /* [in] [unique,charset(UTF16)] */, + const char *_Account /* [in] [unique,charset(UTF16)] */, + struct wkssvc_PasswordBuffer *_EncryptedPassword /* [in] [unique] */, + uint32_t _Reserved /* [in] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrSetPrimaryComputername_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrSetPrimaryComputername_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.primary_name = _primary_name; + state->orig.in.Account = _Account; + state->orig.in.EncryptedPassword = _EncryptedPassword; + state->orig.in.Reserved = _Reserved; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrSetPrimaryComputername, &state->orig); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRSETPRIMARYCOMPUTERNAME, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrSetPrimaryComputername_done, req); + return req; +} + +static void rpccli_wkssvc_NetrSetPrimaryComputername_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrSetPrimaryComputername_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrSetPrimaryComputername_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrSetPrimaryComputername, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrSetPrimaryComputername_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrSetPrimaryComputername_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrSetPrimaryComputername_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrSetPrimaryComputername(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name /* [in] [unique,charset(UTF16)] */, @@ -1519,6 +5209,131 @@ NTSTATUS rpccli_wkssvc_NetrSetPrimaryComputername(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } +struct rpccli_wkssvc_NetrEnumerateComputerNames_state { + struct wkssvc_NetrEnumerateComputerNames orig; + struct wkssvc_NetrEnumerateComputerNames tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_wkssvc_NetrEnumerateComputerNames_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_wkssvc_NetrEnumerateComputerNames_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_server_name /* [in] [unique,charset(UTF16)] */, + enum wkssvc_ComputerNameType _name_type /* [in] */, + uint32_t _Reserved /* [in] */, + struct wkssvc_ComputerNamesCtr **_ctr /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_wkssvc_NetrEnumerateComputerNames_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_wkssvc_NetrEnumerateComputerNames_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.server_name = _server_name; + state->orig.in.name_type = _name_type; + state->orig.in.Reserved = _Reserved; + + /* Out parameters */ + state->orig.out.ctr = _ctr; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(wkssvc_NetrEnumerateComputerNames, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_wkssvc_NetrEnumerateComputerNames_out_memory"); + if (tevent_req_nomem(state->out_mem_ctx, req)) { + return tevent_req_post(req, ev); + } + + /* make a temporary copy, that we pass to the dispatch function */ + state->tmp = state->orig; + + subreq = cli->dispatch_send(state, ev, cli, + &ndr_table_wkssvc, + NDR_WKSSVC_NETRENUMERATECOMPUTERNAMES, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_wkssvc_NetrEnumerateComputerNames_done, req); + return req; +} + +static void rpccli_wkssvc_NetrEnumerateComputerNames_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_wkssvc_NetrEnumerateComputerNames_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrEnumerateComputerNames_state); + NTSTATUS status; + TALLOC_CTX *mem_ctx; + + if (state->out_mem_ctx) { + mem_ctx = state->out_mem_ctx; + } else { + mem_ctx = state; + } + + status = state->dispatch_recv(subreq, mem_ctx); + TALLOC_FREE(subreq); + if (!NT_STATUS_IS_OK(status)) { + tevent_req_nterror(req, status); + return; + } + + /* Copy out parameters */ + *state->orig.out.ctr = *state->tmp.out.ctr; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(wkssvc_NetrEnumerateComputerNames, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_wkssvc_NetrEnumerateComputerNames_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) +{ + struct rpccli_wkssvc_NetrEnumerateComputerNames_state *state = tevent_req_data( + req, struct rpccli_wkssvc_NetrEnumerateComputerNames_state); + NTSTATUS status; + + if (tevent_req_is_nterror(req, &status)) { + tevent_req_received(req); + return status; + } + + /* Steal possbile out parameters to the callers context */ + talloc_steal(mem_ctx, state->out_mem_ctx); + + /* Return result */ + *result = state->orig.out.result; + + tevent_req_received(req); + return NT_STATUS_OK; +} + NTSTATUS rpccli_wkssvc_NetrEnumerateComputerNames(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *server_name /* [in] [unique,charset(UTF16)] */, -- cgit