diff options
Diffstat (limited to 'librpc/gen_ndr/cli_lsa.c')
| -rw-r--r-- | librpc/gen_ndr/cli_lsa.c | 9832 |
1 files changed, 9832 insertions, 0 deletions
diff --git a/librpc/gen_ndr/cli_lsa.c b/librpc/gen_ndr/cli_lsa.c index 04cf38aaf3..bc51b71798 100644 --- a/librpc/gen_ndr/cli_lsa.c +++ b/librpc/gen_ndr/cli_lsa.c @@ -6,6 +6,126 @@ #include "includes.h" #include "../librpc/gen_ndr/cli_lsa.h" +struct rpccli_lsa_Close_state { + struct lsa_Close orig; + struct lsa_Close tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_Close_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_Close_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in,out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_Close_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_Close_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + + /* Out parameters */ + state->orig.out.handle = _handle; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_Close, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_Close_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_lsarpc, + NDR_LSA_CLOSE, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_Close_done, req); + return req; +} + +static void rpccli_lsa_Close_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_Close_state *state = tevent_req_data( + req, struct rpccli_lsa_Close_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.handle = *state->tmp.out.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(lsa_Close, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_Close_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_Close_state *state = tevent_req_data( + req, struct rpccli_lsa_Close_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_lsa_Close(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in,out] [ref] */) @@ -45,6 +165,118 @@ NTSTATUS rpccli_lsa_Close(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_Delete_state { + struct lsa_Delete orig; + struct lsa_Delete tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_Delete_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_Delete_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_Delete_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_Delete_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_Delete, &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_lsarpc, + NDR_LSA_DELETE, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_Delete_done, req); + return req; +} + +static void rpccli_lsa_Delete_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_Delete_state *state = tevent_req_data( + req, struct rpccli_lsa_Delete_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(lsa_Delete, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_Delete_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_Delete_state *state = tevent_req_data( + req, struct rpccli_lsa_Delete_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_lsa_Delete(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */) @@ -83,6 +315,133 @@ NTSTATUS rpccli_lsa_Delete(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_EnumPrivs_state { + struct lsa_EnumPrivs orig; + struct lsa_EnumPrivs tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_EnumPrivs_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_EnumPrivs_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + uint32_t *_resume_handle /* [in,out] [ref] */, + struct lsa_PrivArray *_privs /* [out] [ref] */, + uint32_t _max_count /* [in] */) +{ + struct tevent_req *req; + struct rpccli_lsa_EnumPrivs_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_EnumPrivs_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.resume_handle = _resume_handle; + state->orig.in.max_count = _max_count; + + /* Out parameters */ + state->orig.out.resume_handle = _resume_handle; + state->orig.out.privs = _privs; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_EnumPrivs, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_EnumPrivs_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_lsarpc, + NDR_LSA_ENUMPRIVS, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_EnumPrivs_done, req); + return req; +} + +static void rpccli_lsa_EnumPrivs_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_EnumPrivs_state *state = tevent_req_data( + req, struct rpccli_lsa_EnumPrivs_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.resume_handle = *state->tmp.out.resume_handle; + *state->orig.out.privs = *state->tmp.out.privs; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(lsa_EnumPrivs, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_EnumPrivs_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_EnumPrivs_state *state = tevent_req_data( + req, struct rpccli_lsa_EnumPrivs_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_lsa_EnumPrivs(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -128,6 +487,129 @@ NTSTATUS rpccli_lsa_EnumPrivs(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_QuerySecurity_state { + struct lsa_QuerySecurity orig; + struct lsa_QuerySecurity tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_QuerySecurity_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_QuerySecurity_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + uint32_t _sec_info /* [in] */, + struct sec_desc_buf **_sdbuf /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_QuerySecurity_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_QuerySecurity_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.sec_info = _sec_info; + + /* Out parameters */ + state->orig.out.sdbuf = _sdbuf; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_QuerySecurity, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_QuerySecurity_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_lsarpc, + NDR_LSA_QUERYSECURITY, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_QuerySecurity_done, req); + return req; +} + +static void rpccli_lsa_QuerySecurity_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_QuerySecurity_state *state = tevent_req_data( + req, struct rpccli_lsa_QuerySecurity_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.sdbuf = *state->tmp.out.sdbuf; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(lsa_QuerySecurity, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_QuerySecurity_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_QuerySecurity_state *state = tevent_req_data( + req, struct rpccli_lsa_QuerySecurity_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_lsa_QuerySecurity(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -170,6 +652,122 @@ NTSTATUS rpccli_lsa_QuerySecurity(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_SetSecObj_state { + struct lsa_SetSecObj orig; + struct lsa_SetSecObj tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_SetSecObj_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_SetSecObj_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + uint32_t _sec_info /* [in] */, + struct sec_desc_buf *_sdbuf /* [in] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_SetSecObj_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_SetSecObj_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.sec_info = _sec_info; + state->orig.in.sdbuf = _sdbuf; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_SetSecObj, &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_lsarpc, + NDR_LSA_SETSECOBJ, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_SetSecObj_done, req); + return req; +} + +static void rpccli_lsa_SetSecObj_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_SetSecObj_state *state = tevent_req_data( + req, struct rpccli_lsa_SetSecObj_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(lsa_SetSecObj, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_SetSecObj_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_SetSecObj_state *state = tevent_req_data( + req, struct rpccli_lsa_SetSecObj_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_lsa_SetSecObj(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -212,6 +810,116 @@ NTSTATUS rpccli_lsa_SetSecObj(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_ChangePassword_state { + struct lsa_ChangePassword orig; + struct lsa_ChangePassword tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_ChangePassword_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_ChangePassword_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_ChangePassword_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_ChangePassword_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_ChangePassword, &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_lsarpc, + NDR_LSA_CHANGEPASSWORD, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_ChangePassword_done, req); + return req; +} + +static void rpccli_lsa_ChangePassword_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_ChangePassword_state *state = tevent_req_data( + req, struct rpccli_lsa_ChangePassword_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(lsa_ChangePassword, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_ChangePassword_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_ChangePassword_state *state = tevent_req_data( + req, struct rpccli_lsa_ChangePassword_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_lsa_ChangePassword(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { @@ -248,6 +956,131 @@ NTSTATUS rpccli_lsa_ChangePassword(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_OpenPolicy_state { + struct lsa_OpenPolicy orig; + struct lsa_OpenPolicy tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_OpenPolicy_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_OpenPolicy_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + uint16_t *_system_name /* [in] [unique] */, + struct lsa_ObjectAttribute *_attr /* [in] [ref] */, + uint32_t _access_mask /* [in] */, + struct policy_handle *_handle /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_OpenPolicy_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_OpenPolicy_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.system_name = _system_name; + state->orig.in.attr = _attr; + state->orig.in.access_mask = _access_mask; + + /* Out parameters */ + state->orig.out.handle = _handle; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_OpenPolicy, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_OpenPolicy_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_lsarpc, + NDR_LSA_OPENPOLICY, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_OpenPolicy_done, req); + return req; +} + +static void rpccli_lsa_OpenPolicy_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_OpenPolicy_state *state = tevent_req_data( + req, struct rpccli_lsa_OpenPolicy_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.handle = *state->tmp.out.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(lsa_OpenPolicy, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_OpenPolicy_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_OpenPolicy_state *state = tevent_req_data( + req, struct rpccli_lsa_OpenPolicy_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_lsa_OpenPolicy(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint16_t *system_name /* [in] [unique] */, @@ -292,6 +1125,129 @@ NTSTATUS rpccli_lsa_OpenPolicy(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_QueryInfoPolicy_state { + struct lsa_QueryInfoPolicy orig; + struct lsa_QueryInfoPolicy tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_QueryInfoPolicy_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_QueryInfoPolicy_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + enum lsa_PolicyInfo _level /* [in] */, + union lsa_PolicyInformation **_info /* [out] [ref,switch_is(level)] */) +{ + struct tevent_req *req; + struct rpccli_lsa_QueryInfoPolicy_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_QueryInfoPolicy_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + 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(lsa_QueryInfoPolicy, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_QueryInfoPolicy_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_lsarpc, + NDR_LSA_QUERYINFOPOLICY, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_QueryInfoPolicy_done, req); + return req; +} + +static void rpccli_lsa_QueryInfoPolicy_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_QueryInfoPolicy_state *state = tevent_req_data( + req, struct rpccli_lsa_QueryInfoPolicy_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(lsa_QueryInfoPolicy, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_QueryInfoPolicy_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_QueryInfoPolicy_state *state = tevent_req_data( + req, struct rpccli_lsa_QueryInfoPolicy_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_lsa_QueryInfoPolicy(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -334,6 +1290,122 @@ NTSTATUS rpccli_lsa_QueryInfoPolicy(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_SetInfoPolicy_state { + struct lsa_SetInfoPolicy orig; + struct lsa_SetInfoPolicy tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_SetInfoPolicy_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_SetInfoPolicy_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + enum lsa_PolicyInfo _level /* [in] */, + union lsa_PolicyInformation *_info /* [in] [ref,switch_is(level)] */) +{ + struct tevent_req *req; + struct rpccli_lsa_SetInfoPolicy_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_SetInfoPolicy_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.level = _level; + state->orig.in.info = _info; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_SetInfoPolicy, &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_lsarpc, + NDR_LSA_SETINFOPOLICY, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_SetInfoPolicy_done, req); + return req; +} + +static void rpccli_lsa_SetInfoPolicy_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_SetInfoPolicy_state *state = tevent_req_data( + req, struct rpccli_lsa_SetInfoPolicy_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(lsa_SetInfoPolicy, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_SetInfoPolicy_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_SetInfoPolicy_state *state = tevent_req_data( + req, struct rpccli_lsa_SetInfoPolicy_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_lsa_SetInfoPolicy(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -376,6 +1448,116 @@ NTSTATUS rpccli_lsa_SetInfoPolicy(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_ClearAuditLog_state { + struct lsa_ClearAuditLog orig; + struct lsa_ClearAuditLog tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_ClearAuditLog_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_ClearAuditLog_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_ClearAuditLog_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_ClearAuditLog_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_ClearAuditLog, &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_lsarpc, + NDR_LSA_CLEARAUDITLOG, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_ClearAuditLog_done, req); + return req; +} + +static void rpccli_lsa_ClearAuditLog_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_ClearAuditLog_state *state = tevent_req_data( + req, struct rpccli_lsa_ClearAuditLog_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(lsa_ClearAuditLog, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_ClearAuditLog_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_ClearAuditLog_state *state = tevent_req_data( + req, struct rpccli_lsa_ClearAuditLog_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_lsa_ClearAuditLog(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { @@ -412,6 +1594,131 @@ NTSTATUS rpccli_lsa_ClearAuditLog(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_CreateAccount_state { + struct lsa_CreateAccount orig; + struct lsa_CreateAccount tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_CreateAccount_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_CreateAccount_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct dom_sid2 *_sid /* [in] [ref] */, + uint32_t _access_mask /* [in] */, + struct policy_handle *_acct_handle /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_CreateAccount_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_CreateAccount_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.sid = _sid; + state->orig.in.access_mask = _access_mask; + + /* Out parameters */ + state->orig.out.acct_handle = _acct_handle; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_CreateAccount, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_CreateAccount_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_lsarpc, + NDR_LSA_CREATEACCOUNT, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_CreateAccount_done, req); + return req; +} + +static void rpccli_lsa_CreateAccount_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_CreateAccount_state *state = tevent_req_data( + req, struct rpccli_lsa_CreateAccount_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.acct_handle = *state->tmp.out.acct_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(lsa_CreateAccount, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_CreateAccount_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_CreateAccount_state *state = tevent_req_data( + req, struct rpccli_lsa_CreateAccount_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_lsa_CreateAccount(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -456,6 +1763,133 @@ NTSTATUS rpccli_lsa_CreateAccount(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_EnumAccounts_state { + struct lsa_EnumAccounts orig; + struct lsa_EnumAccounts tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_EnumAccounts_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_EnumAccounts_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + uint32_t *_resume_handle /* [in,out] [ref] */, + struct lsa_SidArray *_sids /* [out] [ref] */, + uint32_t _num_entries /* [in] [range(0,8192)] */) +{ + struct tevent_req *req; + struct rpccli_lsa_EnumAccounts_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_EnumAccounts_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.resume_handle = _resume_handle; + state->orig.in.num_entries = _num_entries; + + /* Out parameters */ + state->orig.out.resume_handle = _resume_handle; + state->orig.out.sids = _sids; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_EnumAccounts, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_EnumAccounts_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_lsarpc, + NDR_LSA_ENUMACCOUNTS, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_EnumAccounts_done, req); + return req; +} + +static void rpccli_lsa_EnumAccounts_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_EnumAccounts_state *state = tevent_req_data( + req, struct rpccli_lsa_EnumAccounts_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.resume_handle = *state->tmp.out.resume_handle; + *state->orig.out.sids = *state->tmp.out.sids; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(lsa_EnumAccounts, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_EnumAccounts_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_EnumAccounts_state *state = tevent_req_data( + req, struct rpccli_lsa_EnumAccounts_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_lsa_EnumAccounts(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -501,6 +1935,131 @@ NTSTATUS rpccli_lsa_EnumAccounts(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_CreateTrustedDomain_state { + struct lsa_CreateTrustedDomain orig; + struct lsa_CreateTrustedDomain tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_CreateTrustedDomain_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_CreateTrustedDomain_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_policy_handle /* [in] [ref] */, + struct lsa_DomainInfo *_info /* [in] [ref] */, + uint32_t _access_mask /* [in] */, + struct policy_handle *_trustdom_handle /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_CreateTrustedDomain_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_CreateTrustedDomain_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.policy_handle = _policy_handle; + state->orig.in.info = _info; + state->orig.in.access_mask = _access_mask; + + /* Out parameters */ + state->orig.out.trustdom_handle = _trustdom_handle; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomain, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_CreateTrustedDomain_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_lsarpc, + NDR_LSA_CREATETRUSTEDDOMAIN, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_CreateTrustedDomain_done, req); + return req; +} + +static void rpccli_lsa_CreateTrustedDomain_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_CreateTrustedDomain_state *state = tevent_req_data( + req, struct rpccli_lsa_CreateTrustedDomain_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.trustdom_handle = *state->tmp.out.trustdom_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(lsa_CreateTrustedDomain, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_CreateTrustedDomain_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_CreateTrustedDomain_state *state = tevent_req_data( + req, struct rpccli_lsa_CreateTrustedDomain_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_lsa_CreateTrustedDomain(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *policy_handle /* [in] [ref] */, @@ -545,6 +2104,133 @@ NTSTATUS rpccli_lsa_CreateTrustedDomain(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_EnumTrustDom_state { + struct lsa_EnumTrustDom orig; + struct lsa_EnumTrustDom tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_EnumTrustDom_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_EnumTrustDom_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + uint32_t *_resume_handle /* [in,out] [ref] */, + struct lsa_DomainList *_domains /* [out] [ref] */, + uint32_t _max_size /* [in] */) +{ + struct tevent_req *req; + struct rpccli_lsa_EnumTrustDom_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_EnumTrustDom_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.resume_handle = _resume_handle; + state->orig.in.max_size = _max_size; + + /* Out parameters */ + state->orig.out.resume_handle = _resume_handle; + state->orig.out.domains = _domains; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_EnumTrustDom, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_EnumTrustDom_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_lsarpc, + NDR_LSA_ENUMTRUSTDOM, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_EnumTrustDom_done, req); + return req; +} + +static void rpccli_lsa_EnumTrustDom_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_EnumTrustDom_state *state = tevent_req_data( + req, struct rpccli_lsa_EnumTrustDom_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.resume_handle = *state->tmp.out.resume_handle; + *state->orig.out.domains = *state->tmp.out.domains; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(lsa_EnumTrustDom, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_EnumTrustDom_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_EnumTrustDom_state *state = tevent_req_data( + req, struct rpccli_lsa_EnumTrustDom_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_lsa_EnumTrustDom(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -590,6 +2276,141 @@ NTSTATUS rpccli_lsa_EnumTrustDom(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_LookupNames_state { + struct lsa_LookupNames orig; + struct lsa_LookupNames tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_LookupNames_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_LookupNames_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + uint32_t _num_names /* [in] [range(0,1000)] */, + struct lsa_String *_names /* [in] [size_is(num_names)] */, + struct lsa_RefDomainList **_domains /* [out] [ref] */, + struct lsa_TransSidArray *_sids /* [in,out] [ref] */, + enum lsa_LookupNamesLevel _level /* [in] */, + uint32_t *_count /* [in,out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_LookupNames_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_LookupNames_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.num_names = _num_names; + state->orig.in.names = _names; + state->orig.in.sids = _sids; + state->orig.in.level = _level; + state->orig.in.count = _count; + + /* Out parameters */ + state->orig.out.domains = _domains; + state->orig.out.sids = _sids; + state->orig.out.count = _count; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_LookupNames, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_LookupNames_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_lsarpc, + NDR_LSA_LOOKUPNAMES, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_LookupNames_done, req); + return req; +} + +static void rpccli_lsa_LookupNames_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_LookupNames_state *state = tevent_req_data( + req, struct rpccli_lsa_LookupNames_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.domains = *state->tmp.out.domains; + *state->orig.out.sids = *state->tmp.out.sids; + *state->orig.out.count = *state->tmp.out.count; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(lsa_LookupNames, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_LookupNames_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_LookupNames_state *state = tevent_req_data( + req, struct rpccli_lsa_LookupNames_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_lsa_LookupNames(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -642,6 +2463,139 @@ NTSTATUS rpccli_lsa_LookupNames(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_LookupSids_state { + struct lsa_LookupSids orig; + struct lsa_LookupSids tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_LookupSids_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_LookupSids_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct lsa_SidArray *_sids /* [in] [ref] */, + struct lsa_RefDomainList **_domains /* [out] [ref] */, + struct lsa_TransNameArray *_names /* [in,out] [ref] */, + uint16_t _level /* [in] */, + uint32_t *_count /* [in,out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_LookupSids_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_LookupSids_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.sids = _sids; + state->orig.in.names = _names; + state->orig.in.level = _level; + state->orig.in.count = _count; + + /* Out parameters */ + state->orig.out.domains = _domains; + state->orig.out.names = _names; + state->orig.out.count = _count; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_LookupSids, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_LookupSids_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_lsarpc, + NDR_LSA_LOOKUPSIDS, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_LookupSids_done, req); + return req; +} + +static void rpccli_lsa_LookupSids_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_LookupSids_state *state = tevent_req_data( + req, struct rpccli_lsa_LookupSids_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.domains = *state->tmp.out.domains; + *state->orig.out.names = *state->tmp.out.names; + *state->orig.out.count = *state->tmp.out.count; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(lsa_LookupSids, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_LookupSids_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_LookupSids_state *state = tevent_req_data( + req, struct rpccli_lsa_LookupSids_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_lsa_LookupSids(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -692,6 +2646,131 @@ NTSTATUS rpccli_lsa_LookupSids(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_CreateSecret_state { + struct lsa_CreateSecret orig; + struct lsa_CreateSecret tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_CreateSecret_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_CreateSecret_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct lsa_String _name /* [in] */, + uint32_t _access_mask /* [in] */, + struct policy_handle *_sec_handle /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_CreateSecret_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_CreateSecret_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.name = _name; + state->orig.in.access_mask = _access_mask; + + /* Out parameters */ + state->orig.out.sec_handle = _sec_handle; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_CreateSecret, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_CreateSecret_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_lsarpc, + NDR_LSA_CREATESECRET, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_CreateSecret_done, req); + return req; +} + +static void rpccli_lsa_CreateSecret_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_CreateSecret_state *state = tevent_req_data( + req, struct rpccli_lsa_CreateSecret_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.sec_handle = *state->tmp.out.sec_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(lsa_CreateSecret, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_CreateSecret_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_CreateSecret_state *state = tevent_req_data( + req, struct rpccli_lsa_CreateSecret_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_lsa_CreateSecret(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -736,6 +2815,131 @@ NTSTATUS rpccli_lsa_CreateSecret(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_OpenAccount_state { + struct lsa_OpenAccount orig; + struct lsa_OpenAccount tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_OpenAccount_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_OpenAccount_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct dom_sid2 *_sid /* [in] [ref] */, + uint32_t _access_mask /* [in] */, + struct policy_handle *_acct_handle /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_OpenAccount_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_OpenAccount_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.sid = _sid; + state->orig.in.access_mask = _access_mask; + + /* Out parameters */ + state->orig.out.acct_handle = _acct_handle; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_OpenAccount, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_OpenAccount_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_lsarpc, + NDR_LSA_OPENACCOUNT, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_OpenAccount_done, req); + return req; +} + +static void rpccli_lsa_OpenAccount_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_OpenAccount_state *state = tevent_req_data( + req, struct rpccli_lsa_OpenAccount_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.acct_handle = *state->tmp.out.acct_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(lsa_OpenAccount, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_OpenAccount_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_OpenAccount_state *state = tevent_req_data( + req, struct rpccli_lsa_OpenAccount_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_lsa_OpenAccount(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -780,6 +2984,127 @@ NTSTATUS rpccli_lsa_OpenAccount(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_EnumPrivsAccount_state { + struct lsa_EnumPrivsAccount orig; + struct lsa_EnumPrivsAccount tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_EnumPrivsAccount_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_EnumPrivsAccount_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct lsa_PrivilegeSet **_privs /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_EnumPrivsAccount_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_EnumPrivsAccount_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + + /* Out parameters */ + state->orig.out.privs = _privs; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_EnumPrivsAccount, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_EnumPrivsAccount_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_lsarpc, + NDR_LSA_ENUMPRIVSACCOUNT, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_EnumPrivsAccount_done, req); + return req; +} + +static void rpccli_lsa_EnumPrivsAccount_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_EnumPrivsAccount_state *state = tevent_req_data( + req, struct rpccli_lsa_EnumPrivsAccount_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.privs = *state->tmp.out.privs; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(lsa_EnumPrivsAccount, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_EnumPrivsAccount_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_EnumPrivsAccount_state *state = tevent_req_data( + req, struct rpccli_lsa_EnumPrivsAccount_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_lsa_EnumPrivsAccount(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -820,6 +3145,120 @@ NTSTATUS rpccli_lsa_EnumPrivsAccount(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_AddPrivilegesToAccount_state { + struct lsa_AddPrivilegesToAccount orig; + struct lsa_AddPrivilegesToAccount tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_AddPrivilegesToAccount_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_AddPrivilegesToAccount_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct lsa_PrivilegeSet *_privs /* [in] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_AddPrivilegesToAccount_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_AddPrivilegesToAccount_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.privs = _privs; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_AddPrivilegesToAccount, &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_lsarpc, + NDR_LSA_ADDPRIVILEGESTOACCOUNT, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_AddPrivilegesToAccount_done, req); + return req; +} + +static void rpccli_lsa_AddPrivilegesToAccount_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_AddPrivilegesToAccount_state *state = tevent_req_data( + req, struct rpccli_lsa_AddPrivilegesToAccount_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(lsa_AddPrivilegesToAccount, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_AddPrivilegesToAccount_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_AddPrivilegesToAccount_state *state = tevent_req_data( + req, struct rpccli_lsa_AddPrivilegesToAccount_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_lsa_AddPrivilegesToAccount(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -860,6 +3299,122 @@ NTSTATUS rpccli_lsa_AddPrivilegesToAccount(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_RemovePrivilegesFromAccount_state { + struct lsa_RemovePrivilegesFromAccount orig; + struct lsa_RemovePrivilegesFromAccount tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_RemovePrivilegesFromAccount_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_RemovePrivilegesFromAccount_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + uint8_t _remove_all /* [in] */, + struct lsa_PrivilegeSet *_privs /* [in] [unique] */) +{ + struct tevent_req *req; + struct rpccli_lsa_RemovePrivilegesFromAccount_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_RemovePrivilegesFromAccount_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.remove_all = _remove_all; + state->orig.in.privs = _privs; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_RemovePrivilegesFromAccount, &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_lsarpc, + NDR_LSA_REMOVEPRIVILEGESFROMACCOUNT, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_RemovePrivilegesFromAccount_done, req); + return req; +} + +static void rpccli_lsa_RemovePrivilegesFromAccount_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_RemovePrivilegesFromAccount_state *state = tevent_req_data( + req, struct rpccli_lsa_RemovePrivilegesFromAccount_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(lsa_RemovePrivilegesFromAccount, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_RemovePrivilegesFromAccount_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_RemovePrivilegesFromAccount_state *state = tevent_req_data( + req, struct rpccli_lsa_RemovePrivilegesFromAccount_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_lsa_RemovePrivilegesFromAccount(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -902,6 +3457,116 @@ NTSTATUS rpccli_lsa_RemovePrivilegesFromAccount(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_GetQuotasForAccount_state { + struct lsa_GetQuotasForAccount orig; + struct lsa_GetQuotasForAccount tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_GetQuotasForAccount_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_GetQuotasForAccount_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_GetQuotasForAccount_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_GetQuotasForAccount_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_GetQuotasForAccount, &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_lsarpc, + NDR_LSA_GETQUOTASFORACCOUNT, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_GetQuotasForAccount_done, req); + return req; +} + +static void rpccli_lsa_GetQuotasForAccount_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_GetQuotasForAccount_state *state = tevent_req_data( + req, struct rpccli_lsa_GetQuotasForAccount_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(lsa_GetQuotasForAccount, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_GetQuotasForAccount_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_GetQuotasForAccount_state *state = tevent_req_data( + req, struct rpccli_lsa_GetQuotasForAccount_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_lsa_GetQuotasForAccount(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { @@ -938,6 +3603,116 @@ NTSTATUS rpccli_lsa_GetQuotasForAccount(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_SetQuotasForAccount_state { + struct lsa_SetQuotasForAccount orig; + struct lsa_SetQuotasForAccount tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_SetQuotasForAccount_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_SetQuotasForAccount_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_SetQuotasForAccount_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_SetQuotasForAccount_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_SetQuotasForAccount, &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_lsarpc, + NDR_LSA_SETQUOTASFORACCOUNT, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_SetQuotasForAccount_done, req); + return req; +} + +static void rpccli_lsa_SetQuotasForAccount_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_SetQuotasForAccount_state *state = tevent_req_data( + req, struct rpccli_lsa_SetQuotasForAccount_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(lsa_SetQuotasForAccount, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_SetQuotasForAccount_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_SetQuotasForAccount_state *state = tevent_req_data( + req, struct rpccli_lsa_SetQuotasForAccount_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_lsa_SetQuotasForAccount(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { @@ -974,6 +3749,127 @@ NTSTATUS rpccli_lsa_SetQuotasForAccount(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_GetSystemAccessAccount_state { + struct lsa_GetSystemAccessAccount orig; + struct lsa_GetSystemAccessAccount tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_GetSystemAccessAccount_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_GetSystemAccessAccount_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + uint32_t *_access_mask /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_GetSystemAccessAccount_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_GetSystemAccessAccount_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + + /* Out parameters */ + state->orig.out.access_mask = _access_mask; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_GetSystemAccessAccount, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_GetSystemAccessAccount_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_lsarpc, + NDR_LSA_GETSYSTEMACCESSACCOUNT, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_GetSystemAccessAccount_done, req); + return req; +} + +static void rpccli_lsa_GetSystemAccessAccount_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_GetSystemAccessAccount_state *state = tevent_req_data( + req, struct rpccli_lsa_GetSystemAccessAccount_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.access_mask = *state->tmp.out.access_mask; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(lsa_GetSystemAccessAccount, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_GetSystemAccessAccount_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_GetSystemAccessAccount_state *state = tevent_req_data( + req, struct rpccli_lsa_GetSystemAccessAccount_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_lsa_GetSystemAccessAccount(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -1014,6 +3910,120 @@ NTSTATUS rpccli_lsa_GetSystemAccessAccount(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_SetSystemAccessAccount_state { + struct lsa_SetSystemAccessAccount orig; + struct lsa_SetSystemAccessAccount tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_SetSystemAccessAccount_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_SetSystemAccessAccount_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + uint32_t _access_mask /* [in] */) +{ + struct tevent_req *req; + struct rpccli_lsa_SetSystemAccessAccount_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_SetSystemAccessAccount_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.access_mask = _access_mask; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_SetSystemAccessAccount, &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_lsarpc, + NDR_LSA_SETSYSTEMACCESSACCOUNT, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_SetSystemAccessAccount_done, req); + return req; +} + +static void rpccli_lsa_SetSystemAccessAccount_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_SetSystemAccessAccount_state *state = tevent_req_data( + req, struct rpccli_lsa_SetSystemAccessAccount_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(lsa_SetSystemAccessAccount, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_SetSystemAccessAccount_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_SetSystemAccessAccount_state *state = tevent_req_data( + req, struct rpccli_lsa_SetSystemAccessAccount_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_lsa_SetSystemAccessAccount(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -1054,6 +4064,131 @@ NTSTATUS rpccli_lsa_SetSystemAccessAccount(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_OpenTrustedDomain_state { + struct lsa_OpenTrustedDomain orig; + struct lsa_OpenTrustedDomain tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_OpenTrustedDomain_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_OpenTrustedDomain_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct dom_sid2 *_sid /* [in] [ref] */, + uint32_t _access_mask /* [in] */, + struct policy_handle *_trustdom_handle /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_OpenTrustedDomain_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_OpenTrustedDomain_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.sid = _sid; + state->orig.in.access_mask = _access_mask; + + /* Out parameters */ + state->orig.out.trustdom_handle = _trustdom_handle; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_OpenTrustedDomain, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_OpenTrustedDomain_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_lsarpc, + NDR_LSA_OPENTRUSTEDDOMAIN, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_OpenTrustedDomain_done, req); + return req; +} + +static void rpccli_lsa_OpenTrustedDomain_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_OpenTrustedDomain_state *state = tevent_req_data( + req, struct rpccli_lsa_OpenTrustedDomain_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.trustdom_handle = *state->tmp.out.trustdom_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(lsa_OpenTrustedDomain, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_OpenTrustedDomain_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_OpenTrustedDomain_state *state = tevent_req_data( + req, struct rpccli_lsa_OpenTrustedDomain_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_lsa_OpenTrustedDomain(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -1098,6 +4233,129 @@ NTSTATUS rpccli_lsa_OpenTrustedDomain(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_QueryTrustedDomainInfo_state { + struct lsa_QueryTrustedDomainInfo orig; + struct lsa_QueryTrustedDomainInfo tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_QueryTrustedDomainInfo_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_QueryTrustedDomainInfo_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_trustdom_handle /* [in] [ref] */, + enum lsa_TrustDomInfoEnum _level /* [in] */, + union lsa_TrustedDomainInfo **_info /* [out] [ref,switch_is(level)] */) +{ + struct tevent_req *req; + struct rpccli_lsa_QueryTrustedDomainInfo_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_QueryTrustedDomainInfo_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.trustdom_handle = _trustdom_handle; + 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(lsa_QueryTrustedDomainInfo, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_QueryTrustedDomainInfo_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_lsarpc, + NDR_LSA_QUERYTRUSTEDDOMAININFO, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_QueryTrustedDomainInfo_done, req); + return req; +} + +static void rpccli_lsa_QueryTrustedDomainInfo_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_QueryTrustedDomainInfo_state *state = tevent_req_data( + req, struct rpccli_lsa_QueryTrustedDomainInfo_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(lsa_QueryTrustedDomainInfo, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_QueryTrustedDomainInfo_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_QueryTrustedDomainInfo_state *state = tevent_req_data( + req, struct rpccli_lsa_QueryTrustedDomainInfo_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_lsa_QueryTrustedDomainInfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *trustdom_handle /* [in] [ref] */, @@ -1140,6 +4398,122 @@ NTSTATUS rpccli_lsa_QueryTrustedDomainInfo(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_SetInformationTrustedDomain_state { + struct lsa_SetInformationTrustedDomain orig; + struct lsa_SetInformationTrustedDomain tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_SetInformationTrustedDomain_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_SetInformationTrustedDomain_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_trustdom_handle /* [in] [ref] */, + enum lsa_TrustDomInfoEnum _level /* [in] */, + union lsa_TrustedDomainInfo *_info /* [in] [ref,switch_is(level)] */) +{ + struct tevent_req *req; + struct rpccli_lsa_SetInformationTrustedDomain_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_SetInformationTrustedDomain_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.trustdom_handle = _trustdom_handle; + state->orig.in.level = _level; + state->orig.in.info = _info; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_SetInformationTrustedDomain, &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_lsarpc, + NDR_LSA_SETINFORMATIONTRUSTEDDOMAIN, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_SetInformationTrustedDomain_done, req); + return req; +} + +static void rpccli_lsa_SetInformationTrustedDomain_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_SetInformationTrustedDomain_state *state = tevent_req_data( + req, struct rpccli_lsa_SetInformationTrustedDomain_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(lsa_SetInformationTrustedDomain, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_SetInformationTrustedDomain_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_SetInformationTrustedDomain_state *state = tevent_req_data( + req, struct rpccli_lsa_SetInformationTrustedDomain_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_lsa_SetInformationTrustedDomain(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *trustdom_handle /* [in] [ref] */, @@ -1182,6 +4556,131 @@ NTSTATUS rpccli_lsa_SetInformationTrustedDomain(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_OpenSecret_state { + struct lsa_OpenSecret orig; + struct lsa_OpenSecret tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_OpenSecret_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_OpenSecret_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct lsa_String _name /* [in] */, + uint32_t _access_mask /* [in] */, + struct policy_handle *_sec_handle /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_OpenSecret_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_OpenSecret_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.name = _name; + state->orig.in.access_mask = _access_mask; + + /* Out parameters */ + state->orig.out.sec_handle = _sec_handle; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_OpenSecret, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_OpenSecret_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_lsarpc, + NDR_LSA_OPENSECRET, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_OpenSecret_done, req); + return req; +} + +static void rpccli_lsa_OpenSecret_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_OpenSecret_state *state = tevent_req_data( + req, struct rpccli_lsa_OpenSecret_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.sec_handle = *state->tmp.out.sec_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(lsa_OpenSecret, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_OpenSecret_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_OpenSecret_state *state = tevent_req_data( + req, struct rpccli_lsa_OpenSecret_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_lsa_OpenSecret(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -1226,6 +4725,122 @@ NTSTATUS rpccli_lsa_OpenSecret(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_SetSecret_state { + struct lsa_SetSecret orig; + struct lsa_SetSecret tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_SetSecret_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_SetSecret_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_sec_handle /* [in] [ref] */, + struct lsa_DATA_BUF *_new_val /* [in] [unique] */, + struct lsa_DATA_BUF *_old_val /* [in] [unique] */) +{ + struct tevent_req *req; + struct rpccli_lsa_SetSecret_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_SetSecret_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.sec_handle = _sec_handle; + state->orig.in.new_val = _new_val; + state->orig.in.old_val = _old_val; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_SetSecret, &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_lsarpc, + NDR_LSA_SETSECRET, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_SetSecret_done, req); + return req; +} + +static void rpccli_lsa_SetSecret_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_SetSecret_state *state = tevent_req_data( + req, struct rpccli_lsa_SetSecret_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(lsa_SetSecret, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_SetSecret_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_SetSecret_state *state = tevent_req_data( + req, struct rpccli_lsa_SetSecret_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_lsa_SetSecret(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *sec_handle /* [in] [ref] */, @@ -1268,6 +4883,148 @@ NTSTATUS rpccli_lsa_SetSecret(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_QuerySecret_state { + struct lsa_QuerySecret orig; + struct lsa_QuerySecret tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_QuerySecret_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_QuerySecret_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_sec_handle /* [in] [ref] */, + struct lsa_DATA_BUF_PTR *_new_val /* [in,out] [unique] */, + NTTIME *_new_mtime /* [in,out] [unique] */, + struct lsa_DATA_BUF_PTR *_old_val /* [in,out] [unique] */, + NTTIME *_old_mtime /* [in,out] [unique] */) +{ + struct tevent_req *req; + struct rpccli_lsa_QuerySecret_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_QuerySecret_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.sec_handle = _sec_handle; + state->orig.in.new_val = _new_val; + state->orig.in.new_mtime = _new_mtime; + state->orig.in.old_val = _old_val; + state->orig.in.old_mtime = _old_mtime; + + /* Out parameters */ + state->orig.out.new_val = _new_val; + state->orig.out.new_mtime = _new_mtime; + state->orig.out.old_val = _old_val; + state->orig.out.old_mtime = _old_mtime; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_QuerySecret, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_QuerySecret_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_lsarpc, + NDR_LSA_QUERYSECRET, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_QuerySecret_done, req); + return req; +} + +static void rpccli_lsa_QuerySecret_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_QuerySecret_state *state = tevent_req_data( + req, struct rpccli_lsa_QuerySecret_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.new_val && state->tmp.out.new_val) { + *state->orig.out.new_val = *state->tmp.out.new_val; + } + if (state->orig.out.new_mtime && state->tmp.out.new_mtime) { + *state->orig.out.new_mtime = *state->tmp.out.new_mtime; + } + if (state->orig.out.old_val && state->tmp.out.old_val) { + *state->orig.out.old_val = *state->tmp.out.old_val; + } + if (state->orig.out.old_mtime && state->tmp.out.old_mtime) { + *state->orig.out.old_mtime = *state->tmp.out.old_mtime; + } + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(lsa_QuerySecret, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_QuerySecret_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_QuerySecret_state *state = tevent_req_data( + req, struct rpccli_lsa_QuerySecret_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_lsa_QuerySecret(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *sec_handle /* [in] [ref] */, @@ -1326,6 +5083,129 @@ NTSTATUS rpccli_lsa_QuerySecret(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_LookupPrivValue_state { + struct lsa_LookupPrivValue orig; + struct lsa_LookupPrivValue tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_LookupPrivValue_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_LookupPrivValue_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct lsa_String *_name /* [in] [ref] */, + struct lsa_LUID *_luid /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_LookupPrivValue_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_LookupPrivValue_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.name = _name; + + /* Out parameters */ + state->orig.out.luid = _luid; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_LookupPrivValue, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_LookupPrivValue_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_lsarpc, + NDR_LSA_LOOKUPPRIVVALUE, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_LookupPrivValue_done, req); + return req; +} + +static void rpccli_lsa_LookupPrivValue_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_LookupPrivValue_state *state = tevent_req_data( + req, struct rpccli_lsa_LookupPrivValue_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.luid = *state->tmp.out.luid; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(lsa_LookupPrivValue, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_LookupPrivValue_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_LookupPrivValue_state *state = tevent_req_data( + req, struct rpccli_lsa_LookupPrivValue_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_lsa_LookupPrivValue(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -1368,6 +5248,129 @@ NTSTATUS rpccli_lsa_LookupPrivValue(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_LookupPrivName_state { + struct lsa_LookupPrivName orig; + struct lsa_LookupPrivName tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_LookupPrivName_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_LookupPrivName_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct lsa_LUID *_luid /* [in] [ref] */, + struct lsa_StringLarge **_name /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_LookupPrivName_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_LookupPrivName_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.luid = _luid; + + /* Out parameters */ + state->orig.out.name = _name; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_LookupPrivName, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_LookupPrivName_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_lsarpc, + NDR_LSA_LOOKUPPRIVNAME, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_LookupPrivName_done, req); + return req; +} + +static void rpccli_lsa_LookupPrivName_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_LookupPrivName_state *state = tevent_req_data( + req, struct rpccli_lsa_LookupPrivName_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.name = *state->tmp.out.name; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(lsa_LookupPrivName, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_LookupPrivName_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_LookupPrivName_state *state = tevent_req_data( + req, struct rpccli_lsa_LookupPrivName_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_lsa_LookupPrivName(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -1410,6 +5413,136 @@ NTSTATUS rpccli_lsa_LookupPrivName(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_LookupPrivDisplayName_state { + struct lsa_LookupPrivDisplayName orig; + struct lsa_LookupPrivDisplayName tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_LookupPrivDisplayName_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_LookupPrivDisplayName_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct lsa_String *_name /* [in] [ref] */, + uint16_t _language_id /* [in] */, + uint16_t _language_id_sys /* [in] */, + struct lsa_StringLarge **_disp_name /* [out] [ref] */, + uint16_t *_returned_language_id /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_LookupPrivDisplayName_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_LookupPrivDisplayName_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.name = _name; + state->orig.in.language_id = _language_id; + state->orig.in.language_id_sys = _language_id_sys; + + /* Out parameters */ + state->orig.out.disp_name = _disp_name; + state->orig.out.returned_language_id = _returned_language_id; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_LookupPrivDisplayName, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_LookupPrivDisplayName_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_lsarpc, + NDR_LSA_LOOKUPPRIVDISPLAYNAME, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_LookupPrivDisplayName_done, req); + return req; +} + +static void rpccli_lsa_LookupPrivDisplayName_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_LookupPrivDisplayName_state *state = tevent_req_data( + req, struct rpccli_lsa_LookupPrivDisplayName_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.disp_name = *state->tmp.out.disp_name; + *state->orig.out.returned_language_id = *state->tmp.out.returned_language_id; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(lsa_LookupPrivDisplayName, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_LookupPrivDisplayName_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_LookupPrivDisplayName_state *state = tevent_req_data( + req, struct rpccli_lsa_LookupPrivDisplayName_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_lsa_LookupPrivDisplayName(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -1458,6 +5591,126 @@ NTSTATUS rpccli_lsa_LookupPrivDisplayName(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_DeleteObject_state { + struct lsa_DeleteObject orig; + struct lsa_DeleteObject tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_DeleteObject_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_DeleteObject_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in,out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_DeleteObject_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_DeleteObject_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + + /* Out parameters */ + state->orig.out.handle = _handle; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_DeleteObject, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_DeleteObject_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_lsarpc, + NDR_LSA_DELETEOBJECT, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_DeleteObject_done, req); + return req; +} + +static void rpccli_lsa_DeleteObject_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_DeleteObject_state *state = tevent_req_data( + req, struct rpccli_lsa_DeleteObject_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.handle = *state->tmp.out.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(lsa_DeleteObject, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_DeleteObject_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_DeleteObject_state *state = tevent_req_data( + req, struct rpccli_lsa_DeleteObject_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_lsa_DeleteObject(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in,out] [ref] */) @@ -1497,6 +5750,129 @@ NTSTATUS rpccli_lsa_DeleteObject(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_EnumAccountsWithUserRight_state { + struct lsa_EnumAccountsWithUserRight orig; + struct lsa_EnumAccountsWithUserRight tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_EnumAccountsWithUserRight_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_EnumAccountsWithUserRight_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct lsa_String *_name /* [in] [unique] */, + struct lsa_SidArray *_sids /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_EnumAccountsWithUserRight_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_EnumAccountsWithUserRight_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.name = _name; + + /* Out parameters */ + state->orig.out.sids = _sids; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_EnumAccountsWithUserRight, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_EnumAccountsWithUserRight_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_lsarpc, + NDR_LSA_ENUMACCOUNTSWITHUSERRIGHT, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_EnumAccountsWithUserRight_done, req); + return req; +} + +static void rpccli_lsa_EnumAccountsWithUserRight_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_EnumAccountsWithUserRight_state *state = tevent_req_data( + req, struct rpccli_lsa_EnumAccountsWithUserRight_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.sids = *state->tmp.out.sids; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(lsa_EnumAccountsWithUserRight, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_EnumAccountsWithUserRight_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_EnumAccountsWithUserRight_state *state = tevent_req_data( + req, struct rpccli_lsa_EnumAccountsWithUserRight_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_lsa_EnumAccountsWithUserRight(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -1539,6 +5915,129 @@ NTSTATUS rpccli_lsa_EnumAccountsWithUserRight(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_EnumAccountRights_state { + struct lsa_EnumAccountRights orig; + struct lsa_EnumAccountRights tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_EnumAccountRights_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_EnumAccountRights_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct dom_sid2 *_sid /* [in] [ref] */, + struct lsa_RightSet *_rights /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_EnumAccountRights_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_EnumAccountRights_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.sid = _sid; + + /* Out parameters */ + state->orig.out.rights = _rights; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_EnumAccountRights, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_EnumAccountRights_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_lsarpc, + NDR_LSA_ENUMACCOUNTRIGHTS, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_EnumAccountRights_done, req); + return req; +} + +static void rpccli_lsa_EnumAccountRights_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_EnumAccountRights_state *state = tevent_req_data( + req, struct rpccli_lsa_EnumAccountRights_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.rights = *state->tmp.out.rights; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(lsa_EnumAccountRights, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_EnumAccountRights_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_EnumAccountRights_state *state = tevent_req_data( + req, struct rpccli_lsa_EnumAccountRights_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_lsa_EnumAccountRights(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -1581,6 +6080,122 @@ NTSTATUS rpccli_lsa_EnumAccountRights(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_AddAccountRights_state { + struct lsa_AddAccountRights orig; + struct lsa_AddAccountRights tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_AddAccountRights_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_AddAccountRights_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct dom_sid2 *_sid /* [in] [ref] */, + struct lsa_RightSet *_rights /* [in] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_AddAccountRights_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_AddAccountRights_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.sid = _sid; + state->orig.in.rights = _rights; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_AddAccountRights, &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_lsarpc, + NDR_LSA_ADDACCOUNTRIGHTS, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_AddAccountRights_done, req); + return req; +} + +static void rpccli_lsa_AddAccountRights_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_AddAccountRights_state *state = tevent_req_data( + req, struct rpccli_lsa_AddAccountRights_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(lsa_AddAccountRights, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_AddAccountRights_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_AddAccountRights_state *state = tevent_req_data( + req, struct rpccli_lsa_AddAccountRights_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_lsa_AddAccountRights(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -1623,6 +6238,124 @@ NTSTATUS rpccli_lsa_AddAccountRights(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_RemoveAccountRights_state { + struct lsa_RemoveAccountRights orig; + struct lsa_RemoveAccountRights tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_RemoveAccountRights_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_RemoveAccountRights_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct dom_sid2 *_sid /* [in] [ref] */, + uint8_t _remove_all /* [in] */, + struct lsa_RightSet *_rights /* [in] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_RemoveAccountRights_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_RemoveAccountRights_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.sid = _sid; + state->orig.in.remove_all = _remove_all; + state->orig.in.rights = _rights; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_RemoveAccountRights, &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_lsarpc, + NDR_LSA_REMOVEACCOUNTRIGHTS, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_RemoveAccountRights_done, req); + return req; +} + +static void rpccli_lsa_RemoveAccountRights_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_RemoveAccountRights_state *state = tevent_req_data( + req, struct rpccli_lsa_RemoveAccountRights_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(lsa_RemoveAccountRights, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_RemoveAccountRights_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_RemoveAccountRights_state *state = tevent_req_data( + req, struct rpccli_lsa_RemoveAccountRights_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_lsa_RemoveAccountRights(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -1667,6 +6400,131 @@ NTSTATUS rpccli_lsa_RemoveAccountRights(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_QueryTrustedDomainInfoBySid_state { + struct lsa_QueryTrustedDomainInfoBySid orig; + struct lsa_QueryTrustedDomainInfoBySid tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_QueryTrustedDomainInfoBySid_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_QueryTrustedDomainInfoBySid_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct dom_sid2 *_dom_sid /* [in] [ref] */, + enum lsa_TrustDomInfoEnum _level /* [in] */, + union lsa_TrustedDomainInfo **_info /* [out] [ref,switch_is(level)] */) +{ + struct tevent_req *req; + struct rpccli_lsa_QueryTrustedDomainInfoBySid_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_QueryTrustedDomainInfoBySid_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.dom_sid = _dom_sid; + 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(lsa_QueryTrustedDomainInfoBySid, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_QueryTrustedDomainInfoBySid_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_lsarpc, + NDR_LSA_QUERYTRUSTEDDOMAININFOBYSID, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_QueryTrustedDomainInfoBySid_done, req); + return req; +} + +static void rpccli_lsa_QueryTrustedDomainInfoBySid_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_QueryTrustedDomainInfoBySid_state *state = tevent_req_data( + req, struct rpccli_lsa_QueryTrustedDomainInfoBySid_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(lsa_QueryTrustedDomainInfoBySid, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_QueryTrustedDomainInfoBySid_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_QueryTrustedDomainInfoBySid_state *state = tevent_req_data( + req, struct rpccli_lsa_QueryTrustedDomainInfoBySid_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_lsa_QueryTrustedDomainInfoBySid(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -1711,6 +6569,124 @@ NTSTATUS rpccli_lsa_QueryTrustedDomainInfoBySid(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_SetTrustedDomainInfo_state { + struct lsa_SetTrustedDomainInfo orig; + struct lsa_SetTrustedDomainInfo tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_SetTrustedDomainInfo_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_SetTrustedDomainInfo_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct dom_sid2 *_dom_sid /* [in] [ref] */, + enum lsa_TrustDomInfoEnum _level /* [in] */, + union lsa_TrustedDomainInfo *_info /* [in] [ref,switch_is(level)] */) +{ + struct tevent_req *req; + struct rpccli_lsa_SetTrustedDomainInfo_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_SetTrustedDomainInfo_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.dom_sid = _dom_sid; + state->orig.in.level = _level; + state->orig.in.info = _info; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_SetTrustedDomainInfo, &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_lsarpc, + NDR_LSA_SETTRUSTEDDOMAININFO, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_SetTrustedDomainInfo_done, req); + return req; +} + +static void rpccli_lsa_SetTrustedDomainInfo_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_SetTrustedDomainInfo_state *state = tevent_req_data( + req, struct rpccli_lsa_SetTrustedDomainInfo_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(lsa_SetTrustedDomainInfo, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_SetTrustedDomainInfo_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_SetTrustedDomainInfo_state *state = tevent_req_data( + req, struct rpccli_lsa_SetTrustedDomainInfo_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_lsa_SetTrustedDomainInfo(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -1755,6 +6731,120 @@ NTSTATUS rpccli_lsa_SetTrustedDomainInfo(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_DeleteTrustedDomain_state { + struct lsa_DeleteTrustedDomain orig; + struct lsa_DeleteTrustedDomain tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_DeleteTrustedDomain_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_DeleteTrustedDomain_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct dom_sid2 *_dom_sid /* [in] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_DeleteTrustedDomain_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_DeleteTrustedDomain_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.dom_sid = _dom_sid; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_DeleteTrustedDomain, &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_lsarpc, + NDR_LSA_DELETETRUSTEDDOMAIN, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_DeleteTrustedDomain_done, req); + return req; +} + +static void rpccli_lsa_DeleteTrustedDomain_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_DeleteTrustedDomain_state *state = tevent_req_data( + req, struct rpccli_lsa_DeleteTrustedDomain_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(lsa_DeleteTrustedDomain, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_DeleteTrustedDomain_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_DeleteTrustedDomain_state *state = tevent_req_data( + req, struct rpccli_lsa_DeleteTrustedDomain_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_lsa_DeleteTrustedDomain(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -1795,6 +6885,122 @@ NTSTATUS rpccli_lsa_DeleteTrustedDomain(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_StorePrivateData_state { + struct lsa_StorePrivateData orig; + struct lsa_StorePrivateData tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_StorePrivateData_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_StorePrivateData_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct lsa_String *_name /* [in] [ref] */, + struct lsa_DATA_BUF *_val /* [in] [unique] */) +{ + struct tevent_req *req; + struct rpccli_lsa_StorePrivateData_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_StorePrivateData_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.name = _name; + state->orig.in.val = _val; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_StorePrivateData, &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_lsarpc, + NDR_LSA_STOREPRIVATEDATA, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_StorePrivateData_done, req); + return req; +} + +static void rpccli_lsa_StorePrivateData_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_StorePrivateData_state *state = tevent_req_data( + req, struct rpccli_lsa_StorePrivateData_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(lsa_StorePrivateData, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_StorePrivateData_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_StorePrivateData_state *state = tevent_req_data( + req, struct rpccli_lsa_StorePrivateData_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_lsa_StorePrivateData(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -1837,6 +7043,130 @@ NTSTATUS rpccli_lsa_StorePrivateData(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_RetrievePrivateData_state { + struct lsa_RetrievePrivateData orig; + struct lsa_RetrievePrivateData tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_RetrievePrivateData_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_RetrievePrivateData_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct lsa_String *_name /* [in] [ref] */, + struct lsa_DATA_BUF **_val /* [in,out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_RetrievePrivateData_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_RetrievePrivateData_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.name = _name; + state->orig.in.val = _val; + + /* Out parameters */ + state->orig.out.val = _val; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_RetrievePrivateData, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_RetrievePrivateData_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_lsarpc, + NDR_LSA_RETRIEVEPRIVATEDATA, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_RetrievePrivateData_done, req); + return req; +} + +static void rpccli_lsa_RetrievePrivateData_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_RetrievePrivateData_state *state = tevent_req_data( + req, struct rpccli_lsa_RetrievePrivateData_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.val = *state->tmp.out.val; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(lsa_RetrievePrivateData, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_RetrievePrivateData_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_RetrievePrivateData_state *state = tevent_req_data( + req, struct rpccli_lsa_RetrievePrivateData_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_lsa_RetrievePrivateData(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -1880,6 +7210,131 @@ NTSTATUS rpccli_lsa_RetrievePrivateData(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_OpenPolicy2_state { + struct lsa_OpenPolicy2 orig; + struct lsa_OpenPolicy2 tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_OpenPolicy2_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_OpenPolicy2_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_system_name /* [in] [unique,charset(UTF16)] */, + struct lsa_ObjectAttribute *_attr /* [in] [ref] */, + uint32_t _access_mask /* [in] */, + struct policy_handle *_handle /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_OpenPolicy2_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_OpenPolicy2_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.system_name = _system_name; + state->orig.in.attr = _attr; + state->orig.in.access_mask = _access_mask; + + /* Out parameters */ + state->orig.out.handle = _handle; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_OpenPolicy2, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_OpenPolicy2_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_lsarpc, + NDR_LSA_OPENPOLICY2, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_OpenPolicy2_done, req); + return req; +} + +static void rpccli_lsa_OpenPolicy2_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_OpenPolicy2_state *state = tevent_req_data( + req, struct rpccli_lsa_OpenPolicy2_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.handle = *state->tmp.out.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(lsa_OpenPolicy2, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_OpenPolicy2_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_OpenPolicy2_state *state = tevent_req_data( + req, struct rpccli_lsa_OpenPolicy2_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_lsa_OpenPolicy2(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *system_name /* [in] [unique,charset(UTF16)] */, @@ -1924,6 +7379,134 @@ NTSTATUS rpccli_lsa_OpenPolicy2(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_GetUserName_state { + struct lsa_GetUserName orig; + struct lsa_GetUserName tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_GetUserName_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_GetUserName_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + const char *_system_name /* [in] [unique,charset(UTF16)] */, + struct lsa_String **_account_name /* [in,out] [ref] */, + struct lsa_String **_authority_name /* [in,out] [unique] */) +{ + struct tevent_req *req; + struct rpccli_lsa_GetUserName_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_GetUserName_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.system_name = _system_name; + state->orig.in.account_name = _account_name; + state->orig.in.authority_name = _authority_name; + + /* Out parameters */ + state->orig.out.account_name = _account_name; + state->orig.out.authority_name = _authority_name; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_GetUserName, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_GetUserName_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_lsarpc, + NDR_LSA_GETUSERNAME, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_GetUserName_done, req); + return req; +} + +static void rpccli_lsa_GetUserName_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_GetUserName_state *state = tevent_req_data( + req, struct rpccli_lsa_GetUserName_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.account_name = *state->tmp.out.account_name; + if (state->orig.out.authority_name && state->tmp.out.authority_name) { + *state->orig.out.authority_name = *state->tmp.out.authority_name; + } + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(lsa_GetUserName, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_GetUserName_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_GetUserName_state *state = tevent_req_data( + req, struct rpccli_lsa_GetUserName_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_lsa_GetUserName(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const char *system_name /* [in] [unique,charset(UTF16)] */, @@ -1970,6 +7553,129 @@ NTSTATUS rpccli_lsa_GetUserName(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_QueryInfoPolicy2_state { + struct lsa_QueryInfoPolicy2 orig; + struct lsa_QueryInfoPolicy2 tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_QueryInfoPolicy2_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_QueryInfoPolicy2_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + enum lsa_PolicyInfo _level /* [in] */, + union lsa_PolicyInformation **_info /* [out] [ref,switch_is(level)] */) +{ + struct tevent_req *req; + struct rpccli_lsa_QueryInfoPolicy2_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_QueryInfoPolicy2_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + 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(lsa_QueryInfoPolicy2, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_QueryInfoPolicy2_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_lsarpc, + NDR_LSA_QUERYINFOPOLICY2, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_QueryInfoPolicy2_done, req); + return req; +} + +static void rpccli_lsa_QueryInfoPolicy2_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_QueryInfoPolicy2_state *state = tevent_req_data( + req, struct rpccli_lsa_QueryInfoPolicy2_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(lsa_QueryInfoPolicy2, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_QueryInfoPolicy2_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_QueryInfoPolicy2_state *state = tevent_req_data( + req, struct rpccli_lsa_QueryInfoPolicy2_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_lsa_QueryInfoPolicy2(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -2012,6 +7718,122 @@ NTSTATUS rpccli_lsa_QueryInfoPolicy2(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_SetInfoPolicy2_state { + struct lsa_SetInfoPolicy2 orig; + struct lsa_SetInfoPolicy2 tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_SetInfoPolicy2_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_SetInfoPolicy2_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + enum lsa_PolicyInfo _level /* [in] */, + union lsa_PolicyInformation *_info /* [in] [ref,switch_is(level)] */) +{ + struct tevent_req *req; + struct rpccli_lsa_SetInfoPolicy2_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_SetInfoPolicy2_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.level = _level; + state->orig.in.info = _info; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_SetInfoPolicy2, &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_lsarpc, + NDR_LSA_SETINFOPOLICY2, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_SetInfoPolicy2_done, req); + return req; +} + +static void rpccli_lsa_SetInfoPolicy2_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_SetInfoPolicy2_state *state = tevent_req_data( + req, struct rpccli_lsa_SetInfoPolicy2_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(lsa_SetInfoPolicy2, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_SetInfoPolicy2_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_SetInfoPolicy2_state *state = tevent_req_data( + req, struct rpccli_lsa_SetInfoPolicy2_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_lsa_SetInfoPolicy2(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -2054,6 +7876,131 @@ NTSTATUS rpccli_lsa_SetInfoPolicy2(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_QueryTrustedDomainInfoByName_state { + struct lsa_QueryTrustedDomainInfoByName orig; + struct lsa_QueryTrustedDomainInfoByName tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_QueryTrustedDomainInfoByName_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_QueryTrustedDomainInfoByName_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct lsa_String *_trusted_domain /* [in] [ref] */, + enum lsa_TrustDomInfoEnum _level /* [in] */, + union lsa_TrustedDomainInfo **_info /* [out] [ref,switch_is(level)] */) +{ + struct tevent_req *req; + struct rpccli_lsa_QueryTrustedDomainInfoByName_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_QueryTrustedDomainInfoByName_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.trusted_domain = _trusted_domain; + 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(lsa_QueryTrustedDomainInfoByName, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_QueryTrustedDomainInfoByName_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_lsarpc, + NDR_LSA_QUERYTRUSTEDDOMAININFOBYNAME, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_QueryTrustedDomainInfoByName_done, req); + return req; +} + +static void rpccli_lsa_QueryTrustedDomainInfoByName_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_QueryTrustedDomainInfoByName_state *state = tevent_req_data( + req, struct rpccli_lsa_QueryTrustedDomainInfoByName_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(lsa_QueryTrustedDomainInfoByName, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_QueryTrustedDomainInfoByName_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_QueryTrustedDomainInfoByName_state *state = tevent_req_data( + req, struct rpccli_lsa_QueryTrustedDomainInfoByName_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_lsa_QueryTrustedDomainInfoByName(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -2098,6 +8045,124 @@ NTSTATUS rpccli_lsa_QueryTrustedDomainInfoByName(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_SetTrustedDomainInfoByName_state { + struct lsa_SetTrustedDomainInfoByName orig; + struct lsa_SetTrustedDomainInfoByName tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_SetTrustedDomainInfoByName_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_SetTrustedDomainInfoByName_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct lsa_String _trusted_domain /* [in] */, + enum lsa_TrustDomInfoEnum _level /* [in] */, + union lsa_TrustedDomainInfo *_info /* [in] [unique,switch_is(level)] */) +{ + struct tevent_req *req; + struct rpccli_lsa_SetTrustedDomainInfoByName_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_SetTrustedDomainInfoByName_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.trusted_domain = _trusted_domain; + state->orig.in.level = _level; + state->orig.in.info = _info; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_SetTrustedDomainInfoByName, &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_lsarpc, + NDR_LSA_SETTRUSTEDDOMAININFOBYNAME, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_SetTrustedDomainInfoByName_done, req); + return req; +} + +static void rpccli_lsa_SetTrustedDomainInfoByName_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_SetTrustedDomainInfoByName_state *state = tevent_req_data( + req, struct rpccli_lsa_SetTrustedDomainInfoByName_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(lsa_SetTrustedDomainInfoByName, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_SetTrustedDomainInfoByName_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_SetTrustedDomainInfoByName_state *state = tevent_req_data( + req, struct rpccli_lsa_SetTrustedDomainInfoByName_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_lsa_SetTrustedDomainInfoByName(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -2142,6 +8207,133 @@ NTSTATUS rpccli_lsa_SetTrustedDomainInfoByName(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_EnumTrustedDomainsEx_state { + struct lsa_EnumTrustedDomainsEx orig; + struct lsa_EnumTrustedDomainsEx tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_EnumTrustedDomainsEx_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_EnumTrustedDomainsEx_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + uint32_t *_resume_handle /* [in,out] [ref] */, + struct lsa_DomainListEx *_domains /* [out] [ref] */, + uint32_t _max_size /* [in] */) +{ + struct tevent_req *req; + struct rpccli_lsa_EnumTrustedDomainsEx_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_EnumTrustedDomainsEx_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.resume_handle = _resume_handle; + state->orig.in.max_size = _max_size; + + /* Out parameters */ + state->orig.out.resume_handle = _resume_handle; + state->orig.out.domains = _domains; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_EnumTrustedDomainsEx, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_EnumTrustedDomainsEx_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_lsarpc, + NDR_LSA_ENUMTRUSTEDDOMAINSEX, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_EnumTrustedDomainsEx_done, req); + return req; +} + +static void rpccli_lsa_EnumTrustedDomainsEx_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_EnumTrustedDomainsEx_state *state = tevent_req_data( + req, struct rpccli_lsa_EnumTrustedDomainsEx_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.resume_handle = *state->tmp.out.resume_handle; + *state->orig.out.domains = *state->tmp.out.domains; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(lsa_EnumTrustedDomainsEx, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_EnumTrustedDomainsEx_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_EnumTrustedDomainsEx_state *state = tevent_req_data( + req, struct rpccli_lsa_EnumTrustedDomainsEx_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_lsa_EnumTrustedDomainsEx(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -2187,6 +8379,133 @@ NTSTATUS rpccli_lsa_EnumTrustedDomainsEx(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_CreateTrustedDomainEx_state { + struct lsa_CreateTrustedDomainEx orig; + struct lsa_CreateTrustedDomainEx tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_CreateTrustedDomainEx_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_CreateTrustedDomainEx_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_policy_handle /* [in] [ref] */, + struct lsa_TrustDomainInfoInfoEx *_info /* [in] [ref] */, + struct lsa_TrustDomainInfoAuthInfoInternal *_auth_info /* [in] [ref] */, + uint32_t _access_mask /* [in] */, + struct policy_handle *_trustdom_handle /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_CreateTrustedDomainEx_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_CreateTrustedDomainEx_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.policy_handle = _policy_handle; + state->orig.in.info = _info; + state->orig.in.auth_info = _auth_info; + state->orig.in.access_mask = _access_mask; + + /* Out parameters */ + state->orig.out.trustdom_handle = _trustdom_handle; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomainEx, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_CreateTrustedDomainEx_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_lsarpc, + NDR_LSA_CREATETRUSTEDDOMAINEX, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_CreateTrustedDomainEx_done, req); + return req; +} + +static void rpccli_lsa_CreateTrustedDomainEx_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_CreateTrustedDomainEx_state *state = tevent_req_data( + req, struct rpccli_lsa_CreateTrustedDomainEx_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.trustdom_handle = *state->tmp.out.trustdom_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(lsa_CreateTrustedDomainEx, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_CreateTrustedDomainEx_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_CreateTrustedDomainEx_state *state = tevent_req_data( + req, struct rpccli_lsa_CreateTrustedDomainEx_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_lsa_CreateTrustedDomainEx(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *policy_handle /* [in] [ref] */, @@ -2233,6 +8552,126 @@ NTSTATUS rpccli_lsa_CreateTrustedDomainEx(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_CloseTrustedDomainEx_state { + struct lsa_CloseTrustedDomainEx orig; + struct lsa_CloseTrustedDomainEx tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_CloseTrustedDomainEx_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_CloseTrustedDomainEx_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in,out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_CloseTrustedDomainEx_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_CloseTrustedDomainEx_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + + /* Out parameters */ + state->orig.out.handle = _handle; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_CloseTrustedDomainEx, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_CloseTrustedDomainEx_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_lsarpc, + NDR_LSA_CLOSETRUSTEDDOMAINEX, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_CloseTrustedDomainEx_done, req); + return req; +} + +static void rpccli_lsa_CloseTrustedDomainEx_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_CloseTrustedDomainEx_state *state = tevent_req_data( + req, struct rpccli_lsa_CloseTrustedDomainEx_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.handle = *state->tmp.out.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(lsa_CloseTrustedDomainEx, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_CloseTrustedDomainEx_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_CloseTrustedDomainEx_state *state = tevent_req_data( + req, struct rpccli_lsa_CloseTrustedDomainEx_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_lsa_CloseTrustedDomainEx(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in,out] [ref] */) @@ -2272,6 +8711,129 @@ NTSTATUS rpccli_lsa_CloseTrustedDomainEx(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_QueryDomainInformationPolicy_state { + struct lsa_QueryDomainInformationPolicy orig; + struct lsa_QueryDomainInformationPolicy tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_QueryDomainInformationPolicy_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_QueryDomainInformationPolicy_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + uint16_t _level /* [in] */, + union lsa_DomainInformationPolicy **_info /* [out] [ref,switch_is(level)] */) +{ + struct tevent_req *req; + struct rpccli_lsa_QueryDomainInformationPolicy_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_QueryDomainInformationPolicy_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + 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(lsa_QueryDomainInformationPolicy, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_QueryDomainInformationPolicy_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_lsarpc, + NDR_LSA_QUERYDOMAININFORMATIONPOLICY, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_QueryDomainInformationPolicy_done, req); + return req; +} + +static void rpccli_lsa_QueryDomainInformationPolicy_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_QueryDomainInformationPolicy_state *state = tevent_req_data( + req, struct rpccli_lsa_QueryDomainInformationPolicy_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(lsa_QueryDomainInformationPolicy, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_QueryDomainInformationPolicy_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_QueryDomainInformationPolicy_state *state = tevent_req_data( + req, struct rpccli_lsa_QueryDomainInformationPolicy_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_lsa_QueryDomainInformationPolicy(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -2314,6 +8876,122 @@ NTSTATUS rpccli_lsa_QueryDomainInformationPolicy(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_SetDomainInformationPolicy_state { + struct lsa_SetDomainInformationPolicy orig; + struct lsa_SetDomainInformationPolicy tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_SetDomainInformationPolicy_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_SetDomainInformationPolicy_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + uint16_t _level /* [in] */, + union lsa_DomainInformationPolicy *_info /* [in] [unique,switch_is(level)] */) +{ + struct tevent_req *req; + struct rpccli_lsa_SetDomainInformationPolicy_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_SetDomainInformationPolicy_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.level = _level; + state->orig.in.info = _info; + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_SetDomainInformationPolicy, &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_lsarpc, + NDR_LSA_SETDOMAININFORMATIONPOLICY, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_SetDomainInformationPolicy_done, req); + return req; +} + +static void rpccli_lsa_SetDomainInformationPolicy_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_SetDomainInformationPolicy_state *state = tevent_req_data( + req, struct rpccli_lsa_SetDomainInformationPolicy_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(lsa_SetDomainInformationPolicy, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_SetDomainInformationPolicy_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_SetDomainInformationPolicy_state *state = tevent_req_data( + req, struct rpccli_lsa_SetDomainInformationPolicy_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_lsa_SetDomainInformationPolicy(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -2356,6 +9034,131 @@ NTSTATUS rpccli_lsa_SetDomainInformationPolicy(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_OpenTrustedDomainByName_state { + struct lsa_OpenTrustedDomainByName orig; + struct lsa_OpenTrustedDomainByName tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_OpenTrustedDomainByName_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_OpenTrustedDomainByName_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct lsa_String _name /* [in] */, + uint32_t _access_mask /* [in] */, + struct policy_handle *_trustdom_handle /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_OpenTrustedDomainByName_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_OpenTrustedDomainByName_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.name = _name; + state->orig.in.access_mask = _access_mask; + + /* Out parameters */ + state->orig.out.trustdom_handle = _trustdom_handle; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_OpenTrustedDomainByName, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_OpenTrustedDomainByName_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_lsarpc, + NDR_LSA_OPENTRUSTEDDOMAINBYNAME, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_OpenTrustedDomainByName_done, req); + return req; +} + +static void rpccli_lsa_OpenTrustedDomainByName_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_OpenTrustedDomainByName_state *state = tevent_req_data( + req, struct rpccli_lsa_OpenTrustedDomainByName_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.trustdom_handle = *state->tmp.out.trustdom_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(lsa_OpenTrustedDomainByName, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_OpenTrustedDomainByName_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_OpenTrustedDomainByName_state *state = tevent_req_data( + req, struct rpccli_lsa_OpenTrustedDomainByName_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_lsa_OpenTrustedDomainByName(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -2400,6 +9203,116 @@ NTSTATUS rpccli_lsa_OpenTrustedDomainByName(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_TestCall_state { + struct lsa_TestCall orig; + struct lsa_TestCall tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_TestCall_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_TestCall_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_TestCall_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_TestCall_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_TestCall, &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_lsarpc, + NDR_LSA_TESTCALL, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_TestCall_done, req); + return req; +} + +static void rpccli_lsa_TestCall_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_TestCall_state *state = tevent_req_data( + req, struct rpccli_lsa_TestCall_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(lsa_TestCall, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_TestCall_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_TestCall_state *state = tevent_req_data( + req, struct rpccli_lsa_TestCall_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_lsa_TestCall(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { @@ -2436,6 +9349,143 @@ NTSTATUS rpccli_lsa_TestCall(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_LookupSids2_state { + struct lsa_LookupSids2 orig; + struct lsa_LookupSids2 tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_LookupSids2_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_LookupSids2_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct lsa_SidArray *_sids /* [in] [ref] */, + struct lsa_RefDomainList **_domains /* [out] [ref] */, + struct lsa_TransNameArray2 *_names /* [in,out] [ref] */, + uint16_t _level /* [in] */, + uint32_t *_count /* [in,out] [ref] */, + uint32_t _unknown1 /* [in] */, + uint32_t _unknown2 /* [in] */) +{ + struct tevent_req *req; + struct rpccli_lsa_LookupSids2_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_LookupSids2_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.sids = _sids; + state->orig.in.names = _names; + state->orig.in.level = _level; + state->orig.in.count = _count; + state->orig.in.unknown1 = _unknown1; + state->orig.in.unknown2 = _unknown2; + + /* Out parameters */ + state->orig.out.domains = _domains; + state->orig.out.names = _names; + state->orig.out.count = _count; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_LookupSids2, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_LookupSids2_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_lsarpc, + NDR_LSA_LOOKUPSIDS2, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_LookupSids2_done, req); + return req; +} + +static void rpccli_lsa_LookupSids2_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_LookupSids2_state *state = tevent_req_data( + req, struct rpccli_lsa_LookupSids2_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.domains = *state->tmp.out.domains; + *state->orig.out.names = *state->tmp.out.names; + *state->orig.out.count = *state->tmp.out.count; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(lsa_LookupSids2, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_LookupSids2_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_LookupSids2_state *state = tevent_req_data( + req, struct rpccli_lsa_LookupSids2_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_lsa_LookupSids2(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -2490,6 +9540,145 @@ NTSTATUS rpccli_lsa_LookupSids2(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_LookupNames2_state { + struct lsa_LookupNames2 orig; + struct lsa_LookupNames2 tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_LookupNames2_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_LookupNames2_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + uint32_t _num_names /* [in] [range(0,1000)] */, + struct lsa_String *_names /* [in] [size_is(num_names)] */, + struct lsa_RefDomainList **_domains /* [out] [ref] */, + struct lsa_TransSidArray2 *_sids /* [in,out] [ref] */, + enum lsa_LookupNamesLevel _level /* [in] */, + uint32_t *_count /* [in,out] [ref] */, + uint32_t _lookup_options /* [in] */, + uint32_t _client_revision /* [in] */) +{ + struct tevent_req *req; + struct rpccli_lsa_LookupNames2_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_LookupNames2_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.num_names = _num_names; + state->orig.in.names = _names; + state->orig.in.sids = _sids; + state->orig.in.level = _level; + state->orig.in.count = _count; + state->orig.in.lookup_options = _lookup_options; + state->orig.in.client_revision = _client_revision; + + /* Out parameters */ + state->orig.out.domains = _domains; + state->orig.out.sids = _sids; + state->orig.out.count = _count; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_LookupNames2, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_LookupNames2_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_lsarpc, + NDR_LSA_LOOKUPNAMES2, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_LookupNames2_done, req); + return req; +} + +static void rpccli_lsa_LookupNames2_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_LookupNames2_state *state = tevent_req_data( + req, struct rpccli_lsa_LookupNames2_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.domains = *state->tmp.out.domains; + *state->orig.out.sids = *state->tmp.out.sids; + *state->orig.out.count = *state->tmp.out.count; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(lsa_LookupNames2, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_LookupNames2_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_LookupNames2_state *state = tevent_req_data( + req, struct rpccli_lsa_LookupNames2_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_lsa_LookupNames2(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -2546,6 +9735,133 @@ NTSTATUS rpccli_lsa_LookupNames2(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_CreateTrustedDomainEx2_state { + struct lsa_CreateTrustedDomainEx2 orig; + struct lsa_CreateTrustedDomainEx2 tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_CreateTrustedDomainEx2_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_CreateTrustedDomainEx2_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_policy_handle /* [in] [ref] */, + struct lsa_TrustDomainInfoInfoEx *_info /* [in] [ref] */, + struct lsa_TrustDomainInfoAuthInfoInternal *_auth_info /* [in] [ref] */, + uint32_t _access_mask /* [in] */, + struct policy_handle *_trustdom_handle /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_CreateTrustedDomainEx2_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_CreateTrustedDomainEx2_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.policy_handle = _policy_handle; + state->orig.in.info = _info; + state->orig.in.auth_info = _auth_info; + state->orig.in.access_mask = _access_mask; + + /* Out parameters */ + state->orig.out.trustdom_handle = _trustdom_handle; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_CreateTrustedDomainEx2, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_CreateTrustedDomainEx2_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_lsarpc, + NDR_LSA_CREATETRUSTEDDOMAINEX2, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_CreateTrustedDomainEx2_done, req); + return req; +} + +static void rpccli_lsa_CreateTrustedDomainEx2_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_CreateTrustedDomainEx2_state *state = tevent_req_data( + req, struct rpccli_lsa_CreateTrustedDomainEx2_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.trustdom_handle = *state->tmp.out.trustdom_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(lsa_CreateTrustedDomainEx2, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_CreateTrustedDomainEx2_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_CreateTrustedDomainEx2_state *state = tevent_req_data( + req, struct rpccli_lsa_CreateTrustedDomainEx2_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_lsa_CreateTrustedDomainEx2(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *policy_handle /* [in] [ref] */, @@ -2592,6 +9908,116 @@ NTSTATUS rpccli_lsa_CreateTrustedDomainEx2(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_CREDRWRITE_state { + struct lsa_CREDRWRITE orig; + struct lsa_CREDRWRITE tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_CREDRWRITE_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_CREDRWRITE_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_CREDRWRITE_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_CREDRWRITE_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_CREDRWRITE, &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_lsarpc, + NDR_LSA_CREDRWRITE, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_CREDRWRITE_done, req); + return req; +} + +static void rpccli_lsa_CREDRWRITE_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_CREDRWRITE_state *state = tevent_req_data( + req, struct rpccli_lsa_CREDRWRITE_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(lsa_CREDRWRITE, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_CREDRWRITE_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_CREDRWRITE_state *state = tevent_req_data( + req, struct rpccli_lsa_CREDRWRITE_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_lsa_CREDRWRITE(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { @@ -2628,6 +10054,116 @@ NTSTATUS rpccli_lsa_CREDRWRITE(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_CREDRREAD_state { + struct lsa_CREDRREAD orig; + struct lsa_CREDRREAD tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_CREDRREAD_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_CREDRREAD_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_CREDRREAD_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_CREDRREAD_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_CREDRREAD, &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_lsarpc, + NDR_LSA_CREDRREAD, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_CREDRREAD_done, req); + return req; +} + +static void rpccli_lsa_CREDRREAD_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_CREDRREAD_state *state = tevent_req_data( + req, struct rpccli_lsa_CREDRREAD_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(lsa_CREDRREAD, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_CREDRREAD_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_CREDRREAD_state *state = tevent_req_data( + req, struct rpccli_lsa_CREDRREAD_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_lsa_CREDRREAD(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { @@ -2664,6 +10200,116 @@ NTSTATUS rpccli_lsa_CREDRREAD(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_CREDRENUMERATE_state { + struct lsa_CREDRENUMERATE orig; + struct lsa_CREDRENUMERATE tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_CREDRENUMERATE_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_CREDRENUMERATE_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_CREDRENUMERATE_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_CREDRENUMERATE_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_CREDRENUMERATE, &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_lsarpc, + NDR_LSA_CREDRENUMERATE, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_CREDRENUMERATE_done, req); + return req; +} + +static void rpccli_lsa_CREDRENUMERATE_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_CREDRENUMERATE_state *state = tevent_req_data( + req, struct rpccli_lsa_CREDRENUMERATE_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(lsa_CREDRENUMERATE, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_CREDRENUMERATE_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_CREDRENUMERATE_state *state = tevent_req_data( + req, struct rpccli_lsa_CREDRENUMERATE_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_lsa_CREDRENUMERATE(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { @@ -2700,6 +10346,116 @@ NTSTATUS rpccli_lsa_CREDRENUMERATE(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_state { + struct lsa_CREDRWRITEDOMAINCREDENTIALS orig; + struct lsa_CREDRWRITEDOMAINCREDENTIALS tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_CREDRWRITEDOMAINCREDENTIALS, &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_lsarpc, + NDR_LSA_CREDRWRITEDOMAINCREDENTIALS, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_done, req); + return req; +} + +static void rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_state *state = tevent_req_data( + req, struct rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_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(lsa_CREDRWRITEDOMAINCREDENTIALS, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_state *state = tevent_req_data( + req, struct rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS_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_lsa_CREDRWRITEDOMAINCREDENTIALS(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { @@ -2736,6 +10492,116 @@ NTSTATUS rpccli_lsa_CREDRWRITEDOMAINCREDENTIALS(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_CREDRREADDOMAINCREDENTIALS_state { + struct lsa_CREDRREADDOMAINCREDENTIALS orig; + struct lsa_CREDRREADDOMAINCREDENTIALS tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_CREDRREADDOMAINCREDENTIALS_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_CREDRREADDOMAINCREDENTIALS_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_CREDRREADDOMAINCREDENTIALS_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_CREDRREADDOMAINCREDENTIALS_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_CREDRREADDOMAINCREDENTIALS, &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_lsarpc, + NDR_LSA_CREDRREADDOMAINCREDENTIALS, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_CREDRREADDOMAINCREDENTIALS_done, req); + return req; +} + +static void rpccli_lsa_CREDRREADDOMAINCREDENTIALS_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_CREDRREADDOMAINCREDENTIALS_state *state = tevent_req_data( + req, struct rpccli_lsa_CREDRREADDOMAINCREDENTIALS_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(lsa_CREDRREADDOMAINCREDENTIALS, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_CREDRREADDOMAINCREDENTIALS_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_CREDRREADDOMAINCREDENTIALS_state *state = tevent_req_data( + req, struct rpccli_lsa_CREDRREADDOMAINCREDENTIALS_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_lsa_CREDRREADDOMAINCREDENTIALS(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { @@ -2772,6 +10638,116 @@ NTSTATUS rpccli_lsa_CREDRREADDOMAINCREDENTIALS(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_CREDRDELETE_state { + struct lsa_CREDRDELETE orig; + struct lsa_CREDRDELETE tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_CREDRDELETE_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_CREDRDELETE_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_CREDRDELETE_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_CREDRDELETE_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_CREDRDELETE, &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_lsarpc, + NDR_LSA_CREDRDELETE, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_CREDRDELETE_done, req); + return req; +} + +static void rpccli_lsa_CREDRDELETE_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_CREDRDELETE_state *state = tevent_req_data( + req, struct rpccli_lsa_CREDRDELETE_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(lsa_CREDRDELETE, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_CREDRDELETE_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_CREDRDELETE_state *state = tevent_req_data( + req, struct rpccli_lsa_CREDRDELETE_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_lsa_CREDRDELETE(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { @@ -2808,6 +10784,116 @@ NTSTATUS rpccli_lsa_CREDRDELETE(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_CREDRGETTARGETINFO_state { + struct lsa_CREDRGETTARGETINFO orig; + struct lsa_CREDRGETTARGETINFO tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_CREDRGETTARGETINFO_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_CREDRGETTARGETINFO_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_CREDRGETTARGETINFO_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_CREDRGETTARGETINFO_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_CREDRGETTARGETINFO, &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_lsarpc, + NDR_LSA_CREDRGETTARGETINFO, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_CREDRGETTARGETINFO_done, req); + return req; +} + +static void rpccli_lsa_CREDRGETTARGETINFO_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_CREDRGETTARGETINFO_state *state = tevent_req_data( + req, struct rpccli_lsa_CREDRGETTARGETINFO_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(lsa_CREDRGETTARGETINFO, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_CREDRGETTARGETINFO_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_CREDRGETTARGETINFO_state *state = tevent_req_data( + req, struct rpccli_lsa_CREDRGETTARGETINFO_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_lsa_CREDRGETTARGETINFO(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { @@ -2844,6 +10930,116 @@ NTSTATUS rpccli_lsa_CREDRGETTARGETINFO(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_CREDRPROFILELOADED_state { + struct lsa_CREDRPROFILELOADED orig; + struct lsa_CREDRPROFILELOADED tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_CREDRPROFILELOADED_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_CREDRPROFILELOADED_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_CREDRPROFILELOADED_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_CREDRPROFILELOADED_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_CREDRPROFILELOADED, &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_lsarpc, + NDR_LSA_CREDRPROFILELOADED, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_CREDRPROFILELOADED_done, req); + return req; +} + +static void rpccli_lsa_CREDRPROFILELOADED_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_CREDRPROFILELOADED_state *state = tevent_req_data( + req, struct rpccli_lsa_CREDRPROFILELOADED_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(lsa_CREDRPROFILELOADED, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_CREDRPROFILELOADED_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_CREDRPROFILELOADED_state *state = tevent_req_data( + req, struct rpccli_lsa_CREDRPROFILELOADED_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_lsa_CREDRPROFILELOADED(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { @@ -2880,6 +11076,145 @@ NTSTATUS rpccli_lsa_CREDRPROFILELOADED(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_LookupNames3_state { + struct lsa_LookupNames3 orig; + struct lsa_LookupNames3 tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_LookupNames3_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_LookupNames3_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + uint32_t _num_names /* [in] [range(0,1000)] */, + struct lsa_String *_names /* [in] [size_is(num_names)] */, + struct lsa_RefDomainList **_domains /* [out] [ref] */, + struct lsa_TransSidArray3 *_sids /* [in,out] [ref] */, + enum lsa_LookupNamesLevel _level /* [in] */, + uint32_t *_count /* [in,out] [ref] */, + uint32_t _lookup_options /* [in] */, + uint32_t _client_revision /* [in] */) +{ + struct tevent_req *req; + struct rpccli_lsa_LookupNames3_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_LookupNames3_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.num_names = _num_names; + state->orig.in.names = _names; + state->orig.in.sids = _sids; + state->orig.in.level = _level; + state->orig.in.count = _count; + state->orig.in.lookup_options = _lookup_options; + state->orig.in.client_revision = _client_revision; + + /* Out parameters */ + state->orig.out.domains = _domains; + state->orig.out.sids = _sids; + state->orig.out.count = _count; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_LookupNames3, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_LookupNames3_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_lsarpc, + NDR_LSA_LOOKUPNAMES3, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_LookupNames3_done, req); + return req; +} + +static void rpccli_lsa_LookupNames3_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_LookupNames3_state *state = tevent_req_data( + req, struct rpccli_lsa_LookupNames3_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.domains = *state->tmp.out.domains; + *state->orig.out.sids = *state->tmp.out.sids; + *state->orig.out.count = *state->tmp.out.count; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(lsa_LookupNames3, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_LookupNames3_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_LookupNames3_state *state = tevent_req_data( + req, struct rpccli_lsa_LookupNames3_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_lsa_LookupNames3(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -2936,6 +11271,116 @@ NTSTATUS rpccli_lsa_LookupNames3(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_CREDRGETSESSIONTYPES_state { + struct lsa_CREDRGETSESSIONTYPES orig; + struct lsa_CREDRGETSESSIONTYPES tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_CREDRGETSESSIONTYPES_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_CREDRGETSESSIONTYPES_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_CREDRGETSESSIONTYPES_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_CREDRGETSESSIONTYPES_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_CREDRGETSESSIONTYPES, &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_lsarpc, + NDR_LSA_CREDRGETSESSIONTYPES, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_CREDRGETSESSIONTYPES_done, req); + return req; +} + +static void rpccli_lsa_CREDRGETSESSIONTYPES_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_CREDRGETSESSIONTYPES_state *state = tevent_req_data( + req, struct rpccli_lsa_CREDRGETSESSIONTYPES_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(lsa_CREDRGETSESSIONTYPES, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_CREDRGETSESSIONTYPES_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_CREDRGETSESSIONTYPES_state *state = tevent_req_data( + req, struct rpccli_lsa_CREDRGETSESSIONTYPES_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_lsa_CREDRGETSESSIONTYPES(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { @@ -2972,6 +11417,116 @@ NTSTATUS rpccli_lsa_CREDRGETSESSIONTYPES(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_LSARREGISTERAUDITEVENT_state { + struct lsa_LSARREGISTERAUDITEVENT orig; + struct lsa_LSARREGISTERAUDITEVENT tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_LSARREGISTERAUDITEVENT_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_LSARREGISTERAUDITEVENT_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_LSARREGISTERAUDITEVENT_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_LSARREGISTERAUDITEVENT_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_LSARREGISTERAUDITEVENT, &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_lsarpc, + NDR_LSA_LSARREGISTERAUDITEVENT, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_LSARREGISTERAUDITEVENT_done, req); + return req; +} + +static void rpccli_lsa_LSARREGISTERAUDITEVENT_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_LSARREGISTERAUDITEVENT_state *state = tevent_req_data( + req, struct rpccli_lsa_LSARREGISTERAUDITEVENT_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(lsa_LSARREGISTERAUDITEVENT, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_LSARREGISTERAUDITEVENT_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_LSARREGISTERAUDITEVENT_state *state = tevent_req_data( + req, struct rpccli_lsa_LSARREGISTERAUDITEVENT_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_lsa_LSARREGISTERAUDITEVENT(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { @@ -3008,6 +11563,116 @@ NTSTATUS rpccli_lsa_LSARREGISTERAUDITEVENT(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_LSARGENAUDITEVENT_state { + struct lsa_LSARGENAUDITEVENT orig; + struct lsa_LSARGENAUDITEVENT tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_LSARGENAUDITEVENT_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_LSARGENAUDITEVENT_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_LSARGENAUDITEVENT_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_LSARGENAUDITEVENT_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_LSARGENAUDITEVENT, &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_lsarpc, + NDR_LSA_LSARGENAUDITEVENT, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_LSARGENAUDITEVENT_done, req); + return req; +} + +static void rpccli_lsa_LSARGENAUDITEVENT_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_LSARGENAUDITEVENT_state *state = tevent_req_data( + req, struct rpccli_lsa_LSARGENAUDITEVENT_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(lsa_LSARGENAUDITEVENT, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_LSARGENAUDITEVENT_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_LSARGENAUDITEVENT_state *state = tevent_req_data( + req, struct rpccli_lsa_LSARGENAUDITEVENT_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_lsa_LSARGENAUDITEVENT(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { @@ -3044,6 +11709,116 @@ NTSTATUS rpccli_lsa_LSARGENAUDITEVENT(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_LSARUNREGISTERAUDITEVENT_state { + struct lsa_LSARUNREGISTERAUDITEVENT orig; + struct lsa_LSARUNREGISTERAUDITEVENT tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_LSARUNREGISTERAUDITEVENT_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_LSARUNREGISTERAUDITEVENT_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_LSARUNREGISTERAUDITEVENT_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_LSARUNREGISTERAUDITEVENT_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_LSARUNREGISTERAUDITEVENT, &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_lsarpc, + NDR_LSA_LSARUNREGISTERAUDITEVENT, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_LSARUNREGISTERAUDITEVENT_done, req); + return req; +} + +static void rpccli_lsa_LSARUNREGISTERAUDITEVENT_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_LSARUNREGISTERAUDITEVENT_state *state = tevent_req_data( + req, struct rpccli_lsa_LSARUNREGISTERAUDITEVENT_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(lsa_LSARUNREGISTERAUDITEVENT, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_LSARUNREGISTERAUDITEVENT_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_LSARUNREGISTERAUDITEVENT_state *state = tevent_req_data( + req, struct rpccli_lsa_LSARUNREGISTERAUDITEVENT_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_lsa_LSARUNREGISTERAUDITEVENT(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { @@ -3080,6 +11855,131 @@ NTSTATUS rpccli_lsa_LSARUNREGISTERAUDITEVENT(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_lsaRQueryForestTrustInformation_state { + struct lsa_lsaRQueryForestTrustInformation orig; + struct lsa_lsaRQueryForestTrustInformation tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_lsaRQueryForestTrustInformation_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_lsaRQueryForestTrustInformation_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_handle /* [in] [ref] */, + struct lsa_String *_trusted_domain_name /* [in] [ref] */, + uint16_t _unknown /* [in] */, + struct lsa_ForestTrustInformation **_forest_trust_info /* [out] [ref] */) +{ + struct tevent_req *req; + struct rpccli_lsa_lsaRQueryForestTrustInformation_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_lsaRQueryForestTrustInformation_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.handle = _handle; + state->orig.in.trusted_domain_name = _trusted_domain_name; + state->orig.in.unknown = _unknown; + + /* Out parameters */ + state->orig.out.forest_trust_info = _forest_trust_info; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_lsaRQueryForestTrustInformation, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_lsaRQueryForestTrustInformation_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_lsarpc, + NDR_LSA_LSARQUERYFORESTTRUSTINFORMATION, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_lsaRQueryForestTrustInformation_done, req); + return req; +} + +static void rpccli_lsa_lsaRQueryForestTrustInformation_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_lsaRQueryForestTrustInformation_state *state = tevent_req_data( + req, struct rpccli_lsa_lsaRQueryForestTrustInformation_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.forest_trust_info = *state->tmp.out.forest_trust_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(lsa_lsaRQueryForestTrustInformation, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_lsaRQueryForestTrustInformation_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_lsaRQueryForestTrustInformation_state *state = tevent_req_data( + req, struct rpccli_lsa_lsaRQueryForestTrustInformation_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_lsa_lsaRQueryForestTrustInformation(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct policy_handle *handle /* [in] [ref] */, @@ -3124,6 +12024,116 @@ NTSTATUS rpccli_lsa_lsaRQueryForestTrustInformation(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_state { + struct lsa_LSARSETFORESTTRUSTINFORMATION orig; + struct lsa_LSARSETFORESTTRUSTINFORMATION tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_LSARSETFORESTTRUSTINFORMATION, &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_lsarpc, + NDR_LSA_LSARSETFORESTTRUSTINFORMATION, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_done, req); + return req; +} + +static void rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_state *state = tevent_req_data( + req, struct rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_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(lsa_LSARSETFORESTTRUSTINFORMATION, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_state *state = tevent_req_data( + req, struct rpccli_lsa_LSARSETFORESTTRUSTINFORMATION_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_lsa_LSARSETFORESTTRUSTINFORMATION(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { @@ -3160,6 +12170,116 @@ NTSTATUS rpccli_lsa_LSARSETFORESTTRUSTINFORMATION(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_CREDRRENAME_state { + struct lsa_CREDRRENAME orig; + struct lsa_CREDRRENAME tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_CREDRRENAME_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_CREDRRENAME_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_CREDRRENAME_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_CREDRRENAME_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_CREDRRENAME, &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_lsarpc, + NDR_LSA_CREDRRENAME, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_CREDRRENAME_done, req); + return req; +} + +static void rpccli_lsa_CREDRRENAME_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_CREDRRENAME_state *state = tevent_req_data( + req, struct rpccli_lsa_CREDRRENAME_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(lsa_CREDRRENAME, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_CREDRRENAME_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_CREDRRENAME_state *state = tevent_req_data( + req, struct rpccli_lsa_CREDRRENAME_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_lsa_CREDRRENAME(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { @@ -3196,6 +12316,141 @@ NTSTATUS rpccli_lsa_CREDRRENAME(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_LookupSids3_state { + struct lsa_LookupSids3 orig; + struct lsa_LookupSids3 tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_LookupSids3_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_LookupSids3_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct lsa_SidArray *_sids /* [in] [ref] */, + struct lsa_RefDomainList **_domains /* [out] [ref] */, + struct lsa_TransNameArray2 *_names /* [in,out] [ref] */, + uint16_t _level /* [in] */, + uint32_t *_count /* [in,out] [ref] */, + uint32_t _unknown1 /* [in] */, + uint32_t _unknown2 /* [in] */) +{ + struct tevent_req *req; + struct rpccli_lsa_LookupSids3_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_LookupSids3_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.sids = _sids; + state->orig.in.names = _names; + state->orig.in.level = _level; + state->orig.in.count = _count; + state->orig.in.unknown1 = _unknown1; + state->orig.in.unknown2 = _unknown2; + + /* Out parameters */ + state->orig.out.domains = _domains; + state->orig.out.names = _names; + state->orig.out.count = _count; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_LookupSids3, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_LookupSids3_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_lsarpc, + NDR_LSA_LOOKUPSIDS3, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_LookupSids3_done, req); + return req; +} + +static void rpccli_lsa_LookupSids3_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_LookupSids3_state *state = tevent_req_data( + req, struct rpccli_lsa_LookupSids3_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.domains = *state->tmp.out.domains; + *state->orig.out.names = *state->tmp.out.names; + *state->orig.out.count = *state->tmp.out.count; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(lsa_LookupSids3, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_LookupSids3_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_LookupSids3_state *state = tevent_req_data( + req, struct rpccli_lsa_LookupSids3_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_lsa_LookupSids3(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, struct lsa_SidArray *sids /* [in] [ref] */, @@ -3248,6 +12503,143 @@ NTSTATUS rpccli_lsa_LookupSids3(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_LookupNames4_state { + struct lsa_LookupNames4 orig; + struct lsa_LookupNames4 tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_LookupNames4_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_LookupNames4_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + uint32_t _num_names /* [in] [range(0,1000)] */, + struct lsa_String *_names /* [in] [size_is(num_names)] */, + struct lsa_RefDomainList **_domains /* [out] [ref] */, + struct lsa_TransSidArray3 *_sids /* [in,out] [ref] */, + enum lsa_LookupNamesLevel _level /* [in] */, + uint32_t *_count /* [in,out] [ref] */, + uint32_t _lookup_options /* [in] */, + uint32_t _client_revision /* [in] */) +{ + struct tevent_req *req; + struct rpccli_lsa_LookupNames4_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_LookupNames4_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + state->orig.in.num_names = _num_names; + state->orig.in.names = _names; + state->orig.in.sids = _sids; + state->orig.in.level = _level; + state->orig.in.count = _count; + state->orig.in.lookup_options = _lookup_options; + state->orig.in.client_revision = _client_revision; + + /* Out parameters */ + state->orig.out.domains = _domains; + state->orig.out.sids = _sids; + state->orig.out.count = _count; + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_LookupNames4, &state->orig); + } + + state->out_mem_ctx = talloc_named_const(state, 0, + "rpccli_lsa_LookupNames4_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_lsarpc, + NDR_LSA_LOOKUPNAMES4, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_LookupNames4_done, req); + return req; +} + +static void rpccli_lsa_LookupNames4_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_LookupNames4_state *state = tevent_req_data( + req, struct rpccli_lsa_LookupNames4_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.domains = *state->tmp.out.domains; + *state->orig.out.sids = *state->tmp.out.sids; + *state->orig.out.count = *state->tmp.out.count; + + /* Copy result */ + state->orig.out.result = state->tmp.out.result; + + /* Reset temporary structure */ + ZERO_STRUCT(state->tmp); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_OUT_DEBUG(lsa_LookupNames4, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_LookupNames4_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_LookupNames4_state *state = tevent_req_data( + req, struct rpccli_lsa_LookupNames4_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_lsa_LookupNames4(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, uint32_t num_names /* [in] [range(0,1000)] */, @@ -3302,6 +12694,116 @@ NTSTATUS rpccli_lsa_LookupNames4(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_LSAROPENPOLICYSCE_state { + struct lsa_LSAROPENPOLICYSCE orig; + struct lsa_LSAROPENPOLICYSCE tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_LSAROPENPOLICYSCE_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_LSAROPENPOLICYSCE_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_LSAROPENPOLICYSCE_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_LSAROPENPOLICYSCE_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_LSAROPENPOLICYSCE, &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_lsarpc, + NDR_LSA_LSAROPENPOLICYSCE, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_LSAROPENPOLICYSCE_done, req); + return req; +} + +static void rpccli_lsa_LSAROPENPOLICYSCE_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_LSAROPENPOLICYSCE_state *state = tevent_req_data( + req, struct rpccli_lsa_LSAROPENPOLICYSCE_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(lsa_LSAROPENPOLICYSCE, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_LSAROPENPOLICYSCE_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_LSAROPENPOLICYSCE_state *state = tevent_req_data( + req, struct rpccli_lsa_LSAROPENPOLICYSCE_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_lsa_LSAROPENPOLICYSCE(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { @@ -3338,6 +12840,116 @@ NTSTATUS rpccli_lsa_LSAROPENPOLICYSCE(struct rpc_pipe_client *cli, return r.out.result; } +struct rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_state { + struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE orig; + struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_LSARADTREGISTERSECURITYEVENTSOURCE, &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_lsarpc, + NDR_LSA_LSARADTREGISTERSECURITYEVENTSOURCE, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_done, req); + return req; +} + +static void rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_state *state = tevent_req_data( + req, struct rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_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(lsa_LSARADTREGISTERSECURITYEVENTSOURCE, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_state *state = tevent_req_data( + req, struct rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE_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_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { @@ -3374,6 +12986,116 @@ NTSTATUS rpccli_lsa_LSARADTREGISTERSECURITYEVENTSOURCE(struct rpc_pipe_client *c return r.out.result; } +struct rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_state { + struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE orig; + struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE, &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_lsarpc, + NDR_LSA_LSARADTUNREGISTERSECURITYEVENTSOURCE, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_done, req); + return req; +} + +static void rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_state *state = tevent_req_data( + req, struct rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_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(lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_state *state = tevent_req_data( + req, struct rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE_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_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { @@ -3410,6 +13132,116 @@ NTSTATUS rpccli_lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(struct rpc_pipe_client return r.out.result; } +struct rpccli_lsa_LSARADTREPORTSECURITYEVENT_state { + struct lsa_LSARADTREPORTSECURITYEVENT orig; + struct lsa_LSARADTREPORTSECURITYEVENT tmp; + TALLOC_CTX *out_mem_ctx; + NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); +}; + +static void rpccli_lsa_LSARADTREPORTSECURITYEVENT_done(struct tevent_req *subreq); + +struct tevent_req *rpccli_lsa_LSARADTREPORTSECURITYEVENT_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli) +{ + struct tevent_req *req; + struct rpccli_lsa_LSARADTREPORTSECURITYEVENT_state *state; + struct tevent_req *subreq; + + req = tevent_req_create(mem_ctx, &state, + struct rpccli_lsa_LSARADTREPORTSECURITYEVENT_state); + if (req == NULL) { + return NULL; + } + state->out_mem_ctx = NULL; + state->dispatch_recv = cli->dispatch_recv; + + /* In parameters */ + + /* Out parameters */ + + /* Result */ + ZERO_STRUCT(state->orig.out.result); + + if (DEBUGLEVEL >= 10) { + NDR_PRINT_IN_DEBUG(lsa_LSARADTREPORTSECURITYEVENT, &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_lsarpc, + NDR_LSA_LSARADTREPORTSECURITYEVENT, + &state->tmp); + if (tevent_req_nomem(subreq, req)) { + return tevent_req_post(req, ev); + } + tevent_req_set_callback(subreq, rpccli_lsa_LSARADTREPORTSECURITYEVENT_done, req); + return req; +} + +static void rpccli_lsa_LSARADTREPORTSECURITYEVENT_done(struct tevent_req *subreq) +{ + struct tevent_req *req = tevent_req_callback_data( + subreq, struct tevent_req); + struct rpccli_lsa_LSARADTREPORTSECURITYEVENT_state *state = tevent_req_data( + req, struct rpccli_lsa_LSARADTREPORTSECURITYEVENT_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(lsa_LSARADTREPORTSECURITYEVENT, &state->orig); + } + + tevent_req_done(req); +} + +NTSTATUS rpccli_lsa_LSARADTREPORTSECURITYEVENT_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + NTSTATUS *result) +{ + struct rpccli_lsa_LSARADTREPORTSECURITYEVENT_state *state = tevent_req_data( + req, struct rpccli_lsa_LSARADTREPORTSECURITYEVENT_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_lsa_LSARADTREPORTSECURITYEVENT(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx) { |