LCOV - code coverage report
Current view: top level - bin/default/librpc/gen_ndr - ndr_drsuapi_c.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 179 1637 10.9 %
Date: 2021-09-23 10:06:22 Functions: 31 152 20.4 %

          Line data    Source code
       1             : /* client functions auto-generated by pidl */
       2             : 
       3             : #include "includes.h"
       4             : #include <tevent.h>
       5             : #include "lib/util/tevent_ntstatus.h"
       6             : #include "bin/default/librpc/gen_ndr/ndr_drsuapi.h"
       7             : #include "bin/default/librpc/gen_ndr/ndr_drsuapi_c.h"
       8             : 
       9             : /* drsuapi - client functions generated by pidl */
      10             : 
      11             : struct dcerpc_drsuapi_DsBind_r_state {
      12             :         TALLOC_CTX *out_mem_ctx;
      13             : };
      14             : 
      15             : static void dcerpc_drsuapi_DsBind_r_done(struct tevent_req *subreq);
      16             : 
      17          25 : struct tevent_req *dcerpc_drsuapi_DsBind_r_send(TALLOC_CTX *mem_ctx,
      18             :         struct tevent_context *ev,
      19             :         struct dcerpc_binding_handle *h,
      20             :         struct drsuapi_DsBind *r)
      21             : {
      22             :         struct tevent_req *req;
      23             :         struct dcerpc_drsuapi_DsBind_r_state *state;
      24             :         struct tevent_req *subreq;
      25             : 
      26          25 :         req = tevent_req_create(mem_ctx, &state,
      27             :                                 struct dcerpc_drsuapi_DsBind_r_state);
      28          25 :         if (req == NULL) {
      29           0 :                 return NULL;
      30             :         }
      31             : 
      32          25 :         state->out_mem_ctx = talloc_new(state);
      33          25 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
      34           0 :                 return tevent_req_post(req, ev);
      35             :         }
      36             : 
      37          25 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
      38             :                         NULL, &ndr_table_drsuapi,
      39          25 :                         NDR_DRSUAPI_DSBIND, state->out_mem_ctx, r);
      40          25 :         if (tevent_req_nomem(subreq, req)) {
      41           0 :                 return tevent_req_post(req, ev);
      42             :         }
      43          25 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsBind_r_done, req);
      44             : 
      45          25 :         return req;
      46             : }
      47             : 
      48          25 : static void dcerpc_drsuapi_DsBind_r_done(struct tevent_req *subreq)
      49             : {
      50          19 :         struct tevent_req *req =
      51          25 :                 tevent_req_callback_data(subreq,
      52             :                 struct tevent_req);
      53             :         NTSTATUS status;
      54             : 
      55          25 :         status = dcerpc_binding_handle_call_recv(subreq);
      56          25 :         TALLOC_FREE(subreq);
      57          25 :         if (tevent_req_nterror(req, status)) {
      58           0 :                 return;
      59             :         }
      60             : 
      61          25 :         tevent_req_done(req);
      62             : }
      63             : 
      64          25 : NTSTATUS dcerpc_drsuapi_DsBind_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
      65             : {
      66          19 :         struct dcerpc_drsuapi_DsBind_r_state *state =
      67          25 :                 tevent_req_data(req,
      68             :                 struct dcerpc_drsuapi_DsBind_r_state);
      69             :         NTSTATUS status;
      70             : 
      71          25 :         if (tevent_req_is_nterror(req, &status)) {
      72           0 :                 tevent_req_received(req);
      73           0 :                 return status;
      74             :         }
      75             : 
      76          25 :         talloc_steal(mem_ctx, state->out_mem_ctx);
      77             : 
      78          25 :         tevent_req_received(req);
      79          25 :         return NT_STATUS_OK;
      80             : }
      81             : 
      82        1944 : NTSTATUS dcerpc_drsuapi_DsBind_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct drsuapi_DsBind *r)
      83             : {
      84             :         NTSTATUS status;
      85             : 
      86        1944 :         status = dcerpc_binding_handle_call(h,
      87             :                         NULL, &ndr_table_drsuapi,
      88             :                         NDR_DRSUAPI_DSBIND, mem_ctx, r);
      89             : 
      90        1944 :         return status;
      91             : }
      92             : 
      93             : struct dcerpc_drsuapi_DsBind_state {
      94             :         struct drsuapi_DsBind orig;
      95             :         struct drsuapi_DsBind tmp;
      96             :         TALLOC_CTX *out_mem_ctx;
      97             : };
      98             : 
      99             : static void dcerpc_drsuapi_DsBind_done(struct tevent_req *subreq);
     100             : 
     101           0 : struct tevent_req *dcerpc_drsuapi_DsBind_send(TALLOC_CTX *mem_ctx,
     102             :                                               struct tevent_context *ev,
     103             :                                               struct dcerpc_binding_handle *h,
     104             :                                               struct GUID *_bind_guid /* [in] [unique] */,
     105             :                                               struct drsuapi_DsBindInfoCtr *_bind_info /* [in,out] [unique] */,
     106             :                                               struct policy_handle *_bind_handle /* [out] [ref] */)
     107             : {
     108             :         struct tevent_req *req;
     109             :         struct dcerpc_drsuapi_DsBind_state *state;
     110             :         struct tevent_req *subreq;
     111             : 
     112           0 :         req = tevent_req_create(mem_ctx, &state,
     113             :                                 struct dcerpc_drsuapi_DsBind_state);
     114           0 :         if (req == NULL) {
     115           0 :                 return NULL;
     116             :         }
     117           0 :         state->out_mem_ctx = NULL;
     118             : 
     119             :         /* In parameters */
     120           0 :         state->orig.in.bind_guid = _bind_guid;
     121           0 :         state->orig.in.bind_info = _bind_info;
     122             : 
     123             :         /* Out parameters */
     124           0 :         state->orig.out.bind_info = _bind_info;
     125           0 :         state->orig.out.bind_handle = _bind_handle;
     126             : 
     127             :         /* Result */
     128           0 :         NDR_ZERO_STRUCT(state->orig.out.result);
     129             : 
     130           0 :         state->out_mem_ctx = talloc_named_const(state, 0,
     131             :                              "dcerpc_drsuapi_DsBind_out_memory");
     132           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
     133           0 :                 return tevent_req_post(req, ev);
     134             :         }
     135             : 
     136             :         /* make a temporary copy, that we pass to the dispatch function */
     137           0 :         state->tmp = state->orig;
     138             : 
     139           0 :         subreq = dcerpc_drsuapi_DsBind_r_send(state, ev, h, &state->tmp);
     140           0 :         if (tevent_req_nomem(subreq, req)) {
     141           0 :                 return tevent_req_post(req, ev);
     142             :         }
     143           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsBind_done, req);
     144           0 :         return req;
     145             : }
     146             : 
     147           0 : static void dcerpc_drsuapi_DsBind_done(struct tevent_req *subreq)
     148             : {
     149           0 :         struct tevent_req *req = tevent_req_callback_data(
     150             :                 subreq, struct tevent_req);
     151           0 :         struct dcerpc_drsuapi_DsBind_state *state = tevent_req_data(
     152             :                 req, struct dcerpc_drsuapi_DsBind_state);
     153             :         NTSTATUS status;
     154             :         TALLOC_CTX *mem_ctx;
     155             : 
     156           0 :         if (state->out_mem_ctx) {
     157           0 :                 mem_ctx = state->out_mem_ctx;
     158             :         } else {
     159           0 :                 mem_ctx = state;
     160             :         }
     161             : 
     162           0 :         status = dcerpc_drsuapi_DsBind_r_recv(subreq, mem_ctx);
     163           0 :         TALLOC_FREE(subreq);
     164           0 :         if (tevent_req_nterror(req, status)) {
     165           0 :                 return;
     166             :         }
     167             : 
     168             :         /* Copy out parameters */
     169           0 :         if (state->orig.out.bind_info && state->tmp.out.bind_info) {
     170           0 :                 *state->orig.out.bind_info = *state->tmp.out.bind_info;
     171             :         }
     172           0 :         *state->orig.out.bind_handle = *state->tmp.out.bind_handle;
     173             : 
     174             :         /* Copy result */
     175           0 :         state->orig.out.result = state->tmp.out.result;
     176             : 
     177             :         /* Reset temporary structure */
     178           0 :         NDR_ZERO_STRUCT(state->tmp);
     179             : 
     180           0 :         tevent_req_done(req);
     181             : }
     182             : 
     183           0 : NTSTATUS dcerpc_drsuapi_DsBind_recv(struct tevent_req *req,
     184             :                                     TALLOC_CTX *mem_ctx,
     185             :                                     WERROR *result)
     186             : {
     187           0 :         struct dcerpc_drsuapi_DsBind_state *state = tevent_req_data(
     188             :                 req, struct dcerpc_drsuapi_DsBind_state);
     189             :         NTSTATUS status;
     190             : 
     191           0 :         if (tevent_req_is_nterror(req, &status)) {
     192           0 :                 tevent_req_received(req);
     193           0 :                 return status;
     194             :         }
     195             : 
     196             :         /* Steal possible out parameters to the callers context */
     197           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
     198             : 
     199             :         /* Return result */
     200           0 :         *result = state->orig.out.result;
     201             : 
     202           0 :         tevent_req_received(req);
     203           0 :         return NT_STATUS_OK;
     204             : }
     205             : 
     206           0 : NTSTATUS dcerpc_drsuapi_DsBind(struct dcerpc_binding_handle *h,
     207             :                                TALLOC_CTX *mem_ctx,
     208             :                                struct GUID *_bind_guid /* [in] [unique] */,
     209             :                                struct drsuapi_DsBindInfoCtr *_bind_info /* [in,out] [unique] */,
     210             :                                struct policy_handle *_bind_handle /* [out] [ref] */,
     211             :                                WERROR *result)
     212             : {
     213             :         struct drsuapi_DsBind r;
     214             :         NTSTATUS status;
     215             : 
     216             :         /* In parameters */
     217           0 :         r.in.bind_guid = _bind_guid;
     218           0 :         r.in.bind_info = _bind_info;
     219             : 
     220             :         /* Out parameters */
     221           0 :         r.out.bind_info = _bind_info;
     222           0 :         r.out.bind_handle = _bind_handle;
     223             : 
     224             :         /* Result */
     225           0 :         NDR_ZERO_STRUCT(r.out.result);
     226             : 
     227           0 :         status = dcerpc_drsuapi_DsBind_r(h, mem_ctx, &r);
     228           0 :         if (!NT_STATUS_IS_OK(status)) {
     229           0 :                 return status;
     230             :         }
     231             : 
     232             :         /* Return variables */
     233           0 :         if (_bind_info && r.out.bind_info) {
     234           0 :                 *_bind_info = *r.out.bind_info;
     235             :         }
     236           0 :         *_bind_handle = *r.out.bind_handle;
     237             : 
     238             :         /* Return result */
     239           0 :         *result = r.out.result;
     240             : 
     241           0 :         return NT_STATUS_OK;
     242             : }
     243             : 
     244             : struct dcerpc_drsuapi_DsUnbind_r_state {
     245             :         TALLOC_CTX *out_mem_ctx;
     246             : };
     247             : 
     248             : static void dcerpc_drsuapi_DsUnbind_r_done(struct tevent_req *subreq);
     249             : 
     250           0 : struct tevent_req *dcerpc_drsuapi_DsUnbind_r_send(TALLOC_CTX *mem_ctx,
     251             :         struct tevent_context *ev,
     252             :         struct dcerpc_binding_handle *h,
     253             :         struct drsuapi_DsUnbind *r)
     254             : {
     255             :         struct tevent_req *req;
     256             :         struct dcerpc_drsuapi_DsUnbind_r_state *state;
     257             :         struct tevent_req *subreq;
     258             : 
     259           0 :         req = tevent_req_create(mem_ctx, &state,
     260             :                                 struct dcerpc_drsuapi_DsUnbind_r_state);
     261           0 :         if (req == NULL) {
     262           0 :                 return NULL;
     263             :         }
     264             : 
     265           0 :         state->out_mem_ctx = talloc_new(state);
     266           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
     267           0 :                 return tevent_req_post(req, ev);
     268             :         }
     269             : 
     270           0 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
     271             :                         NULL, &ndr_table_drsuapi,
     272           0 :                         NDR_DRSUAPI_DSUNBIND, state->out_mem_ctx, r);
     273           0 :         if (tevent_req_nomem(subreq, req)) {
     274           0 :                 return tevent_req_post(req, ev);
     275             :         }
     276           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsUnbind_r_done, req);
     277             : 
     278           0 :         return req;
     279             : }
     280             : 
     281           0 : static void dcerpc_drsuapi_DsUnbind_r_done(struct tevent_req *subreq)
     282             : {
     283           0 :         struct tevent_req *req =
     284           0 :                 tevent_req_callback_data(subreq,
     285             :                 struct tevent_req);
     286             :         NTSTATUS status;
     287             : 
     288           0 :         status = dcerpc_binding_handle_call_recv(subreq);
     289           0 :         TALLOC_FREE(subreq);
     290           0 :         if (tevent_req_nterror(req, status)) {
     291           0 :                 return;
     292             :         }
     293             : 
     294           0 :         tevent_req_done(req);
     295             : }
     296             : 
     297           0 : NTSTATUS dcerpc_drsuapi_DsUnbind_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
     298             : {
     299           0 :         struct dcerpc_drsuapi_DsUnbind_r_state *state =
     300           0 :                 tevent_req_data(req,
     301             :                 struct dcerpc_drsuapi_DsUnbind_r_state);
     302             :         NTSTATUS status;
     303             : 
     304           0 :         if (tevent_req_is_nterror(req, &status)) {
     305           0 :                 tevent_req_received(req);
     306           0 :                 return status;
     307             :         }
     308             : 
     309           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
     310             : 
     311           0 :         tevent_req_received(req);
     312           0 :         return NT_STATUS_OK;
     313             : }
     314             : 
     315          25 : NTSTATUS dcerpc_drsuapi_DsUnbind_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct drsuapi_DsUnbind *r)
     316             : {
     317             :         NTSTATUS status;
     318             : 
     319          25 :         status = dcerpc_binding_handle_call(h,
     320             :                         NULL, &ndr_table_drsuapi,
     321             :                         NDR_DRSUAPI_DSUNBIND, mem_ctx, r);
     322             : 
     323          25 :         return status;
     324             : }
     325             : 
     326             : struct dcerpc_drsuapi_DsUnbind_state {
     327             :         struct drsuapi_DsUnbind orig;
     328             :         struct drsuapi_DsUnbind tmp;
     329             :         TALLOC_CTX *out_mem_ctx;
     330             : };
     331             : 
     332             : static void dcerpc_drsuapi_DsUnbind_done(struct tevent_req *subreq);
     333             : 
     334           0 : struct tevent_req *dcerpc_drsuapi_DsUnbind_send(TALLOC_CTX *mem_ctx,
     335             :                                                 struct tevent_context *ev,
     336             :                                                 struct dcerpc_binding_handle *h,
     337             :                                                 struct policy_handle *_bind_handle /* [in,out] [ref] */)
     338             : {
     339             :         struct tevent_req *req;
     340             :         struct dcerpc_drsuapi_DsUnbind_state *state;
     341             :         struct tevent_req *subreq;
     342             : 
     343           0 :         req = tevent_req_create(mem_ctx, &state,
     344             :                                 struct dcerpc_drsuapi_DsUnbind_state);
     345           0 :         if (req == NULL) {
     346           0 :                 return NULL;
     347             :         }
     348           0 :         state->out_mem_ctx = NULL;
     349             : 
     350             :         /* In parameters */
     351           0 :         state->orig.in.bind_handle = _bind_handle;
     352             : 
     353             :         /* Out parameters */
     354           0 :         state->orig.out.bind_handle = _bind_handle;
     355             : 
     356             :         /* Result */
     357           0 :         NDR_ZERO_STRUCT(state->orig.out.result);
     358             : 
     359           0 :         state->out_mem_ctx = talloc_named_const(state, 0,
     360             :                              "dcerpc_drsuapi_DsUnbind_out_memory");
     361           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
     362           0 :                 return tevent_req_post(req, ev);
     363             :         }
     364             : 
     365             :         /* make a temporary copy, that we pass to the dispatch function */
     366           0 :         state->tmp = state->orig;
     367             : 
     368           0 :         subreq = dcerpc_drsuapi_DsUnbind_r_send(state, ev, h, &state->tmp);
     369           0 :         if (tevent_req_nomem(subreq, req)) {
     370           0 :                 return tevent_req_post(req, ev);
     371             :         }
     372           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsUnbind_done, req);
     373           0 :         return req;
     374             : }
     375             : 
     376           0 : static void dcerpc_drsuapi_DsUnbind_done(struct tevent_req *subreq)
     377             : {
     378           0 :         struct tevent_req *req = tevent_req_callback_data(
     379             :                 subreq, struct tevent_req);
     380           0 :         struct dcerpc_drsuapi_DsUnbind_state *state = tevent_req_data(
     381             :                 req, struct dcerpc_drsuapi_DsUnbind_state);
     382             :         NTSTATUS status;
     383             :         TALLOC_CTX *mem_ctx;
     384             : 
     385           0 :         if (state->out_mem_ctx) {
     386           0 :                 mem_ctx = state->out_mem_ctx;
     387             :         } else {
     388           0 :                 mem_ctx = state;
     389             :         }
     390             : 
     391           0 :         status = dcerpc_drsuapi_DsUnbind_r_recv(subreq, mem_ctx);
     392           0 :         TALLOC_FREE(subreq);
     393           0 :         if (tevent_req_nterror(req, status)) {
     394           0 :                 return;
     395             :         }
     396             : 
     397             :         /* Copy out parameters */
     398           0 :         *state->orig.out.bind_handle = *state->tmp.out.bind_handle;
     399             : 
     400             :         /* Copy result */
     401           0 :         state->orig.out.result = state->tmp.out.result;
     402             : 
     403             :         /* Reset temporary structure */
     404           0 :         NDR_ZERO_STRUCT(state->tmp);
     405             : 
     406           0 :         tevent_req_done(req);
     407             : }
     408             : 
     409           0 : NTSTATUS dcerpc_drsuapi_DsUnbind_recv(struct tevent_req *req,
     410             :                                       TALLOC_CTX *mem_ctx,
     411             :                                       WERROR *result)
     412             : {
     413           0 :         struct dcerpc_drsuapi_DsUnbind_state *state = tevent_req_data(
     414             :                 req, struct dcerpc_drsuapi_DsUnbind_state);
     415             :         NTSTATUS status;
     416             : 
     417           0 :         if (tevent_req_is_nterror(req, &status)) {
     418           0 :                 tevent_req_received(req);
     419           0 :                 return status;
     420             :         }
     421             : 
     422             :         /* Steal possible out parameters to the callers context */
     423           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
     424             : 
     425             :         /* Return result */
     426           0 :         *result = state->orig.out.result;
     427             : 
     428           0 :         tevent_req_received(req);
     429           0 :         return NT_STATUS_OK;
     430             : }
     431             : 
     432           0 : NTSTATUS dcerpc_drsuapi_DsUnbind(struct dcerpc_binding_handle *h,
     433             :                                  TALLOC_CTX *mem_ctx,
     434             :                                  struct policy_handle *_bind_handle /* [in,out] [ref] */,
     435             :                                  WERROR *result)
     436             : {
     437             :         struct drsuapi_DsUnbind r;
     438             :         NTSTATUS status;
     439             : 
     440             :         /* In parameters */
     441           0 :         r.in.bind_handle = _bind_handle;
     442             : 
     443             :         /* Out parameters */
     444           0 :         r.out.bind_handle = _bind_handle;
     445             : 
     446             :         /* Result */
     447           0 :         NDR_ZERO_STRUCT(r.out.result);
     448             : 
     449           0 :         status = dcerpc_drsuapi_DsUnbind_r(h, mem_ctx, &r);
     450           0 :         if (!NT_STATUS_IS_OK(status)) {
     451           0 :                 return status;
     452             :         }
     453             : 
     454             :         /* Return variables */
     455           0 :         *_bind_handle = *r.out.bind_handle;
     456             : 
     457             :         /* Return result */
     458           0 :         *result = r.out.result;
     459             : 
     460           0 :         return NT_STATUS_OK;
     461             : }
     462             : 
     463             : struct dcerpc_drsuapi_DsReplicaSync_r_state {
     464             :         TALLOC_CTX *out_mem_ctx;
     465             : };
     466             : 
     467             : static void dcerpc_drsuapi_DsReplicaSync_r_done(struct tevent_req *subreq);
     468             : 
     469        1827 : struct tevent_req *dcerpc_drsuapi_DsReplicaSync_r_send(TALLOC_CTX *mem_ctx,
     470             :         struct tevent_context *ev,
     471             :         struct dcerpc_binding_handle *h,
     472             :         struct drsuapi_DsReplicaSync *r)
     473             : {
     474             :         struct tevent_req *req;
     475             :         struct dcerpc_drsuapi_DsReplicaSync_r_state *state;
     476             :         struct tevent_req *subreq;
     477             : 
     478        1827 :         req = tevent_req_create(mem_ctx, &state,
     479             :                                 struct dcerpc_drsuapi_DsReplicaSync_r_state);
     480        1827 :         if (req == NULL) {
     481           0 :                 return NULL;
     482             :         }
     483             : 
     484        1827 :         state->out_mem_ctx = NULL;
     485             : 
     486        1827 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
     487             :                         NULL, &ndr_table_drsuapi,
     488             :                         NDR_DRSUAPI_DSREPLICASYNC, state, r);
     489        1827 :         if (tevent_req_nomem(subreq, req)) {
     490           0 :                 return tevent_req_post(req, ev);
     491             :         }
     492        1827 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsReplicaSync_r_done, req);
     493             : 
     494        1827 :         return req;
     495             : }
     496             : 
     497        1827 : static void dcerpc_drsuapi_DsReplicaSync_r_done(struct tevent_req *subreq)
     498             : {
     499        1827 :         struct tevent_req *req =
     500        1827 :                 tevent_req_callback_data(subreq,
     501             :                 struct tevent_req);
     502             :         NTSTATUS status;
     503             : 
     504        1827 :         status = dcerpc_binding_handle_call_recv(subreq);
     505        1827 :         TALLOC_FREE(subreq);
     506        1827 :         if (tevent_req_nterror(req, status)) {
     507           0 :                 return;
     508             :         }
     509             : 
     510        1827 :         tevent_req_done(req);
     511             : }
     512             : 
     513        1827 : NTSTATUS dcerpc_drsuapi_DsReplicaSync_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
     514             : {
     515        1827 :         struct dcerpc_drsuapi_DsReplicaSync_r_state *state =
     516        1827 :                 tevent_req_data(req,
     517             :                 struct dcerpc_drsuapi_DsReplicaSync_r_state);
     518             :         NTSTATUS status;
     519             : 
     520        1827 :         if (tevent_req_is_nterror(req, &status)) {
     521           0 :                 tevent_req_received(req);
     522           0 :                 return status;
     523             :         }
     524             : 
     525        1827 :         talloc_steal(mem_ctx, state->out_mem_ctx);
     526             : 
     527        1827 :         tevent_req_received(req);
     528        1827 :         return NT_STATUS_OK;
     529             : }
     530             : 
     531         924 : NTSTATUS dcerpc_drsuapi_DsReplicaSync_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct drsuapi_DsReplicaSync *r)
     532             : {
     533             :         NTSTATUS status;
     534             : 
     535         924 :         status = dcerpc_binding_handle_call(h,
     536             :                         NULL, &ndr_table_drsuapi,
     537             :                         NDR_DRSUAPI_DSREPLICASYNC, mem_ctx, r);
     538             : 
     539         924 :         return status;
     540             : }
     541             : 
     542             : struct dcerpc_drsuapi_DsReplicaSync_state {
     543             :         struct drsuapi_DsReplicaSync orig;
     544             :         struct drsuapi_DsReplicaSync tmp;
     545             :         TALLOC_CTX *out_mem_ctx;
     546             : };
     547             : 
     548             : static void dcerpc_drsuapi_DsReplicaSync_done(struct tevent_req *subreq);
     549             : 
     550           0 : struct tevent_req *dcerpc_drsuapi_DsReplicaSync_send(TALLOC_CTX *mem_ctx,
     551             :                                                      struct tevent_context *ev,
     552             :                                                      struct dcerpc_binding_handle *h,
     553             :                                                      struct policy_handle *_bind_handle /* [in] [ref] */,
     554             :                                                      uint32_t _level /* [in]  */,
     555             :                                                      union drsuapi_DsReplicaSyncRequest *_req /* [in] [ref,switch_is(level)] */)
     556             : {
     557             :         struct tevent_req *req;
     558             :         struct dcerpc_drsuapi_DsReplicaSync_state *state;
     559             :         struct tevent_req *subreq;
     560             : 
     561           0 :         req = tevent_req_create(mem_ctx, &state,
     562             :                                 struct dcerpc_drsuapi_DsReplicaSync_state);
     563           0 :         if (req == NULL) {
     564           0 :                 return NULL;
     565             :         }
     566           0 :         state->out_mem_ctx = NULL;
     567             : 
     568             :         /* In parameters */
     569           0 :         state->orig.in.bind_handle = _bind_handle;
     570           0 :         state->orig.in.level = _level;
     571           0 :         state->orig.in.req = _req;
     572             : 
     573             :         /* Out parameters */
     574             : 
     575             :         /* Result */
     576           0 :         NDR_ZERO_STRUCT(state->orig.out.result);
     577             : 
     578             :         /* make a temporary copy, that we pass to the dispatch function */
     579           0 :         state->tmp = state->orig;
     580             : 
     581           0 :         subreq = dcerpc_drsuapi_DsReplicaSync_r_send(state, ev, h, &state->tmp);
     582           0 :         if (tevent_req_nomem(subreq, req)) {
     583           0 :                 return tevent_req_post(req, ev);
     584             :         }
     585           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsReplicaSync_done, req);
     586           0 :         return req;
     587             : }
     588             : 
     589           0 : static void dcerpc_drsuapi_DsReplicaSync_done(struct tevent_req *subreq)
     590             : {
     591           0 :         struct tevent_req *req = tevent_req_callback_data(
     592             :                 subreq, struct tevent_req);
     593           0 :         struct dcerpc_drsuapi_DsReplicaSync_state *state = tevent_req_data(
     594             :                 req, struct dcerpc_drsuapi_DsReplicaSync_state);
     595             :         NTSTATUS status;
     596             :         TALLOC_CTX *mem_ctx;
     597             : 
     598           0 :         if (state->out_mem_ctx) {
     599           0 :                 mem_ctx = state->out_mem_ctx;
     600             :         } else {
     601           0 :                 mem_ctx = state;
     602             :         }
     603             : 
     604           0 :         status = dcerpc_drsuapi_DsReplicaSync_r_recv(subreq, mem_ctx);
     605           0 :         TALLOC_FREE(subreq);
     606           0 :         if (tevent_req_nterror(req, status)) {
     607           0 :                 return;
     608             :         }
     609             : 
     610             :         /* Copy out parameters */
     611             : 
     612             :         /* Copy result */
     613           0 :         state->orig.out.result = state->tmp.out.result;
     614             : 
     615             :         /* Reset temporary structure */
     616           0 :         NDR_ZERO_STRUCT(state->tmp);
     617             : 
     618           0 :         tevent_req_done(req);
     619             : }
     620             : 
     621           0 : NTSTATUS dcerpc_drsuapi_DsReplicaSync_recv(struct tevent_req *req,
     622             :                                            TALLOC_CTX *mem_ctx,
     623             :                                            WERROR *result)
     624             : {
     625           0 :         struct dcerpc_drsuapi_DsReplicaSync_state *state = tevent_req_data(
     626             :                 req, struct dcerpc_drsuapi_DsReplicaSync_state);
     627             :         NTSTATUS status;
     628             : 
     629           0 :         if (tevent_req_is_nterror(req, &status)) {
     630           0 :                 tevent_req_received(req);
     631           0 :                 return status;
     632             :         }
     633             : 
     634             :         /* Steal possible out parameters to the callers context */
     635           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
     636             : 
     637             :         /* Return result */
     638           0 :         *result = state->orig.out.result;
     639             : 
     640           0 :         tevent_req_received(req);
     641           0 :         return NT_STATUS_OK;
     642             : }
     643             : 
     644           0 : NTSTATUS dcerpc_drsuapi_DsReplicaSync(struct dcerpc_binding_handle *h,
     645             :                                       TALLOC_CTX *mem_ctx,
     646             :                                       struct policy_handle *_bind_handle /* [in] [ref] */,
     647             :                                       uint32_t _level /* [in]  */,
     648             :                                       union drsuapi_DsReplicaSyncRequest *_req /* [in] [ref,switch_is(level)] */,
     649             :                                       WERROR *result)
     650             : {
     651             :         struct drsuapi_DsReplicaSync r;
     652             :         NTSTATUS status;
     653             : 
     654             :         /* In parameters */
     655           0 :         r.in.bind_handle = _bind_handle;
     656           0 :         r.in.level = _level;
     657           0 :         r.in.req = _req;
     658             : 
     659             :         /* Out parameters */
     660             : 
     661             :         /* Result */
     662           0 :         NDR_ZERO_STRUCT(r.out.result);
     663             : 
     664           0 :         status = dcerpc_drsuapi_DsReplicaSync_r(h, mem_ctx, &r);
     665           0 :         if (!NT_STATUS_IS_OK(status)) {
     666           0 :                 return status;
     667             :         }
     668             : 
     669             :         /* Return variables */
     670             : 
     671             :         /* Return result */
     672           0 :         *result = r.out.result;
     673             : 
     674           0 :         return NT_STATUS_OK;
     675             : }
     676             : 
     677             : struct dcerpc_drsuapi_DsGetNCChanges_r_state {
     678             :         TALLOC_CTX *out_mem_ctx;
     679             : };
     680             : 
     681             : static void dcerpc_drsuapi_DsGetNCChanges_r_done(struct tevent_req *subreq);
     682             : 
     683        5142 : struct tevent_req *dcerpc_drsuapi_DsGetNCChanges_r_send(TALLOC_CTX *mem_ctx,
     684             :         struct tevent_context *ev,
     685             :         struct dcerpc_binding_handle *h,
     686             :         struct drsuapi_DsGetNCChanges *r)
     687             : {
     688             :         struct tevent_req *req;
     689             :         struct dcerpc_drsuapi_DsGetNCChanges_r_state *state;
     690             :         struct tevent_req *subreq;
     691             : 
     692        5142 :         req = tevent_req_create(mem_ctx, &state,
     693             :                                 struct dcerpc_drsuapi_DsGetNCChanges_r_state);
     694        5142 :         if (req == NULL) {
     695           0 :                 return NULL;
     696             :         }
     697             : 
     698        5142 :         state->out_mem_ctx = talloc_new(state);
     699        5142 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
     700           0 :                 return tevent_req_post(req, ev);
     701             :         }
     702             : 
     703        5142 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
     704             :                         NULL, &ndr_table_drsuapi,
     705        5142 :                         NDR_DRSUAPI_DSGETNCCHANGES, state->out_mem_ctx, r);
     706        5142 :         if (tevent_req_nomem(subreq, req)) {
     707           0 :                 return tevent_req_post(req, ev);
     708             :         }
     709        5142 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsGetNCChanges_r_done, req);
     710             : 
     711        5142 :         return req;
     712             : }
     713             : 
     714        5142 : static void dcerpc_drsuapi_DsGetNCChanges_r_done(struct tevent_req *subreq)
     715             : {
     716        5088 :         struct tevent_req *req =
     717        5142 :                 tevent_req_callback_data(subreq,
     718             :                 struct tevent_req);
     719             :         NTSTATUS status;
     720             : 
     721        5142 :         status = dcerpc_binding_handle_call_recv(subreq);
     722        5142 :         TALLOC_FREE(subreq);
     723        5142 :         if (tevent_req_nterror(req, status)) {
     724           0 :                 return;
     725             :         }
     726             : 
     727        5142 :         tevent_req_done(req);
     728             : }
     729             : 
     730        5142 : NTSTATUS dcerpc_drsuapi_DsGetNCChanges_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
     731             : {
     732        5088 :         struct dcerpc_drsuapi_DsGetNCChanges_r_state *state =
     733        5142 :                 tevent_req_data(req,
     734             :                 struct dcerpc_drsuapi_DsGetNCChanges_r_state);
     735             :         NTSTATUS status;
     736             : 
     737        5142 :         if (tevent_req_is_nterror(req, &status)) {
     738           0 :                 tevent_req_received(req);
     739           0 :                 return status;
     740             :         }
     741             : 
     742        5142 :         talloc_steal(mem_ctx, state->out_mem_ctx);
     743             : 
     744        5142 :         tevent_req_received(req);
     745        5142 :         return NT_STATUS_OK;
     746             : }
     747             : 
     748        2102 : NTSTATUS dcerpc_drsuapi_DsGetNCChanges_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct drsuapi_DsGetNCChanges *r)
     749             : {
     750             :         NTSTATUS status;
     751             : 
     752        2102 :         status = dcerpc_binding_handle_call(h,
     753             :                         NULL, &ndr_table_drsuapi,
     754             :                         NDR_DRSUAPI_DSGETNCCHANGES, mem_ctx, r);
     755             : 
     756        2102 :         return status;
     757             : }
     758             : 
     759             : struct dcerpc_drsuapi_DsGetNCChanges_state {
     760             :         struct drsuapi_DsGetNCChanges orig;
     761             :         struct drsuapi_DsGetNCChanges tmp;
     762             :         TALLOC_CTX *out_mem_ctx;
     763             : };
     764             : 
     765             : static void dcerpc_drsuapi_DsGetNCChanges_done(struct tevent_req *subreq);
     766             : 
     767           0 : struct tevent_req *dcerpc_drsuapi_DsGetNCChanges_send(TALLOC_CTX *mem_ctx,
     768             :                                                       struct tevent_context *ev,
     769             :                                                       struct dcerpc_binding_handle *h,
     770             :                                                       struct policy_handle *_bind_handle /* [in] [ref] */,
     771             :                                                       uint32_t _level /* [in]  */,
     772             :                                                       union drsuapi_DsGetNCChangesRequest *_req /* [in] [ref,switch_is(level)] */,
     773             :                                                       uint32_t *_level_out /* [out] [ref] */,
     774             :                                                       union drsuapi_DsGetNCChangesCtr *_ctr /* [out] [ref,switch_is(*level_out)] */)
     775             : {
     776             :         struct tevent_req *req;
     777             :         struct dcerpc_drsuapi_DsGetNCChanges_state *state;
     778             :         struct tevent_req *subreq;
     779             : 
     780           0 :         req = tevent_req_create(mem_ctx, &state,
     781             :                                 struct dcerpc_drsuapi_DsGetNCChanges_state);
     782           0 :         if (req == NULL) {
     783           0 :                 return NULL;
     784             :         }
     785           0 :         state->out_mem_ctx = NULL;
     786             : 
     787             :         /* In parameters */
     788           0 :         state->orig.in.bind_handle = _bind_handle;
     789           0 :         state->orig.in.level = _level;
     790           0 :         state->orig.in.req = _req;
     791             : 
     792             :         /* Out parameters */
     793           0 :         state->orig.out.level_out = _level_out;
     794           0 :         state->orig.out.ctr = _ctr;
     795             : 
     796             :         /* Result */
     797           0 :         NDR_ZERO_STRUCT(state->orig.out.result);
     798             : 
     799           0 :         state->out_mem_ctx = talloc_named_const(state, 0,
     800             :                              "dcerpc_drsuapi_DsGetNCChanges_out_memory");
     801           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
     802           0 :                 return tevent_req_post(req, ev);
     803             :         }
     804             : 
     805             :         /* make a temporary copy, that we pass to the dispatch function */
     806           0 :         state->tmp = state->orig;
     807             : 
     808           0 :         subreq = dcerpc_drsuapi_DsGetNCChanges_r_send(state, ev, h, &state->tmp);
     809           0 :         if (tevent_req_nomem(subreq, req)) {
     810           0 :                 return tevent_req_post(req, ev);
     811             :         }
     812           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsGetNCChanges_done, req);
     813           0 :         return req;
     814             : }
     815             : 
     816           0 : static void dcerpc_drsuapi_DsGetNCChanges_done(struct tevent_req *subreq)
     817             : {
     818           0 :         struct tevent_req *req = tevent_req_callback_data(
     819             :                 subreq, struct tevent_req);
     820           0 :         struct dcerpc_drsuapi_DsGetNCChanges_state *state = tevent_req_data(
     821             :                 req, struct dcerpc_drsuapi_DsGetNCChanges_state);
     822             :         NTSTATUS status;
     823             :         TALLOC_CTX *mem_ctx;
     824             : 
     825           0 :         if (state->out_mem_ctx) {
     826           0 :                 mem_ctx = state->out_mem_ctx;
     827             :         } else {
     828           0 :                 mem_ctx = state;
     829             :         }
     830             : 
     831           0 :         status = dcerpc_drsuapi_DsGetNCChanges_r_recv(subreq, mem_ctx);
     832           0 :         TALLOC_FREE(subreq);
     833           0 :         if (tevent_req_nterror(req, status)) {
     834           0 :                 return;
     835             :         }
     836             : 
     837             :         /* Copy out parameters */
     838           0 :         *state->orig.out.level_out = *state->tmp.out.level_out;
     839           0 :         *state->orig.out.ctr = *state->tmp.out.ctr;
     840             : 
     841             :         /* Copy result */
     842           0 :         state->orig.out.result = state->tmp.out.result;
     843             : 
     844             :         /* Reset temporary structure */
     845           0 :         NDR_ZERO_STRUCT(state->tmp);
     846             : 
     847           0 :         tevent_req_done(req);
     848             : }
     849             : 
     850           0 : NTSTATUS dcerpc_drsuapi_DsGetNCChanges_recv(struct tevent_req *req,
     851             :                                             TALLOC_CTX *mem_ctx,
     852             :                                             WERROR *result)
     853             : {
     854           0 :         struct dcerpc_drsuapi_DsGetNCChanges_state *state = tevent_req_data(
     855             :                 req, struct dcerpc_drsuapi_DsGetNCChanges_state);
     856             :         NTSTATUS status;
     857             : 
     858           0 :         if (tevent_req_is_nterror(req, &status)) {
     859           0 :                 tevent_req_received(req);
     860           0 :                 return status;
     861             :         }
     862             : 
     863             :         /* Steal possible out parameters to the callers context */
     864           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
     865             : 
     866             :         /* Return result */
     867           0 :         *result = state->orig.out.result;
     868             : 
     869           0 :         tevent_req_received(req);
     870           0 :         return NT_STATUS_OK;
     871             : }
     872             : 
     873           0 : NTSTATUS dcerpc_drsuapi_DsGetNCChanges(struct dcerpc_binding_handle *h,
     874             :                                        TALLOC_CTX *mem_ctx,
     875             :                                        struct policy_handle *_bind_handle /* [in] [ref] */,
     876             :                                        uint32_t _level /* [in]  */,
     877             :                                        union drsuapi_DsGetNCChangesRequest *_req /* [in] [ref,switch_is(level)] */,
     878             :                                        uint32_t *_level_out /* [out] [ref] */,
     879             :                                        union drsuapi_DsGetNCChangesCtr *_ctr /* [out] [ref,switch_is(*level_out)] */,
     880             :                                        WERROR *result)
     881             : {
     882             :         struct drsuapi_DsGetNCChanges r;
     883             :         NTSTATUS status;
     884             : 
     885             :         /* In parameters */
     886           0 :         r.in.bind_handle = _bind_handle;
     887           0 :         r.in.level = _level;
     888           0 :         r.in.req = _req;
     889             : 
     890             :         /* Out parameters */
     891           0 :         r.out.level_out = _level_out;
     892           0 :         r.out.ctr = _ctr;
     893             : 
     894             :         /* Result */
     895           0 :         NDR_ZERO_STRUCT(r.out.result);
     896             : 
     897           0 :         status = dcerpc_drsuapi_DsGetNCChanges_r(h, mem_ctx, &r);
     898           0 :         if (!NT_STATUS_IS_OK(status)) {
     899           0 :                 return status;
     900             :         }
     901             : 
     902             :         /* Return variables */
     903           0 :         *_level_out = *r.out.level_out;
     904           0 :         *_ctr = *r.out.ctr;
     905             : 
     906             :         /* Return result */
     907           0 :         *result = r.out.result;
     908             : 
     909           0 :         return NT_STATUS_OK;
     910             : }
     911             : 
     912             : struct dcerpc_drsuapi_DsReplicaUpdateRefs_r_state {
     913             :         TALLOC_CTX *out_mem_ctx;
     914             : };
     915             : 
     916             : static void dcerpc_drsuapi_DsReplicaUpdateRefs_r_done(struct tevent_req *subreq);
     917             : 
     918        1758 : struct tevent_req *dcerpc_drsuapi_DsReplicaUpdateRefs_r_send(TALLOC_CTX *mem_ctx,
     919             :         struct tevent_context *ev,
     920             :         struct dcerpc_binding_handle *h,
     921             :         struct drsuapi_DsReplicaUpdateRefs *r)
     922             : {
     923             :         struct tevent_req *req;
     924             :         struct dcerpc_drsuapi_DsReplicaUpdateRefs_r_state *state;
     925             :         struct tevent_req *subreq;
     926             : 
     927        1758 :         req = tevent_req_create(mem_ctx, &state,
     928             :                                 struct dcerpc_drsuapi_DsReplicaUpdateRefs_r_state);
     929        1758 :         if (req == NULL) {
     930           0 :                 return NULL;
     931             :         }
     932             : 
     933        1758 :         state->out_mem_ctx = NULL;
     934             : 
     935        1758 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
     936             :                         NULL, &ndr_table_drsuapi,
     937             :                         NDR_DRSUAPI_DSREPLICAUPDATEREFS, state, r);
     938        1758 :         if (tevent_req_nomem(subreq, req)) {
     939           0 :                 return tevent_req_post(req, ev);
     940             :         }
     941        1758 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsReplicaUpdateRefs_r_done, req);
     942             : 
     943        1758 :         return req;
     944             : }
     945             : 
     946        1758 : static void dcerpc_drsuapi_DsReplicaUpdateRefs_r_done(struct tevent_req *subreq)
     947             : {
     948        1752 :         struct tevent_req *req =
     949        1758 :                 tevent_req_callback_data(subreq,
     950             :                 struct tevent_req);
     951             :         NTSTATUS status;
     952             : 
     953        1758 :         status = dcerpc_binding_handle_call_recv(subreq);
     954        1758 :         TALLOC_FREE(subreq);
     955        1758 :         if (tevent_req_nterror(req, status)) {
     956           0 :                 return;
     957             :         }
     958             : 
     959        1758 :         tevent_req_done(req);
     960             : }
     961             : 
     962        1758 : NTSTATUS dcerpc_drsuapi_DsReplicaUpdateRefs_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
     963             : {
     964        1752 :         struct dcerpc_drsuapi_DsReplicaUpdateRefs_r_state *state =
     965        1758 :                 tevent_req_data(req,
     966             :                 struct dcerpc_drsuapi_DsReplicaUpdateRefs_r_state);
     967             :         NTSTATUS status;
     968             : 
     969        1758 :         if (tevent_req_is_nterror(req, &status)) {
     970           0 :                 tevent_req_received(req);
     971           0 :                 return status;
     972             :         }
     973             : 
     974        1758 :         talloc_steal(mem_ctx, state->out_mem_ctx);
     975             : 
     976        1758 :         tevent_req_received(req);
     977        1758 :         return NT_STATUS_OK;
     978             : }
     979             : 
     980         182 : NTSTATUS dcerpc_drsuapi_DsReplicaUpdateRefs_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct drsuapi_DsReplicaUpdateRefs *r)
     981             : {
     982             :         NTSTATUS status;
     983             : 
     984         182 :         status = dcerpc_binding_handle_call(h,
     985             :                         NULL, &ndr_table_drsuapi,
     986             :                         NDR_DRSUAPI_DSREPLICAUPDATEREFS, mem_ctx, r);
     987             : 
     988         182 :         return status;
     989             : }
     990             : 
     991             : struct dcerpc_drsuapi_DsReplicaUpdateRefs_state {
     992             :         struct drsuapi_DsReplicaUpdateRefs orig;
     993             :         struct drsuapi_DsReplicaUpdateRefs tmp;
     994             :         TALLOC_CTX *out_mem_ctx;
     995             : };
     996             : 
     997             : static void dcerpc_drsuapi_DsReplicaUpdateRefs_done(struct tevent_req *subreq);
     998             : 
     999           0 : struct tevent_req *dcerpc_drsuapi_DsReplicaUpdateRefs_send(TALLOC_CTX *mem_ctx,
    1000             :                                                            struct tevent_context *ev,
    1001             :                                                            struct dcerpc_binding_handle *h,
    1002             :                                                            struct policy_handle *_bind_handle /* [in] [ref] */,
    1003             :                                                            uint32_t _level /* [in]  */,
    1004             :                                                            union drsuapi_DsReplicaUpdateRefsRequest _req /* [in] [switch_is(level)] */)
    1005             : {
    1006             :         struct tevent_req *req;
    1007             :         struct dcerpc_drsuapi_DsReplicaUpdateRefs_state *state;
    1008             :         struct tevent_req *subreq;
    1009             : 
    1010           0 :         req = tevent_req_create(mem_ctx, &state,
    1011             :                                 struct dcerpc_drsuapi_DsReplicaUpdateRefs_state);
    1012           0 :         if (req == NULL) {
    1013           0 :                 return NULL;
    1014             :         }
    1015           0 :         state->out_mem_ctx = NULL;
    1016             : 
    1017             :         /* In parameters */
    1018           0 :         state->orig.in.bind_handle = _bind_handle;
    1019           0 :         state->orig.in.level = _level;
    1020           0 :         state->orig.in.req = _req;
    1021             : 
    1022             :         /* Out parameters */
    1023             : 
    1024             :         /* Result */
    1025           0 :         NDR_ZERO_STRUCT(state->orig.out.result);
    1026             : 
    1027             :         /* make a temporary copy, that we pass to the dispatch function */
    1028           0 :         state->tmp = state->orig;
    1029             : 
    1030           0 :         subreq = dcerpc_drsuapi_DsReplicaUpdateRefs_r_send(state, ev, h, &state->tmp);
    1031           0 :         if (tevent_req_nomem(subreq, req)) {
    1032           0 :                 return tevent_req_post(req, ev);
    1033             :         }
    1034           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsReplicaUpdateRefs_done, req);
    1035           0 :         return req;
    1036             : }
    1037             : 
    1038           0 : static void dcerpc_drsuapi_DsReplicaUpdateRefs_done(struct tevent_req *subreq)
    1039             : {
    1040           0 :         struct tevent_req *req = tevent_req_callback_data(
    1041             :                 subreq, struct tevent_req);
    1042           0 :         struct dcerpc_drsuapi_DsReplicaUpdateRefs_state *state = tevent_req_data(
    1043             :                 req, struct dcerpc_drsuapi_DsReplicaUpdateRefs_state);
    1044             :         NTSTATUS status;
    1045             :         TALLOC_CTX *mem_ctx;
    1046             : 
    1047           0 :         if (state->out_mem_ctx) {
    1048           0 :                 mem_ctx = state->out_mem_ctx;
    1049             :         } else {
    1050           0 :                 mem_ctx = state;
    1051             :         }
    1052             : 
    1053           0 :         status = dcerpc_drsuapi_DsReplicaUpdateRefs_r_recv(subreq, mem_ctx);
    1054           0 :         TALLOC_FREE(subreq);
    1055           0 :         if (tevent_req_nterror(req, status)) {
    1056           0 :                 return;
    1057             :         }
    1058             : 
    1059             :         /* Copy out parameters */
    1060             : 
    1061             :         /* Copy result */
    1062           0 :         state->orig.out.result = state->tmp.out.result;
    1063             : 
    1064             :         /* Reset temporary structure */
    1065           0 :         NDR_ZERO_STRUCT(state->tmp);
    1066             : 
    1067           0 :         tevent_req_done(req);
    1068             : }
    1069             : 
    1070           0 : NTSTATUS dcerpc_drsuapi_DsReplicaUpdateRefs_recv(struct tevent_req *req,
    1071             :                                                  TALLOC_CTX *mem_ctx,
    1072             :                                                  WERROR *result)
    1073             : {
    1074           0 :         struct dcerpc_drsuapi_DsReplicaUpdateRefs_state *state = tevent_req_data(
    1075             :                 req, struct dcerpc_drsuapi_DsReplicaUpdateRefs_state);
    1076             :         NTSTATUS status;
    1077             : 
    1078           0 :         if (tevent_req_is_nterror(req, &status)) {
    1079           0 :                 tevent_req_received(req);
    1080           0 :                 return status;
    1081             :         }
    1082             : 
    1083             :         /* Steal possible out parameters to the callers context */
    1084           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    1085             : 
    1086             :         /* Return result */
    1087           0 :         *result = state->orig.out.result;
    1088             : 
    1089           0 :         tevent_req_received(req);
    1090           0 :         return NT_STATUS_OK;
    1091             : }
    1092             : 
    1093           0 : NTSTATUS dcerpc_drsuapi_DsReplicaUpdateRefs(struct dcerpc_binding_handle *h,
    1094             :                                             TALLOC_CTX *mem_ctx,
    1095             :                                             struct policy_handle *_bind_handle /* [in] [ref] */,
    1096             :                                             uint32_t _level /* [in]  */,
    1097             :                                             union drsuapi_DsReplicaUpdateRefsRequest _req /* [in] [switch_is(level)] */,
    1098             :                                             WERROR *result)
    1099             : {
    1100             :         struct drsuapi_DsReplicaUpdateRefs r;
    1101             :         NTSTATUS status;
    1102             : 
    1103             :         /* In parameters */
    1104           0 :         r.in.bind_handle = _bind_handle;
    1105           0 :         r.in.level = _level;
    1106           0 :         r.in.req = _req;
    1107             : 
    1108             :         /* Out parameters */
    1109             : 
    1110             :         /* Result */
    1111           0 :         NDR_ZERO_STRUCT(r.out.result);
    1112             : 
    1113           0 :         status = dcerpc_drsuapi_DsReplicaUpdateRefs_r(h, mem_ctx, &r);
    1114           0 :         if (!NT_STATUS_IS_OK(status)) {
    1115           0 :                 return status;
    1116             :         }
    1117             : 
    1118             :         /* Return variables */
    1119             : 
    1120             :         /* Return result */
    1121           0 :         *result = r.out.result;
    1122             : 
    1123           0 :         return NT_STATUS_OK;
    1124             : }
    1125             : 
    1126             : struct dcerpc_drsuapi_DsReplicaAdd_r_state {
    1127             :         TALLOC_CTX *out_mem_ctx;
    1128             : };
    1129             : 
    1130             : static void dcerpc_drsuapi_DsReplicaAdd_r_done(struct tevent_req *subreq);
    1131             : 
    1132           0 : struct tevent_req *dcerpc_drsuapi_DsReplicaAdd_r_send(TALLOC_CTX *mem_ctx,
    1133             :         struct tevent_context *ev,
    1134             :         struct dcerpc_binding_handle *h,
    1135             :         struct drsuapi_DsReplicaAdd *r)
    1136             : {
    1137             :         struct tevent_req *req;
    1138             :         struct dcerpc_drsuapi_DsReplicaAdd_r_state *state;
    1139             :         struct tevent_req *subreq;
    1140             : 
    1141           0 :         req = tevent_req_create(mem_ctx, &state,
    1142             :                                 struct dcerpc_drsuapi_DsReplicaAdd_r_state);
    1143           0 :         if (req == NULL) {
    1144           0 :                 return NULL;
    1145             :         }
    1146             : 
    1147           0 :         state->out_mem_ctx = NULL;
    1148             : 
    1149           0 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    1150             :                         NULL, &ndr_table_drsuapi,
    1151             :                         NDR_DRSUAPI_DSREPLICAADD, state, r);
    1152           0 :         if (tevent_req_nomem(subreq, req)) {
    1153           0 :                 return tevent_req_post(req, ev);
    1154             :         }
    1155           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsReplicaAdd_r_done, req);
    1156             : 
    1157           0 :         return req;
    1158             : }
    1159             : 
    1160           0 : static void dcerpc_drsuapi_DsReplicaAdd_r_done(struct tevent_req *subreq)
    1161             : {
    1162           0 :         struct tevent_req *req =
    1163           0 :                 tevent_req_callback_data(subreq,
    1164             :                 struct tevent_req);
    1165             :         NTSTATUS status;
    1166             : 
    1167           0 :         status = dcerpc_binding_handle_call_recv(subreq);
    1168           0 :         TALLOC_FREE(subreq);
    1169           0 :         if (tevent_req_nterror(req, status)) {
    1170           0 :                 return;
    1171             :         }
    1172             : 
    1173           0 :         tevent_req_done(req);
    1174             : }
    1175             : 
    1176           0 : NTSTATUS dcerpc_drsuapi_DsReplicaAdd_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    1177             : {
    1178           0 :         struct dcerpc_drsuapi_DsReplicaAdd_r_state *state =
    1179           0 :                 tevent_req_data(req,
    1180             :                 struct dcerpc_drsuapi_DsReplicaAdd_r_state);
    1181             :         NTSTATUS status;
    1182             : 
    1183           0 :         if (tevent_req_is_nterror(req, &status)) {
    1184           0 :                 tevent_req_received(req);
    1185           0 :                 return status;
    1186             :         }
    1187             : 
    1188           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    1189             : 
    1190           0 :         tevent_req_received(req);
    1191           0 :         return NT_STATUS_OK;
    1192             : }
    1193             : 
    1194           0 : NTSTATUS dcerpc_drsuapi_DsReplicaAdd_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct drsuapi_DsReplicaAdd *r)
    1195             : {
    1196             :         NTSTATUS status;
    1197             : 
    1198           0 :         status = dcerpc_binding_handle_call(h,
    1199             :                         NULL, &ndr_table_drsuapi,
    1200             :                         NDR_DRSUAPI_DSREPLICAADD, mem_ctx, r);
    1201             : 
    1202           0 :         return status;
    1203             : }
    1204             : 
    1205             : struct dcerpc_drsuapi_DsReplicaAdd_state {
    1206             :         struct drsuapi_DsReplicaAdd orig;
    1207             :         struct drsuapi_DsReplicaAdd tmp;
    1208             :         TALLOC_CTX *out_mem_ctx;
    1209             : };
    1210             : 
    1211             : static void dcerpc_drsuapi_DsReplicaAdd_done(struct tevent_req *subreq);
    1212             : 
    1213           0 : struct tevent_req *dcerpc_drsuapi_DsReplicaAdd_send(TALLOC_CTX *mem_ctx,
    1214             :                                                     struct tevent_context *ev,
    1215             :                                                     struct dcerpc_binding_handle *h,
    1216             :                                                     struct policy_handle *_bind_handle /* [in] [ref] */,
    1217             :                                                     uint32_t _level /* [in]  */,
    1218             :                                                     union drsuapi_DsReplicaAddRequest _req /* [in] [switch_is(level)] */)
    1219             : {
    1220             :         struct tevent_req *req;
    1221             :         struct dcerpc_drsuapi_DsReplicaAdd_state *state;
    1222             :         struct tevent_req *subreq;
    1223             : 
    1224           0 :         req = tevent_req_create(mem_ctx, &state,
    1225             :                                 struct dcerpc_drsuapi_DsReplicaAdd_state);
    1226           0 :         if (req == NULL) {
    1227           0 :                 return NULL;
    1228             :         }
    1229           0 :         state->out_mem_ctx = NULL;
    1230             : 
    1231             :         /* In parameters */
    1232           0 :         state->orig.in.bind_handle = _bind_handle;
    1233           0 :         state->orig.in.level = _level;
    1234           0 :         state->orig.in.req = _req;
    1235             : 
    1236             :         /* Out parameters */
    1237             : 
    1238             :         /* Result */
    1239           0 :         NDR_ZERO_STRUCT(state->orig.out.result);
    1240             : 
    1241             :         /* make a temporary copy, that we pass to the dispatch function */
    1242           0 :         state->tmp = state->orig;
    1243             : 
    1244           0 :         subreq = dcerpc_drsuapi_DsReplicaAdd_r_send(state, ev, h, &state->tmp);
    1245           0 :         if (tevent_req_nomem(subreq, req)) {
    1246           0 :                 return tevent_req_post(req, ev);
    1247             :         }
    1248           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsReplicaAdd_done, req);
    1249           0 :         return req;
    1250             : }
    1251             : 
    1252           0 : static void dcerpc_drsuapi_DsReplicaAdd_done(struct tevent_req *subreq)
    1253             : {
    1254           0 :         struct tevent_req *req = tevent_req_callback_data(
    1255             :                 subreq, struct tevent_req);
    1256           0 :         struct dcerpc_drsuapi_DsReplicaAdd_state *state = tevent_req_data(
    1257             :                 req, struct dcerpc_drsuapi_DsReplicaAdd_state);
    1258             :         NTSTATUS status;
    1259             :         TALLOC_CTX *mem_ctx;
    1260             : 
    1261           0 :         if (state->out_mem_ctx) {
    1262           0 :                 mem_ctx = state->out_mem_ctx;
    1263             :         } else {
    1264           0 :                 mem_ctx = state;
    1265             :         }
    1266             : 
    1267           0 :         status = dcerpc_drsuapi_DsReplicaAdd_r_recv(subreq, mem_ctx);
    1268           0 :         TALLOC_FREE(subreq);
    1269           0 :         if (tevent_req_nterror(req, status)) {
    1270           0 :                 return;
    1271             :         }
    1272             : 
    1273             :         /* Copy out parameters */
    1274             : 
    1275             :         /* Copy result */
    1276           0 :         state->orig.out.result = state->tmp.out.result;
    1277             : 
    1278             :         /* Reset temporary structure */
    1279           0 :         NDR_ZERO_STRUCT(state->tmp);
    1280             : 
    1281           0 :         tevent_req_done(req);
    1282             : }
    1283             : 
    1284           0 : NTSTATUS dcerpc_drsuapi_DsReplicaAdd_recv(struct tevent_req *req,
    1285             :                                           TALLOC_CTX *mem_ctx,
    1286             :                                           WERROR *result)
    1287             : {
    1288           0 :         struct dcerpc_drsuapi_DsReplicaAdd_state *state = tevent_req_data(
    1289             :                 req, struct dcerpc_drsuapi_DsReplicaAdd_state);
    1290             :         NTSTATUS status;
    1291             : 
    1292           0 :         if (tevent_req_is_nterror(req, &status)) {
    1293           0 :                 tevent_req_received(req);
    1294           0 :                 return status;
    1295             :         }
    1296             : 
    1297             :         /* Steal possible out parameters to the callers context */
    1298           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    1299             : 
    1300             :         /* Return result */
    1301           0 :         *result = state->orig.out.result;
    1302             : 
    1303           0 :         tevent_req_received(req);
    1304           0 :         return NT_STATUS_OK;
    1305             : }
    1306             : 
    1307           0 : NTSTATUS dcerpc_drsuapi_DsReplicaAdd(struct dcerpc_binding_handle *h,
    1308             :                                      TALLOC_CTX *mem_ctx,
    1309             :                                      struct policy_handle *_bind_handle /* [in] [ref] */,
    1310             :                                      uint32_t _level /* [in]  */,
    1311             :                                      union drsuapi_DsReplicaAddRequest _req /* [in] [switch_is(level)] */,
    1312             :                                      WERROR *result)
    1313             : {
    1314             :         struct drsuapi_DsReplicaAdd r;
    1315             :         NTSTATUS status;
    1316             : 
    1317             :         /* In parameters */
    1318           0 :         r.in.bind_handle = _bind_handle;
    1319           0 :         r.in.level = _level;
    1320           0 :         r.in.req = _req;
    1321             : 
    1322             :         /* Out parameters */
    1323             : 
    1324             :         /* Result */
    1325           0 :         NDR_ZERO_STRUCT(r.out.result);
    1326             : 
    1327           0 :         status = dcerpc_drsuapi_DsReplicaAdd_r(h, mem_ctx, &r);
    1328           0 :         if (!NT_STATUS_IS_OK(status)) {
    1329           0 :                 return status;
    1330             :         }
    1331             : 
    1332             :         /* Return variables */
    1333             : 
    1334             :         /* Return result */
    1335           0 :         *result = r.out.result;
    1336             : 
    1337           0 :         return NT_STATUS_OK;
    1338             : }
    1339             : 
    1340             : struct dcerpc_drsuapi_DsReplicaDel_r_state {
    1341             :         TALLOC_CTX *out_mem_ctx;
    1342             : };
    1343             : 
    1344             : static void dcerpc_drsuapi_DsReplicaDel_r_done(struct tevent_req *subreq);
    1345             : 
    1346           0 : struct tevent_req *dcerpc_drsuapi_DsReplicaDel_r_send(TALLOC_CTX *mem_ctx,
    1347             :         struct tevent_context *ev,
    1348             :         struct dcerpc_binding_handle *h,
    1349             :         struct drsuapi_DsReplicaDel *r)
    1350             : {
    1351             :         struct tevent_req *req;
    1352             :         struct dcerpc_drsuapi_DsReplicaDel_r_state *state;
    1353             :         struct tevent_req *subreq;
    1354             : 
    1355           0 :         req = tevent_req_create(mem_ctx, &state,
    1356             :                                 struct dcerpc_drsuapi_DsReplicaDel_r_state);
    1357           0 :         if (req == NULL) {
    1358           0 :                 return NULL;
    1359             :         }
    1360             : 
    1361           0 :         state->out_mem_ctx = NULL;
    1362             : 
    1363           0 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    1364             :                         NULL, &ndr_table_drsuapi,
    1365             :                         NDR_DRSUAPI_DSREPLICADEL, state, r);
    1366           0 :         if (tevent_req_nomem(subreq, req)) {
    1367           0 :                 return tevent_req_post(req, ev);
    1368             :         }
    1369           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsReplicaDel_r_done, req);
    1370             : 
    1371           0 :         return req;
    1372             : }
    1373             : 
    1374           0 : static void dcerpc_drsuapi_DsReplicaDel_r_done(struct tevent_req *subreq)
    1375             : {
    1376           0 :         struct tevent_req *req =
    1377           0 :                 tevent_req_callback_data(subreq,
    1378             :                 struct tevent_req);
    1379             :         NTSTATUS status;
    1380             : 
    1381           0 :         status = dcerpc_binding_handle_call_recv(subreq);
    1382           0 :         TALLOC_FREE(subreq);
    1383           0 :         if (tevent_req_nterror(req, status)) {
    1384           0 :                 return;
    1385             :         }
    1386             : 
    1387           0 :         tevent_req_done(req);
    1388             : }
    1389             : 
    1390           0 : NTSTATUS dcerpc_drsuapi_DsReplicaDel_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    1391             : {
    1392           0 :         struct dcerpc_drsuapi_DsReplicaDel_r_state *state =
    1393           0 :                 tevent_req_data(req,
    1394             :                 struct dcerpc_drsuapi_DsReplicaDel_r_state);
    1395             :         NTSTATUS status;
    1396             : 
    1397           0 :         if (tevent_req_is_nterror(req, &status)) {
    1398           0 :                 tevent_req_received(req);
    1399           0 :                 return status;
    1400             :         }
    1401             : 
    1402           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    1403             : 
    1404           0 :         tevent_req_received(req);
    1405           0 :         return NT_STATUS_OK;
    1406             : }
    1407             : 
    1408           0 : NTSTATUS dcerpc_drsuapi_DsReplicaDel_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct drsuapi_DsReplicaDel *r)
    1409             : {
    1410             :         NTSTATUS status;
    1411             : 
    1412           0 :         status = dcerpc_binding_handle_call(h,
    1413             :                         NULL, &ndr_table_drsuapi,
    1414             :                         NDR_DRSUAPI_DSREPLICADEL, mem_ctx, r);
    1415             : 
    1416           0 :         return status;
    1417             : }
    1418             : 
    1419             : struct dcerpc_drsuapi_DsReplicaDel_state {
    1420             :         struct drsuapi_DsReplicaDel orig;
    1421             :         struct drsuapi_DsReplicaDel tmp;
    1422             :         TALLOC_CTX *out_mem_ctx;
    1423             : };
    1424             : 
    1425             : static void dcerpc_drsuapi_DsReplicaDel_done(struct tevent_req *subreq);
    1426             : 
    1427           0 : struct tevent_req *dcerpc_drsuapi_DsReplicaDel_send(TALLOC_CTX *mem_ctx,
    1428             :                                                     struct tevent_context *ev,
    1429             :                                                     struct dcerpc_binding_handle *h,
    1430             :                                                     struct policy_handle *_bind_handle /* [in] [ref] */,
    1431             :                                                     uint32_t _level /* [in]  */,
    1432             :                                                     union drsuapi_DsReplicaDelRequest _req /* [in] [switch_is(level)] */)
    1433             : {
    1434             :         struct tevent_req *req;
    1435             :         struct dcerpc_drsuapi_DsReplicaDel_state *state;
    1436             :         struct tevent_req *subreq;
    1437             : 
    1438           0 :         req = tevent_req_create(mem_ctx, &state,
    1439             :                                 struct dcerpc_drsuapi_DsReplicaDel_state);
    1440           0 :         if (req == NULL) {
    1441           0 :                 return NULL;
    1442             :         }
    1443           0 :         state->out_mem_ctx = NULL;
    1444             : 
    1445             :         /* In parameters */
    1446           0 :         state->orig.in.bind_handle = _bind_handle;
    1447           0 :         state->orig.in.level = _level;
    1448           0 :         state->orig.in.req = _req;
    1449             : 
    1450             :         /* Out parameters */
    1451             : 
    1452             :         /* Result */
    1453           0 :         NDR_ZERO_STRUCT(state->orig.out.result);
    1454             : 
    1455             :         /* make a temporary copy, that we pass to the dispatch function */
    1456           0 :         state->tmp = state->orig;
    1457             : 
    1458           0 :         subreq = dcerpc_drsuapi_DsReplicaDel_r_send(state, ev, h, &state->tmp);
    1459           0 :         if (tevent_req_nomem(subreq, req)) {
    1460           0 :                 return tevent_req_post(req, ev);
    1461             :         }
    1462           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsReplicaDel_done, req);
    1463           0 :         return req;
    1464             : }
    1465             : 
    1466           0 : static void dcerpc_drsuapi_DsReplicaDel_done(struct tevent_req *subreq)
    1467             : {
    1468           0 :         struct tevent_req *req = tevent_req_callback_data(
    1469             :                 subreq, struct tevent_req);
    1470           0 :         struct dcerpc_drsuapi_DsReplicaDel_state *state = tevent_req_data(
    1471             :                 req, struct dcerpc_drsuapi_DsReplicaDel_state);
    1472             :         NTSTATUS status;
    1473             :         TALLOC_CTX *mem_ctx;
    1474             : 
    1475           0 :         if (state->out_mem_ctx) {
    1476           0 :                 mem_ctx = state->out_mem_ctx;
    1477             :         } else {
    1478           0 :                 mem_ctx = state;
    1479             :         }
    1480             : 
    1481           0 :         status = dcerpc_drsuapi_DsReplicaDel_r_recv(subreq, mem_ctx);
    1482           0 :         TALLOC_FREE(subreq);
    1483           0 :         if (tevent_req_nterror(req, status)) {
    1484           0 :                 return;
    1485             :         }
    1486             : 
    1487             :         /* Copy out parameters */
    1488             : 
    1489             :         /* Copy result */
    1490           0 :         state->orig.out.result = state->tmp.out.result;
    1491             : 
    1492             :         /* Reset temporary structure */
    1493           0 :         NDR_ZERO_STRUCT(state->tmp);
    1494             : 
    1495           0 :         tevent_req_done(req);
    1496             : }
    1497             : 
    1498           0 : NTSTATUS dcerpc_drsuapi_DsReplicaDel_recv(struct tevent_req *req,
    1499             :                                           TALLOC_CTX *mem_ctx,
    1500             :                                           WERROR *result)
    1501             : {
    1502           0 :         struct dcerpc_drsuapi_DsReplicaDel_state *state = tevent_req_data(
    1503             :                 req, struct dcerpc_drsuapi_DsReplicaDel_state);
    1504             :         NTSTATUS status;
    1505             : 
    1506           0 :         if (tevent_req_is_nterror(req, &status)) {
    1507           0 :                 tevent_req_received(req);
    1508           0 :                 return status;
    1509             :         }
    1510             : 
    1511             :         /* Steal possible out parameters to the callers context */
    1512           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    1513             : 
    1514             :         /* Return result */
    1515           0 :         *result = state->orig.out.result;
    1516             : 
    1517           0 :         tevent_req_received(req);
    1518           0 :         return NT_STATUS_OK;
    1519             : }
    1520             : 
    1521           0 : NTSTATUS dcerpc_drsuapi_DsReplicaDel(struct dcerpc_binding_handle *h,
    1522             :                                      TALLOC_CTX *mem_ctx,
    1523             :                                      struct policy_handle *_bind_handle /* [in] [ref] */,
    1524             :                                      uint32_t _level /* [in]  */,
    1525             :                                      union drsuapi_DsReplicaDelRequest _req /* [in] [switch_is(level)] */,
    1526             :                                      WERROR *result)
    1527             : {
    1528             :         struct drsuapi_DsReplicaDel r;
    1529             :         NTSTATUS status;
    1530             : 
    1531             :         /* In parameters */
    1532           0 :         r.in.bind_handle = _bind_handle;
    1533           0 :         r.in.level = _level;
    1534           0 :         r.in.req = _req;
    1535             : 
    1536             :         /* Out parameters */
    1537             : 
    1538             :         /* Result */
    1539           0 :         NDR_ZERO_STRUCT(r.out.result);
    1540             : 
    1541           0 :         status = dcerpc_drsuapi_DsReplicaDel_r(h, mem_ctx, &r);
    1542           0 :         if (!NT_STATUS_IS_OK(status)) {
    1543           0 :                 return status;
    1544             :         }
    1545             : 
    1546             :         /* Return variables */
    1547             : 
    1548             :         /* Return result */
    1549           0 :         *result = r.out.result;
    1550             : 
    1551           0 :         return NT_STATUS_OK;
    1552             : }
    1553             : 
    1554             : struct dcerpc_drsuapi_DsReplicaMod_r_state {
    1555             :         TALLOC_CTX *out_mem_ctx;
    1556             : };
    1557             : 
    1558             : static void dcerpc_drsuapi_DsReplicaMod_r_done(struct tevent_req *subreq);
    1559             : 
    1560           0 : struct tevent_req *dcerpc_drsuapi_DsReplicaMod_r_send(TALLOC_CTX *mem_ctx,
    1561             :         struct tevent_context *ev,
    1562             :         struct dcerpc_binding_handle *h,
    1563             :         struct drsuapi_DsReplicaMod *r)
    1564             : {
    1565             :         struct tevent_req *req;
    1566             :         struct dcerpc_drsuapi_DsReplicaMod_r_state *state;
    1567             :         struct tevent_req *subreq;
    1568             : 
    1569           0 :         req = tevent_req_create(mem_ctx, &state,
    1570             :                                 struct dcerpc_drsuapi_DsReplicaMod_r_state);
    1571           0 :         if (req == NULL) {
    1572           0 :                 return NULL;
    1573             :         }
    1574             : 
    1575           0 :         state->out_mem_ctx = NULL;
    1576             : 
    1577           0 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    1578             :                         NULL, &ndr_table_drsuapi,
    1579             :                         NDR_DRSUAPI_DSREPLICAMOD, state, r);
    1580           0 :         if (tevent_req_nomem(subreq, req)) {
    1581           0 :                 return tevent_req_post(req, ev);
    1582             :         }
    1583           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsReplicaMod_r_done, req);
    1584             : 
    1585           0 :         return req;
    1586             : }
    1587             : 
    1588           0 : static void dcerpc_drsuapi_DsReplicaMod_r_done(struct tevent_req *subreq)
    1589             : {
    1590           0 :         struct tevent_req *req =
    1591           0 :                 tevent_req_callback_data(subreq,
    1592             :                 struct tevent_req);
    1593             :         NTSTATUS status;
    1594             : 
    1595           0 :         status = dcerpc_binding_handle_call_recv(subreq);
    1596           0 :         TALLOC_FREE(subreq);
    1597           0 :         if (tevent_req_nterror(req, status)) {
    1598           0 :                 return;
    1599             :         }
    1600             : 
    1601           0 :         tevent_req_done(req);
    1602             : }
    1603             : 
    1604           0 : NTSTATUS dcerpc_drsuapi_DsReplicaMod_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    1605             : {
    1606           0 :         struct dcerpc_drsuapi_DsReplicaMod_r_state *state =
    1607           0 :                 tevent_req_data(req,
    1608             :                 struct dcerpc_drsuapi_DsReplicaMod_r_state);
    1609             :         NTSTATUS status;
    1610             : 
    1611           0 :         if (tevent_req_is_nterror(req, &status)) {
    1612           0 :                 tevent_req_received(req);
    1613           0 :                 return status;
    1614             :         }
    1615             : 
    1616           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    1617             : 
    1618           0 :         tevent_req_received(req);
    1619           0 :         return NT_STATUS_OK;
    1620             : }
    1621             : 
    1622           0 : NTSTATUS dcerpc_drsuapi_DsReplicaMod_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct drsuapi_DsReplicaMod *r)
    1623             : {
    1624             :         NTSTATUS status;
    1625             : 
    1626           0 :         status = dcerpc_binding_handle_call(h,
    1627             :                         NULL, &ndr_table_drsuapi,
    1628             :                         NDR_DRSUAPI_DSREPLICAMOD, mem_ctx, r);
    1629             : 
    1630           0 :         return status;
    1631             : }
    1632             : 
    1633             : struct dcerpc_drsuapi_DsReplicaMod_state {
    1634             :         struct drsuapi_DsReplicaMod orig;
    1635             :         struct drsuapi_DsReplicaMod tmp;
    1636             :         TALLOC_CTX *out_mem_ctx;
    1637             : };
    1638             : 
    1639             : static void dcerpc_drsuapi_DsReplicaMod_done(struct tevent_req *subreq);
    1640             : 
    1641           0 : struct tevent_req *dcerpc_drsuapi_DsReplicaMod_send(TALLOC_CTX *mem_ctx,
    1642             :                                                     struct tevent_context *ev,
    1643             :                                                     struct dcerpc_binding_handle *h,
    1644             :                                                     struct policy_handle *_bind_handle /* [in] [ref] */,
    1645             :                                                     uint32_t _level /* [in]  */,
    1646             :                                                     union drsuapi_DsReplicaModRequest _req /* [in] [switch_is(level)] */)
    1647             : {
    1648             :         struct tevent_req *req;
    1649             :         struct dcerpc_drsuapi_DsReplicaMod_state *state;
    1650             :         struct tevent_req *subreq;
    1651             : 
    1652           0 :         req = tevent_req_create(mem_ctx, &state,
    1653             :                                 struct dcerpc_drsuapi_DsReplicaMod_state);
    1654           0 :         if (req == NULL) {
    1655           0 :                 return NULL;
    1656             :         }
    1657           0 :         state->out_mem_ctx = NULL;
    1658             : 
    1659             :         /* In parameters */
    1660           0 :         state->orig.in.bind_handle = _bind_handle;
    1661           0 :         state->orig.in.level = _level;
    1662           0 :         state->orig.in.req = _req;
    1663             : 
    1664             :         /* Out parameters */
    1665             : 
    1666             :         /* Result */
    1667           0 :         NDR_ZERO_STRUCT(state->orig.out.result);
    1668             : 
    1669             :         /* make a temporary copy, that we pass to the dispatch function */
    1670           0 :         state->tmp = state->orig;
    1671             : 
    1672           0 :         subreq = dcerpc_drsuapi_DsReplicaMod_r_send(state, ev, h, &state->tmp);
    1673           0 :         if (tevent_req_nomem(subreq, req)) {
    1674           0 :                 return tevent_req_post(req, ev);
    1675             :         }
    1676           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsReplicaMod_done, req);
    1677           0 :         return req;
    1678             : }
    1679             : 
    1680           0 : static void dcerpc_drsuapi_DsReplicaMod_done(struct tevent_req *subreq)
    1681             : {
    1682           0 :         struct tevent_req *req = tevent_req_callback_data(
    1683             :                 subreq, struct tevent_req);
    1684           0 :         struct dcerpc_drsuapi_DsReplicaMod_state *state = tevent_req_data(
    1685             :                 req, struct dcerpc_drsuapi_DsReplicaMod_state);
    1686             :         NTSTATUS status;
    1687             :         TALLOC_CTX *mem_ctx;
    1688             : 
    1689           0 :         if (state->out_mem_ctx) {
    1690           0 :                 mem_ctx = state->out_mem_ctx;
    1691             :         } else {
    1692           0 :                 mem_ctx = state;
    1693             :         }
    1694             : 
    1695           0 :         status = dcerpc_drsuapi_DsReplicaMod_r_recv(subreq, mem_ctx);
    1696           0 :         TALLOC_FREE(subreq);
    1697           0 :         if (tevent_req_nterror(req, status)) {
    1698           0 :                 return;
    1699             :         }
    1700             : 
    1701             :         /* Copy out parameters */
    1702             : 
    1703             :         /* Copy result */
    1704           0 :         state->orig.out.result = state->tmp.out.result;
    1705             : 
    1706             :         /* Reset temporary structure */
    1707           0 :         NDR_ZERO_STRUCT(state->tmp);
    1708             : 
    1709           0 :         tevent_req_done(req);
    1710             : }
    1711             : 
    1712           0 : NTSTATUS dcerpc_drsuapi_DsReplicaMod_recv(struct tevent_req *req,
    1713             :                                           TALLOC_CTX *mem_ctx,
    1714             :                                           WERROR *result)
    1715             : {
    1716           0 :         struct dcerpc_drsuapi_DsReplicaMod_state *state = tevent_req_data(
    1717             :                 req, struct dcerpc_drsuapi_DsReplicaMod_state);
    1718             :         NTSTATUS status;
    1719             : 
    1720           0 :         if (tevent_req_is_nterror(req, &status)) {
    1721           0 :                 tevent_req_received(req);
    1722           0 :                 return status;
    1723             :         }
    1724             : 
    1725             :         /* Steal possible out parameters to the callers context */
    1726           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    1727             : 
    1728             :         /* Return result */
    1729           0 :         *result = state->orig.out.result;
    1730             : 
    1731           0 :         tevent_req_received(req);
    1732           0 :         return NT_STATUS_OK;
    1733             : }
    1734             : 
    1735           0 : NTSTATUS dcerpc_drsuapi_DsReplicaMod(struct dcerpc_binding_handle *h,
    1736             :                                      TALLOC_CTX *mem_ctx,
    1737             :                                      struct policy_handle *_bind_handle /* [in] [ref] */,
    1738             :                                      uint32_t _level /* [in]  */,
    1739             :                                      union drsuapi_DsReplicaModRequest _req /* [in] [switch_is(level)] */,
    1740             :                                      WERROR *result)
    1741             : {
    1742             :         struct drsuapi_DsReplicaMod r;
    1743             :         NTSTATUS status;
    1744             : 
    1745             :         /* In parameters */
    1746           0 :         r.in.bind_handle = _bind_handle;
    1747           0 :         r.in.level = _level;
    1748           0 :         r.in.req = _req;
    1749             : 
    1750             :         /* Out parameters */
    1751             : 
    1752             :         /* Result */
    1753           0 :         NDR_ZERO_STRUCT(r.out.result);
    1754             : 
    1755           0 :         status = dcerpc_drsuapi_DsReplicaMod_r(h, mem_ctx, &r);
    1756           0 :         if (!NT_STATUS_IS_OK(status)) {
    1757           0 :                 return status;
    1758             :         }
    1759             : 
    1760             :         /* Return variables */
    1761             : 
    1762             :         /* Return result */
    1763           0 :         *result = r.out.result;
    1764             : 
    1765           0 :         return NT_STATUS_OK;
    1766             : }
    1767             : 
    1768             : struct dcerpc_drsuapi_DsGetMemberships_r_state {
    1769             :         TALLOC_CTX *out_mem_ctx;
    1770             : };
    1771             : 
    1772             : static void dcerpc_drsuapi_DsGetMemberships_r_done(struct tevent_req *subreq);
    1773             : 
    1774           0 : struct tevent_req *dcerpc_drsuapi_DsGetMemberships_r_send(TALLOC_CTX *mem_ctx,
    1775             :         struct tevent_context *ev,
    1776             :         struct dcerpc_binding_handle *h,
    1777             :         struct drsuapi_DsGetMemberships *r)
    1778             : {
    1779             :         struct tevent_req *req;
    1780             :         struct dcerpc_drsuapi_DsGetMemberships_r_state *state;
    1781             :         struct tevent_req *subreq;
    1782             : 
    1783           0 :         req = tevent_req_create(mem_ctx, &state,
    1784             :                                 struct dcerpc_drsuapi_DsGetMemberships_r_state);
    1785           0 :         if (req == NULL) {
    1786           0 :                 return NULL;
    1787             :         }
    1788             : 
    1789           0 :         state->out_mem_ctx = talloc_new(state);
    1790           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    1791           0 :                 return tevent_req_post(req, ev);
    1792             :         }
    1793             : 
    1794           0 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    1795             :                         NULL, &ndr_table_drsuapi,
    1796           0 :                         NDR_DRSUAPI_DSGETMEMBERSHIPS, state->out_mem_ctx, r);
    1797           0 :         if (tevent_req_nomem(subreq, req)) {
    1798           0 :                 return tevent_req_post(req, ev);
    1799             :         }
    1800           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsGetMemberships_r_done, req);
    1801             : 
    1802           0 :         return req;
    1803             : }
    1804             : 
    1805           0 : static void dcerpc_drsuapi_DsGetMemberships_r_done(struct tevent_req *subreq)
    1806             : {
    1807           0 :         struct tevent_req *req =
    1808           0 :                 tevent_req_callback_data(subreq,
    1809             :                 struct tevent_req);
    1810             :         NTSTATUS status;
    1811             : 
    1812           0 :         status = dcerpc_binding_handle_call_recv(subreq);
    1813           0 :         TALLOC_FREE(subreq);
    1814           0 :         if (tevent_req_nterror(req, status)) {
    1815           0 :                 return;
    1816             :         }
    1817             : 
    1818           0 :         tevent_req_done(req);
    1819             : }
    1820             : 
    1821           0 : NTSTATUS dcerpc_drsuapi_DsGetMemberships_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    1822             : {
    1823           0 :         struct dcerpc_drsuapi_DsGetMemberships_r_state *state =
    1824           0 :                 tevent_req_data(req,
    1825             :                 struct dcerpc_drsuapi_DsGetMemberships_r_state);
    1826             :         NTSTATUS status;
    1827             : 
    1828           0 :         if (tevent_req_is_nterror(req, &status)) {
    1829           0 :                 tevent_req_received(req);
    1830           0 :                 return status;
    1831             :         }
    1832             : 
    1833           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    1834             : 
    1835           0 :         tevent_req_received(req);
    1836           0 :         return NT_STATUS_OK;
    1837             : }
    1838             : 
    1839           0 : NTSTATUS dcerpc_drsuapi_DsGetMemberships_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct drsuapi_DsGetMemberships *r)
    1840             : {
    1841             :         NTSTATUS status;
    1842             : 
    1843           0 :         status = dcerpc_binding_handle_call(h,
    1844             :                         NULL, &ndr_table_drsuapi,
    1845             :                         NDR_DRSUAPI_DSGETMEMBERSHIPS, mem_ctx, r);
    1846             : 
    1847           0 :         return status;
    1848             : }
    1849             : 
    1850             : struct dcerpc_drsuapi_DsGetMemberships_state {
    1851             :         struct drsuapi_DsGetMemberships orig;
    1852             :         struct drsuapi_DsGetMemberships tmp;
    1853             :         TALLOC_CTX *out_mem_ctx;
    1854             : };
    1855             : 
    1856             : static void dcerpc_drsuapi_DsGetMemberships_done(struct tevent_req *subreq);
    1857             : 
    1858           0 : struct tevent_req *dcerpc_drsuapi_DsGetMemberships_send(TALLOC_CTX *mem_ctx,
    1859             :                                                         struct tevent_context *ev,
    1860             :                                                         struct dcerpc_binding_handle *h,
    1861             :                                                         struct policy_handle *_bind_handle /* [in] [ref] */,
    1862             :                                                         uint32_t _level /* [in]  */,
    1863             :                                                         union drsuapi_DsGetMembershipsRequest *_req /* [in] [ref,switch_is(level)] */,
    1864             :                                                         uint32_t *_level_out /* [out] [ref] */,
    1865             :                                                         union drsuapi_DsGetMembershipsCtr *_ctr /* [out] [ref,switch_is(*level_out)] */)
    1866             : {
    1867             :         struct tevent_req *req;
    1868             :         struct dcerpc_drsuapi_DsGetMemberships_state *state;
    1869             :         struct tevent_req *subreq;
    1870             : 
    1871           0 :         req = tevent_req_create(mem_ctx, &state,
    1872             :                                 struct dcerpc_drsuapi_DsGetMemberships_state);
    1873           0 :         if (req == NULL) {
    1874           0 :                 return NULL;
    1875             :         }
    1876           0 :         state->out_mem_ctx = NULL;
    1877             : 
    1878             :         /* In parameters */
    1879           0 :         state->orig.in.bind_handle = _bind_handle;
    1880           0 :         state->orig.in.level = _level;
    1881           0 :         state->orig.in.req = _req;
    1882             : 
    1883             :         /* Out parameters */
    1884           0 :         state->orig.out.level_out = _level_out;
    1885           0 :         state->orig.out.ctr = _ctr;
    1886             : 
    1887             :         /* Result */
    1888           0 :         NDR_ZERO_STRUCT(state->orig.out.result);
    1889             : 
    1890           0 :         state->out_mem_ctx = talloc_named_const(state, 0,
    1891             :                              "dcerpc_drsuapi_DsGetMemberships_out_memory");
    1892           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    1893           0 :                 return tevent_req_post(req, ev);
    1894             :         }
    1895             : 
    1896             :         /* make a temporary copy, that we pass to the dispatch function */
    1897           0 :         state->tmp = state->orig;
    1898             : 
    1899           0 :         subreq = dcerpc_drsuapi_DsGetMemberships_r_send(state, ev, h, &state->tmp);
    1900           0 :         if (tevent_req_nomem(subreq, req)) {
    1901           0 :                 return tevent_req_post(req, ev);
    1902             :         }
    1903           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsGetMemberships_done, req);
    1904           0 :         return req;
    1905             : }
    1906             : 
    1907           0 : static void dcerpc_drsuapi_DsGetMemberships_done(struct tevent_req *subreq)
    1908             : {
    1909           0 :         struct tevent_req *req = tevent_req_callback_data(
    1910             :                 subreq, struct tevent_req);
    1911           0 :         struct dcerpc_drsuapi_DsGetMemberships_state *state = tevent_req_data(
    1912             :                 req, struct dcerpc_drsuapi_DsGetMemberships_state);
    1913             :         NTSTATUS status;
    1914             :         TALLOC_CTX *mem_ctx;
    1915             : 
    1916           0 :         if (state->out_mem_ctx) {
    1917           0 :                 mem_ctx = state->out_mem_ctx;
    1918             :         } else {
    1919           0 :                 mem_ctx = state;
    1920             :         }
    1921             : 
    1922           0 :         status = dcerpc_drsuapi_DsGetMemberships_r_recv(subreq, mem_ctx);
    1923           0 :         TALLOC_FREE(subreq);
    1924           0 :         if (tevent_req_nterror(req, status)) {
    1925           0 :                 return;
    1926             :         }
    1927             : 
    1928             :         /* Copy out parameters */
    1929           0 :         *state->orig.out.level_out = *state->tmp.out.level_out;
    1930           0 :         *state->orig.out.ctr = *state->tmp.out.ctr;
    1931             : 
    1932             :         /* Copy result */
    1933           0 :         state->orig.out.result = state->tmp.out.result;
    1934             : 
    1935             :         /* Reset temporary structure */
    1936           0 :         NDR_ZERO_STRUCT(state->tmp);
    1937             : 
    1938           0 :         tevent_req_done(req);
    1939             : }
    1940             : 
    1941           0 : NTSTATUS dcerpc_drsuapi_DsGetMemberships_recv(struct tevent_req *req,
    1942             :                                               TALLOC_CTX *mem_ctx,
    1943             :                                               WERROR *result)
    1944             : {
    1945           0 :         struct dcerpc_drsuapi_DsGetMemberships_state *state = tevent_req_data(
    1946             :                 req, struct dcerpc_drsuapi_DsGetMemberships_state);
    1947             :         NTSTATUS status;
    1948             : 
    1949           0 :         if (tevent_req_is_nterror(req, &status)) {
    1950           0 :                 tevent_req_received(req);
    1951           0 :                 return status;
    1952             :         }
    1953             : 
    1954             :         /* Steal possible out parameters to the callers context */
    1955           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    1956             : 
    1957             :         /* Return result */
    1958           0 :         *result = state->orig.out.result;
    1959             : 
    1960           0 :         tevent_req_received(req);
    1961           0 :         return NT_STATUS_OK;
    1962             : }
    1963             : 
    1964           0 : NTSTATUS dcerpc_drsuapi_DsGetMemberships(struct dcerpc_binding_handle *h,
    1965             :                                          TALLOC_CTX *mem_ctx,
    1966             :                                          struct policy_handle *_bind_handle /* [in] [ref] */,
    1967             :                                          uint32_t _level /* [in]  */,
    1968             :                                          union drsuapi_DsGetMembershipsRequest *_req /* [in] [ref,switch_is(level)] */,
    1969             :                                          uint32_t *_level_out /* [out] [ref] */,
    1970             :                                          union drsuapi_DsGetMembershipsCtr *_ctr /* [out] [ref,switch_is(*level_out)] */,
    1971             :                                          WERROR *result)
    1972             : {
    1973             :         struct drsuapi_DsGetMemberships r;
    1974             :         NTSTATUS status;
    1975             : 
    1976             :         /* In parameters */
    1977           0 :         r.in.bind_handle = _bind_handle;
    1978           0 :         r.in.level = _level;
    1979           0 :         r.in.req = _req;
    1980             : 
    1981             :         /* Out parameters */
    1982           0 :         r.out.level_out = _level_out;
    1983           0 :         r.out.ctr = _ctr;
    1984             : 
    1985             :         /* Result */
    1986           0 :         NDR_ZERO_STRUCT(r.out.result);
    1987             : 
    1988           0 :         status = dcerpc_drsuapi_DsGetMemberships_r(h, mem_ctx, &r);
    1989           0 :         if (!NT_STATUS_IS_OK(status)) {
    1990           0 :                 return status;
    1991             :         }
    1992             : 
    1993             :         /* Return variables */
    1994           0 :         *_level_out = *r.out.level_out;
    1995           0 :         *_ctr = *r.out.ctr;
    1996             : 
    1997             :         /* Return result */
    1998           0 :         *result = r.out.result;
    1999             : 
    2000           0 :         return NT_STATUS_OK;
    2001             : }
    2002             : 
    2003             : struct dcerpc_drsuapi_DsGetNT4ChangeLog_r_state {
    2004             :         TALLOC_CTX *out_mem_ctx;
    2005             : };
    2006             : 
    2007             : static void dcerpc_drsuapi_DsGetNT4ChangeLog_r_done(struct tevent_req *subreq);
    2008             : 
    2009           0 : struct tevent_req *dcerpc_drsuapi_DsGetNT4ChangeLog_r_send(TALLOC_CTX *mem_ctx,
    2010             :         struct tevent_context *ev,
    2011             :         struct dcerpc_binding_handle *h,
    2012             :         struct drsuapi_DsGetNT4ChangeLog *r)
    2013             : {
    2014             :         struct tevent_req *req;
    2015             :         struct dcerpc_drsuapi_DsGetNT4ChangeLog_r_state *state;
    2016             :         struct tevent_req *subreq;
    2017             : 
    2018           0 :         req = tevent_req_create(mem_ctx, &state,
    2019             :                                 struct dcerpc_drsuapi_DsGetNT4ChangeLog_r_state);
    2020           0 :         if (req == NULL) {
    2021           0 :                 return NULL;
    2022             :         }
    2023             : 
    2024           0 :         state->out_mem_ctx = talloc_new(state);
    2025           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    2026           0 :                 return tevent_req_post(req, ev);
    2027             :         }
    2028             : 
    2029           0 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    2030             :                         NULL, &ndr_table_drsuapi,
    2031           0 :                         NDR_DRSUAPI_DSGETNT4CHANGELOG, state->out_mem_ctx, r);
    2032           0 :         if (tevent_req_nomem(subreq, req)) {
    2033           0 :                 return tevent_req_post(req, ev);
    2034             :         }
    2035           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsGetNT4ChangeLog_r_done, req);
    2036             : 
    2037           0 :         return req;
    2038             : }
    2039             : 
    2040           0 : static void dcerpc_drsuapi_DsGetNT4ChangeLog_r_done(struct tevent_req *subreq)
    2041             : {
    2042           0 :         struct tevent_req *req =
    2043           0 :                 tevent_req_callback_data(subreq,
    2044             :                 struct tevent_req);
    2045             :         NTSTATUS status;
    2046             : 
    2047           0 :         status = dcerpc_binding_handle_call_recv(subreq);
    2048           0 :         TALLOC_FREE(subreq);
    2049           0 :         if (tevent_req_nterror(req, status)) {
    2050           0 :                 return;
    2051             :         }
    2052             : 
    2053           0 :         tevent_req_done(req);
    2054             : }
    2055             : 
    2056           0 : NTSTATUS dcerpc_drsuapi_DsGetNT4ChangeLog_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    2057             : {
    2058           0 :         struct dcerpc_drsuapi_DsGetNT4ChangeLog_r_state *state =
    2059           0 :                 tevent_req_data(req,
    2060             :                 struct dcerpc_drsuapi_DsGetNT4ChangeLog_r_state);
    2061             :         NTSTATUS status;
    2062             : 
    2063           0 :         if (tevent_req_is_nterror(req, &status)) {
    2064           0 :                 tevent_req_received(req);
    2065           0 :                 return status;
    2066             :         }
    2067             : 
    2068           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    2069             : 
    2070           0 :         tevent_req_received(req);
    2071           0 :         return NT_STATUS_OK;
    2072             : }
    2073             : 
    2074           3 : NTSTATUS dcerpc_drsuapi_DsGetNT4ChangeLog_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct drsuapi_DsGetNT4ChangeLog *r)
    2075             : {
    2076             :         NTSTATUS status;
    2077             : 
    2078           3 :         status = dcerpc_binding_handle_call(h,
    2079             :                         NULL, &ndr_table_drsuapi,
    2080             :                         NDR_DRSUAPI_DSGETNT4CHANGELOG, mem_ctx, r);
    2081             : 
    2082           3 :         return status;
    2083             : }
    2084             : 
    2085             : struct dcerpc_drsuapi_DsGetNT4ChangeLog_state {
    2086             :         struct drsuapi_DsGetNT4ChangeLog orig;
    2087             :         struct drsuapi_DsGetNT4ChangeLog tmp;
    2088             :         TALLOC_CTX *out_mem_ctx;
    2089             : };
    2090             : 
    2091             : static void dcerpc_drsuapi_DsGetNT4ChangeLog_done(struct tevent_req *subreq);
    2092             : 
    2093           0 : struct tevent_req *dcerpc_drsuapi_DsGetNT4ChangeLog_send(TALLOC_CTX *mem_ctx,
    2094             :                                                          struct tevent_context *ev,
    2095             :                                                          struct dcerpc_binding_handle *h,
    2096             :                                                          struct policy_handle *_bind_handle /* [in] [ref] */,
    2097             :                                                          uint32_t _level /* [in]  */,
    2098             :                                                          union drsuapi_DsGetNT4ChangeLogRequest *_req /* [in] [ref,switch_is(level)] */,
    2099             :                                                          uint32_t *_level_out /* [out] [ref] */,
    2100             :                                                          union drsuapi_DsGetNT4ChangeLogInfo *_info /* [out] [ref,switch_is(*level_out)] */)
    2101             : {
    2102             :         struct tevent_req *req;
    2103             :         struct dcerpc_drsuapi_DsGetNT4ChangeLog_state *state;
    2104             :         struct tevent_req *subreq;
    2105             : 
    2106           0 :         req = tevent_req_create(mem_ctx, &state,
    2107             :                                 struct dcerpc_drsuapi_DsGetNT4ChangeLog_state);
    2108           0 :         if (req == NULL) {
    2109           0 :                 return NULL;
    2110             :         }
    2111           0 :         state->out_mem_ctx = NULL;
    2112             : 
    2113             :         /* In parameters */
    2114           0 :         state->orig.in.bind_handle = _bind_handle;
    2115           0 :         state->orig.in.level = _level;
    2116           0 :         state->orig.in.req = _req;
    2117             : 
    2118             :         /* Out parameters */
    2119           0 :         state->orig.out.level_out = _level_out;
    2120           0 :         state->orig.out.info = _info;
    2121             : 
    2122             :         /* Result */
    2123           0 :         NDR_ZERO_STRUCT(state->orig.out.result);
    2124             : 
    2125           0 :         state->out_mem_ctx = talloc_named_const(state, 0,
    2126             :                              "dcerpc_drsuapi_DsGetNT4ChangeLog_out_memory");
    2127           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    2128           0 :                 return tevent_req_post(req, ev);
    2129             :         }
    2130             : 
    2131             :         /* make a temporary copy, that we pass to the dispatch function */
    2132           0 :         state->tmp = state->orig;
    2133             : 
    2134           0 :         subreq = dcerpc_drsuapi_DsGetNT4ChangeLog_r_send(state, ev, h, &state->tmp);
    2135           0 :         if (tevent_req_nomem(subreq, req)) {
    2136           0 :                 return tevent_req_post(req, ev);
    2137             :         }
    2138           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsGetNT4ChangeLog_done, req);
    2139           0 :         return req;
    2140             : }
    2141             : 
    2142           0 : static void dcerpc_drsuapi_DsGetNT4ChangeLog_done(struct tevent_req *subreq)
    2143             : {
    2144           0 :         struct tevent_req *req = tevent_req_callback_data(
    2145             :                 subreq, struct tevent_req);
    2146           0 :         struct dcerpc_drsuapi_DsGetNT4ChangeLog_state *state = tevent_req_data(
    2147             :                 req, struct dcerpc_drsuapi_DsGetNT4ChangeLog_state);
    2148             :         NTSTATUS status;
    2149             :         TALLOC_CTX *mem_ctx;
    2150             : 
    2151           0 :         if (state->out_mem_ctx) {
    2152           0 :                 mem_ctx = state->out_mem_ctx;
    2153             :         } else {
    2154           0 :                 mem_ctx = state;
    2155             :         }
    2156             : 
    2157           0 :         status = dcerpc_drsuapi_DsGetNT4ChangeLog_r_recv(subreq, mem_ctx);
    2158           0 :         TALLOC_FREE(subreq);
    2159           0 :         if (tevent_req_nterror(req, status)) {
    2160           0 :                 return;
    2161             :         }
    2162             : 
    2163             :         /* Copy out parameters */
    2164           0 :         *state->orig.out.level_out = *state->tmp.out.level_out;
    2165           0 :         *state->orig.out.info = *state->tmp.out.info;
    2166             : 
    2167             :         /* Copy result */
    2168           0 :         state->orig.out.result = state->tmp.out.result;
    2169             : 
    2170             :         /* Reset temporary structure */
    2171           0 :         NDR_ZERO_STRUCT(state->tmp);
    2172             : 
    2173           0 :         tevent_req_done(req);
    2174             : }
    2175             : 
    2176           0 : NTSTATUS dcerpc_drsuapi_DsGetNT4ChangeLog_recv(struct tevent_req *req,
    2177             :                                                TALLOC_CTX *mem_ctx,
    2178             :                                                WERROR *result)
    2179             : {
    2180           0 :         struct dcerpc_drsuapi_DsGetNT4ChangeLog_state *state = tevent_req_data(
    2181             :                 req, struct dcerpc_drsuapi_DsGetNT4ChangeLog_state);
    2182             :         NTSTATUS status;
    2183             : 
    2184           0 :         if (tevent_req_is_nterror(req, &status)) {
    2185           0 :                 tevent_req_received(req);
    2186           0 :                 return status;
    2187             :         }
    2188             : 
    2189             :         /* Steal possible out parameters to the callers context */
    2190           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    2191             : 
    2192             :         /* Return result */
    2193           0 :         *result = state->orig.out.result;
    2194             : 
    2195           0 :         tevent_req_received(req);
    2196           0 :         return NT_STATUS_OK;
    2197             : }
    2198             : 
    2199           0 : NTSTATUS dcerpc_drsuapi_DsGetNT4ChangeLog(struct dcerpc_binding_handle *h,
    2200             :                                           TALLOC_CTX *mem_ctx,
    2201             :                                           struct policy_handle *_bind_handle /* [in] [ref] */,
    2202             :                                           uint32_t _level /* [in]  */,
    2203             :                                           union drsuapi_DsGetNT4ChangeLogRequest *_req /* [in] [ref,switch_is(level)] */,
    2204             :                                           uint32_t *_level_out /* [out] [ref] */,
    2205             :                                           union drsuapi_DsGetNT4ChangeLogInfo *_info /* [out] [ref,switch_is(*level_out)] */,
    2206             :                                           WERROR *result)
    2207             : {
    2208             :         struct drsuapi_DsGetNT4ChangeLog r;
    2209             :         NTSTATUS status;
    2210             : 
    2211             :         /* In parameters */
    2212           0 :         r.in.bind_handle = _bind_handle;
    2213           0 :         r.in.level = _level;
    2214           0 :         r.in.req = _req;
    2215             : 
    2216             :         /* Out parameters */
    2217           0 :         r.out.level_out = _level_out;
    2218           0 :         r.out.info = _info;
    2219             : 
    2220             :         /* Result */
    2221           0 :         NDR_ZERO_STRUCT(r.out.result);
    2222             : 
    2223           0 :         status = dcerpc_drsuapi_DsGetNT4ChangeLog_r(h, mem_ctx, &r);
    2224           0 :         if (!NT_STATUS_IS_OK(status)) {
    2225           0 :                 return status;
    2226             :         }
    2227             : 
    2228             :         /* Return variables */
    2229           0 :         *_level_out = *r.out.level_out;
    2230           0 :         *_info = *r.out.info;
    2231             : 
    2232             :         /* Return result */
    2233           0 :         *result = r.out.result;
    2234             : 
    2235           0 :         return NT_STATUS_OK;
    2236             : }
    2237             : 
    2238             : struct dcerpc_drsuapi_DsCrackNames_r_state {
    2239             :         TALLOC_CTX *out_mem_ctx;
    2240             : };
    2241             : 
    2242             : static void dcerpc_drsuapi_DsCrackNames_r_done(struct tevent_req *subreq);
    2243             : 
    2244           0 : struct tevent_req *dcerpc_drsuapi_DsCrackNames_r_send(TALLOC_CTX *mem_ctx,
    2245             :         struct tevent_context *ev,
    2246             :         struct dcerpc_binding_handle *h,
    2247             :         struct drsuapi_DsCrackNames *r)
    2248             : {
    2249             :         struct tevent_req *req;
    2250             :         struct dcerpc_drsuapi_DsCrackNames_r_state *state;
    2251             :         struct tevent_req *subreq;
    2252             : 
    2253           0 :         req = tevent_req_create(mem_ctx, &state,
    2254             :                                 struct dcerpc_drsuapi_DsCrackNames_r_state);
    2255           0 :         if (req == NULL) {
    2256           0 :                 return NULL;
    2257             :         }
    2258             : 
    2259           0 :         state->out_mem_ctx = talloc_new(state);
    2260           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    2261           0 :                 return tevent_req_post(req, ev);
    2262             :         }
    2263             : 
    2264           0 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    2265             :                         NULL, &ndr_table_drsuapi,
    2266           0 :                         NDR_DRSUAPI_DSCRACKNAMES, state->out_mem_ctx, r);
    2267           0 :         if (tevent_req_nomem(subreq, req)) {
    2268           0 :                 return tevent_req_post(req, ev);
    2269             :         }
    2270           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsCrackNames_r_done, req);
    2271             : 
    2272           0 :         return req;
    2273             : }
    2274             : 
    2275           0 : static void dcerpc_drsuapi_DsCrackNames_r_done(struct tevent_req *subreq)
    2276             : {
    2277           0 :         struct tevent_req *req =
    2278           0 :                 tevent_req_callback_data(subreq,
    2279             :                 struct tevent_req);
    2280             :         NTSTATUS status;
    2281             : 
    2282           0 :         status = dcerpc_binding_handle_call_recv(subreq);
    2283           0 :         TALLOC_FREE(subreq);
    2284           0 :         if (tevent_req_nterror(req, status)) {
    2285           0 :                 return;
    2286             :         }
    2287             : 
    2288           0 :         tevent_req_done(req);
    2289             : }
    2290             : 
    2291           0 : NTSTATUS dcerpc_drsuapi_DsCrackNames_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    2292             : {
    2293           0 :         struct dcerpc_drsuapi_DsCrackNames_r_state *state =
    2294           0 :                 tevent_req_data(req,
    2295             :                 struct dcerpc_drsuapi_DsCrackNames_r_state);
    2296             :         NTSTATUS status;
    2297             : 
    2298           0 :         if (tevent_req_is_nterror(req, &status)) {
    2299           0 :                 tevent_req_received(req);
    2300           0 :                 return status;
    2301             :         }
    2302             : 
    2303           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    2304             : 
    2305           0 :         tevent_req_received(req);
    2306           0 :         return NT_STATUS_OK;
    2307             : }
    2308             : 
    2309        1416 : NTSTATUS dcerpc_drsuapi_DsCrackNames_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct drsuapi_DsCrackNames *r)
    2310             : {
    2311             :         NTSTATUS status;
    2312             : 
    2313        1416 :         status = dcerpc_binding_handle_call(h,
    2314             :                         NULL, &ndr_table_drsuapi,
    2315             :                         NDR_DRSUAPI_DSCRACKNAMES, mem_ctx, r);
    2316             : 
    2317        1416 :         return status;
    2318             : }
    2319             : 
    2320             : struct dcerpc_drsuapi_DsCrackNames_state {
    2321             :         struct drsuapi_DsCrackNames orig;
    2322             :         struct drsuapi_DsCrackNames tmp;
    2323             :         TALLOC_CTX *out_mem_ctx;
    2324             : };
    2325             : 
    2326             : static void dcerpc_drsuapi_DsCrackNames_done(struct tevent_req *subreq);
    2327             : 
    2328           0 : struct tevent_req *dcerpc_drsuapi_DsCrackNames_send(TALLOC_CTX *mem_ctx,
    2329             :                                                     struct tevent_context *ev,
    2330             :                                                     struct dcerpc_binding_handle *h,
    2331             :                                                     struct policy_handle *_bind_handle /* [in] [ref] */,
    2332             :                                                     uint32_t _level /* [in]  */,
    2333             :                                                     union drsuapi_DsNameRequest *_req /* [in] [ref,switch_is(level)] */,
    2334             :                                                     uint32_t *_level_out /* [out] [ref] */,
    2335             :                                                     union drsuapi_DsNameCtr *_ctr /* [out] [ref,switch_is(*level_out)] */)
    2336             : {
    2337             :         struct tevent_req *req;
    2338             :         struct dcerpc_drsuapi_DsCrackNames_state *state;
    2339             :         struct tevent_req *subreq;
    2340             : 
    2341           0 :         req = tevent_req_create(mem_ctx, &state,
    2342             :                                 struct dcerpc_drsuapi_DsCrackNames_state);
    2343           0 :         if (req == NULL) {
    2344           0 :                 return NULL;
    2345             :         }
    2346           0 :         state->out_mem_ctx = NULL;
    2347             : 
    2348             :         /* In parameters */
    2349           0 :         state->orig.in.bind_handle = _bind_handle;
    2350           0 :         state->orig.in.level = _level;
    2351           0 :         state->orig.in.req = _req;
    2352             : 
    2353             :         /* Out parameters */
    2354           0 :         state->orig.out.level_out = _level_out;
    2355           0 :         state->orig.out.ctr = _ctr;
    2356             : 
    2357             :         /* Result */
    2358           0 :         NDR_ZERO_STRUCT(state->orig.out.result);
    2359             : 
    2360           0 :         state->out_mem_ctx = talloc_named_const(state, 0,
    2361             :                              "dcerpc_drsuapi_DsCrackNames_out_memory");
    2362           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    2363           0 :                 return tevent_req_post(req, ev);
    2364             :         }
    2365             : 
    2366             :         /* make a temporary copy, that we pass to the dispatch function */
    2367           0 :         state->tmp = state->orig;
    2368             : 
    2369           0 :         subreq = dcerpc_drsuapi_DsCrackNames_r_send(state, ev, h, &state->tmp);
    2370           0 :         if (tevent_req_nomem(subreq, req)) {
    2371           0 :                 return tevent_req_post(req, ev);
    2372             :         }
    2373           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsCrackNames_done, req);
    2374           0 :         return req;
    2375             : }
    2376             : 
    2377           0 : static void dcerpc_drsuapi_DsCrackNames_done(struct tevent_req *subreq)
    2378             : {
    2379           0 :         struct tevent_req *req = tevent_req_callback_data(
    2380             :                 subreq, struct tevent_req);
    2381           0 :         struct dcerpc_drsuapi_DsCrackNames_state *state = tevent_req_data(
    2382             :                 req, struct dcerpc_drsuapi_DsCrackNames_state);
    2383             :         NTSTATUS status;
    2384             :         TALLOC_CTX *mem_ctx;
    2385             : 
    2386           0 :         if (state->out_mem_ctx) {
    2387           0 :                 mem_ctx = state->out_mem_ctx;
    2388             :         } else {
    2389           0 :                 mem_ctx = state;
    2390             :         }
    2391             : 
    2392           0 :         status = dcerpc_drsuapi_DsCrackNames_r_recv(subreq, mem_ctx);
    2393           0 :         TALLOC_FREE(subreq);
    2394           0 :         if (tevent_req_nterror(req, status)) {
    2395           0 :                 return;
    2396             :         }
    2397             : 
    2398             :         /* Copy out parameters */
    2399           0 :         *state->orig.out.level_out = *state->tmp.out.level_out;
    2400           0 :         *state->orig.out.ctr = *state->tmp.out.ctr;
    2401             : 
    2402             :         /* Copy result */
    2403           0 :         state->orig.out.result = state->tmp.out.result;
    2404             : 
    2405             :         /* Reset temporary structure */
    2406           0 :         NDR_ZERO_STRUCT(state->tmp);
    2407             : 
    2408           0 :         tevent_req_done(req);
    2409             : }
    2410             : 
    2411           0 : NTSTATUS dcerpc_drsuapi_DsCrackNames_recv(struct tevent_req *req,
    2412             :                                           TALLOC_CTX *mem_ctx,
    2413             :                                           WERROR *result)
    2414             : {
    2415           0 :         struct dcerpc_drsuapi_DsCrackNames_state *state = tevent_req_data(
    2416             :                 req, struct dcerpc_drsuapi_DsCrackNames_state);
    2417             :         NTSTATUS status;
    2418             : 
    2419           0 :         if (tevent_req_is_nterror(req, &status)) {
    2420           0 :                 tevent_req_received(req);
    2421           0 :                 return status;
    2422             :         }
    2423             : 
    2424             :         /* Steal possible out parameters to the callers context */
    2425           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    2426             : 
    2427             :         /* Return result */
    2428           0 :         *result = state->orig.out.result;
    2429             : 
    2430           0 :         tevent_req_received(req);
    2431           0 :         return NT_STATUS_OK;
    2432             : }
    2433             : 
    2434           0 : NTSTATUS dcerpc_drsuapi_DsCrackNames(struct dcerpc_binding_handle *h,
    2435             :                                      TALLOC_CTX *mem_ctx,
    2436             :                                      struct policy_handle *_bind_handle /* [in] [ref] */,
    2437             :                                      uint32_t _level /* [in]  */,
    2438             :                                      union drsuapi_DsNameRequest *_req /* [in] [ref,switch_is(level)] */,
    2439             :                                      uint32_t *_level_out /* [out] [ref] */,
    2440             :                                      union drsuapi_DsNameCtr *_ctr /* [out] [ref,switch_is(*level_out)] */,
    2441             :                                      WERROR *result)
    2442             : {
    2443             :         struct drsuapi_DsCrackNames r;
    2444             :         NTSTATUS status;
    2445             : 
    2446             :         /* In parameters */
    2447           0 :         r.in.bind_handle = _bind_handle;
    2448           0 :         r.in.level = _level;
    2449           0 :         r.in.req = _req;
    2450             : 
    2451             :         /* Out parameters */
    2452           0 :         r.out.level_out = _level_out;
    2453           0 :         r.out.ctr = _ctr;
    2454             : 
    2455             :         /* Result */
    2456           0 :         NDR_ZERO_STRUCT(r.out.result);
    2457             : 
    2458           0 :         status = dcerpc_drsuapi_DsCrackNames_r(h, mem_ctx, &r);
    2459           0 :         if (!NT_STATUS_IS_OK(status)) {
    2460           0 :                 return status;
    2461             :         }
    2462             : 
    2463             :         /* Return variables */
    2464           0 :         *_level_out = *r.out.level_out;
    2465           0 :         *_ctr = *r.out.ctr;
    2466             : 
    2467             :         /* Return result */
    2468           0 :         *result = r.out.result;
    2469             : 
    2470           0 :         return NT_STATUS_OK;
    2471             : }
    2472             : 
    2473             : struct dcerpc_drsuapi_DsWriteAccountSpn_r_state {
    2474             :         TALLOC_CTX *out_mem_ctx;
    2475             : };
    2476             : 
    2477             : static void dcerpc_drsuapi_DsWriteAccountSpn_r_done(struct tevent_req *subreq);
    2478             : 
    2479           0 : struct tevent_req *dcerpc_drsuapi_DsWriteAccountSpn_r_send(TALLOC_CTX *mem_ctx,
    2480             :         struct tevent_context *ev,
    2481             :         struct dcerpc_binding_handle *h,
    2482             :         struct drsuapi_DsWriteAccountSpn *r)
    2483             : {
    2484             :         struct tevent_req *req;
    2485             :         struct dcerpc_drsuapi_DsWriteAccountSpn_r_state *state;
    2486             :         struct tevent_req *subreq;
    2487             : 
    2488           0 :         req = tevent_req_create(mem_ctx, &state,
    2489             :                                 struct dcerpc_drsuapi_DsWriteAccountSpn_r_state);
    2490           0 :         if (req == NULL) {
    2491           0 :                 return NULL;
    2492             :         }
    2493             : 
    2494           0 :         state->out_mem_ctx = talloc_new(state);
    2495           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    2496           0 :                 return tevent_req_post(req, ev);
    2497             :         }
    2498             : 
    2499           0 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    2500             :                         NULL, &ndr_table_drsuapi,
    2501           0 :                         NDR_DRSUAPI_DSWRITEACCOUNTSPN, state->out_mem_ctx, r);
    2502           0 :         if (tevent_req_nomem(subreq, req)) {
    2503           0 :                 return tevent_req_post(req, ev);
    2504             :         }
    2505           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsWriteAccountSpn_r_done, req);
    2506             : 
    2507           0 :         return req;
    2508             : }
    2509             : 
    2510           0 : static void dcerpc_drsuapi_DsWriteAccountSpn_r_done(struct tevent_req *subreq)
    2511             : {
    2512           0 :         struct tevent_req *req =
    2513           0 :                 tevent_req_callback_data(subreq,
    2514             :                 struct tevent_req);
    2515             :         NTSTATUS status;
    2516             : 
    2517           0 :         status = dcerpc_binding_handle_call_recv(subreq);
    2518           0 :         TALLOC_FREE(subreq);
    2519           0 :         if (tevent_req_nterror(req, status)) {
    2520           0 :                 return;
    2521             :         }
    2522             : 
    2523           0 :         tevent_req_done(req);
    2524             : }
    2525             : 
    2526           0 : NTSTATUS dcerpc_drsuapi_DsWriteAccountSpn_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    2527             : {
    2528           0 :         struct dcerpc_drsuapi_DsWriteAccountSpn_r_state *state =
    2529           0 :                 tevent_req_data(req,
    2530             :                 struct dcerpc_drsuapi_DsWriteAccountSpn_r_state);
    2531             :         NTSTATUS status;
    2532             : 
    2533           0 :         if (tevent_req_is_nterror(req, &status)) {
    2534           0 :                 tevent_req_received(req);
    2535           0 :                 return status;
    2536             :         }
    2537             : 
    2538           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    2539             : 
    2540           0 :         tevent_req_received(req);
    2541           0 :         return NT_STATUS_OK;
    2542             : }
    2543             : 
    2544           4 : NTSTATUS dcerpc_drsuapi_DsWriteAccountSpn_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct drsuapi_DsWriteAccountSpn *r)
    2545             : {
    2546             :         NTSTATUS status;
    2547             : 
    2548           4 :         status = dcerpc_binding_handle_call(h,
    2549             :                         NULL, &ndr_table_drsuapi,
    2550             :                         NDR_DRSUAPI_DSWRITEACCOUNTSPN, mem_ctx, r);
    2551             : 
    2552           4 :         return status;
    2553             : }
    2554             : 
    2555             : struct dcerpc_drsuapi_DsWriteAccountSpn_state {
    2556             :         struct drsuapi_DsWriteAccountSpn orig;
    2557             :         struct drsuapi_DsWriteAccountSpn tmp;
    2558             :         TALLOC_CTX *out_mem_ctx;
    2559             : };
    2560             : 
    2561             : static void dcerpc_drsuapi_DsWriteAccountSpn_done(struct tevent_req *subreq);
    2562             : 
    2563           0 : struct tevent_req *dcerpc_drsuapi_DsWriteAccountSpn_send(TALLOC_CTX *mem_ctx,
    2564             :                                                          struct tevent_context *ev,
    2565             :                                                          struct dcerpc_binding_handle *h,
    2566             :                                                          struct policy_handle *_bind_handle /* [in] [ref] */,
    2567             :                                                          uint32_t _level /* [in]  */,
    2568             :                                                          union drsuapi_DsWriteAccountSpnRequest *_req /* [in] [ref,switch_is(level)] */,
    2569             :                                                          uint32_t *_level_out /* [out] [ref] */,
    2570             :                                                          union drsuapi_DsWriteAccountSpnResult *_res /* [out] [ref,switch_is(*level_out)] */)
    2571             : {
    2572             :         struct tevent_req *req;
    2573             :         struct dcerpc_drsuapi_DsWriteAccountSpn_state *state;
    2574             :         struct tevent_req *subreq;
    2575             : 
    2576           0 :         req = tevent_req_create(mem_ctx, &state,
    2577             :                                 struct dcerpc_drsuapi_DsWriteAccountSpn_state);
    2578           0 :         if (req == NULL) {
    2579           0 :                 return NULL;
    2580             :         }
    2581           0 :         state->out_mem_ctx = NULL;
    2582             : 
    2583             :         /* In parameters */
    2584           0 :         state->orig.in.bind_handle = _bind_handle;
    2585           0 :         state->orig.in.level = _level;
    2586           0 :         state->orig.in.req = _req;
    2587             : 
    2588             :         /* Out parameters */
    2589           0 :         state->orig.out.level_out = _level_out;
    2590           0 :         state->orig.out.res = _res;
    2591             : 
    2592             :         /* Result */
    2593           0 :         NDR_ZERO_STRUCT(state->orig.out.result);
    2594             : 
    2595           0 :         state->out_mem_ctx = talloc_named_const(state, 0,
    2596             :                              "dcerpc_drsuapi_DsWriteAccountSpn_out_memory");
    2597           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    2598           0 :                 return tevent_req_post(req, ev);
    2599             :         }
    2600             : 
    2601             :         /* make a temporary copy, that we pass to the dispatch function */
    2602           0 :         state->tmp = state->orig;
    2603             : 
    2604           0 :         subreq = dcerpc_drsuapi_DsWriteAccountSpn_r_send(state, ev, h, &state->tmp);
    2605           0 :         if (tevent_req_nomem(subreq, req)) {
    2606           0 :                 return tevent_req_post(req, ev);
    2607             :         }
    2608           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsWriteAccountSpn_done, req);
    2609           0 :         return req;
    2610             : }
    2611             : 
    2612           0 : static void dcerpc_drsuapi_DsWriteAccountSpn_done(struct tevent_req *subreq)
    2613             : {
    2614           0 :         struct tevent_req *req = tevent_req_callback_data(
    2615             :                 subreq, struct tevent_req);
    2616           0 :         struct dcerpc_drsuapi_DsWriteAccountSpn_state *state = tevent_req_data(
    2617             :                 req, struct dcerpc_drsuapi_DsWriteAccountSpn_state);
    2618             :         NTSTATUS status;
    2619             :         TALLOC_CTX *mem_ctx;
    2620             : 
    2621           0 :         if (state->out_mem_ctx) {
    2622           0 :                 mem_ctx = state->out_mem_ctx;
    2623             :         } else {
    2624           0 :                 mem_ctx = state;
    2625             :         }
    2626             : 
    2627           0 :         status = dcerpc_drsuapi_DsWriteAccountSpn_r_recv(subreq, mem_ctx);
    2628           0 :         TALLOC_FREE(subreq);
    2629           0 :         if (tevent_req_nterror(req, status)) {
    2630           0 :                 return;
    2631             :         }
    2632             : 
    2633             :         /* Copy out parameters */
    2634           0 :         *state->orig.out.level_out = *state->tmp.out.level_out;
    2635           0 :         *state->orig.out.res = *state->tmp.out.res;
    2636             : 
    2637             :         /* Copy result */
    2638           0 :         state->orig.out.result = state->tmp.out.result;
    2639             : 
    2640             :         /* Reset temporary structure */
    2641           0 :         NDR_ZERO_STRUCT(state->tmp);
    2642             : 
    2643           0 :         tevent_req_done(req);
    2644             : }
    2645             : 
    2646           0 : NTSTATUS dcerpc_drsuapi_DsWriteAccountSpn_recv(struct tevent_req *req,
    2647             :                                                TALLOC_CTX *mem_ctx,
    2648             :                                                WERROR *result)
    2649             : {
    2650           0 :         struct dcerpc_drsuapi_DsWriteAccountSpn_state *state = tevent_req_data(
    2651             :                 req, struct dcerpc_drsuapi_DsWriteAccountSpn_state);
    2652             :         NTSTATUS status;
    2653             : 
    2654           0 :         if (tevent_req_is_nterror(req, &status)) {
    2655           0 :                 tevent_req_received(req);
    2656           0 :                 return status;
    2657             :         }
    2658             : 
    2659             :         /* Steal possible out parameters to the callers context */
    2660           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    2661             : 
    2662             :         /* Return result */
    2663           0 :         *result = state->orig.out.result;
    2664             : 
    2665           0 :         tevent_req_received(req);
    2666           0 :         return NT_STATUS_OK;
    2667             : }
    2668             : 
    2669           0 : NTSTATUS dcerpc_drsuapi_DsWriteAccountSpn(struct dcerpc_binding_handle *h,
    2670             :                                           TALLOC_CTX *mem_ctx,
    2671             :                                           struct policy_handle *_bind_handle /* [in] [ref] */,
    2672             :                                           uint32_t _level /* [in]  */,
    2673             :                                           union drsuapi_DsWriteAccountSpnRequest *_req /* [in] [ref,switch_is(level)] */,
    2674             :                                           uint32_t *_level_out /* [out] [ref] */,
    2675             :                                           union drsuapi_DsWriteAccountSpnResult *_res /* [out] [ref,switch_is(*level_out)] */,
    2676             :                                           WERROR *result)
    2677             : {
    2678             :         struct drsuapi_DsWriteAccountSpn r;
    2679             :         NTSTATUS status;
    2680             : 
    2681             :         /* In parameters */
    2682           0 :         r.in.bind_handle = _bind_handle;
    2683           0 :         r.in.level = _level;
    2684           0 :         r.in.req = _req;
    2685             : 
    2686             :         /* Out parameters */
    2687           0 :         r.out.level_out = _level_out;
    2688           0 :         r.out.res = _res;
    2689             : 
    2690             :         /* Result */
    2691           0 :         NDR_ZERO_STRUCT(r.out.result);
    2692             : 
    2693           0 :         status = dcerpc_drsuapi_DsWriteAccountSpn_r(h, mem_ctx, &r);
    2694           0 :         if (!NT_STATUS_IS_OK(status)) {
    2695           0 :                 return status;
    2696             :         }
    2697             : 
    2698             :         /* Return variables */
    2699           0 :         *_level_out = *r.out.level_out;
    2700           0 :         *_res = *r.out.res;
    2701             : 
    2702             :         /* Return result */
    2703           0 :         *result = r.out.result;
    2704             : 
    2705           0 :         return NT_STATUS_OK;
    2706             : }
    2707             : 
    2708             : struct dcerpc_drsuapi_DsRemoveDSServer_r_state {
    2709             :         TALLOC_CTX *out_mem_ctx;
    2710             : };
    2711             : 
    2712             : static void dcerpc_drsuapi_DsRemoveDSServer_r_done(struct tevent_req *subreq);
    2713             : 
    2714           4 : struct tevent_req *dcerpc_drsuapi_DsRemoveDSServer_r_send(TALLOC_CTX *mem_ctx,
    2715             :         struct tevent_context *ev,
    2716             :         struct dcerpc_binding_handle *h,
    2717             :         struct drsuapi_DsRemoveDSServer *r)
    2718             : {
    2719             :         struct tevent_req *req;
    2720             :         struct dcerpc_drsuapi_DsRemoveDSServer_r_state *state;
    2721             :         struct tevent_req *subreq;
    2722             : 
    2723           4 :         req = tevent_req_create(mem_ctx, &state,
    2724             :                                 struct dcerpc_drsuapi_DsRemoveDSServer_r_state);
    2725           4 :         if (req == NULL) {
    2726           0 :                 return NULL;
    2727             :         }
    2728             : 
    2729           4 :         state->out_mem_ctx = talloc_new(state);
    2730           4 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    2731           0 :                 return tevent_req_post(req, ev);
    2732             :         }
    2733             : 
    2734           4 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    2735             :                         NULL, &ndr_table_drsuapi,
    2736           4 :                         NDR_DRSUAPI_DSREMOVEDSSERVER, state->out_mem_ctx, r);
    2737           4 :         if (tevent_req_nomem(subreq, req)) {
    2738           0 :                 return tevent_req_post(req, ev);
    2739             :         }
    2740           4 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsRemoveDSServer_r_done, req);
    2741             : 
    2742           4 :         return req;
    2743             : }
    2744             : 
    2745           4 : static void dcerpc_drsuapi_DsRemoveDSServer_r_done(struct tevent_req *subreq)
    2746             : {
    2747           2 :         struct tevent_req *req =
    2748           4 :                 tevent_req_callback_data(subreq,
    2749             :                 struct tevent_req);
    2750             :         NTSTATUS status;
    2751             : 
    2752           4 :         status = dcerpc_binding_handle_call_recv(subreq);
    2753           4 :         TALLOC_FREE(subreq);
    2754           4 :         if (tevent_req_nterror(req, status)) {
    2755           0 :                 return;
    2756             :         }
    2757             : 
    2758           4 :         tevent_req_done(req);
    2759             : }
    2760             : 
    2761           4 : NTSTATUS dcerpc_drsuapi_DsRemoveDSServer_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    2762             : {
    2763           2 :         struct dcerpc_drsuapi_DsRemoveDSServer_r_state *state =
    2764           4 :                 tevent_req_data(req,
    2765             :                 struct dcerpc_drsuapi_DsRemoveDSServer_r_state);
    2766             :         NTSTATUS status;
    2767             : 
    2768           4 :         if (tevent_req_is_nterror(req, &status)) {
    2769           0 :                 tevent_req_received(req);
    2770           0 :                 return status;
    2771             :         }
    2772             : 
    2773           4 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    2774             : 
    2775           4 :         tevent_req_received(req);
    2776           4 :         return NT_STATUS_OK;
    2777             : }
    2778             : 
    2779           3 : NTSTATUS dcerpc_drsuapi_DsRemoveDSServer_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct drsuapi_DsRemoveDSServer *r)
    2780             : {
    2781             :         NTSTATUS status;
    2782             : 
    2783           3 :         status = dcerpc_binding_handle_call(h,
    2784             :                         NULL, &ndr_table_drsuapi,
    2785             :                         NDR_DRSUAPI_DSREMOVEDSSERVER, mem_ctx, r);
    2786             : 
    2787           3 :         return status;
    2788             : }
    2789             : 
    2790             : struct dcerpc_drsuapi_DsRemoveDSServer_state {
    2791             :         struct drsuapi_DsRemoveDSServer orig;
    2792             :         struct drsuapi_DsRemoveDSServer tmp;
    2793             :         TALLOC_CTX *out_mem_ctx;
    2794             : };
    2795             : 
    2796             : static void dcerpc_drsuapi_DsRemoveDSServer_done(struct tevent_req *subreq);
    2797             : 
    2798           0 : struct tevent_req *dcerpc_drsuapi_DsRemoveDSServer_send(TALLOC_CTX *mem_ctx,
    2799             :                                                         struct tevent_context *ev,
    2800             :                                                         struct dcerpc_binding_handle *h,
    2801             :                                                         struct policy_handle *_bind_handle /* [in] [ref] */,
    2802             :                                                         uint32_t _level /* [in]  */,
    2803             :                                                         union drsuapi_DsRemoveDSServerRequest *_req /* [in] [ref,switch_is(level)] */,
    2804             :                                                         uint32_t *_level_out /* [out] [ref] */,
    2805             :                                                         union drsuapi_DsRemoveDSServerResult *_res /* [out] [ref,switch_is(*level_out)] */)
    2806             : {
    2807             :         struct tevent_req *req;
    2808             :         struct dcerpc_drsuapi_DsRemoveDSServer_state *state;
    2809             :         struct tevent_req *subreq;
    2810             : 
    2811           0 :         req = tevent_req_create(mem_ctx, &state,
    2812             :                                 struct dcerpc_drsuapi_DsRemoveDSServer_state);
    2813           0 :         if (req == NULL) {
    2814           0 :                 return NULL;
    2815             :         }
    2816           0 :         state->out_mem_ctx = NULL;
    2817             : 
    2818             :         /* In parameters */
    2819           0 :         state->orig.in.bind_handle = _bind_handle;
    2820           0 :         state->orig.in.level = _level;
    2821           0 :         state->orig.in.req = _req;
    2822             : 
    2823             :         /* Out parameters */
    2824           0 :         state->orig.out.level_out = _level_out;
    2825           0 :         state->orig.out.res = _res;
    2826             : 
    2827             :         /* Result */
    2828           0 :         NDR_ZERO_STRUCT(state->orig.out.result);
    2829             : 
    2830           0 :         state->out_mem_ctx = talloc_named_const(state, 0,
    2831             :                              "dcerpc_drsuapi_DsRemoveDSServer_out_memory");
    2832           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    2833           0 :                 return tevent_req_post(req, ev);
    2834             :         }
    2835             : 
    2836             :         /* make a temporary copy, that we pass to the dispatch function */
    2837           0 :         state->tmp = state->orig;
    2838             : 
    2839           0 :         subreq = dcerpc_drsuapi_DsRemoveDSServer_r_send(state, ev, h, &state->tmp);
    2840           0 :         if (tevent_req_nomem(subreq, req)) {
    2841           0 :                 return tevent_req_post(req, ev);
    2842             :         }
    2843           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsRemoveDSServer_done, req);
    2844           0 :         return req;
    2845             : }
    2846             : 
    2847           0 : static void dcerpc_drsuapi_DsRemoveDSServer_done(struct tevent_req *subreq)
    2848             : {
    2849           0 :         struct tevent_req *req = tevent_req_callback_data(
    2850             :                 subreq, struct tevent_req);
    2851           0 :         struct dcerpc_drsuapi_DsRemoveDSServer_state *state = tevent_req_data(
    2852             :                 req, struct dcerpc_drsuapi_DsRemoveDSServer_state);
    2853             :         NTSTATUS status;
    2854             :         TALLOC_CTX *mem_ctx;
    2855             : 
    2856           0 :         if (state->out_mem_ctx) {
    2857           0 :                 mem_ctx = state->out_mem_ctx;
    2858             :         } else {
    2859           0 :                 mem_ctx = state;
    2860             :         }
    2861             : 
    2862           0 :         status = dcerpc_drsuapi_DsRemoveDSServer_r_recv(subreq, mem_ctx);
    2863           0 :         TALLOC_FREE(subreq);
    2864           0 :         if (tevent_req_nterror(req, status)) {
    2865           0 :                 return;
    2866             :         }
    2867             : 
    2868             :         /* Copy out parameters */
    2869           0 :         *state->orig.out.level_out = *state->tmp.out.level_out;
    2870           0 :         *state->orig.out.res = *state->tmp.out.res;
    2871             : 
    2872             :         /* Copy result */
    2873           0 :         state->orig.out.result = state->tmp.out.result;
    2874             : 
    2875             :         /* Reset temporary structure */
    2876           0 :         NDR_ZERO_STRUCT(state->tmp);
    2877             : 
    2878           0 :         tevent_req_done(req);
    2879             : }
    2880             : 
    2881           0 : NTSTATUS dcerpc_drsuapi_DsRemoveDSServer_recv(struct tevent_req *req,
    2882             :                                               TALLOC_CTX *mem_ctx,
    2883             :                                               WERROR *result)
    2884             : {
    2885           0 :         struct dcerpc_drsuapi_DsRemoveDSServer_state *state = tevent_req_data(
    2886             :                 req, struct dcerpc_drsuapi_DsRemoveDSServer_state);
    2887             :         NTSTATUS status;
    2888             : 
    2889           0 :         if (tevent_req_is_nterror(req, &status)) {
    2890           0 :                 tevent_req_received(req);
    2891           0 :                 return status;
    2892             :         }
    2893             : 
    2894             :         /* Steal possible out parameters to the callers context */
    2895           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    2896             : 
    2897             :         /* Return result */
    2898           0 :         *result = state->orig.out.result;
    2899             : 
    2900           0 :         tevent_req_received(req);
    2901           0 :         return NT_STATUS_OK;
    2902             : }
    2903             : 
    2904           0 : NTSTATUS dcerpc_drsuapi_DsRemoveDSServer(struct dcerpc_binding_handle *h,
    2905             :                                          TALLOC_CTX *mem_ctx,
    2906             :                                          struct policy_handle *_bind_handle /* [in] [ref] */,
    2907             :                                          uint32_t _level /* [in]  */,
    2908             :                                          union drsuapi_DsRemoveDSServerRequest *_req /* [in] [ref,switch_is(level)] */,
    2909             :                                          uint32_t *_level_out /* [out] [ref] */,
    2910             :                                          union drsuapi_DsRemoveDSServerResult *_res /* [out] [ref,switch_is(*level_out)] */,
    2911             :                                          WERROR *result)
    2912             : {
    2913             :         struct drsuapi_DsRemoveDSServer r;
    2914             :         NTSTATUS status;
    2915             : 
    2916             :         /* In parameters */
    2917           0 :         r.in.bind_handle = _bind_handle;
    2918           0 :         r.in.level = _level;
    2919           0 :         r.in.req = _req;
    2920             : 
    2921             :         /* Out parameters */
    2922           0 :         r.out.level_out = _level_out;
    2923           0 :         r.out.res = _res;
    2924             : 
    2925             :         /* Result */
    2926           0 :         NDR_ZERO_STRUCT(r.out.result);
    2927             : 
    2928           0 :         status = dcerpc_drsuapi_DsRemoveDSServer_r(h, mem_ctx, &r);
    2929           0 :         if (!NT_STATUS_IS_OK(status)) {
    2930           0 :                 return status;
    2931             :         }
    2932             : 
    2933             :         /* Return variables */
    2934           0 :         *_level_out = *r.out.level_out;
    2935           0 :         *_res = *r.out.res;
    2936             : 
    2937             :         /* Return result */
    2938           0 :         *result = r.out.result;
    2939             : 
    2940           0 :         return NT_STATUS_OK;
    2941             : }
    2942             : 
    2943             : struct dcerpc_drsuapi_DsGetDomainControllerInfo_r_state {
    2944             :         TALLOC_CTX *out_mem_ctx;
    2945             : };
    2946             : 
    2947             : static void dcerpc_drsuapi_DsGetDomainControllerInfo_r_done(struct tevent_req *subreq);
    2948             : 
    2949           0 : struct tevent_req *dcerpc_drsuapi_DsGetDomainControllerInfo_r_send(TALLOC_CTX *mem_ctx,
    2950             :         struct tevent_context *ev,
    2951             :         struct dcerpc_binding_handle *h,
    2952             :         struct drsuapi_DsGetDomainControllerInfo *r)
    2953             : {
    2954             :         struct tevent_req *req;
    2955             :         struct dcerpc_drsuapi_DsGetDomainControllerInfo_r_state *state;
    2956             :         struct tevent_req *subreq;
    2957             : 
    2958           0 :         req = tevent_req_create(mem_ctx, &state,
    2959             :                                 struct dcerpc_drsuapi_DsGetDomainControllerInfo_r_state);
    2960           0 :         if (req == NULL) {
    2961           0 :                 return NULL;
    2962             :         }
    2963             : 
    2964           0 :         state->out_mem_ctx = talloc_new(state);
    2965           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    2966           0 :                 return tevent_req_post(req, ev);
    2967             :         }
    2968             : 
    2969           0 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    2970             :                         NULL, &ndr_table_drsuapi,
    2971           0 :                         NDR_DRSUAPI_DSGETDOMAINCONTROLLERINFO, state->out_mem_ctx, r);
    2972           0 :         if (tevent_req_nomem(subreq, req)) {
    2973           0 :                 return tevent_req_post(req, ev);
    2974             :         }
    2975           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsGetDomainControllerInfo_r_done, req);
    2976             : 
    2977           0 :         return req;
    2978             : }
    2979             : 
    2980           0 : static void dcerpc_drsuapi_DsGetDomainControllerInfo_r_done(struct tevent_req *subreq)
    2981             : {
    2982           0 :         struct tevent_req *req =
    2983           0 :                 tevent_req_callback_data(subreq,
    2984             :                 struct tevent_req);
    2985             :         NTSTATUS status;
    2986             : 
    2987           0 :         status = dcerpc_binding_handle_call_recv(subreq);
    2988           0 :         TALLOC_FREE(subreq);
    2989           0 :         if (tevent_req_nterror(req, status)) {
    2990           0 :                 return;
    2991             :         }
    2992             : 
    2993           0 :         tevent_req_done(req);
    2994             : }
    2995             : 
    2996           0 : NTSTATUS dcerpc_drsuapi_DsGetDomainControllerInfo_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    2997             : {
    2998           0 :         struct dcerpc_drsuapi_DsGetDomainControllerInfo_r_state *state =
    2999           0 :                 tevent_req_data(req,
    3000             :                 struct dcerpc_drsuapi_DsGetDomainControllerInfo_r_state);
    3001             :         NTSTATUS status;
    3002             : 
    3003           0 :         if (tevent_req_is_nterror(req, &status)) {
    3004           0 :                 tevent_req_received(req);
    3005           0 :                 return status;
    3006             :         }
    3007             : 
    3008           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    3009             : 
    3010           0 :         tevent_req_received(req);
    3011           0 :         return NT_STATUS_OK;
    3012             : }
    3013             : 
    3014           6 : NTSTATUS dcerpc_drsuapi_DsGetDomainControllerInfo_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct drsuapi_DsGetDomainControllerInfo *r)
    3015             : {
    3016             :         NTSTATUS status;
    3017             : 
    3018           6 :         status = dcerpc_binding_handle_call(h,
    3019             :                         NULL, &ndr_table_drsuapi,
    3020             :                         NDR_DRSUAPI_DSGETDOMAINCONTROLLERINFO, mem_ctx, r);
    3021             : 
    3022           6 :         return status;
    3023             : }
    3024             : 
    3025             : struct dcerpc_drsuapi_DsGetDomainControllerInfo_state {
    3026             :         struct drsuapi_DsGetDomainControllerInfo orig;
    3027             :         struct drsuapi_DsGetDomainControllerInfo tmp;
    3028             :         TALLOC_CTX *out_mem_ctx;
    3029             : };
    3030             : 
    3031             : static void dcerpc_drsuapi_DsGetDomainControllerInfo_done(struct tevent_req *subreq);
    3032             : 
    3033           0 : struct tevent_req *dcerpc_drsuapi_DsGetDomainControllerInfo_send(TALLOC_CTX *mem_ctx,
    3034             :                                                                  struct tevent_context *ev,
    3035             :                                                                  struct dcerpc_binding_handle *h,
    3036             :                                                                  struct policy_handle *_bind_handle /* [in] [ref] */,
    3037             :                                                                  uint32_t _level /* [in]  */,
    3038             :                                                                  union drsuapi_DsGetDCInfoRequest *_req /* [in] [ref,switch_is(level)] */,
    3039             :                                                                  enum drsuapi_DsGetDCInfoCtrLevels *_level_out /* [out] [ref] */,
    3040             :                                                                  union drsuapi_DsGetDCInfoCtr *_ctr /* [out] [ref,switch_is(*level_out)] */)
    3041             : {
    3042             :         struct tevent_req *req;
    3043             :         struct dcerpc_drsuapi_DsGetDomainControllerInfo_state *state;
    3044             :         struct tevent_req *subreq;
    3045             : 
    3046           0 :         req = tevent_req_create(mem_ctx, &state,
    3047             :                                 struct dcerpc_drsuapi_DsGetDomainControllerInfo_state);
    3048           0 :         if (req == NULL) {
    3049           0 :                 return NULL;
    3050             :         }
    3051           0 :         state->out_mem_ctx = NULL;
    3052             : 
    3053             :         /* In parameters */
    3054           0 :         state->orig.in.bind_handle = _bind_handle;
    3055           0 :         state->orig.in.level = _level;
    3056           0 :         state->orig.in.req = _req;
    3057             : 
    3058             :         /* Out parameters */
    3059           0 :         state->orig.out.level_out = _level_out;
    3060           0 :         state->orig.out.ctr = _ctr;
    3061             : 
    3062             :         /* Result */
    3063           0 :         NDR_ZERO_STRUCT(state->orig.out.result);
    3064             : 
    3065           0 :         state->out_mem_ctx = talloc_named_const(state, 0,
    3066             :                              "dcerpc_drsuapi_DsGetDomainControllerInfo_out_memory");
    3067           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    3068           0 :                 return tevent_req_post(req, ev);
    3069             :         }
    3070             : 
    3071             :         /* make a temporary copy, that we pass to the dispatch function */
    3072           0 :         state->tmp = state->orig;
    3073             : 
    3074           0 :         subreq = dcerpc_drsuapi_DsGetDomainControllerInfo_r_send(state, ev, h, &state->tmp);
    3075           0 :         if (tevent_req_nomem(subreq, req)) {
    3076           0 :                 return tevent_req_post(req, ev);
    3077             :         }
    3078           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsGetDomainControllerInfo_done, req);
    3079           0 :         return req;
    3080             : }
    3081             : 
    3082           0 : static void dcerpc_drsuapi_DsGetDomainControllerInfo_done(struct tevent_req *subreq)
    3083             : {
    3084           0 :         struct tevent_req *req = tevent_req_callback_data(
    3085             :                 subreq, struct tevent_req);
    3086           0 :         struct dcerpc_drsuapi_DsGetDomainControllerInfo_state *state = tevent_req_data(
    3087             :                 req, struct dcerpc_drsuapi_DsGetDomainControllerInfo_state);
    3088             :         NTSTATUS status;
    3089             :         TALLOC_CTX *mem_ctx;
    3090             : 
    3091           0 :         if (state->out_mem_ctx) {
    3092           0 :                 mem_ctx = state->out_mem_ctx;
    3093             :         } else {
    3094           0 :                 mem_ctx = state;
    3095             :         }
    3096             : 
    3097           0 :         status = dcerpc_drsuapi_DsGetDomainControllerInfo_r_recv(subreq, mem_ctx);
    3098           0 :         TALLOC_FREE(subreq);
    3099           0 :         if (tevent_req_nterror(req, status)) {
    3100           0 :                 return;
    3101             :         }
    3102             : 
    3103             :         /* Copy out parameters */
    3104           0 :         *state->orig.out.level_out = *state->tmp.out.level_out;
    3105           0 :         *state->orig.out.ctr = *state->tmp.out.ctr;
    3106             : 
    3107             :         /* Copy result */
    3108           0 :         state->orig.out.result = state->tmp.out.result;
    3109             : 
    3110             :         /* Reset temporary structure */
    3111           0 :         NDR_ZERO_STRUCT(state->tmp);
    3112             : 
    3113           0 :         tevent_req_done(req);
    3114             : }
    3115             : 
    3116           0 : NTSTATUS dcerpc_drsuapi_DsGetDomainControllerInfo_recv(struct tevent_req *req,
    3117             :                                                        TALLOC_CTX *mem_ctx,
    3118             :                                                        WERROR *result)
    3119             : {
    3120           0 :         struct dcerpc_drsuapi_DsGetDomainControllerInfo_state *state = tevent_req_data(
    3121             :                 req, struct dcerpc_drsuapi_DsGetDomainControllerInfo_state);
    3122             :         NTSTATUS status;
    3123             : 
    3124           0 :         if (tevent_req_is_nterror(req, &status)) {
    3125           0 :                 tevent_req_received(req);
    3126           0 :                 return status;
    3127             :         }
    3128             : 
    3129             :         /* Steal possible out parameters to the callers context */
    3130           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    3131             : 
    3132             :         /* Return result */
    3133           0 :         *result = state->orig.out.result;
    3134             : 
    3135           0 :         tevent_req_received(req);
    3136           0 :         return NT_STATUS_OK;
    3137             : }
    3138             : 
    3139           0 : NTSTATUS dcerpc_drsuapi_DsGetDomainControllerInfo(struct dcerpc_binding_handle *h,
    3140             :                                                   TALLOC_CTX *mem_ctx,
    3141             :                                                   struct policy_handle *_bind_handle /* [in] [ref] */,
    3142             :                                                   uint32_t _level /* [in]  */,
    3143             :                                                   union drsuapi_DsGetDCInfoRequest *_req /* [in] [ref,switch_is(level)] */,
    3144             :                                                   enum drsuapi_DsGetDCInfoCtrLevels *_level_out /* [out] [ref] */,
    3145             :                                                   union drsuapi_DsGetDCInfoCtr *_ctr /* [out] [ref,switch_is(*level_out)] */,
    3146             :                                                   WERROR *result)
    3147             : {
    3148             :         struct drsuapi_DsGetDomainControllerInfo r;
    3149             :         NTSTATUS status;
    3150             : 
    3151             :         /* In parameters */
    3152           0 :         r.in.bind_handle = _bind_handle;
    3153           0 :         r.in.level = _level;
    3154           0 :         r.in.req = _req;
    3155             : 
    3156             :         /* Out parameters */
    3157           0 :         r.out.level_out = _level_out;
    3158           0 :         r.out.ctr = _ctr;
    3159             : 
    3160             :         /* Result */
    3161           0 :         NDR_ZERO_STRUCT(r.out.result);
    3162             : 
    3163           0 :         status = dcerpc_drsuapi_DsGetDomainControllerInfo_r(h, mem_ctx, &r);
    3164           0 :         if (!NT_STATUS_IS_OK(status)) {
    3165           0 :                 return status;
    3166             :         }
    3167             : 
    3168             :         /* Return variables */
    3169           0 :         *_level_out = *r.out.level_out;
    3170           0 :         *_ctr = *r.out.ctr;
    3171             : 
    3172             :         /* Return result */
    3173           0 :         *result = r.out.result;
    3174             : 
    3175           0 :         return NT_STATUS_OK;
    3176             : }
    3177             : 
    3178             : struct dcerpc_drsuapi_DsAddEntry_r_state {
    3179             :         TALLOC_CTX *out_mem_ctx;
    3180             : };
    3181             : 
    3182             : static void dcerpc_drsuapi_DsAddEntry_r_done(struct tevent_req *subreq);
    3183             : 
    3184           4 : struct tevent_req *dcerpc_drsuapi_DsAddEntry_r_send(TALLOC_CTX *mem_ctx,
    3185             :         struct tevent_context *ev,
    3186             :         struct dcerpc_binding_handle *h,
    3187             :         struct drsuapi_DsAddEntry *r)
    3188             : {
    3189             :         struct tevent_req *req;
    3190             :         struct dcerpc_drsuapi_DsAddEntry_r_state *state;
    3191             :         struct tevent_req *subreq;
    3192             : 
    3193           4 :         req = tevent_req_create(mem_ctx, &state,
    3194             :                                 struct dcerpc_drsuapi_DsAddEntry_r_state);
    3195           4 :         if (req == NULL) {
    3196           0 :                 return NULL;
    3197             :         }
    3198             : 
    3199           4 :         state->out_mem_ctx = talloc_new(state);
    3200           4 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    3201           0 :                 return tevent_req_post(req, ev);
    3202             :         }
    3203             : 
    3204           4 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    3205             :                         NULL, &ndr_table_drsuapi,
    3206           4 :                         NDR_DRSUAPI_DSADDENTRY, state->out_mem_ctx, r);
    3207           4 :         if (tevent_req_nomem(subreq, req)) {
    3208           0 :                 return tevent_req_post(req, ev);
    3209             :         }
    3210           4 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsAddEntry_r_done, req);
    3211             : 
    3212           4 :         return req;
    3213             : }
    3214             : 
    3215           4 : static void dcerpc_drsuapi_DsAddEntry_r_done(struct tevent_req *subreq)
    3216             : {
    3217           2 :         struct tevent_req *req =
    3218           4 :                 tevent_req_callback_data(subreq,
    3219             :                 struct tevent_req);
    3220             :         NTSTATUS status;
    3221             : 
    3222           4 :         status = dcerpc_binding_handle_call_recv(subreq);
    3223           4 :         TALLOC_FREE(subreq);
    3224           4 :         if (tevent_req_nterror(req, status)) {
    3225           0 :                 return;
    3226             :         }
    3227             : 
    3228           4 :         tevent_req_done(req);
    3229             : }
    3230             : 
    3231           4 : NTSTATUS dcerpc_drsuapi_DsAddEntry_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    3232             : {
    3233           2 :         struct dcerpc_drsuapi_DsAddEntry_r_state *state =
    3234           4 :                 tevent_req_data(req,
    3235             :                 struct dcerpc_drsuapi_DsAddEntry_r_state);
    3236             :         NTSTATUS status;
    3237             : 
    3238           4 :         if (tevent_req_is_nterror(req, &status)) {
    3239           0 :                 tevent_req_received(req);
    3240           0 :                 return status;
    3241             :         }
    3242             : 
    3243           4 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    3244             : 
    3245           4 :         tevent_req_received(req);
    3246           4 :         return NT_STATUS_OK;
    3247             : }
    3248             : 
    3249          59 : NTSTATUS dcerpc_drsuapi_DsAddEntry_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct drsuapi_DsAddEntry *r)
    3250             : {
    3251             :         NTSTATUS status;
    3252             : 
    3253          59 :         status = dcerpc_binding_handle_call(h,
    3254             :                         NULL, &ndr_table_drsuapi,
    3255             :                         NDR_DRSUAPI_DSADDENTRY, mem_ctx, r);
    3256             : 
    3257          59 :         return status;
    3258             : }
    3259             : 
    3260             : struct dcerpc_drsuapi_DsAddEntry_state {
    3261             :         struct drsuapi_DsAddEntry orig;
    3262             :         struct drsuapi_DsAddEntry tmp;
    3263             :         TALLOC_CTX *out_mem_ctx;
    3264             : };
    3265             : 
    3266             : static void dcerpc_drsuapi_DsAddEntry_done(struct tevent_req *subreq);
    3267             : 
    3268           0 : struct tevent_req *dcerpc_drsuapi_DsAddEntry_send(TALLOC_CTX *mem_ctx,
    3269             :                                                   struct tevent_context *ev,
    3270             :                                                   struct dcerpc_binding_handle *h,
    3271             :                                                   struct policy_handle *_bind_handle /* [in] [ref] */,
    3272             :                                                   uint32_t _level /* [in]  */,
    3273             :                                                   union drsuapi_DsAddEntryRequest *_req /* [in] [ref,switch_is(level)] */,
    3274             :                                                   uint32_t *_level_out /* [out] [ref] */,
    3275             :                                                   union drsuapi_DsAddEntryCtr *_ctr /* [out] [ref,switch_is(*level_out)] */)
    3276             : {
    3277             :         struct tevent_req *req;
    3278             :         struct dcerpc_drsuapi_DsAddEntry_state *state;
    3279             :         struct tevent_req *subreq;
    3280             : 
    3281           0 :         req = tevent_req_create(mem_ctx, &state,
    3282             :                                 struct dcerpc_drsuapi_DsAddEntry_state);
    3283           0 :         if (req == NULL) {
    3284           0 :                 return NULL;
    3285             :         }
    3286           0 :         state->out_mem_ctx = NULL;
    3287             : 
    3288             :         /* In parameters */
    3289           0 :         state->orig.in.bind_handle = _bind_handle;
    3290           0 :         state->orig.in.level = _level;
    3291           0 :         state->orig.in.req = _req;
    3292             : 
    3293             :         /* Out parameters */
    3294           0 :         state->orig.out.level_out = _level_out;
    3295           0 :         state->orig.out.ctr = _ctr;
    3296             : 
    3297             :         /* Result */
    3298           0 :         NDR_ZERO_STRUCT(state->orig.out.result);
    3299             : 
    3300           0 :         state->out_mem_ctx = talloc_named_const(state, 0,
    3301             :                              "dcerpc_drsuapi_DsAddEntry_out_memory");
    3302           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    3303           0 :                 return tevent_req_post(req, ev);
    3304             :         }
    3305             : 
    3306             :         /* make a temporary copy, that we pass to the dispatch function */
    3307           0 :         state->tmp = state->orig;
    3308             : 
    3309           0 :         subreq = dcerpc_drsuapi_DsAddEntry_r_send(state, ev, h, &state->tmp);
    3310           0 :         if (tevent_req_nomem(subreq, req)) {
    3311           0 :                 return tevent_req_post(req, ev);
    3312             :         }
    3313           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsAddEntry_done, req);
    3314           0 :         return req;
    3315             : }
    3316             : 
    3317           0 : static void dcerpc_drsuapi_DsAddEntry_done(struct tevent_req *subreq)
    3318             : {
    3319           0 :         struct tevent_req *req = tevent_req_callback_data(
    3320             :                 subreq, struct tevent_req);
    3321           0 :         struct dcerpc_drsuapi_DsAddEntry_state *state = tevent_req_data(
    3322             :                 req, struct dcerpc_drsuapi_DsAddEntry_state);
    3323             :         NTSTATUS status;
    3324             :         TALLOC_CTX *mem_ctx;
    3325             : 
    3326           0 :         if (state->out_mem_ctx) {
    3327           0 :                 mem_ctx = state->out_mem_ctx;
    3328             :         } else {
    3329           0 :                 mem_ctx = state;
    3330             :         }
    3331             : 
    3332           0 :         status = dcerpc_drsuapi_DsAddEntry_r_recv(subreq, mem_ctx);
    3333           0 :         TALLOC_FREE(subreq);
    3334           0 :         if (tevent_req_nterror(req, status)) {
    3335           0 :                 return;
    3336             :         }
    3337             : 
    3338             :         /* Copy out parameters */
    3339           0 :         *state->orig.out.level_out = *state->tmp.out.level_out;
    3340           0 :         *state->orig.out.ctr = *state->tmp.out.ctr;
    3341             : 
    3342             :         /* Copy result */
    3343           0 :         state->orig.out.result = state->tmp.out.result;
    3344             : 
    3345             :         /* Reset temporary structure */
    3346           0 :         NDR_ZERO_STRUCT(state->tmp);
    3347             : 
    3348           0 :         tevent_req_done(req);
    3349             : }
    3350             : 
    3351           0 : NTSTATUS dcerpc_drsuapi_DsAddEntry_recv(struct tevent_req *req,
    3352             :                                         TALLOC_CTX *mem_ctx,
    3353             :                                         WERROR *result)
    3354             : {
    3355           0 :         struct dcerpc_drsuapi_DsAddEntry_state *state = tevent_req_data(
    3356             :                 req, struct dcerpc_drsuapi_DsAddEntry_state);
    3357             :         NTSTATUS status;
    3358             : 
    3359           0 :         if (tevent_req_is_nterror(req, &status)) {
    3360           0 :                 tevent_req_received(req);
    3361           0 :                 return status;
    3362             :         }
    3363             : 
    3364             :         /* Steal possible out parameters to the callers context */
    3365           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    3366             : 
    3367             :         /* Return result */
    3368           0 :         *result = state->orig.out.result;
    3369             : 
    3370           0 :         tevent_req_received(req);
    3371           0 :         return NT_STATUS_OK;
    3372             : }
    3373             : 
    3374           0 : NTSTATUS dcerpc_drsuapi_DsAddEntry(struct dcerpc_binding_handle *h,
    3375             :                                    TALLOC_CTX *mem_ctx,
    3376             :                                    struct policy_handle *_bind_handle /* [in] [ref] */,
    3377             :                                    uint32_t _level /* [in]  */,
    3378             :                                    union drsuapi_DsAddEntryRequest *_req /* [in] [ref,switch_is(level)] */,
    3379             :                                    uint32_t *_level_out /* [out] [ref] */,
    3380             :                                    union drsuapi_DsAddEntryCtr *_ctr /* [out] [ref,switch_is(*level_out)] */,
    3381             :                                    WERROR *result)
    3382             : {
    3383             :         struct drsuapi_DsAddEntry r;
    3384             :         NTSTATUS status;
    3385             : 
    3386             :         /* In parameters */
    3387           0 :         r.in.bind_handle = _bind_handle;
    3388           0 :         r.in.level = _level;
    3389           0 :         r.in.req = _req;
    3390             : 
    3391             :         /* Out parameters */
    3392           0 :         r.out.level_out = _level_out;
    3393           0 :         r.out.ctr = _ctr;
    3394             : 
    3395             :         /* Result */
    3396           0 :         NDR_ZERO_STRUCT(r.out.result);
    3397             : 
    3398           0 :         status = dcerpc_drsuapi_DsAddEntry_r(h, mem_ctx, &r);
    3399           0 :         if (!NT_STATUS_IS_OK(status)) {
    3400           0 :                 return status;
    3401             :         }
    3402             : 
    3403             :         /* Return variables */
    3404           0 :         *_level_out = *r.out.level_out;
    3405           0 :         *_ctr = *r.out.ctr;
    3406             : 
    3407             :         /* Return result */
    3408           0 :         *result = r.out.result;
    3409             : 
    3410           0 :         return NT_STATUS_OK;
    3411             : }
    3412             : 
    3413             : struct dcerpc_drsuapi_DsExecuteKCC_r_state {
    3414             :         TALLOC_CTX *out_mem_ctx;
    3415             : };
    3416             : 
    3417             : static void dcerpc_drsuapi_DsExecuteKCC_r_done(struct tevent_req *subreq);
    3418             : 
    3419           0 : struct tevent_req *dcerpc_drsuapi_DsExecuteKCC_r_send(TALLOC_CTX *mem_ctx,
    3420             :         struct tevent_context *ev,
    3421             :         struct dcerpc_binding_handle *h,
    3422             :         struct drsuapi_DsExecuteKCC *r)
    3423             : {
    3424             :         struct tevent_req *req;
    3425             :         struct dcerpc_drsuapi_DsExecuteKCC_r_state *state;
    3426             :         struct tevent_req *subreq;
    3427             : 
    3428           0 :         req = tevent_req_create(mem_ctx, &state,
    3429             :                                 struct dcerpc_drsuapi_DsExecuteKCC_r_state);
    3430           0 :         if (req == NULL) {
    3431           0 :                 return NULL;
    3432             :         }
    3433             : 
    3434           0 :         state->out_mem_ctx = NULL;
    3435             : 
    3436           0 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    3437             :                         NULL, &ndr_table_drsuapi,
    3438             :                         NDR_DRSUAPI_DSEXECUTEKCC, state, r);
    3439           0 :         if (tevent_req_nomem(subreq, req)) {
    3440           0 :                 return tevent_req_post(req, ev);
    3441             :         }
    3442           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsExecuteKCC_r_done, req);
    3443             : 
    3444           0 :         return req;
    3445             : }
    3446             : 
    3447           0 : static void dcerpc_drsuapi_DsExecuteKCC_r_done(struct tevent_req *subreq)
    3448             : {
    3449           0 :         struct tevent_req *req =
    3450           0 :                 tevent_req_callback_data(subreq,
    3451             :                 struct tevent_req);
    3452             :         NTSTATUS status;
    3453             : 
    3454           0 :         status = dcerpc_binding_handle_call_recv(subreq);
    3455           0 :         TALLOC_FREE(subreq);
    3456           0 :         if (tevent_req_nterror(req, status)) {
    3457           0 :                 return;
    3458             :         }
    3459             : 
    3460           0 :         tevent_req_done(req);
    3461             : }
    3462             : 
    3463           0 : NTSTATUS dcerpc_drsuapi_DsExecuteKCC_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    3464             : {
    3465           0 :         struct dcerpc_drsuapi_DsExecuteKCC_r_state *state =
    3466           0 :                 tevent_req_data(req,
    3467             :                 struct dcerpc_drsuapi_DsExecuteKCC_r_state);
    3468             :         NTSTATUS status;
    3469             : 
    3470           0 :         if (tevent_req_is_nterror(req, &status)) {
    3471           0 :                 tevent_req_received(req);
    3472           0 :                 return status;
    3473             :         }
    3474             : 
    3475           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    3476             : 
    3477           0 :         tevent_req_received(req);
    3478           0 :         return NT_STATUS_OK;
    3479             : }
    3480             : 
    3481           1 : NTSTATUS dcerpc_drsuapi_DsExecuteKCC_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct drsuapi_DsExecuteKCC *r)
    3482             : {
    3483             :         NTSTATUS status;
    3484             : 
    3485           1 :         status = dcerpc_binding_handle_call(h,
    3486             :                         NULL, &ndr_table_drsuapi,
    3487             :                         NDR_DRSUAPI_DSEXECUTEKCC, mem_ctx, r);
    3488             : 
    3489           1 :         return status;
    3490             : }
    3491             : 
    3492             : struct dcerpc_drsuapi_DsExecuteKCC_state {
    3493             :         struct drsuapi_DsExecuteKCC orig;
    3494             :         struct drsuapi_DsExecuteKCC tmp;
    3495             :         TALLOC_CTX *out_mem_ctx;
    3496             : };
    3497             : 
    3498             : static void dcerpc_drsuapi_DsExecuteKCC_done(struct tevent_req *subreq);
    3499             : 
    3500           0 : struct tevent_req *dcerpc_drsuapi_DsExecuteKCC_send(TALLOC_CTX *mem_ctx,
    3501             :                                                     struct tevent_context *ev,
    3502             :                                                     struct dcerpc_binding_handle *h,
    3503             :                                                     struct policy_handle *_bind_handle /* [in] [ref] */,
    3504             :                                                     uint32_t _level /* [in]  */,
    3505             :                                                     union drsuapi_DsExecuteKCCRequest *_req /* [in] [ref,switch_is(level)] */)
    3506             : {
    3507             :         struct tevent_req *req;
    3508             :         struct dcerpc_drsuapi_DsExecuteKCC_state *state;
    3509             :         struct tevent_req *subreq;
    3510             : 
    3511           0 :         req = tevent_req_create(mem_ctx, &state,
    3512             :                                 struct dcerpc_drsuapi_DsExecuteKCC_state);
    3513           0 :         if (req == NULL) {
    3514           0 :                 return NULL;
    3515             :         }
    3516           0 :         state->out_mem_ctx = NULL;
    3517             : 
    3518             :         /* In parameters */
    3519           0 :         state->orig.in.bind_handle = _bind_handle;
    3520           0 :         state->orig.in.level = _level;
    3521           0 :         state->orig.in.req = _req;
    3522             : 
    3523             :         /* Out parameters */
    3524             : 
    3525             :         /* Result */
    3526           0 :         NDR_ZERO_STRUCT(state->orig.out.result);
    3527             : 
    3528             :         /* make a temporary copy, that we pass to the dispatch function */
    3529           0 :         state->tmp = state->orig;
    3530             : 
    3531           0 :         subreq = dcerpc_drsuapi_DsExecuteKCC_r_send(state, ev, h, &state->tmp);
    3532           0 :         if (tevent_req_nomem(subreq, req)) {
    3533           0 :                 return tevent_req_post(req, ev);
    3534             :         }
    3535           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsExecuteKCC_done, req);
    3536           0 :         return req;
    3537             : }
    3538             : 
    3539           0 : static void dcerpc_drsuapi_DsExecuteKCC_done(struct tevent_req *subreq)
    3540             : {
    3541           0 :         struct tevent_req *req = tevent_req_callback_data(
    3542             :                 subreq, struct tevent_req);
    3543           0 :         struct dcerpc_drsuapi_DsExecuteKCC_state *state = tevent_req_data(
    3544             :                 req, struct dcerpc_drsuapi_DsExecuteKCC_state);
    3545             :         NTSTATUS status;
    3546             :         TALLOC_CTX *mem_ctx;
    3547             : 
    3548           0 :         if (state->out_mem_ctx) {
    3549           0 :                 mem_ctx = state->out_mem_ctx;
    3550             :         } else {
    3551           0 :                 mem_ctx = state;
    3552             :         }
    3553             : 
    3554           0 :         status = dcerpc_drsuapi_DsExecuteKCC_r_recv(subreq, mem_ctx);
    3555           0 :         TALLOC_FREE(subreq);
    3556           0 :         if (tevent_req_nterror(req, status)) {
    3557           0 :                 return;
    3558             :         }
    3559             : 
    3560             :         /* Copy out parameters */
    3561             : 
    3562             :         /* Copy result */
    3563           0 :         state->orig.out.result = state->tmp.out.result;
    3564             : 
    3565             :         /* Reset temporary structure */
    3566           0 :         NDR_ZERO_STRUCT(state->tmp);
    3567             : 
    3568           0 :         tevent_req_done(req);
    3569             : }
    3570             : 
    3571           0 : NTSTATUS dcerpc_drsuapi_DsExecuteKCC_recv(struct tevent_req *req,
    3572             :                                           TALLOC_CTX *mem_ctx,
    3573             :                                           WERROR *result)
    3574             : {
    3575           0 :         struct dcerpc_drsuapi_DsExecuteKCC_state *state = tevent_req_data(
    3576             :                 req, struct dcerpc_drsuapi_DsExecuteKCC_state);
    3577             :         NTSTATUS status;
    3578             : 
    3579           0 :         if (tevent_req_is_nterror(req, &status)) {
    3580           0 :                 tevent_req_received(req);
    3581           0 :                 return status;
    3582             :         }
    3583             : 
    3584             :         /* Steal possible out parameters to the callers context */
    3585           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    3586             : 
    3587             :         /* Return result */
    3588           0 :         *result = state->orig.out.result;
    3589             : 
    3590           0 :         tevent_req_received(req);
    3591           0 :         return NT_STATUS_OK;
    3592             : }
    3593             : 
    3594           0 : NTSTATUS dcerpc_drsuapi_DsExecuteKCC(struct dcerpc_binding_handle *h,
    3595             :                                      TALLOC_CTX *mem_ctx,
    3596             :                                      struct policy_handle *_bind_handle /* [in] [ref] */,
    3597             :                                      uint32_t _level /* [in]  */,
    3598             :                                      union drsuapi_DsExecuteKCCRequest *_req /* [in] [ref,switch_is(level)] */,
    3599             :                                      WERROR *result)
    3600             : {
    3601             :         struct drsuapi_DsExecuteKCC r;
    3602             :         NTSTATUS status;
    3603             : 
    3604             :         /* In parameters */
    3605           0 :         r.in.bind_handle = _bind_handle;
    3606           0 :         r.in.level = _level;
    3607           0 :         r.in.req = _req;
    3608             : 
    3609             :         /* Out parameters */
    3610             : 
    3611             :         /* Result */
    3612           0 :         NDR_ZERO_STRUCT(r.out.result);
    3613             : 
    3614           0 :         status = dcerpc_drsuapi_DsExecuteKCC_r(h, mem_ctx, &r);
    3615           0 :         if (!NT_STATUS_IS_OK(status)) {
    3616           0 :                 return status;
    3617             :         }
    3618             : 
    3619             :         /* Return variables */
    3620             : 
    3621             :         /* Return result */
    3622           0 :         *result = r.out.result;
    3623             : 
    3624           0 :         return NT_STATUS_OK;
    3625             : }
    3626             : 
    3627             : struct dcerpc_drsuapi_DsReplicaGetInfo_r_state {
    3628             :         TALLOC_CTX *out_mem_ctx;
    3629             : };
    3630             : 
    3631             : static void dcerpc_drsuapi_DsReplicaGetInfo_r_done(struct tevent_req *subreq);
    3632             : 
    3633           0 : struct tevent_req *dcerpc_drsuapi_DsReplicaGetInfo_r_send(TALLOC_CTX *mem_ctx,
    3634             :         struct tevent_context *ev,
    3635             :         struct dcerpc_binding_handle *h,
    3636             :         struct drsuapi_DsReplicaGetInfo *r)
    3637             : {
    3638             :         struct tevent_req *req;
    3639             :         struct dcerpc_drsuapi_DsReplicaGetInfo_r_state *state;
    3640             :         struct tevent_req *subreq;
    3641             : 
    3642           0 :         req = tevent_req_create(mem_ctx, &state,
    3643             :                                 struct dcerpc_drsuapi_DsReplicaGetInfo_r_state);
    3644           0 :         if (req == NULL) {
    3645           0 :                 return NULL;
    3646             :         }
    3647             : 
    3648           0 :         state->out_mem_ctx = talloc_new(state);
    3649           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    3650           0 :                 return tevent_req_post(req, ev);
    3651             :         }
    3652             : 
    3653           0 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    3654             :                         NULL, &ndr_table_drsuapi,
    3655           0 :                         NDR_DRSUAPI_DSREPLICAGETINFO, state->out_mem_ctx, r);
    3656           0 :         if (tevent_req_nomem(subreq, req)) {
    3657           0 :                 return tevent_req_post(req, ev);
    3658             :         }
    3659           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsReplicaGetInfo_r_done, req);
    3660             : 
    3661           0 :         return req;
    3662             : }
    3663             : 
    3664           0 : static void dcerpc_drsuapi_DsReplicaGetInfo_r_done(struct tevent_req *subreq)
    3665             : {
    3666           0 :         struct tevent_req *req =
    3667           0 :                 tevent_req_callback_data(subreq,
    3668             :                 struct tevent_req);
    3669             :         NTSTATUS status;
    3670             : 
    3671           0 :         status = dcerpc_binding_handle_call_recv(subreq);
    3672           0 :         TALLOC_FREE(subreq);
    3673           0 :         if (tevent_req_nterror(req, status)) {
    3674           0 :                 return;
    3675             :         }
    3676             : 
    3677           0 :         tevent_req_done(req);
    3678             : }
    3679             : 
    3680           0 : NTSTATUS dcerpc_drsuapi_DsReplicaGetInfo_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    3681             : {
    3682           0 :         struct dcerpc_drsuapi_DsReplicaGetInfo_r_state *state =
    3683           0 :                 tevent_req_data(req,
    3684             :                 struct dcerpc_drsuapi_DsReplicaGetInfo_r_state);
    3685             :         NTSTATUS status;
    3686             : 
    3687           0 :         if (tevent_req_is_nterror(req, &status)) {
    3688           0 :                 tevent_req_received(req);
    3689           0 :                 return status;
    3690             :         }
    3691             : 
    3692           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    3693             : 
    3694           0 :         tevent_req_received(req);
    3695           0 :         return NT_STATUS_OK;
    3696             : }
    3697             : 
    3698          16 : NTSTATUS dcerpc_drsuapi_DsReplicaGetInfo_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct drsuapi_DsReplicaGetInfo *r)
    3699             : {
    3700             :         NTSTATUS status;
    3701             : 
    3702          16 :         status = dcerpc_binding_handle_call(h,
    3703             :                         NULL, &ndr_table_drsuapi,
    3704             :                         NDR_DRSUAPI_DSREPLICAGETINFO, mem_ctx, r);
    3705             : 
    3706          16 :         return status;
    3707             : }
    3708             : 
    3709             : struct dcerpc_drsuapi_DsReplicaGetInfo_state {
    3710             :         struct drsuapi_DsReplicaGetInfo orig;
    3711             :         struct drsuapi_DsReplicaGetInfo tmp;
    3712             :         TALLOC_CTX *out_mem_ctx;
    3713             : };
    3714             : 
    3715             : static void dcerpc_drsuapi_DsReplicaGetInfo_done(struct tevent_req *subreq);
    3716             : 
    3717           0 : struct tevent_req *dcerpc_drsuapi_DsReplicaGetInfo_send(TALLOC_CTX *mem_ctx,
    3718             :                                                         struct tevent_context *ev,
    3719             :                                                         struct dcerpc_binding_handle *h,
    3720             :                                                         struct policy_handle *_bind_handle /* [in] [ref] */,
    3721             :                                                         enum drsuapi_DsReplicaGetInfoLevel _level /* [in]  */,
    3722             :                                                         union drsuapi_DsReplicaGetInfoRequest *_req /* [in] [ref,switch_is(level)] */,
    3723             :                                                         enum drsuapi_DsReplicaInfoType *_info_type /* [out] [ref] */,
    3724             :                                                         union drsuapi_DsReplicaInfo *_info /* [out] [ref,switch_is(*info_type)] */)
    3725             : {
    3726             :         struct tevent_req *req;
    3727             :         struct dcerpc_drsuapi_DsReplicaGetInfo_state *state;
    3728             :         struct tevent_req *subreq;
    3729             : 
    3730           0 :         req = tevent_req_create(mem_ctx, &state,
    3731             :                                 struct dcerpc_drsuapi_DsReplicaGetInfo_state);
    3732           0 :         if (req == NULL) {
    3733           0 :                 return NULL;
    3734             :         }
    3735           0 :         state->out_mem_ctx = NULL;
    3736             : 
    3737             :         /* In parameters */
    3738           0 :         state->orig.in.bind_handle = _bind_handle;
    3739           0 :         state->orig.in.level = _level;
    3740           0 :         state->orig.in.req = _req;
    3741             : 
    3742             :         /* Out parameters */
    3743           0 :         state->orig.out.info_type = _info_type;
    3744           0 :         state->orig.out.info = _info;
    3745             : 
    3746             :         /* Result */
    3747           0 :         NDR_ZERO_STRUCT(state->orig.out.result);
    3748             : 
    3749           0 :         state->out_mem_ctx = talloc_named_const(state, 0,
    3750             :                              "dcerpc_drsuapi_DsReplicaGetInfo_out_memory");
    3751           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    3752           0 :                 return tevent_req_post(req, ev);
    3753             :         }
    3754             : 
    3755             :         /* make a temporary copy, that we pass to the dispatch function */
    3756           0 :         state->tmp = state->orig;
    3757             : 
    3758           0 :         subreq = dcerpc_drsuapi_DsReplicaGetInfo_r_send(state, ev, h, &state->tmp);
    3759           0 :         if (tevent_req_nomem(subreq, req)) {
    3760           0 :                 return tevent_req_post(req, ev);
    3761             :         }
    3762           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsReplicaGetInfo_done, req);
    3763           0 :         return req;
    3764             : }
    3765             : 
    3766           0 : static void dcerpc_drsuapi_DsReplicaGetInfo_done(struct tevent_req *subreq)
    3767             : {
    3768           0 :         struct tevent_req *req = tevent_req_callback_data(
    3769             :                 subreq, struct tevent_req);
    3770           0 :         struct dcerpc_drsuapi_DsReplicaGetInfo_state *state = tevent_req_data(
    3771             :                 req, struct dcerpc_drsuapi_DsReplicaGetInfo_state);
    3772             :         NTSTATUS status;
    3773             :         TALLOC_CTX *mem_ctx;
    3774             : 
    3775           0 :         if (state->out_mem_ctx) {
    3776           0 :                 mem_ctx = state->out_mem_ctx;
    3777             :         } else {
    3778           0 :                 mem_ctx = state;
    3779             :         }
    3780             : 
    3781           0 :         status = dcerpc_drsuapi_DsReplicaGetInfo_r_recv(subreq, mem_ctx);
    3782           0 :         TALLOC_FREE(subreq);
    3783           0 :         if (tevent_req_nterror(req, status)) {
    3784           0 :                 return;
    3785             :         }
    3786             : 
    3787             :         /* Copy out parameters */
    3788           0 :         *state->orig.out.info_type = *state->tmp.out.info_type;
    3789           0 :         *state->orig.out.info = *state->tmp.out.info;
    3790             : 
    3791             :         /* Copy result */
    3792           0 :         state->orig.out.result = state->tmp.out.result;
    3793             : 
    3794             :         /* Reset temporary structure */
    3795           0 :         NDR_ZERO_STRUCT(state->tmp);
    3796             : 
    3797           0 :         tevent_req_done(req);
    3798             : }
    3799             : 
    3800           0 : NTSTATUS dcerpc_drsuapi_DsReplicaGetInfo_recv(struct tevent_req *req,
    3801             :                                               TALLOC_CTX *mem_ctx,
    3802             :                                               WERROR *result)
    3803             : {
    3804           0 :         struct dcerpc_drsuapi_DsReplicaGetInfo_state *state = tevent_req_data(
    3805             :                 req, struct dcerpc_drsuapi_DsReplicaGetInfo_state);
    3806             :         NTSTATUS status;
    3807             : 
    3808           0 :         if (tevent_req_is_nterror(req, &status)) {
    3809           0 :                 tevent_req_received(req);
    3810           0 :                 return status;
    3811             :         }
    3812             : 
    3813             :         /* Steal possible out parameters to the callers context */
    3814           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    3815             : 
    3816             :         /* Return result */
    3817           0 :         *result = state->orig.out.result;
    3818             : 
    3819           0 :         tevent_req_received(req);
    3820           0 :         return NT_STATUS_OK;
    3821             : }
    3822             : 
    3823           0 : NTSTATUS dcerpc_drsuapi_DsReplicaGetInfo(struct dcerpc_binding_handle *h,
    3824             :                                          TALLOC_CTX *mem_ctx,
    3825             :                                          struct policy_handle *_bind_handle /* [in] [ref] */,
    3826             :                                          enum drsuapi_DsReplicaGetInfoLevel _level /* [in]  */,
    3827             :                                          union drsuapi_DsReplicaGetInfoRequest *_req /* [in] [ref,switch_is(level)] */,
    3828             :                                          enum drsuapi_DsReplicaInfoType *_info_type /* [out] [ref] */,
    3829             :                                          union drsuapi_DsReplicaInfo *_info /* [out] [ref,switch_is(*info_type)] */,
    3830             :                                          WERROR *result)
    3831             : {
    3832             :         struct drsuapi_DsReplicaGetInfo r;
    3833             :         NTSTATUS status;
    3834             : 
    3835             :         /* In parameters */
    3836           0 :         r.in.bind_handle = _bind_handle;
    3837           0 :         r.in.level = _level;
    3838           0 :         r.in.req = _req;
    3839             : 
    3840             :         /* Out parameters */
    3841           0 :         r.out.info_type = _info_type;
    3842           0 :         r.out.info = _info;
    3843             : 
    3844             :         /* Result */
    3845           0 :         NDR_ZERO_STRUCT(r.out.result);
    3846             : 
    3847           0 :         status = dcerpc_drsuapi_DsReplicaGetInfo_r(h, mem_ctx, &r);
    3848           0 :         if (!NT_STATUS_IS_OK(status)) {
    3849           0 :                 return status;
    3850             :         }
    3851             : 
    3852             :         /* Return variables */
    3853           0 :         *_info_type = *r.out.info_type;
    3854           0 :         *_info = *r.out.info;
    3855             : 
    3856             :         /* Return result */
    3857           0 :         *result = r.out.result;
    3858             : 
    3859           0 :         return NT_STATUS_OK;
    3860             : }
    3861             : 
    3862             : struct dcerpc_drsuapi_DsGetMemberships2_r_state {
    3863             :         TALLOC_CTX *out_mem_ctx;
    3864             : };
    3865             : 
    3866             : static void dcerpc_drsuapi_DsGetMemberships2_r_done(struct tevent_req *subreq);
    3867             : 
    3868           0 : struct tevent_req *dcerpc_drsuapi_DsGetMemberships2_r_send(TALLOC_CTX *mem_ctx,
    3869             :         struct tevent_context *ev,
    3870             :         struct dcerpc_binding_handle *h,
    3871             :         struct drsuapi_DsGetMemberships2 *r)
    3872             : {
    3873             :         struct tevent_req *req;
    3874             :         struct dcerpc_drsuapi_DsGetMemberships2_r_state *state;
    3875             :         struct tevent_req *subreq;
    3876             : 
    3877           0 :         req = tevent_req_create(mem_ctx, &state,
    3878             :                                 struct dcerpc_drsuapi_DsGetMemberships2_r_state);
    3879           0 :         if (req == NULL) {
    3880           0 :                 return NULL;
    3881             :         }
    3882             : 
    3883           0 :         state->out_mem_ctx = talloc_new(state);
    3884           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    3885           0 :                 return tevent_req_post(req, ev);
    3886             :         }
    3887             : 
    3888           0 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    3889             :                         NULL, &ndr_table_drsuapi,
    3890           0 :                         NDR_DRSUAPI_DSGETMEMBERSHIPS2, state->out_mem_ctx, r);
    3891           0 :         if (tevent_req_nomem(subreq, req)) {
    3892           0 :                 return tevent_req_post(req, ev);
    3893             :         }
    3894           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsGetMemberships2_r_done, req);
    3895             : 
    3896           0 :         return req;
    3897             : }
    3898             : 
    3899           0 : static void dcerpc_drsuapi_DsGetMemberships2_r_done(struct tevent_req *subreq)
    3900             : {
    3901           0 :         struct tevent_req *req =
    3902           0 :                 tevent_req_callback_data(subreq,
    3903             :                 struct tevent_req);
    3904             :         NTSTATUS status;
    3905             : 
    3906           0 :         status = dcerpc_binding_handle_call_recv(subreq);
    3907           0 :         TALLOC_FREE(subreq);
    3908           0 :         if (tevent_req_nterror(req, status)) {
    3909           0 :                 return;
    3910             :         }
    3911             : 
    3912           0 :         tevent_req_done(req);
    3913             : }
    3914             : 
    3915           0 : NTSTATUS dcerpc_drsuapi_DsGetMemberships2_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    3916             : {
    3917           0 :         struct dcerpc_drsuapi_DsGetMemberships2_r_state *state =
    3918           0 :                 tevent_req_data(req,
    3919             :                 struct dcerpc_drsuapi_DsGetMemberships2_r_state);
    3920             :         NTSTATUS status;
    3921             : 
    3922           0 :         if (tevent_req_is_nterror(req, &status)) {
    3923           0 :                 tevent_req_received(req);
    3924           0 :                 return status;
    3925             :         }
    3926             : 
    3927           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    3928             : 
    3929           0 :         tevent_req_received(req);
    3930           0 :         return NT_STATUS_OK;
    3931             : }
    3932             : 
    3933           0 : NTSTATUS dcerpc_drsuapi_DsGetMemberships2_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct drsuapi_DsGetMemberships2 *r)
    3934             : {
    3935             :         NTSTATUS status;
    3936             : 
    3937           0 :         status = dcerpc_binding_handle_call(h,
    3938             :                         NULL, &ndr_table_drsuapi,
    3939             :                         NDR_DRSUAPI_DSGETMEMBERSHIPS2, mem_ctx, r);
    3940             : 
    3941           0 :         return status;
    3942             : }
    3943             : 
    3944             : struct dcerpc_drsuapi_DsGetMemberships2_state {
    3945             :         struct drsuapi_DsGetMemberships2 orig;
    3946             :         struct drsuapi_DsGetMemberships2 tmp;
    3947             :         TALLOC_CTX *out_mem_ctx;
    3948             : };
    3949             : 
    3950             : static void dcerpc_drsuapi_DsGetMemberships2_done(struct tevent_req *subreq);
    3951             : 
    3952           0 : struct tevent_req *dcerpc_drsuapi_DsGetMemberships2_send(TALLOC_CTX *mem_ctx,
    3953             :                                                          struct tevent_context *ev,
    3954             :                                                          struct dcerpc_binding_handle *h,
    3955             :                                                          struct policy_handle *_bind_handle /* [in] [ref] */,
    3956             :                                                          uint32_t _level /* [in]  */,
    3957             :                                                          union drsuapi_DsGetMemberships2Request *_req /* [in] [ref,switch_is(level)] */,
    3958             :                                                          uint32_t *_level_out /* [out] [ref] */,
    3959             :                                                          union drsuapi_DsGetMemberships2Ctr *_ctr /* [out] [ref,switch_is(*level_out)] */)
    3960             : {
    3961             :         struct tevent_req *req;
    3962             :         struct dcerpc_drsuapi_DsGetMemberships2_state *state;
    3963             :         struct tevent_req *subreq;
    3964             : 
    3965           0 :         req = tevent_req_create(mem_ctx, &state,
    3966             :                                 struct dcerpc_drsuapi_DsGetMemberships2_state);
    3967           0 :         if (req == NULL) {
    3968           0 :                 return NULL;
    3969             :         }
    3970           0 :         state->out_mem_ctx = NULL;
    3971             : 
    3972             :         /* In parameters */
    3973           0 :         state->orig.in.bind_handle = _bind_handle;
    3974           0 :         state->orig.in.level = _level;
    3975           0 :         state->orig.in.req = _req;
    3976             : 
    3977             :         /* Out parameters */
    3978           0 :         state->orig.out.level_out = _level_out;
    3979           0 :         state->orig.out.ctr = _ctr;
    3980             : 
    3981             :         /* Result */
    3982           0 :         NDR_ZERO_STRUCT(state->orig.out.result);
    3983             : 
    3984           0 :         state->out_mem_ctx = talloc_named_const(state, 0,
    3985             :                              "dcerpc_drsuapi_DsGetMemberships2_out_memory");
    3986           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    3987           0 :                 return tevent_req_post(req, ev);
    3988             :         }
    3989             : 
    3990             :         /* make a temporary copy, that we pass to the dispatch function */
    3991           0 :         state->tmp = state->orig;
    3992             : 
    3993           0 :         subreq = dcerpc_drsuapi_DsGetMemberships2_r_send(state, ev, h, &state->tmp);
    3994           0 :         if (tevent_req_nomem(subreq, req)) {
    3995           0 :                 return tevent_req_post(req, ev);
    3996             :         }
    3997           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_DsGetMemberships2_done, req);
    3998           0 :         return req;
    3999             : }
    4000             : 
    4001           0 : static void dcerpc_drsuapi_DsGetMemberships2_done(struct tevent_req *subreq)
    4002             : {
    4003           0 :         struct tevent_req *req = tevent_req_callback_data(
    4004             :                 subreq, struct tevent_req);
    4005           0 :         struct dcerpc_drsuapi_DsGetMemberships2_state *state = tevent_req_data(
    4006             :                 req, struct dcerpc_drsuapi_DsGetMemberships2_state);
    4007             :         NTSTATUS status;
    4008             :         TALLOC_CTX *mem_ctx;
    4009             : 
    4010           0 :         if (state->out_mem_ctx) {
    4011           0 :                 mem_ctx = state->out_mem_ctx;
    4012             :         } else {
    4013           0 :                 mem_ctx = state;
    4014             :         }
    4015             : 
    4016           0 :         status = dcerpc_drsuapi_DsGetMemberships2_r_recv(subreq, mem_ctx);
    4017           0 :         TALLOC_FREE(subreq);
    4018           0 :         if (tevent_req_nterror(req, status)) {
    4019           0 :                 return;
    4020             :         }
    4021             : 
    4022             :         /* Copy out parameters */
    4023           0 :         *state->orig.out.level_out = *state->tmp.out.level_out;
    4024           0 :         *state->orig.out.ctr = *state->tmp.out.ctr;
    4025             : 
    4026             :         /* Copy result */
    4027           0 :         state->orig.out.result = state->tmp.out.result;
    4028             : 
    4029             :         /* Reset temporary structure */
    4030           0 :         NDR_ZERO_STRUCT(state->tmp);
    4031             : 
    4032           0 :         tevent_req_done(req);
    4033             : }
    4034             : 
    4035           0 : NTSTATUS dcerpc_drsuapi_DsGetMemberships2_recv(struct tevent_req *req,
    4036             :                                                TALLOC_CTX *mem_ctx,
    4037             :                                                WERROR *result)
    4038             : {
    4039           0 :         struct dcerpc_drsuapi_DsGetMemberships2_state *state = tevent_req_data(
    4040             :                 req, struct dcerpc_drsuapi_DsGetMemberships2_state);
    4041             :         NTSTATUS status;
    4042             : 
    4043           0 :         if (tevent_req_is_nterror(req, &status)) {
    4044           0 :                 tevent_req_received(req);
    4045           0 :                 return status;
    4046             :         }
    4047             : 
    4048             :         /* Steal possible out parameters to the callers context */
    4049           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    4050             : 
    4051             :         /* Return result */
    4052           0 :         *result = state->orig.out.result;
    4053             : 
    4054           0 :         tevent_req_received(req);
    4055           0 :         return NT_STATUS_OK;
    4056             : }
    4057             : 
    4058           0 : NTSTATUS dcerpc_drsuapi_DsGetMemberships2(struct dcerpc_binding_handle *h,
    4059             :                                           TALLOC_CTX *mem_ctx,
    4060             :                                           struct policy_handle *_bind_handle /* [in] [ref] */,
    4061             :                                           uint32_t _level /* [in]  */,
    4062             :                                           union drsuapi_DsGetMemberships2Request *_req /* [in] [ref,switch_is(level)] */,
    4063             :                                           uint32_t *_level_out /* [out] [ref] */,
    4064             :                                           union drsuapi_DsGetMemberships2Ctr *_ctr /* [out] [ref,switch_is(*level_out)] */,
    4065             :                                           WERROR *result)
    4066             : {
    4067             :         struct drsuapi_DsGetMemberships2 r;
    4068             :         NTSTATUS status;
    4069             : 
    4070             :         /* In parameters */
    4071           0 :         r.in.bind_handle = _bind_handle;
    4072           0 :         r.in.level = _level;
    4073           0 :         r.in.req = _req;
    4074             : 
    4075             :         /* Out parameters */
    4076           0 :         r.out.level_out = _level_out;
    4077           0 :         r.out.ctr = _ctr;
    4078             : 
    4079             :         /* Result */
    4080           0 :         NDR_ZERO_STRUCT(r.out.result);
    4081             : 
    4082           0 :         status = dcerpc_drsuapi_DsGetMemberships2_r(h, mem_ctx, &r);
    4083           0 :         if (!NT_STATUS_IS_OK(status)) {
    4084           0 :                 return status;
    4085             :         }
    4086             : 
    4087             :         /* Return variables */
    4088           0 :         *_level_out = *r.out.level_out;
    4089           0 :         *_ctr = *r.out.ctr;
    4090             : 
    4091             :         /* Return result */
    4092           0 :         *result = r.out.result;
    4093             : 
    4094           0 :         return NT_STATUS_OK;
    4095             : }
    4096             : 
    4097             : struct dcerpc_drsuapi_QuerySitesByCost_r_state {
    4098             :         TALLOC_CTX *out_mem_ctx;
    4099             : };
    4100             : 
    4101             : static void dcerpc_drsuapi_QuerySitesByCost_r_done(struct tevent_req *subreq);
    4102             : 
    4103           0 : struct tevent_req *dcerpc_drsuapi_QuerySitesByCost_r_send(TALLOC_CTX *mem_ctx,
    4104             :         struct tevent_context *ev,
    4105             :         struct dcerpc_binding_handle *h,
    4106             :         struct drsuapi_QuerySitesByCost *r)
    4107             : {
    4108             :         struct tevent_req *req;
    4109             :         struct dcerpc_drsuapi_QuerySitesByCost_r_state *state;
    4110             :         struct tevent_req *subreq;
    4111             : 
    4112           0 :         req = tevent_req_create(mem_ctx, &state,
    4113             :                                 struct dcerpc_drsuapi_QuerySitesByCost_r_state);
    4114           0 :         if (req == NULL) {
    4115           0 :                 return NULL;
    4116             :         }
    4117             : 
    4118           0 :         state->out_mem_ctx = talloc_new(state);
    4119           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    4120           0 :                 return tevent_req_post(req, ev);
    4121             :         }
    4122             : 
    4123           0 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    4124             :                         NULL, &ndr_table_drsuapi,
    4125           0 :                         NDR_DRSUAPI_QUERYSITESBYCOST, state->out_mem_ctx, r);
    4126           0 :         if (tevent_req_nomem(subreq, req)) {
    4127           0 :                 return tevent_req_post(req, ev);
    4128             :         }
    4129           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_QuerySitesByCost_r_done, req);
    4130             : 
    4131           0 :         return req;
    4132             : }
    4133             : 
    4134           0 : static void dcerpc_drsuapi_QuerySitesByCost_r_done(struct tevent_req *subreq)
    4135             : {
    4136           0 :         struct tevent_req *req =
    4137           0 :                 tevent_req_callback_data(subreq,
    4138             :                 struct tevent_req);
    4139             :         NTSTATUS status;
    4140             : 
    4141           0 :         status = dcerpc_binding_handle_call_recv(subreq);
    4142           0 :         TALLOC_FREE(subreq);
    4143           0 :         if (tevent_req_nterror(req, status)) {
    4144           0 :                 return;
    4145             :         }
    4146             : 
    4147           0 :         tevent_req_done(req);
    4148             : }
    4149             : 
    4150           0 : NTSTATUS dcerpc_drsuapi_QuerySitesByCost_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    4151             : {
    4152           0 :         struct dcerpc_drsuapi_QuerySitesByCost_r_state *state =
    4153           0 :                 tevent_req_data(req,
    4154             :                 struct dcerpc_drsuapi_QuerySitesByCost_r_state);
    4155             :         NTSTATUS status;
    4156             : 
    4157           0 :         if (tevent_req_is_nterror(req, &status)) {
    4158           0 :                 tevent_req_received(req);
    4159           0 :                 return status;
    4160             :         }
    4161             : 
    4162           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    4163             : 
    4164           0 :         tevent_req_received(req);
    4165           0 :         return NT_STATUS_OK;
    4166             : }
    4167             : 
    4168           0 : NTSTATUS dcerpc_drsuapi_QuerySitesByCost_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct drsuapi_QuerySitesByCost *r)
    4169             : {
    4170             :         NTSTATUS status;
    4171             : 
    4172           0 :         status = dcerpc_binding_handle_call(h,
    4173             :                         NULL, &ndr_table_drsuapi,
    4174             :                         NDR_DRSUAPI_QUERYSITESBYCOST, mem_ctx, r);
    4175             : 
    4176           0 :         return status;
    4177             : }
    4178             : 
    4179             : struct dcerpc_drsuapi_QuerySitesByCost_state {
    4180             :         struct drsuapi_QuerySitesByCost orig;
    4181             :         struct drsuapi_QuerySitesByCost tmp;
    4182             :         TALLOC_CTX *out_mem_ctx;
    4183             : };
    4184             : 
    4185             : static void dcerpc_drsuapi_QuerySitesByCost_done(struct tevent_req *subreq);
    4186             : 
    4187           0 : struct tevent_req *dcerpc_drsuapi_QuerySitesByCost_send(TALLOC_CTX *mem_ctx,
    4188             :                                                         struct tevent_context *ev,
    4189             :                                                         struct dcerpc_binding_handle *h,
    4190             :                                                         struct policy_handle *_bind_handle /* [in] [ref] */,
    4191             :                                                         uint32_t _level /* [in]  */,
    4192             :                                                         union drsuapi_QuerySitesByCostRequest *_req /* [in] [ref,switch_is(level)] */,
    4193             :                                                         uint32_t *_level_out /* [out] [ref] */,
    4194             :                                                         union drsuapi_QuerySitesByCostCtr *_ctr /* [out] [ref,switch_is(*level_out)] */)
    4195             : {
    4196             :         struct tevent_req *req;
    4197             :         struct dcerpc_drsuapi_QuerySitesByCost_state *state;
    4198             :         struct tevent_req *subreq;
    4199             : 
    4200           0 :         req = tevent_req_create(mem_ctx, &state,
    4201             :                                 struct dcerpc_drsuapi_QuerySitesByCost_state);
    4202           0 :         if (req == NULL) {
    4203           0 :                 return NULL;
    4204             :         }
    4205           0 :         state->out_mem_ctx = NULL;
    4206             : 
    4207             :         /* In parameters */
    4208           0 :         state->orig.in.bind_handle = _bind_handle;
    4209           0 :         state->orig.in.level = _level;
    4210           0 :         state->orig.in.req = _req;
    4211             : 
    4212             :         /* Out parameters */
    4213           0 :         state->orig.out.level_out = _level_out;
    4214           0 :         state->orig.out.ctr = _ctr;
    4215             : 
    4216             :         /* Result */
    4217           0 :         NDR_ZERO_STRUCT(state->orig.out.result);
    4218             : 
    4219           0 :         state->out_mem_ctx = talloc_named_const(state, 0,
    4220             :                              "dcerpc_drsuapi_QuerySitesByCost_out_memory");
    4221           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    4222           0 :                 return tevent_req_post(req, ev);
    4223             :         }
    4224             : 
    4225             :         /* make a temporary copy, that we pass to the dispatch function */
    4226           0 :         state->tmp = state->orig;
    4227             : 
    4228           0 :         subreq = dcerpc_drsuapi_QuerySitesByCost_r_send(state, ev, h, &state->tmp);
    4229           0 :         if (tevent_req_nomem(subreq, req)) {
    4230           0 :                 return tevent_req_post(req, ev);
    4231             :         }
    4232           0 :         tevent_req_set_callback(subreq, dcerpc_drsuapi_QuerySitesByCost_done, req);
    4233           0 :         return req;
    4234             : }
    4235             : 
    4236           0 : static void dcerpc_drsuapi_QuerySitesByCost_done(struct tevent_req *subreq)
    4237             : {
    4238           0 :         struct tevent_req *req = tevent_req_callback_data(
    4239             :                 subreq, struct tevent_req);
    4240           0 :         struct dcerpc_drsuapi_QuerySitesByCost_state *state = tevent_req_data(
    4241             :                 req, struct dcerpc_drsuapi_QuerySitesByCost_state);
    4242             :         NTSTATUS status;
    4243             :         TALLOC_CTX *mem_ctx;
    4244             : 
    4245           0 :         if (state->out_mem_ctx) {
    4246           0 :                 mem_ctx = state->out_mem_ctx;
    4247             :         } else {
    4248           0 :                 mem_ctx = state;
    4249             :         }
    4250             : 
    4251           0 :         status = dcerpc_drsuapi_QuerySitesByCost_r_recv(subreq, mem_ctx);
    4252           0 :         TALLOC_FREE(subreq);
    4253           0 :         if (tevent_req_nterror(req, status)) {
    4254           0 :                 return;
    4255             :         }
    4256             : 
    4257             :         /* Copy out parameters */
    4258           0 :         *state->orig.out.level_out = *state->tmp.out.level_out;
    4259           0 :         *state->orig.out.ctr = *state->tmp.out.ctr;
    4260             : 
    4261             :         /* Copy result */
    4262           0 :         state->orig.out.result = state->tmp.out.result;
    4263             : 
    4264             :         /* Reset temporary structure */
    4265           0 :         NDR_ZERO_STRUCT(state->tmp);
    4266             : 
    4267           0 :         tevent_req_done(req);
    4268             : }
    4269             : 
    4270           0 : NTSTATUS dcerpc_drsuapi_QuerySitesByCost_recv(struct tevent_req *req,
    4271             :                                               TALLOC_CTX *mem_ctx,
    4272             :                                               WERROR *result)
    4273             : {
    4274           0 :         struct dcerpc_drsuapi_QuerySitesByCost_state *state = tevent_req_data(
    4275             :                 req, struct dcerpc_drsuapi_QuerySitesByCost_state);
    4276             :         NTSTATUS status;
    4277             : 
    4278           0 :         if (tevent_req_is_nterror(req, &status)) {
    4279           0 :                 tevent_req_received(req);
    4280           0 :                 return status;
    4281             :         }
    4282             : 
    4283             :         /* Steal possible out parameters to the callers context */
    4284           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    4285             : 
    4286             :         /* Return result */
    4287           0 :         *result = state->orig.out.result;
    4288             : 
    4289           0 :         tevent_req_received(req);
    4290           0 :         return NT_STATUS_OK;
    4291             : }
    4292             : 
    4293           0 : NTSTATUS dcerpc_drsuapi_QuerySitesByCost(struct dcerpc_binding_handle *h,
    4294             :                                          TALLOC_CTX *mem_ctx,
    4295             :                                          struct policy_handle *_bind_handle /* [in] [ref] */,
    4296             :                                          uint32_t _level /* [in]  */,
    4297             :                                          union drsuapi_QuerySitesByCostRequest *_req /* [in] [ref,switch_is(level)] */,
    4298             :                                          uint32_t *_level_out /* [out] [ref] */,
    4299             :                                          union drsuapi_QuerySitesByCostCtr *_ctr /* [out] [ref,switch_is(*level_out)] */,
    4300             :                                          WERROR *result)
    4301             : {
    4302             :         struct drsuapi_QuerySitesByCost r;
    4303             :         NTSTATUS status;
    4304             : 
    4305             :         /* In parameters */
    4306           0 :         r.in.bind_handle = _bind_handle;
    4307           0 :         r.in.level = _level;
    4308           0 :         r.in.req = _req;
    4309             : 
    4310             :         /* Out parameters */
    4311           0 :         r.out.level_out = _level_out;
    4312           0 :         r.out.ctr = _ctr;
    4313             : 
    4314             :         /* Result */
    4315           0 :         NDR_ZERO_STRUCT(r.out.result);
    4316             : 
    4317           0 :         status = dcerpc_drsuapi_QuerySitesByCost_r(h, mem_ctx, &r);
    4318           0 :         if (!NT_STATUS_IS_OK(status)) {
    4319           0 :                 return status;
    4320             :         }
    4321             : 
    4322             :         /* Return variables */
    4323           0 :         *_level_out = *r.out.level_out;
    4324           0 :         *_ctr = *r.out.ctr;
    4325             : 
    4326             :         /* Return result */
    4327           0 :         *result = r.out.result;
    4328             : 
    4329           0 :         return NT_STATUS_OK;
    4330             : }
    4331             : 

Generated by: LCOV version 1.13