From bae320e2aac91839fd2c331e1ad719cb1b4de599 Mon Sep 17 00:00:00 2001 From: Andrew Tridgell Date: Fri, 11 Sep 2009 20:14:11 +1000 Subject: [PATCH] s4-idl: added the IDL for the DsReplica* calls --- librpc/gen_ndr/cli_drsuapi.c | 204 ++++--- librpc/gen_ndr/cli_drsuapi.h | 72 ++- librpc/gen_ndr/drsuapi.h | 77 ++- librpc/gen_ndr/ndr_drsuapi.c | 814 ++++++++++++++++++++++++++-- librpc/gen_ndr/ndr_drsuapi.h | 19 +- librpc/idl/drsuapi.idl | 76 ++- source4/rpc_server/drsuapi/dcesrv_drsuapi.c | 18 +- 7 files changed, 1094 insertions(+), 186 deletions(-) diff --git a/librpc/gen_ndr/cli_drsuapi.c b/librpc/gen_ndr/cli_drsuapi.c index 14c89aa1940..43d41eacb02 100644 --- a/librpc/gen_ndr/cli_drsuapi.c +++ b/librpc/gen_ndr/cli_drsuapi.c @@ -852,25 +852,28 @@ NTSTATUS rpccli_drsuapi_DsReplicaUpdateRefs(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } -struct rpccli_DRSUAPI_REPLICA_ADD_state { - struct DRSUAPI_REPLICA_ADD orig; - struct DRSUAPI_REPLICA_ADD tmp; +struct rpccli_drsuapi_DsReplicaAdd_state { + struct drsuapi_DsReplicaAdd orig; + struct drsuapi_DsReplicaAdd tmp; TALLOC_CTX *out_mem_ctx; NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); }; -static void rpccli_DRSUAPI_REPLICA_ADD_done(struct tevent_req *subreq); +static void rpccli_drsuapi_DsReplicaAdd_done(struct tevent_req *subreq); -struct tevent_req *rpccli_DRSUAPI_REPLICA_ADD_send(TALLOC_CTX *mem_ctx, - struct tevent_context *ev, - struct rpc_pipe_client *cli) +struct tevent_req *rpccli_drsuapi_DsReplicaAdd_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_bind_handle /* [in] [ref] */, + int32_t _level /* [in] */, + union drsuapi_DsReplicaAddRequest _req /* [in] [switch_is(level)] */) { struct tevent_req *req; - struct rpccli_DRSUAPI_REPLICA_ADD_state *state; + struct rpccli_drsuapi_DsReplicaAdd_state *state; struct tevent_req *subreq; req = tevent_req_create(mem_ctx, &state, - struct rpccli_DRSUAPI_REPLICA_ADD_state); + struct rpccli_drsuapi_DsReplicaAdd_state); if (req == NULL) { return NULL; } @@ -878,6 +881,9 @@ struct tevent_req *rpccli_DRSUAPI_REPLICA_ADD_send(TALLOC_CTX *mem_ctx, state->dispatch_recv = cli->dispatch_recv; /* In parameters */ + state->orig.in.bind_handle = _bind_handle; + state->orig.in.level = _level; + state->orig.in.req = _req; /* Out parameters */ @@ -885,7 +891,7 @@ struct tevent_req *rpccli_DRSUAPI_REPLICA_ADD_send(TALLOC_CTX *mem_ctx, ZERO_STRUCT(state->orig.out.result); if (DEBUGLEVEL >= 10) { - NDR_PRINT_IN_DEBUG(DRSUAPI_REPLICA_ADD, &state->orig); + NDR_PRINT_IN_DEBUG(drsuapi_DsReplicaAdd, &state->orig); } /* make a temporary copy, that we pass to the dispatch function */ @@ -893,21 +899,21 @@ struct tevent_req *rpccli_DRSUAPI_REPLICA_ADD_send(TALLOC_CTX *mem_ctx, subreq = cli->dispatch_send(state, ev, cli, &ndr_table_drsuapi, - NDR_DRSUAPI_REPLICA_ADD, + NDR_DRSUAPI_DSREPLICAADD, &state->tmp); if (tevent_req_nomem(subreq, req)) { return tevent_req_post(req, ev); } - tevent_req_set_callback(subreq, rpccli_DRSUAPI_REPLICA_ADD_done, req); + tevent_req_set_callback(subreq, rpccli_drsuapi_DsReplicaAdd_done, req); return req; } -static void rpccli_DRSUAPI_REPLICA_ADD_done(struct tevent_req *subreq) +static void rpccli_drsuapi_DsReplicaAdd_done(struct tevent_req *subreq) { struct tevent_req *req = tevent_req_callback_data( subreq, struct tevent_req); - struct rpccli_DRSUAPI_REPLICA_ADD_state *state = tevent_req_data( - req, struct rpccli_DRSUAPI_REPLICA_ADD_state); + struct rpccli_drsuapi_DsReplicaAdd_state *state = tevent_req_data( + req, struct rpccli_drsuapi_DsReplicaAdd_state); NTSTATUS status; TALLOC_CTX *mem_ctx; @@ -933,18 +939,18 @@ static void rpccli_DRSUAPI_REPLICA_ADD_done(struct tevent_req *subreq) ZERO_STRUCT(state->tmp); if (DEBUGLEVEL >= 10) { - NDR_PRINT_OUT_DEBUG(DRSUAPI_REPLICA_ADD, &state->orig); + NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaAdd, &state->orig); } tevent_req_done(req); } -NTSTATUS rpccli_DRSUAPI_REPLICA_ADD_recv(struct tevent_req *req, - TALLOC_CTX *mem_ctx, - WERROR *result) +NTSTATUS rpccli_drsuapi_DsReplicaAdd_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) { - struct rpccli_DRSUAPI_REPLICA_ADD_state *state = tevent_req_data( - req, struct rpccli_DRSUAPI_REPLICA_ADD_state); + struct rpccli_drsuapi_DsReplicaAdd_state *state = tevent_req_data( + req, struct rpccli_drsuapi_DsReplicaAdd_state); NTSTATUS status; if (tevent_req_is_nterror(req, &status)) { @@ -962,23 +968,29 @@ NTSTATUS rpccli_DRSUAPI_REPLICA_ADD_recv(struct tevent_req *req, return NT_STATUS_OK; } -NTSTATUS rpccli_DRSUAPI_REPLICA_ADD(struct rpc_pipe_client *cli, - TALLOC_CTX *mem_ctx, - WERROR *werror) +NTSTATUS rpccli_drsuapi_DsReplicaAdd(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + struct policy_handle *bind_handle /* [in] [ref] */, + int32_t level /* [in] */, + union drsuapi_DsReplicaAddRequest req /* [in] [switch_is(level)] */, + WERROR *werror) { - struct DRSUAPI_REPLICA_ADD r; + struct drsuapi_DsReplicaAdd r; NTSTATUS status; /* In parameters */ + r.in.bind_handle = bind_handle; + r.in.level = level; + r.in.req = req; if (DEBUGLEVEL >= 10) { - NDR_PRINT_IN_DEBUG(DRSUAPI_REPLICA_ADD, &r); + NDR_PRINT_IN_DEBUG(drsuapi_DsReplicaAdd, &r); } status = cli->dispatch(cli, mem_ctx, &ndr_table_drsuapi, - NDR_DRSUAPI_REPLICA_ADD, + NDR_DRSUAPI_DSREPLICAADD, &r); if (!NT_STATUS_IS_OK(status)) { @@ -986,7 +998,7 @@ NTSTATUS rpccli_DRSUAPI_REPLICA_ADD(struct rpc_pipe_client *cli, } if (DEBUGLEVEL >= 10) { - NDR_PRINT_OUT_DEBUG(DRSUAPI_REPLICA_ADD, &r); + NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaAdd, &r); } if (NT_STATUS_IS_ERR(status)) { @@ -1003,25 +1015,28 @@ NTSTATUS rpccli_DRSUAPI_REPLICA_ADD(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } -struct rpccli_DRSUAPI_REPLICA_DEL_state { - struct DRSUAPI_REPLICA_DEL orig; - struct DRSUAPI_REPLICA_DEL tmp; +struct rpccli_drsuapi_DsReplicaDel_state { + struct drsuapi_DsReplicaDel orig; + struct drsuapi_DsReplicaDel tmp; TALLOC_CTX *out_mem_ctx; NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); }; -static void rpccli_DRSUAPI_REPLICA_DEL_done(struct tevent_req *subreq); +static void rpccli_drsuapi_DsReplicaDel_done(struct tevent_req *subreq); -struct tevent_req *rpccli_DRSUAPI_REPLICA_DEL_send(TALLOC_CTX *mem_ctx, - struct tevent_context *ev, - struct rpc_pipe_client *cli) +struct tevent_req *rpccli_drsuapi_DsReplicaDel_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_bind_handle /* [in] [ref] */, + int32_t _level /* [in] */, + union drsuapi_DsReplicaDelRequest _req /* [in] [switch_is(level)] */) { struct tevent_req *req; - struct rpccli_DRSUAPI_REPLICA_DEL_state *state; + struct rpccli_drsuapi_DsReplicaDel_state *state; struct tevent_req *subreq; req = tevent_req_create(mem_ctx, &state, - struct rpccli_DRSUAPI_REPLICA_DEL_state); + struct rpccli_drsuapi_DsReplicaDel_state); if (req == NULL) { return NULL; } @@ -1029,6 +1044,9 @@ struct tevent_req *rpccli_DRSUAPI_REPLICA_DEL_send(TALLOC_CTX *mem_ctx, state->dispatch_recv = cli->dispatch_recv; /* In parameters */ + state->orig.in.bind_handle = _bind_handle; + state->orig.in.level = _level; + state->orig.in.req = _req; /* Out parameters */ @@ -1036,7 +1054,7 @@ struct tevent_req *rpccli_DRSUAPI_REPLICA_DEL_send(TALLOC_CTX *mem_ctx, ZERO_STRUCT(state->orig.out.result); if (DEBUGLEVEL >= 10) { - NDR_PRINT_IN_DEBUG(DRSUAPI_REPLICA_DEL, &state->orig); + NDR_PRINT_IN_DEBUG(drsuapi_DsReplicaDel, &state->orig); } /* make a temporary copy, that we pass to the dispatch function */ @@ -1044,21 +1062,21 @@ struct tevent_req *rpccli_DRSUAPI_REPLICA_DEL_send(TALLOC_CTX *mem_ctx, subreq = cli->dispatch_send(state, ev, cli, &ndr_table_drsuapi, - NDR_DRSUAPI_REPLICA_DEL, + NDR_DRSUAPI_DSREPLICADEL, &state->tmp); if (tevent_req_nomem(subreq, req)) { return tevent_req_post(req, ev); } - tevent_req_set_callback(subreq, rpccli_DRSUAPI_REPLICA_DEL_done, req); + tevent_req_set_callback(subreq, rpccli_drsuapi_DsReplicaDel_done, req); return req; } -static void rpccli_DRSUAPI_REPLICA_DEL_done(struct tevent_req *subreq) +static void rpccli_drsuapi_DsReplicaDel_done(struct tevent_req *subreq) { struct tevent_req *req = tevent_req_callback_data( subreq, struct tevent_req); - struct rpccli_DRSUAPI_REPLICA_DEL_state *state = tevent_req_data( - req, struct rpccli_DRSUAPI_REPLICA_DEL_state); + struct rpccli_drsuapi_DsReplicaDel_state *state = tevent_req_data( + req, struct rpccli_drsuapi_DsReplicaDel_state); NTSTATUS status; TALLOC_CTX *mem_ctx; @@ -1084,18 +1102,18 @@ static void rpccli_DRSUAPI_REPLICA_DEL_done(struct tevent_req *subreq) ZERO_STRUCT(state->tmp); if (DEBUGLEVEL >= 10) { - NDR_PRINT_OUT_DEBUG(DRSUAPI_REPLICA_DEL, &state->orig); + NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaDel, &state->orig); } tevent_req_done(req); } -NTSTATUS rpccli_DRSUAPI_REPLICA_DEL_recv(struct tevent_req *req, - TALLOC_CTX *mem_ctx, - WERROR *result) +NTSTATUS rpccli_drsuapi_DsReplicaDel_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) { - struct rpccli_DRSUAPI_REPLICA_DEL_state *state = tevent_req_data( - req, struct rpccli_DRSUAPI_REPLICA_DEL_state); + struct rpccli_drsuapi_DsReplicaDel_state *state = tevent_req_data( + req, struct rpccli_drsuapi_DsReplicaDel_state); NTSTATUS status; if (tevent_req_is_nterror(req, &status)) { @@ -1113,23 +1131,29 @@ NTSTATUS rpccli_DRSUAPI_REPLICA_DEL_recv(struct tevent_req *req, return NT_STATUS_OK; } -NTSTATUS rpccli_DRSUAPI_REPLICA_DEL(struct rpc_pipe_client *cli, - TALLOC_CTX *mem_ctx, - WERROR *werror) +NTSTATUS rpccli_drsuapi_DsReplicaDel(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + struct policy_handle *bind_handle /* [in] [ref] */, + int32_t level /* [in] */, + union drsuapi_DsReplicaDelRequest req /* [in] [switch_is(level)] */, + WERROR *werror) { - struct DRSUAPI_REPLICA_DEL r; + struct drsuapi_DsReplicaDel r; NTSTATUS status; /* In parameters */ + r.in.bind_handle = bind_handle; + r.in.level = level; + r.in.req = req; if (DEBUGLEVEL >= 10) { - NDR_PRINT_IN_DEBUG(DRSUAPI_REPLICA_DEL, &r); + NDR_PRINT_IN_DEBUG(drsuapi_DsReplicaDel, &r); } status = cli->dispatch(cli, mem_ctx, &ndr_table_drsuapi, - NDR_DRSUAPI_REPLICA_DEL, + NDR_DRSUAPI_DSREPLICADEL, &r); if (!NT_STATUS_IS_OK(status)) { @@ -1137,7 +1161,7 @@ NTSTATUS rpccli_DRSUAPI_REPLICA_DEL(struct rpc_pipe_client *cli, } if (DEBUGLEVEL >= 10) { - NDR_PRINT_OUT_DEBUG(DRSUAPI_REPLICA_DEL, &r); + NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaDel, &r); } if (NT_STATUS_IS_ERR(status)) { @@ -1154,25 +1178,28 @@ NTSTATUS rpccli_DRSUAPI_REPLICA_DEL(struct rpc_pipe_client *cli, return werror_to_ntstatus(r.out.result); } -struct rpccli_DRSUAPI_REPLICA_MODIFY_state { - struct DRSUAPI_REPLICA_MODIFY orig; - struct DRSUAPI_REPLICA_MODIFY tmp; +struct rpccli_drsuapi_DsReplicaMod_state { + struct drsuapi_DsReplicaMod orig; + struct drsuapi_DsReplicaMod tmp; TALLOC_CTX *out_mem_ctx; NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx); }; -static void rpccli_DRSUAPI_REPLICA_MODIFY_done(struct tevent_req *subreq); +static void rpccli_drsuapi_DsReplicaMod_done(struct tevent_req *subreq); -struct tevent_req *rpccli_DRSUAPI_REPLICA_MODIFY_send(TALLOC_CTX *mem_ctx, - struct tevent_context *ev, - struct rpc_pipe_client *cli) +struct tevent_req *rpccli_drsuapi_DsReplicaMod_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_bind_handle /* [in] [ref] */, + int32_t _level /* [in] */, + union drsuapi_DsReplicaModRequest _req /* [in] [switch_is(level)] */) { struct tevent_req *req; - struct rpccli_DRSUAPI_REPLICA_MODIFY_state *state; + struct rpccli_drsuapi_DsReplicaMod_state *state; struct tevent_req *subreq; req = tevent_req_create(mem_ctx, &state, - struct rpccli_DRSUAPI_REPLICA_MODIFY_state); + struct rpccli_drsuapi_DsReplicaMod_state); if (req == NULL) { return NULL; } @@ -1180,6 +1207,9 @@ struct tevent_req *rpccli_DRSUAPI_REPLICA_MODIFY_send(TALLOC_CTX *mem_ctx, state->dispatch_recv = cli->dispatch_recv; /* In parameters */ + state->orig.in.bind_handle = _bind_handle; + state->orig.in.level = _level; + state->orig.in.req = _req; /* Out parameters */ @@ -1187,7 +1217,7 @@ struct tevent_req *rpccli_DRSUAPI_REPLICA_MODIFY_send(TALLOC_CTX *mem_ctx, ZERO_STRUCT(state->orig.out.result); if (DEBUGLEVEL >= 10) { - NDR_PRINT_IN_DEBUG(DRSUAPI_REPLICA_MODIFY, &state->orig); + NDR_PRINT_IN_DEBUG(drsuapi_DsReplicaMod, &state->orig); } /* make a temporary copy, that we pass to the dispatch function */ @@ -1195,21 +1225,21 @@ struct tevent_req *rpccli_DRSUAPI_REPLICA_MODIFY_send(TALLOC_CTX *mem_ctx, subreq = cli->dispatch_send(state, ev, cli, &ndr_table_drsuapi, - NDR_DRSUAPI_REPLICA_MODIFY, + NDR_DRSUAPI_DSREPLICAMOD, &state->tmp); if (tevent_req_nomem(subreq, req)) { return tevent_req_post(req, ev); } - tevent_req_set_callback(subreq, rpccli_DRSUAPI_REPLICA_MODIFY_done, req); + tevent_req_set_callback(subreq, rpccli_drsuapi_DsReplicaMod_done, req); return req; } -static void rpccli_DRSUAPI_REPLICA_MODIFY_done(struct tevent_req *subreq) +static void rpccli_drsuapi_DsReplicaMod_done(struct tevent_req *subreq) { struct tevent_req *req = tevent_req_callback_data( subreq, struct tevent_req); - struct rpccli_DRSUAPI_REPLICA_MODIFY_state *state = tevent_req_data( - req, struct rpccli_DRSUAPI_REPLICA_MODIFY_state); + struct rpccli_drsuapi_DsReplicaMod_state *state = tevent_req_data( + req, struct rpccli_drsuapi_DsReplicaMod_state); NTSTATUS status; TALLOC_CTX *mem_ctx; @@ -1235,18 +1265,18 @@ static void rpccli_DRSUAPI_REPLICA_MODIFY_done(struct tevent_req *subreq) ZERO_STRUCT(state->tmp); if (DEBUGLEVEL >= 10) { - NDR_PRINT_OUT_DEBUG(DRSUAPI_REPLICA_MODIFY, &state->orig); + NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaMod, &state->orig); } tevent_req_done(req); } -NTSTATUS rpccli_DRSUAPI_REPLICA_MODIFY_recv(struct tevent_req *req, - TALLOC_CTX *mem_ctx, - WERROR *result) +NTSTATUS rpccli_drsuapi_DsReplicaMod_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result) { - struct rpccli_DRSUAPI_REPLICA_MODIFY_state *state = tevent_req_data( - req, struct rpccli_DRSUAPI_REPLICA_MODIFY_state); + struct rpccli_drsuapi_DsReplicaMod_state *state = tevent_req_data( + req, struct rpccli_drsuapi_DsReplicaMod_state); NTSTATUS status; if (tevent_req_is_nterror(req, &status)) { @@ -1264,23 +1294,29 @@ NTSTATUS rpccli_DRSUAPI_REPLICA_MODIFY_recv(struct tevent_req *req, return NT_STATUS_OK; } -NTSTATUS rpccli_DRSUAPI_REPLICA_MODIFY(struct rpc_pipe_client *cli, - TALLOC_CTX *mem_ctx, - WERROR *werror) +NTSTATUS rpccli_drsuapi_DsReplicaMod(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + struct policy_handle *bind_handle /* [in] [ref] */, + int32_t level /* [in] */, + union drsuapi_DsReplicaModRequest req /* [in] [switch_is(level)] */, + WERROR *werror) { - struct DRSUAPI_REPLICA_MODIFY r; + struct drsuapi_DsReplicaMod r; NTSTATUS status; /* In parameters */ + r.in.bind_handle = bind_handle; + r.in.level = level; + r.in.req = req; if (DEBUGLEVEL >= 10) { - NDR_PRINT_IN_DEBUG(DRSUAPI_REPLICA_MODIFY, &r); + NDR_PRINT_IN_DEBUG(drsuapi_DsReplicaMod, &r); } status = cli->dispatch(cli, mem_ctx, &ndr_table_drsuapi, - NDR_DRSUAPI_REPLICA_MODIFY, + NDR_DRSUAPI_DSREPLICAMOD, &r); if (!NT_STATUS_IS_OK(status)) { @@ -1288,7 +1324,7 @@ NTSTATUS rpccli_DRSUAPI_REPLICA_MODIFY(struct rpc_pipe_client *cli, } if (DEBUGLEVEL >= 10) { - NDR_PRINT_OUT_DEBUG(DRSUAPI_REPLICA_MODIFY, &r); + NDR_PRINT_OUT_DEBUG(drsuapi_DsReplicaMod, &r); } if (NT_STATUS_IS_ERR(status)) { diff --git a/librpc/gen_ndr/cli_drsuapi.h b/librpc/gen_ndr/cli_drsuapi.h index 447528110d9..0549bdfa7fb 100644 --- a/librpc/gen_ndr/cli_drsuapi.h +++ b/librpc/gen_ndr/cli_drsuapi.h @@ -76,33 +76,51 @@ NTSTATUS rpccli_drsuapi_DsReplicaUpdateRefs(struct rpc_pipe_client *cli, int32_t level /* [in] */, union drsuapi_DsReplicaUpdateRefsRequest req /* [in] [switch_is(level)] */, WERROR *werror); -struct tevent_req *rpccli_DRSUAPI_REPLICA_ADD_send(TALLOC_CTX *mem_ctx, - struct tevent_context *ev, - struct rpc_pipe_client *cli); -NTSTATUS rpccli_DRSUAPI_REPLICA_ADD_recv(struct tevent_req *req, - TALLOC_CTX *mem_ctx, - WERROR *result); -NTSTATUS rpccli_DRSUAPI_REPLICA_ADD(struct rpc_pipe_client *cli, - TALLOC_CTX *mem_ctx, - WERROR *werror); -struct tevent_req *rpccli_DRSUAPI_REPLICA_DEL_send(TALLOC_CTX *mem_ctx, - struct tevent_context *ev, - struct rpc_pipe_client *cli); -NTSTATUS rpccli_DRSUAPI_REPLICA_DEL_recv(struct tevent_req *req, - TALLOC_CTX *mem_ctx, - WERROR *result); -NTSTATUS rpccli_DRSUAPI_REPLICA_DEL(struct rpc_pipe_client *cli, - TALLOC_CTX *mem_ctx, - WERROR *werror); -struct tevent_req *rpccli_DRSUAPI_REPLICA_MODIFY_send(TALLOC_CTX *mem_ctx, - struct tevent_context *ev, - struct rpc_pipe_client *cli); -NTSTATUS rpccli_DRSUAPI_REPLICA_MODIFY_recv(struct tevent_req *req, - TALLOC_CTX *mem_ctx, - WERROR *result); -NTSTATUS rpccli_DRSUAPI_REPLICA_MODIFY(struct rpc_pipe_client *cli, - TALLOC_CTX *mem_ctx, - WERROR *werror); +struct tevent_req *rpccli_drsuapi_DsReplicaAdd_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_bind_handle /* [in] [ref] */, + int32_t _level /* [in] */, + union drsuapi_DsReplicaAddRequest _req /* [in] [switch_is(level)] */); +NTSTATUS rpccli_drsuapi_DsReplicaAdd_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result); +NTSTATUS rpccli_drsuapi_DsReplicaAdd(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + struct policy_handle *bind_handle /* [in] [ref] */, + int32_t level /* [in] */, + union drsuapi_DsReplicaAddRequest req /* [in] [switch_is(level)] */, + WERROR *werror); +struct tevent_req *rpccli_drsuapi_DsReplicaDel_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_bind_handle /* [in] [ref] */, + int32_t _level /* [in] */, + union drsuapi_DsReplicaDelRequest _req /* [in] [switch_is(level)] */); +NTSTATUS rpccli_drsuapi_DsReplicaDel_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result); +NTSTATUS rpccli_drsuapi_DsReplicaDel(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + struct policy_handle *bind_handle /* [in] [ref] */, + int32_t level /* [in] */, + union drsuapi_DsReplicaDelRequest req /* [in] [switch_is(level)] */, + WERROR *werror); +struct tevent_req *rpccli_drsuapi_DsReplicaMod_send(TALLOC_CTX *mem_ctx, + struct tevent_context *ev, + struct rpc_pipe_client *cli, + struct policy_handle *_bind_handle /* [in] [ref] */, + int32_t _level /* [in] */, + union drsuapi_DsReplicaModRequest _req /* [in] [switch_is(level)] */); +NTSTATUS rpccli_drsuapi_DsReplicaMod_recv(struct tevent_req *req, + TALLOC_CTX *mem_ctx, + WERROR *result); +NTSTATUS rpccli_drsuapi_DsReplicaMod(struct rpc_pipe_client *cli, + TALLOC_CTX *mem_ctx, + struct policy_handle *bind_handle /* [in] [ref] */, + int32_t level /* [in] */, + union drsuapi_DsReplicaModRequest req /* [in] [switch_is(level)] */, + WERROR *werror); struct tevent_req *rpccli_DRSUAPI_VERIFY_NAMES_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev, struct rpc_pipe_client *cli); diff --git a/librpc/gen_ndr/drsuapi.h b/librpc/gen_ndr/drsuapi.h index b4888a0ff88..b7ebe4cbc65 100644 --- a/librpc/gen_ndr/drsuapi.h +++ b/librpc/gen_ndr/drsuapi.h @@ -684,13 +684,58 @@ union drsuapi_DsReplicaUpdateRefsRequest { #define DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION ( 0x00000001 ) #define DRSUAPI_DS_REPLICA_ADD_WRITEABLE ( 0x00000002 ) +struct drsuapi_DsReplicaAddRequest1 { + struct drsuapi_DsReplicaObjectIdentifier *naming_context;/* [ref] */ + const char *source_dsa_address;/* [unique,charset(UTF16)] */ + uint8_t schedule[84]; + uint32_t options; +}; + +struct drsuapi_DsReplicaAddRequest2 { + struct drsuapi_DsReplicaObjectIdentifier *naming_context;/* [ref] */ + struct drsuapi_DsReplicaObjectIdentifier *source_dsa_dn;/* [unique] */ + struct drsuapi_DsReplicaObjectIdentifier *transport_dn;/* [unique] */ + const char *source_dsa_address;/* [unique,charset(UTF16)] */ + uint8_t schedule[84]; + uint32_t options; +}; + +union drsuapi_DsReplicaAddRequest { + struct drsuapi_DsReplicaAddRequest1 req1;/* [case] */ + struct drsuapi_DsReplicaAddRequest2 req2;/* [case(2)] */ +}/* [switch_type(int32)] */; + /* bitmap drsuapi_DsReplicaDeleteOptions */ -#define DRSUAPI_DS_REPLICA_DELETE_ASYNCHRONOUS_OPERATION ( 0x00000001 ) -#define DRSUAPI_DS_REPLICA_DELETE_WRITEABLE ( 0x00000002 ) +#define DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION ( 0x00000001 ) +#define DRSUAPI_DS_REPLICA_ADD_WRITEABLE ( 0x00000002 ) + +struct drsuapi_DsReplicaDelRequest1 { + struct drsuapi_DsReplicaObjectIdentifier *naming_context;/* [ref] */ + const char *source_dsa_address;/* [unique,charset(UTF16)] */ + uint32_t options; +}; + +union drsuapi_DsReplicaDelRequest { + struct drsuapi_DsReplicaDelRequest1 req1;/* [case] */ +}/* [switch_type(int32)] */; /* bitmap drsuapi_DsReplicaModifyOptions */ -#define DRSUAPI_DS_REPLICA_MODIFY_ASYNCHRONOUS_OPERATION ( 0x00000001 ) -#define DRSUAPI_DS_REPLICA_MODIFY_WRITEABLE ( 0x00000002 ) +#define DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION ( 0x00000001 ) +#define DRSUAPI_DS_REPLICA_ADD_WRITEABLE ( 0x00000002 ) + +struct drsuapi_DsReplicaModRequest1 { + struct drsuapi_DsReplicaObjectIdentifier *naming_context;/* [ref] */ + struct GUID source_dra; + const char *source_dra_address;/* [unique,charset(UTF16)] */ + uint8_t schedule[84]; + uint32_t replica_flags; + uint32_t modify_fields; + uint32_t options; +}; + +union drsuapi_DsReplicaModRequest { + struct drsuapi_DsReplicaModRequest1 req1;/* [case] */ +}/* [switch_type(int32)] */; enum drsuapi_DsMembershipType #ifndef USE_UINT_ENUMS @@ -1546,7 +1591,13 @@ struct drsuapi_DsReplicaUpdateRefs { }; -struct DRSUAPI_REPLICA_ADD { +struct drsuapi_DsReplicaAdd { + struct { + struct policy_handle *bind_handle;/* [ref] */ + int32_t level; + union drsuapi_DsReplicaAddRequest req;/* [switch_is(level)] */ + } in; + struct { WERROR result; } out; @@ -1554,7 +1605,13 @@ struct DRSUAPI_REPLICA_ADD { }; -struct DRSUAPI_REPLICA_DEL { +struct drsuapi_DsReplicaDel { + struct { + struct policy_handle *bind_handle;/* [ref] */ + int32_t level; + union drsuapi_DsReplicaDelRequest req;/* [switch_is(level)] */ + } in; + struct { WERROR result; } out; @@ -1562,7 +1619,13 @@ struct DRSUAPI_REPLICA_DEL { }; -struct DRSUAPI_REPLICA_MODIFY { +struct drsuapi_DsReplicaMod { + struct { + struct policy_handle *bind_handle;/* [ref] */ + int32_t level; + union drsuapi_DsReplicaModRequest req;/* [switch_is(level)] */ + } in; + struct { WERROR result; } out; diff --git a/librpc/gen_ndr/ndr_drsuapi.c b/librpc/gen_ndr/ndr_drsuapi.c index 32bc879f44e..466f9c32e15 100644 --- a/librpc/gen_ndr/ndr_drsuapi.c +++ b/librpc/gen_ndr/ndr_drsuapi.c @@ -3702,27 +3702,503 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaAddOptions(struct ndr_print *ndr, const ndr->depth--; } +static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest1 *r) +{ + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_push_align(ndr, 4)); + if (r->naming_context == NULL) { + return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer"); + } + NDR_CHECK(ndr_push_ref_ptr(ndr)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address)); + NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84)); + NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->options)); + } + if (ndr_flags & NDR_BUFFERS) { + NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context)); + if (r->source_dsa_address) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->source_dsa_address, ndr_charset_length(r->source_dsa_address, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest1 *r) +{ + uint32_t _ptr_naming_context; + TALLOC_CTX *_mem_save_naming_context_0; + uint32_t _ptr_source_dsa_address; + TALLOC_CTX *_mem_save_source_dsa_address_0; + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_pull_align(ndr, 4)); + NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context)); + if (_ptr_naming_context) { + NDR_PULL_ALLOC(ndr, r->naming_context); + } else { + r->naming_context = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address)); + if (_ptr_source_dsa_address) { + NDR_PULL_ALLOC(ndr, r->source_dsa_address); + } else { + r->source_dsa_address = NULL; + } + NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84)); + NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->options)); + } + if (ndr_flags & NDR_BUFFERS) { + _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0); + NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0); + if (r->source_dsa_address) { + _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address)); + if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dsa_address), ndr_get_array_length(ndr, &r->source_dsa_address)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_address, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0); + } + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest1 *r) +{ + ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest1"); + ndr->depth++; + ndr_print_ptr(ndr, "naming_context", r->naming_context); + ndr->depth++; + ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context); + ndr->depth--; + ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address); + ndr->depth++; + if (r->source_dsa_address) { + ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address); + } + ndr->depth--; + ndr_print_array_uint8(ndr, "schedule", r->schedule, 84); + ndr_print_drsuapi_DsReplicaAddOptions(ndr, "options", r->options); + ndr->depth--; +} + +static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest2(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaAddRequest2 *r) +{ + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_push_align(ndr, 4)); + if (r->naming_context == NULL) { + return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer"); + } + NDR_CHECK(ndr_push_ref_ptr(ndr)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_dn)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->transport_dn)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address)); + NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84)); + NDR_CHECK(ndr_push_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, r->options)); + } + if (ndr_flags & NDR_BUFFERS) { + NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context)); + if (r->source_dsa_dn) { + NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn)); + } + if (r->transport_dn) { + NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn)); + } + if (r->source_dsa_address) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->source_dsa_address, ndr_charset_length(r->source_dsa_address, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest2(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaAddRequest2 *r) +{ + uint32_t _ptr_naming_context; + TALLOC_CTX *_mem_save_naming_context_0; + uint32_t _ptr_source_dsa_dn; + TALLOC_CTX *_mem_save_source_dsa_dn_0; + uint32_t _ptr_transport_dn; + TALLOC_CTX *_mem_save_transport_dn_0; + uint32_t _ptr_source_dsa_address; + TALLOC_CTX *_mem_save_source_dsa_address_0; + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_pull_align(ndr, 4)); + NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context)); + if (_ptr_naming_context) { + NDR_PULL_ALLOC(ndr, r->naming_context); + } else { + r->naming_context = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_dn)); + if (_ptr_source_dsa_dn) { + NDR_PULL_ALLOC(ndr, r->source_dsa_dn); + } else { + r->source_dsa_dn = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_transport_dn)); + if (_ptr_transport_dn) { + NDR_PULL_ALLOC(ndr, r->transport_dn); + } else { + r->transport_dn = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address)); + if (_ptr_source_dsa_address) { + NDR_PULL_ALLOC(ndr, r->source_dsa_address); + } else { + r->source_dsa_address = NULL; + } + NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84)); + NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddOptions(ndr, NDR_SCALARS, &r->options)); + } + if (ndr_flags & NDR_BUFFERS) { + _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0); + NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0); + if (r->source_dsa_dn) { + _mem_save_source_dsa_dn_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_dn, 0); + NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->source_dsa_dn)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_dn_0, 0); + } + if (r->transport_dn) { + _mem_save_transport_dn_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->transport_dn, 0); + NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->transport_dn)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_transport_dn_0, 0); + } + if (r->source_dsa_address) { + _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address)); + if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dsa_address), ndr_get_array_length(ndr, &r->source_dsa_address)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_address, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0); + } + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest2 *r) +{ + ndr_print_struct(ndr, name, "drsuapi_DsReplicaAddRequest2"); + ndr->depth++; + ndr_print_ptr(ndr, "naming_context", r->naming_context); + ndr->depth++; + ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context); + ndr->depth--; + ndr_print_ptr(ndr, "source_dsa_dn", r->source_dsa_dn); + ndr->depth++; + if (r->source_dsa_dn) { + ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "source_dsa_dn", r->source_dsa_dn); + } + ndr->depth--; + ndr_print_ptr(ndr, "transport_dn", r->transport_dn); + ndr->depth++; + if (r->transport_dn) { + ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "transport_dn", r->transport_dn); + } + ndr->depth--; + ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address); + ndr->depth++; + if (r->source_dsa_address) { + ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address); + } + ndr->depth--; + ndr_print_array_uint8(ndr, "schedule", r->schedule, 84); + ndr_print_drsuapi_DsReplicaAddOptions(ndr, "options", r->options); + ndr->depth--; +} + +static enum ndr_err_code ndr_push_drsuapi_DsReplicaAddRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaAddRequest *r) +{ + if (ndr_flags & NDR_SCALARS) { + int level = ndr_push_get_switch_value(ndr, r); + NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level)); + switch (level) { + case 1: { + NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1)); + break; } + + case 2: { + NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2)); + break; } + + default: + return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__); + } + } + if (ndr_flags & NDR_BUFFERS) { + int level = ndr_push_get_switch_value(ndr, r); + switch (level) { + case 1: + NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1)); + break; + + case 2: + NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2)); + break; + + default: + return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__); + } + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAddRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaAddRequest *r) +{ + int level; + int32_t _level; + level = ndr_pull_get_switch_value(ndr, r); + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level)); + if (_level != level) { + return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__); + } + switch (level) { + case 1: { + NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_SCALARS, &r->req1)); + break; } + + case 2: { + NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_SCALARS, &r->req2)); + break; } + + default: + return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__); + } + } + if (ndr_flags & NDR_BUFFERS) { + switch (level) { + case 1: + NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest1(ndr, NDR_BUFFERS, &r->req1)); + break; + + case 2: + NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest2(ndr, NDR_BUFFERS, &r->req2)); + break; + + default: + return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__); + } + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_drsuapi_DsReplicaAddRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaAddRequest *r) +{ + int level; + level = ndr_print_get_switch_value(ndr, r); + ndr_print_union(ndr, name, level, "drsuapi_DsReplicaAddRequest"); + switch (level) { + case 1: + ndr_print_drsuapi_DsReplicaAddRequest1(ndr, "req1", &r->req1); + break; + + case 2: + ndr_print_drsuapi_DsReplicaAddRequest2(ndr, "req2", &r->req2); + break; + + default: + ndr_print_bad_level(ndr, name, level); + } +} + static enum ndr_err_code ndr_push_drsuapi_DsReplicaDeleteOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r) { - NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r)); + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDeleteOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r) +{ + uint32_t v; + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v)); + *r = v; + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_drsuapi_DsReplicaDeleteOptions(struct ndr_print *ndr, const char *name, uint32_t r) +{ + ndr_print_uint32(ndr, name, r); + ndr->depth++; + ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r); + ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r); + ndr->depth--; +} + +static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaDelRequest1 *r) +{ + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_push_align(ndr, 4)); + if (r->naming_context == NULL) { + return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer"); + } + NDR_CHECK(ndr_push_ref_ptr(ndr)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dsa_address)); + NDR_CHECK(ndr_push_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, r->options)); + } + if (ndr_flags & NDR_BUFFERS) { + NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context)); + if (r->source_dsa_address) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dsa_address, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->source_dsa_address, ndr_charset_length(r->source_dsa_address, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaDelRequest1 *r) +{ + uint32_t _ptr_naming_context; + TALLOC_CTX *_mem_save_naming_context_0; + uint32_t _ptr_source_dsa_address; + TALLOC_CTX *_mem_save_source_dsa_address_0; + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_pull_align(ndr, 4)); + NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context)); + if (_ptr_naming_context) { + NDR_PULL_ALLOC(ndr, r->naming_context); + } else { + r->naming_context = NULL; + } + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dsa_address)); + if (_ptr_source_dsa_address) { + NDR_PULL_ALLOC(ndr, r->source_dsa_address); + } else { + r->source_dsa_address = NULL; + } + NDR_CHECK(ndr_pull_drsuapi_DsReplicaDeleteOptions(ndr, NDR_SCALARS, &r->options)); + } + if (ndr_flags & NDR_BUFFERS) { + _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0); + NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0); + if (r->source_dsa_address) { + _mem_save_source_dsa_address_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->source_dsa_address, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dsa_address)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dsa_address)); + if (ndr_get_array_length(ndr, &r->source_dsa_address) > ndr_get_array_size(ndr, &r->source_dsa_address)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dsa_address), ndr_get_array_length(ndr, &r->source_dsa_address)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dsa_address, ndr_get_array_length(ndr, &r->source_dsa_address), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dsa_address_0, 0); + } + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaDelRequest1 *r) +{ + ndr_print_struct(ndr, name, "drsuapi_DsReplicaDelRequest1"); + ndr->depth++; + ndr_print_ptr(ndr, "naming_context", r->naming_context); + ndr->depth++; + ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context); + ndr->depth--; + ndr_print_ptr(ndr, "source_dsa_address", r->source_dsa_address); + ndr->depth++; + if (r->source_dsa_address) { + ndr_print_string(ndr, "source_dsa_address", r->source_dsa_address); + } + ndr->depth--; + ndr_print_drsuapi_DsReplicaDeleteOptions(ndr, "options", r->options); + ndr->depth--; +} + +static enum ndr_err_code ndr_push_drsuapi_DsReplicaDelRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaDelRequest *r) +{ + if (ndr_flags & NDR_SCALARS) { + int level = ndr_push_get_switch_value(ndr, r); + NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level)); + switch (level) { + case 1: { + NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1)); + break; } + + default: + return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__); + } + } + if (ndr_flags & NDR_BUFFERS) { + int level = ndr_push_get_switch_value(ndr, r); + switch (level) { + case 1: + NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1)); + break; + + default: + return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__); + } + } return NDR_ERR_SUCCESS; } -static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDeleteOptions(struct ndr_pull *ndr, int ndr_flags, uint32_t *r) +static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDelRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaDelRequest *r) { - uint32_t v; - NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v)); - *r = v; + int level; + int32_t _level; + level = ndr_pull_get_switch_value(ndr, r); + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level)); + if (_level != level) { + return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__); + } + switch (level) { + case 1: { + NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_SCALARS, &r->req1)); + break; } + + default: + return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__); + } + } + if (ndr_flags & NDR_BUFFERS) { + switch (level) { + case 1: + NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest1(ndr, NDR_BUFFERS, &r->req1)); + break; + + default: + return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__); + } + } return NDR_ERR_SUCCESS; } -_PUBLIC_ void ndr_print_drsuapi_DsReplicaDeleteOptions(struct ndr_print *ndr, const char *name, uint32_t r) +_PUBLIC_ void ndr_print_drsuapi_DsReplicaDelRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaDelRequest *r) { - ndr_print_uint32(ndr, name, r); - ndr->depth++; - ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_DELETE_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_DELETE_ASYNCHRONOUS_OPERATION, r); - ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_DELETE_WRITEABLE", DRSUAPI_DS_REPLICA_DELETE_WRITEABLE, r); - ndr->depth--; + int level; + level = ndr_print_get_switch_value(ndr, r); + ndr_print_union(ndr, name, level, "drsuapi_DsReplicaDelRequest"); + switch (level) { + case 1: + ndr_print_drsuapi_DsReplicaDelRequest1(ndr, "req1", &r->req1); + break; + + default: + ndr_print_bad_level(ndr, name, level); + } } static enum ndr_err_code ndr_push_drsuapi_DsReplicaModifyOptions(struct ndr_push *ndr, int ndr_flags, uint32_t r) @@ -3743,11 +4219,182 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaModifyOptions(struct ndr_print *ndr, co { ndr_print_uint32(ndr, name, r); ndr->depth++; - ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_MODIFY_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_MODIFY_ASYNCHRONOUS_OPERATION, r); - ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_MODIFY_WRITEABLE", DRSUAPI_DS_REPLICA_MODIFY_WRITEABLE, r); + ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION", DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION, r); + ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DRSUAPI_DS_REPLICA_ADD_WRITEABLE", DRSUAPI_DS_REPLICA_ADD_WRITEABLE, r); + ndr->depth--; +} + +static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest1(struct ndr_push *ndr, int ndr_flags, const struct drsuapi_DsReplicaModRequest1 *r) +{ + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_push_align(ndr, 4)); + if (r->naming_context == NULL) { + return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer"); + } + NDR_CHECK(ndr_push_ref_ptr(ndr)); + NDR_CHECK(ndr_push_GUID(ndr, NDR_SCALARS, &r->source_dra)); + NDR_CHECK(ndr_push_unique_ptr(ndr, r->source_dra_address)); + NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->schedule, 84)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->replica_flags)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->modify_fields)); + NDR_CHECK(ndr_push_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, r->options)); + } + if (ndr_flags & NDR_BUFFERS) { + NDR_CHECK(ndr_push_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context)); + if (r->source_dra_address) { + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16))); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0)); + NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->source_dra_address, CH_UTF16))); + NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->source_dra_address, ndr_charset_length(r->source_dra_address, CH_UTF16), sizeof(uint16_t), CH_UTF16)); + } + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest1(struct ndr_pull *ndr, int ndr_flags, struct drsuapi_DsReplicaModRequest1 *r) +{ + uint32_t _ptr_naming_context; + TALLOC_CTX *_mem_save_naming_context_0; + uint32_t _ptr_source_dra_address; + TALLOC_CTX *_mem_save_source_dra_address_0; + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_pull_align(ndr, 4)); + NDR_CHECK(ndr_pull_ref_ptr(ndr, &_ptr_naming_context)); + if (_ptr_naming_context) { + NDR_PULL_ALLOC(ndr, r->naming_context); + } else { + r->naming_context = NULL; + } + NDR_CHECK(ndr_pull_GUID(ndr, NDR_SCALARS, &r->source_dra)); + NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_source_dra_address)); + if (_ptr_source_dra_address) { + NDR_PULL_ALLOC(ndr, r->source_dra_address); + } else { + r->source_dra_address = NULL; + } + NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->schedule, 84)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->replica_flags)); + NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->modify_fields)); + NDR_CHECK(ndr_pull_drsuapi_DsReplicaModifyOptions(ndr, NDR_SCALARS, &r->options)); + } + if (ndr_flags & NDR_BUFFERS) { + _mem_save_naming_context_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->naming_context, 0); + NDR_CHECK(ndr_pull_drsuapi_DsReplicaObjectIdentifier(ndr, NDR_SCALARS|NDR_BUFFERS, r->naming_context)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_naming_context_0, 0); + if (r->source_dra_address) { + _mem_save_source_dra_address_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->source_dra_address, 0); + NDR_CHECK(ndr_pull_array_size(ndr, &r->source_dra_address)); + NDR_CHECK(ndr_pull_array_length(ndr, &r->source_dra_address)); + if (ndr_get_array_length(ndr, &r->source_dra_address) > ndr_get_array_size(ndr, &r->source_dra_address)) { + return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->source_dra_address), ndr_get_array_length(ndr, &r->source_dra_address)); + } + NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->source_dra_address), sizeof(uint16_t))); + NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->source_dra_address, ndr_get_array_length(ndr, &r->source_dra_address), sizeof(uint16_t), CH_UTF16)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_source_dra_address_0, 0); + } + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaModRequest1 *r) +{ + ndr_print_struct(ndr, name, "drsuapi_DsReplicaModRequest1"); + ndr->depth++; + ndr_print_ptr(ndr, "naming_context", r->naming_context); + ndr->depth++; + ndr_print_drsuapi_DsReplicaObjectIdentifier(ndr, "naming_context", r->naming_context); + ndr->depth--; + ndr_print_GUID(ndr, "source_dra", &r->source_dra); + ndr_print_ptr(ndr, "source_dra_address", r->source_dra_address); + ndr->depth++; + if (r->source_dra_address) { + ndr_print_string(ndr, "source_dra_address", r->source_dra_address); + } + ndr->depth--; + ndr_print_array_uint8(ndr, "schedule", r->schedule, 84); + ndr_print_uint32(ndr, "replica_flags", r->replica_flags); + ndr_print_uint32(ndr, "modify_fields", r->modify_fields); + ndr_print_drsuapi_DsReplicaModifyOptions(ndr, "options", r->options); ndr->depth--; } +static enum ndr_err_code ndr_push_drsuapi_DsReplicaModRequest(struct ndr_push *ndr, int ndr_flags, const union drsuapi_DsReplicaModRequest *r) +{ + if (ndr_flags & NDR_SCALARS) { + int level = ndr_push_get_switch_value(ndr, r); + NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, level)); + switch (level) { + case 1: { + NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1)); + break; } + + default: + return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__); + } + } + if (ndr_flags & NDR_BUFFERS) { + int level = ndr_push_get_switch_value(ndr, r); + switch (level) { + case 1: + NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1)); + break; + + default: + return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__); + } + } + return NDR_ERR_SUCCESS; +} + +static enum ndr_err_code ndr_pull_drsuapi_DsReplicaModRequest(struct ndr_pull *ndr, int ndr_flags, union drsuapi_DsReplicaModRequest *r) +{ + int level; + int32_t _level; + level = ndr_pull_get_switch_value(ndr, r); + if (ndr_flags & NDR_SCALARS) { + NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &_level)); + if (_level != level) { + return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r at %s", _level, __location__); + } + switch (level) { + case 1: { + NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_SCALARS, &r->req1)); + break; } + + default: + return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__); + } + } + if (ndr_flags & NDR_BUFFERS) { + switch (level) { + case 1: + NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest1(ndr, NDR_BUFFERS, &r->req1)); + break; + + default: + return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u at %s", level, __location__); + } + } + return NDR_ERR_SUCCESS; +} + +_PUBLIC_ void ndr_print_drsuapi_DsReplicaModRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaModRequest *r) +{ + int level; + level = ndr_print_get_switch_value(ndr, r); + ndr_print_union(ndr, name, level, "drsuapi_DsReplicaModRequest"); + switch (level) { + case 1: + ndr_print_drsuapi_DsReplicaModRequest1(ndr, "req1", &r->req1); + break; + + default: + ndr_print_bad_level(ndr, name, level); + } +} + static enum ndr_err_code ndr_push_drsuapi_DsMembershipType(struct ndr_push *ndr, int ndr_flags, enum drsuapi_DsMembershipType r) { NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r)); @@ -12689,9 +13336,16 @@ _PUBLIC_ void ndr_print_drsuapi_DsReplicaUpdateRefs(struct ndr_print *ndr, const ndr->depth--; } -static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_ADD(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_ADD *r) +static enum ndr_err_code ndr_push_drsuapi_DsReplicaAdd(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaAdd *r) { if (flags & NDR_IN) { + if (r->in.bind_handle == NULL) { + return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer"); + } + NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle)); + NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level)); + NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level)); + NDR_CHECK(ndr_push_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req)); } if (flags & NDR_OUT) { NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result)); @@ -12699,9 +13353,20 @@ static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_ADD(struct ndr_push *ndr, int return NDR_ERR_SUCCESS; } -static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_ADD(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_ADD *r) +static enum ndr_err_code ndr_pull_drsuapi_DsReplicaAdd(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaAdd *r) { + TALLOC_CTX *_mem_save_bind_handle_0; if (flags & NDR_IN) { + if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { + NDR_PULL_ALLOC(ndr, r->in.bind_handle); + } + _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC); + NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC); + NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level)); + NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level)); + NDR_CHECK(ndr_pull_drsuapi_DsReplicaAddRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req)); } if (flags & NDR_OUT) { NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result)); @@ -12709,20 +13374,27 @@ static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_ADD(struct ndr_pull *ndr, int return NDR_ERR_SUCCESS; } -_PUBLIC_ void ndr_print_DRSUAPI_REPLICA_ADD(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_ADD *r) +_PUBLIC_ void ndr_print_drsuapi_DsReplicaAdd(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaAdd *r) { - ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_ADD"); + ndr_print_struct(ndr, name, "drsuapi_DsReplicaAdd"); ndr->depth++; if (flags & NDR_SET_VALUES) { ndr->flags |= LIBNDR_PRINT_SET_VALUES; } if (flags & NDR_IN) { - ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_ADD"); + ndr_print_struct(ndr, "in", "drsuapi_DsReplicaAdd"); + ndr->depth++; + ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle); ndr->depth++; + ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle); + ndr->depth--; + ndr_print_int32(ndr, "level", r->in.level); + ndr_print_set_switch_value(ndr, &r->in.req, r->in.level); + ndr_print_drsuapi_DsReplicaAddRequest(ndr, "req", &r->in.req); ndr->depth--; } if (flags & NDR_OUT) { - ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_ADD"); + ndr_print_struct(ndr, "out", "drsuapi_DsReplicaAdd"); ndr->depth++; ndr_print_WERROR(ndr, "result", r->out.result); ndr->depth--; @@ -12730,9 +13402,16 @@ _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_ADD(struct ndr_print *ndr, const char *n ndr->depth--; } -static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_DEL(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_DEL *r) +static enum ndr_err_code ndr_push_drsuapi_DsReplicaDel(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaDel *r) { if (flags & NDR_IN) { + if (r->in.bind_handle == NULL) { + return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer"); + } + NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle)); + NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level)); + NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level)); + NDR_CHECK(ndr_push_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req)); } if (flags & NDR_OUT) { NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result)); @@ -12740,9 +13419,20 @@ static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_DEL(struct ndr_push *ndr, int return NDR_ERR_SUCCESS; } -static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_DEL(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_DEL *r) +static enum ndr_err_code ndr_pull_drsuapi_DsReplicaDel(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaDel *r) { + TALLOC_CTX *_mem_save_bind_handle_0; if (flags & NDR_IN) { + if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { + NDR_PULL_ALLOC(ndr, r->in.bind_handle); + } + _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC); + NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC); + NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level)); + NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level)); + NDR_CHECK(ndr_pull_drsuapi_DsReplicaDelRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req)); } if (flags & NDR_OUT) { NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result)); @@ -12750,20 +13440,27 @@ static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_DEL(struct ndr_pull *ndr, int return NDR_ERR_SUCCESS; } -_PUBLIC_ void ndr_print_DRSUAPI_REPLICA_DEL(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_DEL *r) +_PUBLIC_ void ndr_print_drsuapi_DsReplicaDel(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaDel *r) { - ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_DEL"); + ndr_print_struct(ndr, name, "drsuapi_DsReplicaDel"); ndr->depth++; if (flags & NDR_SET_VALUES) { ndr->flags |= LIBNDR_PRINT_SET_VALUES; } if (flags & NDR_IN) { - ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_DEL"); + ndr_print_struct(ndr, "in", "drsuapi_DsReplicaDel"); ndr->depth++; + ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle); + ndr->depth++; + ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle); + ndr->depth--; + ndr_print_int32(ndr, "level", r->in.level); + ndr_print_set_switch_value(ndr, &r->in.req, r->in.level); + ndr_print_drsuapi_DsReplicaDelRequest(ndr, "req", &r->in.req); ndr->depth--; } if (flags & NDR_OUT) { - ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_DEL"); + ndr_print_struct(ndr, "out", "drsuapi_DsReplicaDel"); ndr->depth++; ndr_print_WERROR(ndr, "result", r->out.result); ndr->depth--; @@ -12771,9 +13468,16 @@ _PUBLIC_ void ndr_print_DRSUAPI_REPLICA_DEL(struct ndr_print *ndr, const char *n ndr->depth--; } -static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_MODIFY(struct ndr_push *ndr, int flags, const struct DRSUAPI_REPLICA_MODIFY *r) +static enum ndr_err_code ndr_push_drsuapi_DsReplicaMod(struct ndr_push *ndr, int flags, const struct drsuapi_DsReplicaMod *r) { if (flags & NDR_IN) { + if (r->in.bind_handle == NULL) { + return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer"); + } + NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle)); + NDR_CHECK(ndr_push_int32(ndr, NDR_SCALARS, r->in.level)); + NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.req, r->in.level)); + NDR_CHECK(ndr_push_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req)); } if (flags & NDR_OUT) { NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result)); @@ -12781,9 +13485,20 @@ static enum ndr_err_code ndr_push_DRSUAPI_REPLICA_MODIFY(struct ndr_push *ndr, i return NDR_ERR_SUCCESS; } -static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_MODIFY(struct ndr_pull *ndr, int flags, struct DRSUAPI_REPLICA_MODIFY *r) +static enum ndr_err_code ndr_pull_drsuapi_DsReplicaMod(struct ndr_pull *ndr, int flags, struct drsuapi_DsReplicaMod *r) { + TALLOC_CTX *_mem_save_bind_handle_0; if (flags & NDR_IN) { + if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) { + NDR_PULL_ALLOC(ndr, r->in.bind_handle); + } + _mem_save_bind_handle_0 = NDR_PULL_GET_MEM_CTX(ndr); + NDR_PULL_SET_MEM_CTX(ndr, r->in.bind_handle, LIBNDR_FLAG_REF_ALLOC); + NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.bind_handle)); + NDR_PULL_SET_MEM_CTX(ndr, _mem_save_bind_handle_0, LIBNDR_FLAG_REF_ALLOC); + NDR_CHECK(ndr_pull_int32(ndr, NDR_SCALARS, &r->in.level)); + NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.req, r->in.level)); + NDR_CHECK(ndr_pull_drsuapi_DsReplicaModRequest(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.req)); } if (flags & NDR_OUT) { NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result)); @@ -12791,20 +13506,27 @@ static enum ndr_err_code ndr_pull_DRSUAPI_REPLICA_MODIFY(struct ndr_pull *ndr, i return NDR_ERR_SUCCESS; } -_PUBLIC_ void ndr_print_DRSUAPI_REPLICA_MODIFY(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_MODIFY *r) +_PUBLIC_ void ndr_print_drsuapi_DsReplicaMod(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaMod *r) { - ndr_print_struct(ndr, name, "DRSUAPI_REPLICA_MODIFY"); + ndr_print_struct(ndr, name, "drsuapi_DsReplicaMod"); ndr->depth++; if (flags & NDR_SET_VALUES) { ndr->flags |= LIBNDR_PRINT_SET_VALUES; } if (flags & NDR_IN) { - ndr_print_struct(ndr, "in", "DRSUAPI_REPLICA_MODIFY"); + ndr_print_struct(ndr, "in", "drsuapi_DsReplicaMod"); + ndr->depth++; + ndr_print_ptr(ndr, "bind_handle", r->in.bind_handle); ndr->depth++; + ndr_print_policy_handle(ndr, "bind_handle", r->in.bind_handle); + ndr->depth--; + ndr_print_int32(ndr, "level", r->in.level); + ndr_print_set_switch_value(ndr, &r->in.req, r->in.level); + ndr_print_drsuapi_DsReplicaModRequest(ndr, "req", &r->in.req); ndr->depth--; } if (flags & NDR_OUT) { - ndr_print_struct(ndr, "out", "DRSUAPI_REPLICA_MODIFY"); + ndr_print_struct(ndr, "out", "drsuapi_DsReplicaMod"); ndr->depth++; ndr_print_WERROR(ndr, "result", r->out.result); ndr->depth--; @@ -14341,27 +15063,27 @@ static const struct ndr_interface_call drsuapi_calls[] = { false, }, { - "DRSUAPI_REPLICA_ADD", - sizeof(struct DRSUAPI_REPLICA_ADD), - (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_ADD, - (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_ADD, - (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_ADD, + "drsuapi_DsReplicaAdd", + sizeof(struct drsuapi_DsReplicaAdd), + (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaAdd, + (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaAdd, + (ndr_print_function_t) ndr_print_drsuapi_DsReplicaAdd, false, }, { - "DRSUAPI_REPLICA_DEL", - sizeof(struct DRSUAPI_REPLICA_DEL), - (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_DEL, - (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_DEL, - (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_DEL, + "drsuapi_DsReplicaDel", + sizeof(struct drsuapi_DsReplicaDel), + (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaDel, + (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaDel, + (ndr_print_function_t) ndr_print_drsuapi_DsReplicaDel, false, }, { - "DRSUAPI_REPLICA_MODIFY", - sizeof(struct DRSUAPI_REPLICA_MODIFY), - (ndr_push_flags_fn_t) ndr_push_DRSUAPI_REPLICA_MODIFY, - (ndr_pull_flags_fn_t) ndr_pull_DRSUAPI_REPLICA_MODIFY, - (ndr_print_function_t) ndr_print_DRSUAPI_REPLICA_MODIFY, + "drsuapi_DsReplicaMod", + sizeof(struct drsuapi_DsReplicaMod), + (ndr_push_flags_fn_t) ndr_push_drsuapi_DsReplicaMod, + (ndr_pull_flags_fn_t) ndr_pull_drsuapi_DsReplicaMod, + (ndr_print_function_t) ndr_print_drsuapi_DsReplicaMod, false, }, { diff --git a/librpc/gen_ndr/ndr_drsuapi.h b/librpc/gen_ndr/ndr_drsuapi.h index f7cb768ccc1..c4634b37886 100644 --- a/librpc/gen_ndr/ndr_drsuapi.h +++ b/librpc/gen_ndr/ndr_drsuapi.h @@ -22,11 +22,11 @@ extern const struct ndr_interface_table ndr_table_drsuapi; #define NDR_DRSUAPI_DSREPLICAUPDATEREFS (0x04) -#define NDR_DRSUAPI_REPLICA_ADD (0x05) +#define NDR_DRSUAPI_DSREPLICAADD (0x05) -#define NDR_DRSUAPI_REPLICA_DEL (0x06) +#define NDR_DRSUAPI_DSREPLICADEL (0x06) -#define NDR_DRSUAPI_REPLICA_MODIFY (0x07) +#define NDR_DRSUAPI_DSREPLICAMOD (0x07) #define NDR_DRSUAPI_VERIFY_NAMES (0x08) @@ -174,8 +174,15 @@ void ndr_print_drsuapi_DsReplicaUpdateRefsOptions(struct ndr_print *ndr, const c void ndr_print_drsuapi_DsReplicaUpdateRefsRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaUpdateRefsRequest1 *r); void ndr_print_drsuapi_DsReplicaUpdateRefsRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaUpdateRefsRequest *r); void ndr_print_drsuapi_DsReplicaAddOptions(struct ndr_print *ndr, const char *name, uint32_t r); +void ndr_print_drsuapi_DsReplicaAddRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest1 *r); +void ndr_print_drsuapi_DsReplicaAddRequest2(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaAddRequest2 *r); +void ndr_print_drsuapi_DsReplicaAddRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaAddRequest *r); void ndr_print_drsuapi_DsReplicaDeleteOptions(struct ndr_print *ndr, const char *name, uint32_t r); +void ndr_print_drsuapi_DsReplicaDelRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaDelRequest1 *r); +void ndr_print_drsuapi_DsReplicaDelRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaDelRequest *r); void ndr_print_drsuapi_DsReplicaModifyOptions(struct ndr_print *ndr, const char *name, uint32_t r); +void ndr_print_drsuapi_DsReplicaModRequest1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsReplicaModRequest1 *r); +void ndr_print_drsuapi_DsReplicaModRequest(struct ndr_print *ndr, const char *name, const union drsuapi_DsReplicaModRequest *r); void ndr_print_drsuapi_DsMembershipType(struct ndr_print *ndr, const char *name, enum drsuapi_DsMembershipType r); void ndr_print_drsuapi_DsGetMembershipsCtr1(struct ndr_print *ndr, const char *name, const struct drsuapi_DsGetMembershipsCtr1 *r); void ndr_print_drsuapi_DsGetMembershipsCtr(struct ndr_print *ndr, const char *name, const union drsuapi_DsGetMembershipsCtr *r); @@ -276,9 +283,9 @@ void ndr_print_drsuapi_DsUnbind(struct ndr_print *ndr, const char *name, int fla void ndr_print_drsuapi_DsReplicaSync(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaSync *r); void ndr_print_drsuapi_DsGetNCChanges(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetNCChanges *r); void ndr_print_drsuapi_DsReplicaUpdateRefs(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaUpdateRefs *r); -void ndr_print_DRSUAPI_REPLICA_ADD(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_ADD *r); -void ndr_print_DRSUAPI_REPLICA_DEL(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_DEL *r); -void ndr_print_DRSUAPI_REPLICA_MODIFY(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_REPLICA_MODIFY *r); +void ndr_print_drsuapi_DsReplicaAdd(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaAdd *r); +void ndr_print_drsuapi_DsReplicaDel(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaDel *r); +void ndr_print_drsuapi_DsReplicaMod(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsReplicaMod *r); void ndr_print_DRSUAPI_VERIFY_NAMES(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_VERIFY_NAMES *r); void ndr_print_drsuapi_DsGetMemberships(struct ndr_print *ndr, const char *name, int flags, const struct drsuapi_DsGetMemberships *r); void ndr_print_DRSUAPI_INTER_DOMAIN_MOVE(struct ndr_print *ndr, const char *name, int flags, const struct DRSUAPI_INTER_DOMAIN_MOVE *r); diff --git a/librpc/idl/drsuapi.idl b/librpc/idl/drsuapi.idl index e5d25362bf6..4ca7e568f30 100644 --- a/librpc/idl/drsuapi.idl +++ b/librpc/idl/drsuapi.idl @@ -751,26 +751,88 @@ interface drsuapi /* TODO ... */ } drsuapi_DsReplicaAddOptions; - [todo] WERROR DRSUAPI_REPLICA_ADD(); + + typedef struct { + [ref] drsuapi_DsReplicaObjectIdentifier *naming_context; + [charset(UTF16),string] uint16 *source_dsa_address; + uint8 schedule[84]; + drsuapi_DsReplicaAddOptions options; + } drsuapi_DsReplicaAddRequest1; + + typedef struct { + [ref] drsuapi_DsReplicaObjectIdentifier *naming_context; + drsuapi_DsReplicaObjectIdentifier *source_dsa_dn; + drsuapi_DsReplicaObjectIdentifier *transport_dn; + [charset(UTF16),string] uint16 *source_dsa_address; + uint8 schedule[84]; + drsuapi_DsReplicaAddOptions options; + } drsuapi_DsReplicaAddRequest2; + + typedef [switch_type(int32)] union { + [case(1)] drsuapi_DsReplicaAddRequest1 req1; + [case(2)] drsuapi_DsReplicaAddRequest2 req2; + } drsuapi_DsReplicaAddRequest; + + WERROR drsuapi_DsReplicaAdd( + [in] policy_handle *bind_handle, + [in] int32 level, + [in,switch_is(level)] drsuapi_DsReplicaAddRequest req + ); + /*****************/ /* Function 0x06 */ typedef bitmap { - DRSUAPI_DS_REPLICA_DELETE_ASYNCHRONOUS_OPERATION = 0x00000001, - DRSUAPI_DS_REPLICA_DELETE_WRITEABLE = 0x00000002 + DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION = 0x00000001, + DRSUAPI_DS_REPLICA_ADD_WRITEABLE = 0x00000002 /* TODO ... */ } drsuapi_DsReplicaDeleteOptions; - [todo] WERROR DRSUAPI_REPLICA_DEL(); + + typedef struct { + [ref] drsuapi_DsReplicaObjectIdentifier *naming_context; + [charset(UTF16),string] uint16 *source_dsa_address; + drsuapi_DsReplicaDeleteOptions options; + } drsuapi_DsReplicaDelRequest1; + + typedef [switch_type(int32)] union { + [case(1)] drsuapi_DsReplicaDelRequest1 req1; + } drsuapi_DsReplicaDelRequest; + + WERROR drsuapi_DsReplicaDel( + [in] policy_handle *bind_handle, + [in] int32 level, + [in,switch_is(level)] drsuapi_DsReplicaDelRequest req + ); /*****************/ /* Function 0x07 */ typedef bitmap { - DRSUAPI_DS_REPLICA_MODIFY_ASYNCHRONOUS_OPERATION = 0x00000001, - DRSUAPI_DS_REPLICA_MODIFY_WRITEABLE = 0x00000002 + DRSUAPI_DS_REPLICA_ADD_ASYNCHRONOUS_OPERATION = 0x00000001, + DRSUAPI_DS_REPLICA_ADD_WRITEABLE = 0x00000002 + /* TODO ... */ } drsuapi_DsReplicaModifyOptions; - [todo] WERROR DRSUAPI_REPLICA_MODIFY(); + + typedef struct { + [ref] drsuapi_DsReplicaObjectIdentifier *naming_context; + GUID source_dra; + [charset(UTF16),string] uint16 *source_dra_address; + uint8 schedule[84]; + uint32 replica_flags; + uint32 modify_fields; + drsuapi_DsReplicaModifyOptions options; + } drsuapi_DsReplicaModRequest1; + + typedef [switch_type(int32)] union { + [case(1)] drsuapi_DsReplicaModRequest1 req1; + } drsuapi_DsReplicaModRequest; + + WERROR drsuapi_DsReplicaMod( + [in] policy_handle *bind_handle, + [in] int32 level, + [in,switch_is(level)] drsuapi_DsReplicaModRequest req + ); /*****************/ /* Function 0x08 */ diff --git a/source4/rpc_server/drsuapi/dcesrv_drsuapi.c b/source4/rpc_server/drsuapi/dcesrv_drsuapi.c index 8ea7defe3b0..a5418a1a938 100644 --- a/source4/rpc_server/drsuapi/dcesrv_drsuapi.c +++ b/source4/rpc_server/drsuapi/dcesrv_drsuapi.c @@ -259,30 +259,30 @@ static WERROR dcesrv_drsuapi_DsReplicaSync(struct dcesrv_call_state *dce_call, T } /* - DRSUAPI_REPLICA_ADD + drsuapi_DsReplicaAdd */ -static WERROR dcesrv_DRSUAPI_REPLICA_ADD(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, - struct DRSUAPI_REPLICA_ADD *r) +static WERROR dcesrv_drsuapi_DsReplicaAdd(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, + struct drsuapi_DsReplicaAdd *r) { DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR); } /* - DRSUAPI_REPLICA_DEL + drsuapi_DsReplicaDel */ -static WERROR dcesrv_DRSUAPI_REPLICA_DEL(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, - struct DRSUAPI_REPLICA_DEL *r) +static WERROR dcesrv_drsuapi_DsReplicaDel(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, + struct drsuapi_DsReplicaDel *r) { DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR); } /* - DRSUAPI_REPLICA_MODIFY + drsuapi_DsReplicaModify */ -static WERROR dcesrv_DRSUAPI_REPLICA_MODIFY(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, - struct DRSUAPI_REPLICA_MODIFY *r) +static WERROR dcesrv_drsuapi_DsReplicaMod(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, + struct drsuapi_DsReplicaMod *r) { DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR); } -- 2.11.4.GIT