LCOV - code coverage report
Current view: top level - bin/default/librpc/gen_ndr - ndr_winbind_c.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 1187 2038 58.2 %
Date: 2021-09-23 10:06:22 Functions: 125 196 63.8 %

          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_winbind.h"
       7             : #include "bin/default/librpc/gen_ndr/ndr_winbind_c.h"
       8             : 
       9             : /* winbind - client functions generated by pidl */
      10             : 
      11             : struct dcerpc_wbint_Ping_r_state {
      12             :         TALLOC_CTX *out_mem_ctx;
      13             : };
      14             : 
      15             : static void dcerpc_wbint_Ping_r_done(struct tevent_req *subreq);
      16             : 
      17           0 : struct tevent_req *dcerpc_wbint_Ping_r_send(TALLOC_CTX *mem_ctx,
      18             :         struct tevent_context *ev,
      19             :         struct dcerpc_binding_handle *h,
      20             :         struct wbint_Ping *r)
      21             : {
      22             :         struct tevent_req *req;
      23             :         struct dcerpc_wbint_Ping_r_state *state;
      24             :         struct tevent_req *subreq;
      25             : 
      26           0 :         req = tevent_req_create(mem_ctx, &state,
      27             :                                 struct dcerpc_wbint_Ping_r_state);
      28           0 :         if (req == NULL) {
      29           0 :                 return NULL;
      30             :         }
      31             : 
      32           0 :         state->out_mem_ctx = talloc_new(state);
      33           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
      34           0 :                 return tevent_req_post(req, ev);
      35             :         }
      36             : 
      37           0 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
      38             :                         NULL, &ndr_table_winbind,
      39           0 :                         NDR_WBINT_PING, state->out_mem_ctx, r);
      40           0 :         if (tevent_req_nomem(subreq, req)) {
      41           0 :                 return tevent_req_post(req, ev);
      42             :         }
      43           0 :         tevent_req_set_callback(subreq, dcerpc_wbint_Ping_r_done, req);
      44             : 
      45           0 :         return req;
      46             : }
      47             : 
      48           0 : static void dcerpc_wbint_Ping_r_done(struct tevent_req *subreq)
      49             : {
      50           0 :         struct tevent_req *req =
      51           0 :                 tevent_req_callback_data(subreq,
      52             :                 struct tevent_req);
      53             :         NTSTATUS status;
      54             : 
      55           0 :         status = dcerpc_binding_handle_call_recv(subreq);
      56           0 :         TALLOC_FREE(subreq);
      57           0 :         if (tevent_req_nterror(req, status)) {
      58           0 :                 return;
      59             :         }
      60             : 
      61           0 :         tevent_req_done(req);
      62             : }
      63             : 
      64           0 : NTSTATUS dcerpc_wbint_Ping_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
      65             : {
      66           0 :         struct dcerpc_wbint_Ping_r_state *state =
      67           0 :                 tevent_req_data(req,
      68             :                 struct dcerpc_wbint_Ping_r_state);
      69             :         NTSTATUS status;
      70             : 
      71           0 :         if (tevent_req_is_nterror(req, &status)) {
      72           0 :                 tevent_req_received(req);
      73           0 :                 return status;
      74             :         }
      75             : 
      76           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
      77             : 
      78           0 :         tevent_req_received(req);
      79           0 :         return NT_STATUS_OK;
      80             : }
      81             : 
      82           0 : NTSTATUS dcerpc_wbint_Ping_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wbint_Ping *r)
      83             : {
      84             :         NTSTATUS status;
      85             : 
      86           0 :         status = dcerpc_binding_handle_call(h,
      87             :                         NULL, &ndr_table_winbind,
      88             :                         NDR_WBINT_PING, mem_ctx, r);
      89             : 
      90           0 :         return status;
      91             : }
      92             : 
      93             : struct dcerpc_wbint_Ping_state {
      94             :         struct wbint_Ping orig;
      95             :         struct wbint_Ping tmp;
      96             :         TALLOC_CTX *out_mem_ctx;
      97             : };
      98             : 
      99             : static void dcerpc_wbint_Ping_done(struct tevent_req *subreq);
     100             : 
     101           0 : struct tevent_req *dcerpc_wbint_Ping_send(TALLOC_CTX *mem_ctx,
     102             :                                           struct tevent_context *ev,
     103             :                                           struct dcerpc_binding_handle *h,
     104             :                                           uint32_t _in_data /* [in]  */,
     105             :                                           uint32_t *_out_data /* [out] [ref] */)
     106             : {
     107             :         struct tevent_req *req;
     108             :         struct dcerpc_wbint_Ping_state *state;
     109             :         struct tevent_req *subreq;
     110             : 
     111           0 :         req = tevent_req_create(mem_ctx, &state,
     112             :                                 struct dcerpc_wbint_Ping_state);
     113           0 :         if (req == NULL) {
     114           0 :                 return NULL;
     115             :         }
     116           0 :         state->out_mem_ctx = NULL;
     117             : 
     118             :         /* In parameters */
     119           0 :         state->orig.in.in_data = _in_data;
     120             : 
     121             :         /* Out parameters */
     122           0 :         state->orig.out.out_data = _out_data;
     123             : 
     124           0 :         state->out_mem_ctx = talloc_named_const(state, 0,
     125             :                              "dcerpc_wbint_Ping_out_memory");
     126           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
     127           0 :                 return tevent_req_post(req, ev);
     128             :         }
     129             : 
     130             :         /* make a temporary copy, that we pass to the dispatch function */
     131           0 :         state->tmp = state->orig;
     132             : 
     133           0 :         subreq = dcerpc_wbint_Ping_r_send(state, ev, h, &state->tmp);
     134           0 :         if (tevent_req_nomem(subreq, req)) {
     135           0 :                 return tevent_req_post(req, ev);
     136             :         }
     137           0 :         tevent_req_set_callback(subreq, dcerpc_wbint_Ping_done, req);
     138           0 :         return req;
     139             : }
     140             : 
     141           0 : static void dcerpc_wbint_Ping_done(struct tevent_req *subreq)
     142             : {
     143           0 :         struct tevent_req *req = tevent_req_callback_data(
     144             :                 subreq, struct tevent_req);
     145           0 :         struct dcerpc_wbint_Ping_state *state = tevent_req_data(
     146             :                 req, struct dcerpc_wbint_Ping_state);
     147             :         NTSTATUS status;
     148             :         TALLOC_CTX *mem_ctx;
     149             : 
     150           0 :         if (state->out_mem_ctx) {
     151           0 :                 mem_ctx = state->out_mem_ctx;
     152             :         } else {
     153           0 :                 mem_ctx = state;
     154             :         }
     155             : 
     156           0 :         status = dcerpc_wbint_Ping_r_recv(subreq, mem_ctx);
     157           0 :         TALLOC_FREE(subreq);
     158           0 :         if (tevent_req_nterror(req, status)) {
     159           0 :                 return;
     160             :         }
     161             : 
     162             :         /* Copy out parameters */
     163           0 :         *state->orig.out.out_data = *state->tmp.out.out_data;
     164             : 
     165             :         /* Reset temporary structure */
     166           0 :         NDR_ZERO_STRUCT(state->tmp);
     167             : 
     168           0 :         tevent_req_done(req);
     169             : }
     170             : 
     171           0 : NTSTATUS dcerpc_wbint_Ping_recv(struct tevent_req *req,
     172             :                                 TALLOC_CTX *mem_ctx)
     173             : {
     174           0 :         struct dcerpc_wbint_Ping_state *state = tevent_req_data(
     175             :                 req, struct dcerpc_wbint_Ping_state);
     176             :         NTSTATUS status;
     177             : 
     178           0 :         if (tevent_req_is_nterror(req, &status)) {
     179           0 :                 tevent_req_received(req);
     180           0 :                 return status;
     181             :         }
     182             : 
     183             :         /* Steal possible out parameters to the callers context */
     184           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
     185             : 
     186           0 :         tevent_req_received(req);
     187           0 :         return NT_STATUS_OK;
     188             : }
     189             : 
     190           0 : NTSTATUS dcerpc_wbint_Ping(struct dcerpc_binding_handle *h,
     191             :                            TALLOC_CTX *mem_ctx,
     192             :                            uint32_t _in_data /* [in]  */,
     193             :                            uint32_t *_out_data /* [out] [ref] */)
     194             : {
     195             :         struct wbint_Ping r;
     196             :         NTSTATUS status;
     197             : 
     198             :         /* In parameters */
     199           0 :         r.in.in_data = _in_data;
     200             : 
     201             :         /* Out parameters */
     202           0 :         r.out.out_data = _out_data;
     203             : 
     204           0 :         status = dcerpc_wbint_Ping_r(h, mem_ctx, &r);
     205           0 :         if (!NT_STATUS_IS_OK(status)) {
     206           0 :                 return status;
     207             :         }
     208             : 
     209             :         /* Return variables */
     210           0 :         *_out_data = *r.out.out_data;
     211             : 
     212             :         /* Return result */
     213             : 
     214           0 :         return NT_STATUS_OK;
     215             : }
     216             : 
     217             : struct dcerpc_wbint_LookupSid_r_state {
     218             :         TALLOC_CTX *out_mem_ctx;
     219             : };
     220             : 
     221             : static void dcerpc_wbint_LookupSid_r_done(struct tevent_req *subreq);
     222             : 
     223       19596 : struct tevent_req *dcerpc_wbint_LookupSid_r_send(TALLOC_CTX *mem_ctx,
     224             :         struct tevent_context *ev,
     225             :         struct dcerpc_binding_handle *h,
     226             :         struct wbint_LookupSid *r)
     227             : {
     228             :         struct tevent_req *req;
     229             :         struct dcerpc_wbint_LookupSid_r_state *state;
     230             :         struct tevent_req *subreq;
     231             : 
     232       19596 :         req = tevent_req_create(mem_ctx, &state,
     233             :                                 struct dcerpc_wbint_LookupSid_r_state);
     234       19596 :         if (req == NULL) {
     235           0 :                 return NULL;
     236             :         }
     237             : 
     238       19596 :         state->out_mem_ctx = talloc_new(state);
     239       19596 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
     240           0 :                 return tevent_req_post(req, ev);
     241             :         }
     242             : 
     243       19596 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
     244             :                         NULL, &ndr_table_winbind,
     245       19596 :                         NDR_WBINT_LOOKUPSID, state->out_mem_ctx, r);
     246       19596 :         if (tevent_req_nomem(subreq, req)) {
     247           0 :                 return tevent_req_post(req, ev);
     248             :         }
     249       19596 :         tevent_req_set_callback(subreq, dcerpc_wbint_LookupSid_r_done, req);
     250             : 
     251       19596 :         return req;
     252             : }
     253             : 
     254       19596 : static void dcerpc_wbint_LookupSid_r_done(struct tevent_req *subreq)
     255             : {
     256       18576 :         struct tevent_req *req =
     257       19596 :                 tevent_req_callback_data(subreq,
     258             :                 struct tevent_req);
     259             :         NTSTATUS status;
     260             : 
     261       19596 :         status = dcerpc_binding_handle_call_recv(subreq);
     262       19596 :         TALLOC_FREE(subreq);
     263       19596 :         if (tevent_req_nterror(req, status)) {
     264           0 :                 return;
     265             :         }
     266             : 
     267       19596 :         tevent_req_done(req);
     268             : }
     269             : 
     270       19596 : NTSTATUS dcerpc_wbint_LookupSid_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
     271             : {
     272       18576 :         struct dcerpc_wbint_LookupSid_r_state *state =
     273       19596 :                 tevent_req_data(req,
     274             :                 struct dcerpc_wbint_LookupSid_r_state);
     275             :         NTSTATUS status;
     276             : 
     277       19596 :         if (tevent_req_is_nterror(req, &status)) {
     278           0 :                 tevent_req_received(req);
     279           0 :                 return status;
     280             :         }
     281             : 
     282       19596 :         talloc_steal(mem_ctx, state->out_mem_ctx);
     283             : 
     284       19596 :         tevent_req_received(req);
     285       19596 :         return NT_STATUS_OK;
     286             : }
     287             : 
     288           0 : NTSTATUS dcerpc_wbint_LookupSid_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wbint_LookupSid *r)
     289             : {
     290             :         NTSTATUS status;
     291             : 
     292           0 :         status = dcerpc_binding_handle_call(h,
     293             :                         NULL, &ndr_table_winbind,
     294             :                         NDR_WBINT_LOOKUPSID, mem_ctx, r);
     295             : 
     296           0 :         return status;
     297             : }
     298             : 
     299             : struct dcerpc_wbint_LookupSid_state {
     300             :         struct wbint_LookupSid orig;
     301             :         struct wbint_LookupSid tmp;
     302             :         TALLOC_CTX *out_mem_ctx;
     303             : };
     304             : 
     305             : static void dcerpc_wbint_LookupSid_done(struct tevent_req *subreq);
     306             : 
     307       19596 : struct tevent_req *dcerpc_wbint_LookupSid_send(TALLOC_CTX *mem_ctx,
     308             :                                                struct tevent_context *ev,
     309             :                                                struct dcerpc_binding_handle *h,
     310             :                                                struct dom_sid *_sid /* [in] [ref] */,
     311             :                                                enum lsa_SidType *_type /* [out] [ref] */,
     312             :                                                const char **_domain /* [out] [charset(UTF8),ref] */,
     313             :                                                const char **_name /* [out] [charset(UTF8),ref] */)
     314             : {
     315             :         struct tevent_req *req;
     316             :         struct dcerpc_wbint_LookupSid_state *state;
     317             :         struct tevent_req *subreq;
     318             : 
     319       19596 :         req = tevent_req_create(mem_ctx, &state,
     320             :                                 struct dcerpc_wbint_LookupSid_state);
     321       19596 :         if (req == NULL) {
     322           0 :                 return NULL;
     323             :         }
     324       19596 :         state->out_mem_ctx = NULL;
     325             : 
     326             :         /* In parameters */
     327       19596 :         state->orig.in.sid = _sid;
     328             : 
     329             :         /* Out parameters */
     330       19596 :         state->orig.out.type = _type;
     331       19596 :         state->orig.out.domain = _domain;
     332       19596 :         state->orig.out.name = _name;
     333             : 
     334             :         /* Result */
     335       19596 :         NDR_ZERO_STRUCT(state->orig.out.result);
     336             : 
     337       19596 :         state->out_mem_ctx = talloc_named_const(state, 0,
     338             :                              "dcerpc_wbint_LookupSid_out_memory");
     339       19596 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
     340           0 :                 return tevent_req_post(req, ev);
     341             :         }
     342             : 
     343             :         /* make a temporary copy, that we pass to the dispatch function */
     344       19596 :         state->tmp = state->orig;
     345             : 
     346       19596 :         subreq = dcerpc_wbint_LookupSid_r_send(state, ev, h, &state->tmp);
     347       19596 :         if (tevent_req_nomem(subreq, req)) {
     348           0 :                 return tevent_req_post(req, ev);
     349             :         }
     350       19596 :         tevent_req_set_callback(subreq, dcerpc_wbint_LookupSid_done, req);
     351       19596 :         return req;
     352             : }
     353             : 
     354       19596 : static void dcerpc_wbint_LookupSid_done(struct tevent_req *subreq)
     355             : {
     356       19596 :         struct tevent_req *req = tevent_req_callback_data(
     357             :                 subreq, struct tevent_req);
     358       19596 :         struct dcerpc_wbint_LookupSid_state *state = tevent_req_data(
     359             :                 req, struct dcerpc_wbint_LookupSid_state);
     360             :         NTSTATUS status;
     361             :         TALLOC_CTX *mem_ctx;
     362             : 
     363       19596 :         if (state->out_mem_ctx) {
     364       19596 :                 mem_ctx = state->out_mem_ctx;
     365             :         } else {
     366           0 :                 mem_ctx = state;
     367             :         }
     368             : 
     369       19596 :         status = dcerpc_wbint_LookupSid_r_recv(subreq, mem_ctx);
     370       19596 :         TALLOC_FREE(subreq);
     371       19596 :         if (tevent_req_nterror(req, status)) {
     372           0 :                 return;
     373             :         }
     374             : 
     375             :         /* Copy out parameters */
     376       19596 :         *state->orig.out.type = *state->tmp.out.type;
     377       19596 :         *state->orig.out.domain = *state->tmp.out.domain;
     378       19596 :         *state->orig.out.name = *state->tmp.out.name;
     379             : 
     380             :         /* Copy result */
     381       19596 :         state->orig.out.result = state->tmp.out.result;
     382             : 
     383             :         /* Reset temporary structure */
     384       19596 :         NDR_ZERO_STRUCT(state->tmp);
     385             : 
     386       19596 :         tevent_req_done(req);
     387             : }
     388             : 
     389       19596 : NTSTATUS dcerpc_wbint_LookupSid_recv(struct tevent_req *req,
     390             :                                      TALLOC_CTX *mem_ctx,
     391             :                                      NTSTATUS *result)
     392             : {
     393       19596 :         struct dcerpc_wbint_LookupSid_state *state = tevent_req_data(
     394             :                 req, struct dcerpc_wbint_LookupSid_state);
     395             :         NTSTATUS status;
     396             : 
     397       19596 :         if (tevent_req_is_nterror(req, &status)) {
     398           0 :                 tevent_req_received(req);
     399           0 :                 return status;
     400             :         }
     401             : 
     402             :         /* Steal possible out parameters to the callers context */
     403       19596 :         talloc_steal(mem_ctx, state->out_mem_ctx);
     404             : 
     405             :         /* Return result */
     406       19596 :         *result = state->orig.out.result;
     407             : 
     408       19596 :         tevent_req_received(req);
     409       19596 :         return NT_STATUS_OK;
     410             : }
     411             : 
     412           0 : NTSTATUS dcerpc_wbint_LookupSid(struct dcerpc_binding_handle *h,
     413             :                                 TALLOC_CTX *mem_ctx,
     414             :                                 struct dom_sid *_sid /* [in] [ref] */,
     415             :                                 enum lsa_SidType *_type /* [out] [ref] */,
     416             :                                 const char **_domain /* [out] [charset(UTF8),ref] */,
     417             :                                 const char **_name /* [out] [charset(UTF8),ref] */,
     418             :                                 NTSTATUS *result)
     419             : {
     420             :         struct wbint_LookupSid r;
     421             :         NTSTATUS status;
     422             : 
     423             :         /* In parameters */
     424           0 :         r.in.sid = _sid;
     425             : 
     426             :         /* Out parameters */
     427           0 :         r.out.type = _type;
     428           0 :         r.out.domain = _domain;
     429           0 :         r.out.name = _name;
     430             : 
     431             :         /* Result */
     432           0 :         NDR_ZERO_STRUCT(r.out.result);
     433             : 
     434           0 :         status = dcerpc_wbint_LookupSid_r(h, mem_ctx, &r);
     435           0 :         if (!NT_STATUS_IS_OK(status)) {
     436           0 :                 return status;
     437             :         }
     438             : 
     439             :         /* Return variables */
     440           0 :         *_type = *r.out.type;
     441           0 :         *_domain = *r.out.domain;
     442           0 :         *_name = *r.out.name;
     443             : 
     444             :         /* Return result */
     445           0 :         *result = r.out.result;
     446             : 
     447           0 :         return NT_STATUS_OK;
     448             : }
     449             : 
     450             : struct dcerpc_wbint_LookupSids_r_state {
     451             :         TALLOC_CTX *out_mem_ctx;
     452             : };
     453             : 
     454             : static void dcerpc_wbint_LookupSids_r_done(struct tevent_req *subreq);
     455             : 
     456         711 : struct tevent_req *dcerpc_wbint_LookupSids_r_send(TALLOC_CTX *mem_ctx,
     457             :         struct tevent_context *ev,
     458             :         struct dcerpc_binding_handle *h,
     459             :         struct wbint_LookupSids *r)
     460             : {
     461             :         struct tevent_req *req;
     462             :         struct dcerpc_wbint_LookupSids_r_state *state;
     463             :         struct tevent_req *subreq;
     464             : 
     465         711 :         req = tevent_req_create(mem_ctx, &state,
     466             :                                 struct dcerpc_wbint_LookupSids_r_state);
     467         711 :         if (req == NULL) {
     468           0 :                 return NULL;
     469             :         }
     470             : 
     471         711 :         state->out_mem_ctx = talloc_new(state);
     472         711 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
     473           0 :                 return tevent_req_post(req, ev);
     474             :         }
     475             : 
     476         711 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
     477             :                         NULL, &ndr_table_winbind,
     478         711 :                         NDR_WBINT_LOOKUPSIDS, state->out_mem_ctx, r);
     479         711 :         if (tevent_req_nomem(subreq, req)) {
     480           0 :                 return tevent_req_post(req, ev);
     481             :         }
     482         711 :         tevent_req_set_callback(subreq, dcerpc_wbint_LookupSids_r_done, req);
     483             : 
     484         711 :         return req;
     485             : }
     486             : 
     487         711 : static void dcerpc_wbint_LookupSids_r_done(struct tevent_req *subreq)
     488             : {
     489         672 :         struct tevent_req *req =
     490         711 :                 tevent_req_callback_data(subreq,
     491             :                 struct tevent_req);
     492             :         NTSTATUS status;
     493             : 
     494         711 :         status = dcerpc_binding_handle_call_recv(subreq);
     495         711 :         TALLOC_FREE(subreq);
     496         711 :         if (tevent_req_nterror(req, status)) {
     497           0 :                 return;
     498             :         }
     499             : 
     500         711 :         tevent_req_done(req);
     501             : }
     502             : 
     503         711 : NTSTATUS dcerpc_wbint_LookupSids_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
     504             : {
     505         672 :         struct dcerpc_wbint_LookupSids_r_state *state =
     506         711 :                 tevent_req_data(req,
     507             :                 struct dcerpc_wbint_LookupSids_r_state);
     508             :         NTSTATUS status;
     509             : 
     510         711 :         if (tevent_req_is_nterror(req, &status)) {
     511           0 :                 tevent_req_received(req);
     512           0 :                 return status;
     513             :         }
     514             : 
     515         711 :         talloc_steal(mem_ctx, state->out_mem_ctx);
     516             : 
     517         711 :         tevent_req_received(req);
     518         711 :         return NT_STATUS_OK;
     519             : }
     520             : 
     521           0 : NTSTATUS dcerpc_wbint_LookupSids_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wbint_LookupSids *r)
     522             : {
     523             :         NTSTATUS status;
     524             : 
     525           0 :         status = dcerpc_binding_handle_call(h,
     526             :                         NULL, &ndr_table_winbind,
     527             :                         NDR_WBINT_LOOKUPSIDS, mem_ctx, r);
     528             : 
     529           0 :         return status;
     530             : }
     531             : 
     532             : struct dcerpc_wbint_LookupSids_state {
     533             :         struct wbint_LookupSids orig;
     534             :         struct wbint_LookupSids tmp;
     535             :         TALLOC_CTX *out_mem_ctx;
     536             : };
     537             : 
     538             : static void dcerpc_wbint_LookupSids_done(struct tevent_req *subreq);
     539             : 
     540         711 : struct tevent_req *dcerpc_wbint_LookupSids_send(TALLOC_CTX *mem_ctx,
     541             :                                                 struct tevent_context *ev,
     542             :                                                 struct dcerpc_binding_handle *h,
     543             :                                                 struct lsa_SidArray *_sids /* [in] [ref] */,
     544             :                                                 struct lsa_RefDomainList *_domains /* [out] [ref] */,
     545             :                                                 struct lsa_TransNameArray *_names /* [out] [ref] */)
     546             : {
     547             :         struct tevent_req *req;
     548             :         struct dcerpc_wbint_LookupSids_state *state;
     549             :         struct tevent_req *subreq;
     550             : 
     551         711 :         req = tevent_req_create(mem_ctx, &state,
     552             :                                 struct dcerpc_wbint_LookupSids_state);
     553         711 :         if (req == NULL) {
     554           0 :                 return NULL;
     555             :         }
     556         711 :         state->out_mem_ctx = NULL;
     557             : 
     558             :         /* In parameters */
     559         711 :         state->orig.in.sids = _sids;
     560             : 
     561             :         /* Out parameters */
     562         711 :         state->orig.out.domains = _domains;
     563         711 :         state->orig.out.names = _names;
     564             : 
     565             :         /* Result */
     566         711 :         NDR_ZERO_STRUCT(state->orig.out.result);
     567             : 
     568         711 :         state->out_mem_ctx = talloc_named_const(state, 0,
     569             :                              "dcerpc_wbint_LookupSids_out_memory");
     570         711 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
     571           0 :                 return tevent_req_post(req, ev);
     572             :         }
     573             : 
     574             :         /* make a temporary copy, that we pass to the dispatch function */
     575         711 :         state->tmp = state->orig;
     576             : 
     577         711 :         subreq = dcerpc_wbint_LookupSids_r_send(state, ev, h, &state->tmp);
     578         711 :         if (tevent_req_nomem(subreq, req)) {
     579           0 :                 return tevent_req_post(req, ev);
     580             :         }
     581         711 :         tevent_req_set_callback(subreq, dcerpc_wbint_LookupSids_done, req);
     582         711 :         return req;
     583             : }
     584             : 
     585         711 : static void dcerpc_wbint_LookupSids_done(struct tevent_req *subreq)
     586             : {
     587         711 :         struct tevent_req *req = tevent_req_callback_data(
     588             :                 subreq, struct tevent_req);
     589         711 :         struct dcerpc_wbint_LookupSids_state *state = tevent_req_data(
     590             :                 req, struct dcerpc_wbint_LookupSids_state);
     591             :         NTSTATUS status;
     592             :         TALLOC_CTX *mem_ctx;
     593             : 
     594         711 :         if (state->out_mem_ctx) {
     595         711 :                 mem_ctx = state->out_mem_ctx;
     596             :         } else {
     597           0 :                 mem_ctx = state;
     598             :         }
     599             : 
     600         711 :         status = dcerpc_wbint_LookupSids_r_recv(subreq, mem_ctx);
     601         711 :         TALLOC_FREE(subreq);
     602         711 :         if (tevent_req_nterror(req, status)) {
     603           0 :                 return;
     604             :         }
     605             : 
     606             :         /* Copy out parameters */
     607         711 :         *state->orig.out.domains = *state->tmp.out.domains;
     608         711 :         *state->orig.out.names = *state->tmp.out.names;
     609             : 
     610             :         /* Copy result */
     611         711 :         state->orig.out.result = state->tmp.out.result;
     612             : 
     613             :         /* Reset temporary structure */
     614         711 :         NDR_ZERO_STRUCT(state->tmp);
     615             : 
     616         711 :         tevent_req_done(req);
     617             : }
     618             : 
     619         711 : NTSTATUS dcerpc_wbint_LookupSids_recv(struct tevent_req *req,
     620             :                                       TALLOC_CTX *mem_ctx,
     621             :                                       NTSTATUS *result)
     622             : {
     623         711 :         struct dcerpc_wbint_LookupSids_state *state = tevent_req_data(
     624             :                 req, struct dcerpc_wbint_LookupSids_state);
     625             :         NTSTATUS status;
     626             : 
     627         711 :         if (tevent_req_is_nterror(req, &status)) {
     628           0 :                 tevent_req_received(req);
     629           0 :                 return status;
     630             :         }
     631             : 
     632             :         /* Steal possible out parameters to the callers context */
     633         711 :         talloc_steal(mem_ctx, state->out_mem_ctx);
     634             : 
     635             :         /* Return result */
     636         711 :         *result = state->orig.out.result;
     637             : 
     638         711 :         tevent_req_received(req);
     639         711 :         return NT_STATUS_OK;
     640             : }
     641             : 
     642           0 : NTSTATUS dcerpc_wbint_LookupSids(struct dcerpc_binding_handle *h,
     643             :                                  TALLOC_CTX *mem_ctx,
     644             :                                  struct lsa_SidArray *_sids /* [in] [ref] */,
     645             :                                  struct lsa_RefDomainList *_domains /* [out] [ref] */,
     646             :                                  struct lsa_TransNameArray *_names /* [out] [ref] */,
     647             :                                  NTSTATUS *result)
     648             : {
     649             :         struct wbint_LookupSids r;
     650             :         NTSTATUS status;
     651             : 
     652             :         /* In parameters */
     653           0 :         r.in.sids = _sids;
     654             : 
     655             :         /* Out parameters */
     656           0 :         r.out.domains = _domains;
     657           0 :         r.out.names = _names;
     658             : 
     659             :         /* Result */
     660           0 :         NDR_ZERO_STRUCT(r.out.result);
     661             : 
     662           0 :         status = dcerpc_wbint_LookupSids_r(h, mem_ctx, &r);
     663           0 :         if (!NT_STATUS_IS_OK(status)) {
     664           0 :                 return status;
     665             :         }
     666             : 
     667             :         /* Return variables */
     668           0 :         *_domains = *r.out.domains;
     669           0 :         *_names = *r.out.names;
     670             : 
     671             :         /* Return result */
     672           0 :         *result = r.out.result;
     673             : 
     674           0 :         return NT_STATUS_OK;
     675             : }
     676             : 
     677             : struct dcerpc_wbint_LookupName_r_state {
     678             :         TALLOC_CTX *out_mem_ctx;
     679             : };
     680             : 
     681             : static void dcerpc_wbint_LookupName_r_done(struct tevent_req *subreq);
     682             : 
     683       49284 : struct tevent_req *dcerpc_wbint_LookupName_r_send(TALLOC_CTX *mem_ctx,
     684             :         struct tevent_context *ev,
     685             :         struct dcerpc_binding_handle *h,
     686             :         struct wbint_LookupName *r)
     687             : {
     688             :         struct tevent_req *req;
     689             :         struct dcerpc_wbint_LookupName_r_state *state;
     690             :         struct tevent_req *subreq;
     691             : 
     692       49284 :         req = tevent_req_create(mem_ctx, &state,
     693             :                                 struct dcerpc_wbint_LookupName_r_state);
     694       49284 :         if (req == NULL) {
     695           0 :                 return NULL;
     696             :         }
     697             : 
     698       49284 :         state->out_mem_ctx = talloc_new(state);
     699       49284 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
     700           0 :                 return tevent_req_post(req, ev);
     701             :         }
     702             : 
     703       49284 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
     704             :                         NULL, &ndr_table_winbind,
     705       49284 :                         NDR_WBINT_LOOKUPNAME, state->out_mem_ctx, r);
     706       49284 :         if (tevent_req_nomem(subreq, req)) {
     707           0 :                 return tevent_req_post(req, ev);
     708             :         }
     709       49284 :         tevent_req_set_callback(subreq, dcerpc_wbint_LookupName_r_done, req);
     710             : 
     711       49284 :         return req;
     712             : }
     713             : 
     714       49280 : static void dcerpc_wbint_LookupName_r_done(struct tevent_req *subreq)
     715             : {
     716       48486 :         struct tevent_req *req =
     717       49280 :                 tevent_req_callback_data(subreq,
     718             :                 struct tevent_req);
     719             :         NTSTATUS status;
     720             : 
     721       49280 :         status = dcerpc_binding_handle_call_recv(subreq);
     722       49280 :         TALLOC_FREE(subreq);
     723       49280 :         if (tevent_req_nterror(req, status)) {
     724           0 :                 return;
     725             :         }
     726             : 
     727       49280 :         tevent_req_done(req);
     728             : }
     729             : 
     730       49280 : NTSTATUS dcerpc_wbint_LookupName_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
     731             : {
     732       48486 :         struct dcerpc_wbint_LookupName_r_state *state =
     733       49280 :                 tevent_req_data(req,
     734             :                 struct dcerpc_wbint_LookupName_r_state);
     735             :         NTSTATUS status;
     736             : 
     737       49280 :         if (tevent_req_is_nterror(req, &status)) {
     738           0 :                 tevent_req_received(req);
     739           0 :                 return status;
     740             :         }
     741             : 
     742       49280 :         talloc_steal(mem_ctx, state->out_mem_ctx);
     743             : 
     744       49280 :         tevent_req_received(req);
     745       49280 :         return NT_STATUS_OK;
     746             : }
     747             : 
     748           0 : NTSTATUS dcerpc_wbint_LookupName_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wbint_LookupName *r)
     749             : {
     750             :         NTSTATUS status;
     751             : 
     752           0 :         status = dcerpc_binding_handle_call(h,
     753             :                         NULL, &ndr_table_winbind,
     754             :                         NDR_WBINT_LOOKUPNAME, mem_ctx, r);
     755             : 
     756           0 :         return status;
     757             : }
     758             : 
     759             : struct dcerpc_wbint_LookupName_state {
     760             :         struct wbint_LookupName orig;
     761             :         struct wbint_LookupName tmp;
     762             :         TALLOC_CTX *out_mem_ctx;
     763             : };
     764             : 
     765             : static void dcerpc_wbint_LookupName_done(struct tevent_req *subreq);
     766             : 
     767       49284 : struct tevent_req *dcerpc_wbint_LookupName_send(TALLOC_CTX *mem_ctx,
     768             :                                                 struct tevent_context *ev,
     769             :                                                 struct dcerpc_binding_handle *h,
     770             :                                                 const char *_domain /* [in] [charset(UTF8),ref] */,
     771             :                                                 const char *_name /* [in] [charset(UTF8),ref] */,
     772             :                                                 uint32_t _flags /* [in]  */,
     773             :                                                 enum lsa_SidType *_type /* [out] [ref] */,
     774             :                                                 struct dom_sid *_sid /* [out] [ref] */)
     775             : {
     776             :         struct tevent_req *req;
     777             :         struct dcerpc_wbint_LookupName_state *state;
     778             :         struct tevent_req *subreq;
     779             : 
     780       49284 :         req = tevent_req_create(mem_ctx, &state,
     781             :                                 struct dcerpc_wbint_LookupName_state);
     782       49284 :         if (req == NULL) {
     783           0 :                 return NULL;
     784             :         }
     785       49284 :         state->out_mem_ctx = NULL;
     786             : 
     787             :         /* In parameters */
     788       49284 :         state->orig.in.domain = _domain;
     789       49284 :         state->orig.in.name = _name;
     790       49284 :         state->orig.in.flags = _flags;
     791             : 
     792             :         /* Out parameters */
     793       49284 :         state->orig.out.type = _type;
     794       49284 :         state->orig.out.sid = _sid;
     795             : 
     796             :         /* Result */
     797       49284 :         NDR_ZERO_STRUCT(state->orig.out.result);
     798             : 
     799       49284 :         state->out_mem_ctx = talloc_named_const(state, 0,
     800             :                              "dcerpc_wbint_LookupName_out_memory");
     801       49284 :         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       49284 :         state->tmp = state->orig;
     807             : 
     808       49284 :         subreq = dcerpc_wbint_LookupName_r_send(state, ev, h, &state->tmp);
     809       49284 :         if (tevent_req_nomem(subreq, req)) {
     810           0 :                 return tevent_req_post(req, ev);
     811             :         }
     812       49284 :         tevent_req_set_callback(subreq, dcerpc_wbint_LookupName_done, req);
     813       49284 :         return req;
     814             : }
     815             : 
     816       49280 : static void dcerpc_wbint_LookupName_done(struct tevent_req *subreq)
     817             : {
     818       49280 :         struct tevent_req *req = tevent_req_callback_data(
     819             :                 subreq, struct tevent_req);
     820       49280 :         struct dcerpc_wbint_LookupName_state *state = tevent_req_data(
     821             :                 req, struct dcerpc_wbint_LookupName_state);
     822             :         NTSTATUS status;
     823             :         TALLOC_CTX *mem_ctx;
     824             : 
     825       49280 :         if (state->out_mem_ctx) {
     826       49280 :                 mem_ctx = state->out_mem_ctx;
     827             :         } else {
     828           0 :                 mem_ctx = state;
     829             :         }
     830             : 
     831       49280 :         status = dcerpc_wbint_LookupName_r_recv(subreq, mem_ctx);
     832       49280 :         TALLOC_FREE(subreq);
     833       49280 :         if (tevent_req_nterror(req, status)) {
     834           0 :                 return;
     835             :         }
     836             : 
     837             :         /* Copy out parameters */
     838       49280 :         *state->orig.out.type = *state->tmp.out.type;
     839       49280 :         *state->orig.out.sid = *state->tmp.out.sid;
     840             : 
     841             :         /* Copy result */
     842       49280 :         state->orig.out.result = state->tmp.out.result;
     843             : 
     844             :         /* Reset temporary structure */
     845       49280 :         NDR_ZERO_STRUCT(state->tmp);
     846             : 
     847       49280 :         tevent_req_done(req);
     848             : }
     849             : 
     850       49280 : NTSTATUS dcerpc_wbint_LookupName_recv(struct tevent_req *req,
     851             :                                       TALLOC_CTX *mem_ctx,
     852             :                                       NTSTATUS *result)
     853             : {
     854       49280 :         struct dcerpc_wbint_LookupName_state *state = tevent_req_data(
     855             :                 req, struct dcerpc_wbint_LookupName_state);
     856             :         NTSTATUS status;
     857             : 
     858       49280 :         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       49280 :         talloc_steal(mem_ctx, state->out_mem_ctx);
     865             : 
     866             :         /* Return result */
     867       49280 :         *result = state->orig.out.result;
     868             : 
     869       49280 :         tevent_req_received(req);
     870       49280 :         return NT_STATUS_OK;
     871             : }
     872             : 
     873           0 : NTSTATUS dcerpc_wbint_LookupName(struct dcerpc_binding_handle *h,
     874             :                                  TALLOC_CTX *mem_ctx,
     875             :                                  const char *_domain /* [in] [charset(UTF8),ref] */,
     876             :                                  const char *_name /* [in] [charset(UTF8),ref] */,
     877             :                                  uint32_t _flags /* [in]  */,
     878             :                                  enum lsa_SidType *_type /* [out] [ref] */,
     879             :                                  struct dom_sid *_sid /* [out] [ref] */,
     880             :                                  NTSTATUS *result)
     881             : {
     882             :         struct wbint_LookupName r;
     883             :         NTSTATUS status;
     884             : 
     885             :         /* In parameters */
     886           0 :         r.in.domain = _domain;
     887           0 :         r.in.name = _name;
     888           0 :         r.in.flags = _flags;
     889             : 
     890             :         /* Out parameters */
     891           0 :         r.out.type = _type;
     892           0 :         r.out.sid = _sid;
     893             : 
     894             :         /* Result */
     895           0 :         NDR_ZERO_STRUCT(r.out.result);
     896             : 
     897           0 :         status = dcerpc_wbint_LookupName_r(h, mem_ctx, &r);
     898           0 :         if (!NT_STATUS_IS_OK(status)) {
     899           0 :                 return status;
     900             :         }
     901             : 
     902             :         /* Return variables */
     903           0 :         *_type = *r.out.type;
     904           0 :         *_sid = *r.out.sid;
     905             : 
     906             :         /* Return result */
     907           0 :         *result = r.out.result;
     908             : 
     909           0 :         return NT_STATUS_OK;
     910             : }
     911             : 
     912             : struct dcerpc_wbint_Sids2UnixIDs_r_state {
     913             :         TALLOC_CTX *out_mem_ctx;
     914             : };
     915             : 
     916             : static void dcerpc_wbint_Sids2UnixIDs_r_done(struct tevent_req *subreq);
     917             : 
     918        3877 : struct tevent_req *dcerpc_wbint_Sids2UnixIDs_r_send(TALLOC_CTX *mem_ctx,
     919             :         struct tevent_context *ev,
     920             :         struct dcerpc_binding_handle *h,
     921             :         struct wbint_Sids2UnixIDs *r)
     922             : {
     923             :         struct tevent_req *req;
     924             :         struct dcerpc_wbint_Sids2UnixIDs_r_state *state;
     925             :         struct tevent_req *subreq;
     926             : 
     927        3877 :         req = tevent_req_create(mem_ctx, &state,
     928             :                                 struct dcerpc_wbint_Sids2UnixIDs_r_state);
     929        3877 :         if (req == NULL) {
     930           0 :                 return NULL;
     931             :         }
     932             : 
     933        3877 :         state->out_mem_ctx = talloc_new(state);
     934        3877 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
     935           0 :                 return tevent_req_post(req, ev);
     936             :         }
     937             : 
     938        3877 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
     939             :                         NULL, &ndr_table_winbind,
     940        3877 :                         NDR_WBINT_SIDS2UNIXIDS, state->out_mem_ctx, r);
     941        3877 :         if (tevent_req_nomem(subreq, req)) {
     942           0 :                 return tevent_req_post(req, ev);
     943             :         }
     944        3877 :         tevent_req_set_callback(subreq, dcerpc_wbint_Sids2UnixIDs_r_done, req);
     945             : 
     946        3877 :         return req;
     947             : }
     948             : 
     949        3864 : static void dcerpc_wbint_Sids2UnixIDs_r_done(struct tevent_req *subreq)
     950             : {
     951        3700 :         struct tevent_req *req =
     952        3864 :                 tevent_req_callback_data(subreq,
     953             :                 struct tevent_req);
     954             :         NTSTATUS status;
     955             : 
     956        3864 :         status = dcerpc_binding_handle_call_recv(subreq);
     957        3864 :         TALLOC_FREE(subreq);
     958        3864 :         if (tevent_req_nterror(req, status)) {
     959           0 :                 return;
     960             :         }
     961             : 
     962        3864 :         tevent_req_done(req);
     963             : }
     964             : 
     965        3864 : NTSTATUS dcerpc_wbint_Sids2UnixIDs_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
     966             : {
     967        3700 :         struct dcerpc_wbint_Sids2UnixIDs_r_state *state =
     968        3864 :                 tevent_req_data(req,
     969             :                 struct dcerpc_wbint_Sids2UnixIDs_r_state);
     970             :         NTSTATUS status;
     971             : 
     972        3864 :         if (tevent_req_is_nterror(req, &status)) {
     973           0 :                 tevent_req_received(req);
     974           0 :                 return status;
     975             :         }
     976             : 
     977        3864 :         talloc_steal(mem_ctx, state->out_mem_ctx);
     978             : 
     979        3864 :         tevent_req_received(req);
     980        3864 :         return NT_STATUS_OK;
     981             : }
     982             : 
     983           0 : NTSTATUS dcerpc_wbint_Sids2UnixIDs_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wbint_Sids2UnixIDs *r)
     984             : {
     985             :         NTSTATUS status;
     986             : 
     987           0 :         status = dcerpc_binding_handle_call(h,
     988             :                         NULL, &ndr_table_winbind,
     989             :                         NDR_WBINT_SIDS2UNIXIDS, mem_ctx, r);
     990             : 
     991           0 :         return status;
     992             : }
     993             : 
     994             : struct dcerpc_wbint_Sids2UnixIDs_state {
     995             :         struct wbint_Sids2UnixIDs orig;
     996             :         struct wbint_Sids2UnixIDs tmp;
     997             :         TALLOC_CTX *out_mem_ctx;
     998             : };
     999             : 
    1000             : static void dcerpc_wbint_Sids2UnixIDs_done(struct tevent_req *subreq);
    1001             : 
    1002        3877 : struct tevent_req *dcerpc_wbint_Sids2UnixIDs_send(TALLOC_CTX *mem_ctx,
    1003             :                                                   struct tevent_context *ev,
    1004             :                                                   struct dcerpc_binding_handle *h,
    1005             :                                                   struct lsa_RefDomainList *_domains /* [in] [ref] */,
    1006             :                                                   struct wbint_TransIDArray *_ids /* [in,out] [ref] */)
    1007             : {
    1008             :         struct tevent_req *req;
    1009             :         struct dcerpc_wbint_Sids2UnixIDs_state *state;
    1010             :         struct tevent_req *subreq;
    1011             : 
    1012        3877 :         req = tevent_req_create(mem_ctx, &state,
    1013             :                                 struct dcerpc_wbint_Sids2UnixIDs_state);
    1014        3877 :         if (req == NULL) {
    1015           0 :                 return NULL;
    1016             :         }
    1017        3877 :         state->out_mem_ctx = NULL;
    1018             : 
    1019             :         /* In parameters */
    1020        3877 :         state->orig.in.domains = _domains;
    1021        3877 :         state->orig.in.ids = _ids;
    1022             : 
    1023             :         /* Out parameters */
    1024        3877 :         state->orig.out.ids = _ids;
    1025             : 
    1026             :         /* Result */
    1027        3877 :         NDR_ZERO_STRUCT(state->orig.out.result);
    1028             : 
    1029        3877 :         state->out_mem_ctx = talloc_named_const(state, 0,
    1030             :                              "dcerpc_wbint_Sids2UnixIDs_out_memory");
    1031        3877 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    1032           0 :                 return tevent_req_post(req, ev);
    1033             :         }
    1034             : 
    1035             :         /* make a temporary copy, that we pass to the dispatch function */
    1036        3877 :         state->tmp = state->orig;
    1037             : 
    1038        3877 :         subreq = dcerpc_wbint_Sids2UnixIDs_r_send(state, ev, h, &state->tmp);
    1039        3877 :         if (tevent_req_nomem(subreq, req)) {
    1040           0 :                 return tevent_req_post(req, ev);
    1041             :         }
    1042        3877 :         tevent_req_set_callback(subreq, dcerpc_wbint_Sids2UnixIDs_done, req);
    1043        3877 :         return req;
    1044             : }
    1045             : 
    1046        3864 : static void dcerpc_wbint_Sids2UnixIDs_done(struct tevent_req *subreq)
    1047             : {
    1048        3864 :         struct tevent_req *req = tevent_req_callback_data(
    1049             :                 subreq, struct tevent_req);
    1050        3864 :         struct dcerpc_wbint_Sids2UnixIDs_state *state = tevent_req_data(
    1051             :                 req, struct dcerpc_wbint_Sids2UnixIDs_state);
    1052             :         NTSTATUS status;
    1053             :         TALLOC_CTX *mem_ctx;
    1054             : 
    1055        3864 :         if (state->out_mem_ctx) {
    1056        3864 :                 mem_ctx = state->out_mem_ctx;
    1057             :         } else {
    1058           0 :                 mem_ctx = state;
    1059             :         }
    1060             : 
    1061        3864 :         status = dcerpc_wbint_Sids2UnixIDs_r_recv(subreq, mem_ctx);
    1062        3864 :         TALLOC_FREE(subreq);
    1063        3864 :         if (tevent_req_nterror(req, status)) {
    1064           0 :                 return;
    1065             :         }
    1066             : 
    1067             :         /* Copy out parameters */
    1068        3864 :         *state->orig.out.ids = *state->tmp.out.ids;
    1069             : 
    1070             :         /* Copy result */
    1071        3864 :         state->orig.out.result = state->tmp.out.result;
    1072             : 
    1073             :         /* Reset temporary structure */
    1074        3864 :         NDR_ZERO_STRUCT(state->tmp);
    1075             : 
    1076        3864 :         tevent_req_done(req);
    1077             : }
    1078             : 
    1079        3864 : NTSTATUS dcerpc_wbint_Sids2UnixIDs_recv(struct tevent_req *req,
    1080             :                                         TALLOC_CTX *mem_ctx,
    1081             :                                         NTSTATUS *result)
    1082             : {
    1083        3864 :         struct dcerpc_wbint_Sids2UnixIDs_state *state = tevent_req_data(
    1084             :                 req, struct dcerpc_wbint_Sids2UnixIDs_state);
    1085             :         NTSTATUS status;
    1086             : 
    1087        3864 :         if (tevent_req_is_nterror(req, &status)) {
    1088           0 :                 tevent_req_received(req);
    1089           0 :                 return status;
    1090             :         }
    1091             : 
    1092             :         /* Steal possible out parameters to the callers context */
    1093        3864 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    1094             : 
    1095             :         /* Return result */
    1096        3864 :         *result = state->orig.out.result;
    1097             : 
    1098        3864 :         tevent_req_received(req);
    1099        3864 :         return NT_STATUS_OK;
    1100             : }
    1101             : 
    1102           0 : NTSTATUS dcerpc_wbint_Sids2UnixIDs(struct dcerpc_binding_handle *h,
    1103             :                                    TALLOC_CTX *mem_ctx,
    1104             :                                    struct lsa_RefDomainList *_domains /* [in] [ref] */,
    1105             :                                    struct wbint_TransIDArray *_ids /* [in,out] [ref] */,
    1106             :                                    NTSTATUS *result)
    1107             : {
    1108             :         struct wbint_Sids2UnixIDs r;
    1109             :         NTSTATUS status;
    1110             : 
    1111             :         /* In parameters */
    1112           0 :         r.in.domains = _domains;
    1113           0 :         r.in.ids = _ids;
    1114             : 
    1115             :         /* Out parameters */
    1116           0 :         r.out.ids = _ids;
    1117             : 
    1118             :         /* Result */
    1119           0 :         NDR_ZERO_STRUCT(r.out.result);
    1120             : 
    1121           0 :         status = dcerpc_wbint_Sids2UnixIDs_r(h, mem_ctx, &r);
    1122           0 :         if (!NT_STATUS_IS_OK(status)) {
    1123           0 :                 return status;
    1124             :         }
    1125             : 
    1126             :         /* Return variables */
    1127           0 :         *_ids = *r.out.ids;
    1128             : 
    1129             :         /* Return result */
    1130           0 :         *result = r.out.result;
    1131             : 
    1132           0 :         return NT_STATUS_OK;
    1133             : }
    1134             : 
    1135             : struct dcerpc_wbint_UnixIDs2Sids_r_state {
    1136             :         TALLOC_CTX *out_mem_ctx;
    1137             : };
    1138             : 
    1139             : static void dcerpc_wbint_UnixIDs2Sids_r_done(struct tevent_req *subreq);
    1140             : 
    1141         403 : struct tevent_req *dcerpc_wbint_UnixIDs2Sids_r_send(TALLOC_CTX *mem_ctx,
    1142             :         struct tevent_context *ev,
    1143             :         struct dcerpc_binding_handle *h,
    1144             :         struct wbint_UnixIDs2Sids *r)
    1145             : {
    1146             :         struct tevent_req *req;
    1147             :         struct dcerpc_wbint_UnixIDs2Sids_r_state *state;
    1148             :         struct tevent_req *subreq;
    1149             : 
    1150         403 :         req = tevent_req_create(mem_ctx, &state,
    1151             :                                 struct dcerpc_wbint_UnixIDs2Sids_r_state);
    1152         403 :         if (req == NULL) {
    1153           0 :                 return NULL;
    1154             :         }
    1155             : 
    1156         403 :         state->out_mem_ctx = talloc_new(state);
    1157         403 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    1158           0 :                 return tevent_req_post(req, ev);
    1159             :         }
    1160             : 
    1161         403 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    1162             :                         NULL, &ndr_table_winbind,
    1163         403 :                         NDR_WBINT_UNIXIDS2SIDS, state->out_mem_ctx, r);
    1164         403 :         if (tevent_req_nomem(subreq, req)) {
    1165           0 :                 return tevent_req_post(req, ev);
    1166             :         }
    1167         403 :         tevent_req_set_callback(subreq, dcerpc_wbint_UnixIDs2Sids_r_done, req);
    1168             : 
    1169         403 :         return req;
    1170             : }
    1171             : 
    1172         403 : static void dcerpc_wbint_UnixIDs2Sids_r_done(struct tevent_req *subreq)
    1173             : {
    1174         353 :         struct tevent_req *req =
    1175         403 :                 tevent_req_callback_data(subreq,
    1176             :                 struct tevent_req);
    1177             :         NTSTATUS status;
    1178             : 
    1179         403 :         status = dcerpc_binding_handle_call_recv(subreq);
    1180         403 :         TALLOC_FREE(subreq);
    1181         403 :         if (tevent_req_nterror(req, status)) {
    1182           0 :                 return;
    1183             :         }
    1184             : 
    1185         403 :         tevent_req_done(req);
    1186             : }
    1187             : 
    1188         403 : NTSTATUS dcerpc_wbint_UnixIDs2Sids_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    1189             : {
    1190         353 :         struct dcerpc_wbint_UnixIDs2Sids_r_state *state =
    1191         403 :                 tevent_req_data(req,
    1192             :                 struct dcerpc_wbint_UnixIDs2Sids_r_state);
    1193             :         NTSTATUS status;
    1194             : 
    1195         403 :         if (tevent_req_is_nterror(req, &status)) {
    1196           0 :                 tevent_req_received(req);
    1197           0 :                 return status;
    1198             :         }
    1199             : 
    1200         403 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    1201             : 
    1202         403 :         tevent_req_received(req);
    1203         403 :         return NT_STATUS_OK;
    1204             : }
    1205             : 
    1206           0 : NTSTATUS dcerpc_wbint_UnixIDs2Sids_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wbint_UnixIDs2Sids *r)
    1207             : {
    1208             :         NTSTATUS status;
    1209             : 
    1210           0 :         status = dcerpc_binding_handle_call(h,
    1211             :                         NULL, &ndr_table_winbind,
    1212             :                         NDR_WBINT_UNIXIDS2SIDS, mem_ctx, r);
    1213             : 
    1214           0 :         return status;
    1215             : }
    1216             : 
    1217             : struct dcerpc_wbint_UnixIDs2Sids_state {
    1218             :         struct wbint_UnixIDs2Sids orig;
    1219             :         struct wbint_UnixIDs2Sids tmp;
    1220             :         TALLOC_CTX *out_mem_ctx;
    1221             : };
    1222             : 
    1223             : static void dcerpc_wbint_UnixIDs2Sids_done(struct tevent_req *subreq);
    1224             : 
    1225         403 : struct tevent_req *dcerpc_wbint_UnixIDs2Sids_send(TALLOC_CTX *mem_ctx,
    1226             :                                                   struct tevent_context *ev,
    1227             :                                                   struct dcerpc_binding_handle *h,
    1228             :                                                   const char *_domain_name /* [in] [charset(UTF8),ref] */,
    1229             :                                                   struct dom_sid _domain_sid /* [in]  */,
    1230             :                                                   uint32_t _num_ids /* [in]  */,
    1231             :                                                   struct unixid *_xids /* [in,out]  */,
    1232             :                                                   struct dom_sid *_sids /* [out]  */)
    1233             : {
    1234             :         struct tevent_req *req;
    1235             :         struct dcerpc_wbint_UnixIDs2Sids_state *state;
    1236             :         struct tevent_req *subreq;
    1237             : 
    1238         403 :         req = tevent_req_create(mem_ctx, &state,
    1239             :                                 struct dcerpc_wbint_UnixIDs2Sids_state);
    1240         403 :         if (req == NULL) {
    1241           0 :                 return NULL;
    1242             :         }
    1243         403 :         state->out_mem_ctx = NULL;
    1244             : 
    1245             :         /* In parameters */
    1246         403 :         state->orig.in.domain_name = _domain_name;
    1247         403 :         state->orig.in.domain_sid = _domain_sid;
    1248         403 :         state->orig.in.num_ids = _num_ids;
    1249         403 :         state->orig.in.xids = _xids;
    1250             : 
    1251             :         /* Out parameters */
    1252         403 :         state->orig.out.xids = _xids;
    1253         403 :         state->orig.out.sids = _sids;
    1254             : 
    1255             :         /* Result */
    1256         403 :         NDR_ZERO_STRUCT(state->orig.out.result);
    1257             : 
    1258         403 :         state->out_mem_ctx = talloc_named_const(state, 0,
    1259             :                              "dcerpc_wbint_UnixIDs2Sids_out_memory");
    1260         403 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    1261           0 :                 return tevent_req_post(req, ev);
    1262             :         }
    1263             : 
    1264             :         /* make a temporary copy, that we pass to the dispatch function */
    1265         403 :         state->tmp = state->orig;
    1266             : 
    1267         403 :         subreq = dcerpc_wbint_UnixIDs2Sids_r_send(state, ev, h, &state->tmp);
    1268         403 :         if (tevent_req_nomem(subreq, req)) {
    1269           0 :                 return tevent_req_post(req, ev);
    1270             :         }
    1271         403 :         tevent_req_set_callback(subreq, dcerpc_wbint_UnixIDs2Sids_done, req);
    1272         403 :         return req;
    1273             : }
    1274             : 
    1275         403 : static void dcerpc_wbint_UnixIDs2Sids_done(struct tevent_req *subreq)
    1276             : {
    1277         403 :         struct tevent_req *req = tevent_req_callback_data(
    1278             :                 subreq, struct tevent_req);
    1279         403 :         struct dcerpc_wbint_UnixIDs2Sids_state *state = tevent_req_data(
    1280             :                 req, struct dcerpc_wbint_UnixIDs2Sids_state);
    1281             :         NTSTATUS status;
    1282             :         TALLOC_CTX *mem_ctx;
    1283             : 
    1284         403 :         if (state->out_mem_ctx) {
    1285         403 :                 mem_ctx = state->out_mem_ctx;
    1286             :         } else {
    1287           0 :                 mem_ctx = state;
    1288             :         }
    1289             : 
    1290         403 :         status = dcerpc_wbint_UnixIDs2Sids_r_recv(subreq, mem_ctx);
    1291         403 :         TALLOC_FREE(subreq);
    1292         403 :         if (tevent_req_nterror(req, status)) {
    1293           0 :                 return;
    1294             :         }
    1295             : 
    1296             :         /* Copy out parameters */
    1297             :         {
    1298             :                 size_t _copy_len_xids;
    1299         403 :                 _copy_len_xids = state->tmp.in.num_ids;
    1300         403 :                 if (state->orig.out.xids != state->tmp.out.xids) {
    1301         403 :                         memcpy(state->orig.out.xids, state->tmp.out.xids, _copy_len_xids * sizeof(*state->orig.out.xids));
    1302             :                 }
    1303             :         }
    1304             :         {
    1305             :                 size_t _copy_len_sids;
    1306         403 :                 _copy_len_sids = state->tmp.in.num_ids;
    1307         403 :                 if (state->orig.out.sids != state->tmp.out.sids) {
    1308         403 :                         memcpy(state->orig.out.sids, state->tmp.out.sids, _copy_len_sids * sizeof(*state->orig.out.sids));
    1309             :                 }
    1310             :         }
    1311             : 
    1312             :         /* Copy result */
    1313         403 :         state->orig.out.result = state->tmp.out.result;
    1314             : 
    1315             :         /* Reset temporary structure */
    1316         403 :         NDR_ZERO_STRUCT(state->tmp);
    1317             : 
    1318         403 :         tevent_req_done(req);
    1319             : }
    1320             : 
    1321         403 : NTSTATUS dcerpc_wbint_UnixIDs2Sids_recv(struct tevent_req *req,
    1322             :                                         TALLOC_CTX *mem_ctx,
    1323             :                                         NTSTATUS *result)
    1324             : {
    1325         403 :         struct dcerpc_wbint_UnixIDs2Sids_state *state = tevent_req_data(
    1326             :                 req, struct dcerpc_wbint_UnixIDs2Sids_state);
    1327             :         NTSTATUS status;
    1328             : 
    1329         403 :         if (tevent_req_is_nterror(req, &status)) {
    1330           0 :                 tevent_req_received(req);
    1331           0 :                 return status;
    1332             :         }
    1333             : 
    1334             :         /* Steal possible out parameters to the callers context */
    1335         403 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    1336             : 
    1337             :         /* Return result */
    1338         403 :         *result = state->orig.out.result;
    1339             : 
    1340         403 :         tevent_req_received(req);
    1341         403 :         return NT_STATUS_OK;
    1342             : }
    1343             : 
    1344           0 : NTSTATUS dcerpc_wbint_UnixIDs2Sids(struct dcerpc_binding_handle *h,
    1345             :                                    TALLOC_CTX *mem_ctx,
    1346             :                                    const char *_domain_name /* [in] [charset(UTF8),ref] */,
    1347             :                                    struct dom_sid _domain_sid /* [in]  */,
    1348             :                                    uint32_t _num_ids /* [in]  */,
    1349             :                                    struct unixid *_xids /* [in,out]  */,
    1350             :                                    struct dom_sid *_sids /* [out]  */,
    1351             :                                    NTSTATUS *result)
    1352             : {
    1353             :         struct wbint_UnixIDs2Sids r;
    1354             :         NTSTATUS status;
    1355             : 
    1356             :         /* In parameters */
    1357           0 :         r.in.domain_name = _domain_name;
    1358           0 :         r.in.domain_sid = _domain_sid;
    1359           0 :         r.in.num_ids = _num_ids;
    1360           0 :         r.in.xids = _xids;
    1361             : 
    1362             :         /* Out parameters */
    1363           0 :         r.out.xids = _xids;
    1364           0 :         r.out.sids = _sids;
    1365             : 
    1366             :         /* Result */
    1367           0 :         NDR_ZERO_STRUCT(r.out.result);
    1368             : 
    1369           0 :         status = dcerpc_wbint_UnixIDs2Sids_r(h, mem_ctx, &r);
    1370           0 :         if (!NT_STATUS_IS_OK(status)) {
    1371           0 :                 return status;
    1372             :         }
    1373             : 
    1374             :         /* Return variables */
    1375             :         {
    1376             :                 size_t _copy_len_xids;
    1377           0 :                 _copy_len_xids = r.in.num_ids;
    1378           0 :                 if (_xids != r.out.xids) {
    1379           0 :                         memcpy(_xids, r.out.xids, _copy_len_xids * sizeof(*_xids));
    1380             :                 }
    1381             :         }
    1382             :         {
    1383             :                 size_t _copy_len_sids;
    1384           0 :                 _copy_len_sids = r.in.num_ids;
    1385           0 :                 if (_sids != r.out.sids) {
    1386           0 :                         memcpy(_sids, r.out.sids, _copy_len_sids * sizeof(*_sids));
    1387             :                 }
    1388             :         }
    1389             : 
    1390             :         /* Return result */
    1391           0 :         *result = r.out.result;
    1392             : 
    1393           0 :         return NT_STATUS_OK;
    1394             : }
    1395             : 
    1396             : struct dcerpc_wbint_AllocateUid_r_state {
    1397             :         TALLOC_CTX *out_mem_ctx;
    1398             : };
    1399             : 
    1400             : static void dcerpc_wbint_AllocateUid_r_done(struct tevent_req *subreq);
    1401             : 
    1402           9 : struct tevent_req *dcerpc_wbint_AllocateUid_r_send(TALLOC_CTX *mem_ctx,
    1403             :         struct tevent_context *ev,
    1404             :         struct dcerpc_binding_handle *h,
    1405             :         struct wbint_AllocateUid *r)
    1406             : {
    1407             :         struct tevent_req *req;
    1408             :         struct dcerpc_wbint_AllocateUid_r_state *state;
    1409             :         struct tevent_req *subreq;
    1410             : 
    1411           9 :         req = tevent_req_create(mem_ctx, &state,
    1412             :                                 struct dcerpc_wbint_AllocateUid_r_state);
    1413           9 :         if (req == NULL) {
    1414           0 :                 return NULL;
    1415             :         }
    1416             : 
    1417           9 :         state->out_mem_ctx = talloc_new(state);
    1418           9 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    1419           0 :                 return tevent_req_post(req, ev);
    1420             :         }
    1421             : 
    1422           9 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    1423             :                         NULL, &ndr_table_winbind,
    1424           9 :                         NDR_WBINT_ALLOCATEUID, state->out_mem_ctx, r);
    1425           9 :         if (tevent_req_nomem(subreq, req)) {
    1426           0 :                 return tevent_req_post(req, ev);
    1427             :         }
    1428           9 :         tevent_req_set_callback(subreq, dcerpc_wbint_AllocateUid_r_done, req);
    1429             : 
    1430           9 :         return req;
    1431             : }
    1432             : 
    1433           9 : static void dcerpc_wbint_AllocateUid_r_done(struct tevent_req *subreq)
    1434             : {
    1435           8 :         struct tevent_req *req =
    1436           9 :                 tevent_req_callback_data(subreq,
    1437             :                 struct tevent_req);
    1438             :         NTSTATUS status;
    1439             : 
    1440           9 :         status = dcerpc_binding_handle_call_recv(subreq);
    1441           9 :         TALLOC_FREE(subreq);
    1442           9 :         if (tevent_req_nterror(req, status)) {
    1443           0 :                 return;
    1444             :         }
    1445             : 
    1446           9 :         tevent_req_done(req);
    1447             : }
    1448             : 
    1449           9 : NTSTATUS dcerpc_wbint_AllocateUid_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    1450             : {
    1451           8 :         struct dcerpc_wbint_AllocateUid_r_state *state =
    1452           9 :                 tevent_req_data(req,
    1453             :                 struct dcerpc_wbint_AllocateUid_r_state);
    1454             :         NTSTATUS status;
    1455             : 
    1456           9 :         if (tevent_req_is_nterror(req, &status)) {
    1457           0 :                 tevent_req_received(req);
    1458           0 :                 return status;
    1459             :         }
    1460             : 
    1461           9 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    1462             : 
    1463           9 :         tevent_req_received(req);
    1464           9 :         return NT_STATUS_OK;
    1465             : }
    1466             : 
    1467           0 : NTSTATUS dcerpc_wbint_AllocateUid_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wbint_AllocateUid *r)
    1468             : {
    1469             :         NTSTATUS status;
    1470             : 
    1471           0 :         status = dcerpc_binding_handle_call(h,
    1472             :                         NULL, &ndr_table_winbind,
    1473             :                         NDR_WBINT_ALLOCATEUID, mem_ctx, r);
    1474             : 
    1475           0 :         return status;
    1476             : }
    1477             : 
    1478             : struct dcerpc_wbint_AllocateUid_state {
    1479             :         struct wbint_AllocateUid orig;
    1480             :         struct wbint_AllocateUid tmp;
    1481             :         TALLOC_CTX *out_mem_ctx;
    1482             : };
    1483             : 
    1484             : static void dcerpc_wbint_AllocateUid_done(struct tevent_req *subreq);
    1485             : 
    1486           9 : struct tevent_req *dcerpc_wbint_AllocateUid_send(TALLOC_CTX *mem_ctx,
    1487             :                                                  struct tevent_context *ev,
    1488             :                                                  struct dcerpc_binding_handle *h,
    1489             :                                                  uint64_t *_uid /* [out] [ref] */)
    1490             : {
    1491             :         struct tevent_req *req;
    1492             :         struct dcerpc_wbint_AllocateUid_state *state;
    1493             :         struct tevent_req *subreq;
    1494             : 
    1495           9 :         req = tevent_req_create(mem_ctx, &state,
    1496             :                                 struct dcerpc_wbint_AllocateUid_state);
    1497           9 :         if (req == NULL) {
    1498           0 :                 return NULL;
    1499             :         }
    1500           9 :         state->out_mem_ctx = NULL;
    1501             : 
    1502             :         /* In parameters */
    1503             : 
    1504             :         /* Out parameters */
    1505           9 :         state->orig.out.uid = _uid;
    1506             : 
    1507             :         /* Result */
    1508           9 :         NDR_ZERO_STRUCT(state->orig.out.result);
    1509             : 
    1510           9 :         state->out_mem_ctx = talloc_named_const(state, 0,
    1511             :                              "dcerpc_wbint_AllocateUid_out_memory");
    1512           9 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    1513           0 :                 return tevent_req_post(req, ev);
    1514             :         }
    1515             : 
    1516             :         /* make a temporary copy, that we pass to the dispatch function */
    1517           9 :         state->tmp = state->orig;
    1518             : 
    1519           9 :         subreq = dcerpc_wbint_AllocateUid_r_send(state, ev, h, &state->tmp);
    1520           9 :         if (tevent_req_nomem(subreq, req)) {
    1521           0 :                 return tevent_req_post(req, ev);
    1522             :         }
    1523           9 :         tevent_req_set_callback(subreq, dcerpc_wbint_AllocateUid_done, req);
    1524           9 :         return req;
    1525             : }
    1526             : 
    1527           9 : static void dcerpc_wbint_AllocateUid_done(struct tevent_req *subreq)
    1528             : {
    1529           9 :         struct tevent_req *req = tevent_req_callback_data(
    1530             :                 subreq, struct tevent_req);
    1531           9 :         struct dcerpc_wbint_AllocateUid_state *state = tevent_req_data(
    1532             :                 req, struct dcerpc_wbint_AllocateUid_state);
    1533             :         NTSTATUS status;
    1534             :         TALLOC_CTX *mem_ctx;
    1535             : 
    1536           9 :         if (state->out_mem_ctx) {
    1537           9 :                 mem_ctx = state->out_mem_ctx;
    1538             :         } else {
    1539           0 :                 mem_ctx = state;
    1540             :         }
    1541             : 
    1542           9 :         status = dcerpc_wbint_AllocateUid_r_recv(subreq, mem_ctx);
    1543           9 :         TALLOC_FREE(subreq);
    1544           9 :         if (tevent_req_nterror(req, status)) {
    1545           0 :                 return;
    1546             :         }
    1547             : 
    1548             :         /* Copy out parameters */
    1549           9 :         *state->orig.out.uid = *state->tmp.out.uid;
    1550             : 
    1551             :         /* Copy result */
    1552           9 :         state->orig.out.result = state->tmp.out.result;
    1553             : 
    1554             :         /* Reset temporary structure */
    1555           9 :         NDR_ZERO_STRUCT(state->tmp);
    1556             : 
    1557           9 :         tevent_req_done(req);
    1558             : }
    1559             : 
    1560           9 : NTSTATUS dcerpc_wbint_AllocateUid_recv(struct tevent_req *req,
    1561             :                                        TALLOC_CTX *mem_ctx,
    1562             :                                        NTSTATUS *result)
    1563             : {
    1564           9 :         struct dcerpc_wbint_AllocateUid_state *state = tevent_req_data(
    1565             :                 req, struct dcerpc_wbint_AllocateUid_state);
    1566             :         NTSTATUS status;
    1567             : 
    1568           9 :         if (tevent_req_is_nterror(req, &status)) {
    1569           0 :                 tevent_req_received(req);
    1570           0 :                 return status;
    1571             :         }
    1572             : 
    1573             :         /* Steal possible out parameters to the callers context */
    1574           9 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    1575             : 
    1576             :         /* Return result */
    1577           9 :         *result = state->orig.out.result;
    1578             : 
    1579           9 :         tevent_req_received(req);
    1580           9 :         return NT_STATUS_OK;
    1581             : }
    1582             : 
    1583           0 : NTSTATUS dcerpc_wbint_AllocateUid(struct dcerpc_binding_handle *h,
    1584             :                                   TALLOC_CTX *mem_ctx,
    1585             :                                   uint64_t *_uid /* [out] [ref] */,
    1586             :                                   NTSTATUS *result)
    1587             : {
    1588             :         struct wbint_AllocateUid r;
    1589             :         NTSTATUS status;
    1590             : 
    1591             :         /* In parameters */
    1592             : 
    1593             :         /* Out parameters */
    1594           0 :         r.out.uid = _uid;
    1595             : 
    1596             :         /* Result */
    1597           0 :         NDR_ZERO_STRUCT(r.out.result);
    1598             : 
    1599           0 :         status = dcerpc_wbint_AllocateUid_r(h, mem_ctx, &r);
    1600           0 :         if (!NT_STATUS_IS_OK(status)) {
    1601           0 :                 return status;
    1602             :         }
    1603             : 
    1604             :         /* Return variables */
    1605           0 :         *_uid = *r.out.uid;
    1606             : 
    1607             :         /* Return result */
    1608           0 :         *result = r.out.result;
    1609             : 
    1610           0 :         return NT_STATUS_OK;
    1611             : }
    1612             : 
    1613             : struct dcerpc_wbint_AllocateGid_r_state {
    1614             :         TALLOC_CTX *out_mem_ctx;
    1615             : };
    1616             : 
    1617             : static void dcerpc_wbint_AllocateGid_r_done(struct tevent_req *subreq);
    1618             : 
    1619         438 : struct tevent_req *dcerpc_wbint_AllocateGid_r_send(TALLOC_CTX *mem_ctx,
    1620             :         struct tevent_context *ev,
    1621             :         struct dcerpc_binding_handle *h,
    1622             :         struct wbint_AllocateGid *r)
    1623             : {
    1624             :         struct tevent_req *req;
    1625             :         struct dcerpc_wbint_AllocateGid_r_state *state;
    1626             :         struct tevent_req *subreq;
    1627             : 
    1628         438 :         req = tevent_req_create(mem_ctx, &state,
    1629             :                                 struct dcerpc_wbint_AllocateGid_r_state);
    1630         438 :         if (req == NULL) {
    1631           0 :                 return NULL;
    1632             :         }
    1633             : 
    1634         438 :         state->out_mem_ctx = talloc_new(state);
    1635         438 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    1636           0 :                 return tevent_req_post(req, ev);
    1637             :         }
    1638             : 
    1639         438 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    1640             :                         NULL, &ndr_table_winbind,
    1641         438 :                         NDR_WBINT_ALLOCATEGID, state->out_mem_ctx, r);
    1642         438 :         if (tevent_req_nomem(subreq, req)) {
    1643           0 :                 return tevent_req_post(req, ev);
    1644             :         }
    1645         438 :         tevent_req_set_callback(subreq, dcerpc_wbint_AllocateGid_r_done, req);
    1646             : 
    1647         438 :         return req;
    1648             : }
    1649             : 
    1650         438 : static void dcerpc_wbint_AllocateGid_r_done(struct tevent_req *subreq)
    1651             : {
    1652         424 :         struct tevent_req *req =
    1653         438 :                 tevent_req_callback_data(subreq,
    1654             :                 struct tevent_req);
    1655             :         NTSTATUS status;
    1656             : 
    1657         438 :         status = dcerpc_binding_handle_call_recv(subreq);
    1658         438 :         TALLOC_FREE(subreq);
    1659         438 :         if (tevent_req_nterror(req, status)) {
    1660           0 :                 return;
    1661             :         }
    1662             : 
    1663         438 :         tevent_req_done(req);
    1664             : }
    1665             : 
    1666         438 : NTSTATUS dcerpc_wbint_AllocateGid_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    1667             : {
    1668         424 :         struct dcerpc_wbint_AllocateGid_r_state *state =
    1669         438 :                 tevent_req_data(req,
    1670             :                 struct dcerpc_wbint_AllocateGid_r_state);
    1671             :         NTSTATUS status;
    1672             : 
    1673         438 :         if (tevent_req_is_nterror(req, &status)) {
    1674           0 :                 tevent_req_received(req);
    1675           0 :                 return status;
    1676             :         }
    1677             : 
    1678         438 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    1679             : 
    1680         438 :         tevent_req_received(req);
    1681         438 :         return NT_STATUS_OK;
    1682             : }
    1683             : 
    1684           0 : NTSTATUS dcerpc_wbint_AllocateGid_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wbint_AllocateGid *r)
    1685             : {
    1686             :         NTSTATUS status;
    1687             : 
    1688           0 :         status = dcerpc_binding_handle_call(h,
    1689             :                         NULL, &ndr_table_winbind,
    1690             :                         NDR_WBINT_ALLOCATEGID, mem_ctx, r);
    1691             : 
    1692           0 :         return status;
    1693             : }
    1694             : 
    1695             : struct dcerpc_wbint_AllocateGid_state {
    1696             :         struct wbint_AllocateGid orig;
    1697             :         struct wbint_AllocateGid tmp;
    1698             :         TALLOC_CTX *out_mem_ctx;
    1699             : };
    1700             : 
    1701             : static void dcerpc_wbint_AllocateGid_done(struct tevent_req *subreq);
    1702             : 
    1703         438 : struct tevent_req *dcerpc_wbint_AllocateGid_send(TALLOC_CTX *mem_ctx,
    1704             :                                                  struct tevent_context *ev,
    1705             :                                                  struct dcerpc_binding_handle *h,
    1706             :                                                  uint64_t *_gid /* [out] [ref] */)
    1707             : {
    1708             :         struct tevent_req *req;
    1709             :         struct dcerpc_wbint_AllocateGid_state *state;
    1710             :         struct tevent_req *subreq;
    1711             : 
    1712         438 :         req = tevent_req_create(mem_ctx, &state,
    1713             :                                 struct dcerpc_wbint_AllocateGid_state);
    1714         438 :         if (req == NULL) {
    1715           0 :                 return NULL;
    1716             :         }
    1717         438 :         state->out_mem_ctx = NULL;
    1718             : 
    1719             :         /* In parameters */
    1720             : 
    1721             :         /* Out parameters */
    1722         438 :         state->orig.out.gid = _gid;
    1723             : 
    1724             :         /* Result */
    1725         438 :         NDR_ZERO_STRUCT(state->orig.out.result);
    1726             : 
    1727         438 :         state->out_mem_ctx = talloc_named_const(state, 0,
    1728             :                              "dcerpc_wbint_AllocateGid_out_memory");
    1729         438 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    1730           0 :                 return tevent_req_post(req, ev);
    1731             :         }
    1732             : 
    1733             :         /* make a temporary copy, that we pass to the dispatch function */
    1734         438 :         state->tmp = state->orig;
    1735             : 
    1736         438 :         subreq = dcerpc_wbint_AllocateGid_r_send(state, ev, h, &state->tmp);
    1737         438 :         if (tevent_req_nomem(subreq, req)) {
    1738           0 :                 return tevent_req_post(req, ev);
    1739             :         }
    1740         438 :         tevent_req_set_callback(subreq, dcerpc_wbint_AllocateGid_done, req);
    1741         438 :         return req;
    1742             : }
    1743             : 
    1744         438 : static void dcerpc_wbint_AllocateGid_done(struct tevent_req *subreq)
    1745             : {
    1746         438 :         struct tevent_req *req = tevent_req_callback_data(
    1747             :                 subreq, struct tevent_req);
    1748         438 :         struct dcerpc_wbint_AllocateGid_state *state = tevent_req_data(
    1749             :                 req, struct dcerpc_wbint_AllocateGid_state);
    1750             :         NTSTATUS status;
    1751             :         TALLOC_CTX *mem_ctx;
    1752             : 
    1753         438 :         if (state->out_mem_ctx) {
    1754         438 :                 mem_ctx = state->out_mem_ctx;
    1755             :         } else {
    1756           0 :                 mem_ctx = state;
    1757             :         }
    1758             : 
    1759         438 :         status = dcerpc_wbint_AllocateGid_r_recv(subreq, mem_ctx);
    1760         438 :         TALLOC_FREE(subreq);
    1761         438 :         if (tevent_req_nterror(req, status)) {
    1762           0 :                 return;
    1763             :         }
    1764             : 
    1765             :         /* Copy out parameters */
    1766         438 :         *state->orig.out.gid = *state->tmp.out.gid;
    1767             : 
    1768             :         /* Copy result */
    1769         438 :         state->orig.out.result = state->tmp.out.result;
    1770             : 
    1771             :         /* Reset temporary structure */
    1772         438 :         NDR_ZERO_STRUCT(state->tmp);
    1773             : 
    1774         438 :         tevent_req_done(req);
    1775             : }
    1776             : 
    1777         438 : NTSTATUS dcerpc_wbint_AllocateGid_recv(struct tevent_req *req,
    1778             :                                        TALLOC_CTX *mem_ctx,
    1779             :                                        NTSTATUS *result)
    1780             : {
    1781         438 :         struct dcerpc_wbint_AllocateGid_state *state = tevent_req_data(
    1782             :                 req, struct dcerpc_wbint_AllocateGid_state);
    1783             :         NTSTATUS status;
    1784             : 
    1785         438 :         if (tevent_req_is_nterror(req, &status)) {
    1786           0 :                 tevent_req_received(req);
    1787           0 :                 return status;
    1788             :         }
    1789             : 
    1790             :         /* Steal possible out parameters to the callers context */
    1791         438 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    1792             : 
    1793             :         /* Return result */
    1794         438 :         *result = state->orig.out.result;
    1795             : 
    1796         438 :         tevent_req_received(req);
    1797         438 :         return NT_STATUS_OK;
    1798             : }
    1799             : 
    1800           0 : NTSTATUS dcerpc_wbint_AllocateGid(struct dcerpc_binding_handle *h,
    1801             :                                   TALLOC_CTX *mem_ctx,
    1802             :                                   uint64_t *_gid /* [out] [ref] */,
    1803             :                                   NTSTATUS *result)
    1804             : {
    1805             :         struct wbint_AllocateGid r;
    1806             :         NTSTATUS status;
    1807             : 
    1808             :         /* In parameters */
    1809             : 
    1810             :         /* Out parameters */
    1811           0 :         r.out.gid = _gid;
    1812             : 
    1813             :         /* Result */
    1814           0 :         NDR_ZERO_STRUCT(r.out.result);
    1815             : 
    1816           0 :         status = dcerpc_wbint_AllocateGid_r(h, mem_ctx, &r);
    1817           0 :         if (!NT_STATUS_IS_OK(status)) {
    1818           0 :                 return status;
    1819             :         }
    1820             : 
    1821             :         /* Return variables */
    1822           0 :         *_gid = *r.out.gid;
    1823             : 
    1824             :         /* Return result */
    1825           0 :         *result = r.out.result;
    1826             : 
    1827           0 :         return NT_STATUS_OK;
    1828             : }
    1829             : 
    1830             : struct dcerpc_wbint_GetNssInfo_r_state {
    1831             :         TALLOC_CTX *out_mem_ctx;
    1832             : };
    1833             : 
    1834             : static void dcerpc_wbint_GetNssInfo_r_done(struct tevent_req *subreq);
    1835             : 
    1836       47910 : struct tevent_req *dcerpc_wbint_GetNssInfo_r_send(TALLOC_CTX *mem_ctx,
    1837             :         struct tevent_context *ev,
    1838             :         struct dcerpc_binding_handle *h,
    1839             :         struct wbint_GetNssInfo *r)
    1840             : {
    1841             :         struct tevent_req *req;
    1842             :         struct dcerpc_wbint_GetNssInfo_r_state *state;
    1843             :         struct tevent_req *subreq;
    1844             : 
    1845       47910 :         req = tevent_req_create(mem_ctx, &state,
    1846             :                                 struct dcerpc_wbint_GetNssInfo_r_state);
    1847       47910 :         if (req == NULL) {
    1848           0 :                 return NULL;
    1849             :         }
    1850             : 
    1851       47910 :         state->out_mem_ctx = talloc_new(state);
    1852       47910 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    1853           0 :                 return tevent_req_post(req, ev);
    1854             :         }
    1855             : 
    1856       47910 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    1857             :                         NULL, &ndr_table_winbind,
    1858       47910 :                         NDR_WBINT_GETNSSINFO, state->out_mem_ctx, r);
    1859       47910 :         if (tevent_req_nomem(subreq, req)) {
    1860           0 :                 return tevent_req_post(req, ev);
    1861             :         }
    1862       47910 :         tevent_req_set_callback(subreq, dcerpc_wbint_GetNssInfo_r_done, req);
    1863             : 
    1864       47910 :         return req;
    1865             : }
    1866             : 
    1867       47910 : static void dcerpc_wbint_GetNssInfo_r_done(struct tevent_req *subreq)
    1868             : {
    1869       47040 :         struct tevent_req *req =
    1870       47910 :                 tevent_req_callback_data(subreq,
    1871             :                 struct tevent_req);
    1872             :         NTSTATUS status;
    1873             : 
    1874       47910 :         status = dcerpc_binding_handle_call_recv(subreq);
    1875       47910 :         TALLOC_FREE(subreq);
    1876       47910 :         if (tevent_req_nterror(req, status)) {
    1877           0 :                 return;
    1878             :         }
    1879             : 
    1880       47910 :         tevent_req_done(req);
    1881             : }
    1882             : 
    1883       47910 : NTSTATUS dcerpc_wbint_GetNssInfo_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    1884             : {
    1885       47040 :         struct dcerpc_wbint_GetNssInfo_r_state *state =
    1886       47910 :                 tevent_req_data(req,
    1887             :                 struct dcerpc_wbint_GetNssInfo_r_state);
    1888             :         NTSTATUS status;
    1889             : 
    1890       47910 :         if (tevent_req_is_nterror(req, &status)) {
    1891           0 :                 tevent_req_received(req);
    1892           0 :                 return status;
    1893             :         }
    1894             : 
    1895       47910 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    1896             : 
    1897       47910 :         tevent_req_received(req);
    1898       47910 :         return NT_STATUS_OK;
    1899             : }
    1900             : 
    1901           0 : NTSTATUS dcerpc_wbint_GetNssInfo_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wbint_GetNssInfo *r)
    1902             : {
    1903             :         NTSTATUS status;
    1904             : 
    1905           0 :         status = dcerpc_binding_handle_call(h,
    1906             :                         NULL, &ndr_table_winbind,
    1907             :                         NDR_WBINT_GETNSSINFO, mem_ctx, r);
    1908             : 
    1909           0 :         return status;
    1910             : }
    1911             : 
    1912             : struct dcerpc_wbint_GetNssInfo_state {
    1913             :         struct wbint_GetNssInfo orig;
    1914             :         struct wbint_GetNssInfo tmp;
    1915             :         TALLOC_CTX *out_mem_ctx;
    1916             : };
    1917             : 
    1918             : static void dcerpc_wbint_GetNssInfo_done(struct tevent_req *subreq);
    1919             : 
    1920       47910 : struct tevent_req *dcerpc_wbint_GetNssInfo_send(TALLOC_CTX *mem_ctx,
    1921             :                                                 struct tevent_context *ev,
    1922             :                                                 struct dcerpc_binding_handle *h,
    1923             :                                                 struct wbint_userinfo *_info /* [in,out] [ref] */)
    1924             : {
    1925             :         struct tevent_req *req;
    1926             :         struct dcerpc_wbint_GetNssInfo_state *state;
    1927             :         struct tevent_req *subreq;
    1928             : 
    1929       47910 :         req = tevent_req_create(mem_ctx, &state,
    1930             :                                 struct dcerpc_wbint_GetNssInfo_state);
    1931       47910 :         if (req == NULL) {
    1932           0 :                 return NULL;
    1933             :         }
    1934       47910 :         state->out_mem_ctx = NULL;
    1935             : 
    1936             :         /* In parameters */
    1937       47910 :         state->orig.in.info = _info;
    1938             : 
    1939             :         /* Out parameters */
    1940       47910 :         state->orig.out.info = _info;
    1941             : 
    1942             :         /* Result */
    1943       47910 :         NDR_ZERO_STRUCT(state->orig.out.result);
    1944             : 
    1945       47910 :         state->out_mem_ctx = talloc_named_const(state, 0,
    1946             :                              "dcerpc_wbint_GetNssInfo_out_memory");
    1947       47910 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    1948           0 :                 return tevent_req_post(req, ev);
    1949             :         }
    1950             : 
    1951             :         /* make a temporary copy, that we pass to the dispatch function */
    1952       47910 :         state->tmp = state->orig;
    1953             : 
    1954       47910 :         subreq = dcerpc_wbint_GetNssInfo_r_send(state, ev, h, &state->tmp);
    1955       47910 :         if (tevent_req_nomem(subreq, req)) {
    1956           0 :                 return tevent_req_post(req, ev);
    1957             :         }
    1958       47910 :         tevent_req_set_callback(subreq, dcerpc_wbint_GetNssInfo_done, req);
    1959       47910 :         return req;
    1960             : }
    1961             : 
    1962       47910 : static void dcerpc_wbint_GetNssInfo_done(struct tevent_req *subreq)
    1963             : {
    1964       47910 :         struct tevent_req *req = tevent_req_callback_data(
    1965             :                 subreq, struct tevent_req);
    1966       47910 :         struct dcerpc_wbint_GetNssInfo_state *state = tevent_req_data(
    1967             :                 req, struct dcerpc_wbint_GetNssInfo_state);
    1968             :         NTSTATUS status;
    1969             :         TALLOC_CTX *mem_ctx;
    1970             : 
    1971       47910 :         if (state->out_mem_ctx) {
    1972       47910 :                 mem_ctx = state->out_mem_ctx;
    1973             :         } else {
    1974           0 :                 mem_ctx = state;
    1975             :         }
    1976             : 
    1977       47910 :         status = dcerpc_wbint_GetNssInfo_r_recv(subreq, mem_ctx);
    1978       47910 :         TALLOC_FREE(subreq);
    1979       47910 :         if (tevent_req_nterror(req, status)) {
    1980           0 :                 return;
    1981             :         }
    1982             : 
    1983             :         /* Copy out parameters */
    1984       47910 :         *state->orig.out.info = *state->tmp.out.info;
    1985             : 
    1986             :         /* Copy result */
    1987       47910 :         state->orig.out.result = state->tmp.out.result;
    1988             : 
    1989             :         /* Reset temporary structure */
    1990       47910 :         NDR_ZERO_STRUCT(state->tmp);
    1991             : 
    1992       47910 :         tevent_req_done(req);
    1993             : }
    1994             : 
    1995       47910 : NTSTATUS dcerpc_wbint_GetNssInfo_recv(struct tevent_req *req,
    1996             :                                       TALLOC_CTX *mem_ctx,
    1997             :                                       NTSTATUS *result)
    1998             : {
    1999       47910 :         struct dcerpc_wbint_GetNssInfo_state *state = tevent_req_data(
    2000             :                 req, struct dcerpc_wbint_GetNssInfo_state);
    2001             :         NTSTATUS status;
    2002             : 
    2003       47910 :         if (tevent_req_is_nterror(req, &status)) {
    2004           0 :                 tevent_req_received(req);
    2005           0 :                 return status;
    2006             :         }
    2007             : 
    2008             :         /* Steal possible out parameters to the callers context */
    2009       47910 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    2010             : 
    2011             :         /* Return result */
    2012       47910 :         *result = state->orig.out.result;
    2013             : 
    2014       47910 :         tevent_req_received(req);
    2015       47910 :         return NT_STATUS_OK;
    2016             : }
    2017             : 
    2018           0 : NTSTATUS dcerpc_wbint_GetNssInfo(struct dcerpc_binding_handle *h,
    2019             :                                  TALLOC_CTX *mem_ctx,
    2020             :                                  struct wbint_userinfo *_info /* [in,out] [ref] */,
    2021             :                                  NTSTATUS *result)
    2022             : {
    2023             :         struct wbint_GetNssInfo r;
    2024             :         NTSTATUS status;
    2025             : 
    2026             :         /* In parameters */
    2027           0 :         r.in.info = _info;
    2028             : 
    2029             :         /* Out parameters */
    2030           0 :         r.out.info = _info;
    2031             : 
    2032             :         /* Result */
    2033           0 :         NDR_ZERO_STRUCT(r.out.result);
    2034             : 
    2035           0 :         status = dcerpc_wbint_GetNssInfo_r(h, mem_ctx, &r);
    2036           0 :         if (!NT_STATUS_IS_OK(status)) {
    2037           0 :                 return status;
    2038             :         }
    2039             : 
    2040             :         /* Return variables */
    2041           0 :         *_info = *r.out.info;
    2042             : 
    2043             :         /* Return result */
    2044           0 :         *result = r.out.result;
    2045             : 
    2046           0 :         return NT_STATUS_OK;
    2047             : }
    2048             : 
    2049             : struct dcerpc_wbint_LookupUserAliases_r_state {
    2050             :         TALLOC_CTX *out_mem_ctx;
    2051             : };
    2052             : 
    2053             : static void dcerpc_wbint_LookupUserAliases_r_done(struct tevent_req *subreq);
    2054             : 
    2055        4495 : struct tevent_req *dcerpc_wbint_LookupUserAliases_r_send(TALLOC_CTX *mem_ctx,
    2056             :         struct tevent_context *ev,
    2057             :         struct dcerpc_binding_handle *h,
    2058             :         struct wbint_LookupUserAliases *r)
    2059             : {
    2060             :         struct tevent_req *req;
    2061             :         struct dcerpc_wbint_LookupUserAliases_r_state *state;
    2062             :         struct tevent_req *subreq;
    2063             : 
    2064        4495 :         req = tevent_req_create(mem_ctx, &state,
    2065             :                                 struct dcerpc_wbint_LookupUserAliases_r_state);
    2066        4495 :         if (req == NULL) {
    2067           0 :                 return NULL;
    2068             :         }
    2069             : 
    2070        4495 :         state->out_mem_ctx = talloc_new(state);
    2071        4495 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    2072           0 :                 return tevent_req_post(req, ev);
    2073             :         }
    2074             : 
    2075        4495 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    2076             :                         NULL, &ndr_table_winbind,
    2077        4495 :                         NDR_WBINT_LOOKUPUSERALIASES, state->out_mem_ctx, r);
    2078        4495 :         if (tevent_req_nomem(subreq, req)) {
    2079           0 :                 return tevent_req_post(req, ev);
    2080             :         }
    2081        4495 :         tevent_req_set_callback(subreq, dcerpc_wbint_LookupUserAliases_r_done, req);
    2082             : 
    2083        4495 :         return req;
    2084             : }
    2085             : 
    2086        4495 : static void dcerpc_wbint_LookupUserAliases_r_done(struct tevent_req *subreq)
    2087             : {
    2088        4421 :         struct tevent_req *req =
    2089        4495 :                 tevent_req_callback_data(subreq,
    2090             :                 struct tevent_req);
    2091             :         NTSTATUS status;
    2092             : 
    2093        4495 :         status = dcerpc_binding_handle_call_recv(subreq);
    2094        4495 :         TALLOC_FREE(subreq);
    2095        4495 :         if (tevent_req_nterror(req, status)) {
    2096           0 :                 return;
    2097             :         }
    2098             : 
    2099        4495 :         tevent_req_done(req);
    2100             : }
    2101             : 
    2102        4495 : NTSTATUS dcerpc_wbint_LookupUserAliases_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    2103             : {
    2104        4421 :         struct dcerpc_wbint_LookupUserAliases_r_state *state =
    2105        4495 :                 tevent_req_data(req,
    2106             :                 struct dcerpc_wbint_LookupUserAliases_r_state);
    2107             :         NTSTATUS status;
    2108             : 
    2109        4495 :         if (tevent_req_is_nterror(req, &status)) {
    2110           0 :                 tevent_req_received(req);
    2111           0 :                 return status;
    2112             :         }
    2113             : 
    2114        4495 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    2115             : 
    2116        4495 :         tevent_req_received(req);
    2117        4495 :         return NT_STATUS_OK;
    2118             : }
    2119             : 
    2120           0 : NTSTATUS dcerpc_wbint_LookupUserAliases_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wbint_LookupUserAliases *r)
    2121             : {
    2122             :         NTSTATUS status;
    2123             : 
    2124           0 :         status = dcerpc_binding_handle_call(h,
    2125             :                         NULL, &ndr_table_winbind,
    2126             :                         NDR_WBINT_LOOKUPUSERALIASES, mem_ctx, r);
    2127             : 
    2128           0 :         return status;
    2129             : }
    2130             : 
    2131             : struct dcerpc_wbint_LookupUserAliases_state {
    2132             :         struct wbint_LookupUserAliases orig;
    2133             :         struct wbint_LookupUserAliases tmp;
    2134             :         TALLOC_CTX *out_mem_ctx;
    2135             : };
    2136             : 
    2137             : static void dcerpc_wbint_LookupUserAliases_done(struct tevent_req *subreq);
    2138             : 
    2139        4495 : struct tevent_req *dcerpc_wbint_LookupUserAliases_send(TALLOC_CTX *mem_ctx,
    2140             :                                                        struct tevent_context *ev,
    2141             :                                                        struct dcerpc_binding_handle *h,
    2142             :                                                        struct wbint_SidArray *_sids /* [in] [ref] */,
    2143             :                                                        struct wbint_RidArray *_rids /* [out] [ref] */)
    2144             : {
    2145             :         struct tevent_req *req;
    2146             :         struct dcerpc_wbint_LookupUserAliases_state *state;
    2147             :         struct tevent_req *subreq;
    2148             : 
    2149        4495 :         req = tevent_req_create(mem_ctx, &state,
    2150             :                                 struct dcerpc_wbint_LookupUserAliases_state);
    2151        4495 :         if (req == NULL) {
    2152           0 :                 return NULL;
    2153             :         }
    2154        4495 :         state->out_mem_ctx = NULL;
    2155             : 
    2156             :         /* In parameters */
    2157        4495 :         state->orig.in.sids = _sids;
    2158             : 
    2159             :         /* Out parameters */
    2160        4495 :         state->orig.out.rids = _rids;
    2161             : 
    2162             :         /* Result */
    2163        4495 :         NDR_ZERO_STRUCT(state->orig.out.result);
    2164             : 
    2165        4495 :         state->out_mem_ctx = talloc_named_const(state, 0,
    2166             :                              "dcerpc_wbint_LookupUserAliases_out_memory");
    2167        4495 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    2168           0 :                 return tevent_req_post(req, ev);
    2169             :         }
    2170             : 
    2171             :         /* make a temporary copy, that we pass to the dispatch function */
    2172        4495 :         state->tmp = state->orig;
    2173             : 
    2174        4495 :         subreq = dcerpc_wbint_LookupUserAliases_r_send(state, ev, h, &state->tmp);
    2175        4495 :         if (tevent_req_nomem(subreq, req)) {
    2176           0 :                 return tevent_req_post(req, ev);
    2177             :         }
    2178        4495 :         tevent_req_set_callback(subreq, dcerpc_wbint_LookupUserAliases_done, req);
    2179        4495 :         return req;
    2180             : }
    2181             : 
    2182        4495 : static void dcerpc_wbint_LookupUserAliases_done(struct tevent_req *subreq)
    2183             : {
    2184        4495 :         struct tevent_req *req = tevent_req_callback_data(
    2185             :                 subreq, struct tevent_req);
    2186        4495 :         struct dcerpc_wbint_LookupUserAliases_state *state = tevent_req_data(
    2187             :                 req, struct dcerpc_wbint_LookupUserAliases_state);
    2188             :         NTSTATUS status;
    2189             :         TALLOC_CTX *mem_ctx;
    2190             : 
    2191        4495 :         if (state->out_mem_ctx) {
    2192        4495 :                 mem_ctx = state->out_mem_ctx;
    2193             :         } else {
    2194           0 :                 mem_ctx = state;
    2195             :         }
    2196             : 
    2197        4495 :         status = dcerpc_wbint_LookupUserAliases_r_recv(subreq, mem_ctx);
    2198        4495 :         TALLOC_FREE(subreq);
    2199        4495 :         if (tevent_req_nterror(req, status)) {
    2200           0 :                 return;
    2201             :         }
    2202             : 
    2203             :         /* Copy out parameters */
    2204        4495 :         *state->orig.out.rids = *state->tmp.out.rids;
    2205             : 
    2206             :         /* Copy result */
    2207        4495 :         state->orig.out.result = state->tmp.out.result;
    2208             : 
    2209             :         /* Reset temporary structure */
    2210        4495 :         NDR_ZERO_STRUCT(state->tmp);
    2211             : 
    2212        4495 :         tevent_req_done(req);
    2213             : }
    2214             : 
    2215        4495 : NTSTATUS dcerpc_wbint_LookupUserAliases_recv(struct tevent_req *req,
    2216             :                                              TALLOC_CTX *mem_ctx,
    2217             :                                              NTSTATUS *result)
    2218             : {
    2219        4495 :         struct dcerpc_wbint_LookupUserAliases_state *state = tevent_req_data(
    2220             :                 req, struct dcerpc_wbint_LookupUserAliases_state);
    2221             :         NTSTATUS status;
    2222             : 
    2223        4495 :         if (tevent_req_is_nterror(req, &status)) {
    2224           0 :                 tevent_req_received(req);
    2225           0 :                 return status;
    2226             :         }
    2227             : 
    2228             :         /* Steal possible out parameters to the callers context */
    2229        4495 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    2230             : 
    2231             :         /* Return result */
    2232        4495 :         *result = state->orig.out.result;
    2233             : 
    2234        4495 :         tevent_req_received(req);
    2235        4495 :         return NT_STATUS_OK;
    2236             : }
    2237             : 
    2238           0 : NTSTATUS dcerpc_wbint_LookupUserAliases(struct dcerpc_binding_handle *h,
    2239             :                                         TALLOC_CTX *mem_ctx,
    2240             :                                         struct wbint_SidArray *_sids /* [in] [ref] */,
    2241             :                                         struct wbint_RidArray *_rids /* [out] [ref] */,
    2242             :                                         NTSTATUS *result)
    2243             : {
    2244             :         struct wbint_LookupUserAliases r;
    2245             :         NTSTATUS status;
    2246             : 
    2247             :         /* In parameters */
    2248           0 :         r.in.sids = _sids;
    2249             : 
    2250             :         /* Out parameters */
    2251           0 :         r.out.rids = _rids;
    2252             : 
    2253             :         /* Result */
    2254           0 :         NDR_ZERO_STRUCT(r.out.result);
    2255             : 
    2256           0 :         status = dcerpc_wbint_LookupUserAliases_r(h, mem_ctx, &r);
    2257           0 :         if (!NT_STATUS_IS_OK(status)) {
    2258           0 :                 return status;
    2259             :         }
    2260             : 
    2261             :         /* Return variables */
    2262           0 :         *_rids = *r.out.rids;
    2263             : 
    2264             :         /* Return result */
    2265           0 :         *result = r.out.result;
    2266             : 
    2267           0 :         return NT_STATUS_OK;
    2268             : }
    2269             : 
    2270             : struct dcerpc_wbint_LookupUserGroups_r_state {
    2271             :         TALLOC_CTX *out_mem_ctx;
    2272             : };
    2273             : 
    2274             : static void dcerpc_wbint_LookupUserGroups_r_done(struct tevent_req *subreq);
    2275             : 
    2276        2395 : struct tevent_req *dcerpc_wbint_LookupUserGroups_r_send(TALLOC_CTX *mem_ctx,
    2277             :         struct tevent_context *ev,
    2278             :         struct dcerpc_binding_handle *h,
    2279             :         struct wbint_LookupUserGroups *r)
    2280             : {
    2281             :         struct tevent_req *req;
    2282             :         struct dcerpc_wbint_LookupUserGroups_r_state *state;
    2283             :         struct tevent_req *subreq;
    2284             : 
    2285        2395 :         req = tevent_req_create(mem_ctx, &state,
    2286             :                                 struct dcerpc_wbint_LookupUserGroups_r_state);
    2287        2395 :         if (req == NULL) {
    2288           0 :                 return NULL;
    2289             :         }
    2290             : 
    2291        2395 :         state->out_mem_ctx = talloc_new(state);
    2292        2395 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    2293           0 :                 return tevent_req_post(req, ev);
    2294             :         }
    2295             : 
    2296        2395 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    2297             :                         NULL, &ndr_table_winbind,
    2298        2395 :                         NDR_WBINT_LOOKUPUSERGROUPS, state->out_mem_ctx, r);
    2299        2395 :         if (tevent_req_nomem(subreq, req)) {
    2300           0 :                 return tevent_req_post(req, ev);
    2301             :         }
    2302        2395 :         tevent_req_set_callback(subreq, dcerpc_wbint_LookupUserGroups_r_done, req);
    2303             : 
    2304        2395 :         return req;
    2305             : }
    2306             : 
    2307        2395 : static void dcerpc_wbint_LookupUserGroups_r_done(struct tevent_req *subreq)
    2308             : {
    2309        2383 :         struct tevent_req *req =
    2310        2395 :                 tevent_req_callback_data(subreq,
    2311             :                 struct tevent_req);
    2312             :         NTSTATUS status;
    2313             : 
    2314        2395 :         status = dcerpc_binding_handle_call_recv(subreq);
    2315        2395 :         TALLOC_FREE(subreq);
    2316        2395 :         if (tevent_req_nterror(req, status)) {
    2317           0 :                 return;
    2318             :         }
    2319             : 
    2320        2395 :         tevent_req_done(req);
    2321             : }
    2322             : 
    2323        2395 : NTSTATUS dcerpc_wbint_LookupUserGroups_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    2324             : {
    2325        2383 :         struct dcerpc_wbint_LookupUserGroups_r_state *state =
    2326        2395 :                 tevent_req_data(req,
    2327             :                 struct dcerpc_wbint_LookupUserGroups_r_state);
    2328             :         NTSTATUS status;
    2329             : 
    2330        2395 :         if (tevent_req_is_nterror(req, &status)) {
    2331           0 :                 tevent_req_received(req);
    2332           0 :                 return status;
    2333             :         }
    2334             : 
    2335        2395 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    2336             : 
    2337        2395 :         tevent_req_received(req);
    2338        2395 :         return NT_STATUS_OK;
    2339             : }
    2340             : 
    2341           0 : NTSTATUS dcerpc_wbint_LookupUserGroups_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wbint_LookupUserGroups *r)
    2342             : {
    2343             :         NTSTATUS status;
    2344             : 
    2345           0 :         status = dcerpc_binding_handle_call(h,
    2346             :                         NULL, &ndr_table_winbind,
    2347             :                         NDR_WBINT_LOOKUPUSERGROUPS, mem_ctx, r);
    2348             : 
    2349           0 :         return status;
    2350             : }
    2351             : 
    2352             : struct dcerpc_wbint_LookupUserGroups_state {
    2353             :         struct wbint_LookupUserGroups orig;
    2354             :         struct wbint_LookupUserGroups tmp;
    2355             :         TALLOC_CTX *out_mem_ctx;
    2356             : };
    2357             : 
    2358             : static void dcerpc_wbint_LookupUserGroups_done(struct tevent_req *subreq);
    2359             : 
    2360        2395 : struct tevent_req *dcerpc_wbint_LookupUserGroups_send(TALLOC_CTX *mem_ctx,
    2361             :                                                       struct tevent_context *ev,
    2362             :                                                       struct dcerpc_binding_handle *h,
    2363             :                                                       struct dom_sid *_sid /* [in] [ref] */,
    2364             :                                                       struct wbint_SidArray *_sids /* [out] [ref] */)
    2365             : {
    2366             :         struct tevent_req *req;
    2367             :         struct dcerpc_wbint_LookupUserGroups_state *state;
    2368             :         struct tevent_req *subreq;
    2369             : 
    2370        2395 :         req = tevent_req_create(mem_ctx, &state,
    2371             :                                 struct dcerpc_wbint_LookupUserGroups_state);
    2372        2395 :         if (req == NULL) {
    2373           0 :                 return NULL;
    2374             :         }
    2375        2395 :         state->out_mem_ctx = NULL;
    2376             : 
    2377             :         /* In parameters */
    2378        2395 :         state->orig.in.sid = _sid;
    2379             : 
    2380             :         /* Out parameters */
    2381        2395 :         state->orig.out.sids = _sids;
    2382             : 
    2383             :         /* Result */
    2384        2395 :         NDR_ZERO_STRUCT(state->orig.out.result);
    2385             : 
    2386        2395 :         state->out_mem_ctx = talloc_named_const(state, 0,
    2387             :                              "dcerpc_wbint_LookupUserGroups_out_memory");
    2388        2395 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    2389           0 :                 return tevent_req_post(req, ev);
    2390             :         }
    2391             : 
    2392             :         /* make a temporary copy, that we pass to the dispatch function */
    2393        2395 :         state->tmp = state->orig;
    2394             : 
    2395        2395 :         subreq = dcerpc_wbint_LookupUserGroups_r_send(state, ev, h, &state->tmp);
    2396        2395 :         if (tevent_req_nomem(subreq, req)) {
    2397           0 :                 return tevent_req_post(req, ev);
    2398             :         }
    2399        2395 :         tevent_req_set_callback(subreq, dcerpc_wbint_LookupUserGroups_done, req);
    2400        2395 :         return req;
    2401             : }
    2402             : 
    2403        2395 : static void dcerpc_wbint_LookupUserGroups_done(struct tevent_req *subreq)
    2404             : {
    2405        2395 :         struct tevent_req *req = tevent_req_callback_data(
    2406             :                 subreq, struct tevent_req);
    2407        2395 :         struct dcerpc_wbint_LookupUserGroups_state *state = tevent_req_data(
    2408             :                 req, struct dcerpc_wbint_LookupUserGroups_state);
    2409             :         NTSTATUS status;
    2410             :         TALLOC_CTX *mem_ctx;
    2411             : 
    2412        2395 :         if (state->out_mem_ctx) {
    2413        2395 :                 mem_ctx = state->out_mem_ctx;
    2414             :         } else {
    2415           0 :                 mem_ctx = state;
    2416             :         }
    2417             : 
    2418        2395 :         status = dcerpc_wbint_LookupUserGroups_r_recv(subreq, mem_ctx);
    2419        2395 :         TALLOC_FREE(subreq);
    2420        2395 :         if (tevent_req_nterror(req, status)) {
    2421           0 :                 return;
    2422             :         }
    2423             : 
    2424             :         /* Copy out parameters */
    2425        2395 :         *state->orig.out.sids = *state->tmp.out.sids;
    2426             : 
    2427             :         /* Copy result */
    2428        2395 :         state->orig.out.result = state->tmp.out.result;
    2429             : 
    2430             :         /* Reset temporary structure */
    2431        2395 :         NDR_ZERO_STRUCT(state->tmp);
    2432             : 
    2433        2395 :         tevent_req_done(req);
    2434             : }
    2435             : 
    2436        2395 : NTSTATUS dcerpc_wbint_LookupUserGroups_recv(struct tevent_req *req,
    2437             :                                             TALLOC_CTX *mem_ctx,
    2438             :                                             NTSTATUS *result)
    2439             : {
    2440        2395 :         struct dcerpc_wbint_LookupUserGroups_state *state = tevent_req_data(
    2441             :                 req, struct dcerpc_wbint_LookupUserGroups_state);
    2442             :         NTSTATUS status;
    2443             : 
    2444        2395 :         if (tevent_req_is_nterror(req, &status)) {
    2445           0 :                 tevent_req_received(req);
    2446           0 :                 return status;
    2447             :         }
    2448             : 
    2449             :         /* Steal possible out parameters to the callers context */
    2450        2395 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    2451             : 
    2452             :         /* Return result */
    2453        2395 :         *result = state->orig.out.result;
    2454             : 
    2455        2395 :         tevent_req_received(req);
    2456        2395 :         return NT_STATUS_OK;
    2457             : }
    2458             : 
    2459           0 : NTSTATUS dcerpc_wbint_LookupUserGroups(struct dcerpc_binding_handle *h,
    2460             :                                        TALLOC_CTX *mem_ctx,
    2461             :                                        struct dom_sid *_sid /* [in] [ref] */,
    2462             :                                        struct wbint_SidArray *_sids /* [out] [ref] */,
    2463             :                                        NTSTATUS *result)
    2464             : {
    2465             :         struct wbint_LookupUserGroups r;
    2466             :         NTSTATUS status;
    2467             : 
    2468             :         /* In parameters */
    2469           0 :         r.in.sid = _sid;
    2470             : 
    2471             :         /* Out parameters */
    2472           0 :         r.out.sids = _sids;
    2473             : 
    2474             :         /* Result */
    2475           0 :         NDR_ZERO_STRUCT(r.out.result);
    2476             : 
    2477           0 :         status = dcerpc_wbint_LookupUserGroups_r(h, mem_ctx, &r);
    2478           0 :         if (!NT_STATUS_IS_OK(status)) {
    2479           0 :                 return status;
    2480             :         }
    2481             : 
    2482             :         /* Return variables */
    2483           0 :         *_sids = *r.out.sids;
    2484             : 
    2485             :         /* Return result */
    2486           0 :         *result = r.out.result;
    2487             : 
    2488           0 :         return NT_STATUS_OK;
    2489             : }
    2490             : 
    2491             : struct dcerpc_wbint_QuerySequenceNumber_r_state {
    2492             :         TALLOC_CTX *out_mem_ctx;
    2493             : };
    2494             : 
    2495             : static void dcerpc_wbint_QuerySequenceNumber_r_done(struct tevent_req *subreq);
    2496             : 
    2497          36 : struct tevent_req *dcerpc_wbint_QuerySequenceNumber_r_send(TALLOC_CTX *mem_ctx,
    2498             :         struct tevent_context *ev,
    2499             :         struct dcerpc_binding_handle *h,
    2500             :         struct wbint_QuerySequenceNumber *r)
    2501             : {
    2502             :         struct tevent_req *req;
    2503             :         struct dcerpc_wbint_QuerySequenceNumber_r_state *state;
    2504             :         struct tevent_req *subreq;
    2505             : 
    2506          36 :         req = tevent_req_create(mem_ctx, &state,
    2507             :                                 struct dcerpc_wbint_QuerySequenceNumber_r_state);
    2508          36 :         if (req == NULL) {
    2509           0 :                 return NULL;
    2510             :         }
    2511             : 
    2512          36 :         state->out_mem_ctx = talloc_new(state);
    2513          36 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    2514           0 :                 return tevent_req_post(req, ev);
    2515             :         }
    2516             : 
    2517          36 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    2518             :                         NULL, &ndr_table_winbind,
    2519          36 :                         NDR_WBINT_QUERYSEQUENCENUMBER, state->out_mem_ctx, r);
    2520          36 :         if (tevent_req_nomem(subreq, req)) {
    2521           0 :                 return tevent_req_post(req, ev);
    2522             :         }
    2523          36 :         tevent_req_set_callback(subreq, dcerpc_wbint_QuerySequenceNumber_r_done, req);
    2524             : 
    2525          36 :         return req;
    2526             : }
    2527             : 
    2528          36 : static void dcerpc_wbint_QuerySequenceNumber_r_done(struct tevent_req *subreq)
    2529             : {
    2530          26 :         struct tevent_req *req =
    2531          36 :                 tevent_req_callback_data(subreq,
    2532             :                 struct tevent_req);
    2533             :         NTSTATUS status;
    2534             : 
    2535          36 :         status = dcerpc_binding_handle_call_recv(subreq);
    2536          36 :         TALLOC_FREE(subreq);
    2537          36 :         if (tevent_req_nterror(req, status)) {
    2538           0 :                 return;
    2539             :         }
    2540             : 
    2541          36 :         tevent_req_done(req);
    2542             : }
    2543             : 
    2544          36 : NTSTATUS dcerpc_wbint_QuerySequenceNumber_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    2545             : {
    2546          26 :         struct dcerpc_wbint_QuerySequenceNumber_r_state *state =
    2547          36 :                 tevent_req_data(req,
    2548             :                 struct dcerpc_wbint_QuerySequenceNumber_r_state);
    2549             :         NTSTATUS status;
    2550             : 
    2551          36 :         if (tevent_req_is_nterror(req, &status)) {
    2552           0 :                 tevent_req_received(req);
    2553           0 :                 return status;
    2554             :         }
    2555             : 
    2556          36 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    2557             : 
    2558          36 :         tevent_req_received(req);
    2559          36 :         return NT_STATUS_OK;
    2560             : }
    2561             : 
    2562           0 : NTSTATUS dcerpc_wbint_QuerySequenceNumber_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wbint_QuerySequenceNumber *r)
    2563             : {
    2564             :         NTSTATUS status;
    2565             : 
    2566           0 :         status = dcerpc_binding_handle_call(h,
    2567             :                         NULL, &ndr_table_winbind,
    2568             :                         NDR_WBINT_QUERYSEQUENCENUMBER, mem_ctx, r);
    2569             : 
    2570           0 :         return status;
    2571             : }
    2572             : 
    2573             : struct dcerpc_wbint_QuerySequenceNumber_state {
    2574             :         struct wbint_QuerySequenceNumber orig;
    2575             :         struct wbint_QuerySequenceNumber tmp;
    2576             :         TALLOC_CTX *out_mem_ctx;
    2577             : };
    2578             : 
    2579             : static void dcerpc_wbint_QuerySequenceNumber_done(struct tevent_req *subreq);
    2580             : 
    2581          36 : struct tevent_req *dcerpc_wbint_QuerySequenceNumber_send(TALLOC_CTX *mem_ctx,
    2582             :                                                          struct tevent_context *ev,
    2583             :                                                          struct dcerpc_binding_handle *h,
    2584             :                                                          uint32_t *_sequence /* [out] [ref] */)
    2585             : {
    2586             :         struct tevent_req *req;
    2587             :         struct dcerpc_wbint_QuerySequenceNumber_state *state;
    2588             :         struct tevent_req *subreq;
    2589             : 
    2590          36 :         req = tevent_req_create(mem_ctx, &state,
    2591             :                                 struct dcerpc_wbint_QuerySequenceNumber_state);
    2592          36 :         if (req == NULL) {
    2593           0 :                 return NULL;
    2594             :         }
    2595          36 :         state->out_mem_ctx = NULL;
    2596             : 
    2597             :         /* In parameters */
    2598             : 
    2599             :         /* Out parameters */
    2600          36 :         state->orig.out.sequence = _sequence;
    2601             : 
    2602             :         /* Result */
    2603          36 :         NDR_ZERO_STRUCT(state->orig.out.result);
    2604             : 
    2605          36 :         state->out_mem_ctx = talloc_named_const(state, 0,
    2606             :                              "dcerpc_wbint_QuerySequenceNumber_out_memory");
    2607          36 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    2608           0 :                 return tevent_req_post(req, ev);
    2609             :         }
    2610             : 
    2611             :         /* make a temporary copy, that we pass to the dispatch function */
    2612          36 :         state->tmp = state->orig;
    2613             : 
    2614          36 :         subreq = dcerpc_wbint_QuerySequenceNumber_r_send(state, ev, h, &state->tmp);
    2615          36 :         if (tevent_req_nomem(subreq, req)) {
    2616           0 :                 return tevent_req_post(req, ev);
    2617             :         }
    2618          36 :         tevent_req_set_callback(subreq, dcerpc_wbint_QuerySequenceNumber_done, req);
    2619          36 :         return req;
    2620             : }
    2621             : 
    2622          36 : static void dcerpc_wbint_QuerySequenceNumber_done(struct tevent_req *subreq)
    2623             : {
    2624          36 :         struct tevent_req *req = tevent_req_callback_data(
    2625             :                 subreq, struct tevent_req);
    2626          36 :         struct dcerpc_wbint_QuerySequenceNumber_state *state = tevent_req_data(
    2627             :                 req, struct dcerpc_wbint_QuerySequenceNumber_state);
    2628             :         NTSTATUS status;
    2629             :         TALLOC_CTX *mem_ctx;
    2630             : 
    2631          36 :         if (state->out_mem_ctx) {
    2632          36 :                 mem_ctx = state->out_mem_ctx;
    2633             :         } else {
    2634           0 :                 mem_ctx = state;
    2635             :         }
    2636             : 
    2637          36 :         status = dcerpc_wbint_QuerySequenceNumber_r_recv(subreq, mem_ctx);
    2638          36 :         TALLOC_FREE(subreq);
    2639          36 :         if (tevent_req_nterror(req, status)) {
    2640           0 :                 return;
    2641             :         }
    2642             : 
    2643             :         /* Copy out parameters */
    2644          36 :         *state->orig.out.sequence = *state->tmp.out.sequence;
    2645             : 
    2646             :         /* Copy result */
    2647          36 :         state->orig.out.result = state->tmp.out.result;
    2648             : 
    2649             :         /* Reset temporary structure */
    2650          36 :         NDR_ZERO_STRUCT(state->tmp);
    2651             : 
    2652          36 :         tevent_req_done(req);
    2653             : }
    2654             : 
    2655          36 : NTSTATUS dcerpc_wbint_QuerySequenceNumber_recv(struct tevent_req *req,
    2656             :                                                TALLOC_CTX *mem_ctx,
    2657             :                                                NTSTATUS *result)
    2658             : {
    2659          36 :         struct dcerpc_wbint_QuerySequenceNumber_state *state = tevent_req_data(
    2660             :                 req, struct dcerpc_wbint_QuerySequenceNumber_state);
    2661             :         NTSTATUS status;
    2662             : 
    2663          36 :         if (tevent_req_is_nterror(req, &status)) {
    2664           0 :                 tevent_req_received(req);
    2665           0 :                 return status;
    2666             :         }
    2667             : 
    2668             :         /* Steal possible out parameters to the callers context */
    2669          36 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    2670             : 
    2671             :         /* Return result */
    2672          36 :         *result = state->orig.out.result;
    2673             : 
    2674          36 :         tevent_req_received(req);
    2675          36 :         return NT_STATUS_OK;
    2676             : }
    2677             : 
    2678           0 : NTSTATUS dcerpc_wbint_QuerySequenceNumber(struct dcerpc_binding_handle *h,
    2679             :                                           TALLOC_CTX *mem_ctx,
    2680             :                                           uint32_t *_sequence /* [out] [ref] */,
    2681             :                                           NTSTATUS *result)
    2682             : {
    2683             :         struct wbint_QuerySequenceNumber r;
    2684             :         NTSTATUS status;
    2685             : 
    2686             :         /* In parameters */
    2687             : 
    2688             :         /* Out parameters */
    2689           0 :         r.out.sequence = _sequence;
    2690             : 
    2691             :         /* Result */
    2692           0 :         NDR_ZERO_STRUCT(r.out.result);
    2693             : 
    2694           0 :         status = dcerpc_wbint_QuerySequenceNumber_r(h, mem_ctx, &r);
    2695           0 :         if (!NT_STATUS_IS_OK(status)) {
    2696           0 :                 return status;
    2697             :         }
    2698             : 
    2699             :         /* Return variables */
    2700           0 :         *_sequence = *r.out.sequence;
    2701             : 
    2702             :         /* Return result */
    2703           0 :         *result = r.out.result;
    2704             : 
    2705           0 :         return NT_STATUS_OK;
    2706             : }
    2707             : 
    2708             : struct dcerpc_wbint_LookupGroupMembers_r_state {
    2709             :         TALLOC_CTX *out_mem_ctx;
    2710             : };
    2711             : 
    2712             : static void dcerpc_wbint_LookupGroupMembers_r_done(struct tevent_req *subreq);
    2713             : 
    2714           0 : struct tevent_req *dcerpc_wbint_LookupGroupMembers_r_send(TALLOC_CTX *mem_ctx,
    2715             :         struct tevent_context *ev,
    2716             :         struct dcerpc_binding_handle *h,
    2717             :         struct wbint_LookupGroupMembers *r)
    2718             : {
    2719             :         struct tevent_req *req;
    2720             :         struct dcerpc_wbint_LookupGroupMembers_r_state *state;
    2721             :         struct tevent_req *subreq;
    2722             : 
    2723           0 :         req = tevent_req_create(mem_ctx, &state,
    2724             :                                 struct dcerpc_wbint_LookupGroupMembers_r_state);
    2725           0 :         if (req == NULL) {
    2726           0 :                 return NULL;
    2727             :         }
    2728             : 
    2729           0 :         state->out_mem_ctx = talloc_new(state);
    2730           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    2731           0 :                 return tevent_req_post(req, ev);
    2732             :         }
    2733             : 
    2734           0 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    2735             :                         NULL, &ndr_table_winbind,
    2736           0 :                         NDR_WBINT_LOOKUPGROUPMEMBERS, state->out_mem_ctx, r);
    2737           0 :         if (tevent_req_nomem(subreq, req)) {
    2738           0 :                 return tevent_req_post(req, ev);
    2739             :         }
    2740           0 :         tevent_req_set_callback(subreq, dcerpc_wbint_LookupGroupMembers_r_done, req);
    2741             : 
    2742           0 :         return req;
    2743             : }
    2744             : 
    2745           0 : static void dcerpc_wbint_LookupGroupMembers_r_done(struct tevent_req *subreq)
    2746             : {
    2747           0 :         struct tevent_req *req =
    2748           0 :                 tevent_req_callback_data(subreq,
    2749             :                 struct tevent_req);
    2750             :         NTSTATUS status;
    2751             : 
    2752           0 :         status = dcerpc_binding_handle_call_recv(subreq);
    2753           0 :         TALLOC_FREE(subreq);
    2754           0 :         if (tevent_req_nterror(req, status)) {
    2755           0 :                 return;
    2756             :         }
    2757             : 
    2758           0 :         tevent_req_done(req);
    2759             : }
    2760             : 
    2761           0 : NTSTATUS dcerpc_wbint_LookupGroupMembers_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    2762             : {
    2763           0 :         struct dcerpc_wbint_LookupGroupMembers_r_state *state =
    2764           0 :                 tevent_req_data(req,
    2765             :                 struct dcerpc_wbint_LookupGroupMembers_r_state);
    2766             :         NTSTATUS status;
    2767             : 
    2768           0 :         if (tevent_req_is_nterror(req, &status)) {
    2769           0 :                 tevent_req_received(req);
    2770           0 :                 return status;
    2771             :         }
    2772             : 
    2773           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    2774             : 
    2775           0 :         tevent_req_received(req);
    2776           0 :         return NT_STATUS_OK;
    2777             : }
    2778             : 
    2779           0 : NTSTATUS dcerpc_wbint_LookupGroupMembers_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wbint_LookupGroupMembers *r)
    2780             : {
    2781             :         NTSTATUS status;
    2782             : 
    2783           0 :         status = dcerpc_binding_handle_call(h,
    2784             :                         NULL, &ndr_table_winbind,
    2785             :                         NDR_WBINT_LOOKUPGROUPMEMBERS, mem_ctx, r);
    2786             : 
    2787           0 :         return status;
    2788             : }
    2789             : 
    2790             : struct dcerpc_wbint_LookupGroupMembers_state {
    2791             :         struct wbint_LookupGroupMembers orig;
    2792             :         struct wbint_LookupGroupMembers tmp;
    2793             :         TALLOC_CTX *out_mem_ctx;
    2794             : };
    2795             : 
    2796             : static void dcerpc_wbint_LookupGroupMembers_done(struct tevent_req *subreq);
    2797             : 
    2798           0 : struct tevent_req *dcerpc_wbint_LookupGroupMembers_send(TALLOC_CTX *mem_ctx,
    2799             :                                                         struct tevent_context *ev,
    2800             :                                                         struct dcerpc_binding_handle *h,
    2801             :                                                         struct dom_sid *_sid /* [in] [ref] */,
    2802             :                                                         enum lsa_SidType _type /* [in]  */,
    2803             :                                                         struct wbint_Principals *_members /* [out] [ref] */)
    2804             : {
    2805             :         struct tevent_req *req;
    2806             :         struct dcerpc_wbint_LookupGroupMembers_state *state;
    2807             :         struct tevent_req *subreq;
    2808             : 
    2809           0 :         req = tevent_req_create(mem_ctx, &state,
    2810             :                                 struct dcerpc_wbint_LookupGroupMembers_state);
    2811           0 :         if (req == NULL) {
    2812           0 :                 return NULL;
    2813             :         }
    2814           0 :         state->out_mem_ctx = NULL;
    2815             : 
    2816             :         /* In parameters */
    2817           0 :         state->orig.in.sid = _sid;
    2818           0 :         state->orig.in.type = _type;
    2819             : 
    2820             :         /* Out parameters */
    2821           0 :         state->orig.out.members = _members;
    2822             : 
    2823             :         /* Result */
    2824           0 :         NDR_ZERO_STRUCT(state->orig.out.result);
    2825             : 
    2826           0 :         state->out_mem_ctx = talloc_named_const(state, 0,
    2827             :                              "dcerpc_wbint_LookupGroupMembers_out_memory");
    2828           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    2829           0 :                 return tevent_req_post(req, ev);
    2830             :         }
    2831             : 
    2832             :         /* make a temporary copy, that we pass to the dispatch function */
    2833           0 :         state->tmp = state->orig;
    2834             : 
    2835           0 :         subreq = dcerpc_wbint_LookupGroupMembers_r_send(state, ev, h, &state->tmp);
    2836           0 :         if (tevent_req_nomem(subreq, req)) {
    2837           0 :                 return tevent_req_post(req, ev);
    2838             :         }
    2839           0 :         tevent_req_set_callback(subreq, dcerpc_wbint_LookupGroupMembers_done, req);
    2840           0 :         return req;
    2841             : }
    2842             : 
    2843           0 : static void dcerpc_wbint_LookupGroupMembers_done(struct tevent_req *subreq)
    2844             : {
    2845           0 :         struct tevent_req *req = tevent_req_callback_data(
    2846             :                 subreq, struct tevent_req);
    2847           0 :         struct dcerpc_wbint_LookupGroupMembers_state *state = tevent_req_data(
    2848             :                 req, struct dcerpc_wbint_LookupGroupMembers_state);
    2849             :         NTSTATUS status;
    2850             :         TALLOC_CTX *mem_ctx;
    2851             : 
    2852           0 :         if (state->out_mem_ctx) {
    2853           0 :                 mem_ctx = state->out_mem_ctx;
    2854             :         } else {
    2855           0 :                 mem_ctx = state;
    2856             :         }
    2857             : 
    2858           0 :         status = dcerpc_wbint_LookupGroupMembers_r_recv(subreq, mem_ctx);
    2859           0 :         TALLOC_FREE(subreq);
    2860           0 :         if (tevent_req_nterror(req, status)) {
    2861           0 :                 return;
    2862             :         }
    2863             : 
    2864             :         /* Copy out parameters */
    2865           0 :         *state->orig.out.members = *state->tmp.out.members;
    2866             : 
    2867             :         /* Copy result */
    2868           0 :         state->orig.out.result = state->tmp.out.result;
    2869             : 
    2870             :         /* Reset temporary structure */
    2871           0 :         NDR_ZERO_STRUCT(state->tmp);
    2872             : 
    2873           0 :         tevent_req_done(req);
    2874             : }
    2875             : 
    2876           0 : NTSTATUS dcerpc_wbint_LookupGroupMembers_recv(struct tevent_req *req,
    2877             :                                               TALLOC_CTX *mem_ctx,
    2878             :                                               NTSTATUS *result)
    2879             : {
    2880           0 :         struct dcerpc_wbint_LookupGroupMembers_state *state = tevent_req_data(
    2881             :                 req, struct dcerpc_wbint_LookupGroupMembers_state);
    2882             :         NTSTATUS status;
    2883             : 
    2884           0 :         if (tevent_req_is_nterror(req, &status)) {
    2885           0 :                 tevent_req_received(req);
    2886           0 :                 return status;
    2887             :         }
    2888             : 
    2889             :         /* Steal possible out parameters to the callers context */
    2890           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    2891             : 
    2892             :         /* Return result */
    2893           0 :         *result = state->orig.out.result;
    2894             : 
    2895           0 :         tevent_req_received(req);
    2896           0 :         return NT_STATUS_OK;
    2897             : }
    2898             : 
    2899           0 : NTSTATUS dcerpc_wbint_LookupGroupMembers(struct dcerpc_binding_handle *h,
    2900             :                                          TALLOC_CTX *mem_ctx,
    2901             :                                          struct dom_sid *_sid /* [in] [ref] */,
    2902             :                                          enum lsa_SidType _type /* [in]  */,
    2903             :                                          struct wbint_Principals *_members /* [out] [ref] */,
    2904             :                                          NTSTATUS *result)
    2905             : {
    2906             :         struct wbint_LookupGroupMembers r;
    2907             :         NTSTATUS status;
    2908             : 
    2909             :         /* In parameters */
    2910           0 :         r.in.sid = _sid;
    2911           0 :         r.in.type = _type;
    2912             : 
    2913             :         /* Out parameters */
    2914           0 :         r.out.members = _members;
    2915             : 
    2916             :         /* Result */
    2917           0 :         NDR_ZERO_STRUCT(r.out.result);
    2918             : 
    2919           0 :         status = dcerpc_wbint_LookupGroupMembers_r(h, mem_ctx, &r);
    2920           0 :         if (!NT_STATUS_IS_OK(status)) {
    2921           0 :                 return status;
    2922             :         }
    2923             : 
    2924             :         /* Return variables */
    2925           0 :         *_members = *r.out.members;
    2926             : 
    2927             :         /* Return result */
    2928           0 :         *result = r.out.result;
    2929             : 
    2930           0 :         return NT_STATUS_OK;
    2931             : }
    2932             : 
    2933             : struct dcerpc_wbint_QueryGroupList_r_state {
    2934             :         TALLOC_CTX *out_mem_ctx;
    2935             : };
    2936             : 
    2937             : static void dcerpc_wbint_QueryGroupList_r_done(struct tevent_req *subreq);
    2938             : 
    2939          69 : struct tevent_req *dcerpc_wbint_QueryGroupList_r_send(TALLOC_CTX *mem_ctx,
    2940             :         struct tevent_context *ev,
    2941             :         struct dcerpc_binding_handle *h,
    2942             :         struct wbint_QueryGroupList *r)
    2943             : {
    2944             :         struct tevent_req *req;
    2945             :         struct dcerpc_wbint_QueryGroupList_r_state *state;
    2946             :         struct tevent_req *subreq;
    2947             : 
    2948          69 :         req = tevent_req_create(mem_ctx, &state,
    2949             :                                 struct dcerpc_wbint_QueryGroupList_r_state);
    2950          69 :         if (req == NULL) {
    2951           0 :                 return NULL;
    2952             :         }
    2953             : 
    2954          69 :         state->out_mem_ctx = talloc_new(state);
    2955          69 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    2956           0 :                 return tevent_req_post(req, ev);
    2957             :         }
    2958             : 
    2959          69 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    2960             :                         NULL, &ndr_table_winbind,
    2961          69 :                         NDR_WBINT_QUERYGROUPLIST, state->out_mem_ctx, r);
    2962          69 :         if (tevent_req_nomem(subreq, req)) {
    2963           0 :                 return tevent_req_post(req, ev);
    2964             :         }
    2965          69 :         tevent_req_set_callback(subreq, dcerpc_wbint_QueryGroupList_r_done, req);
    2966             : 
    2967          69 :         return req;
    2968             : }
    2969             : 
    2970          69 : static void dcerpc_wbint_QueryGroupList_r_done(struct tevent_req *subreq)
    2971             : {
    2972          53 :         struct tevent_req *req =
    2973          69 :                 tevent_req_callback_data(subreq,
    2974             :                 struct tevent_req);
    2975             :         NTSTATUS status;
    2976             : 
    2977          69 :         status = dcerpc_binding_handle_call_recv(subreq);
    2978          69 :         TALLOC_FREE(subreq);
    2979          69 :         if (tevent_req_nterror(req, status)) {
    2980           0 :                 return;
    2981             :         }
    2982             : 
    2983          69 :         tevent_req_done(req);
    2984             : }
    2985             : 
    2986          69 : NTSTATUS dcerpc_wbint_QueryGroupList_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    2987             : {
    2988          53 :         struct dcerpc_wbint_QueryGroupList_r_state *state =
    2989          69 :                 tevent_req_data(req,
    2990             :                 struct dcerpc_wbint_QueryGroupList_r_state);
    2991             :         NTSTATUS status;
    2992             : 
    2993          69 :         if (tevent_req_is_nterror(req, &status)) {
    2994           0 :                 tevent_req_received(req);
    2995           0 :                 return status;
    2996             :         }
    2997             : 
    2998          69 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    2999             : 
    3000          69 :         tevent_req_received(req);
    3001          69 :         return NT_STATUS_OK;
    3002             : }
    3003             : 
    3004           0 : NTSTATUS dcerpc_wbint_QueryGroupList_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wbint_QueryGroupList *r)
    3005             : {
    3006             :         NTSTATUS status;
    3007             : 
    3008           0 :         status = dcerpc_binding_handle_call(h,
    3009             :                         NULL, &ndr_table_winbind,
    3010             :                         NDR_WBINT_QUERYGROUPLIST, mem_ctx, r);
    3011             : 
    3012           0 :         return status;
    3013             : }
    3014             : 
    3015             : struct dcerpc_wbint_QueryGroupList_state {
    3016             :         struct wbint_QueryGroupList orig;
    3017             :         struct wbint_QueryGroupList tmp;
    3018             :         TALLOC_CTX *out_mem_ctx;
    3019             : };
    3020             : 
    3021             : static void dcerpc_wbint_QueryGroupList_done(struct tevent_req *subreq);
    3022             : 
    3023          69 : struct tevent_req *dcerpc_wbint_QueryGroupList_send(TALLOC_CTX *mem_ctx,
    3024             :                                                     struct tevent_context *ev,
    3025             :                                                     struct dcerpc_binding_handle *h,
    3026             :                                                     struct wbint_Principals *_groups /* [out] [ref] */)
    3027             : {
    3028             :         struct tevent_req *req;
    3029             :         struct dcerpc_wbint_QueryGroupList_state *state;
    3030             :         struct tevent_req *subreq;
    3031             : 
    3032          69 :         req = tevent_req_create(mem_ctx, &state,
    3033             :                                 struct dcerpc_wbint_QueryGroupList_state);
    3034          69 :         if (req == NULL) {
    3035           0 :                 return NULL;
    3036             :         }
    3037          69 :         state->out_mem_ctx = NULL;
    3038             : 
    3039             :         /* In parameters */
    3040             : 
    3041             :         /* Out parameters */
    3042          69 :         state->orig.out.groups = _groups;
    3043             : 
    3044             :         /* Result */
    3045          69 :         NDR_ZERO_STRUCT(state->orig.out.result);
    3046             : 
    3047          69 :         state->out_mem_ctx = talloc_named_const(state, 0,
    3048             :                              "dcerpc_wbint_QueryGroupList_out_memory");
    3049          69 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    3050           0 :                 return tevent_req_post(req, ev);
    3051             :         }
    3052             : 
    3053             :         /* make a temporary copy, that we pass to the dispatch function */
    3054          69 :         state->tmp = state->orig;
    3055             : 
    3056          69 :         subreq = dcerpc_wbint_QueryGroupList_r_send(state, ev, h, &state->tmp);
    3057          69 :         if (tevent_req_nomem(subreq, req)) {
    3058           0 :                 return tevent_req_post(req, ev);
    3059             :         }
    3060          69 :         tevent_req_set_callback(subreq, dcerpc_wbint_QueryGroupList_done, req);
    3061          69 :         return req;
    3062             : }
    3063             : 
    3064          69 : static void dcerpc_wbint_QueryGroupList_done(struct tevent_req *subreq)
    3065             : {
    3066          69 :         struct tevent_req *req = tevent_req_callback_data(
    3067             :                 subreq, struct tevent_req);
    3068          69 :         struct dcerpc_wbint_QueryGroupList_state *state = tevent_req_data(
    3069             :                 req, struct dcerpc_wbint_QueryGroupList_state);
    3070             :         NTSTATUS status;
    3071             :         TALLOC_CTX *mem_ctx;
    3072             : 
    3073          69 :         if (state->out_mem_ctx) {
    3074          69 :                 mem_ctx = state->out_mem_ctx;
    3075             :         } else {
    3076           0 :                 mem_ctx = state;
    3077             :         }
    3078             : 
    3079          69 :         status = dcerpc_wbint_QueryGroupList_r_recv(subreq, mem_ctx);
    3080          69 :         TALLOC_FREE(subreq);
    3081          69 :         if (tevent_req_nterror(req, status)) {
    3082           0 :                 return;
    3083             :         }
    3084             : 
    3085             :         /* Copy out parameters */
    3086          69 :         *state->orig.out.groups = *state->tmp.out.groups;
    3087             : 
    3088             :         /* Copy result */
    3089          69 :         state->orig.out.result = state->tmp.out.result;
    3090             : 
    3091             :         /* Reset temporary structure */
    3092          69 :         NDR_ZERO_STRUCT(state->tmp);
    3093             : 
    3094          69 :         tevent_req_done(req);
    3095             : }
    3096             : 
    3097          69 : NTSTATUS dcerpc_wbint_QueryGroupList_recv(struct tevent_req *req,
    3098             :                                           TALLOC_CTX *mem_ctx,
    3099             :                                           NTSTATUS *result)
    3100             : {
    3101          69 :         struct dcerpc_wbint_QueryGroupList_state *state = tevent_req_data(
    3102             :                 req, struct dcerpc_wbint_QueryGroupList_state);
    3103             :         NTSTATUS status;
    3104             : 
    3105          69 :         if (tevent_req_is_nterror(req, &status)) {
    3106           0 :                 tevent_req_received(req);
    3107           0 :                 return status;
    3108             :         }
    3109             : 
    3110             :         /* Steal possible out parameters to the callers context */
    3111          69 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    3112             : 
    3113             :         /* Return result */
    3114          69 :         *result = state->orig.out.result;
    3115             : 
    3116          69 :         tevent_req_received(req);
    3117          69 :         return NT_STATUS_OK;
    3118             : }
    3119             : 
    3120           0 : NTSTATUS dcerpc_wbint_QueryGroupList(struct dcerpc_binding_handle *h,
    3121             :                                      TALLOC_CTX *mem_ctx,
    3122             :                                      struct wbint_Principals *_groups /* [out] [ref] */,
    3123             :                                      NTSTATUS *result)
    3124             : {
    3125             :         struct wbint_QueryGroupList r;
    3126             :         NTSTATUS status;
    3127             : 
    3128             :         /* In parameters */
    3129             : 
    3130             :         /* Out parameters */
    3131           0 :         r.out.groups = _groups;
    3132             : 
    3133             :         /* Result */
    3134           0 :         NDR_ZERO_STRUCT(r.out.result);
    3135             : 
    3136           0 :         status = dcerpc_wbint_QueryGroupList_r(h, mem_ctx, &r);
    3137           0 :         if (!NT_STATUS_IS_OK(status)) {
    3138           0 :                 return status;
    3139             :         }
    3140             : 
    3141             :         /* Return variables */
    3142           0 :         *_groups = *r.out.groups;
    3143             : 
    3144             :         /* Return result */
    3145           0 :         *result = r.out.result;
    3146             : 
    3147           0 :         return NT_STATUS_OK;
    3148             : }
    3149             : 
    3150             : struct dcerpc_wbint_QueryUserRidList_r_state {
    3151             :         TALLOC_CTX *out_mem_ctx;
    3152             : };
    3153             : 
    3154             : static void dcerpc_wbint_QueryUserRidList_r_done(struct tevent_req *subreq);
    3155             : 
    3156         179 : struct tevent_req *dcerpc_wbint_QueryUserRidList_r_send(TALLOC_CTX *mem_ctx,
    3157             :         struct tevent_context *ev,
    3158             :         struct dcerpc_binding_handle *h,
    3159             :         struct wbint_QueryUserRidList *r)
    3160             : {
    3161             :         struct tevent_req *req;
    3162             :         struct dcerpc_wbint_QueryUserRidList_r_state *state;
    3163             :         struct tevent_req *subreq;
    3164             : 
    3165         179 :         req = tevent_req_create(mem_ctx, &state,
    3166             :                                 struct dcerpc_wbint_QueryUserRidList_r_state);
    3167         179 :         if (req == NULL) {
    3168           0 :                 return NULL;
    3169             :         }
    3170             : 
    3171         179 :         state->out_mem_ctx = talloc_new(state);
    3172         179 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    3173           0 :                 return tevent_req_post(req, ev);
    3174             :         }
    3175             : 
    3176         179 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    3177             :                         NULL, &ndr_table_winbind,
    3178         179 :                         NDR_WBINT_QUERYUSERRIDLIST, state->out_mem_ctx, r);
    3179         179 :         if (tevent_req_nomem(subreq, req)) {
    3180           0 :                 return tevent_req_post(req, ev);
    3181             :         }
    3182         179 :         tevent_req_set_callback(subreq, dcerpc_wbint_QueryUserRidList_r_done, req);
    3183             : 
    3184         179 :         return req;
    3185             : }
    3186             : 
    3187         179 : static void dcerpc_wbint_QueryUserRidList_r_done(struct tevent_req *subreq)
    3188             : {
    3189         141 :         struct tevent_req *req =
    3190         179 :                 tevent_req_callback_data(subreq,
    3191             :                 struct tevent_req);
    3192             :         NTSTATUS status;
    3193             : 
    3194         179 :         status = dcerpc_binding_handle_call_recv(subreq);
    3195         179 :         TALLOC_FREE(subreq);
    3196         179 :         if (tevent_req_nterror(req, status)) {
    3197           0 :                 return;
    3198             :         }
    3199             : 
    3200         179 :         tevent_req_done(req);
    3201             : }
    3202             : 
    3203         179 : NTSTATUS dcerpc_wbint_QueryUserRidList_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    3204             : {
    3205         141 :         struct dcerpc_wbint_QueryUserRidList_r_state *state =
    3206         179 :                 tevent_req_data(req,
    3207             :                 struct dcerpc_wbint_QueryUserRidList_r_state);
    3208             :         NTSTATUS status;
    3209             : 
    3210         179 :         if (tevent_req_is_nterror(req, &status)) {
    3211           0 :                 tevent_req_received(req);
    3212           0 :                 return status;
    3213             :         }
    3214             : 
    3215         179 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    3216             : 
    3217         179 :         tevent_req_received(req);
    3218         179 :         return NT_STATUS_OK;
    3219             : }
    3220             : 
    3221           0 : NTSTATUS dcerpc_wbint_QueryUserRidList_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wbint_QueryUserRidList *r)
    3222             : {
    3223             :         NTSTATUS status;
    3224             : 
    3225           0 :         status = dcerpc_binding_handle_call(h,
    3226             :                         NULL, &ndr_table_winbind,
    3227             :                         NDR_WBINT_QUERYUSERRIDLIST, mem_ctx, r);
    3228             : 
    3229           0 :         return status;
    3230             : }
    3231             : 
    3232             : struct dcerpc_wbint_QueryUserRidList_state {
    3233             :         struct wbint_QueryUserRidList orig;
    3234             :         struct wbint_QueryUserRidList tmp;
    3235             :         TALLOC_CTX *out_mem_ctx;
    3236             : };
    3237             : 
    3238             : static void dcerpc_wbint_QueryUserRidList_done(struct tevent_req *subreq);
    3239             : 
    3240         179 : struct tevent_req *dcerpc_wbint_QueryUserRidList_send(TALLOC_CTX *mem_ctx,
    3241             :                                                       struct tevent_context *ev,
    3242             :                                                       struct dcerpc_binding_handle *h,
    3243             :                                                       struct wbint_RidArray *_rids /* [out] [ref] */)
    3244             : {
    3245             :         struct tevent_req *req;
    3246             :         struct dcerpc_wbint_QueryUserRidList_state *state;
    3247             :         struct tevent_req *subreq;
    3248             : 
    3249         179 :         req = tevent_req_create(mem_ctx, &state,
    3250             :                                 struct dcerpc_wbint_QueryUserRidList_state);
    3251         179 :         if (req == NULL) {
    3252           0 :                 return NULL;
    3253             :         }
    3254         179 :         state->out_mem_ctx = NULL;
    3255             : 
    3256             :         /* In parameters */
    3257             : 
    3258             :         /* Out parameters */
    3259         179 :         state->orig.out.rids = _rids;
    3260             : 
    3261             :         /* Result */
    3262         179 :         NDR_ZERO_STRUCT(state->orig.out.result);
    3263             : 
    3264         179 :         state->out_mem_ctx = talloc_named_const(state, 0,
    3265             :                              "dcerpc_wbint_QueryUserRidList_out_memory");
    3266         179 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    3267           0 :                 return tevent_req_post(req, ev);
    3268             :         }
    3269             : 
    3270             :         /* make a temporary copy, that we pass to the dispatch function */
    3271         179 :         state->tmp = state->orig;
    3272             : 
    3273         179 :         subreq = dcerpc_wbint_QueryUserRidList_r_send(state, ev, h, &state->tmp);
    3274         179 :         if (tevent_req_nomem(subreq, req)) {
    3275           0 :                 return tevent_req_post(req, ev);
    3276             :         }
    3277         179 :         tevent_req_set_callback(subreq, dcerpc_wbint_QueryUserRidList_done, req);
    3278         179 :         return req;
    3279             : }
    3280             : 
    3281         179 : static void dcerpc_wbint_QueryUserRidList_done(struct tevent_req *subreq)
    3282             : {
    3283         179 :         struct tevent_req *req = tevent_req_callback_data(
    3284             :                 subreq, struct tevent_req);
    3285         179 :         struct dcerpc_wbint_QueryUserRidList_state *state = tevent_req_data(
    3286             :                 req, struct dcerpc_wbint_QueryUserRidList_state);
    3287             :         NTSTATUS status;
    3288             :         TALLOC_CTX *mem_ctx;
    3289             : 
    3290         179 :         if (state->out_mem_ctx) {
    3291         179 :                 mem_ctx = state->out_mem_ctx;
    3292             :         } else {
    3293           0 :                 mem_ctx = state;
    3294             :         }
    3295             : 
    3296         179 :         status = dcerpc_wbint_QueryUserRidList_r_recv(subreq, mem_ctx);
    3297         179 :         TALLOC_FREE(subreq);
    3298         179 :         if (tevent_req_nterror(req, status)) {
    3299           0 :                 return;
    3300             :         }
    3301             : 
    3302             :         /* Copy out parameters */
    3303         179 :         *state->orig.out.rids = *state->tmp.out.rids;
    3304             : 
    3305             :         /* Copy result */
    3306         179 :         state->orig.out.result = state->tmp.out.result;
    3307             : 
    3308             :         /* Reset temporary structure */
    3309         179 :         NDR_ZERO_STRUCT(state->tmp);
    3310             : 
    3311         179 :         tevent_req_done(req);
    3312             : }
    3313             : 
    3314         179 : NTSTATUS dcerpc_wbint_QueryUserRidList_recv(struct tevent_req *req,
    3315             :                                             TALLOC_CTX *mem_ctx,
    3316             :                                             NTSTATUS *result)
    3317             : {
    3318         179 :         struct dcerpc_wbint_QueryUserRidList_state *state = tevent_req_data(
    3319             :                 req, struct dcerpc_wbint_QueryUserRidList_state);
    3320             :         NTSTATUS status;
    3321             : 
    3322         179 :         if (tevent_req_is_nterror(req, &status)) {
    3323           0 :                 tevent_req_received(req);
    3324           0 :                 return status;
    3325             :         }
    3326             : 
    3327             :         /* Steal possible out parameters to the callers context */
    3328         179 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    3329             : 
    3330             :         /* Return result */
    3331         179 :         *result = state->orig.out.result;
    3332             : 
    3333         179 :         tevent_req_received(req);
    3334         179 :         return NT_STATUS_OK;
    3335             : }
    3336             : 
    3337           0 : NTSTATUS dcerpc_wbint_QueryUserRidList(struct dcerpc_binding_handle *h,
    3338             :                                        TALLOC_CTX *mem_ctx,
    3339             :                                        struct wbint_RidArray *_rids /* [out] [ref] */,
    3340             :                                        NTSTATUS *result)
    3341             : {
    3342             :         struct wbint_QueryUserRidList r;
    3343             :         NTSTATUS status;
    3344             : 
    3345             :         /* In parameters */
    3346             : 
    3347             :         /* Out parameters */
    3348           0 :         r.out.rids = _rids;
    3349             : 
    3350             :         /* Result */
    3351           0 :         NDR_ZERO_STRUCT(r.out.result);
    3352             : 
    3353           0 :         status = dcerpc_wbint_QueryUserRidList_r(h, mem_ctx, &r);
    3354           0 :         if (!NT_STATUS_IS_OK(status)) {
    3355           0 :                 return status;
    3356             :         }
    3357             : 
    3358             :         /* Return variables */
    3359           0 :         *_rids = *r.out.rids;
    3360             : 
    3361             :         /* Return result */
    3362           0 :         *result = r.out.result;
    3363             : 
    3364           0 :         return NT_STATUS_OK;
    3365             : }
    3366             : 
    3367             : struct dcerpc_wbint_DsGetDcName_r_state {
    3368             :         TALLOC_CTX *out_mem_ctx;
    3369             : };
    3370             : 
    3371             : static void dcerpc_wbint_DsGetDcName_r_done(struct tevent_req *subreq);
    3372             : 
    3373          86 : struct tevent_req *dcerpc_wbint_DsGetDcName_r_send(TALLOC_CTX *mem_ctx,
    3374             :         struct tevent_context *ev,
    3375             :         struct dcerpc_binding_handle *h,
    3376             :         struct wbint_DsGetDcName *r)
    3377             : {
    3378             :         struct tevent_req *req;
    3379             :         struct dcerpc_wbint_DsGetDcName_r_state *state;
    3380             :         struct tevent_req *subreq;
    3381             : 
    3382          86 :         req = tevent_req_create(mem_ctx, &state,
    3383             :                                 struct dcerpc_wbint_DsGetDcName_r_state);
    3384          86 :         if (req == NULL) {
    3385           0 :                 return NULL;
    3386             :         }
    3387             : 
    3388          86 :         state->out_mem_ctx = talloc_new(state);
    3389          86 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    3390           0 :                 return tevent_req_post(req, ev);
    3391             :         }
    3392             : 
    3393          86 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    3394             :                         NULL, &ndr_table_winbind,
    3395          86 :                         NDR_WBINT_DSGETDCNAME, state->out_mem_ctx, r);
    3396          86 :         if (tevent_req_nomem(subreq, req)) {
    3397           0 :                 return tevent_req_post(req, ev);
    3398             :         }
    3399          86 :         tevent_req_set_callback(subreq, dcerpc_wbint_DsGetDcName_r_done, req);
    3400             : 
    3401          86 :         return req;
    3402             : }
    3403             : 
    3404          83 : static void dcerpc_wbint_DsGetDcName_r_done(struct tevent_req *subreq)
    3405             : {
    3406          55 :         struct tevent_req *req =
    3407          83 :                 tevent_req_callback_data(subreq,
    3408             :                 struct tevent_req);
    3409             :         NTSTATUS status;
    3410             : 
    3411          83 :         status = dcerpc_binding_handle_call_recv(subreq);
    3412          83 :         TALLOC_FREE(subreq);
    3413          83 :         if (tevent_req_nterror(req, status)) {
    3414           0 :                 return;
    3415             :         }
    3416             : 
    3417          83 :         tevent_req_done(req);
    3418             : }
    3419             : 
    3420          83 : NTSTATUS dcerpc_wbint_DsGetDcName_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    3421             : {
    3422          55 :         struct dcerpc_wbint_DsGetDcName_r_state *state =
    3423          83 :                 tevent_req_data(req,
    3424             :                 struct dcerpc_wbint_DsGetDcName_r_state);
    3425             :         NTSTATUS status;
    3426             : 
    3427          83 :         if (tevent_req_is_nterror(req, &status)) {
    3428           0 :                 tevent_req_received(req);
    3429           0 :                 return status;
    3430             :         }
    3431             : 
    3432          83 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    3433             : 
    3434          83 :         tevent_req_received(req);
    3435          83 :         return NT_STATUS_OK;
    3436             : }
    3437             : 
    3438           0 : NTSTATUS dcerpc_wbint_DsGetDcName_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wbint_DsGetDcName *r)
    3439             : {
    3440             :         NTSTATUS status;
    3441             : 
    3442           0 :         status = dcerpc_binding_handle_call(h,
    3443             :                         NULL, &ndr_table_winbind,
    3444             :                         NDR_WBINT_DSGETDCNAME, mem_ctx, r);
    3445             : 
    3446           0 :         return status;
    3447             : }
    3448             : 
    3449             : struct dcerpc_wbint_DsGetDcName_state {
    3450             :         struct wbint_DsGetDcName orig;
    3451             :         struct wbint_DsGetDcName tmp;
    3452             :         TALLOC_CTX *out_mem_ctx;
    3453             : };
    3454             : 
    3455             : static void dcerpc_wbint_DsGetDcName_done(struct tevent_req *subreq);
    3456             : 
    3457          86 : struct tevent_req *dcerpc_wbint_DsGetDcName_send(TALLOC_CTX *mem_ctx,
    3458             :                                                  struct tevent_context *ev,
    3459             :                                                  struct dcerpc_binding_handle *h,
    3460             :                                                  const char *_domain_name /* [in] [charset(UTF8),ref] */,
    3461             :                                                  struct GUID *_domain_guid /* [in] [unique] */,
    3462             :                                                  const char *_site_name /* [in] [charset(UTF8),unique] */,
    3463             :                                                  uint32_t _flags /* [in]  */,
    3464             :                                                  struct netr_DsRGetDCNameInfo **_dc_info /* [out] [ref] */)
    3465             : {
    3466             :         struct tevent_req *req;
    3467             :         struct dcerpc_wbint_DsGetDcName_state *state;
    3468             :         struct tevent_req *subreq;
    3469             : 
    3470          86 :         req = tevent_req_create(mem_ctx, &state,
    3471             :                                 struct dcerpc_wbint_DsGetDcName_state);
    3472          86 :         if (req == NULL) {
    3473           0 :                 return NULL;
    3474             :         }
    3475          86 :         state->out_mem_ctx = NULL;
    3476             : 
    3477             :         /* In parameters */
    3478          86 :         state->orig.in.domain_name = _domain_name;
    3479          86 :         state->orig.in.domain_guid = _domain_guid;
    3480          86 :         state->orig.in.site_name = _site_name;
    3481          86 :         state->orig.in.flags = _flags;
    3482             : 
    3483             :         /* Out parameters */
    3484          86 :         state->orig.out.dc_info = _dc_info;
    3485             : 
    3486             :         /* Result */
    3487          86 :         NDR_ZERO_STRUCT(state->orig.out.result);
    3488             : 
    3489          86 :         state->out_mem_ctx = talloc_named_const(state, 0,
    3490             :                              "dcerpc_wbint_DsGetDcName_out_memory");
    3491          86 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    3492           0 :                 return tevent_req_post(req, ev);
    3493             :         }
    3494             : 
    3495             :         /* make a temporary copy, that we pass to the dispatch function */
    3496          86 :         state->tmp = state->orig;
    3497             : 
    3498          86 :         subreq = dcerpc_wbint_DsGetDcName_r_send(state, ev, h, &state->tmp);
    3499          86 :         if (tevent_req_nomem(subreq, req)) {
    3500           0 :                 return tevent_req_post(req, ev);
    3501             :         }
    3502          86 :         tevent_req_set_callback(subreq, dcerpc_wbint_DsGetDcName_done, req);
    3503          86 :         return req;
    3504             : }
    3505             : 
    3506          83 : static void dcerpc_wbint_DsGetDcName_done(struct tevent_req *subreq)
    3507             : {
    3508          83 :         struct tevent_req *req = tevent_req_callback_data(
    3509             :                 subreq, struct tevent_req);
    3510          83 :         struct dcerpc_wbint_DsGetDcName_state *state = tevent_req_data(
    3511             :                 req, struct dcerpc_wbint_DsGetDcName_state);
    3512             :         NTSTATUS status;
    3513             :         TALLOC_CTX *mem_ctx;
    3514             : 
    3515          83 :         if (state->out_mem_ctx) {
    3516          83 :                 mem_ctx = state->out_mem_ctx;
    3517             :         } else {
    3518           0 :                 mem_ctx = state;
    3519             :         }
    3520             : 
    3521          83 :         status = dcerpc_wbint_DsGetDcName_r_recv(subreq, mem_ctx);
    3522          83 :         TALLOC_FREE(subreq);
    3523          83 :         if (tevent_req_nterror(req, status)) {
    3524           0 :                 return;
    3525             :         }
    3526             : 
    3527             :         /* Copy out parameters */
    3528          83 :         *state->orig.out.dc_info = *state->tmp.out.dc_info;
    3529             : 
    3530             :         /* Copy result */
    3531          83 :         state->orig.out.result = state->tmp.out.result;
    3532             : 
    3533             :         /* Reset temporary structure */
    3534          83 :         NDR_ZERO_STRUCT(state->tmp);
    3535             : 
    3536          83 :         tevent_req_done(req);
    3537             : }
    3538             : 
    3539          83 : NTSTATUS dcerpc_wbint_DsGetDcName_recv(struct tevent_req *req,
    3540             :                                        TALLOC_CTX *mem_ctx,
    3541             :                                        NTSTATUS *result)
    3542             : {
    3543          83 :         struct dcerpc_wbint_DsGetDcName_state *state = tevent_req_data(
    3544             :                 req, struct dcerpc_wbint_DsGetDcName_state);
    3545             :         NTSTATUS status;
    3546             : 
    3547          83 :         if (tevent_req_is_nterror(req, &status)) {
    3548           0 :                 tevent_req_received(req);
    3549           0 :                 return status;
    3550             :         }
    3551             : 
    3552             :         /* Steal possible out parameters to the callers context */
    3553          83 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    3554             : 
    3555             :         /* Return result */
    3556          83 :         *result = state->orig.out.result;
    3557             : 
    3558          83 :         tevent_req_received(req);
    3559          83 :         return NT_STATUS_OK;
    3560             : }
    3561             : 
    3562           0 : NTSTATUS dcerpc_wbint_DsGetDcName(struct dcerpc_binding_handle *h,
    3563             :                                   TALLOC_CTX *mem_ctx,
    3564             :                                   const char *_domain_name /* [in] [charset(UTF8),ref] */,
    3565             :                                   struct GUID *_domain_guid /* [in] [unique] */,
    3566             :                                   const char *_site_name /* [in] [charset(UTF8),unique] */,
    3567             :                                   uint32_t _flags /* [in]  */,
    3568             :                                   struct netr_DsRGetDCNameInfo **_dc_info /* [out] [ref] */,
    3569             :                                   NTSTATUS *result)
    3570             : {
    3571             :         struct wbint_DsGetDcName r;
    3572             :         NTSTATUS status;
    3573             : 
    3574             :         /* In parameters */
    3575           0 :         r.in.domain_name = _domain_name;
    3576           0 :         r.in.domain_guid = _domain_guid;
    3577           0 :         r.in.site_name = _site_name;
    3578           0 :         r.in.flags = _flags;
    3579             : 
    3580             :         /* Out parameters */
    3581           0 :         r.out.dc_info = _dc_info;
    3582             : 
    3583             :         /* Result */
    3584           0 :         NDR_ZERO_STRUCT(r.out.result);
    3585             : 
    3586           0 :         status = dcerpc_wbint_DsGetDcName_r(h, mem_ctx, &r);
    3587           0 :         if (!NT_STATUS_IS_OK(status)) {
    3588           0 :                 return status;
    3589             :         }
    3590             : 
    3591             :         /* Return variables */
    3592           0 :         *_dc_info = *r.out.dc_info;
    3593             : 
    3594             :         /* Return result */
    3595           0 :         *result = r.out.result;
    3596             : 
    3597           0 :         return NT_STATUS_OK;
    3598             : }
    3599             : 
    3600             : struct dcerpc_wbint_LookupRids_r_state {
    3601             :         TALLOC_CTX *out_mem_ctx;
    3602             : };
    3603             : 
    3604             : static void dcerpc_wbint_LookupRids_r_done(struct tevent_req *subreq);
    3605             : 
    3606          80 : struct tevent_req *dcerpc_wbint_LookupRids_r_send(TALLOC_CTX *mem_ctx,
    3607             :         struct tevent_context *ev,
    3608             :         struct dcerpc_binding_handle *h,
    3609             :         struct wbint_LookupRids *r)
    3610             : {
    3611             :         struct tevent_req *req;
    3612             :         struct dcerpc_wbint_LookupRids_r_state *state;
    3613             :         struct tevent_req *subreq;
    3614             : 
    3615          80 :         req = tevent_req_create(mem_ctx, &state,
    3616             :                                 struct dcerpc_wbint_LookupRids_r_state);
    3617          80 :         if (req == NULL) {
    3618           0 :                 return NULL;
    3619             :         }
    3620             : 
    3621          80 :         state->out_mem_ctx = talloc_new(state);
    3622          80 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    3623           0 :                 return tevent_req_post(req, ev);
    3624             :         }
    3625             : 
    3626          80 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    3627             :                         NULL, &ndr_table_winbind,
    3628          80 :                         NDR_WBINT_LOOKUPRIDS, state->out_mem_ctx, r);
    3629          80 :         if (tevent_req_nomem(subreq, req)) {
    3630           0 :                 return tevent_req_post(req, ev);
    3631             :         }
    3632          80 :         tevent_req_set_callback(subreq, dcerpc_wbint_LookupRids_r_done, req);
    3633             : 
    3634          80 :         return req;
    3635             : }
    3636             : 
    3637          80 : static void dcerpc_wbint_LookupRids_r_done(struct tevent_req *subreq)
    3638             : {
    3639          68 :         struct tevent_req *req =
    3640          80 :                 tevent_req_callback_data(subreq,
    3641             :                 struct tevent_req);
    3642             :         NTSTATUS status;
    3643             : 
    3644          80 :         status = dcerpc_binding_handle_call_recv(subreq);
    3645          80 :         TALLOC_FREE(subreq);
    3646          80 :         if (tevent_req_nterror(req, status)) {
    3647           0 :                 return;
    3648             :         }
    3649             : 
    3650          80 :         tevent_req_done(req);
    3651             : }
    3652             : 
    3653          80 : NTSTATUS dcerpc_wbint_LookupRids_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    3654             : {
    3655          68 :         struct dcerpc_wbint_LookupRids_r_state *state =
    3656          80 :                 tevent_req_data(req,
    3657             :                 struct dcerpc_wbint_LookupRids_r_state);
    3658             :         NTSTATUS status;
    3659             : 
    3660          80 :         if (tevent_req_is_nterror(req, &status)) {
    3661           0 :                 tevent_req_received(req);
    3662           0 :                 return status;
    3663             :         }
    3664             : 
    3665          80 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    3666             : 
    3667          80 :         tevent_req_received(req);
    3668          80 :         return NT_STATUS_OK;
    3669             : }
    3670             : 
    3671           0 : NTSTATUS dcerpc_wbint_LookupRids_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wbint_LookupRids *r)
    3672             : {
    3673             :         NTSTATUS status;
    3674             : 
    3675           0 :         status = dcerpc_binding_handle_call(h,
    3676             :                         NULL, &ndr_table_winbind,
    3677             :                         NDR_WBINT_LOOKUPRIDS, mem_ctx, r);
    3678             : 
    3679           0 :         return status;
    3680             : }
    3681             : 
    3682             : struct dcerpc_wbint_LookupRids_state {
    3683             :         struct wbint_LookupRids orig;
    3684             :         struct wbint_LookupRids tmp;
    3685             :         TALLOC_CTX *out_mem_ctx;
    3686             : };
    3687             : 
    3688             : static void dcerpc_wbint_LookupRids_done(struct tevent_req *subreq);
    3689             : 
    3690          80 : struct tevent_req *dcerpc_wbint_LookupRids_send(TALLOC_CTX *mem_ctx,
    3691             :                                                 struct tevent_context *ev,
    3692             :                                                 struct dcerpc_binding_handle *h,
    3693             :                                                 struct dom_sid *_domain_sid /* [in] [ref] */,
    3694             :                                                 struct wbint_RidArray *_rids /* [in] [ref] */,
    3695             :                                                 const char **_domain_name /* [out] [charset(UTF8),ref] */,
    3696             :                                                 struct wbint_Principals *_names /* [out] [ref] */)
    3697             : {
    3698             :         struct tevent_req *req;
    3699             :         struct dcerpc_wbint_LookupRids_state *state;
    3700             :         struct tevent_req *subreq;
    3701             : 
    3702          80 :         req = tevent_req_create(mem_ctx, &state,
    3703             :                                 struct dcerpc_wbint_LookupRids_state);
    3704          80 :         if (req == NULL) {
    3705           0 :                 return NULL;
    3706             :         }
    3707          80 :         state->out_mem_ctx = NULL;
    3708             : 
    3709             :         /* In parameters */
    3710          80 :         state->orig.in.domain_sid = _domain_sid;
    3711          80 :         state->orig.in.rids = _rids;
    3712             : 
    3713             :         /* Out parameters */
    3714          80 :         state->orig.out.domain_name = _domain_name;
    3715          80 :         state->orig.out.names = _names;
    3716             : 
    3717             :         /* Result */
    3718          80 :         NDR_ZERO_STRUCT(state->orig.out.result);
    3719             : 
    3720          80 :         state->out_mem_ctx = talloc_named_const(state, 0,
    3721             :                              "dcerpc_wbint_LookupRids_out_memory");
    3722          80 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    3723           0 :                 return tevent_req_post(req, ev);
    3724             :         }
    3725             : 
    3726             :         /* make a temporary copy, that we pass to the dispatch function */
    3727          80 :         state->tmp = state->orig;
    3728             : 
    3729          80 :         subreq = dcerpc_wbint_LookupRids_r_send(state, ev, h, &state->tmp);
    3730          80 :         if (tevent_req_nomem(subreq, req)) {
    3731           0 :                 return tevent_req_post(req, ev);
    3732             :         }
    3733          80 :         tevent_req_set_callback(subreq, dcerpc_wbint_LookupRids_done, req);
    3734          80 :         return req;
    3735             : }
    3736             : 
    3737          80 : static void dcerpc_wbint_LookupRids_done(struct tevent_req *subreq)
    3738             : {
    3739          80 :         struct tevent_req *req = tevent_req_callback_data(
    3740             :                 subreq, struct tevent_req);
    3741          80 :         struct dcerpc_wbint_LookupRids_state *state = tevent_req_data(
    3742             :                 req, struct dcerpc_wbint_LookupRids_state);
    3743             :         NTSTATUS status;
    3744             :         TALLOC_CTX *mem_ctx;
    3745             : 
    3746          80 :         if (state->out_mem_ctx) {
    3747          80 :                 mem_ctx = state->out_mem_ctx;
    3748             :         } else {
    3749           0 :                 mem_ctx = state;
    3750             :         }
    3751             : 
    3752          80 :         status = dcerpc_wbint_LookupRids_r_recv(subreq, mem_ctx);
    3753          80 :         TALLOC_FREE(subreq);
    3754          80 :         if (tevent_req_nterror(req, status)) {
    3755           0 :                 return;
    3756             :         }
    3757             : 
    3758             :         /* Copy out parameters */
    3759          80 :         *state->orig.out.domain_name = *state->tmp.out.domain_name;
    3760          80 :         *state->orig.out.names = *state->tmp.out.names;
    3761             : 
    3762             :         /* Copy result */
    3763          80 :         state->orig.out.result = state->tmp.out.result;
    3764             : 
    3765             :         /* Reset temporary structure */
    3766          80 :         NDR_ZERO_STRUCT(state->tmp);
    3767             : 
    3768          80 :         tevent_req_done(req);
    3769             : }
    3770             : 
    3771          80 : NTSTATUS dcerpc_wbint_LookupRids_recv(struct tevent_req *req,
    3772             :                                       TALLOC_CTX *mem_ctx,
    3773             :                                       NTSTATUS *result)
    3774             : {
    3775          80 :         struct dcerpc_wbint_LookupRids_state *state = tevent_req_data(
    3776             :                 req, struct dcerpc_wbint_LookupRids_state);
    3777             :         NTSTATUS status;
    3778             : 
    3779          80 :         if (tevent_req_is_nterror(req, &status)) {
    3780           0 :                 tevent_req_received(req);
    3781           0 :                 return status;
    3782             :         }
    3783             : 
    3784             :         /* Steal possible out parameters to the callers context */
    3785          80 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    3786             : 
    3787             :         /* Return result */
    3788          80 :         *result = state->orig.out.result;
    3789             : 
    3790          80 :         tevent_req_received(req);
    3791          80 :         return NT_STATUS_OK;
    3792             : }
    3793             : 
    3794           0 : NTSTATUS dcerpc_wbint_LookupRids(struct dcerpc_binding_handle *h,
    3795             :                                  TALLOC_CTX *mem_ctx,
    3796             :                                  struct dom_sid *_domain_sid /* [in] [ref] */,
    3797             :                                  struct wbint_RidArray *_rids /* [in] [ref] */,
    3798             :                                  const char **_domain_name /* [out] [charset(UTF8),ref] */,
    3799             :                                  struct wbint_Principals *_names /* [out] [ref] */,
    3800             :                                  NTSTATUS *result)
    3801             : {
    3802             :         struct wbint_LookupRids r;
    3803             :         NTSTATUS status;
    3804             : 
    3805             :         /* In parameters */
    3806           0 :         r.in.domain_sid = _domain_sid;
    3807           0 :         r.in.rids = _rids;
    3808             : 
    3809             :         /* Out parameters */
    3810           0 :         r.out.domain_name = _domain_name;
    3811           0 :         r.out.names = _names;
    3812             : 
    3813             :         /* Result */
    3814           0 :         NDR_ZERO_STRUCT(r.out.result);
    3815             : 
    3816           0 :         status = dcerpc_wbint_LookupRids_r(h, mem_ctx, &r);
    3817           0 :         if (!NT_STATUS_IS_OK(status)) {
    3818           0 :                 return status;
    3819             :         }
    3820             : 
    3821             :         /* Return variables */
    3822           0 :         *_domain_name = *r.out.domain_name;
    3823           0 :         *_names = *r.out.names;
    3824             : 
    3825             :         /* Return result */
    3826           0 :         *result = r.out.result;
    3827             : 
    3828           0 :         return NT_STATUS_OK;
    3829             : }
    3830             : 
    3831             : struct dcerpc_wbint_CheckMachineAccount_r_state {
    3832             :         TALLOC_CTX *out_mem_ctx;
    3833             : };
    3834             : 
    3835             : static void dcerpc_wbint_CheckMachineAccount_r_done(struct tevent_req *subreq);
    3836             : 
    3837          19 : struct tevent_req *dcerpc_wbint_CheckMachineAccount_r_send(TALLOC_CTX *mem_ctx,
    3838             :         struct tevent_context *ev,
    3839             :         struct dcerpc_binding_handle *h,
    3840             :         struct wbint_CheckMachineAccount *r)
    3841             : {
    3842             :         struct tevent_req *req;
    3843             :         struct dcerpc_wbint_CheckMachineAccount_r_state *state;
    3844             :         struct tevent_req *subreq;
    3845             : 
    3846          19 :         req = tevent_req_create(mem_ctx, &state,
    3847             :                                 struct dcerpc_wbint_CheckMachineAccount_r_state);
    3848          19 :         if (req == NULL) {
    3849           0 :                 return NULL;
    3850             :         }
    3851             : 
    3852          19 :         state->out_mem_ctx = NULL;
    3853             : 
    3854          19 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    3855             :                         NULL, &ndr_table_winbind,
    3856             :                         NDR_WBINT_CHECKMACHINEACCOUNT, state, r);
    3857          19 :         if (tevent_req_nomem(subreq, req)) {
    3858           0 :                 return tevent_req_post(req, ev);
    3859             :         }
    3860          19 :         tevent_req_set_callback(subreq, dcerpc_wbint_CheckMachineAccount_r_done, req);
    3861             : 
    3862          19 :         return req;
    3863             : }
    3864             : 
    3865          19 : static void dcerpc_wbint_CheckMachineAccount_r_done(struct tevent_req *subreq)
    3866             : {
    3867          15 :         struct tevent_req *req =
    3868          19 :                 tevent_req_callback_data(subreq,
    3869             :                 struct tevent_req);
    3870             :         NTSTATUS status;
    3871             : 
    3872          19 :         status = dcerpc_binding_handle_call_recv(subreq);
    3873          19 :         TALLOC_FREE(subreq);
    3874          19 :         if (tevent_req_nterror(req, status)) {
    3875           0 :                 return;
    3876             :         }
    3877             : 
    3878          19 :         tevent_req_done(req);
    3879             : }
    3880             : 
    3881          19 : NTSTATUS dcerpc_wbint_CheckMachineAccount_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    3882             : {
    3883          15 :         struct dcerpc_wbint_CheckMachineAccount_r_state *state =
    3884          19 :                 tevent_req_data(req,
    3885             :                 struct dcerpc_wbint_CheckMachineAccount_r_state);
    3886             :         NTSTATUS status;
    3887             : 
    3888          19 :         if (tevent_req_is_nterror(req, &status)) {
    3889           0 :                 tevent_req_received(req);
    3890           0 :                 return status;
    3891             :         }
    3892             : 
    3893          19 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    3894             : 
    3895          19 :         tevent_req_received(req);
    3896          19 :         return NT_STATUS_OK;
    3897             : }
    3898             : 
    3899           0 : NTSTATUS dcerpc_wbint_CheckMachineAccount_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wbint_CheckMachineAccount *r)
    3900             : {
    3901             :         NTSTATUS status;
    3902             : 
    3903           0 :         status = dcerpc_binding_handle_call(h,
    3904             :                         NULL, &ndr_table_winbind,
    3905             :                         NDR_WBINT_CHECKMACHINEACCOUNT, mem_ctx, r);
    3906             : 
    3907           0 :         return status;
    3908             : }
    3909             : 
    3910             : struct dcerpc_wbint_CheckMachineAccount_state {
    3911             :         struct wbint_CheckMachineAccount orig;
    3912             :         struct wbint_CheckMachineAccount tmp;
    3913             :         TALLOC_CTX *out_mem_ctx;
    3914             : };
    3915             : 
    3916             : static void dcerpc_wbint_CheckMachineAccount_done(struct tevent_req *subreq);
    3917             : 
    3918          19 : struct tevent_req *dcerpc_wbint_CheckMachineAccount_send(TALLOC_CTX *mem_ctx,
    3919             :                                                          struct tevent_context *ev,
    3920             :                                                          struct dcerpc_binding_handle *h)
    3921             : {
    3922             :         struct tevent_req *req;
    3923             :         struct dcerpc_wbint_CheckMachineAccount_state *state;
    3924             :         struct tevent_req *subreq;
    3925             : 
    3926          19 :         req = tevent_req_create(mem_ctx, &state,
    3927             :                                 struct dcerpc_wbint_CheckMachineAccount_state);
    3928          19 :         if (req == NULL) {
    3929           0 :                 return NULL;
    3930             :         }
    3931          19 :         state->out_mem_ctx = NULL;
    3932             : 
    3933             :         /* In parameters */
    3934             : 
    3935             :         /* Out parameters */
    3936             : 
    3937             :         /* Result */
    3938          19 :         NDR_ZERO_STRUCT(state->orig.out.result);
    3939             : 
    3940             :         /* make a temporary copy, that we pass to the dispatch function */
    3941          19 :         state->tmp = state->orig;
    3942             : 
    3943          19 :         subreq = dcerpc_wbint_CheckMachineAccount_r_send(state, ev, h, &state->tmp);
    3944          19 :         if (tevent_req_nomem(subreq, req)) {
    3945           0 :                 return tevent_req_post(req, ev);
    3946             :         }
    3947          19 :         tevent_req_set_callback(subreq, dcerpc_wbint_CheckMachineAccount_done, req);
    3948          19 :         return req;
    3949             : }
    3950             : 
    3951          19 : static void dcerpc_wbint_CheckMachineAccount_done(struct tevent_req *subreq)
    3952             : {
    3953          19 :         struct tevent_req *req = tevent_req_callback_data(
    3954             :                 subreq, struct tevent_req);
    3955          19 :         struct dcerpc_wbint_CheckMachineAccount_state *state = tevent_req_data(
    3956             :                 req, struct dcerpc_wbint_CheckMachineAccount_state);
    3957             :         NTSTATUS status;
    3958             :         TALLOC_CTX *mem_ctx;
    3959             : 
    3960          19 :         if (state->out_mem_ctx) {
    3961           0 :                 mem_ctx = state->out_mem_ctx;
    3962             :         } else {
    3963          19 :                 mem_ctx = state;
    3964             :         }
    3965             : 
    3966          19 :         status = dcerpc_wbint_CheckMachineAccount_r_recv(subreq, mem_ctx);
    3967          19 :         TALLOC_FREE(subreq);
    3968          19 :         if (tevent_req_nterror(req, status)) {
    3969           0 :                 return;
    3970             :         }
    3971             : 
    3972             :         /* Copy out parameters */
    3973             : 
    3974             :         /* Copy result */
    3975          19 :         state->orig.out.result = state->tmp.out.result;
    3976             : 
    3977             :         /* Reset temporary structure */
    3978          19 :         NDR_ZERO_STRUCT(state->tmp);
    3979             : 
    3980          19 :         tevent_req_done(req);
    3981             : }
    3982             : 
    3983          19 : NTSTATUS dcerpc_wbint_CheckMachineAccount_recv(struct tevent_req *req,
    3984             :                                                TALLOC_CTX *mem_ctx,
    3985             :                                                NTSTATUS *result)
    3986             : {
    3987          19 :         struct dcerpc_wbint_CheckMachineAccount_state *state = tevent_req_data(
    3988             :                 req, struct dcerpc_wbint_CheckMachineAccount_state);
    3989             :         NTSTATUS status;
    3990             : 
    3991          19 :         if (tevent_req_is_nterror(req, &status)) {
    3992           0 :                 tevent_req_received(req);
    3993           0 :                 return status;
    3994             :         }
    3995             : 
    3996             :         /* Steal possible out parameters to the callers context */
    3997          19 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    3998             : 
    3999             :         /* Return result */
    4000          19 :         *result = state->orig.out.result;
    4001             : 
    4002          19 :         tevent_req_received(req);
    4003          19 :         return NT_STATUS_OK;
    4004             : }
    4005             : 
    4006           0 : NTSTATUS dcerpc_wbint_CheckMachineAccount(struct dcerpc_binding_handle *h,
    4007             :                                           TALLOC_CTX *mem_ctx,
    4008             :                                           NTSTATUS *result)
    4009             : {
    4010             :         struct wbint_CheckMachineAccount r;
    4011             :         NTSTATUS status;
    4012             : 
    4013             :         /* In parameters */
    4014             : 
    4015             :         /* Out parameters */
    4016             : 
    4017             :         /* Result */
    4018           0 :         NDR_ZERO_STRUCT(r.out.result);
    4019             : 
    4020           0 :         status = dcerpc_wbint_CheckMachineAccount_r(h, mem_ctx, &r);
    4021           0 :         if (!NT_STATUS_IS_OK(status)) {
    4022           0 :                 return status;
    4023             :         }
    4024             : 
    4025             :         /* Return variables */
    4026             : 
    4027             :         /* Return result */
    4028           0 :         *result = r.out.result;
    4029             : 
    4030           0 :         return NT_STATUS_OK;
    4031             : }
    4032             : 
    4033             : struct dcerpc_wbint_ChangeMachineAccount_r_state {
    4034             :         TALLOC_CTX *out_mem_ctx;
    4035             : };
    4036             : 
    4037             : static void dcerpc_wbint_ChangeMachineAccount_r_done(struct tevent_req *subreq);
    4038             : 
    4039          17 : struct tevent_req *dcerpc_wbint_ChangeMachineAccount_r_send(TALLOC_CTX *mem_ctx,
    4040             :         struct tevent_context *ev,
    4041             :         struct dcerpc_binding_handle *h,
    4042             :         struct wbint_ChangeMachineAccount *r)
    4043             : {
    4044             :         struct tevent_req *req;
    4045             :         struct dcerpc_wbint_ChangeMachineAccount_r_state *state;
    4046             :         struct tevent_req *subreq;
    4047             : 
    4048          17 :         req = tevent_req_create(mem_ctx, &state,
    4049             :                                 struct dcerpc_wbint_ChangeMachineAccount_r_state);
    4050          17 :         if (req == NULL) {
    4051           0 :                 return NULL;
    4052             :         }
    4053             : 
    4054          17 :         state->out_mem_ctx = NULL;
    4055             : 
    4056          17 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    4057             :                         NULL, &ndr_table_winbind,
    4058             :                         NDR_WBINT_CHANGEMACHINEACCOUNT, state, r);
    4059          17 :         if (tevent_req_nomem(subreq, req)) {
    4060           0 :                 return tevent_req_post(req, ev);
    4061             :         }
    4062          17 :         tevent_req_set_callback(subreq, dcerpc_wbint_ChangeMachineAccount_r_done, req);
    4063             : 
    4064          17 :         return req;
    4065             : }
    4066             : 
    4067          17 : static void dcerpc_wbint_ChangeMachineAccount_r_done(struct tevent_req *subreq)
    4068             : {
    4069          14 :         struct tevent_req *req =
    4070          17 :                 tevent_req_callback_data(subreq,
    4071             :                 struct tevent_req);
    4072             :         NTSTATUS status;
    4073             : 
    4074          17 :         status = dcerpc_binding_handle_call_recv(subreq);
    4075          17 :         TALLOC_FREE(subreq);
    4076          17 :         if (tevent_req_nterror(req, status)) {
    4077           0 :                 return;
    4078             :         }
    4079             : 
    4080          17 :         tevent_req_done(req);
    4081             : }
    4082             : 
    4083          17 : NTSTATUS dcerpc_wbint_ChangeMachineAccount_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    4084             : {
    4085          14 :         struct dcerpc_wbint_ChangeMachineAccount_r_state *state =
    4086          17 :                 tevent_req_data(req,
    4087             :                 struct dcerpc_wbint_ChangeMachineAccount_r_state);
    4088             :         NTSTATUS status;
    4089             : 
    4090          17 :         if (tevent_req_is_nterror(req, &status)) {
    4091           0 :                 tevent_req_received(req);
    4092           0 :                 return status;
    4093             :         }
    4094             : 
    4095          17 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    4096             : 
    4097          17 :         tevent_req_received(req);
    4098          17 :         return NT_STATUS_OK;
    4099             : }
    4100             : 
    4101           0 : NTSTATUS dcerpc_wbint_ChangeMachineAccount_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wbint_ChangeMachineAccount *r)
    4102             : {
    4103             :         NTSTATUS status;
    4104             : 
    4105           0 :         status = dcerpc_binding_handle_call(h,
    4106             :                         NULL, &ndr_table_winbind,
    4107             :                         NDR_WBINT_CHANGEMACHINEACCOUNT, mem_ctx, r);
    4108             : 
    4109           0 :         return status;
    4110             : }
    4111             : 
    4112             : struct dcerpc_wbint_ChangeMachineAccount_state {
    4113             :         struct wbint_ChangeMachineAccount orig;
    4114             :         struct wbint_ChangeMachineAccount tmp;
    4115             :         TALLOC_CTX *out_mem_ctx;
    4116             : };
    4117             : 
    4118             : static void dcerpc_wbint_ChangeMachineAccount_done(struct tevent_req *subreq);
    4119             : 
    4120          17 : struct tevent_req *dcerpc_wbint_ChangeMachineAccount_send(TALLOC_CTX *mem_ctx,
    4121             :                                                           struct tevent_context *ev,
    4122             :                                                           struct dcerpc_binding_handle *h)
    4123             : {
    4124             :         struct tevent_req *req;
    4125             :         struct dcerpc_wbint_ChangeMachineAccount_state *state;
    4126             :         struct tevent_req *subreq;
    4127             : 
    4128          17 :         req = tevent_req_create(mem_ctx, &state,
    4129             :                                 struct dcerpc_wbint_ChangeMachineAccount_state);
    4130          17 :         if (req == NULL) {
    4131           0 :                 return NULL;
    4132             :         }
    4133          17 :         state->out_mem_ctx = NULL;
    4134             : 
    4135             :         /* In parameters */
    4136             : 
    4137             :         /* Out parameters */
    4138             : 
    4139             :         /* Result */
    4140          17 :         NDR_ZERO_STRUCT(state->orig.out.result);
    4141             : 
    4142             :         /* make a temporary copy, that we pass to the dispatch function */
    4143          17 :         state->tmp = state->orig;
    4144             : 
    4145          17 :         subreq = dcerpc_wbint_ChangeMachineAccount_r_send(state, ev, h, &state->tmp);
    4146          17 :         if (tevent_req_nomem(subreq, req)) {
    4147           0 :                 return tevent_req_post(req, ev);
    4148             :         }
    4149          17 :         tevent_req_set_callback(subreq, dcerpc_wbint_ChangeMachineAccount_done, req);
    4150          17 :         return req;
    4151             : }
    4152             : 
    4153          17 : static void dcerpc_wbint_ChangeMachineAccount_done(struct tevent_req *subreq)
    4154             : {
    4155          17 :         struct tevent_req *req = tevent_req_callback_data(
    4156             :                 subreq, struct tevent_req);
    4157          17 :         struct dcerpc_wbint_ChangeMachineAccount_state *state = tevent_req_data(
    4158             :                 req, struct dcerpc_wbint_ChangeMachineAccount_state);
    4159             :         NTSTATUS status;
    4160             :         TALLOC_CTX *mem_ctx;
    4161             : 
    4162          17 :         if (state->out_mem_ctx) {
    4163           0 :                 mem_ctx = state->out_mem_ctx;
    4164             :         } else {
    4165          17 :                 mem_ctx = state;
    4166             :         }
    4167             : 
    4168          17 :         status = dcerpc_wbint_ChangeMachineAccount_r_recv(subreq, mem_ctx);
    4169          17 :         TALLOC_FREE(subreq);
    4170          17 :         if (tevent_req_nterror(req, status)) {
    4171           0 :                 return;
    4172             :         }
    4173             : 
    4174             :         /* Copy out parameters */
    4175             : 
    4176             :         /* Copy result */
    4177          17 :         state->orig.out.result = state->tmp.out.result;
    4178             : 
    4179             :         /* Reset temporary structure */
    4180          17 :         NDR_ZERO_STRUCT(state->tmp);
    4181             : 
    4182          17 :         tevent_req_done(req);
    4183             : }
    4184             : 
    4185          17 : NTSTATUS dcerpc_wbint_ChangeMachineAccount_recv(struct tevent_req *req,
    4186             :                                                 TALLOC_CTX *mem_ctx,
    4187             :                                                 NTSTATUS *result)
    4188             : {
    4189          17 :         struct dcerpc_wbint_ChangeMachineAccount_state *state = tevent_req_data(
    4190             :                 req, struct dcerpc_wbint_ChangeMachineAccount_state);
    4191             :         NTSTATUS status;
    4192             : 
    4193          17 :         if (tevent_req_is_nterror(req, &status)) {
    4194           0 :                 tevent_req_received(req);
    4195           0 :                 return status;
    4196             :         }
    4197             : 
    4198             :         /* Steal possible out parameters to the callers context */
    4199          17 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    4200             : 
    4201             :         /* Return result */
    4202          17 :         *result = state->orig.out.result;
    4203             : 
    4204          17 :         tevent_req_received(req);
    4205          17 :         return NT_STATUS_OK;
    4206             : }
    4207             : 
    4208           0 : NTSTATUS dcerpc_wbint_ChangeMachineAccount(struct dcerpc_binding_handle *h,
    4209             :                                            TALLOC_CTX *mem_ctx,
    4210             :                                            NTSTATUS *result)
    4211             : {
    4212             :         struct wbint_ChangeMachineAccount r;
    4213             :         NTSTATUS status;
    4214             : 
    4215             :         /* In parameters */
    4216             : 
    4217             :         /* Out parameters */
    4218             : 
    4219             :         /* Result */
    4220           0 :         NDR_ZERO_STRUCT(r.out.result);
    4221             : 
    4222           0 :         status = dcerpc_wbint_ChangeMachineAccount_r(h, mem_ctx, &r);
    4223           0 :         if (!NT_STATUS_IS_OK(status)) {
    4224           0 :                 return status;
    4225             :         }
    4226             : 
    4227             :         /* Return variables */
    4228             : 
    4229             :         /* Return result */
    4230           0 :         *result = r.out.result;
    4231             : 
    4232           0 :         return NT_STATUS_OK;
    4233             : }
    4234             : 
    4235             : struct dcerpc_wbint_PingDc_r_state {
    4236             :         TALLOC_CTX *out_mem_ctx;
    4237             : };
    4238             : 
    4239             : static void dcerpc_wbint_PingDc_r_done(struct tevent_req *subreq);
    4240             : 
    4241        1223 : struct tevent_req *dcerpc_wbint_PingDc_r_send(TALLOC_CTX *mem_ctx,
    4242             :         struct tevent_context *ev,
    4243             :         struct dcerpc_binding_handle *h,
    4244             :         struct wbint_PingDc *r)
    4245             : {
    4246             :         struct tevent_req *req;
    4247             :         struct dcerpc_wbint_PingDc_r_state *state;
    4248             :         struct tevent_req *subreq;
    4249             : 
    4250        1223 :         req = tevent_req_create(mem_ctx, &state,
    4251             :                                 struct dcerpc_wbint_PingDc_r_state);
    4252        1223 :         if (req == NULL) {
    4253           0 :                 return NULL;
    4254             :         }
    4255             : 
    4256        1223 :         state->out_mem_ctx = talloc_new(state);
    4257        1223 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    4258           0 :                 return tevent_req_post(req, ev);
    4259             :         }
    4260             : 
    4261        1223 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    4262             :                         NULL, &ndr_table_winbind,
    4263        1223 :                         NDR_WBINT_PINGDC, state->out_mem_ctx, r);
    4264        1223 :         if (tevent_req_nomem(subreq, req)) {
    4265           0 :                 return tevent_req_post(req, ev);
    4266             :         }
    4267        1223 :         tevent_req_set_callback(subreq, dcerpc_wbint_PingDc_r_done, req);
    4268             : 
    4269        1223 :         return req;
    4270             : }
    4271             : 
    4272        1222 : static void dcerpc_wbint_PingDc_r_done(struct tevent_req *subreq)
    4273             : {
    4274        1206 :         struct tevent_req *req =
    4275        1222 :                 tevent_req_callback_data(subreq,
    4276             :                 struct tevent_req);
    4277             :         NTSTATUS status;
    4278             : 
    4279        1222 :         status = dcerpc_binding_handle_call_recv(subreq);
    4280        1222 :         TALLOC_FREE(subreq);
    4281        1222 :         if (tevent_req_nterror(req, status)) {
    4282           0 :                 return;
    4283             :         }
    4284             : 
    4285        1222 :         tevent_req_done(req);
    4286             : }
    4287             : 
    4288        1222 : NTSTATUS dcerpc_wbint_PingDc_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    4289             : {
    4290        1206 :         struct dcerpc_wbint_PingDc_r_state *state =
    4291        1222 :                 tevent_req_data(req,
    4292             :                 struct dcerpc_wbint_PingDc_r_state);
    4293             :         NTSTATUS status;
    4294             : 
    4295        1222 :         if (tevent_req_is_nterror(req, &status)) {
    4296           0 :                 tevent_req_received(req);
    4297           0 :                 return status;
    4298             :         }
    4299             : 
    4300        1222 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    4301             : 
    4302        1222 :         tevent_req_received(req);
    4303        1222 :         return NT_STATUS_OK;
    4304             : }
    4305             : 
    4306           0 : NTSTATUS dcerpc_wbint_PingDc_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct wbint_PingDc *r)
    4307             : {
    4308             :         NTSTATUS status;
    4309             : 
    4310           0 :         status = dcerpc_binding_handle_call(h,
    4311             :                         NULL, &ndr_table_winbind,
    4312             :                         NDR_WBINT_PINGDC, mem_ctx, r);
    4313             : 
    4314           0 :         return status;
    4315             : }
    4316             : 
    4317             : struct dcerpc_wbint_PingDc_state {
    4318             :         struct wbint_PingDc orig;
    4319             :         struct wbint_PingDc tmp;
    4320             :         TALLOC_CTX *out_mem_ctx;
    4321             : };
    4322             : 
    4323             : static void dcerpc_wbint_PingDc_done(struct tevent_req *subreq);
    4324             : 
    4325        1223 : struct tevent_req *dcerpc_wbint_PingDc_send(TALLOC_CTX *mem_ctx,
    4326             :                                             struct tevent_context *ev,
    4327             :                                             struct dcerpc_binding_handle *h,
    4328             :                                             const char **_dcname /* [out] [charset(UTF8),ref] */)
    4329             : {
    4330             :         struct tevent_req *req;
    4331             :         struct dcerpc_wbint_PingDc_state *state;
    4332             :         struct tevent_req *subreq;
    4333             : 
    4334        1223 :         req = tevent_req_create(mem_ctx, &state,
    4335             :                                 struct dcerpc_wbint_PingDc_state);
    4336        1223 :         if (req == NULL) {
    4337           0 :                 return NULL;
    4338             :         }
    4339        1223 :         state->out_mem_ctx = NULL;
    4340             : 
    4341             :         /* In parameters */
    4342             : 
    4343             :         /* Out parameters */
    4344        1223 :         state->orig.out.dcname = _dcname;
    4345             : 
    4346             :         /* Result */
    4347        1223 :         NDR_ZERO_STRUCT(state->orig.out.result);
    4348             : 
    4349        1223 :         state->out_mem_ctx = talloc_named_const(state, 0,
    4350             :                              "dcerpc_wbint_PingDc_out_memory");
    4351        1223 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    4352           0 :                 return tevent_req_post(req, ev);
    4353             :         }
    4354             : 
    4355             :         /* make a temporary copy, that we pass to the dispatch function */
    4356        1223 :         state->tmp = state->orig;
    4357             : 
    4358        1223 :         subreq = dcerpc_wbint_PingDc_r_send(state, ev, h, &state->tmp);
    4359        1223 :         if (tevent_req_nomem(subreq, req)) {
    4360           0 :                 return tevent_req_post(req, ev);
    4361             :         }
    4362        1223 :         tevent_req_set_callback(subreq, dcerpc_wbint_PingDc_done, req);
    4363        1223 :         return req;
    4364             : }
    4365             : 
    4366        1222 : static void dcerpc_wbint_PingDc_done(struct tevent_req *subreq)
    4367             : {
    4368        1222 :         struct tevent_req *req = tevent_req_callback_data(
    4369             :                 subreq, struct tevent_req);
    4370        1222 :         struct dcerpc_wbint_PingDc_state *state = tevent_req_data(
    4371             :                 req, struct dcerpc_wbint_PingDc_state);
    4372             :         NTSTATUS status;
    4373             :         TALLOC_CTX *mem_ctx;
    4374             : 
    4375        1222 :         if (state->out_mem_ctx) {
    4376        1222 :                 mem_ctx = state->out_mem_ctx;
    4377             :         } else {
    4378           0 :                 mem_ctx = state;
    4379             :         }
    4380             : 
    4381        1222 :         status = dcerpc_wbint_PingDc_r_recv(subreq, mem_ctx);
    4382        1222 :         TALLOC_FREE(subreq);
    4383        1222 :         if (tevent_req_nterror(req, status)) {
    4384           0 :                 return;
    4385             :         }
    4386             : 
    4387             :         /* Copy out parameters */
    4388        1222 :         *state->orig.out.dcname = *state->tmp.out.dcname;
    4389             : 
    4390             :         /* Copy result */
    4391        1222 :         state->orig.out.result = state->tmp.out.result;
    4392             : 
    4393             :         /* Reset temporary structure */
    4394        1222 :         NDR_ZERO_STRUCT(state->tmp);
    4395             : 
    4396        1222 :         tevent_req_done(req);
    4397             : }
    4398             : 
    4399        1222 : NTSTATUS dcerpc_wbint_PingDc_recv(struct tevent_req *req,
    4400             :                                   TALLOC_CTX *mem_ctx,
    4401             :                                   NTSTATUS *result)
    4402             : {
    4403        1222 :         struct dcerpc_wbint_PingDc_state *state = tevent_req_data(
    4404             :                 req, struct dcerpc_wbint_PingDc_state);
    4405             :         NTSTATUS status;
    4406             : 
    4407        1222 :         if (tevent_req_is_nterror(req, &status)) {
    4408           0 :                 tevent_req_received(req);
    4409           0 :                 return status;
    4410             :         }
    4411             : 
    4412             :         /* Steal possible out parameters to the callers context */
    4413        1222 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    4414             : 
    4415             :         /* Return result */
    4416        1222 :         *result = state->orig.out.result;
    4417             : 
    4418        1222 :         tevent_req_received(req);
    4419        1222 :         return NT_STATUS_OK;
    4420             : }
    4421             : 
    4422           0 : NTSTATUS dcerpc_wbint_PingDc(struct dcerpc_binding_handle *h,
    4423             :                              TALLOC_CTX *mem_ctx,
    4424             :                              const char **_dcname /* [out] [charset(UTF8),ref] */,
    4425             :                              NTSTATUS *result)
    4426             : {
    4427             :         struct wbint_PingDc r;
    4428             :         NTSTATUS status;
    4429             : 
    4430             :         /* In parameters */
    4431             : 
    4432             :         /* Out parameters */
    4433           0 :         r.out.dcname = _dcname;
    4434             : 
    4435             :         /* Result */
    4436           0 :         NDR_ZERO_STRUCT(r.out.result);
    4437             : 
    4438           0 :         status = dcerpc_wbint_PingDc_r(h, mem_ctx, &r);
    4439           0 :         if (!NT_STATUS_IS_OK(status)) {
    4440           0 :                 return status;
    4441             :         }
    4442             : 
    4443             :         /* Return variables */
    4444           0 :         *_dcname = *r.out.dcname;
    4445             : 
    4446             :         /* Return result */
    4447           0 :         *result = r.out.result;
    4448             : 
    4449           0 :         return NT_STATUS_OK;
    4450             : }
    4451             : 
    4452             : struct dcerpc_winbind_SamLogon_r_state {
    4453             :         TALLOC_CTX *out_mem_ctx;
    4454             : };
    4455             : 
    4456             : static void dcerpc_winbind_SamLogon_r_done(struct tevent_req *subreq);
    4457             : 
    4458        1239 : struct tevent_req *dcerpc_winbind_SamLogon_r_send(TALLOC_CTX *mem_ctx,
    4459             :         struct tevent_context *ev,
    4460             :         struct dcerpc_binding_handle *h,
    4461             :         struct winbind_SamLogon *r)
    4462             : {
    4463             :         struct tevent_req *req;
    4464             :         struct dcerpc_winbind_SamLogon_r_state *state;
    4465             :         struct tevent_req *subreq;
    4466             : 
    4467        1239 :         req = tevent_req_create(mem_ctx, &state,
    4468             :                                 struct dcerpc_winbind_SamLogon_r_state);
    4469        1239 :         if (req == NULL) {
    4470           0 :                 return NULL;
    4471             :         }
    4472             : 
    4473        1239 :         state->out_mem_ctx = talloc_new(state);
    4474        1239 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    4475           0 :                 return tevent_req_post(req, ev);
    4476             :         }
    4477             : 
    4478        1239 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    4479             :                         NULL, &ndr_table_winbind,
    4480        1239 :                         NDR_WINBIND_SAMLOGON, state->out_mem_ctx, r);
    4481        1239 :         if (tevent_req_nomem(subreq, req)) {
    4482           0 :                 return tevent_req_post(req, ev);
    4483             :         }
    4484        1239 :         tevent_req_set_callback(subreq, dcerpc_winbind_SamLogon_r_done, req);
    4485             : 
    4486        1239 :         return req;
    4487             : }
    4488             : 
    4489        1220 : static void dcerpc_winbind_SamLogon_r_done(struct tevent_req *subreq)
    4490             : {
    4491         965 :         struct tevent_req *req =
    4492        1220 :                 tevent_req_callback_data(subreq,
    4493             :                 struct tevent_req);
    4494             :         NTSTATUS status;
    4495             : 
    4496        1220 :         status = dcerpc_binding_handle_call_recv(subreq);
    4497        1220 :         TALLOC_FREE(subreq);
    4498        1220 :         if (tevent_req_nterror(req, status)) {
    4499           2 :                 return;
    4500             :         }
    4501             : 
    4502        1218 :         tevent_req_done(req);
    4503             : }
    4504             : 
    4505        1220 : NTSTATUS dcerpc_winbind_SamLogon_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    4506             : {
    4507         965 :         struct dcerpc_winbind_SamLogon_r_state *state =
    4508        1220 :                 tevent_req_data(req,
    4509             :                 struct dcerpc_winbind_SamLogon_r_state);
    4510             :         NTSTATUS status;
    4511             : 
    4512        1220 :         if (tevent_req_is_nterror(req, &status)) {
    4513           2 :                 tevent_req_received(req);
    4514           2 :                 return status;
    4515             :         }
    4516             : 
    4517        1218 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    4518             : 
    4519        1218 :         tevent_req_received(req);
    4520        1218 :         return NT_STATUS_OK;
    4521             : }
    4522             : 
    4523           0 : NTSTATUS dcerpc_winbind_SamLogon_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct winbind_SamLogon *r)
    4524             : {
    4525             :         NTSTATUS status;
    4526             : 
    4527           0 :         status = dcerpc_binding_handle_call(h,
    4528             :                         NULL, &ndr_table_winbind,
    4529             :                         NDR_WINBIND_SAMLOGON, mem_ctx, r);
    4530             : 
    4531           0 :         return status;
    4532             : }
    4533             : 
    4534             : /*
    4535             :  * The following functions are skipped because
    4536             :  * an [out] argument validation is not a pointer or array:
    4537             :  *
    4538             :  * dcerpc_winbind_SamLogon_send()
    4539             :  * dcerpc_winbind_SamLogon_recv()
    4540             :  * dcerpc_winbind_SamLogon()
    4541             :  */
    4542             : 
    4543             : struct dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_r_state {
    4544             :         TALLOC_CTX *out_mem_ctx;
    4545             : };
    4546             : 
    4547             : static void dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_r_done(struct tevent_req *subreq);
    4548             : 
    4549           0 : struct tevent_req *dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_r_send(TALLOC_CTX *mem_ctx,
    4550             :         struct tevent_context *ev,
    4551             :         struct dcerpc_binding_handle *h,
    4552             :         struct winbind_DsrUpdateReadOnlyServerDnsRecords *r)
    4553             : {
    4554             :         struct tevent_req *req;
    4555             :         struct dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_r_state *state;
    4556             :         struct tevent_req *subreq;
    4557             : 
    4558           0 :         req = tevent_req_create(mem_ctx, &state,
    4559             :                                 struct dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_r_state);
    4560           0 :         if (req == NULL) {
    4561           0 :                 return NULL;
    4562             :         }
    4563             : 
    4564           0 :         state->out_mem_ctx = talloc_new(state);
    4565           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    4566           0 :                 return tevent_req_post(req, ev);
    4567             :         }
    4568             : 
    4569           0 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    4570             :                         NULL, &ndr_table_winbind,
    4571           0 :                         NDR_WINBIND_DSRUPDATEREADONLYSERVERDNSRECORDS, state->out_mem_ctx, r);
    4572           0 :         if (tevent_req_nomem(subreq, req)) {
    4573           0 :                 return tevent_req_post(req, ev);
    4574             :         }
    4575           0 :         tevent_req_set_callback(subreq, dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_r_done, req);
    4576             : 
    4577           0 :         return req;
    4578             : }
    4579             : 
    4580           0 : static void dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_r_done(struct tevent_req *subreq)
    4581             : {
    4582           0 :         struct tevent_req *req =
    4583           0 :                 tevent_req_callback_data(subreq,
    4584             :                 struct tevent_req);
    4585             :         NTSTATUS status;
    4586             : 
    4587           0 :         status = dcerpc_binding_handle_call_recv(subreq);
    4588           0 :         TALLOC_FREE(subreq);
    4589           0 :         if (tevent_req_nterror(req, status)) {
    4590           0 :                 return;
    4591             :         }
    4592             : 
    4593           0 :         tevent_req_done(req);
    4594             : }
    4595             : 
    4596           0 : NTSTATUS dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    4597             : {
    4598           0 :         struct dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_r_state *state =
    4599           0 :                 tevent_req_data(req,
    4600             :                 struct dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_r_state);
    4601             :         NTSTATUS status;
    4602             : 
    4603           0 :         if (tevent_req_is_nterror(req, &status)) {
    4604           0 :                 tevent_req_received(req);
    4605           0 :                 return status;
    4606             :         }
    4607             : 
    4608           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    4609             : 
    4610           0 :         tevent_req_received(req);
    4611           0 :         return NT_STATUS_OK;
    4612             : }
    4613             : 
    4614           4 : NTSTATUS dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct winbind_DsrUpdateReadOnlyServerDnsRecords *r)
    4615             : {
    4616             :         NTSTATUS status;
    4617             : 
    4618           4 :         status = dcerpc_binding_handle_call(h,
    4619             :                         NULL, &ndr_table_winbind,
    4620             :                         NDR_WINBIND_DSRUPDATEREADONLYSERVERDNSRECORDS, mem_ctx, r);
    4621             : 
    4622           4 :         return status;
    4623             : }
    4624             : 
    4625             : struct dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_state {
    4626             :         struct winbind_DsrUpdateReadOnlyServerDnsRecords orig;
    4627             :         struct winbind_DsrUpdateReadOnlyServerDnsRecords tmp;
    4628             :         TALLOC_CTX *out_mem_ctx;
    4629             : };
    4630             : 
    4631             : static void dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_done(struct tevent_req *subreq);
    4632             : 
    4633           0 : struct tevent_req *dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_send(TALLOC_CTX *mem_ctx,
    4634             :                                                                          struct tevent_context *ev,
    4635             :                                                                          struct dcerpc_binding_handle *h,
    4636             :                                                                          const char *_site_name /* [in] [charset(UTF16),unique] */,
    4637             :                                                                          uint32_t _dns_ttl /* [in]  */,
    4638             :                                                                          struct NL_DNS_NAME_INFO_ARRAY *_dns_names /* [in,out] [ref] */)
    4639             : {
    4640             :         struct tevent_req *req;
    4641             :         struct dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_state *state;
    4642             :         struct tevent_req *subreq;
    4643             : 
    4644           0 :         req = tevent_req_create(mem_ctx, &state,
    4645             :                                 struct dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_state);
    4646           0 :         if (req == NULL) {
    4647           0 :                 return NULL;
    4648             :         }
    4649           0 :         state->out_mem_ctx = NULL;
    4650             : 
    4651             :         /* In parameters */
    4652           0 :         state->orig.in.site_name = _site_name;
    4653           0 :         state->orig.in.dns_ttl = _dns_ttl;
    4654           0 :         state->orig.in.dns_names = _dns_names;
    4655             : 
    4656             :         /* Out parameters */
    4657           0 :         state->orig.out.dns_names = _dns_names;
    4658             : 
    4659             :         /* Result */
    4660           0 :         NDR_ZERO_STRUCT(state->orig.out.result);
    4661             : 
    4662           0 :         state->out_mem_ctx = talloc_named_const(state, 0,
    4663             :                              "dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_out_memory");
    4664           0 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    4665           0 :                 return tevent_req_post(req, ev);
    4666             :         }
    4667             : 
    4668             :         /* make a temporary copy, that we pass to the dispatch function */
    4669           0 :         state->tmp = state->orig;
    4670             : 
    4671           0 :         subreq = dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_r_send(state, ev, h, &state->tmp);
    4672           0 :         if (tevent_req_nomem(subreq, req)) {
    4673           0 :                 return tevent_req_post(req, ev);
    4674             :         }
    4675           0 :         tevent_req_set_callback(subreq, dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_done, req);
    4676           0 :         return req;
    4677             : }
    4678             : 
    4679           0 : static void dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_done(struct tevent_req *subreq)
    4680             : {
    4681           0 :         struct tevent_req *req = tevent_req_callback_data(
    4682             :                 subreq, struct tevent_req);
    4683           0 :         struct dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_state *state = tevent_req_data(
    4684             :                 req, struct dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_state);
    4685             :         NTSTATUS status;
    4686             :         TALLOC_CTX *mem_ctx;
    4687             : 
    4688           0 :         if (state->out_mem_ctx) {
    4689           0 :                 mem_ctx = state->out_mem_ctx;
    4690             :         } else {
    4691           0 :                 mem_ctx = state;
    4692             :         }
    4693             : 
    4694           0 :         status = dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_r_recv(subreq, mem_ctx);
    4695           0 :         TALLOC_FREE(subreq);
    4696           0 :         if (tevent_req_nterror(req, status)) {
    4697           0 :                 return;
    4698             :         }
    4699             : 
    4700             :         /* Copy out parameters */
    4701           0 :         *state->orig.out.dns_names = *state->tmp.out.dns_names;
    4702             : 
    4703             :         /* Copy result */
    4704           0 :         state->orig.out.result = state->tmp.out.result;
    4705             : 
    4706             :         /* Reset temporary structure */
    4707           0 :         NDR_ZERO_STRUCT(state->tmp);
    4708             : 
    4709           0 :         tevent_req_done(req);
    4710             : }
    4711             : 
    4712           0 : NTSTATUS dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_recv(struct tevent_req *req,
    4713             :                                                                TALLOC_CTX *mem_ctx,
    4714             :                                                                NTSTATUS *result)
    4715             : {
    4716           0 :         struct dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_state *state = tevent_req_data(
    4717             :                 req, struct dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_state);
    4718             :         NTSTATUS status;
    4719             : 
    4720           0 :         if (tevent_req_is_nterror(req, &status)) {
    4721           0 :                 tevent_req_received(req);
    4722           0 :                 return status;
    4723             :         }
    4724             : 
    4725             :         /* Steal possible out parameters to the callers context */
    4726           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    4727             : 
    4728             :         /* Return result */
    4729           0 :         *result = state->orig.out.result;
    4730             : 
    4731           0 :         tevent_req_received(req);
    4732           0 :         return NT_STATUS_OK;
    4733             : }
    4734             : 
    4735           0 : NTSTATUS dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords(struct dcerpc_binding_handle *h,
    4736             :                                                           TALLOC_CTX *mem_ctx,
    4737             :                                                           const char *_site_name /* [in] [charset(UTF16),unique] */,
    4738             :                                                           uint32_t _dns_ttl /* [in]  */,
    4739             :                                                           struct NL_DNS_NAME_INFO_ARRAY *_dns_names /* [in,out] [ref] */,
    4740             :                                                           NTSTATUS *result)
    4741             : {
    4742             :         struct winbind_DsrUpdateReadOnlyServerDnsRecords r;
    4743             :         NTSTATUS status;
    4744             : 
    4745             :         /* In parameters */
    4746           0 :         r.in.site_name = _site_name;
    4747           0 :         r.in.dns_ttl = _dns_ttl;
    4748           0 :         r.in.dns_names = _dns_names;
    4749             : 
    4750             :         /* Out parameters */
    4751           0 :         r.out.dns_names = _dns_names;
    4752             : 
    4753             :         /* Result */
    4754           0 :         NDR_ZERO_STRUCT(r.out.result);
    4755             : 
    4756           0 :         status = dcerpc_winbind_DsrUpdateReadOnlyServerDnsRecords_r(h, mem_ctx, &r);
    4757           0 :         if (!NT_STATUS_IS_OK(status)) {
    4758           0 :                 return status;
    4759             :         }
    4760             : 
    4761             :         /* Return variables */
    4762           0 :         *_dns_names = *r.out.dns_names;
    4763             : 
    4764             :         /* Return result */
    4765           0 :         *result = r.out.result;
    4766             : 
    4767           0 :         return NT_STATUS_OK;
    4768             : }
    4769             : 
    4770             : struct dcerpc_winbind_LogonControl_r_state {
    4771             :         TALLOC_CTX *out_mem_ctx;
    4772             : };
    4773             : 
    4774             : static void dcerpc_winbind_LogonControl_r_done(struct tevent_req *subreq);
    4775             : 
    4776         165 : struct tevent_req *dcerpc_winbind_LogonControl_r_send(TALLOC_CTX *mem_ctx,
    4777             :         struct tevent_context *ev,
    4778             :         struct dcerpc_binding_handle *h,
    4779             :         struct winbind_LogonControl *r)
    4780             : {
    4781             :         struct tevent_req *req;
    4782             :         struct dcerpc_winbind_LogonControl_r_state *state;
    4783             :         struct tevent_req *subreq;
    4784             : 
    4785         165 :         req = tevent_req_create(mem_ctx, &state,
    4786             :                                 struct dcerpc_winbind_LogonControl_r_state);
    4787         165 :         if (req == NULL) {
    4788           0 :                 return NULL;
    4789             :         }
    4790             : 
    4791         165 :         state->out_mem_ctx = talloc_new(state);
    4792         165 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    4793           0 :                 return tevent_req_post(req, ev);
    4794             :         }
    4795             : 
    4796         165 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    4797             :                         NULL, &ndr_table_winbind,
    4798         165 :                         NDR_WINBIND_LOGONCONTROL, state->out_mem_ctx, r);
    4799         165 :         if (tevent_req_nomem(subreq, req)) {
    4800           0 :                 return tevent_req_post(req, ev);
    4801             :         }
    4802         165 :         tevent_req_set_callback(subreq, dcerpc_winbind_LogonControl_r_done, req);
    4803             : 
    4804         165 :         return req;
    4805             : }
    4806             : 
    4807         165 : static void dcerpc_winbind_LogonControl_r_done(struct tevent_req *subreq)
    4808             : {
    4809         109 :         struct tevent_req *req =
    4810         165 :                 tevent_req_callback_data(subreq,
    4811             :                 struct tevent_req);
    4812             :         NTSTATUS status;
    4813             : 
    4814         165 :         status = dcerpc_binding_handle_call_recv(subreq);
    4815         165 :         TALLOC_FREE(subreq);
    4816         165 :         if (tevent_req_nterror(req, status)) {
    4817           0 :                 return;
    4818             :         }
    4819             : 
    4820         165 :         tevent_req_done(req);
    4821             : }
    4822             : 
    4823         165 : NTSTATUS dcerpc_winbind_LogonControl_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    4824             : {
    4825         109 :         struct dcerpc_winbind_LogonControl_r_state *state =
    4826         165 :                 tevent_req_data(req,
    4827             :                 struct dcerpc_winbind_LogonControl_r_state);
    4828             :         NTSTATUS status;
    4829             : 
    4830         165 :         if (tevent_req_is_nterror(req, &status)) {
    4831           0 :                 tevent_req_received(req);
    4832           0 :                 return status;
    4833             :         }
    4834             : 
    4835         165 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    4836             : 
    4837         165 :         tevent_req_received(req);
    4838         165 :         return NT_STATUS_OK;
    4839             : }
    4840             : 
    4841           0 : NTSTATUS dcerpc_winbind_LogonControl_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct winbind_LogonControl *r)
    4842             : {
    4843             :         NTSTATUS status;
    4844             : 
    4845           0 :         status = dcerpc_binding_handle_call(h,
    4846             :                         NULL, &ndr_table_winbind,
    4847             :                         NDR_WINBIND_LOGONCONTROL, mem_ctx, r);
    4848             : 
    4849           0 :         return status;
    4850             : }
    4851             : 
    4852             : struct dcerpc_winbind_LogonControl_state {
    4853             :         struct winbind_LogonControl orig;
    4854             :         struct winbind_LogonControl tmp;
    4855             :         TALLOC_CTX *out_mem_ctx;
    4856             : };
    4857             : 
    4858             : static void dcerpc_winbind_LogonControl_done(struct tevent_req *subreq);
    4859             : 
    4860         165 : struct tevent_req *dcerpc_winbind_LogonControl_send(TALLOC_CTX *mem_ctx,
    4861             :                                                     struct tevent_context *ev,
    4862             :                                                     struct dcerpc_binding_handle *h,
    4863             :                                                     enum netr_LogonControlCode _function_code /* [in]  */,
    4864             :                                                     uint32_t _level /* [in]  */,
    4865             :                                                     union netr_CONTROL_DATA_INFORMATION *_data /* [in] [ref,switch_is(function_code)] */,
    4866             :                                                     union netr_CONTROL_QUERY_INFORMATION *_query /* [out] [ref,switch_is(level)] */)
    4867             : {
    4868             :         struct tevent_req *req;
    4869             :         struct dcerpc_winbind_LogonControl_state *state;
    4870             :         struct tevent_req *subreq;
    4871             : 
    4872         165 :         req = tevent_req_create(mem_ctx, &state,
    4873             :                                 struct dcerpc_winbind_LogonControl_state);
    4874         165 :         if (req == NULL) {
    4875           0 :                 return NULL;
    4876             :         }
    4877         165 :         state->out_mem_ctx = NULL;
    4878             : 
    4879             :         /* In parameters */
    4880         165 :         state->orig.in.function_code = _function_code;
    4881         165 :         state->orig.in.level = _level;
    4882         165 :         state->orig.in.data = _data;
    4883             : 
    4884             :         /* Out parameters */
    4885         165 :         state->orig.out.query = _query;
    4886             : 
    4887             :         /* Result */
    4888         165 :         NDR_ZERO_STRUCT(state->orig.out.result);
    4889             : 
    4890         165 :         state->out_mem_ctx = talloc_named_const(state, 0,
    4891             :                              "dcerpc_winbind_LogonControl_out_memory");
    4892         165 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    4893           0 :                 return tevent_req_post(req, ev);
    4894             :         }
    4895             : 
    4896             :         /* make a temporary copy, that we pass to the dispatch function */
    4897         165 :         state->tmp = state->orig;
    4898             : 
    4899         165 :         subreq = dcerpc_winbind_LogonControl_r_send(state, ev, h, &state->tmp);
    4900         165 :         if (tevent_req_nomem(subreq, req)) {
    4901           0 :                 return tevent_req_post(req, ev);
    4902             :         }
    4903         165 :         tevent_req_set_callback(subreq, dcerpc_winbind_LogonControl_done, req);
    4904         165 :         return req;
    4905             : }
    4906             : 
    4907         165 : static void dcerpc_winbind_LogonControl_done(struct tevent_req *subreq)
    4908             : {
    4909         165 :         struct tevent_req *req = tevent_req_callback_data(
    4910             :                 subreq, struct tevent_req);
    4911         165 :         struct dcerpc_winbind_LogonControl_state *state = tevent_req_data(
    4912             :                 req, struct dcerpc_winbind_LogonControl_state);
    4913             :         NTSTATUS status;
    4914             :         TALLOC_CTX *mem_ctx;
    4915             : 
    4916         165 :         if (state->out_mem_ctx) {
    4917         165 :                 mem_ctx = state->out_mem_ctx;
    4918             :         } else {
    4919           0 :                 mem_ctx = state;
    4920             :         }
    4921             : 
    4922         165 :         status = dcerpc_winbind_LogonControl_r_recv(subreq, mem_ctx);
    4923         165 :         TALLOC_FREE(subreq);
    4924         165 :         if (tevent_req_nterror(req, status)) {
    4925           0 :                 return;
    4926             :         }
    4927             : 
    4928             :         /* Copy out parameters */
    4929         165 :         *state->orig.out.query = *state->tmp.out.query;
    4930             : 
    4931             :         /* Copy result */
    4932         165 :         state->orig.out.result = state->tmp.out.result;
    4933             : 
    4934             :         /* Reset temporary structure */
    4935         165 :         NDR_ZERO_STRUCT(state->tmp);
    4936             : 
    4937         165 :         tevent_req_done(req);
    4938             : }
    4939             : 
    4940         165 : NTSTATUS dcerpc_winbind_LogonControl_recv(struct tevent_req *req,
    4941             :                                           TALLOC_CTX *mem_ctx,
    4942             :                                           WERROR *result)
    4943             : {
    4944         165 :         struct dcerpc_winbind_LogonControl_state *state = tevent_req_data(
    4945             :                 req, struct dcerpc_winbind_LogonControl_state);
    4946             :         NTSTATUS status;
    4947             : 
    4948         165 :         if (tevent_req_is_nterror(req, &status)) {
    4949           0 :                 tevent_req_received(req);
    4950           0 :                 return status;
    4951             :         }
    4952             : 
    4953             :         /* Steal possible out parameters to the callers context */
    4954         165 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    4955             : 
    4956             :         /* Return result */
    4957         165 :         *result = state->orig.out.result;
    4958             : 
    4959         165 :         tevent_req_received(req);
    4960         165 :         return NT_STATUS_OK;
    4961             : }
    4962             : 
    4963           0 : NTSTATUS dcerpc_winbind_LogonControl(struct dcerpc_binding_handle *h,
    4964             :                                      TALLOC_CTX *mem_ctx,
    4965             :                                      enum netr_LogonControlCode _function_code /* [in]  */,
    4966             :                                      uint32_t _level /* [in]  */,
    4967             :                                      union netr_CONTROL_DATA_INFORMATION *_data /* [in] [ref,switch_is(function_code)] */,
    4968             :                                      union netr_CONTROL_QUERY_INFORMATION *_query /* [out] [ref,switch_is(level)] */,
    4969             :                                      WERROR *result)
    4970             : {
    4971             :         struct winbind_LogonControl r;
    4972             :         NTSTATUS status;
    4973             : 
    4974             :         /* In parameters */
    4975           0 :         r.in.function_code = _function_code;
    4976           0 :         r.in.level = _level;
    4977           0 :         r.in.data = _data;
    4978             : 
    4979             :         /* Out parameters */
    4980           0 :         r.out.query = _query;
    4981             : 
    4982             :         /* Result */
    4983           0 :         NDR_ZERO_STRUCT(r.out.result);
    4984             : 
    4985           0 :         status = dcerpc_winbind_LogonControl_r(h, mem_ctx, &r);
    4986           0 :         if (!NT_STATUS_IS_OK(status)) {
    4987           0 :                 return status;
    4988             :         }
    4989             : 
    4990             :         /* Return variables */
    4991           0 :         *_query = *r.out.query;
    4992             : 
    4993             :         /* Return result */
    4994           0 :         *result = r.out.result;
    4995             : 
    4996           0 :         return NT_STATUS_OK;
    4997             : }
    4998             : 
    4999             : struct dcerpc_winbind_GetForestTrustInformation_r_state {
    5000             :         TALLOC_CTX *out_mem_ctx;
    5001             : };
    5002             : 
    5003             : static void dcerpc_winbind_GetForestTrustInformation_r_done(struct tevent_req *subreq);
    5004             : 
    5005          20 : struct tevent_req *dcerpc_winbind_GetForestTrustInformation_r_send(TALLOC_CTX *mem_ctx,
    5006             :         struct tevent_context *ev,
    5007             :         struct dcerpc_binding_handle *h,
    5008             :         struct winbind_GetForestTrustInformation *r)
    5009             : {
    5010             :         struct tevent_req *req;
    5011             :         struct dcerpc_winbind_GetForestTrustInformation_r_state *state;
    5012             :         struct tevent_req *subreq;
    5013             : 
    5014          20 :         req = tevent_req_create(mem_ctx, &state,
    5015             :                                 struct dcerpc_winbind_GetForestTrustInformation_r_state);
    5016          20 :         if (req == NULL) {
    5017           0 :                 return NULL;
    5018             :         }
    5019             : 
    5020          20 :         state->out_mem_ctx = talloc_new(state);
    5021          20 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    5022           0 :                 return tevent_req_post(req, ev);
    5023             :         }
    5024             : 
    5025          20 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    5026             :                         NULL, &ndr_table_winbind,
    5027          20 :                         NDR_WINBIND_GETFORESTTRUSTINFORMATION, state->out_mem_ctx, r);
    5028          20 :         if (tevent_req_nomem(subreq, req)) {
    5029           0 :                 return tevent_req_post(req, ev);
    5030             :         }
    5031          20 :         tevent_req_set_callback(subreq, dcerpc_winbind_GetForestTrustInformation_r_done, req);
    5032             : 
    5033          20 :         return req;
    5034             : }
    5035             : 
    5036          20 : static void dcerpc_winbind_GetForestTrustInformation_r_done(struct tevent_req *subreq)
    5037             : {
    5038          10 :         struct tevent_req *req =
    5039          20 :                 tevent_req_callback_data(subreq,
    5040             :                 struct tevent_req);
    5041             :         NTSTATUS status;
    5042             : 
    5043          20 :         status = dcerpc_binding_handle_call_recv(subreq);
    5044          20 :         TALLOC_FREE(subreq);
    5045          20 :         if (tevent_req_nterror(req, status)) {
    5046           0 :                 return;
    5047             :         }
    5048             : 
    5049          20 :         tevent_req_done(req);
    5050             : }
    5051             : 
    5052          20 : NTSTATUS dcerpc_winbind_GetForestTrustInformation_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    5053             : {
    5054          10 :         struct dcerpc_winbind_GetForestTrustInformation_r_state *state =
    5055          20 :                 tevent_req_data(req,
    5056             :                 struct dcerpc_winbind_GetForestTrustInformation_r_state);
    5057             :         NTSTATUS status;
    5058             : 
    5059          20 :         if (tevent_req_is_nterror(req, &status)) {
    5060           0 :                 tevent_req_received(req);
    5061           0 :                 return status;
    5062             :         }
    5063             : 
    5064          20 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    5065             : 
    5066          20 :         tevent_req_received(req);
    5067          20 :         return NT_STATUS_OK;
    5068             : }
    5069             : 
    5070           0 : NTSTATUS dcerpc_winbind_GetForestTrustInformation_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct winbind_GetForestTrustInformation *r)
    5071             : {
    5072             :         NTSTATUS status;
    5073             : 
    5074           0 :         status = dcerpc_binding_handle_call(h,
    5075             :                         NULL, &ndr_table_winbind,
    5076             :                         NDR_WINBIND_GETFORESTTRUSTINFORMATION, mem_ctx, r);
    5077             : 
    5078           0 :         return status;
    5079             : }
    5080             : 
    5081             : struct dcerpc_winbind_GetForestTrustInformation_state {
    5082             :         struct winbind_GetForestTrustInformation orig;
    5083             :         struct winbind_GetForestTrustInformation tmp;
    5084             :         TALLOC_CTX *out_mem_ctx;
    5085             : };
    5086             : 
    5087             : static void dcerpc_winbind_GetForestTrustInformation_done(struct tevent_req *subreq);
    5088             : 
    5089          20 : struct tevent_req *dcerpc_winbind_GetForestTrustInformation_send(TALLOC_CTX *mem_ctx,
    5090             :                                                                  struct tevent_context *ev,
    5091             :                                                                  struct dcerpc_binding_handle *h,
    5092             :                                                                  const char *_trusted_domain_name /* [in] [charset(UTF16),unique] */,
    5093             :                                                                  uint32_t _flags /* [in]  */,
    5094             :                                                                  struct lsa_ForestTrustInformation **_forest_trust_info /* [out] [ref] */)
    5095             : {
    5096             :         struct tevent_req *req;
    5097             :         struct dcerpc_winbind_GetForestTrustInformation_state *state;
    5098             :         struct tevent_req *subreq;
    5099             : 
    5100          20 :         req = tevent_req_create(mem_ctx, &state,
    5101             :                                 struct dcerpc_winbind_GetForestTrustInformation_state);
    5102          20 :         if (req == NULL) {
    5103           0 :                 return NULL;
    5104             :         }
    5105          20 :         state->out_mem_ctx = NULL;
    5106             : 
    5107             :         /* In parameters */
    5108          20 :         state->orig.in.trusted_domain_name = _trusted_domain_name;
    5109          20 :         state->orig.in.flags = _flags;
    5110             : 
    5111             :         /* Out parameters */
    5112          20 :         state->orig.out.forest_trust_info = _forest_trust_info;
    5113             : 
    5114             :         /* Result */
    5115          20 :         NDR_ZERO_STRUCT(state->orig.out.result);
    5116             : 
    5117          20 :         state->out_mem_ctx = talloc_named_const(state, 0,
    5118             :                              "dcerpc_winbind_GetForestTrustInformation_out_memory");
    5119          20 :         if (tevent_req_nomem(state->out_mem_ctx, req)) {
    5120           0 :                 return tevent_req_post(req, ev);
    5121             :         }
    5122             : 
    5123             :         /* make a temporary copy, that we pass to the dispatch function */
    5124          20 :         state->tmp = state->orig;
    5125             : 
    5126          20 :         subreq = dcerpc_winbind_GetForestTrustInformation_r_send(state, ev, h, &state->tmp);
    5127          20 :         if (tevent_req_nomem(subreq, req)) {
    5128           0 :                 return tevent_req_post(req, ev);
    5129             :         }
    5130          20 :         tevent_req_set_callback(subreq, dcerpc_winbind_GetForestTrustInformation_done, req);
    5131          20 :         return req;
    5132             : }
    5133             : 
    5134          20 : static void dcerpc_winbind_GetForestTrustInformation_done(struct tevent_req *subreq)
    5135             : {
    5136          20 :         struct tevent_req *req = tevent_req_callback_data(
    5137             :                 subreq, struct tevent_req);
    5138          20 :         struct dcerpc_winbind_GetForestTrustInformation_state *state = tevent_req_data(
    5139             :                 req, struct dcerpc_winbind_GetForestTrustInformation_state);
    5140             :         NTSTATUS status;
    5141             :         TALLOC_CTX *mem_ctx;
    5142             : 
    5143          20 :         if (state->out_mem_ctx) {
    5144          20 :                 mem_ctx = state->out_mem_ctx;
    5145             :         } else {
    5146           0 :                 mem_ctx = state;
    5147             :         }
    5148             : 
    5149          20 :         status = dcerpc_winbind_GetForestTrustInformation_r_recv(subreq, mem_ctx);
    5150          20 :         TALLOC_FREE(subreq);
    5151          20 :         if (tevent_req_nterror(req, status)) {
    5152           0 :                 return;
    5153             :         }
    5154             : 
    5155             :         /* Copy out parameters */
    5156          20 :         *state->orig.out.forest_trust_info = *state->tmp.out.forest_trust_info;
    5157             : 
    5158             :         /* Copy result */
    5159          20 :         state->orig.out.result = state->tmp.out.result;
    5160             : 
    5161             :         /* Reset temporary structure */
    5162          20 :         NDR_ZERO_STRUCT(state->tmp);
    5163             : 
    5164          20 :         tevent_req_done(req);
    5165             : }
    5166             : 
    5167          20 : NTSTATUS dcerpc_winbind_GetForestTrustInformation_recv(struct tevent_req *req,
    5168             :                                                        TALLOC_CTX *mem_ctx,
    5169             :                                                        WERROR *result)
    5170             : {
    5171          20 :         struct dcerpc_winbind_GetForestTrustInformation_state *state = tevent_req_data(
    5172             :                 req, struct dcerpc_winbind_GetForestTrustInformation_state);
    5173             :         NTSTATUS status;
    5174             : 
    5175          20 :         if (tevent_req_is_nterror(req, &status)) {
    5176           0 :                 tevent_req_received(req);
    5177           0 :                 return status;
    5178             :         }
    5179             : 
    5180             :         /* Steal possible out parameters to the callers context */
    5181          20 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    5182             : 
    5183             :         /* Return result */
    5184          20 :         *result = state->orig.out.result;
    5185             : 
    5186          20 :         tevent_req_received(req);
    5187          20 :         return NT_STATUS_OK;
    5188             : }
    5189             : 
    5190           0 : NTSTATUS dcerpc_winbind_GetForestTrustInformation(struct dcerpc_binding_handle *h,
    5191             :                                                   TALLOC_CTX *mem_ctx,
    5192             :                                                   const char *_trusted_domain_name /* [in] [charset(UTF16),unique] */,
    5193             :                                                   uint32_t _flags /* [in]  */,
    5194             :                                                   struct lsa_ForestTrustInformation **_forest_trust_info /* [out] [ref] */,
    5195             :                                                   WERROR *result)
    5196             : {
    5197             :         struct winbind_GetForestTrustInformation r;
    5198             :         NTSTATUS status;
    5199             : 
    5200             :         /* In parameters */
    5201           0 :         r.in.trusted_domain_name = _trusted_domain_name;
    5202           0 :         r.in.flags = _flags;
    5203             : 
    5204             :         /* Out parameters */
    5205           0 :         r.out.forest_trust_info = _forest_trust_info;
    5206             : 
    5207             :         /* Result */
    5208           0 :         NDR_ZERO_STRUCT(r.out.result);
    5209             : 
    5210           0 :         status = dcerpc_winbind_GetForestTrustInformation_r(h, mem_ctx, &r);
    5211           0 :         if (!NT_STATUS_IS_OK(status)) {
    5212           0 :                 return status;
    5213             :         }
    5214             : 
    5215             :         /* Return variables */
    5216           0 :         *_forest_trust_info = *r.out.forest_trust_info;
    5217             : 
    5218             :         /* Return result */
    5219           0 :         *result = r.out.result;
    5220             : 
    5221           0 :         return NT_STATUS_OK;
    5222             : }
    5223             : 
    5224             : struct dcerpc_winbind_SendToSam_r_state {
    5225             :         TALLOC_CTX *out_mem_ctx;
    5226             : };
    5227             : 
    5228             : static void dcerpc_winbind_SendToSam_r_done(struct tevent_req *subreq);
    5229             : 
    5230          17 : struct tevent_req *dcerpc_winbind_SendToSam_r_send(TALLOC_CTX *mem_ctx,
    5231             :         struct tevent_context *ev,
    5232             :         struct dcerpc_binding_handle *h,
    5233             :         struct winbind_SendToSam *r)
    5234             : {
    5235             :         struct tevent_req *req;
    5236             :         struct dcerpc_winbind_SendToSam_r_state *state;
    5237             :         struct tevent_req *subreq;
    5238             : 
    5239          17 :         req = tevent_req_create(mem_ctx, &state,
    5240             :                                 struct dcerpc_winbind_SendToSam_r_state);
    5241          17 :         if (req == NULL) {
    5242           0 :                 return NULL;
    5243             :         }
    5244             : 
    5245          17 :         state->out_mem_ctx = NULL;
    5246             : 
    5247          17 :         subreq = dcerpc_binding_handle_call_send(state, ev, h,
    5248             :                         NULL, &ndr_table_winbind,
    5249             :                         NDR_WINBIND_SENDTOSAM, state, r);
    5250          17 :         if (tevent_req_nomem(subreq, req)) {
    5251           0 :                 return tevent_req_post(req, ev);
    5252             :         }
    5253          17 :         tevent_req_set_callback(subreq, dcerpc_winbind_SendToSam_r_done, req);
    5254             : 
    5255          17 :         return req;
    5256             : }
    5257             : 
    5258           0 : static void dcerpc_winbind_SendToSam_r_done(struct tevent_req *subreq)
    5259             : {
    5260           0 :         struct tevent_req *req =
    5261           0 :                 tevent_req_callback_data(subreq,
    5262             :                 struct tevent_req);
    5263             :         NTSTATUS status;
    5264             : 
    5265           0 :         status = dcerpc_binding_handle_call_recv(subreq);
    5266           0 :         TALLOC_FREE(subreq);
    5267           0 :         if (tevent_req_nterror(req, status)) {
    5268           0 :                 return;
    5269             :         }
    5270             : 
    5271           0 :         tevent_req_done(req);
    5272             : }
    5273             : 
    5274           0 : NTSTATUS dcerpc_winbind_SendToSam_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
    5275             : {
    5276           0 :         struct dcerpc_winbind_SendToSam_r_state *state =
    5277           0 :                 tevent_req_data(req,
    5278             :                 struct dcerpc_winbind_SendToSam_r_state);
    5279             :         NTSTATUS status;
    5280             : 
    5281           0 :         if (tevent_req_is_nterror(req, &status)) {
    5282           0 :                 tevent_req_received(req);
    5283           0 :                 return status;
    5284             :         }
    5285             : 
    5286           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    5287             : 
    5288           0 :         tevent_req_received(req);
    5289           0 :         return NT_STATUS_OK;
    5290             : }
    5291             : 
    5292           0 : NTSTATUS dcerpc_winbind_SendToSam_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct winbind_SendToSam *r)
    5293             : {
    5294             :         NTSTATUS status;
    5295             : 
    5296           0 :         status = dcerpc_binding_handle_call(h,
    5297             :                         NULL, &ndr_table_winbind,
    5298             :                         NDR_WINBIND_SENDTOSAM, mem_ctx, r);
    5299             : 
    5300           0 :         return status;
    5301             : }
    5302             : 
    5303             : struct dcerpc_winbind_SendToSam_state {
    5304             :         struct winbind_SendToSam orig;
    5305             :         struct winbind_SendToSam tmp;
    5306             :         TALLOC_CTX *out_mem_ctx;
    5307             : };
    5308             : 
    5309             : static void dcerpc_winbind_SendToSam_done(struct tevent_req *subreq);
    5310             : 
    5311           0 : struct tevent_req *dcerpc_winbind_SendToSam_send(TALLOC_CTX *mem_ctx,
    5312             :                                                  struct tevent_context *ev,
    5313             :                                                  struct dcerpc_binding_handle *h,
    5314             :                                                  struct netr_SendToSamBase _message /* [in]  */)
    5315             : {
    5316             :         struct tevent_req *req;
    5317             :         struct dcerpc_winbind_SendToSam_state *state;
    5318             :         struct tevent_req *subreq;
    5319             : 
    5320           0 :         req = tevent_req_create(mem_ctx, &state,
    5321             :                                 struct dcerpc_winbind_SendToSam_state);
    5322           0 :         if (req == NULL) {
    5323           0 :                 return NULL;
    5324             :         }
    5325           0 :         state->out_mem_ctx = NULL;
    5326             : 
    5327             :         /* In parameters */
    5328           0 :         state->orig.in.message = _message;
    5329             : 
    5330             :         /* Out parameters */
    5331             : 
    5332             :         /* Result */
    5333           0 :         NDR_ZERO_STRUCT(state->orig.out.result);
    5334             : 
    5335             :         /* make a temporary copy, that we pass to the dispatch function */
    5336           0 :         state->tmp = state->orig;
    5337             : 
    5338           0 :         subreq = dcerpc_winbind_SendToSam_r_send(state, ev, h, &state->tmp);
    5339           0 :         if (tevent_req_nomem(subreq, req)) {
    5340           0 :                 return tevent_req_post(req, ev);
    5341             :         }
    5342           0 :         tevent_req_set_callback(subreq, dcerpc_winbind_SendToSam_done, req);
    5343           0 :         return req;
    5344             : }
    5345             : 
    5346           0 : static void dcerpc_winbind_SendToSam_done(struct tevent_req *subreq)
    5347             : {
    5348           0 :         struct tevent_req *req = tevent_req_callback_data(
    5349             :                 subreq, struct tevent_req);
    5350           0 :         struct dcerpc_winbind_SendToSam_state *state = tevent_req_data(
    5351             :                 req, struct dcerpc_winbind_SendToSam_state);
    5352             :         NTSTATUS status;
    5353             :         TALLOC_CTX *mem_ctx;
    5354             : 
    5355           0 :         if (state->out_mem_ctx) {
    5356           0 :                 mem_ctx = state->out_mem_ctx;
    5357             :         } else {
    5358           0 :                 mem_ctx = state;
    5359             :         }
    5360             : 
    5361           0 :         status = dcerpc_winbind_SendToSam_r_recv(subreq, mem_ctx);
    5362           0 :         TALLOC_FREE(subreq);
    5363           0 :         if (tevent_req_nterror(req, status)) {
    5364           0 :                 return;
    5365             :         }
    5366             : 
    5367             :         /* Copy out parameters */
    5368             : 
    5369             :         /* Copy result */
    5370           0 :         state->orig.out.result = state->tmp.out.result;
    5371             : 
    5372             :         /* Reset temporary structure */
    5373           0 :         NDR_ZERO_STRUCT(state->tmp);
    5374             : 
    5375           0 :         tevent_req_done(req);
    5376             : }
    5377             : 
    5378           0 : NTSTATUS dcerpc_winbind_SendToSam_recv(struct tevent_req *req,
    5379             :                                        TALLOC_CTX *mem_ctx,
    5380             :                                        NTSTATUS *result)
    5381             : {
    5382           0 :         struct dcerpc_winbind_SendToSam_state *state = tevent_req_data(
    5383             :                 req, struct dcerpc_winbind_SendToSam_state);
    5384             :         NTSTATUS status;
    5385             : 
    5386           0 :         if (tevent_req_is_nterror(req, &status)) {
    5387           0 :                 tevent_req_received(req);
    5388           0 :                 return status;
    5389             :         }
    5390             : 
    5391             :         /* Steal possible out parameters to the callers context */
    5392           0 :         talloc_steal(mem_ctx, state->out_mem_ctx);
    5393             : 
    5394             :         /* Return result */
    5395           0 :         *result = state->orig.out.result;
    5396             : 
    5397           0 :         tevent_req_received(req);
    5398           0 :         return NT_STATUS_OK;
    5399             : }
    5400             : 
    5401           0 : NTSTATUS dcerpc_winbind_SendToSam(struct dcerpc_binding_handle *h,
    5402             :                                   TALLOC_CTX *mem_ctx,
    5403             :                                   struct netr_SendToSamBase _message /* [in]  */,
    5404             :                                   NTSTATUS *result)
    5405             : {
    5406             :         struct winbind_SendToSam r;
    5407             :         NTSTATUS status;
    5408             : 
    5409             :         /* In parameters */
    5410           0 :         r.in.message = _message;
    5411             : 
    5412             :         /* Out parameters */
    5413             : 
    5414             :         /* Result */
    5415           0 :         NDR_ZERO_STRUCT(r.out.result);
    5416             : 
    5417           0 :         status = dcerpc_winbind_SendToSam_r(h, mem_ctx, &r);
    5418           0 :         if (!NT_STATUS_IS_OK(status)) {
    5419           0 :                 return status;
    5420             :         }
    5421             : 
    5422             :         /* Return variables */
    5423             : 
    5424             :         /* Return result */
    5425           0 :         *result = r.out.result;
    5426             : 
    5427           0 :         return NT_STATUS_OK;
    5428             : }
    5429             : 

Generated by: LCOV version 1.13