source3/librpc/gen_ndr/ndr_srvsvc_c.c

   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 "librpc/gen_ndr/ndr_srvsvc.h"
   7 #include "librpc/gen_ndr/ndr_srvsvc_c.h"
   8
   9 /* srvsvc - client functions generated by pidl */
  10
  11 struct dcerpc_srvsvc_NetCharDevEnum_r_state {
  12         TALLOC_CTX *out_mem_ctx;
  13 };
  14
  15 static void dcerpc_srvsvc_NetCharDevEnum_r_done(struct tevent_req *subreq);
  16
  17 struct tevent_req *dcerpc_srvsvc_NetCharDevEnum_r_send(TALLOC_CTX *mem_ctx,
  18         struct tevent_context *ev,
  19         struct dcerpc_binding_handle *h,
  20         struct srvsvc_NetCharDevEnum *r)
  21 {
  22         struct tevent_req *req;
  23         struct dcerpc_srvsvc_NetCharDevEnum_r_state *state;
  24         struct tevent_req *subreq;
  25
  26         req = tevent_req_create(mem_ctx, &state,
  27                                 struct dcerpc_srvsvc_NetCharDevEnum_r_state);
  28         if (req == NULL) {
  29                 return NULL;
  30         }
  31
  32         state->out_mem_ctx = talloc_new(state);
  33         if (tevent_req_nomem(state->out_mem_ctx, req)) {
  34                 return tevent_req_post(req, ev);
  35         }
  36
  37         subreq = dcerpc_binding_handle_call_send(state, ev, h,
  38                         NULL, &ndr_table_srvsvc,
  39                         NDR_SRVSVC_NETCHARDEVENUM, state->out_mem_ctx, r);
  40         if (tevent_req_nomem(subreq, req)) {
  41                 return tevent_req_post(req, ev);
  42         }
  43         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetCharDevEnum_r_done, req);
  44
  45         return req;
  46 }
  47
  48 static void dcerpc_srvsvc_NetCharDevEnum_r_done(struct tevent_req *subreq)
  49 {
  50         struct tevent_req *req =
  51                 tevent_req_callback_data(subreq,
  52                 struct tevent_req);
  53         NTSTATUS status;
  54
  55         status = dcerpc_binding_handle_call_recv(subreq);
  56         if (!NT_STATUS_IS_OK(status)) {
  57                 tevent_req_nterror(req, status);
  58                 return;
  59         }
  60
  61         tevent_req_done(req);
  62 }
  63
  64 NTSTATUS dcerpc_srvsvc_NetCharDevEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
  65 {
  66         struct dcerpc_srvsvc_NetCharDevEnum_r_state *state =
  67                 tevent_req_data(req,
  68                 struct dcerpc_srvsvc_NetCharDevEnum_r_state);
  69         NTSTATUS status;
  70
  71         if (tevent_req_is_nterror(req, &status)) {
  72                 tevent_req_received(req);
  73                 return status;
  74         }
  75
  76         talloc_steal(mem_ctx, state->out_mem_ctx);
  77
  78         tevent_req_received(req);
  79         return NT_STATUS_OK;
  80 }
  81
  82 NTSTATUS dcerpc_srvsvc_NetCharDevEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetCharDevEnum *r)
  83 {
  84         NTSTATUS status;
  85
  86         status = dcerpc_binding_handle_call(h,
  87                         NULL, &ndr_table_srvsvc,
  88                         NDR_SRVSVC_NETCHARDEVENUM, mem_ctx, r);
  89
  90         return status;
  91 }
  92
  93 NTSTATUS dcerpc_srvsvc_NetCharDevEnum_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetCharDevEnum *r)
  94 {
  95         NTSTATUS status;
  96
  97         status = dcerpc_srvsvc_NetCharDevEnum_r(p->binding_handle, mem_ctx, r);
  98
  99         if (NT_STATUS_IS_RPC(status)) {
 100                 status = NT_STATUS_NET_WRITE_FAULT;
 101         }
 102
 103         return status;
 104 }
 105
 106 struct dcerpc_srvsvc_NetCharDevEnum_state {
 107         struct srvsvc_NetCharDevEnum orig;
 108         struct srvsvc_NetCharDevEnum tmp;
 109         TALLOC_CTX *out_mem_ctx;
 110 };
 111
 112 static void dcerpc_srvsvc_NetCharDevEnum_done(struct tevent_req *subreq);
 113
 114 struct tevent_req *dcerpc_srvsvc_NetCharDevEnum_send(TALLOC_CTX *mem_ctx,
 115                                                      struct tevent_context *ev,
 116                                                      struct dcerpc_binding_handle *h,
 117                                                      const char *_server_unc /* [in] [unique,charset(UTF16)] */,
 118                                                      struct srvsvc_NetCharDevInfoCtr *_info_ctr /* [in,out] [ref] */,
 119                                                      uint32_t _max_buffer /* [in]  */,
 120                                                      uint32_t *_totalentries /* [out] [ref] */,
 121                                                      uint32_t *_resume_handle /* [in,out] [unique] */)
 122 {
 123         struct tevent_req *req;
 124         struct dcerpc_srvsvc_NetCharDevEnum_state *state;
 125         struct tevent_req *subreq;
 126
 127         req = tevent_req_create(mem_ctx, &state,
 128                                 struct dcerpc_srvsvc_NetCharDevEnum_state);
 129         if (req == NULL) {
 130                 return NULL;
 131         }
 132         state->out_mem_ctx = NULL;
 133
 134         /* In parameters */
 135         state->orig.in.server_unc = _server_unc;
 136         state->orig.in.info_ctr = _info_ctr;
 137         state->orig.in.max_buffer = _max_buffer;
 138         state->orig.in.resume_handle = _resume_handle;
 139
 140         /* Out parameters */
 141         state->orig.out.info_ctr = _info_ctr;
 142         state->orig.out.totalentries = _totalentries;
 143         state->orig.out.resume_handle = _resume_handle;
 144
 145         /* Result */
 146         ZERO_STRUCT(state->orig.out.result);
 147
 148         state->out_mem_ctx = talloc_named_const(state, 0,
 149                              "dcerpc_srvsvc_NetCharDevEnum_out_memory");
 150         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 151                 return tevent_req_post(req, ev);
 152         }
 153
 154         /* make a temporary copy, that we pass to the dispatch function */
 155         state->tmp = state->orig;
 156
 157         subreq = dcerpc_srvsvc_NetCharDevEnum_r_send(state, ev, h, &state->tmp);
 158         if (tevent_req_nomem(subreq, req)) {
 159                 return tevent_req_post(req, ev);
 160         }
 161         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetCharDevEnum_done, req);
 162         return req;
 163 }
 164
 165 static void dcerpc_srvsvc_NetCharDevEnum_done(struct tevent_req *subreq)
 166 {
 167         struct tevent_req *req = tevent_req_callback_data(
 168                 subreq, struct tevent_req);
 169         struct dcerpc_srvsvc_NetCharDevEnum_state *state = tevent_req_data(
 170                 req, struct dcerpc_srvsvc_NetCharDevEnum_state);
 171         NTSTATUS status;
 172         TALLOC_CTX *mem_ctx;
 173
 174         if (state->out_mem_ctx) {
 175                 mem_ctx = state->out_mem_ctx;
 176         } else {
 177                 mem_ctx = state;
 178         }
 179
 180         status = dcerpc_srvsvc_NetCharDevEnum_r_recv(subreq, mem_ctx);
 181         TALLOC_FREE(subreq);
 182         if (!NT_STATUS_IS_OK(status)) {
 183                 tevent_req_nterror(req, status);
 184                 return;
 185         }
 186
 187         /* Copy out parameters */
 188         *state->orig.out.info_ctr = *state->tmp.out.info_ctr;
 189         *state->orig.out.totalentries = *state->tmp.out.totalentries;
 190         if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
 191                 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
 192         }
 193
 194         /* Copy result */
 195         state->orig.out.result = state->tmp.out.result;
 196
 197         /* Reset temporary structure */
 198         ZERO_STRUCT(state->tmp);
 199
 200         tevent_req_done(req);
 201 }
 202
 203 NTSTATUS dcerpc_srvsvc_NetCharDevEnum_recv(struct tevent_req *req,
 204                                            TALLOC_CTX *mem_ctx,
 205                                            WERROR *result)
 206 {
 207         struct dcerpc_srvsvc_NetCharDevEnum_state *state = tevent_req_data(
 208                 req, struct dcerpc_srvsvc_NetCharDevEnum_state);
 209         NTSTATUS status;
 210
 211         if (tevent_req_is_nterror(req, &status)) {
 212                 tevent_req_received(req);
 213                 return status;
 214         }
 215
 216         /* Steal possible out parameters to the callers context */
 217         talloc_steal(mem_ctx, state->out_mem_ctx);
 218
 219         /* Return result */
 220         *result = state->orig.out.result;
 221
 222         tevent_req_received(req);
 223         return NT_STATUS_OK;
 224 }
 225
 226 NTSTATUS dcerpc_srvsvc_NetCharDevEnum(struct dcerpc_binding_handle *h,
 227                                       TALLOC_CTX *mem_ctx,
 228                                       const char *_server_unc /* [in] [unique,charset(UTF16)] */,
 229                                       struct srvsvc_NetCharDevInfoCtr *_info_ctr /* [in,out] [ref] */,
 230                                       uint32_t _max_buffer /* [in]  */,
 231                                       uint32_t *_totalentries /* [out] [ref] */,
 232                                       uint32_t *_resume_handle /* [in,out] [unique] */,
 233                                       WERROR *result)
 234 {
 235         struct srvsvc_NetCharDevEnum r;
 236         NTSTATUS status;
 237
 238         /* In parameters */
 239         r.in.server_unc = _server_unc;
 240         r.in.info_ctr = _info_ctr;
 241         r.in.max_buffer = _max_buffer;
 242         r.in.resume_handle = _resume_handle;
 243
 244         status = dcerpc_srvsvc_NetCharDevEnum_r(h, mem_ctx, &r);
 245         if (!NT_STATUS_IS_OK(status)) {
 246                 return status;
 247         }
 248
 249         /* Return variables */
 250         *_info_ctr = *r.out.info_ctr;
 251         *_totalentries = *r.out.totalentries;
 252         if (_resume_handle && r.out.resume_handle) {
 253                 *_resume_handle = *r.out.resume_handle;
 254         }
 255
 256         /* Return result */
 257         *result = r.out.result;
 258
 259         return NT_STATUS_OK;
 260 }
 261
 262 struct dcerpc_srvsvc_NetCharDevGetInfo_r_state {
 263         TALLOC_CTX *out_mem_ctx;
 264 };
 265
 266 static void dcerpc_srvsvc_NetCharDevGetInfo_r_done(struct tevent_req *subreq);
 267
 268 struct tevent_req *dcerpc_srvsvc_NetCharDevGetInfo_r_send(TALLOC_CTX *mem_ctx,
 269         struct tevent_context *ev,
 270         struct dcerpc_binding_handle *h,
 271         struct srvsvc_NetCharDevGetInfo *r)
 272 {
 273         struct tevent_req *req;
 274         struct dcerpc_srvsvc_NetCharDevGetInfo_r_state *state;
 275         struct tevent_req *subreq;
 276
 277         req = tevent_req_create(mem_ctx, &state,
 278                                 struct dcerpc_srvsvc_NetCharDevGetInfo_r_state);
 279         if (req == NULL) {
 280                 return NULL;
 281         }
 282
 283         state->out_mem_ctx = talloc_new(state);
 284         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 285                 return tevent_req_post(req, ev);
 286         }
 287
 288         subreq = dcerpc_binding_handle_call_send(state, ev, h,
 289                         NULL, &ndr_table_srvsvc,
 290                         NDR_SRVSVC_NETCHARDEVGETINFO, state->out_mem_ctx, r);
 291         if (tevent_req_nomem(subreq, req)) {
 292                 return tevent_req_post(req, ev);
 293         }
 294         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetCharDevGetInfo_r_done, req);
 295
 296         return req;
 297 }
 298
 299 static void dcerpc_srvsvc_NetCharDevGetInfo_r_done(struct tevent_req *subreq)
 300 {
 301         struct tevent_req *req =
 302                 tevent_req_callback_data(subreq,
 303                 struct tevent_req);
 304         NTSTATUS status;
 305
 306         status = dcerpc_binding_handle_call_recv(subreq);
 307         if (!NT_STATUS_IS_OK(status)) {
 308                 tevent_req_nterror(req, status);
 309                 return;
 310         }
 311
 312         tevent_req_done(req);
 313 }
 314
 315 NTSTATUS dcerpc_srvsvc_NetCharDevGetInfo_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 316 {
 317         struct dcerpc_srvsvc_NetCharDevGetInfo_r_state *state =
 318                 tevent_req_data(req,
 319                 struct dcerpc_srvsvc_NetCharDevGetInfo_r_state);
 320         NTSTATUS status;
 321
 322         if (tevent_req_is_nterror(req, &status)) {
 323                 tevent_req_received(req);
 324                 return status;
 325         }
 326
 327         talloc_steal(mem_ctx, state->out_mem_ctx);
 328
 329         tevent_req_received(req);
 330         return NT_STATUS_OK;
 331 }
 332
 333 NTSTATUS dcerpc_srvsvc_NetCharDevGetInfo_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetCharDevGetInfo *r)
 334 {
 335         NTSTATUS status;
 336
 337         status = dcerpc_binding_handle_call(h,
 338                         NULL, &ndr_table_srvsvc,
 339                         NDR_SRVSVC_NETCHARDEVGETINFO, mem_ctx, r);
 340
 341         return status;
 342 }
 343
 344 NTSTATUS dcerpc_srvsvc_NetCharDevGetInfo_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetCharDevGetInfo *r)
 345 {
 346         NTSTATUS status;
 347
 348         status = dcerpc_srvsvc_NetCharDevGetInfo_r(p->binding_handle, mem_ctx, r);
 349
 350         if (NT_STATUS_IS_RPC(status)) {
 351                 status = NT_STATUS_NET_WRITE_FAULT;
 352         }
 353
 354         return status;
 355 }
 356
 357 struct dcerpc_srvsvc_NetCharDevGetInfo_state {
 358         struct srvsvc_NetCharDevGetInfo orig;
 359         struct srvsvc_NetCharDevGetInfo tmp;
 360         TALLOC_CTX *out_mem_ctx;
 361 };
 362
 363 static void dcerpc_srvsvc_NetCharDevGetInfo_done(struct tevent_req *subreq);
 364
 365 struct tevent_req *dcerpc_srvsvc_NetCharDevGetInfo_send(TALLOC_CTX *mem_ctx,
 366                                                         struct tevent_context *ev,
 367                                                         struct dcerpc_binding_handle *h,
 368                                                         const char *_server_unc /* [in] [unique,charset(UTF16)] */,
 369                                                         const char *_device_name /* [in] [charset(UTF16)] */,
 370                                                         uint32_t _level /* [in]  */,
 371                                                         union srvsvc_NetCharDevInfo *_info /* [out] [ref,switch_is(level)] */)
 372 {
 373         struct tevent_req *req;
 374         struct dcerpc_srvsvc_NetCharDevGetInfo_state *state;
 375         struct tevent_req *subreq;
 376
 377         req = tevent_req_create(mem_ctx, &state,
 378                                 struct dcerpc_srvsvc_NetCharDevGetInfo_state);
 379         if (req == NULL) {
 380                 return NULL;
 381         }
 382         state->out_mem_ctx = NULL;
 383
 384         /* In parameters */
 385         state->orig.in.server_unc = _server_unc;
 386         state->orig.in.device_name = _device_name;
 387         state->orig.in.level = _level;
 388
 389         /* Out parameters */
 390         state->orig.out.info = _info;
 391
 392         /* Result */
 393         ZERO_STRUCT(state->orig.out.result);
 394
 395         state->out_mem_ctx = talloc_named_const(state, 0,
 396                              "dcerpc_srvsvc_NetCharDevGetInfo_out_memory");
 397         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 398                 return tevent_req_post(req, ev);
 399         }
 400
 401         /* make a temporary copy, that we pass to the dispatch function */
 402         state->tmp = state->orig;
 403
 404         subreq = dcerpc_srvsvc_NetCharDevGetInfo_r_send(state, ev, h, &state->tmp);
 405         if (tevent_req_nomem(subreq, req)) {
 406                 return tevent_req_post(req, ev);
 407         }
 408         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetCharDevGetInfo_done, req);
 409         return req;
 410 }
 411
 412 static void dcerpc_srvsvc_NetCharDevGetInfo_done(struct tevent_req *subreq)
 413 {
 414         struct tevent_req *req = tevent_req_callback_data(
 415                 subreq, struct tevent_req);
 416         struct dcerpc_srvsvc_NetCharDevGetInfo_state *state = tevent_req_data(
 417                 req, struct dcerpc_srvsvc_NetCharDevGetInfo_state);
 418         NTSTATUS status;
 419         TALLOC_CTX *mem_ctx;
 420
 421         if (state->out_mem_ctx) {
 422                 mem_ctx = state->out_mem_ctx;
 423         } else {
 424                 mem_ctx = state;
 425         }
 426
 427         status = dcerpc_srvsvc_NetCharDevGetInfo_r_recv(subreq, mem_ctx);
 428         TALLOC_FREE(subreq);
 429         if (!NT_STATUS_IS_OK(status)) {
 430                 tevent_req_nterror(req, status);
 431                 return;
 432         }
 433
 434         /* Copy out parameters */
 435         *state->orig.out.info = *state->tmp.out.info;
 436
 437         /* Copy result */
 438         state->orig.out.result = state->tmp.out.result;
 439
 440         /* Reset temporary structure */
 441         ZERO_STRUCT(state->tmp);
 442
 443         tevent_req_done(req);
 444 }
 445
 446 NTSTATUS dcerpc_srvsvc_NetCharDevGetInfo_recv(struct tevent_req *req,
 447                                               TALLOC_CTX *mem_ctx,
 448                                               WERROR *result)
 449 {
 450         struct dcerpc_srvsvc_NetCharDevGetInfo_state *state = tevent_req_data(
 451                 req, struct dcerpc_srvsvc_NetCharDevGetInfo_state);
 452         NTSTATUS status;
 453
 454         if (tevent_req_is_nterror(req, &status)) {
 455                 tevent_req_received(req);
 456                 return status;
 457         }
 458
 459         /* Steal possible out parameters to the callers context */
 460         talloc_steal(mem_ctx, state->out_mem_ctx);
 461
 462         /* Return result */
 463         *result = state->orig.out.result;
 464
 465         tevent_req_received(req);
 466         return NT_STATUS_OK;
 467 }
 468
 469 NTSTATUS dcerpc_srvsvc_NetCharDevGetInfo(struct dcerpc_binding_handle *h,
 470                                          TALLOC_CTX *mem_ctx,
 471                                          const char *_server_unc /* [in] [unique,charset(UTF16)] */,
 472                                          const char *_device_name /* [in] [charset(UTF16)] */,
 473                                          uint32_t _level /* [in]  */,
 474                                          union srvsvc_NetCharDevInfo *_info /* [out] [ref,switch_is(level)] */,
 475                                          WERROR *result)
 476 {
 477         struct srvsvc_NetCharDevGetInfo r;
 478         NTSTATUS status;
 479
 480         /* In parameters */
 481         r.in.server_unc = _server_unc;
 482         r.in.device_name = _device_name;
 483         r.in.level = _level;
 484
 485         status = dcerpc_srvsvc_NetCharDevGetInfo_r(h, mem_ctx, &r);
 486         if (!NT_STATUS_IS_OK(status)) {
 487                 return status;
 488         }
 489
 490         /* Return variables */
 491         *_info = *r.out.info;
 492
 493         /* Return result */
 494         *result = r.out.result;
 495
 496         return NT_STATUS_OK;
 497 }
 498
 499 struct dcerpc_srvsvc_NetCharDevControl_r_state {
 500         TALLOC_CTX *out_mem_ctx;
 501 };
 502
 503 static void dcerpc_srvsvc_NetCharDevControl_r_done(struct tevent_req *subreq);
 504
 505 struct tevent_req *dcerpc_srvsvc_NetCharDevControl_r_send(TALLOC_CTX *mem_ctx,
 506         struct tevent_context *ev,
 507         struct dcerpc_binding_handle *h,
 508         struct srvsvc_NetCharDevControl *r)
 509 {
 510         struct tevent_req *req;
 511         struct dcerpc_srvsvc_NetCharDevControl_r_state *state;
 512         struct tevent_req *subreq;
 513
 514         req = tevent_req_create(mem_ctx, &state,
 515                                 struct dcerpc_srvsvc_NetCharDevControl_r_state);
 516         if (req == NULL) {
 517                 return NULL;
 518         }
 519
 520         state->out_mem_ctx = NULL;
 521         subreq = dcerpc_binding_handle_call_send(state, ev, h,
 522                         NULL, &ndr_table_srvsvc,
 523                         NDR_SRVSVC_NETCHARDEVCONTROL, state, r);
 524         if (tevent_req_nomem(subreq, req)) {
 525                 return tevent_req_post(req, ev);
 526         }
 527         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetCharDevControl_r_done, req);
 528
 529         return req;
 530 }
 531
 532 static void dcerpc_srvsvc_NetCharDevControl_r_done(struct tevent_req *subreq)
 533 {
 534         struct tevent_req *req =
 535                 tevent_req_callback_data(subreq,
 536                 struct tevent_req);
 537         NTSTATUS status;
 538
 539         status = dcerpc_binding_handle_call_recv(subreq);
 540         if (!NT_STATUS_IS_OK(status)) {
 541                 tevent_req_nterror(req, status);
 542                 return;
 543         }
 544
 545         tevent_req_done(req);
 546 }
 547
 548 NTSTATUS dcerpc_srvsvc_NetCharDevControl_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 549 {
 550         struct dcerpc_srvsvc_NetCharDevControl_r_state *state =
 551                 tevent_req_data(req,
 552                 struct dcerpc_srvsvc_NetCharDevControl_r_state);
 553         NTSTATUS status;
 554
 555         if (tevent_req_is_nterror(req, &status)) {
 556                 tevent_req_received(req);
 557                 return status;
 558         }
 559
 560         talloc_steal(mem_ctx, state->out_mem_ctx);
 561
 562         tevent_req_received(req);
 563         return NT_STATUS_OK;
 564 }
 565
 566 NTSTATUS dcerpc_srvsvc_NetCharDevControl_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetCharDevControl *r)
 567 {
 568         NTSTATUS status;
 569
 570         status = dcerpc_binding_handle_call(h,
 571                         NULL, &ndr_table_srvsvc,
 572                         NDR_SRVSVC_NETCHARDEVCONTROL, mem_ctx, r);
 573
 574         return status;
 575 }
 576
 577 NTSTATUS dcerpc_srvsvc_NetCharDevControl_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetCharDevControl *r)
 578 {
 579         NTSTATUS status;
 580
 581         status = dcerpc_srvsvc_NetCharDevControl_r(p->binding_handle, mem_ctx, r);
 582
 583         if (NT_STATUS_IS_RPC(status)) {
 584                 status = NT_STATUS_NET_WRITE_FAULT;
 585         }
 586
 587         return status;
 588 }
 589
 590 struct dcerpc_srvsvc_NetCharDevControl_state {
 591         struct srvsvc_NetCharDevControl orig;
 592         struct srvsvc_NetCharDevControl tmp;
 593         TALLOC_CTX *out_mem_ctx;
 594 };
 595
 596 static void dcerpc_srvsvc_NetCharDevControl_done(struct tevent_req *subreq);
 597
 598 struct tevent_req *dcerpc_srvsvc_NetCharDevControl_send(TALLOC_CTX *mem_ctx,
 599                                                         struct tevent_context *ev,
 600                                                         struct dcerpc_binding_handle *h,
 601                                                         const char *_server_unc /* [in] [unique,charset(UTF16)] */,
 602                                                         const char *_device_name /* [in] [charset(UTF16)] */,
 603                                                         uint32_t _opcode /* [in]  */)
 604 {
 605         struct tevent_req *req;
 606         struct dcerpc_srvsvc_NetCharDevControl_state *state;
 607         struct tevent_req *subreq;
 608
 609         req = tevent_req_create(mem_ctx, &state,
 610                                 struct dcerpc_srvsvc_NetCharDevControl_state);
 611         if (req == NULL) {
 612                 return NULL;
 613         }
 614         state->out_mem_ctx = NULL;
 615
 616         /* In parameters */
 617         state->orig.in.server_unc = _server_unc;
 618         state->orig.in.device_name = _device_name;
 619         state->orig.in.opcode = _opcode;
 620
 621         /* Out parameters */
 622
 623         /* Result */
 624         ZERO_STRUCT(state->orig.out.result);
 625
 626         /* make a temporary copy, that we pass to the dispatch function */
 627         state->tmp = state->orig;
 628
 629         subreq = dcerpc_srvsvc_NetCharDevControl_r_send(state, ev, h, &state->tmp);
 630         if (tevent_req_nomem(subreq, req)) {
 631                 return tevent_req_post(req, ev);
 632         }
 633         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetCharDevControl_done, req);
 634         return req;
 635 }
 636
 637 static void dcerpc_srvsvc_NetCharDevControl_done(struct tevent_req *subreq)
 638 {
 639         struct tevent_req *req = tevent_req_callback_data(
 640                 subreq, struct tevent_req);
 641         struct dcerpc_srvsvc_NetCharDevControl_state *state = tevent_req_data(
 642                 req, struct dcerpc_srvsvc_NetCharDevControl_state);
 643         NTSTATUS status;
 644         TALLOC_CTX *mem_ctx;
 645
 646         if (state->out_mem_ctx) {
 647                 mem_ctx = state->out_mem_ctx;
 648         } else {
 649                 mem_ctx = state;
 650         }
 651
 652         status = dcerpc_srvsvc_NetCharDevControl_r_recv(subreq, mem_ctx);
 653         TALLOC_FREE(subreq);
 654         if (!NT_STATUS_IS_OK(status)) {
 655                 tevent_req_nterror(req, status);
 656                 return;
 657         }
 658
 659         /* Copy out parameters */
 660
 661         /* Copy result */
 662         state->orig.out.result = state->tmp.out.result;
 663
 664         /* Reset temporary structure */
 665         ZERO_STRUCT(state->tmp);
 666
 667         tevent_req_done(req);
 668 }
 669
 670 NTSTATUS dcerpc_srvsvc_NetCharDevControl_recv(struct tevent_req *req,
 671                                               TALLOC_CTX *mem_ctx,
 672                                               WERROR *result)
 673 {
 674         struct dcerpc_srvsvc_NetCharDevControl_state *state = tevent_req_data(
 675                 req, struct dcerpc_srvsvc_NetCharDevControl_state);
 676         NTSTATUS status;
 677
 678         if (tevent_req_is_nterror(req, &status)) {
 679                 tevent_req_received(req);
 680                 return status;
 681         }
 682
 683         /* Steal possible out parameters to the callers context */
 684         talloc_steal(mem_ctx, state->out_mem_ctx);
 685
 686         /* Return result */
 687         *result = state->orig.out.result;
 688
 689         tevent_req_received(req);
 690         return NT_STATUS_OK;
 691 }
 692
 693 NTSTATUS dcerpc_srvsvc_NetCharDevControl(struct dcerpc_binding_handle *h,
 694                                          TALLOC_CTX *mem_ctx,
 695                                          const char *_server_unc /* [in] [unique,charset(UTF16)] */,
 696                                          const char *_device_name /* [in] [charset(UTF16)] */,
 697                                          uint32_t _opcode /* [in]  */,
 698                                          WERROR *result)
 699 {
 700         struct srvsvc_NetCharDevControl r;
 701         NTSTATUS status;
 702
 703         /* In parameters */
 704         r.in.server_unc = _server_unc;
 705         r.in.device_name = _device_name;
 706         r.in.opcode = _opcode;
 707
 708         status = dcerpc_srvsvc_NetCharDevControl_r(h, mem_ctx, &r);
 709         if (!NT_STATUS_IS_OK(status)) {
 710                 return status;
 711         }
 712
 713         /* Return variables */
 714
 715         /* Return result */
 716         *result = r.out.result;
 717
 718         return NT_STATUS_OK;
 719 }
 720
 721 struct dcerpc_srvsvc_NetCharDevQEnum_r_state {
 722         TALLOC_CTX *out_mem_ctx;
 723 };
 724
 725 static void dcerpc_srvsvc_NetCharDevQEnum_r_done(struct tevent_req *subreq);
 726
 727 struct tevent_req *dcerpc_srvsvc_NetCharDevQEnum_r_send(TALLOC_CTX *mem_ctx,
 728         struct tevent_context *ev,
 729         struct dcerpc_binding_handle *h,
 730         struct srvsvc_NetCharDevQEnum *r)
 731 {
 732         struct tevent_req *req;
 733         struct dcerpc_srvsvc_NetCharDevQEnum_r_state *state;
 734         struct tevent_req *subreq;
 735
 736         req = tevent_req_create(mem_ctx, &state,
 737                                 struct dcerpc_srvsvc_NetCharDevQEnum_r_state);
 738         if (req == NULL) {
 739                 return NULL;
 740         }
 741
 742         state->out_mem_ctx = talloc_new(state);
 743         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 744                 return tevent_req_post(req, ev);
 745         }
 746
 747         subreq = dcerpc_binding_handle_call_send(state, ev, h,
 748                         NULL, &ndr_table_srvsvc,
 749                         NDR_SRVSVC_NETCHARDEVQENUM, state->out_mem_ctx, r);
 750         if (tevent_req_nomem(subreq, req)) {
 751                 return tevent_req_post(req, ev);
 752         }
 753         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetCharDevQEnum_r_done, req);
 754
 755         return req;
 756 }
 757
 758 static void dcerpc_srvsvc_NetCharDevQEnum_r_done(struct tevent_req *subreq)
 759 {
 760         struct tevent_req *req =
 761                 tevent_req_callback_data(subreq,
 762                 struct tevent_req);
 763         NTSTATUS status;
 764
 765         status = dcerpc_binding_handle_call_recv(subreq);
 766         if (!NT_STATUS_IS_OK(status)) {
 767                 tevent_req_nterror(req, status);
 768                 return;
 769         }
 770
 771         tevent_req_done(req);
 772 }
 773
 774 NTSTATUS dcerpc_srvsvc_NetCharDevQEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 775 {
 776         struct dcerpc_srvsvc_NetCharDevQEnum_r_state *state =
 777                 tevent_req_data(req,
 778                 struct dcerpc_srvsvc_NetCharDevQEnum_r_state);
 779         NTSTATUS status;
 780
 781         if (tevent_req_is_nterror(req, &status)) {
 782                 tevent_req_received(req);
 783                 return status;
 784         }
 785
 786         talloc_steal(mem_ctx, state->out_mem_ctx);
 787
 788         tevent_req_received(req);
 789         return NT_STATUS_OK;
 790 }
 791
 792 NTSTATUS dcerpc_srvsvc_NetCharDevQEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetCharDevQEnum *r)
 793 {
 794         NTSTATUS status;
 795
 796         status = dcerpc_binding_handle_call(h,
 797                         NULL, &ndr_table_srvsvc,
 798                         NDR_SRVSVC_NETCHARDEVQENUM, mem_ctx, r);
 799
 800         return status;
 801 }
 802
 803 NTSTATUS dcerpc_srvsvc_NetCharDevQEnum_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetCharDevQEnum *r)
 804 {
 805         NTSTATUS status;
 806
 807         status = dcerpc_srvsvc_NetCharDevQEnum_r(p->binding_handle, mem_ctx, r);
 808
 809         if (NT_STATUS_IS_RPC(status)) {
 810                 status = NT_STATUS_NET_WRITE_FAULT;
 811         }
 812
 813         return status;
 814 }
 815
 816 struct dcerpc_srvsvc_NetCharDevQEnum_state {
 817         struct srvsvc_NetCharDevQEnum orig;
 818         struct srvsvc_NetCharDevQEnum tmp;
 819         TALLOC_CTX *out_mem_ctx;
 820 };
 821
 822 static void dcerpc_srvsvc_NetCharDevQEnum_done(struct tevent_req *subreq);
 823
 824 struct tevent_req *dcerpc_srvsvc_NetCharDevQEnum_send(TALLOC_CTX *mem_ctx,
 825                                                       struct tevent_context *ev,
 826                                                       struct dcerpc_binding_handle *h,
 827                                                       const char *_server_unc /* [in] [unique,charset(UTF16)] */,
 828                                                       const char *_user /* [in] [unique,charset(UTF16)] */,
 829                                                       struct srvsvc_NetCharDevQInfoCtr *_info_ctr /* [in,out] [ref] */,
 830                                                       uint32_t _max_buffer /* [in]  */,
 831                                                       uint32_t *_totalentries /* [out] [ref] */,
 832                                                       uint32_t *_resume_handle /* [in,out] [unique] */)
 833 {
 834         struct tevent_req *req;
 835         struct dcerpc_srvsvc_NetCharDevQEnum_state *state;
 836         struct tevent_req *subreq;
 837
 838         req = tevent_req_create(mem_ctx, &state,
 839                                 struct dcerpc_srvsvc_NetCharDevQEnum_state);
 840         if (req == NULL) {
 841                 return NULL;
 842         }
 843         state->out_mem_ctx = NULL;
 844
 845         /* In parameters */
 846         state->orig.in.server_unc = _server_unc;
 847         state->orig.in.user = _user;
 848         state->orig.in.info_ctr = _info_ctr;
 849         state->orig.in.max_buffer = _max_buffer;
 850         state->orig.in.resume_handle = _resume_handle;
 851
 852         /* Out parameters */
 853         state->orig.out.info_ctr = _info_ctr;
 854         state->orig.out.totalentries = _totalentries;
 855         state->orig.out.resume_handle = _resume_handle;
 856
 857         /* Result */
 858         ZERO_STRUCT(state->orig.out.result);
 859
 860         state->out_mem_ctx = talloc_named_const(state, 0,
 861                              "dcerpc_srvsvc_NetCharDevQEnum_out_memory");
 862         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 863                 return tevent_req_post(req, ev);
 864         }
 865
 866         /* make a temporary copy, that we pass to the dispatch function */
 867         state->tmp = state->orig;
 868
 869         subreq = dcerpc_srvsvc_NetCharDevQEnum_r_send(state, ev, h, &state->tmp);
 870         if (tevent_req_nomem(subreq, req)) {
 871                 return tevent_req_post(req, ev);
 872         }
 873         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetCharDevQEnum_done, req);
 874         return req;
 875 }
 876
 877 static void dcerpc_srvsvc_NetCharDevQEnum_done(struct tevent_req *subreq)
 878 {
 879         struct tevent_req *req = tevent_req_callback_data(
 880                 subreq, struct tevent_req);
 881         struct dcerpc_srvsvc_NetCharDevQEnum_state *state = tevent_req_data(
 882                 req, struct dcerpc_srvsvc_NetCharDevQEnum_state);
 883         NTSTATUS status;
 884         TALLOC_CTX *mem_ctx;
 885
 886         if (state->out_mem_ctx) {
 887                 mem_ctx = state->out_mem_ctx;
 888         } else {
 889                 mem_ctx = state;
 890         }
 891
 892         status = dcerpc_srvsvc_NetCharDevQEnum_r_recv(subreq, mem_ctx);
 893         TALLOC_FREE(subreq);
 894         if (!NT_STATUS_IS_OK(status)) {
 895                 tevent_req_nterror(req, status);
 896                 return;
 897         }
 898
 899         /* Copy out parameters */
 900         *state->orig.out.info_ctr = *state->tmp.out.info_ctr;
 901         *state->orig.out.totalentries = *state->tmp.out.totalentries;
 902         if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
 903                 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
 904         }
 905
 906         /* Copy result */
 907         state->orig.out.result = state->tmp.out.result;
 908
 909         /* Reset temporary structure */
 910         ZERO_STRUCT(state->tmp);
 911
 912         tevent_req_done(req);
 913 }
 914
 915 NTSTATUS dcerpc_srvsvc_NetCharDevQEnum_recv(struct tevent_req *req,
 916                                             TALLOC_CTX *mem_ctx,
 917                                             WERROR *result)
 918 {
 919         struct dcerpc_srvsvc_NetCharDevQEnum_state *state = tevent_req_data(
 920                 req, struct dcerpc_srvsvc_NetCharDevQEnum_state);
 921         NTSTATUS status;
 922
 923         if (tevent_req_is_nterror(req, &status)) {
 924                 tevent_req_received(req);
 925                 return status;
 926         }
 927
 928         /* Steal possible out parameters to the callers context */
 929         talloc_steal(mem_ctx, state->out_mem_ctx);
 930
 931         /* Return result */
 932         *result = state->orig.out.result;
 933
 934         tevent_req_received(req);
 935         return NT_STATUS_OK;
 936 }
 937
 938 NTSTATUS dcerpc_srvsvc_NetCharDevQEnum(struct dcerpc_binding_handle *h,
 939                                        TALLOC_CTX *mem_ctx,
 940                                        const char *_server_unc /* [in] [unique,charset(UTF16)] */,
 941                                        const char *_user /* [in] [unique,charset(UTF16)] */,
 942                                        struct srvsvc_NetCharDevQInfoCtr *_info_ctr /* [in,out] [ref] */,
 943                                        uint32_t _max_buffer /* [in]  */,
 944                                        uint32_t *_totalentries /* [out] [ref] */,
 945                                        uint32_t *_resume_handle /* [in,out] [unique] */,
 946                                        WERROR *result)
 947 {
 948         struct srvsvc_NetCharDevQEnum r;
 949         NTSTATUS status;
 950
 951         /* In parameters */
 952         r.in.server_unc = _server_unc;
 953         r.in.user = _user;
 954         r.in.info_ctr = _info_ctr;
 955         r.in.max_buffer = _max_buffer;
 956         r.in.resume_handle = _resume_handle;
 957
 958         status = dcerpc_srvsvc_NetCharDevQEnum_r(h, mem_ctx, &r);
 959         if (!NT_STATUS_IS_OK(status)) {
 960                 return status;
 961         }
 962
 963         /* Return variables */
 964         *_info_ctr = *r.out.info_ctr;
 965         *_totalentries = *r.out.totalentries;
 966         if (_resume_handle && r.out.resume_handle) {
 967                 *_resume_handle = *r.out.resume_handle;
 968         }
 969
 970         /* Return result */
 971         *result = r.out.result;
 972
 973         return NT_STATUS_OK;
 974 }
 975
 976 struct dcerpc_srvsvc_NetCharDevQGetInfo_r_state {
 977         TALLOC_CTX *out_mem_ctx;
 978 };
 979
 980 static void dcerpc_srvsvc_NetCharDevQGetInfo_r_done(struct tevent_req *subreq);
 981
 982 struct tevent_req *dcerpc_srvsvc_NetCharDevQGetInfo_r_send(TALLOC_CTX *mem_ctx,
 983         struct tevent_context *ev,
 984         struct dcerpc_binding_handle *h,
 985         struct srvsvc_NetCharDevQGetInfo *r)
 986 {
 987         struct tevent_req *req;
 988         struct dcerpc_srvsvc_NetCharDevQGetInfo_r_state *state;
 989         struct tevent_req *subreq;
 990
 991         req = tevent_req_create(mem_ctx, &state,
 992                                 struct dcerpc_srvsvc_NetCharDevQGetInfo_r_state);
 993         if (req == NULL) {
 994                 return NULL;
 995         }
 996
 997         state->out_mem_ctx = talloc_new(state);
 998         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 999                 return tevent_req_post(req, ev);
1000         }
1001
1002         subreq = dcerpc_binding_handle_call_send(state, ev, h,
1003                         NULL, &ndr_table_srvsvc,
1004                         NDR_SRVSVC_NETCHARDEVQGETINFO, state->out_mem_ctx, r);
1005         if (tevent_req_nomem(subreq, req)) {
1006                 return tevent_req_post(req, ev);
1007         }
1008         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetCharDevQGetInfo_r_done, req);
1009
1010         return req;
1011 }
1012
1013 static void dcerpc_srvsvc_NetCharDevQGetInfo_r_done(struct tevent_req *subreq)
1014 {
1015         struct tevent_req *req =
1016                 tevent_req_callback_data(subreq,
1017                 struct tevent_req);
1018         NTSTATUS status;
1019
1020         status = dcerpc_binding_handle_call_recv(subreq);
1021         if (!NT_STATUS_IS_OK(status)) {
1022                 tevent_req_nterror(req, status);
1023                 return;
1024         }
1025
1026         tevent_req_done(req);
1027 }
1028
1029 NTSTATUS dcerpc_srvsvc_NetCharDevQGetInfo_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
1030 {
1031         struct dcerpc_srvsvc_NetCharDevQGetInfo_r_state *state =
1032                 tevent_req_data(req,
1033                 struct dcerpc_srvsvc_NetCharDevQGetInfo_r_state);
1034         NTSTATUS status;
1035
1036         if (tevent_req_is_nterror(req, &status)) {
1037                 tevent_req_received(req);
1038                 return status;
1039         }
1040
1041         talloc_steal(mem_ctx, state->out_mem_ctx);
1042
1043         tevent_req_received(req);
1044         return NT_STATUS_OK;
1045 }
1046
1047 NTSTATUS dcerpc_srvsvc_NetCharDevQGetInfo_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetCharDevQGetInfo *r)
1048 {
1049         NTSTATUS status;
1050
1051         status = dcerpc_binding_handle_call(h,
1052                         NULL, &ndr_table_srvsvc,
1053                         NDR_SRVSVC_NETCHARDEVQGETINFO, mem_ctx, r);
1054
1055         return status;
1056 }
1057
1058 NTSTATUS dcerpc_srvsvc_NetCharDevQGetInfo_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetCharDevQGetInfo *r)
1059 {
1060         NTSTATUS status;
1061
1062         status = dcerpc_srvsvc_NetCharDevQGetInfo_r(p->binding_handle, mem_ctx, r);
1063
1064         if (NT_STATUS_IS_RPC(status)) {
1065                 status = NT_STATUS_NET_WRITE_FAULT;
1066         }
1067
1068         return status;
1069 }
1070
1071 struct dcerpc_srvsvc_NetCharDevQGetInfo_state {
1072         struct srvsvc_NetCharDevQGetInfo orig;
1073         struct srvsvc_NetCharDevQGetInfo tmp;
1074         TALLOC_CTX *out_mem_ctx;
1075 };
1076
1077 static void dcerpc_srvsvc_NetCharDevQGetInfo_done(struct tevent_req *subreq);
1078
1079 struct tevent_req *dcerpc_srvsvc_NetCharDevQGetInfo_send(TALLOC_CTX *mem_ctx,
1080                                                          struct tevent_context *ev,
1081                                                          struct dcerpc_binding_handle *h,
1082                                                          const char *_server_unc /* [in] [unique,charset(UTF16)] */,
1083                                                          const char *_queue_name /* [in] [charset(UTF16)] */,
1084                                                          const char *_user /* [in] [charset(UTF16)] */,
1085                                                          uint32_t _level /* [in]  */,
1086                                                          union srvsvc_NetCharDevQInfo *_info /* [out] [ref,switch_is(level)] */)
1087 {
1088         struct tevent_req *req;
1089         struct dcerpc_srvsvc_NetCharDevQGetInfo_state *state;
1090         struct tevent_req *subreq;
1091
1092         req = tevent_req_create(mem_ctx, &state,
1093                                 struct dcerpc_srvsvc_NetCharDevQGetInfo_state);
1094         if (req == NULL) {
1095                 return NULL;
1096         }
1097         state->out_mem_ctx = NULL;
1098
1099         /* In parameters */
1100         state->orig.in.server_unc = _server_unc;
1101         state->orig.in.queue_name = _queue_name;
1102         state->orig.in.user = _user;
1103         state->orig.in.level = _level;
1104
1105         /* Out parameters */
1106         state->orig.out.info = _info;
1107
1108         /* Result */
1109         ZERO_STRUCT(state->orig.out.result);
1110
1111         state->out_mem_ctx = talloc_named_const(state, 0,
1112                              "dcerpc_srvsvc_NetCharDevQGetInfo_out_memory");
1113         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1114                 return tevent_req_post(req, ev);
1115         }
1116
1117         /* make a temporary copy, that we pass to the dispatch function */
1118         state->tmp = state->orig;
1119
1120         subreq = dcerpc_srvsvc_NetCharDevQGetInfo_r_send(state, ev, h, &state->tmp);
1121         if (tevent_req_nomem(subreq, req)) {
1122                 return tevent_req_post(req, ev);
1123         }
1124         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetCharDevQGetInfo_done, req);
1125         return req;
1126 }
1127
1128 static void dcerpc_srvsvc_NetCharDevQGetInfo_done(struct tevent_req *subreq)
1129 {
1130         struct tevent_req *req = tevent_req_callback_data(
1131                 subreq, struct tevent_req);
1132         struct dcerpc_srvsvc_NetCharDevQGetInfo_state *state = tevent_req_data(
1133                 req, struct dcerpc_srvsvc_NetCharDevQGetInfo_state);
1134         NTSTATUS status;
1135         TALLOC_CTX *mem_ctx;
1136
1137         if (state->out_mem_ctx) {
1138                 mem_ctx = state->out_mem_ctx;
1139         } else {
1140                 mem_ctx = state;
1141         }
1142
1143         status = dcerpc_srvsvc_NetCharDevQGetInfo_r_recv(subreq, mem_ctx);
1144         TALLOC_FREE(subreq);
1145         if (!NT_STATUS_IS_OK(status)) {
1146                 tevent_req_nterror(req, status);
1147                 return;
1148         }
1149
1150         /* Copy out parameters */
1151         *state->orig.out.info = *state->tmp.out.info;
1152
1153         /* Copy result */
1154         state->orig.out.result = state->tmp.out.result;
1155
1156         /* Reset temporary structure */
1157         ZERO_STRUCT(state->tmp);
1158
1159         tevent_req_done(req);
1160 }
1161
1162 NTSTATUS dcerpc_srvsvc_NetCharDevQGetInfo_recv(struct tevent_req *req,
1163                                                TALLOC_CTX *mem_ctx,
1164                                                WERROR *result)
1165 {
1166         struct dcerpc_srvsvc_NetCharDevQGetInfo_state *state = tevent_req_data(
1167                 req, struct dcerpc_srvsvc_NetCharDevQGetInfo_state);
1168         NTSTATUS status;
1169
1170         if (tevent_req_is_nterror(req, &status)) {
1171                 tevent_req_received(req);
1172                 return status;
1173         }
1174
1175         /* Steal possible out parameters to the callers context */
1176         talloc_steal(mem_ctx, state->out_mem_ctx);
1177
1178         /* Return result */
1179         *result = state->orig.out.result;
1180
1181         tevent_req_received(req);
1182         return NT_STATUS_OK;
1183 }
1184
1185 NTSTATUS dcerpc_srvsvc_NetCharDevQGetInfo(struct dcerpc_binding_handle *h,
1186                                           TALLOC_CTX *mem_ctx,
1187                                           const char *_server_unc /* [in] [unique,charset(UTF16)] */,
1188                                           const char *_queue_name /* [in] [charset(UTF16)] */,
1189                                           const char *_user /* [in] [charset(UTF16)] */,
1190                                           uint32_t _level /* [in]  */,
1191                                           union srvsvc_NetCharDevQInfo *_info /* [out] [ref,switch_is(level)] */,
1192                                           WERROR *result)
1193 {
1194         struct srvsvc_NetCharDevQGetInfo r;
1195         NTSTATUS status;
1196
1197         /* In parameters */
1198         r.in.server_unc = _server_unc;
1199         r.in.queue_name = _queue_name;
1200         r.in.user = _user;
1201         r.in.level = _level;
1202
1203         status = dcerpc_srvsvc_NetCharDevQGetInfo_r(h, mem_ctx, &r);
1204         if (!NT_STATUS_IS_OK(status)) {
1205                 return status;
1206         }
1207
1208         /* Return variables */
1209         *_info = *r.out.info;
1210
1211         /* Return result */
1212         *result = r.out.result;
1213
1214         return NT_STATUS_OK;
1215 }
1216
1217 struct dcerpc_srvsvc_NetCharDevQSetInfo_r_state {
1218         TALLOC_CTX *out_mem_ctx;
1219 };
1220
1221 static void dcerpc_srvsvc_NetCharDevQSetInfo_r_done(struct tevent_req *subreq);
1222
1223 struct tevent_req *dcerpc_srvsvc_NetCharDevQSetInfo_r_send(TALLOC_CTX *mem_ctx,
1224         struct tevent_context *ev,
1225         struct dcerpc_binding_handle *h,
1226         struct srvsvc_NetCharDevQSetInfo *r)
1227 {
1228         struct tevent_req *req;
1229         struct dcerpc_srvsvc_NetCharDevQSetInfo_r_state *state;
1230         struct tevent_req *subreq;
1231
1232         req = tevent_req_create(mem_ctx, &state,
1233                                 struct dcerpc_srvsvc_NetCharDevQSetInfo_r_state);
1234         if (req == NULL) {
1235                 return NULL;
1236         }
1237
1238         state->out_mem_ctx = talloc_new(state);
1239         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1240                 return tevent_req_post(req, ev);
1241         }
1242
1243         subreq = dcerpc_binding_handle_call_send(state, ev, h,
1244                         NULL, &ndr_table_srvsvc,
1245                         NDR_SRVSVC_NETCHARDEVQSETINFO, state->out_mem_ctx, r);
1246         if (tevent_req_nomem(subreq, req)) {
1247                 return tevent_req_post(req, ev);
1248         }
1249         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetCharDevQSetInfo_r_done, req);
1250
1251         return req;
1252 }
1253
1254 static void dcerpc_srvsvc_NetCharDevQSetInfo_r_done(struct tevent_req *subreq)
1255 {
1256         struct tevent_req *req =
1257                 tevent_req_callback_data(subreq,
1258                 struct tevent_req);
1259         NTSTATUS status;
1260
1261         status = dcerpc_binding_handle_call_recv(subreq);
1262         if (!NT_STATUS_IS_OK(status)) {
1263                 tevent_req_nterror(req, status);
1264                 return;
1265         }
1266
1267         tevent_req_done(req);
1268 }
1269
1270 NTSTATUS dcerpc_srvsvc_NetCharDevQSetInfo_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
1271 {
1272         struct dcerpc_srvsvc_NetCharDevQSetInfo_r_state *state =
1273                 tevent_req_data(req,
1274                 struct dcerpc_srvsvc_NetCharDevQSetInfo_r_state);
1275         NTSTATUS status;
1276
1277         if (tevent_req_is_nterror(req, &status)) {
1278                 tevent_req_received(req);
1279                 return status;
1280         }
1281
1282         talloc_steal(mem_ctx, state->out_mem_ctx);
1283
1284         tevent_req_received(req);
1285         return NT_STATUS_OK;
1286 }
1287
1288 NTSTATUS dcerpc_srvsvc_NetCharDevQSetInfo_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetCharDevQSetInfo *r)
1289 {
1290         NTSTATUS status;
1291
1292         status = dcerpc_binding_handle_call(h,
1293                         NULL, &ndr_table_srvsvc,
1294                         NDR_SRVSVC_NETCHARDEVQSETINFO, mem_ctx, r);
1295
1296         return status;
1297 }
1298
1299 NTSTATUS dcerpc_srvsvc_NetCharDevQSetInfo_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetCharDevQSetInfo *r)
1300 {
1301         NTSTATUS status;
1302
1303         status = dcerpc_srvsvc_NetCharDevQSetInfo_r(p->binding_handle, mem_ctx, r);
1304
1305         if (NT_STATUS_IS_RPC(status)) {
1306                 status = NT_STATUS_NET_WRITE_FAULT;
1307         }
1308
1309         return status;
1310 }
1311
1312 struct dcerpc_srvsvc_NetCharDevQSetInfo_state {
1313         struct srvsvc_NetCharDevQSetInfo orig;
1314         struct srvsvc_NetCharDevQSetInfo tmp;
1315         TALLOC_CTX *out_mem_ctx;
1316 };
1317
1318 static void dcerpc_srvsvc_NetCharDevQSetInfo_done(struct tevent_req *subreq);
1319
1320 struct tevent_req *dcerpc_srvsvc_NetCharDevQSetInfo_send(TALLOC_CTX *mem_ctx,
1321                                                          struct tevent_context *ev,
1322                                                          struct dcerpc_binding_handle *h,
1323                                                          const char *_server_unc /* [in] [unique,charset(UTF16)] */,
1324                                                          const char *_queue_name /* [in] [charset(UTF16)] */,
1325                                                          uint32_t _level /* [in]  */,
1326                                                          union srvsvc_NetCharDevQInfo _info /* [in] [switch_is(level)] */,
1327                                                          uint32_t *_parm_error /* [in,out] [unique] */)
1328 {
1329         struct tevent_req *req;
1330         struct dcerpc_srvsvc_NetCharDevQSetInfo_state *state;
1331         struct tevent_req *subreq;
1332
1333         req = tevent_req_create(mem_ctx, &state,
1334                                 struct dcerpc_srvsvc_NetCharDevQSetInfo_state);
1335         if (req == NULL) {
1336                 return NULL;
1337         }
1338         state->out_mem_ctx = NULL;
1339
1340         /* In parameters */
1341         state->orig.in.server_unc = _server_unc;
1342         state->orig.in.queue_name = _queue_name;
1343         state->orig.in.level = _level;
1344         state->orig.in.info = _info;
1345         state->orig.in.parm_error = _parm_error;
1346
1347         /* Out parameters */
1348         state->orig.out.parm_error = _parm_error;
1349
1350         /* Result */
1351         ZERO_STRUCT(state->orig.out.result);
1352
1353         state->out_mem_ctx = talloc_named_const(state, 0,
1354                              "dcerpc_srvsvc_NetCharDevQSetInfo_out_memory");
1355         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1356                 return tevent_req_post(req, ev);
1357         }
1358
1359         /* make a temporary copy, that we pass to the dispatch function */
1360         state->tmp = state->orig;
1361
1362         subreq = dcerpc_srvsvc_NetCharDevQSetInfo_r_send(state, ev, h, &state->tmp);
1363         if (tevent_req_nomem(subreq, req)) {
1364                 return tevent_req_post(req, ev);
1365         }
1366         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetCharDevQSetInfo_done, req);
1367         return req;
1368 }
1369
1370 static void dcerpc_srvsvc_NetCharDevQSetInfo_done(struct tevent_req *subreq)
1371 {
1372         struct tevent_req *req = tevent_req_callback_data(
1373                 subreq, struct tevent_req);
1374         struct dcerpc_srvsvc_NetCharDevQSetInfo_state *state = tevent_req_data(
1375                 req, struct dcerpc_srvsvc_NetCharDevQSetInfo_state);
1376         NTSTATUS status;
1377         TALLOC_CTX *mem_ctx;
1378
1379         if (state->out_mem_ctx) {
1380                 mem_ctx = state->out_mem_ctx;
1381         } else {
1382                 mem_ctx = state;
1383         }
1384
1385         status = dcerpc_srvsvc_NetCharDevQSetInfo_r_recv(subreq, mem_ctx);
1386         TALLOC_FREE(subreq);
1387         if (!NT_STATUS_IS_OK(status)) {
1388                 tevent_req_nterror(req, status);
1389                 return;
1390         }
1391
1392         /* Copy out parameters */
1393         if (state->orig.out.parm_error && state->tmp.out.parm_error) {
1394                 *state->orig.out.parm_error = *state->tmp.out.parm_error;
1395         }
1396
1397         /* Copy result */
1398         state->orig.out.result = state->tmp.out.result;
1399
1400         /* Reset temporary structure */
1401         ZERO_STRUCT(state->tmp);
1402
1403         tevent_req_done(req);
1404 }
1405
1406 NTSTATUS dcerpc_srvsvc_NetCharDevQSetInfo_recv(struct tevent_req *req,
1407                                                TALLOC_CTX *mem_ctx,
1408                                                WERROR *result)
1409 {
1410         struct dcerpc_srvsvc_NetCharDevQSetInfo_state *state = tevent_req_data(
1411                 req, struct dcerpc_srvsvc_NetCharDevQSetInfo_state);
1412         NTSTATUS status;
1413
1414         if (tevent_req_is_nterror(req, &status)) {
1415                 tevent_req_received(req);
1416                 return status;
1417         }
1418
1419         /* Steal possible out parameters to the callers context */
1420         talloc_steal(mem_ctx, state->out_mem_ctx);
1421
1422         /* Return result */
1423         *result = state->orig.out.result;
1424
1425         tevent_req_received(req);
1426         return NT_STATUS_OK;
1427 }
1428
1429 NTSTATUS dcerpc_srvsvc_NetCharDevQSetInfo(struct dcerpc_binding_handle *h,
1430                                           TALLOC_CTX *mem_ctx,
1431                                           const char *_server_unc /* [in] [unique,charset(UTF16)] */,
1432                                           const char *_queue_name /* [in] [charset(UTF16)] */,
1433                                           uint32_t _level /* [in]  */,
1434                                           union srvsvc_NetCharDevQInfo _info /* [in] [switch_is(level)] */,
1435                                           uint32_t *_parm_error /* [in,out] [unique] */,
1436                                           WERROR *result)
1437 {
1438         struct srvsvc_NetCharDevQSetInfo r;
1439         NTSTATUS status;
1440
1441         /* In parameters */
1442         r.in.server_unc = _server_unc;
1443         r.in.queue_name = _queue_name;
1444         r.in.level = _level;
1445         r.in.info = _info;
1446         r.in.parm_error = _parm_error;
1447
1448         status = dcerpc_srvsvc_NetCharDevQSetInfo_r(h, mem_ctx, &r);
1449         if (!NT_STATUS_IS_OK(status)) {
1450                 return status;
1451         }
1452
1453         /* Return variables */
1454         if (_parm_error && r.out.parm_error) {
1455                 *_parm_error = *r.out.parm_error;
1456         }
1457
1458         /* Return result */
1459         *result = r.out.result;
1460
1461         return NT_STATUS_OK;
1462 }
1463
1464 struct dcerpc_srvsvc_NetCharDevQPurge_r_state {
1465         TALLOC_CTX *out_mem_ctx;
1466 };
1467
1468 static void dcerpc_srvsvc_NetCharDevQPurge_r_done(struct tevent_req *subreq);
1469
1470 struct tevent_req *dcerpc_srvsvc_NetCharDevQPurge_r_send(TALLOC_CTX *mem_ctx,
1471         struct tevent_context *ev,
1472         struct dcerpc_binding_handle *h,
1473         struct srvsvc_NetCharDevQPurge *r)
1474 {
1475         struct tevent_req *req;
1476         struct dcerpc_srvsvc_NetCharDevQPurge_r_state *state;
1477         struct tevent_req *subreq;
1478
1479         req = tevent_req_create(mem_ctx, &state,
1480                                 struct dcerpc_srvsvc_NetCharDevQPurge_r_state);
1481         if (req == NULL) {
1482                 return NULL;
1483         }
1484
1485         state->out_mem_ctx = NULL;
1486         subreq = dcerpc_binding_handle_call_send(state, ev, h,
1487                         NULL, &ndr_table_srvsvc,
1488                         NDR_SRVSVC_NETCHARDEVQPURGE, state, r);
1489         if (tevent_req_nomem(subreq, req)) {
1490                 return tevent_req_post(req, ev);
1491         }
1492         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetCharDevQPurge_r_done, req);
1493
1494         return req;
1495 }
1496
1497 static void dcerpc_srvsvc_NetCharDevQPurge_r_done(struct tevent_req *subreq)
1498 {
1499         struct tevent_req *req =
1500                 tevent_req_callback_data(subreq,
1501                 struct tevent_req);
1502         NTSTATUS status;
1503
1504         status = dcerpc_binding_handle_call_recv(subreq);
1505         if (!NT_STATUS_IS_OK(status)) {
1506                 tevent_req_nterror(req, status);
1507                 return;
1508         }
1509
1510         tevent_req_done(req);
1511 }
1512
1513 NTSTATUS dcerpc_srvsvc_NetCharDevQPurge_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
1514 {
1515         struct dcerpc_srvsvc_NetCharDevQPurge_r_state *state =
1516                 tevent_req_data(req,
1517                 struct dcerpc_srvsvc_NetCharDevQPurge_r_state);
1518         NTSTATUS status;
1519
1520         if (tevent_req_is_nterror(req, &status)) {
1521                 tevent_req_received(req);
1522                 return status;
1523         }
1524
1525         talloc_steal(mem_ctx, state->out_mem_ctx);
1526
1527         tevent_req_received(req);
1528         return NT_STATUS_OK;
1529 }
1530
1531 NTSTATUS dcerpc_srvsvc_NetCharDevQPurge_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetCharDevQPurge *r)
1532 {
1533         NTSTATUS status;
1534
1535         status = dcerpc_binding_handle_call(h,
1536                         NULL, &ndr_table_srvsvc,
1537                         NDR_SRVSVC_NETCHARDEVQPURGE, mem_ctx, r);
1538
1539         return status;
1540 }
1541
1542 NTSTATUS dcerpc_srvsvc_NetCharDevQPurge_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetCharDevQPurge *r)
1543 {
1544         NTSTATUS status;
1545
1546         status = dcerpc_srvsvc_NetCharDevQPurge_r(p->binding_handle, mem_ctx, r);
1547
1548         if (NT_STATUS_IS_RPC(status)) {
1549                 status = NT_STATUS_NET_WRITE_FAULT;
1550         }
1551
1552         return status;
1553 }
1554
1555 struct dcerpc_srvsvc_NetCharDevQPurge_state {
1556         struct srvsvc_NetCharDevQPurge orig;
1557         struct srvsvc_NetCharDevQPurge tmp;
1558         TALLOC_CTX *out_mem_ctx;
1559 };
1560
1561 static void dcerpc_srvsvc_NetCharDevQPurge_done(struct tevent_req *subreq);
1562
1563 struct tevent_req *dcerpc_srvsvc_NetCharDevQPurge_send(TALLOC_CTX *mem_ctx,
1564                                                        struct tevent_context *ev,
1565                                                        struct dcerpc_binding_handle *h,
1566                                                        const char *_server_unc /* [in] [unique,charset(UTF16)] */,
1567                                                        const char *_queue_name /* [in] [charset(UTF16)] */)
1568 {
1569         struct tevent_req *req;
1570         struct dcerpc_srvsvc_NetCharDevQPurge_state *state;
1571         struct tevent_req *subreq;
1572
1573         req = tevent_req_create(mem_ctx, &state,
1574                                 struct dcerpc_srvsvc_NetCharDevQPurge_state);
1575         if (req == NULL) {
1576                 return NULL;
1577         }
1578         state->out_mem_ctx = NULL;
1579
1580         /* In parameters */
1581         state->orig.in.server_unc = _server_unc;
1582         state->orig.in.queue_name = _queue_name;
1583
1584         /* Out parameters */
1585
1586         /* Result */
1587         ZERO_STRUCT(state->orig.out.result);
1588
1589         /* make a temporary copy, that we pass to the dispatch function */
1590         state->tmp = state->orig;
1591
1592         subreq = dcerpc_srvsvc_NetCharDevQPurge_r_send(state, ev, h, &state->tmp);
1593         if (tevent_req_nomem(subreq, req)) {
1594                 return tevent_req_post(req, ev);
1595         }
1596         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetCharDevQPurge_done, req);
1597         return req;
1598 }
1599
1600 static void dcerpc_srvsvc_NetCharDevQPurge_done(struct tevent_req *subreq)
1601 {
1602         struct tevent_req *req = tevent_req_callback_data(
1603                 subreq, struct tevent_req);
1604         struct dcerpc_srvsvc_NetCharDevQPurge_state *state = tevent_req_data(
1605                 req, struct dcerpc_srvsvc_NetCharDevQPurge_state);
1606         NTSTATUS status;
1607         TALLOC_CTX *mem_ctx;
1608
1609         if (state->out_mem_ctx) {
1610                 mem_ctx = state->out_mem_ctx;
1611         } else {
1612                 mem_ctx = state;
1613         }
1614
1615         status = dcerpc_srvsvc_NetCharDevQPurge_r_recv(subreq, mem_ctx);
1616         TALLOC_FREE(subreq);
1617         if (!NT_STATUS_IS_OK(status)) {
1618                 tevent_req_nterror(req, status);
1619                 return;
1620         }
1621
1622         /* Copy out parameters */
1623
1624         /* Copy result */
1625         state->orig.out.result = state->tmp.out.result;
1626
1627         /* Reset temporary structure */
1628         ZERO_STRUCT(state->tmp);
1629
1630         tevent_req_done(req);
1631 }
1632
1633 NTSTATUS dcerpc_srvsvc_NetCharDevQPurge_recv(struct tevent_req *req,
1634                                              TALLOC_CTX *mem_ctx,
1635                                              WERROR *result)
1636 {
1637         struct dcerpc_srvsvc_NetCharDevQPurge_state *state = tevent_req_data(
1638                 req, struct dcerpc_srvsvc_NetCharDevQPurge_state);
1639         NTSTATUS status;
1640
1641         if (tevent_req_is_nterror(req, &status)) {
1642                 tevent_req_received(req);
1643                 return status;
1644         }
1645
1646         /* Steal possible out parameters to the callers context */
1647         talloc_steal(mem_ctx, state->out_mem_ctx);
1648
1649         /* Return result */
1650         *result = state->orig.out.result;
1651
1652         tevent_req_received(req);
1653         return NT_STATUS_OK;
1654 }
1655
1656 NTSTATUS dcerpc_srvsvc_NetCharDevQPurge(struct dcerpc_binding_handle *h,
1657                                         TALLOC_CTX *mem_ctx,
1658                                         const char *_server_unc /* [in] [unique,charset(UTF16)] */,
1659                                         const char *_queue_name /* [in] [charset(UTF16)] */,
1660                                         WERROR *result)
1661 {
1662         struct srvsvc_NetCharDevQPurge r;
1663         NTSTATUS status;
1664
1665         /* In parameters */
1666         r.in.server_unc = _server_unc;
1667         r.in.queue_name = _queue_name;
1668
1669         status = dcerpc_srvsvc_NetCharDevQPurge_r(h, mem_ctx, &r);
1670         if (!NT_STATUS_IS_OK(status)) {
1671                 return status;
1672         }
1673
1674         /* Return variables */
1675
1676         /* Return result */
1677         *result = r.out.result;
1678
1679         return NT_STATUS_OK;
1680 }
1681
1682 struct dcerpc_srvsvc_NetCharDevQPurgeSelf_r_state {
1683         TALLOC_CTX *out_mem_ctx;
1684 };
1685
1686 static void dcerpc_srvsvc_NetCharDevQPurgeSelf_r_done(struct tevent_req *subreq);
1687
1688 struct tevent_req *dcerpc_srvsvc_NetCharDevQPurgeSelf_r_send(TALLOC_CTX *mem_ctx,
1689         struct tevent_context *ev,
1690         struct dcerpc_binding_handle *h,
1691         struct srvsvc_NetCharDevQPurgeSelf *r)
1692 {
1693         struct tevent_req *req;
1694         struct dcerpc_srvsvc_NetCharDevQPurgeSelf_r_state *state;
1695         struct tevent_req *subreq;
1696
1697         req = tevent_req_create(mem_ctx, &state,
1698                                 struct dcerpc_srvsvc_NetCharDevQPurgeSelf_r_state);
1699         if (req == NULL) {
1700                 return NULL;
1701         }
1702
1703         state->out_mem_ctx = NULL;
1704         subreq = dcerpc_binding_handle_call_send(state, ev, h,
1705                         NULL, &ndr_table_srvsvc,
1706                         NDR_SRVSVC_NETCHARDEVQPURGESELF, state, r);
1707         if (tevent_req_nomem(subreq, req)) {
1708                 return tevent_req_post(req, ev);
1709         }
1710         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetCharDevQPurgeSelf_r_done, req);
1711
1712         return req;
1713 }
1714
1715 static void dcerpc_srvsvc_NetCharDevQPurgeSelf_r_done(struct tevent_req *subreq)
1716 {
1717         struct tevent_req *req =
1718                 tevent_req_callback_data(subreq,
1719                 struct tevent_req);
1720         NTSTATUS status;
1721
1722         status = dcerpc_binding_handle_call_recv(subreq);
1723         if (!NT_STATUS_IS_OK(status)) {
1724                 tevent_req_nterror(req, status);
1725                 return;
1726         }
1727
1728         tevent_req_done(req);
1729 }
1730
1731 NTSTATUS dcerpc_srvsvc_NetCharDevQPurgeSelf_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
1732 {
1733         struct dcerpc_srvsvc_NetCharDevQPurgeSelf_r_state *state =
1734                 tevent_req_data(req,
1735                 struct dcerpc_srvsvc_NetCharDevQPurgeSelf_r_state);
1736         NTSTATUS status;
1737
1738         if (tevent_req_is_nterror(req, &status)) {
1739                 tevent_req_received(req);
1740                 return status;
1741         }
1742
1743         talloc_steal(mem_ctx, state->out_mem_ctx);
1744
1745         tevent_req_received(req);
1746         return NT_STATUS_OK;
1747 }
1748
1749 NTSTATUS dcerpc_srvsvc_NetCharDevQPurgeSelf_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetCharDevQPurgeSelf *r)
1750 {
1751         NTSTATUS status;
1752
1753         status = dcerpc_binding_handle_call(h,
1754                         NULL, &ndr_table_srvsvc,
1755                         NDR_SRVSVC_NETCHARDEVQPURGESELF, mem_ctx, r);
1756
1757         return status;
1758 }
1759
1760 NTSTATUS dcerpc_srvsvc_NetCharDevQPurgeSelf_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetCharDevQPurgeSelf *r)
1761 {
1762         NTSTATUS status;
1763
1764         status = dcerpc_srvsvc_NetCharDevQPurgeSelf_r(p->binding_handle, mem_ctx, r);
1765
1766         if (NT_STATUS_IS_RPC(status)) {
1767                 status = NT_STATUS_NET_WRITE_FAULT;
1768         }
1769
1770         return status;
1771 }
1772
1773 struct dcerpc_srvsvc_NetCharDevQPurgeSelf_state {
1774         struct srvsvc_NetCharDevQPurgeSelf orig;
1775         struct srvsvc_NetCharDevQPurgeSelf tmp;
1776         TALLOC_CTX *out_mem_ctx;
1777 };
1778
1779 static void dcerpc_srvsvc_NetCharDevQPurgeSelf_done(struct tevent_req *subreq);
1780
1781 struct tevent_req *dcerpc_srvsvc_NetCharDevQPurgeSelf_send(TALLOC_CTX *mem_ctx,
1782                                                            struct tevent_context *ev,
1783                                                            struct dcerpc_binding_handle *h,
1784                                                            const char *_server_unc /* [in] [unique,charset(UTF16)] */,
1785                                                            const char *_queue_name /* [in] [charset(UTF16)] */,
1786                                                            const char *_computer_name /* [in] [charset(UTF16)] */)
1787 {
1788         struct tevent_req *req;
1789         struct dcerpc_srvsvc_NetCharDevQPurgeSelf_state *state;
1790         struct tevent_req *subreq;
1791
1792         req = tevent_req_create(mem_ctx, &state,
1793                                 struct dcerpc_srvsvc_NetCharDevQPurgeSelf_state);
1794         if (req == NULL) {
1795                 return NULL;
1796         }
1797         state->out_mem_ctx = NULL;
1798
1799         /* In parameters */
1800         state->orig.in.server_unc = _server_unc;
1801         state->orig.in.queue_name = _queue_name;
1802         state->orig.in.computer_name = _computer_name;
1803
1804         /* Out parameters */
1805
1806         /* Result */
1807         ZERO_STRUCT(state->orig.out.result);
1808
1809         /* make a temporary copy, that we pass to the dispatch function */
1810         state->tmp = state->orig;
1811
1812         subreq = dcerpc_srvsvc_NetCharDevQPurgeSelf_r_send(state, ev, h, &state->tmp);
1813         if (tevent_req_nomem(subreq, req)) {
1814                 return tevent_req_post(req, ev);
1815         }
1816         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetCharDevQPurgeSelf_done, req);
1817         return req;
1818 }
1819
1820 static void dcerpc_srvsvc_NetCharDevQPurgeSelf_done(struct tevent_req *subreq)
1821 {
1822         struct tevent_req *req = tevent_req_callback_data(
1823                 subreq, struct tevent_req);
1824         struct dcerpc_srvsvc_NetCharDevQPurgeSelf_state *state = tevent_req_data(
1825                 req, struct dcerpc_srvsvc_NetCharDevQPurgeSelf_state);
1826         NTSTATUS status;
1827         TALLOC_CTX *mem_ctx;
1828
1829         if (state->out_mem_ctx) {
1830                 mem_ctx = state->out_mem_ctx;
1831         } else {
1832                 mem_ctx = state;
1833         }
1834
1835         status = dcerpc_srvsvc_NetCharDevQPurgeSelf_r_recv(subreq, mem_ctx);
1836         TALLOC_FREE(subreq);
1837         if (!NT_STATUS_IS_OK(status)) {
1838                 tevent_req_nterror(req, status);
1839                 return;
1840         }
1841
1842         /* Copy out parameters */
1843
1844         /* Copy result */
1845         state->orig.out.result = state->tmp.out.result;
1846
1847         /* Reset temporary structure */
1848         ZERO_STRUCT(state->tmp);
1849
1850         tevent_req_done(req);
1851 }
1852
1853 NTSTATUS dcerpc_srvsvc_NetCharDevQPurgeSelf_recv(struct tevent_req *req,
1854                                                  TALLOC_CTX *mem_ctx,
1855                                                  WERROR *result)
1856 {
1857         struct dcerpc_srvsvc_NetCharDevQPurgeSelf_state *state = tevent_req_data(
1858                 req, struct dcerpc_srvsvc_NetCharDevQPurgeSelf_state);
1859         NTSTATUS status;
1860
1861         if (tevent_req_is_nterror(req, &status)) {
1862                 tevent_req_received(req);
1863                 return status;
1864         }
1865
1866         /* Steal possible out parameters to the callers context */
1867         talloc_steal(mem_ctx, state->out_mem_ctx);
1868
1869         /* Return result */
1870         *result = state->orig.out.result;
1871
1872         tevent_req_received(req);
1873         return NT_STATUS_OK;
1874 }
1875
1876 NTSTATUS dcerpc_srvsvc_NetCharDevQPurgeSelf(struct dcerpc_binding_handle *h,
1877                                             TALLOC_CTX *mem_ctx,
1878                                             const char *_server_unc /* [in] [unique,charset(UTF16)] */,
1879                                             const char *_queue_name /* [in] [charset(UTF16)] */,
1880                                             const char *_computer_name /* [in] [charset(UTF16)] */,
1881                                             WERROR *result)
1882 {
1883         struct srvsvc_NetCharDevQPurgeSelf r;
1884         NTSTATUS status;
1885
1886         /* In parameters */
1887         r.in.server_unc = _server_unc;
1888         r.in.queue_name = _queue_name;
1889         r.in.computer_name = _computer_name;
1890
1891         status = dcerpc_srvsvc_NetCharDevQPurgeSelf_r(h, mem_ctx, &r);
1892         if (!NT_STATUS_IS_OK(status)) {
1893                 return status;
1894         }
1895
1896         /* Return variables */
1897
1898         /* Return result */
1899         *result = r.out.result;
1900
1901         return NT_STATUS_OK;
1902 }
1903
1904 struct dcerpc_srvsvc_NetConnEnum_r_state {
1905         TALLOC_CTX *out_mem_ctx;
1906 };
1907
1908 static void dcerpc_srvsvc_NetConnEnum_r_done(struct tevent_req *subreq);
1909
1910 struct tevent_req *dcerpc_srvsvc_NetConnEnum_r_send(TALLOC_CTX *mem_ctx,
1911         struct tevent_context *ev,
1912         struct dcerpc_binding_handle *h,
1913         struct srvsvc_NetConnEnum *r)
1914 {
1915         struct tevent_req *req;
1916         struct dcerpc_srvsvc_NetConnEnum_r_state *state;
1917         struct tevent_req *subreq;
1918
1919         req = tevent_req_create(mem_ctx, &state,
1920                                 struct dcerpc_srvsvc_NetConnEnum_r_state);
1921         if (req == NULL) {
1922                 return NULL;
1923         }
1924
1925         state->out_mem_ctx = talloc_new(state);
1926         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1927                 return tevent_req_post(req, ev);
1928         }
1929
1930         subreq = dcerpc_binding_handle_call_send(state, ev, h,
1931                         NULL, &ndr_table_srvsvc,
1932                         NDR_SRVSVC_NETCONNENUM, state->out_mem_ctx, r);
1933         if (tevent_req_nomem(subreq, req)) {
1934                 return tevent_req_post(req, ev);
1935         }
1936         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetConnEnum_r_done, req);
1937
1938         return req;
1939 }
1940
1941 static void dcerpc_srvsvc_NetConnEnum_r_done(struct tevent_req *subreq)
1942 {
1943         struct tevent_req *req =
1944                 tevent_req_callback_data(subreq,
1945                 struct tevent_req);
1946         NTSTATUS status;
1947
1948         status = dcerpc_binding_handle_call_recv(subreq);
1949         if (!NT_STATUS_IS_OK(status)) {
1950                 tevent_req_nterror(req, status);
1951                 return;
1952         }
1953
1954         tevent_req_done(req);
1955 }
1956
1957 NTSTATUS dcerpc_srvsvc_NetConnEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
1958 {
1959         struct dcerpc_srvsvc_NetConnEnum_r_state *state =
1960                 tevent_req_data(req,
1961                 struct dcerpc_srvsvc_NetConnEnum_r_state);
1962         NTSTATUS status;
1963
1964         if (tevent_req_is_nterror(req, &status)) {
1965                 tevent_req_received(req);
1966                 return status;
1967         }
1968
1969         talloc_steal(mem_ctx, state->out_mem_ctx);
1970
1971         tevent_req_received(req);
1972         return NT_STATUS_OK;
1973 }
1974
1975 NTSTATUS dcerpc_srvsvc_NetConnEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetConnEnum *r)
1976 {
1977         NTSTATUS status;
1978
1979         status = dcerpc_binding_handle_call(h,
1980                         NULL, &ndr_table_srvsvc,
1981                         NDR_SRVSVC_NETCONNENUM, mem_ctx, r);
1982
1983         return status;
1984 }
1985
1986 NTSTATUS dcerpc_srvsvc_NetConnEnum_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetConnEnum *r)
1987 {
1988         NTSTATUS status;
1989
1990         status = dcerpc_srvsvc_NetConnEnum_r(p->binding_handle, mem_ctx, r);
1991
1992         if (NT_STATUS_IS_RPC(status)) {
1993                 status = NT_STATUS_NET_WRITE_FAULT;
1994         }
1995
1996         return status;
1997 }
1998
1999 struct dcerpc_srvsvc_NetConnEnum_state {
2000         struct srvsvc_NetConnEnum orig;
2001         struct srvsvc_NetConnEnum tmp;
2002         TALLOC_CTX *out_mem_ctx;
2003 };
2004
2005 static void dcerpc_srvsvc_NetConnEnum_done(struct tevent_req *subreq);
2006
2007 struct tevent_req *dcerpc_srvsvc_NetConnEnum_send(TALLOC_CTX *mem_ctx,
2008                                                   struct tevent_context *ev,
2009                                                   struct dcerpc_binding_handle *h,
2010                                                   const char *_server_unc /* [in] [unique,charset(UTF16)] */,
2011                                                   const char *_path /* [in] [unique,charset(UTF16)] */,
2012                                                   struct srvsvc_NetConnInfoCtr *_info_ctr /* [in,out] [ref] */,
2013                                                   uint32_t _max_buffer /* [in]  */,
2014                                                   uint32_t *_totalentries /* [out] [ref] */,
2015                                                   uint32_t *_resume_handle /* [in,out] [unique] */)
2016 {
2017         struct tevent_req *req;
2018         struct dcerpc_srvsvc_NetConnEnum_state *state;
2019         struct tevent_req *subreq;
2020
2021         req = tevent_req_create(mem_ctx, &state,
2022                                 struct dcerpc_srvsvc_NetConnEnum_state);
2023         if (req == NULL) {
2024                 return NULL;
2025         }
2026         state->out_mem_ctx = NULL;
2027
2028         /* In parameters */
2029         state->orig.in.server_unc = _server_unc;
2030         state->orig.in.path = _path;
2031         state->orig.in.info_ctr = _info_ctr;
2032         state->orig.in.max_buffer = _max_buffer;
2033         state->orig.in.resume_handle = _resume_handle;
2034
2035         /* Out parameters */
2036         state->orig.out.info_ctr = _info_ctr;
2037         state->orig.out.totalentries = _totalentries;
2038         state->orig.out.resume_handle = _resume_handle;
2039
2040         /* Result */
2041         ZERO_STRUCT(state->orig.out.result);
2042
2043         state->out_mem_ctx = talloc_named_const(state, 0,
2044                              "dcerpc_srvsvc_NetConnEnum_out_memory");
2045         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2046                 return tevent_req_post(req, ev);
2047         }
2048
2049         /* make a temporary copy, that we pass to the dispatch function */
2050         state->tmp = state->orig;
2051
2052         subreq = dcerpc_srvsvc_NetConnEnum_r_send(state, ev, h, &state->tmp);
2053         if (tevent_req_nomem(subreq, req)) {
2054                 return tevent_req_post(req, ev);
2055         }
2056         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetConnEnum_done, req);
2057         return req;
2058 }
2059
2060 static void dcerpc_srvsvc_NetConnEnum_done(struct tevent_req *subreq)
2061 {
2062         struct tevent_req *req = tevent_req_callback_data(
2063                 subreq, struct tevent_req);
2064         struct dcerpc_srvsvc_NetConnEnum_state *state = tevent_req_data(
2065                 req, struct dcerpc_srvsvc_NetConnEnum_state);
2066         NTSTATUS status;
2067         TALLOC_CTX *mem_ctx;
2068
2069         if (state->out_mem_ctx) {
2070                 mem_ctx = state->out_mem_ctx;
2071         } else {
2072                 mem_ctx = state;
2073         }
2074
2075         status = dcerpc_srvsvc_NetConnEnum_r_recv(subreq, mem_ctx);
2076         TALLOC_FREE(subreq);
2077         if (!NT_STATUS_IS_OK(status)) {
2078                 tevent_req_nterror(req, status);
2079                 return;
2080         }
2081
2082         /* Copy out parameters */
2083         *state->orig.out.info_ctr = *state->tmp.out.info_ctr;
2084         *state->orig.out.totalentries = *state->tmp.out.totalentries;
2085         if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
2086                 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
2087         }
2088
2089         /* Copy result */
2090         state->orig.out.result = state->tmp.out.result;
2091
2092         /* Reset temporary structure */
2093         ZERO_STRUCT(state->tmp);
2094
2095         tevent_req_done(req);
2096 }
2097
2098 NTSTATUS dcerpc_srvsvc_NetConnEnum_recv(struct tevent_req *req,
2099                                         TALLOC_CTX *mem_ctx,
2100                                         WERROR *result)
2101 {
2102         struct dcerpc_srvsvc_NetConnEnum_state *state = tevent_req_data(
2103                 req, struct dcerpc_srvsvc_NetConnEnum_state);
2104         NTSTATUS status;
2105
2106         if (tevent_req_is_nterror(req, &status)) {
2107                 tevent_req_received(req);
2108                 return status;
2109         }
2110
2111         /* Steal possible out parameters to the callers context */
2112         talloc_steal(mem_ctx, state->out_mem_ctx);
2113
2114         /* Return result */
2115         *result = state->orig.out.result;
2116
2117         tevent_req_received(req);
2118         return NT_STATUS_OK;
2119 }
2120
2121 NTSTATUS dcerpc_srvsvc_NetConnEnum(struct dcerpc_binding_handle *h,
2122                                    TALLOC_CTX *mem_ctx,
2123                                    const char *_server_unc /* [in] [unique,charset(UTF16)] */,
2124                                    const char *_path /* [in] [unique,charset(UTF16)] */,
2125                                    struct srvsvc_NetConnInfoCtr *_info_ctr /* [in,out] [ref] */,
2126                                    uint32_t _max_buffer /* [in]  */,
2127                                    uint32_t *_totalentries /* [out] [ref] */,
2128                                    uint32_t *_resume_handle /* [in,out] [unique] */,
2129                                    WERROR *result)
2130 {
2131         struct srvsvc_NetConnEnum r;
2132         NTSTATUS status;
2133
2134         /* In parameters */
2135         r.in.server_unc = _server_unc;
2136         r.in.path = _path;
2137         r.in.info_ctr = _info_ctr;
2138         r.in.max_buffer = _max_buffer;
2139         r.in.resume_handle = _resume_handle;
2140
2141         status = dcerpc_srvsvc_NetConnEnum_r(h, mem_ctx, &r);
2142         if (!NT_STATUS_IS_OK(status)) {
2143                 return status;
2144         }
2145
2146         /* Return variables */
2147         *_info_ctr = *r.out.info_ctr;
2148         *_totalentries = *r.out.totalentries;
2149         if (_resume_handle && r.out.resume_handle) {
2150                 *_resume_handle = *r.out.resume_handle;
2151         }
2152
2153         /* Return result */
2154         *result = r.out.result;
2155
2156         return NT_STATUS_OK;
2157 }
2158
2159 struct dcerpc_srvsvc_NetFileEnum_r_state {
2160         TALLOC_CTX *out_mem_ctx;
2161 };
2162
2163 static void dcerpc_srvsvc_NetFileEnum_r_done(struct tevent_req *subreq);
2164
2165 struct tevent_req *dcerpc_srvsvc_NetFileEnum_r_send(TALLOC_CTX *mem_ctx,
2166         struct tevent_context *ev,
2167         struct dcerpc_binding_handle *h,
2168         struct srvsvc_NetFileEnum *r)
2169 {
2170         struct tevent_req *req;
2171         struct dcerpc_srvsvc_NetFileEnum_r_state *state;
2172         struct tevent_req *subreq;
2173
2174         req = tevent_req_create(mem_ctx, &state,
2175                                 struct dcerpc_srvsvc_NetFileEnum_r_state);
2176         if (req == NULL) {
2177                 return NULL;
2178         }
2179
2180         state->out_mem_ctx = talloc_new(state);
2181         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2182                 return tevent_req_post(req, ev);
2183         }
2184
2185         subreq = dcerpc_binding_handle_call_send(state, ev, h,
2186                         NULL, &ndr_table_srvsvc,
2187                         NDR_SRVSVC_NETFILEENUM, state->out_mem_ctx, r);
2188         if (tevent_req_nomem(subreq, req)) {
2189                 return tevent_req_post(req, ev);
2190         }
2191         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetFileEnum_r_done, req);
2192
2193         return req;
2194 }
2195
2196 static void dcerpc_srvsvc_NetFileEnum_r_done(struct tevent_req *subreq)
2197 {
2198         struct tevent_req *req =
2199                 tevent_req_callback_data(subreq,
2200                 struct tevent_req);
2201         NTSTATUS status;
2202
2203         status = dcerpc_binding_handle_call_recv(subreq);
2204         if (!NT_STATUS_IS_OK(status)) {
2205                 tevent_req_nterror(req, status);
2206                 return;
2207         }
2208
2209         tevent_req_done(req);
2210 }
2211
2212 NTSTATUS dcerpc_srvsvc_NetFileEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
2213 {
2214         struct dcerpc_srvsvc_NetFileEnum_r_state *state =
2215                 tevent_req_data(req,
2216                 struct dcerpc_srvsvc_NetFileEnum_r_state);
2217         NTSTATUS status;
2218
2219         if (tevent_req_is_nterror(req, &status)) {
2220                 tevent_req_received(req);
2221                 return status;
2222         }
2223
2224         talloc_steal(mem_ctx, state->out_mem_ctx);
2225
2226         tevent_req_received(req);
2227         return NT_STATUS_OK;
2228 }
2229
2230 NTSTATUS dcerpc_srvsvc_NetFileEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetFileEnum *r)
2231 {
2232         NTSTATUS status;
2233
2234         status = dcerpc_binding_handle_call(h,
2235                         NULL, &ndr_table_srvsvc,
2236                         NDR_SRVSVC_NETFILEENUM, mem_ctx, r);
2237
2238         return status;
2239 }
2240
2241 NTSTATUS dcerpc_srvsvc_NetFileEnum_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetFileEnum *r)
2242 {
2243         NTSTATUS status;
2244
2245         status = dcerpc_srvsvc_NetFileEnum_r(p->binding_handle, mem_ctx, r);
2246
2247         if (NT_STATUS_IS_RPC(status)) {
2248                 status = NT_STATUS_NET_WRITE_FAULT;
2249         }
2250
2251         return status;
2252 }
2253
2254 struct dcerpc_srvsvc_NetFileEnum_state {
2255         struct srvsvc_NetFileEnum orig;
2256         struct srvsvc_NetFileEnum tmp;
2257         TALLOC_CTX *out_mem_ctx;
2258 };
2259
2260 static void dcerpc_srvsvc_NetFileEnum_done(struct tevent_req *subreq);
2261
2262 struct tevent_req *dcerpc_srvsvc_NetFileEnum_send(TALLOC_CTX *mem_ctx,
2263                                                   struct tevent_context *ev,
2264                                                   struct dcerpc_binding_handle *h,
2265                                                   const char *_server_unc /* [in] [unique,charset(UTF16)] */,
2266                                                   const char *_path /* [in] [unique,charset(UTF16)] */,
2267                                                   const char *_user /* [in] [unique,charset(UTF16)] */,
2268                                                   struct srvsvc_NetFileInfoCtr *_info_ctr /* [in,out] [ref] */,
2269                                                   uint32_t _max_buffer /* [in]  */,
2270                                                   uint32_t *_totalentries /* [out] [ref] */,
2271                                                   uint32_t *_resume_handle /* [in,out] [unique] */)
2272 {
2273         struct tevent_req *req;
2274         struct dcerpc_srvsvc_NetFileEnum_state *state;
2275         struct tevent_req *subreq;
2276
2277         req = tevent_req_create(mem_ctx, &state,
2278                                 struct dcerpc_srvsvc_NetFileEnum_state);
2279         if (req == NULL) {
2280                 return NULL;
2281         }
2282         state->out_mem_ctx = NULL;
2283
2284         /* In parameters */
2285         state->orig.in.server_unc = _server_unc;
2286         state->orig.in.path = _path;
2287         state->orig.in.user = _user;
2288         state->orig.in.info_ctr = _info_ctr;
2289         state->orig.in.max_buffer = _max_buffer;
2290         state->orig.in.resume_handle = _resume_handle;
2291
2292         /* Out parameters */
2293         state->orig.out.info_ctr = _info_ctr;
2294         state->orig.out.totalentries = _totalentries;
2295         state->orig.out.resume_handle = _resume_handle;
2296
2297         /* Result */
2298         ZERO_STRUCT(state->orig.out.result);
2299
2300         state->out_mem_ctx = talloc_named_const(state, 0,
2301                              "dcerpc_srvsvc_NetFileEnum_out_memory");
2302         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2303                 return tevent_req_post(req, ev);
2304         }
2305
2306         /* make a temporary copy, that we pass to the dispatch function */
2307         state->tmp = state->orig;
2308
2309         subreq = dcerpc_srvsvc_NetFileEnum_r_send(state, ev, h, &state->tmp);
2310         if (tevent_req_nomem(subreq, req)) {
2311                 return tevent_req_post(req, ev);
2312         }
2313         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetFileEnum_done, req);
2314         return req;
2315 }
2316
2317 static void dcerpc_srvsvc_NetFileEnum_done(struct tevent_req *subreq)
2318 {
2319         struct tevent_req *req = tevent_req_callback_data(
2320                 subreq, struct tevent_req);
2321         struct dcerpc_srvsvc_NetFileEnum_state *state = tevent_req_data(
2322                 req, struct dcerpc_srvsvc_NetFileEnum_state);
2323         NTSTATUS status;
2324         TALLOC_CTX *mem_ctx;
2325
2326         if (state->out_mem_ctx) {
2327                 mem_ctx = state->out_mem_ctx;
2328         } else {
2329                 mem_ctx = state;
2330         }
2331
2332         status = dcerpc_srvsvc_NetFileEnum_r_recv(subreq, mem_ctx);
2333         TALLOC_FREE(subreq);
2334         if (!NT_STATUS_IS_OK(status)) {
2335                 tevent_req_nterror(req, status);
2336                 return;
2337         }
2338
2339         /* Copy out parameters */
2340         *state->orig.out.info_ctr = *state->tmp.out.info_ctr;
2341         *state->orig.out.totalentries = *state->tmp.out.totalentries;
2342         if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
2343                 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
2344         }
2345
2346         /* Copy result */
2347         state->orig.out.result = state->tmp.out.result;
2348
2349         /* Reset temporary structure */
2350         ZERO_STRUCT(state->tmp);
2351
2352         tevent_req_done(req);
2353 }
2354
2355 NTSTATUS dcerpc_srvsvc_NetFileEnum_recv(struct tevent_req *req,
2356                                         TALLOC_CTX *mem_ctx,
2357                                         WERROR *result)
2358 {
2359         struct dcerpc_srvsvc_NetFileEnum_state *state = tevent_req_data(
2360                 req, struct dcerpc_srvsvc_NetFileEnum_state);
2361         NTSTATUS status;
2362
2363         if (tevent_req_is_nterror(req, &status)) {
2364                 tevent_req_received(req);
2365                 return status;
2366         }
2367
2368         /* Steal possible out parameters to the callers context */
2369         talloc_steal(mem_ctx, state->out_mem_ctx);
2370
2371         /* Return result */
2372         *result = state->orig.out.result;
2373
2374         tevent_req_received(req);
2375         return NT_STATUS_OK;
2376 }
2377
2378 NTSTATUS dcerpc_srvsvc_NetFileEnum(struct dcerpc_binding_handle *h,
2379                                    TALLOC_CTX *mem_ctx,
2380                                    const char *_server_unc /* [in] [unique,charset(UTF16)] */,
2381                                    const char *_path /* [in] [unique,charset(UTF16)] */,
2382                                    const char *_user /* [in] [unique,charset(UTF16)] */,
2383                                    struct srvsvc_NetFileInfoCtr *_info_ctr /* [in,out] [ref] */,
2384                                    uint32_t _max_buffer /* [in]  */,
2385                                    uint32_t *_totalentries /* [out] [ref] */,
2386                                    uint32_t *_resume_handle /* [in,out] [unique] */,
2387                                    WERROR *result)
2388 {
2389         struct srvsvc_NetFileEnum r;
2390         NTSTATUS status;
2391
2392         /* In parameters */
2393         r.in.server_unc = _server_unc;
2394         r.in.path = _path;
2395         r.in.user = _user;
2396         r.in.info_ctr = _info_ctr;
2397         r.in.max_buffer = _max_buffer;
2398         r.in.resume_handle = _resume_handle;
2399
2400         status = dcerpc_srvsvc_NetFileEnum_r(h, mem_ctx, &r);
2401         if (!NT_STATUS_IS_OK(status)) {
2402                 return status;
2403         }
2404
2405         /* Return variables */
2406         *_info_ctr = *r.out.info_ctr;
2407         *_totalentries = *r.out.totalentries;
2408         if (_resume_handle && r.out.resume_handle) {
2409                 *_resume_handle = *r.out.resume_handle;
2410         }
2411
2412         /* Return result */
2413         *result = r.out.result;
2414
2415         return NT_STATUS_OK;
2416 }
2417
2418 struct dcerpc_srvsvc_NetFileGetInfo_r_state {
2419         TALLOC_CTX *out_mem_ctx;
2420 };
2421
2422 static void dcerpc_srvsvc_NetFileGetInfo_r_done(struct tevent_req *subreq);
2423
2424 struct tevent_req *dcerpc_srvsvc_NetFileGetInfo_r_send(TALLOC_CTX *mem_ctx,
2425         struct tevent_context *ev,
2426         struct dcerpc_binding_handle *h,
2427         struct srvsvc_NetFileGetInfo *r)
2428 {
2429         struct tevent_req *req;
2430         struct dcerpc_srvsvc_NetFileGetInfo_r_state *state;
2431         struct tevent_req *subreq;
2432
2433         req = tevent_req_create(mem_ctx, &state,
2434                                 struct dcerpc_srvsvc_NetFileGetInfo_r_state);
2435         if (req == NULL) {
2436                 return NULL;
2437         }
2438
2439         state->out_mem_ctx = talloc_new(state);
2440         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2441                 return tevent_req_post(req, ev);
2442         }
2443
2444         subreq = dcerpc_binding_handle_call_send(state, ev, h,
2445                         NULL, &ndr_table_srvsvc,
2446                         NDR_SRVSVC_NETFILEGETINFO, state->out_mem_ctx, r);
2447         if (tevent_req_nomem(subreq, req)) {
2448                 return tevent_req_post(req, ev);
2449         }
2450         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetFileGetInfo_r_done, req);
2451
2452         return req;
2453 }
2454
2455 static void dcerpc_srvsvc_NetFileGetInfo_r_done(struct tevent_req *subreq)
2456 {
2457         struct tevent_req *req =
2458                 tevent_req_callback_data(subreq,
2459                 struct tevent_req);
2460         NTSTATUS status;
2461
2462         status = dcerpc_binding_handle_call_recv(subreq);
2463         if (!NT_STATUS_IS_OK(status)) {
2464                 tevent_req_nterror(req, status);
2465                 return;
2466         }
2467
2468         tevent_req_done(req);
2469 }
2470
2471 NTSTATUS dcerpc_srvsvc_NetFileGetInfo_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
2472 {
2473         struct dcerpc_srvsvc_NetFileGetInfo_r_state *state =
2474                 tevent_req_data(req,
2475                 struct dcerpc_srvsvc_NetFileGetInfo_r_state);
2476         NTSTATUS status;
2477
2478         if (tevent_req_is_nterror(req, &status)) {
2479                 tevent_req_received(req);
2480                 return status;
2481         }
2482
2483         talloc_steal(mem_ctx, state->out_mem_ctx);
2484
2485         tevent_req_received(req);
2486         return NT_STATUS_OK;
2487 }
2488
2489 NTSTATUS dcerpc_srvsvc_NetFileGetInfo_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetFileGetInfo *r)
2490 {
2491         NTSTATUS status;
2492
2493         status = dcerpc_binding_handle_call(h,
2494                         NULL, &ndr_table_srvsvc,
2495                         NDR_SRVSVC_NETFILEGETINFO, mem_ctx, r);
2496
2497         return status;
2498 }
2499
2500 NTSTATUS dcerpc_srvsvc_NetFileGetInfo_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetFileGetInfo *r)
2501 {
2502         NTSTATUS status;
2503
2504         status = dcerpc_srvsvc_NetFileGetInfo_r(p->binding_handle, mem_ctx, r);
2505
2506         if (NT_STATUS_IS_RPC(status)) {
2507                 status = NT_STATUS_NET_WRITE_FAULT;
2508         }
2509
2510         return status;
2511 }
2512
2513 struct dcerpc_srvsvc_NetFileGetInfo_state {
2514         struct srvsvc_NetFileGetInfo orig;
2515         struct srvsvc_NetFileGetInfo tmp;
2516         TALLOC_CTX *out_mem_ctx;
2517 };
2518
2519 static void dcerpc_srvsvc_NetFileGetInfo_done(struct tevent_req *subreq);
2520
2521 struct tevent_req *dcerpc_srvsvc_NetFileGetInfo_send(TALLOC_CTX *mem_ctx,
2522                                                      struct tevent_context *ev,
2523                                                      struct dcerpc_binding_handle *h,
2524                                                      const char *_server_unc /* [in] [unique,charset(UTF16)] */,
2525                                                      uint32_t _fid /* [in]  */,
2526                                                      uint32_t _level /* [in]  */,
2527                                                      union srvsvc_NetFileInfo *_info /* [out] [ref,switch_is(level)] */)
2528 {
2529         struct tevent_req *req;
2530         struct dcerpc_srvsvc_NetFileGetInfo_state *state;
2531         struct tevent_req *subreq;
2532
2533         req = tevent_req_create(mem_ctx, &state,
2534                                 struct dcerpc_srvsvc_NetFileGetInfo_state);
2535         if (req == NULL) {
2536                 return NULL;
2537         }
2538         state->out_mem_ctx = NULL;
2539
2540         /* In parameters */
2541         state->orig.in.server_unc = _server_unc;
2542         state->orig.in.fid = _fid;
2543         state->orig.in.level = _level;
2544
2545         /* Out parameters */
2546         state->orig.out.info = _info;
2547
2548         /* Result */
2549         ZERO_STRUCT(state->orig.out.result);
2550
2551         state->out_mem_ctx = talloc_named_const(state, 0,
2552                              "dcerpc_srvsvc_NetFileGetInfo_out_memory");
2553         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2554                 return tevent_req_post(req, ev);
2555         }
2556
2557         /* make a temporary copy, that we pass to the dispatch function */
2558         state->tmp = state->orig;
2559
2560         subreq = dcerpc_srvsvc_NetFileGetInfo_r_send(state, ev, h, &state->tmp);
2561         if (tevent_req_nomem(subreq, req)) {
2562                 return tevent_req_post(req, ev);
2563         }
2564         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetFileGetInfo_done, req);
2565         return req;
2566 }
2567
2568 static void dcerpc_srvsvc_NetFileGetInfo_done(struct tevent_req *subreq)
2569 {
2570         struct tevent_req *req = tevent_req_callback_data(
2571                 subreq, struct tevent_req);
2572         struct dcerpc_srvsvc_NetFileGetInfo_state *state = tevent_req_data(
2573                 req, struct dcerpc_srvsvc_NetFileGetInfo_state);
2574         NTSTATUS status;
2575         TALLOC_CTX *mem_ctx;
2576
2577         if (state->out_mem_ctx) {
2578                 mem_ctx = state->out_mem_ctx;
2579         } else {
2580                 mem_ctx = state;
2581         }
2582
2583         status = dcerpc_srvsvc_NetFileGetInfo_r_recv(subreq, mem_ctx);
2584         TALLOC_FREE(subreq);
2585         if (!NT_STATUS_IS_OK(status)) {
2586                 tevent_req_nterror(req, status);
2587                 return;
2588         }
2589
2590         /* Copy out parameters */
2591         *state->orig.out.info = *state->tmp.out.info;
2592
2593         /* Copy result */
2594         state->orig.out.result = state->tmp.out.result;
2595
2596         /* Reset temporary structure */
2597         ZERO_STRUCT(state->tmp);
2598
2599         tevent_req_done(req);
2600 }
2601
2602 NTSTATUS dcerpc_srvsvc_NetFileGetInfo_recv(struct tevent_req *req,
2603                                            TALLOC_CTX *mem_ctx,
2604                                            WERROR *result)
2605 {
2606         struct dcerpc_srvsvc_NetFileGetInfo_state *state = tevent_req_data(
2607                 req, struct dcerpc_srvsvc_NetFileGetInfo_state);
2608         NTSTATUS status;
2609
2610         if (tevent_req_is_nterror(req, &status)) {
2611                 tevent_req_received(req);
2612                 return status;
2613         }
2614
2615         /* Steal possible out parameters to the callers context */
2616         talloc_steal(mem_ctx, state->out_mem_ctx);
2617
2618         /* Return result */
2619         *result = state->orig.out.result;
2620
2621         tevent_req_received(req);
2622         return NT_STATUS_OK;
2623 }
2624
2625 NTSTATUS dcerpc_srvsvc_NetFileGetInfo(struct dcerpc_binding_handle *h,
2626                                       TALLOC_CTX *mem_ctx,
2627                                       const char *_server_unc /* [in] [unique,charset(UTF16)] */,
2628                                       uint32_t _fid /* [in]  */,
2629                                       uint32_t _level /* [in]  */,
2630                                       union srvsvc_NetFileInfo *_info /* [out] [ref,switch_is(level)] */,
2631                                       WERROR *result)
2632 {
2633         struct srvsvc_NetFileGetInfo r;
2634         NTSTATUS status;
2635
2636         /* In parameters */
2637         r.in.server_unc = _server_unc;
2638         r.in.fid = _fid;
2639         r.in.level = _level;
2640
2641         status = dcerpc_srvsvc_NetFileGetInfo_r(h, mem_ctx, &r);
2642         if (!NT_STATUS_IS_OK(status)) {
2643                 return status;
2644         }
2645
2646         /* Return variables */
2647         *_info = *r.out.info;
2648
2649         /* Return result */
2650         *result = r.out.result;
2651
2652         return NT_STATUS_OK;
2653 }
2654
2655 struct dcerpc_srvsvc_NetFileClose_r_state {
2656         TALLOC_CTX *out_mem_ctx;
2657 };
2658
2659 static void dcerpc_srvsvc_NetFileClose_r_done(struct tevent_req *subreq);
2660
2661 struct tevent_req *dcerpc_srvsvc_NetFileClose_r_send(TALLOC_CTX *mem_ctx,
2662         struct tevent_context *ev,
2663         struct dcerpc_binding_handle *h,
2664         struct srvsvc_NetFileClose *r)
2665 {
2666         struct tevent_req *req;
2667         struct dcerpc_srvsvc_NetFileClose_r_state *state;
2668         struct tevent_req *subreq;
2669
2670         req = tevent_req_create(mem_ctx, &state,
2671                                 struct dcerpc_srvsvc_NetFileClose_r_state);
2672         if (req == NULL) {
2673                 return NULL;
2674         }
2675
2676         state->out_mem_ctx = NULL;
2677         subreq = dcerpc_binding_handle_call_send(state, ev, h,
2678                         NULL, &ndr_table_srvsvc,
2679                         NDR_SRVSVC_NETFILECLOSE, state, r);
2680         if (tevent_req_nomem(subreq, req)) {
2681                 return tevent_req_post(req, ev);
2682         }
2683         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetFileClose_r_done, req);
2684
2685         return req;
2686 }
2687
2688 static void dcerpc_srvsvc_NetFileClose_r_done(struct tevent_req *subreq)
2689 {
2690         struct tevent_req *req =
2691                 tevent_req_callback_data(subreq,
2692                 struct tevent_req);
2693         NTSTATUS status;
2694
2695         status = dcerpc_binding_handle_call_recv(subreq);
2696         if (!NT_STATUS_IS_OK(status)) {
2697                 tevent_req_nterror(req, status);
2698                 return;
2699         }
2700
2701         tevent_req_done(req);
2702 }
2703
2704 NTSTATUS dcerpc_srvsvc_NetFileClose_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
2705 {
2706         struct dcerpc_srvsvc_NetFileClose_r_state *state =
2707                 tevent_req_data(req,
2708                 struct dcerpc_srvsvc_NetFileClose_r_state);
2709         NTSTATUS status;
2710
2711         if (tevent_req_is_nterror(req, &status)) {
2712                 tevent_req_received(req);
2713                 return status;
2714         }
2715
2716         talloc_steal(mem_ctx, state->out_mem_ctx);
2717
2718         tevent_req_received(req);
2719         return NT_STATUS_OK;
2720 }
2721
2722 NTSTATUS dcerpc_srvsvc_NetFileClose_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetFileClose *r)
2723 {
2724         NTSTATUS status;
2725
2726         status = dcerpc_binding_handle_call(h,
2727                         NULL, &ndr_table_srvsvc,
2728                         NDR_SRVSVC_NETFILECLOSE, mem_ctx, r);
2729
2730         return status;
2731 }
2732
2733 NTSTATUS dcerpc_srvsvc_NetFileClose_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetFileClose *r)
2734 {
2735         NTSTATUS status;
2736
2737         status = dcerpc_srvsvc_NetFileClose_r(p->binding_handle, mem_ctx, r);
2738
2739         if (NT_STATUS_IS_RPC(status)) {
2740                 status = NT_STATUS_NET_WRITE_FAULT;
2741         }
2742
2743         return status;
2744 }
2745
2746 struct dcerpc_srvsvc_NetFileClose_state {
2747         struct srvsvc_NetFileClose orig;
2748         struct srvsvc_NetFileClose tmp;
2749         TALLOC_CTX *out_mem_ctx;
2750 };
2751
2752 static void dcerpc_srvsvc_NetFileClose_done(struct tevent_req *subreq);
2753
2754 struct tevent_req *dcerpc_srvsvc_NetFileClose_send(TALLOC_CTX *mem_ctx,
2755                                                    struct tevent_context *ev,
2756                                                    struct dcerpc_binding_handle *h,
2757                                                    const char *_server_unc /* [in] [unique,charset(UTF16)] */,
2758                                                    uint32_t _fid /* [in]  */)
2759 {
2760         struct tevent_req *req;
2761         struct dcerpc_srvsvc_NetFileClose_state *state;
2762         struct tevent_req *subreq;
2763
2764         req = tevent_req_create(mem_ctx, &state,
2765                                 struct dcerpc_srvsvc_NetFileClose_state);
2766         if (req == NULL) {
2767                 return NULL;
2768         }
2769         state->out_mem_ctx = NULL;
2770
2771         /* In parameters */
2772         state->orig.in.server_unc = _server_unc;
2773         state->orig.in.fid = _fid;
2774
2775         /* Out parameters */
2776
2777         /* Result */
2778         ZERO_STRUCT(state->orig.out.result);
2779
2780         /* make a temporary copy, that we pass to the dispatch function */
2781         state->tmp = state->orig;
2782
2783         subreq = dcerpc_srvsvc_NetFileClose_r_send(state, ev, h, &state->tmp);
2784         if (tevent_req_nomem(subreq, req)) {
2785                 return tevent_req_post(req, ev);
2786         }
2787         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetFileClose_done, req);
2788         return req;
2789 }
2790
2791 static void dcerpc_srvsvc_NetFileClose_done(struct tevent_req *subreq)
2792 {
2793         struct tevent_req *req = tevent_req_callback_data(
2794                 subreq, struct tevent_req);
2795         struct dcerpc_srvsvc_NetFileClose_state *state = tevent_req_data(
2796                 req, struct dcerpc_srvsvc_NetFileClose_state);
2797         NTSTATUS status;
2798         TALLOC_CTX *mem_ctx;
2799
2800         if (state->out_mem_ctx) {
2801                 mem_ctx = state->out_mem_ctx;
2802         } else {
2803                 mem_ctx = state;
2804         }
2805
2806         status = dcerpc_srvsvc_NetFileClose_r_recv(subreq, mem_ctx);
2807         TALLOC_FREE(subreq);
2808         if (!NT_STATUS_IS_OK(status)) {
2809                 tevent_req_nterror(req, status);
2810                 return;
2811         }
2812
2813         /* Copy out parameters */
2814
2815         /* Copy result */
2816         state->orig.out.result = state->tmp.out.result;
2817
2818         /* Reset temporary structure */
2819         ZERO_STRUCT(state->tmp);
2820
2821         tevent_req_done(req);
2822 }
2823
2824 NTSTATUS dcerpc_srvsvc_NetFileClose_recv(struct tevent_req *req,
2825                                          TALLOC_CTX *mem_ctx,
2826                                          WERROR *result)
2827 {
2828         struct dcerpc_srvsvc_NetFileClose_state *state = tevent_req_data(
2829                 req, struct dcerpc_srvsvc_NetFileClose_state);
2830         NTSTATUS status;
2831
2832         if (tevent_req_is_nterror(req, &status)) {
2833                 tevent_req_received(req);
2834                 return status;
2835         }
2836
2837         /* Steal possible out parameters to the callers context */
2838         talloc_steal(mem_ctx, state->out_mem_ctx);
2839
2840         /* Return result */
2841         *result = state->orig.out.result;
2842
2843         tevent_req_received(req);
2844         return NT_STATUS_OK;
2845 }
2846
2847 NTSTATUS dcerpc_srvsvc_NetFileClose(struct dcerpc_binding_handle *h,
2848                                     TALLOC_CTX *mem_ctx,
2849                                     const char *_server_unc /* [in] [unique,charset(UTF16)] */,
2850                                     uint32_t _fid /* [in]  */,
2851                                     WERROR *result)
2852 {
2853         struct srvsvc_NetFileClose r;
2854         NTSTATUS status;
2855
2856         /* In parameters */
2857         r.in.server_unc = _server_unc;
2858         r.in.fid = _fid;
2859
2860         status = dcerpc_srvsvc_NetFileClose_r(h, mem_ctx, &r);
2861         if (!NT_STATUS_IS_OK(status)) {
2862                 return status;
2863         }
2864
2865         /* Return variables */
2866
2867         /* Return result */
2868         *result = r.out.result;
2869
2870         return NT_STATUS_OK;
2871 }
2872
2873 struct dcerpc_srvsvc_NetSessEnum_r_state {
2874         TALLOC_CTX *out_mem_ctx;
2875 };
2876
2877 static void dcerpc_srvsvc_NetSessEnum_r_done(struct tevent_req *subreq);
2878
2879 struct tevent_req *dcerpc_srvsvc_NetSessEnum_r_send(TALLOC_CTX *mem_ctx,
2880         struct tevent_context *ev,
2881         struct dcerpc_binding_handle *h,
2882         struct srvsvc_NetSessEnum *r)
2883 {
2884         struct tevent_req *req;
2885         struct dcerpc_srvsvc_NetSessEnum_r_state *state;
2886         struct tevent_req *subreq;
2887
2888         req = tevent_req_create(mem_ctx, &state,
2889                                 struct dcerpc_srvsvc_NetSessEnum_r_state);
2890         if (req == NULL) {
2891                 return NULL;
2892         }
2893
2894         state->out_mem_ctx = talloc_new(state);
2895         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2896                 return tevent_req_post(req, ev);
2897         }
2898
2899         subreq = dcerpc_binding_handle_call_send(state, ev, h,
2900                         NULL, &ndr_table_srvsvc,
2901                         NDR_SRVSVC_NETSESSENUM, state->out_mem_ctx, r);
2902         if (tevent_req_nomem(subreq, req)) {
2903                 return tevent_req_post(req, ev);
2904         }
2905         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetSessEnum_r_done, req);
2906
2907         return req;
2908 }
2909
2910 static void dcerpc_srvsvc_NetSessEnum_r_done(struct tevent_req *subreq)
2911 {
2912         struct tevent_req *req =
2913                 tevent_req_callback_data(subreq,
2914                 struct tevent_req);
2915         NTSTATUS status;
2916
2917         status = dcerpc_binding_handle_call_recv(subreq);
2918         if (!NT_STATUS_IS_OK(status)) {
2919                 tevent_req_nterror(req, status);
2920                 return;
2921         }
2922
2923         tevent_req_done(req);
2924 }
2925
2926 NTSTATUS dcerpc_srvsvc_NetSessEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
2927 {
2928         struct dcerpc_srvsvc_NetSessEnum_r_state *state =
2929                 tevent_req_data(req,
2930                 struct dcerpc_srvsvc_NetSessEnum_r_state);
2931         NTSTATUS status;
2932
2933         if (tevent_req_is_nterror(req, &status)) {
2934                 tevent_req_received(req);
2935                 return status;
2936         }
2937
2938         talloc_steal(mem_ctx, state->out_mem_ctx);
2939
2940         tevent_req_received(req);
2941         return NT_STATUS_OK;
2942 }
2943
2944 NTSTATUS dcerpc_srvsvc_NetSessEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetSessEnum *r)
2945 {
2946         NTSTATUS status;
2947
2948         status = dcerpc_binding_handle_call(h,
2949                         NULL, &ndr_table_srvsvc,
2950                         NDR_SRVSVC_NETSESSENUM, mem_ctx, r);
2951
2952         return status;
2953 }
2954
2955 NTSTATUS dcerpc_srvsvc_NetSessEnum_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetSessEnum *r)
2956 {
2957         NTSTATUS status;
2958
2959         status = dcerpc_srvsvc_NetSessEnum_r(p->binding_handle, mem_ctx, r);
2960
2961         if (NT_STATUS_IS_RPC(status)) {
2962                 status = NT_STATUS_NET_WRITE_FAULT;
2963         }
2964
2965         return status;
2966 }
2967
2968 struct dcerpc_srvsvc_NetSessEnum_state {
2969         struct srvsvc_NetSessEnum orig;
2970         struct srvsvc_NetSessEnum tmp;
2971         TALLOC_CTX *out_mem_ctx;
2972 };
2973
2974 static void dcerpc_srvsvc_NetSessEnum_done(struct tevent_req *subreq);
2975
2976 struct tevent_req *dcerpc_srvsvc_NetSessEnum_send(TALLOC_CTX *mem_ctx,
2977                                                   struct tevent_context *ev,
2978                                                   struct dcerpc_binding_handle *h,
2979                                                   const char *_server_unc /* [in] [unique,charset(UTF16)] */,
2980                                                   const char *_client /* [in] [unique,charset(UTF16)] */,
2981                                                   const char *_user /* [in] [unique,charset(UTF16)] */,
2982                                                   struct srvsvc_NetSessInfoCtr *_info_ctr /* [in,out] [ref] */,
2983                                                   uint32_t _max_buffer /* [in]  */,
2984                                                   uint32_t *_totalentries /* [out] [ref] */,
2985                                                   uint32_t *_resume_handle /* [in,out] [unique] */)
2986 {
2987         struct tevent_req *req;
2988         struct dcerpc_srvsvc_NetSessEnum_state *state;
2989         struct tevent_req *subreq;
2990
2991         req = tevent_req_create(mem_ctx, &state,
2992                                 struct dcerpc_srvsvc_NetSessEnum_state);
2993         if (req == NULL) {
2994                 return NULL;
2995         }
2996         state->out_mem_ctx = NULL;
2997
2998         /* In parameters */
2999         state->orig.in.server_unc = _server_unc;
3000         state->orig.in.client = _client;
3001         state->orig.in.user = _user;
3002         state->orig.in.info_ctr = _info_ctr;
3003         state->orig.in.max_buffer = _max_buffer;
3004         state->orig.in.resume_handle = _resume_handle;
3005
3006         /* Out parameters */
3007         state->orig.out.info_ctr = _info_ctr;
3008         state->orig.out.totalentries = _totalentries;
3009         state->orig.out.resume_handle = _resume_handle;
3010
3011         /* Result */
3012         ZERO_STRUCT(state->orig.out.result);
3013
3014         state->out_mem_ctx = talloc_named_const(state, 0,
3015                              "dcerpc_srvsvc_NetSessEnum_out_memory");
3016         if (tevent_req_nomem(state->out_mem_ctx, req)) {
3017                 return tevent_req_post(req, ev);
3018         }
3019
3020         /* make a temporary copy, that we pass to the dispatch function */
3021         state->tmp = state->orig;
3022
3023         subreq = dcerpc_srvsvc_NetSessEnum_r_send(state, ev, h, &state->tmp);
3024         if (tevent_req_nomem(subreq, req)) {
3025                 return tevent_req_post(req, ev);
3026         }
3027         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetSessEnum_done, req);
3028         return req;
3029 }
3030
3031 static void dcerpc_srvsvc_NetSessEnum_done(struct tevent_req *subreq)
3032 {
3033         struct tevent_req *req = tevent_req_callback_data(
3034                 subreq, struct tevent_req);
3035         struct dcerpc_srvsvc_NetSessEnum_state *state = tevent_req_data(
3036                 req, struct dcerpc_srvsvc_NetSessEnum_state);
3037         NTSTATUS status;
3038         TALLOC_CTX *mem_ctx;
3039
3040         if (state->out_mem_ctx) {
3041                 mem_ctx = state->out_mem_ctx;
3042         } else {
3043                 mem_ctx = state;
3044         }
3045
3046         status = dcerpc_srvsvc_NetSessEnum_r_recv(subreq, mem_ctx);
3047         TALLOC_FREE(subreq);
3048         if (!NT_STATUS_IS_OK(status)) {
3049                 tevent_req_nterror(req, status);
3050                 return;
3051         }
3052
3053         /* Copy out parameters */
3054         *state->orig.out.info_ctr = *state->tmp.out.info_ctr;
3055         *state->orig.out.totalentries = *state->tmp.out.totalentries;
3056         if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
3057                 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
3058         }
3059
3060         /* Copy result */
3061         state->orig.out.result = state->tmp.out.result;
3062
3063         /* Reset temporary structure */
3064         ZERO_STRUCT(state->tmp);
3065
3066         tevent_req_done(req);
3067 }
3068
3069 NTSTATUS dcerpc_srvsvc_NetSessEnum_recv(struct tevent_req *req,
3070                                         TALLOC_CTX *mem_ctx,
3071                                         WERROR *result)
3072 {
3073         struct dcerpc_srvsvc_NetSessEnum_state *state = tevent_req_data(
3074                 req, struct dcerpc_srvsvc_NetSessEnum_state);
3075         NTSTATUS status;
3076
3077         if (tevent_req_is_nterror(req, &status)) {
3078                 tevent_req_received(req);
3079                 return status;
3080         }
3081
3082         /* Steal possible out parameters to the callers context */
3083         talloc_steal(mem_ctx, state->out_mem_ctx);
3084
3085         /* Return result */
3086         *result = state->orig.out.result;
3087
3088         tevent_req_received(req);
3089         return NT_STATUS_OK;
3090 }
3091
3092 NTSTATUS dcerpc_srvsvc_NetSessEnum(struct dcerpc_binding_handle *h,
3093                                    TALLOC_CTX *mem_ctx,
3094                                    const char *_server_unc /* [in] [unique,charset(UTF16)] */,
3095                                    const char *_client /* [in] [unique,charset(UTF16)] */,
3096                                    const char *_user /* [in] [unique,charset(UTF16)] */,
3097                                    struct srvsvc_NetSessInfoCtr *_info_ctr /* [in,out] [ref] */,
3098                                    uint32_t _max_buffer /* [in]  */,
3099                                    uint32_t *_totalentries /* [out] [ref] */,
3100                                    uint32_t *_resume_handle /* [in,out] [unique] */,
3101                                    WERROR *result)
3102 {
3103         struct srvsvc_NetSessEnum r;
3104         NTSTATUS status;
3105
3106         /* In parameters */
3107         r.in.server_unc = _server_unc;
3108         r.in.client = _client;
3109         r.in.user = _user;
3110         r.in.info_ctr = _info_ctr;
3111         r.in.max_buffer = _max_buffer;
3112         r.in.resume_handle = _resume_handle;
3113
3114         status = dcerpc_srvsvc_NetSessEnum_r(h, mem_ctx, &r);
3115         if (!NT_STATUS_IS_OK(status)) {
3116                 return status;
3117         }
3118
3119         /* Return variables */
3120         *_info_ctr = *r.out.info_ctr;
3121         *_totalentries = *r.out.totalentries;
3122         if (_resume_handle && r.out.resume_handle) {
3123                 *_resume_handle = *r.out.resume_handle;
3124         }
3125
3126         /* Return result */
3127         *result = r.out.result;
3128
3129         return NT_STATUS_OK;
3130 }
3131
3132 struct dcerpc_srvsvc_NetSessDel_r_state {
3133         TALLOC_CTX *out_mem_ctx;
3134 };
3135
3136 static void dcerpc_srvsvc_NetSessDel_r_done(struct tevent_req *subreq);
3137
3138 struct tevent_req *dcerpc_srvsvc_NetSessDel_r_send(TALLOC_CTX *mem_ctx,
3139         struct tevent_context *ev,
3140         struct dcerpc_binding_handle *h,
3141         struct srvsvc_NetSessDel *r)
3142 {
3143         struct tevent_req *req;
3144         struct dcerpc_srvsvc_NetSessDel_r_state *state;
3145         struct tevent_req *subreq;
3146
3147         req = tevent_req_create(mem_ctx, &state,
3148                                 struct dcerpc_srvsvc_NetSessDel_r_state);
3149         if (req == NULL) {
3150                 return NULL;
3151         }
3152
3153         state->out_mem_ctx = NULL;
3154         subreq = dcerpc_binding_handle_call_send(state, ev, h,
3155                         NULL, &ndr_table_srvsvc,
3156                         NDR_SRVSVC_NETSESSDEL, state, r);
3157         if (tevent_req_nomem(subreq, req)) {
3158                 return tevent_req_post(req, ev);
3159         }
3160         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetSessDel_r_done, req);
3161
3162         return req;
3163 }
3164
3165 static void dcerpc_srvsvc_NetSessDel_r_done(struct tevent_req *subreq)
3166 {
3167         struct tevent_req *req =
3168                 tevent_req_callback_data(subreq,
3169                 struct tevent_req);
3170         NTSTATUS status;
3171
3172         status = dcerpc_binding_handle_call_recv(subreq);
3173         if (!NT_STATUS_IS_OK(status)) {
3174                 tevent_req_nterror(req, status);
3175                 return;
3176         }
3177
3178         tevent_req_done(req);
3179 }
3180
3181 NTSTATUS dcerpc_srvsvc_NetSessDel_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
3182 {
3183         struct dcerpc_srvsvc_NetSessDel_r_state *state =
3184                 tevent_req_data(req,
3185                 struct dcerpc_srvsvc_NetSessDel_r_state);
3186         NTSTATUS status;
3187
3188         if (tevent_req_is_nterror(req, &status)) {
3189                 tevent_req_received(req);
3190                 return status;
3191         }
3192
3193         talloc_steal(mem_ctx, state->out_mem_ctx);
3194
3195         tevent_req_received(req);
3196         return NT_STATUS_OK;
3197 }
3198
3199 NTSTATUS dcerpc_srvsvc_NetSessDel_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetSessDel *r)
3200 {
3201         NTSTATUS status;
3202
3203         status = dcerpc_binding_handle_call(h,
3204                         NULL, &ndr_table_srvsvc,
3205                         NDR_SRVSVC_NETSESSDEL, mem_ctx, r);
3206
3207         return status;
3208 }
3209
3210 NTSTATUS dcerpc_srvsvc_NetSessDel_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetSessDel *r)
3211 {
3212         NTSTATUS status;
3213
3214         status = dcerpc_srvsvc_NetSessDel_r(p->binding_handle, mem_ctx, r);
3215
3216         if (NT_STATUS_IS_RPC(status)) {
3217                 status = NT_STATUS_NET_WRITE_FAULT;
3218         }
3219
3220         return status;
3221 }
3222
3223 struct dcerpc_srvsvc_NetSessDel_state {
3224         struct srvsvc_NetSessDel orig;
3225         struct srvsvc_NetSessDel tmp;
3226         TALLOC_CTX *out_mem_ctx;
3227 };
3228
3229 static void dcerpc_srvsvc_NetSessDel_done(struct tevent_req *subreq);
3230
3231 struct tevent_req *dcerpc_srvsvc_NetSessDel_send(TALLOC_CTX *mem_ctx,
3232                                                  struct tevent_context *ev,
3233                                                  struct dcerpc_binding_handle *h,
3234                                                  const char *_server_unc /* [in] [unique,charset(UTF16)] */,
3235                                                  const char *_client /* [in] [unique,charset(UTF16)] */,
3236                                                  const char *_user /* [in] [unique,charset(UTF16)] */)
3237 {
3238         struct tevent_req *req;
3239         struct dcerpc_srvsvc_NetSessDel_state *state;
3240         struct tevent_req *subreq;
3241
3242         req = tevent_req_create(mem_ctx, &state,
3243                                 struct dcerpc_srvsvc_NetSessDel_state);
3244         if (req == NULL) {
3245                 return NULL;
3246         }
3247         state->out_mem_ctx = NULL;
3248
3249         /* In parameters */
3250         state->orig.in.server_unc = _server_unc;
3251         state->orig.in.client = _client;
3252         state->orig.in.user = _user;
3253
3254         /* Out parameters */
3255
3256         /* Result */
3257         ZERO_STRUCT(state->orig.out.result);
3258
3259         /* make a temporary copy, that we pass to the dispatch function */
3260         state->tmp = state->orig;
3261
3262         subreq = dcerpc_srvsvc_NetSessDel_r_send(state, ev, h, &state->tmp);
3263         if (tevent_req_nomem(subreq, req)) {
3264                 return tevent_req_post(req, ev);
3265         }
3266         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetSessDel_done, req);
3267         return req;
3268 }
3269
3270 static void dcerpc_srvsvc_NetSessDel_done(struct tevent_req *subreq)
3271 {
3272         struct tevent_req *req = tevent_req_callback_data(
3273                 subreq, struct tevent_req);
3274         struct dcerpc_srvsvc_NetSessDel_state *state = tevent_req_data(
3275                 req, struct dcerpc_srvsvc_NetSessDel_state);
3276         NTSTATUS status;
3277         TALLOC_CTX *mem_ctx;
3278
3279         if (state->out_mem_ctx) {
3280                 mem_ctx = state->out_mem_ctx;
3281         } else {
3282                 mem_ctx = state;
3283         }
3284
3285         status = dcerpc_srvsvc_NetSessDel_r_recv(subreq, mem_ctx);
3286         TALLOC_FREE(subreq);
3287         if (!NT_STATUS_IS_OK(status)) {
3288                 tevent_req_nterror(req, status);
3289                 return;
3290         }
3291
3292         /* Copy out parameters */
3293
3294         /* Copy result */
3295         state->orig.out.result = state->tmp.out.result;
3296
3297         /* Reset temporary structure */
3298         ZERO_STRUCT(state->tmp);
3299
3300         tevent_req_done(req);
3301 }
3302
3303 NTSTATUS dcerpc_srvsvc_NetSessDel_recv(struct tevent_req *req,
3304                                        TALLOC_CTX *mem_ctx,
3305                                        WERROR *result)
3306 {
3307         struct dcerpc_srvsvc_NetSessDel_state *state = tevent_req_data(
3308                 req, struct dcerpc_srvsvc_NetSessDel_state);
3309         NTSTATUS status;
3310
3311         if (tevent_req_is_nterror(req, &status)) {
3312                 tevent_req_received(req);
3313                 return status;
3314         }
3315
3316         /* Steal possible out parameters to the callers context */
3317         talloc_steal(mem_ctx, state->out_mem_ctx);
3318
3319         /* Return result */
3320         *result = state->orig.out.result;
3321
3322         tevent_req_received(req);
3323         return NT_STATUS_OK;
3324 }
3325
3326 NTSTATUS dcerpc_srvsvc_NetSessDel(struct dcerpc_binding_handle *h,
3327                                   TALLOC_CTX *mem_ctx,
3328                                   const char *_server_unc /* [in] [unique,charset(UTF16)] */,
3329                                   const char *_client /* [in] [unique,charset(UTF16)] */,
3330                                   const char *_user /* [in] [unique,charset(UTF16)] */,
3331                                   WERROR *result)
3332 {
3333         struct srvsvc_NetSessDel r;
3334         NTSTATUS status;
3335
3336         /* In parameters */
3337         r.in.server_unc = _server_unc;
3338         r.in.client = _client;
3339         r.in.user = _user;
3340
3341         status = dcerpc_srvsvc_NetSessDel_r(h, mem_ctx, &r);
3342         if (!NT_STATUS_IS_OK(status)) {
3343                 return status;
3344         }
3345
3346         /* Return variables */
3347
3348         /* Return result */
3349         *result = r.out.result;
3350
3351         return NT_STATUS_OK;
3352 }
3353
3354 struct dcerpc_srvsvc_NetShareAdd_r_state {
3355         TALLOC_CTX *out_mem_ctx;
3356 };
3357
3358 static void dcerpc_srvsvc_NetShareAdd_r_done(struct tevent_req *subreq);
3359
3360 struct tevent_req *dcerpc_srvsvc_NetShareAdd_r_send(TALLOC_CTX *mem_ctx,
3361         struct tevent_context *ev,
3362         struct dcerpc_binding_handle *h,
3363         struct srvsvc_NetShareAdd *r)
3364 {
3365         struct tevent_req *req;
3366         struct dcerpc_srvsvc_NetShareAdd_r_state *state;
3367         struct tevent_req *subreq;
3368
3369         req = tevent_req_create(mem_ctx, &state,
3370                                 struct dcerpc_srvsvc_NetShareAdd_r_state);
3371         if (req == NULL) {
3372                 return NULL;
3373         }
3374
3375         state->out_mem_ctx = talloc_new(state);
3376         if (tevent_req_nomem(state->out_mem_ctx, req)) {
3377                 return tevent_req_post(req, ev);
3378         }
3379
3380         subreq = dcerpc_binding_handle_call_send(state, ev, h,
3381                         NULL, &ndr_table_srvsvc,
3382                         NDR_SRVSVC_NETSHAREADD, state->out_mem_ctx, r);
3383         if (tevent_req_nomem(subreq, req)) {
3384                 return tevent_req_post(req, ev);
3385         }
3386         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetShareAdd_r_done, req);
3387
3388         return req;
3389 }
3390
3391 static void dcerpc_srvsvc_NetShareAdd_r_done(struct tevent_req *subreq)
3392 {
3393         struct tevent_req *req =
3394                 tevent_req_callback_data(subreq,
3395                 struct tevent_req);
3396         NTSTATUS status;
3397
3398         status = dcerpc_binding_handle_call_recv(subreq);
3399         if (!NT_STATUS_IS_OK(status)) {
3400                 tevent_req_nterror(req, status);
3401                 return;
3402         }
3403
3404         tevent_req_done(req);
3405 }
3406
3407 NTSTATUS dcerpc_srvsvc_NetShareAdd_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
3408 {
3409         struct dcerpc_srvsvc_NetShareAdd_r_state *state =
3410                 tevent_req_data(req,
3411                 struct dcerpc_srvsvc_NetShareAdd_r_state);
3412         NTSTATUS status;
3413
3414         if (tevent_req_is_nterror(req, &status)) {
3415                 tevent_req_received(req);
3416                 return status;
3417         }
3418
3419         talloc_steal(mem_ctx, state->out_mem_ctx);
3420
3421         tevent_req_received(req);
3422         return NT_STATUS_OK;
3423 }
3424
3425 NTSTATUS dcerpc_srvsvc_NetShareAdd_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetShareAdd *r)
3426 {
3427         NTSTATUS status;
3428
3429         status = dcerpc_binding_handle_call(h,
3430                         NULL, &ndr_table_srvsvc,
3431                         NDR_SRVSVC_NETSHAREADD, mem_ctx, r);
3432
3433         return status;
3434 }
3435
3436 NTSTATUS dcerpc_srvsvc_NetShareAdd_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetShareAdd *r)
3437 {
3438         NTSTATUS status;
3439
3440         status = dcerpc_srvsvc_NetShareAdd_r(p->binding_handle, mem_ctx, r);
3441
3442         if (NT_STATUS_IS_RPC(status)) {
3443                 status = NT_STATUS_NET_WRITE_FAULT;
3444         }
3445
3446         return status;
3447 }
3448
3449 struct dcerpc_srvsvc_NetShareAdd_state {
3450         struct srvsvc_NetShareAdd orig;
3451         struct srvsvc_NetShareAdd tmp;
3452         TALLOC_CTX *out_mem_ctx;
3453 };
3454
3455 static void dcerpc_srvsvc_NetShareAdd_done(struct tevent_req *subreq);
3456
3457 struct tevent_req *dcerpc_srvsvc_NetShareAdd_send(TALLOC_CTX *mem_ctx,
3458                                                   struct tevent_context *ev,
3459                                                   struct dcerpc_binding_handle *h,
3460                                                   const char *_server_unc /* [in] [unique,charset(UTF16)] */,
3461                                                   uint32_t _level /* [in]  */,
3462                                                   union srvsvc_NetShareInfo *_info /* [in] [ref,switch_is(level)] */,
3463                                                   uint32_t *_parm_error /* [in,out] [unique] */)
3464 {
3465         struct tevent_req *req;
3466         struct dcerpc_srvsvc_NetShareAdd_state *state;
3467         struct tevent_req *subreq;
3468
3469         req = tevent_req_create(mem_ctx, &state,
3470                                 struct dcerpc_srvsvc_NetShareAdd_state);
3471         if (req == NULL) {
3472                 return NULL;
3473         }
3474         state->out_mem_ctx = NULL;
3475
3476         /* In parameters */
3477         state->orig.in.server_unc = _server_unc;
3478         state->orig.in.level = _level;
3479         state->orig.in.info = _info;
3480         state->orig.in.parm_error = _parm_error;
3481
3482         /* Out parameters */
3483         state->orig.out.parm_error = _parm_error;
3484
3485         /* Result */
3486         ZERO_STRUCT(state->orig.out.result);
3487
3488         state->out_mem_ctx = talloc_named_const(state, 0,
3489                              "dcerpc_srvsvc_NetShareAdd_out_memory");
3490         if (tevent_req_nomem(state->out_mem_ctx, req)) {
3491                 return tevent_req_post(req, ev);
3492         }
3493
3494         /* make a temporary copy, that we pass to the dispatch function */
3495         state->tmp = state->orig;
3496
3497         subreq = dcerpc_srvsvc_NetShareAdd_r_send(state, ev, h, &state->tmp);
3498         if (tevent_req_nomem(subreq, req)) {
3499                 return tevent_req_post(req, ev);
3500         }
3501         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetShareAdd_done, req);
3502         return req;
3503 }
3504
3505 static void dcerpc_srvsvc_NetShareAdd_done(struct tevent_req *subreq)
3506 {
3507         struct tevent_req *req = tevent_req_callback_data(
3508                 subreq, struct tevent_req);
3509         struct dcerpc_srvsvc_NetShareAdd_state *state = tevent_req_data(
3510                 req, struct dcerpc_srvsvc_NetShareAdd_state);
3511         NTSTATUS status;
3512         TALLOC_CTX *mem_ctx;
3513
3514         if (state->out_mem_ctx) {
3515                 mem_ctx = state->out_mem_ctx;
3516         } else {
3517                 mem_ctx = state;
3518         }
3519
3520         status = dcerpc_srvsvc_NetShareAdd_r_recv(subreq, mem_ctx);
3521         TALLOC_FREE(subreq);
3522         if (!NT_STATUS_IS_OK(status)) {
3523                 tevent_req_nterror(req, status);
3524                 return;
3525         }
3526
3527         /* Copy out parameters */
3528         if (state->orig.out.parm_error && state->tmp.out.parm_error) {
3529                 *state->orig.out.parm_error = *state->tmp.out.parm_error;
3530         }
3531
3532         /* Copy result */
3533         state->orig.out.result = state->tmp.out.result;
3534
3535         /* Reset temporary structure */
3536         ZERO_STRUCT(state->tmp);
3537
3538         tevent_req_done(req);
3539 }
3540
3541 NTSTATUS dcerpc_srvsvc_NetShareAdd_recv(struct tevent_req *req,
3542                                         TALLOC_CTX *mem_ctx,
3543                                         WERROR *result)
3544 {
3545         struct dcerpc_srvsvc_NetShareAdd_state *state = tevent_req_data(
3546                 req, struct dcerpc_srvsvc_NetShareAdd_state);
3547         NTSTATUS status;
3548
3549         if (tevent_req_is_nterror(req, &status)) {
3550                 tevent_req_received(req);
3551                 return status;
3552         }
3553
3554         /* Steal possible out parameters to the callers context */
3555         talloc_steal(mem_ctx, state->out_mem_ctx);
3556
3557         /* Return result */
3558         *result = state->orig.out.result;
3559
3560         tevent_req_received(req);
3561         return NT_STATUS_OK;
3562 }
3563
3564 NTSTATUS dcerpc_srvsvc_NetShareAdd(struct dcerpc_binding_handle *h,
3565                                    TALLOC_CTX *mem_ctx,
3566                                    const char *_server_unc /* [in] [unique,charset(UTF16)] */,
3567                                    uint32_t _level /* [in]  */,
3568                                    union srvsvc_NetShareInfo *_info /* [in] [ref,switch_is(level)] */,
3569                                    uint32_t *_parm_error /* [in,out] [unique] */,
3570                                    WERROR *result)
3571 {
3572         struct srvsvc_NetShareAdd r;
3573         NTSTATUS status;
3574
3575         /* In parameters */
3576         r.in.server_unc = _server_unc;
3577         r.in.level = _level;
3578         r.in.info = _info;
3579         r.in.parm_error = _parm_error;
3580
3581         status = dcerpc_srvsvc_NetShareAdd_r(h, mem_ctx, &r);
3582         if (!NT_STATUS_IS_OK(status)) {
3583                 return status;
3584         }
3585
3586         /* Return variables */
3587         if (_parm_error && r.out.parm_error) {
3588                 *_parm_error = *r.out.parm_error;
3589         }
3590
3591         /* Return result */
3592         *result = r.out.result;
3593
3594         return NT_STATUS_OK;
3595 }
3596
3597 struct dcerpc_srvsvc_NetShareEnumAll_r_state {
3598         TALLOC_CTX *out_mem_ctx;
3599 };
3600
3601 static void dcerpc_srvsvc_NetShareEnumAll_r_done(struct tevent_req *subreq);
3602
3603 struct tevent_req *dcerpc_srvsvc_NetShareEnumAll_r_send(TALLOC_CTX *mem_ctx,
3604         struct tevent_context *ev,
3605         struct dcerpc_binding_handle *h,
3606         struct srvsvc_NetShareEnumAll *r)
3607 {
3608         struct tevent_req *req;
3609         struct dcerpc_srvsvc_NetShareEnumAll_r_state *state;
3610         struct tevent_req *subreq;
3611
3612         req = tevent_req_create(mem_ctx, &state,
3613                                 struct dcerpc_srvsvc_NetShareEnumAll_r_state);
3614         if (req == NULL) {
3615                 return NULL;
3616         }
3617
3618         state->out_mem_ctx = talloc_new(state);
3619         if (tevent_req_nomem(state->out_mem_ctx, req)) {
3620                 return tevent_req_post(req, ev);
3621         }
3622
3623         subreq = dcerpc_binding_handle_call_send(state, ev, h,
3624                         NULL, &ndr_table_srvsvc,
3625                         NDR_SRVSVC_NETSHAREENUMALL, state->out_mem_ctx, r);
3626         if (tevent_req_nomem(subreq, req)) {
3627                 return tevent_req_post(req, ev);
3628         }
3629         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetShareEnumAll_r_done, req);
3630
3631         return req;
3632 }
3633
3634 static void dcerpc_srvsvc_NetShareEnumAll_r_done(struct tevent_req *subreq)
3635 {
3636         struct tevent_req *req =
3637                 tevent_req_callback_data(subreq,
3638                 struct tevent_req);
3639         NTSTATUS status;
3640
3641         status = dcerpc_binding_handle_call_recv(subreq);
3642         if (!NT_STATUS_IS_OK(status)) {
3643                 tevent_req_nterror(req, status);
3644                 return;
3645         }
3646
3647         tevent_req_done(req);
3648 }
3649
3650 NTSTATUS dcerpc_srvsvc_NetShareEnumAll_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
3651 {
3652         struct dcerpc_srvsvc_NetShareEnumAll_r_state *state =
3653                 tevent_req_data(req,
3654                 struct dcerpc_srvsvc_NetShareEnumAll_r_state);
3655         NTSTATUS status;
3656
3657         if (tevent_req_is_nterror(req, &status)) {
3658                 tevent_req_received(req);
3659                 return status;
3660         }
3661
3662         talloc_steal(mem_ctx, state->out_mem_ctx);
3663
3664         tevent_req_received(req);
3665         return NT_STATUS_OK;
3666 }
3667
3668 NTSTATUS dcerpc_srvsvc_NetShareEnumAll_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetShareEnumAll *r)
3669 {
3670         NTSTATUS status;
3671
3672         status = dcerpc_binding_handle_call(h,
3673                         NULL, &ndr_table_srvsvc,
3674                         NDR_SRVSVC_NETSHAREENUMALL, mem_ctx, r);
3675
3676         return status;
3677 }
3678
3679 NTSTATUS dcerpc_srvsvc_NetShareEnumAll_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetShareEnumAll *r)
3680 {
3681         NTSTATUS status;
3682
3683         status = dcerpc_srvsvc_NetShareEnumAll_r(p->binding_handle, mem_ctx, r);
3684
3685         if (NT_STATUS_IS_RPC(status)) {
3686                 status = NT_STATUS_NET_WRITE_FAULT;
3687         }
3688
3689         return status;
3690 }
3691
3692 struct dcerpc_srvsvc_NetShareEnumAll_state {
3693         struct srvsvc_NetShareEnumAll orig;
3694         struct srvsvc_NetShareEnumAll tmp;
3695         TALLOC_CTX *out_mem_ctx;
3696 };
3697
3698 static void dcerpc_srvsvc_NetShareEnumAll_done(struct tevent_req *subreq);
3699
3700 struct tevent_req *dcerpc_srvsvc_NetShareEnumAll_send(TALLOC_CTX *mem_ctx,
3701                                                       struct tevent_context *ev,
3702                                                       struct dcerpc_binding_handle *h,
3703                                                       const char *_server_unc /* [in] [unique,charset(UTF16)] */,
3704                                                       struct srvsvc_NetShareInfoCtr *_info_ctr /* [in,out] [ref] */,
3705                                                       uint32_t _max_buffer /* [in]  */,
3706                                                       uint32_t *_totalentries /* [out] [ref] */,
3707                                                       uint32_t *_resume_handle /* [in,out] [unique] */)
3708 {
3709         struct tevent_req *req;
3710         struct dcerpc_srvsvc_NetShareEnumAll_state *state;
3711         struct tevent_req *subreq;
3712
3713         req = tevent_req_create(mem_ctx, &state,
3714                                 struct dcerpc_srvsvc_NetShareEnumAll_state);
3715         if (req == NULL) {
3716                 return NULL;
3717         }
3718         state->out_mem_ctx = NULL;
3719
3720         /* In parameters */
3721         state->orig.in.server_unc = _server_unc;
3722         state->orig.in.info_ctr = _info_ctr;
3723         state->orig.in.max_buffer = _max_buffer;
3724         state->orig.in.resume_handle = _resume_handle;
3725
3726         /* Out parameters */
3727         state->orig.out.info_ctr = _info_ctr;
3728         state->orig.out.totalentries = _totalentries;
3729         state->orig.out.resume_handle = _resume_handle;
3730
3731         /* Result */
3732         ZERO_STRUCT(state->orig.out.result);
3733
3734         state->out_mem_ctx = talloc_named_const(state, 0,
3735                              "dcerpc_srvsvc_NetShareEnumAll_out_memory");
3736         if (tevent_req_nomem(state->out_mem_ctx, req)) {
3737                 return tevent_req_post(req, ev);
3738         }
3739
3740         /* make a temporary copy, that we pass to the dispatch function */
3741         state->tmp = state->orig;
3742
3743         subreq = dcerpc_srvsvc_NetShareEnumAll_r_send(state, ev, h, &state->tmp);
3744         if (tevent_req_nomem(subreq, req)) {
3745                 return tevent_req_post(req, ev);
3746         }
3747         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetShareEnumAll_done, req);
3748         return req;
3749 }
3750
3751 static void dcerpc_srvsvc_NetShareEnumAll_done(struct tevent_req *subreq)
3752 {
3753         struct tevent_req *req = tevent_req_callback_data(
3754                 subreq, struct tevent_req);
3755         struct dcerpc_srvsvc_NetShareEnumAll_state *state = tevent_req_data(
3756                 req, struct dcerpc_srvsvc_NetShareEnumAll_state);
3757         NTSTATUS status;
3758         TALLOC_CTX *mem_ctx;
3759
3760         if (state->out_mem_ctx) {
3761                 mem_ctx = state->out_mem_ctx;
3762         } else {
3763                 mem_ctx = state;
3764         }
3765
3766         status = dcerpc_srvsvc_NetShareEnumAll_r_recv(subreq, mem_ctx);
3767         TALLOC_FREE(subreq);
3768         if (!NT_STATUS_IS_OK(status)) {
3769                 tevent_req_nterror(req, status);
3770                 return;
3771         }
3772
3773         /* Copy out parameters */
3774         *state->orig.out.info_ctr = *state->tmp.out.info_ctr;
3775         *state->orig.out.totalentries = *state->tmp.out.totalentries;
3776         if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
3777                 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
3778         }
3779
3780         /* Copy result */
3781         state->orig.out.result = state->tmp.out.result;
3782
3783         /* Reset temporary structure */
3784         ZERO_STRUCT(state->tmp);
3785
3786         tevent_req_done(req);
3787 }
3788
3789 NTSTATUS dcerpc_srvsvc_NetShareEnumAll_recv(struct tevent_req *req,
3790                                             TALLOC_CTX *mem_ctx,
3791                                             WERROR *result)
3792 {
3793         struct dcerpc_srvsvc_NetShareEnumAll_state *state = tevent_req_data(
3794                 req, struct dcerpc_srvsvc_NetShareEnumAll_state);
3795         NTSTATUS status;
3796
3797         if (tevent_req_is_nterror(req, &status)) {
3798                 tevent_req_received(req);
3799                 return status;
3800         }
3801
3802         /* Steal possible out parameters to the callers context */
3803         talloc_steal(mem_ctx, state->out_mem_ctx);
3804
3805         /* Return result */
3806         *result = state->orig.out.result;
3807
3808         tevent_req_received(req);
3809         return NT_STATUS_OK;
3810 }
3811
3812 NTSTATUS dcerpc_srvsvc_NetShareEnumAll(struct dcerpc_binding_handle *h,
3813                                        TALLOC_CTX *mem_ctx,
3814                                        const char *_server_unc /* [in] [unique,charset(UTF16)] */,
3815                                        struct srvsvc_NetShareInfoCtr *_info_ctr /* [in,out] [ref] */,
3816                                        uint32_t _max_buffer /* [in]  */,
3817                                        uint32_t *_totalentries /* [out] [ref] */,
3818                                        uint32_t *_resume_handle /* [in,out] [unique] */,
3819                                        WERROR *result)
3820 {
3821         struct srvsvc_NetShareEnumAll r;
3822         NTSTATUS status;
3823
3824         /* In parameters */
3825         r.in.server_unc = _server_unc;
3826         r.in.info_ctr = _info_ctr;
3827         r.in.max_buffer = _max_buffer;
3828         r.in.resume_handle = _resume_handle;
3829
3830         status = dcerpc_srvsvc_NetShareEnumAll_r(h, mem_ctx, &r);
3831         if (!NT_STATUS_IS_OK(status)) {
3832                 return status;
3833         }
3834
3835         /* Return variables */
3836         *_info_ctr = *r.out.info_ctr;
3837         *_totalentries = *r.out.totalentries;
3838         if (_resume_handle && r.out.resume_handle) {
3839                 *_resume_handle = *r.out.resume_handle;
3840         }
3841
3842         /* Return result */
3843         *result = r.out.result;
3844
3845         return NT_STATUS_OK;
3846 }
3847
3848 struct dcerpc_srvsvc_NetShareGetInfo_r_state {
3849         TALLOC_CTX *out_mem_ctx;
3850 };
3851
3852 static void dcerpc_srvsvc_NetShareGetInfo_r_done(struct tevent_req *subreq);
3853
3854 struct tevent_req *dcerpc_srvsvc_NetShareGetInfo_r_send(TALLOC_CTX *mem_ctx,
3855         struct tevent_context *ev,
3856         struct dcerpc_binding_handle *h,
3857         struct srvsvc_NetShareGetInfo *r)
3858 {
3859         struct tevent_req *req;
3860         struct dcerpc_srvsvc_NetShareGetInfo_r_state *state;
3861         struct tevent_req *subreq;
3862
3863         req = tevent_req_create(mem_ctx, &state,
3864                                 struct dcerpc_srvsvc_NetShareGetInfo_r_state);
3865         if (req == NULL) {
3866                 return NULL;
3867         }
3868
3869         state->out_mem_ctx = talloc_new(state);
3870         if (tevent_req_nomem(state->out_mem_ctx, req)) {
3871                 return tevent_req_post(req, ev);
3872         }
3873
3874         subreq = dcerpc_binding_handle_call_send(state, ev, h,
3875                         NULL, &ndr_table_srvsvc,
3876                         NDR_SRVSVC_NETSHAREGETINFO, state->out_mem_ctx, r);
3877         if (tevent_req_nomem(subreq, req)) {
3878                 return tevent_req_post(req, ev);
3879         }
3880         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetShareGetInfo_r_done, req);
3881
3882         return req;
3883 }
3884
3885 static void dcerpc_srvsvc_NetShareGetInfo_r_done(struct tevent_req *subreq)
3886 {
3887         struct tevent_req *req =
3888                 tevent_req_callback_data(subreq,
3889                 struct tevent_req);
3890         NTSTATUS status;
3891
3892         status = dcerpc_binding_handle_call_recv(subreq);
3893         if (!NT_STATUS_IS_OK(status)) {
3894                 tevent_req_nterror(req, status);
3895                 return;
3896         }
3897
3898         tevent_req_done(req);
3899 }
3900
3901 NTSTATUS dcerpc_srvsvc_NetShareGetInfo_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
3902 {
3903         struct dcerpc_srvsvc_NetShareGetInfo_r_state *state =
3904                 tevent_req_data(req,
3905                 struct dcerpc_srvsvc_NetShareGetInfo_r_state);
3906         NTSTATUS status;
3907
3908         if (tevent_req_is_nterror(req, &status)) {
3909                 tevent_req_received(req);
3910                 return status;
3911         }
3912
3913         talloc_steal(mem_ctx, state->out_mem_ctx);
3914
3915         tevent_req_received(req);
3916         return NT_STATUS_OK;
3917 }
3918
3919 NTSTATUS dcerpc_srvsvc_NetShareGetInfo_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetShareGetInfo *r)
3920 {
3921         NTSTATUS status;
3922
3923         status = dcerpc_binding_handle_call(h,
3924                         NULL, &ndr_table_srvsvc,
3925                         NDR_SRVSVC_NETSHAREGETINFO, mem_ctx, r);
3926
3927         return status;
3928 }
3929
3930 NTSTATUS dcerpc_srvsvc_NetShareGetInfo_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetShareGetInfo *r)
3931 {
3932         NTSTATUS status;
3933
3934         status = dcerpc_srvsvc_NetShareGetInfo_r(p->binding_handle, mem_ctx, r);
3935
3936         if (NT_STATUS_IS_RPC(status)) {
3937                 status = NT_STATUS_NET_WRITE_FAULT;
3938         }
3939
3940         return status;
3941 }
3942
3943 struct dcerpc_srvsvc_NetShareGetInfo_state {
3944         struct srvsvc_NetShareGetInfo orig;
3945         struct srvsvc_NetShareGetInfo tmp;
3946         TALLOC_CTX *out_mem_ctx;
3947 };
3948
3949 static void dcerpc_srvsvc_NetShareGetInfo_done(struct tevent_req *subreq);
3950
3951 struct tevent_req *dcerpc_srvsvc_NetShareGetInfo_send(TALLOC_CTX *mem_ctx,
3952                                                       struct tevent_context *ev,
3953                                                       struct dcerpc_binding_handle *h,
3954                                                       const char *_server_unc /* [in] [unique,charset(UTF16)] */,
3955                                                       const char *_share_name /* [in] [charset(UTF16)] */,
3956                                                       uint32_t _level /* [in]  */,
3957                                                       union srvsvc_NetShareInfo *_info /* [out] [ref,switch_is(level)] */)
3958 {
3959         struct tevent_req *req;
3960         struct dcerpc_srvsvc_NetShareGetInfo_state *state;
3961         struct tevent_req *subreq;
3962
3963         req = tevent_req_create(mem_ctx, &state,
3964                                 struct dcerpc_srvsvc_NetShareGetInfo_state);
3965         if (req == NULL) {
3966                 return NULL;
3967         }
3968         state->out_mem_ctx = NULL;
3969
3970         /* In parameters */
3971         state->orig.in.server_unc = _server_unc;
3972         state->orig.in.share_name = _share_name;
3973         state->orig.in.level = _level;
3974
3975         /* Out parameters */
3976         state->orig.out.info = _info;
3977
3978         /* Result */
3979         ZERO_STRUCT(state->orig.out.result);
3980
3981         state->out_mem_ctx = talloc_named_const(state, 0,
3982                              "dcerpc_srvsvc_NetShareGetInfo_out_memory");
3983         if (tevent_req_nomem(state->out_mem_ctx, req)) {
3984                 return tevent_req_post(req, ev);
3985         }
3986
3987         /* make a temporary copy, that we pass to the dispatch function */
3988         state->tmp = state->orig;
3989
3990         subreq = dcerpc_srvsvc_NetShareGetInfo_r_send(state, ev, h, &state->tmp);
3991         if (tevent_req_nomem(subreq, req)) {
3992                 return tevent_req_post(req, ev);
3993         }
3994         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetShareGetInfo_done, req);
3995         return req;
3996 }
3997
3998 static void dcerpc_srvsvc_NetShareGetInfo_done(struct tevent_req *subreq)
3999 {
4000         struct tevent_req *req = tevent_req_callback_data(
4001                 subreq, struct tevent_req);
4002         struct dcerpc_srvsvc_NetShareGetInfo_state *state = tevent_req_data(
4003                 req, struct dcerpc_srvsvc_NetShareGetInfo_state);
4004         NTSTATUS status;
4005         TALLOC_CTX *mem_ctx;
4006
4007         if (state->out_mem_ctx) {
4008                 mem_ctx = state->out_mem_ctx;
4009         } else {
4010                 mem_ctx = state;
4011         }
4012
4013         status = dcerpc_srvsvc_NetShareGetInfo_r_recv(subreq, mem_ctx);
4014         TALLOC_FREE(subreq);
4015         if (!NT_STATUS_IS_OK(status)) {
4016                 tevent_req_nterror(req, status);
4017                 return;
4018         }
4019
4020         /* Copy out parameters */
4021         *state->orig.out.info = *state->tmp.out.info;
4022
4023         /* Copy result */
4024         state->orig.out.result = state->tmp.out.result;
4025
4026         /* Reset temporary structure */
4027         ZERO_STRUCT(state->tmp);
4028
4029         tevent_req_done(req);
4030 }
4031
4032 NTSTATUS dcerpc_srvsvc_NetShareGetInfo_recv(struct tevent_req *req,
4033                                             TALLOC_CTX *mem_ctx,
4034                                             WERROR *result)
4035 {
4036         struct dcerpc_srvsvc_NetShareGetInfo_state *state = tevent_req_data(
4037                 req, struct dcerpc_srvsvc_NetShareGetInfo_state);
4038         NTSTATUS status;
4039
4040         if (tevent_req_is_nterror(req, &status)) {
4041                 tevent_req_received(req);
4042                 return status;
4043         }
4044
4045         /* Steal possible out parameters to the callers context */
4046         talloc_steal(mem_ctx, state->out_mem_ctx);
4047
4048         /* Return result */
4049         *result = state->orig.out.result;
4050
4051         tevent_req_received(req);
4052         return NT_STATUS_OK;
4053 }
4054
4055 NTSTATUS dcerpc_srvsvc_NetShareGetInfo(struct dcerpc_binding_handle *h,
4056                                        TALLOC_CTX *mem_ctx,
4057                                        const char *_server_unc /* [in] [unique,charset(UTF16)] */,
4058                                        const char *_share_name /* [in] [charset(UTF16)] */,
4059                                        uint32_t _level /* [in]  */,
4060                                        union srvsvc_NetShareInfo *_info /* [out] [ref,switch_is(level)] */,
4061                                        WERROR *result)
4062 {
4063         struct srvsvc_NetShareGetInfo r;
4064         NTSTATUS status;
4065
4066         /* In parameters */
4067         r.in.server_unc = _server_unc;
4068         r.in.share_name = _share_name;
4069         r.in.level = _level;
4070
4071         status = dcerpc_srvsvc_NetShareGetInfo_r(h, mem_ctx, &r);
4072         if (!NT_STATUS_IS_OK(status)) {
4073                 return status;
4074         }
4075
4076         /* Return variables */
4077         *_info = *r.out.info;
4078
4079         /* Return result */
4080         *result = r.out.result;
4081
4082         return NT_STATUS_OK;
4083 }
4084
4085 struct dcerpc_srvsvc_NetShareSetInfo_r_state {
4086         TALLOC_CTX *out_mem_ctx;
4087 };
4088
4089 static void dcerpc_srvsvc_NetShareSetInfo_r_done(struct tevent_req *subreq);
4090
4091 struct tevent_req *dcerpc_srvsvc_NetShareSetInfo_r_send(TALLOC_CTX *mem_ctx,
4092         struct tevent_context *ev,
4093         struct dcerpc_binding_handle *h,
4094         struct srvsvc_NetShareSetInfo *r)
4095 {
4096         struct tevent_req *req;
4097         struct dcerpc_srvsvc_NetShareSetInfo_r_state *state;
4098         struct tevent_req *subreq;
4099
4100         req = tevent_req_create(mem_ctx, &state,
4101                                 struct dcerpc_srvsvc_NetShareSetInfo_r_state);
4102         if (req == NULL) {
4103                 return NULL;
4104         }
4105
4106         state->out_mem_ctx = talloc_new(state);
4107         if (tevent_req_nomem(state->out_mem_ctx, req)) {
4108                 return tevent_req_post(req, ev);
4109         }
4110
4111         subreq = dcerpc_binding_handle_call_send(state, ev, h,
4112                         NULL, &ndr_table_srvsvc,
4113                         NDR_SRVSVC_NETSHARESETINFO, state->out_mem_ctx, r);
4114         if (tevent_req_nomem(subreq, req)) {
4115                 return tevent_req_post(req, ev);
4116         }
4117         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetShareSetInfo_r_done, req);
4118
4119         return req;
4120 }
4121
4122 static void dcerpc_srvsvc_NetShareSetInfo_r_done(struct tevent_req *subreq)
4123 {
4124         struct tevent_req *req =
4125                 tevent_req_callback_data(subreq,
4126                 struct tevent_req);
4127         NTSTATUS status;
4128
4129         status = dcerpc_binding_handle_call_recv(subreq);
4130         if (!NT_STATUS_IS_OK(status)) {
4131                 tevent_req_nterror(req, status);
4132                 return;
4133         }
4134
4135         tevent_req_done(req);
4136 }
4137
4138 NTSTATUS dcerpc_srvsvc_NetShareSetInfo_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
4139 {
4140         struct dcerpc_srvsvc_NetShareSetInfo_r_state *state =
4141                 tevent_req_data(req,
4142                 struct dcerpc_srvsvc_NetShareSetInfo_r_state);
4143         NTSTATUS status;
4144
4145         if (tevent_req_is_nterror(req, &status)) {
4146                 tevent_req_received(req);
4147                 return status;
4148         }
4149
4150         talloc_steal(mem_ctx, state->out_mem_ctx);
4151
4152         tevent_req_received(req);
4153         return NT_STATUS_OK;
4154 }
4155
4156 NTSTATUS dcerpc_srvsvc_NetShareSetInfo_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetShareSetInfo *r)
4157 {
4158         NTSTATUS status;
4159
4160         status = dcerpc_binding_handle_call(h,
4161                         NULL, &ndr_table_srvsvc,
4162                         NDR_SRVSVC_NETSHARESETINFO, mem_ctx, r);
4163
4164         return status;
4165 }
4166
4167 NTSTATUS dcerpc_srvsvc_NetShareSetInfo_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetShareSetInfo *r)
4168 {
4169         NTSTATUS status;
4170
4171         status = dcerpc_srvsvc_NetShareSetInfo_r(p->binding_handle, mem_ctx, r);
4172
4173         if (NT_STATUS_IS_RPC(status)) {
4174                 status = NT_STATUS_NET_WRITE_FAULT;
4175         }
4176
4177         return status;
4178 }
4179
4180 struct dcerpc_srvsvc_NetShareSetInfo_state {
4181         struct srvsvc_NetShareSetInfo orig;
4182         struct srvsvc_NetShareSetInfo tmp;
4183         TALLOC_CTX *out_mem_ctx;
4184 };
4185
4186 static void dcerpc_srvsvc_NetShareSetInfo_done(struct tevent_req *subreq);
4187
4188 struct tevent_req *dcerpc_srvsvc_NetShareSetInfo_send(TALLOC_CTX *mem_ctx,
4189                                                       struct tevent_context *ev,
4190                                                       struct dcerpc_binding_handle *h,
4191                                                       const char *_server_unc /* [in] [unique,charset(UTF16)] */,
4192                                                       const char *_share_name /* [in] [charset(UTF16)] */,
4193                                                       uint32_t _level /* [in]  */,
4194                                                       union srvsvc_NetShareInfo *_info /* [in] [ref,switch_is(level)] */,
4195                                                       uint32_t *_parm_error /* [in,out] [unique] */)
4196 {
4197         struct tevent_req *req;
4198         struct dcerpc_srvsvc_NetShareSetInfo_state *state;
4199         struct tevent_req *subreq;
4200
4201         req = tevent_req_create(mem_ctx, &state,
4202                                 struct dcerpc_srvsvc_NetShareSetInfo_state);
4203         if (req == NULL) {
4204                 return NULL;
4205         }
4206         state->out_mem_ctx = NULL;
4207
4208         /* In parameters */
4209         state->orig.in.server_unc = _server_unc;
4210         state->orig.in.share_name = _share_name;
4211         state->orig.in.level = _level;
4212         state->orig.in.info = _info;
4213         state->orig.in.parm_error = _parm_error;
4214
4215         /* Out parameters */
4216         state->orig.out.parm_error = _parm_error;
4217
4218         /* Result */
4219         ZERO_STRUCT(state->orig.out.result);
4220
4221         state->out_mem_ctx = talloc_named_const(state, 0,
4222                              "dcerpc_srvsvc_NetShareSetInfo_out_memory");
4223         if (tevent_req_nomem(state->out_mem_ctx, req)) {
4224                 return tevent_req_post(req, ev);
4225         }
4226
4227         /* make a temporary copy, that we pass to the dispatch function */
4228         state->tmp = state->orig;
4229
4230         subreq = dcerpc_srvsvc_NetShareSetInfo_r_send(state, ev, h, &state->tmp);
4231         if (tevent_req_nomem(subreq, req)) {
4232                 return tevent_req_post(req, ev);
4233         }
4234         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetShareSetInfo_done, req);
4235         return req;
4236 }
4237
4238 static void dcerpc_srvsvc_NetShareSetInfo_done(struct tevent_req *subreq)
4239 {
4240         struct tevent_req *req = tevent_req_callback_data(
4241                 subreq, struct tevent_req);
4242         struct dcerpc_srvsvc_NetShareSetInfo_state *state = tevent_req_data(
4243                 req, struct dcerpc_srvsvc_NetShareSetInfo_state);
4244         NTSTATUS status;
4245         TALLOC_CTX *mem_ctx;
4246
4247         if (state->out_mem_ctx) {
4248                 mem_ctx = state->out_mem_ctx;
4249         } else {
4250                 mem_ctx = state;
4251         }
4252
4253         status = dcerpc_srvsvc_NetShareSetInfo_r_recv(subreq, mem_ctx);
4254         TALLOC_FREE(subreq);
4255         if (!NT_STATUS_IS_OK(status)) {
4256                 tevent_req_nterror(req, status);
4257                 return;
4258         }
4259
4260         /* Copy out parameters */
4261         if (state->orig.out.parm_error && state->tmp.out.parm_error) {
4262                 *state->orig.out.parm_error = *state->tmp.out.parm_error;
4263         }
4264
4265         /* Copy result */
4266         state->orig.out.result = state->tmp.out.result;
4267
4268         /* Reset temporary structure */
4269         ZERO_STRUCT(state->tmp);
4270
4271         tevent_req_done(req);
4272 }
4273
4274 NTSTATUS dcerpc_srvsvc_NetShareSetInfo_recv(struct tevent_req *req,
4275                                             TALLOC_CTX *mem_ctx,
4276                                             WERROR *result)
4277 {
4278         struct dcerpc_srvsvc_NetShareSetInfo_state *state = tevent_req_data(
4279                 req, struct dcerpc_srvsvc_NetShareSetInfo_state);
4280         NTSTATUS status;
4281
4282         if (tevent_req_is_nterror(req, &status)) {
4283                 tevent_req_received(req);
4284                 return status;
4285         }
4286
4287         /* Steal possible out parameters to the callers context */
4288         talloc_steal(mem_ctx, state->out_mem_ctx);
4289
4290         /* Return result */
4291         *result = state->orig.out.result;
4292
4293         tevent_req_received(req);
4294         return NT_STATUS_OK;
4295 }
4296
4297 NTSTATUS dcerpc_srvsvc_NetShareSetInfo(struct dcerpc_binding_handle *h,
4298                                        TALLOC_CTX *mem_ctx,
4299                                        const char *_server_unc /* [in] [unique,charset(UTF16)] */,
4300                                        const char *_share_name /* [in] [charset(UTF16)] */,
4301                                        uint32_t _level /* [in]  */,
4302                                        union srvsvc_NetShareInfo *_info /* [in] [ref,switch_is(level)] */,
4303                                        uint32_t *_parm_error /* [in,out] [unique] */,
4304                                        WERROR *result)
4305 {
4306         struct srvsvc_NetShareSetInfo r;
4307         NTSTATUS status;
4308
4309         /* In parameters */
4310         r.in.server_unc = _server_unc;
4311         r.in.share_name = _share_name;
4312         r.in.level = _level;
4313         r.in.info = _info;
4314         r.in.parm_error = _parm_error;
4315
4316         status = dcerpc_srvsvc_NetShareSetInfo_r(h, mem_ctx, &r);
4317         if (!NT_STATUS_IS_OK(status)) {
4318                 return status;
4319         }
4320
4321         /* Return variables */
4322         if (_parm_error && r.out.parm_error) {
4323                 *_parm_error = *r.out.parm_error;
4324         }
4325
4326         /* Return result */
4327         *result = r.out.result;
4328
4329         return NT_STATUS_OK;
4330 }
4331
4332 struct dcerpc_srvsvc_NetShareDel_r_state {
4333         TALLOC_CTX *out_mem_ctx;
4334 };
4335
4336 static void dcerpc_srvsvc_NetShareDel_r_done(struct tevent_req *subreq);
4337
4338 struct tevent_req *dcerpc_srvsvc_NetShareDel_r_send(TALLOC_CTX *mem_ctx,
4339         struct tevent_context *ev,
4340         struct dcerpc_binding_handle *h,
4341         struct srvsvc_NetShareDel *r)
4342 {
4343         struct tevent_req *req;
4344         struct dcerpc_srvsvc_NetShareDel_r_state *state;
4345         struct tevent_req *subreq;
4346
4347         req = tevent_req_create(mem_ctx, &state,
4348                                 struct dcerpc_srvsvc_NetShareDel_r_state);
4349         if (req == NULL) {
4350                 return NULL;
4351         }
4352
4353         state->out_mem_ctx = NULL;
4354         subreq = dcerpc_binding_handle_call_send(state, ev, h,
4355                         NULL, &ndr_table_srvsvc,
4356                         NDR_SRVSVC_NETSHAREDEL, state, r);
4357         if (tevent_req_nomem(subreq, req)) {
4358                 return tevent_req_post(req, ev);
4359         }
4360         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetShareDel_r_done, req);
4361
4362         return req;
4363 }
4364
4365 static void dcerpc_srvsvc_NetShareDel_r_done(struct tevent_req *subreq)
4366 {
4367         struct tevent_req *req =
4368                 tevent_req_callback_data(subreq,
4369                 struct tevent_req);
4370         NTSTATUS status;
4371
4372         status = dcerpc_binding_handle_call_recv(subreq);
4373         if (!NT_STATUS_IS_OK(status)) {
4374                 tevent_req_nterror(req, status);
4375                 return;
4376         }
4377
4378         tevent_req_done(req);
4379 }
4380
4381 NTSTATUS dcerpc_srvsvc_NetShareDel_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
4382 {
4383         struct dcerpc_srvsvc_NetShareDel_r_state *state =
4384                 tevent_req_data(req,
4385                 struct dcerpc_srvsvc_NetShareDel_r_state);
4386         NTSTATUS status;
4387
4388         if (tevent_req_is_nterror(req, &status)) {
4389                 tevent_req_received(req);
4390                 return status;
4391         }
4392
4393         talloc_steal(mem_ctx, state->out_mem_ctx);
4394
4395         tevent_req_received(req);
4396         return NT_STATUS_OK;
4397 }
4398
4399 NTSTATUS dcerpc_srvsvc_NetShareDel_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetShareDel *r)
4400 {
4401         NTSTATUS status;
4402
4403         status = dcerpc_binding_handle_call(h,
4404                         NULL, &ndr_table_srvsvc,
4405                         NDR_SRVSVC_NETSHAREDEL, mem_ctx, r);
4406
4407         return status;
4408 }
4409
4410 NTSTATUS dcerpc_srvsvc_NetShareDel_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetShareDel *r)
4411 {
4412         NTSTATUS status;
4413
4414         status = dcerpc_srvsvc_NetShareDel_r(p->binding_handle, mem_ctx, r);
4415
4416         if (NT_STATUS_IS_RPC(status)) {
4417                 status = NT_STATUS_NET_WRITE_FAULT;
4418         }
4419
4420         return status;
4421 }
4422
4423 struct dcerpc_srvsvc_NetShareDel_state {
4424         struct srvsvc_NetShareDel orig;
4425         struct srvsvc_NetShareDel tmp;
4426         TALLOC_CTX *out_mem_ctx;
4427 };
4428
4429 static void dcerpc_srvsvc_NetShareDel_done(struct tevent_req *subreq);
4430
4431 struct tevent_req *dcerpc_srvsvc_NetShareDel_send(TALLOC_CTX *mem_ctx,
4432                                                   struct tevent_context *ev,
4433                                                   struct dcerpc_binding_handle *h,
4434                                                   const char *_server_unc /* [in] [unique,charset(UTF16)] */,
4435                                                   const char *_share_name /* [in] [charset(UTF16)] */,
4436                                                   uint32_t _reserved /* [in]  */)
4437 {
4438         struct tevent_req *req;
4439         struct dcerpc_srvsvc_NetShareDel_state *state;
4440         struct tevent_req *subreq;
4441
4442         req = tevent_req_create(mem_ctx, &state,
4443                                 struct dcerpc_srvsvc_NetShareDel_state);
4444         if (req == NULL) {
4445                 return NULL;
4446         }
4447         state->out_mem_ctx = NULL;
4448
4449         /* In parameters */
4450         state->orig.in.server_unc = _server_unc;
4451         state->orig.in.share_name = _share_name;
4452         state->orig.in.reserved = _reserved;
4453
4454         /* Out parameters */
4455
4456         /* Result */
4457         ZERO_STRUCT(state->orig.out.result);
4458
4459         /* make a temporary copy, that we pass to the dispatch function */
4460         state->tmp = state->orig;
4461
4462         subreq = dcerpc_srvsvc_NetShareDel_r_send(state, ev, h, &state->tmp);
4463         if (tevent_req_nomem(subreq, req)) {
4464                 return tevent_req_post(req, ev);
4465         }
4466         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetShareDel_done, req);
4467         return req;
4468 }
4469
4470 static void dcerpc_srvsvc_NetShareDel_done(struct tevent_req *subreq)
4471 {
4472         struct tevent_req *req = tevent_req_callback_data(
4473                 subreq, struct tevent_req);
4474         struct dcerpc_srvsvc_NetShareDel_state *state = tevent_req_data(
4475                 req, struct dcerpc_srvsvc_NetShareDel_state);
4476         NTSTATUS status;
4477         TALLOC_CTX *mem_ctx;
4478
4479         if (state->out_mem_ctx) {
4480                 mem_ctx = state->out_mem_ctx;
4481         } else {
4482                 mem_ctx = state;
4483         }
4484
4485         status = dcerpc_srvsvc_NetShareDel_r_recv(subreq, mem_ctx);
4486         TALLOC_FREE(subreq);
4487         if (!NT_STATUS_IS_OK(status)) {
4488                 tevent_req_nterror(req, status);
4489                 return;
4490         }
4491
4492         /* Copy out parameters */
4493
4494         /* Copy result */
4495         state->orig.out.result = state->tmp.out.result;
4496
4497         /* Reset temporary structure */
4498         ZERO_STRUCT(state->tmp);
4499
4500         tevent_req_done(req);
4501 }
4502
4503 NTSTATUS dcerpc_srvsvc_NetShareDel_recv(struct tevent_req *req,
4504                                         TALLOC_CTX *mem_ctx,
4505                                         WERROR *result)
4506 {
4507         struct dcerpc_srvsvc_NetShareDel_state *state = tevent_req_data(
4508                 req, struct dcerpc_srvsvc_NetShareDel_state);
4509         NTSTATUS status;
4510
4511         if (tevent_req_is_nterror(req, &status)) {
4512                 tevent_req_received(req);
4513                 return status;
4514         }
4515
4516         /* Steal possible out parameters to the callers context */
4517         talloc_steal(mem_ctx, state->out_mem_ctx);
4518
4519         /* Return result */
4520         *result = state->orig.out.result;
4521
4522         tevent_req_received(req);
4523         return NT_STATUS_OK;
4524 }
4525
4526 NTSTATUS dcerpc_srvsvc_NetShareDel(struct dcerpc_binding_handle *h,
4527                                    TALLOC_CTX *mem_ctx,
4528                                    const char *_server_unc /* [in] [unique,charset(UTF16)] */,
4529                                    const char *_share_name /* [in] [charset(UTF16)] */,
4530                                    uint32_t _reserved /* [in]  */,
4531                                    WERROR *result)
4532 {
4533         struct srvsvc_NetShareDel r;
4534         NTSTATUS status;
4535
4536         /* In parameters */
4537         r.in.server_unc = _server_unc;
4538         r.in.share_name = _share_name;
4539         r.in.reserved = _reserved;
4540
4541         status = dcerpc_srvsvc_NetShareDel_r(h, mem_ctx, &r);
4542         if (!NT_STATUS_IS_OK(status)) {
4543                 return status;
4544         }
4545
4546         /* Return variables */
4547
4548         /* Return result */
4549         *result = r.out.result;
4550
4551         return NT_STATUS_OK;
4552 }
4553
4554 struct dcerpc_srvsvc_NetShareDelSticky_r_state {
4555         TALLOC_CTX *out_mem_ctx;
4556 };
4557
4558 static void dcerpc_srvsvc_NetShareDelSticky_r_done(struct tevent_req *subreq);
4559
4560 struct tevent_req *dcerpc_srvsvc_NetShareDelSticky_r_send(TALLOC_CTX *mem_ctx,
4561         struct tevent_context *ev,
4562         struct dcerpc_binding_handle *h,
4563         struct srvsvc_NetShareDelSticky *r)
4564 {
4565         struct tevent_req *req;
4566         struct dcerpc_srvsvc_NetShareDelSticky_r_state *state;
4567         struct tevent_req *subreq;
4568
4569         req = tevent_req_create(mem_ctx, &state,
4570                                 struct dcerpc_srvsvc_NetShareDelSticky_r_state);
4571         if (req == NULL) {
4572                 return NULL;
4573         }
4574
4575         state->out_mem_ctx = NULL;
4576         subreq = dcerpc_binding_handle_call_send(state, ev, h,
4577                         NULL, &ndr_table_srvsvc,
4578                         NDR_SRVSVC_NETSHAREDELSTICKY, state, r);
4579         if (tevent_req_nomem(subreq, req)) {
4580                 return tevent_req_post(req, ev);
4581         }
4582         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetShareDelSticky_r_done, req);
4583
4584         return req;
4585 }
4586
4587 static void dcerpc_srvsvc_NetShareDelSticky_r_done(struct tevent_req *subreq)
4588 {
4589         struct tevent_req *req =
4590                 tevent_req_callback_data(subreq,
4591                 struct tevent_req);
4592         NTSTATUS status;
4593
4594         status = dcerpc_binding_handle_call_recv(subreq);
4595         if (!NT_STATUS_IS_OK(status)) {
4596                 tevent_req_nterror(req, status);
4597                 return;
4598         }
4599
4600         tevent_req_done(req);
4601 }
4602
4603 NTSTATUS dcerpc_srvsvc_NetShareDelSticky_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
4604 {
4605         struct dcerpc_srvsvc_NetShareDelSticky_r_state *state =
4606                 tevent_req_data(req,
4607                 struct dcerpc_srvsvc_NetShareDelSticky_r_state);
4608         NTSTATUS status;
4609
4610         if (tevent_req_is_nterror(req, &status)) {
4611                 tevent_req_received(req);
4612                 return status;
4613         }
4614
4615         talloc_steal(mem_ctx, state->out_mem_ctx);
4616
4617         tevent_req_received(req);
4618         return NT_STATUS_OK;
4619 }
4620
4621 NTSTATUS dcerpc_srvsvc_NetShareDelSticky_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetShareDelSticky *r)
4622 {
4623         NTSTATUS status;
4624
4625         status = dcerpc_binding_handle_call(h,
4626                         NULL, &ndr_table_srvsvc,
4627                         NDR_SRVSVC_NETSHAREDELSTICKY, mem_ctx, r);
4628
4629         return status;
4630 }
4631
4632 NTSTATUS dcerpc_srvsvc_NetShareDelSticky_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetShareDelSticky *r)
4633 {
4634         NTSTATUS status;
4635
4636         status = dcerpc_srvsvc_NetShareDelSticky_r(p->binding_handle, mem_ctx, r);
4637
4638         if (NT_STATUS_IS_RPC(status)) {
4639                 status = NT_STATUS_NET_WRITE_FAULT;
4640         }
4641
4642         return status;
4643 }
4644
4645 struct dcerpc_srvsvc_NetShareDelSticky_state {
4646         struct srvsvc_NetShareDelSticky orig;
4647         struct srvsvc_NetShareDelSticky tmp;
4648         TALLOC_CTX *out_mem_ctx;
4649 };
4650
4651 static void dcerpc_srvsvc_NetShareDelSticky_done(struct tevent_req *subreq);
4652
4653 struct tevent_req *dcerpc_srvsvc_NetShareDelSticky_send(TALLOC_CTX *mem_ctx,
4654                                                         struct tevent_context *ev,
4655                                                         struct dcerpc_binding_handle *h,
4656                                                         const char *_server_unc /* [in] [unique,charset(UTF16)] */,
4657                                                         const char *_share_name /* [in] [charset(UTF16)] */,
4658                                                         uint32_t _reserved /* [in]  */)
4659 {
4660         struct tevent_req *req;
4661         struct dcerpc_srvsvc_NetShareDelSticky_state *state;
4662         struct tevent_req *subreq;
4663
4664         req = tevent_req_create(mem_ctx, &state,
4665                                 struct dcerpc_srvsvc_NetShareDelSticky_state);
4666         if (req == NULL) {
4667                 return NULL;
4668         }
4669         state->out_mem_ctx = NULL;
4670
4671         /* In parameters */
4672         state->orig.in.server_unc = _server_unc;
4673         state->orig.in.share_name = _share_name;
4674         state->orig.in.reserved = _reserved;
4675
4676         /* Out parameters */
4677
4678         /* Result */
4679         ZERO_STRUCT(state->orig.out.result);
4680
4681         /* make a temporary copy, that we pass to the dispatch function */
4682         state->tmp = state->orig;
4683
4684         subreq = dcerpc_srvsvc_NetShareDelSticky_r_send(state, ev, h, &state->tmp);
4685         if (tevent_req_nomem(subreq, req)) {
4686                 return tevent_req_post(req, ev);
4687         }
4688         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetShareDelSticky_done, req);
4689         return req;
4690 }
4691
4692 static void dcerpc_srvsvc_NetShareDelSticky_done(struct tevent_req *subreq)
4693 {
4694         struct tevent_req *req = tevent_req_callback_data(
4695                 subreq, struct tevent_req);
4696         struct dcerpc_srvsvc_NetShareDelSticky_state *state = tevent_req_data(
4697                 req, struct dcerpc_srvsvc_NetShareDelSticky_state);
4698         NTSTATUS status;
4699         TALLOC_CTX *mem_ctx;
4700
4701         if (state->out_mem_ctx) {
4702                 mem_ctx = state->out_mem_ctx;
4703         } else {
4704                 mem_ctx = state;
4705         }
4706
4707         status = dcerpc_srvsvc_NetShareDelSticky_r_recv(subreq, mem_ctx);
4708         TALLOC_FREE(subreq);
4709         if (!NT_STATUS_IS_OK(status)) {
4710                 tevent_req_nterror(req, status);
4711                 return;
4712         }
4713
4714         /* Copy out parameters */
4715
4716         /* Copy result */
4717         state->orig.out.result = state->tmp.out.result;
4718
4719         /* Reset temporary structure */
4720         ZERO_STRUCT(state->tmp);
4721
4722         tevent_req_done(req);
4723 }
4724
4725 NTSTATUS dcerpc_srvsvc_NetShareDelSticky_recv(struct tevent_req *req,
4726                                               TALLOC_CTX *mem_ctx,
4727                                               WERROR *result)
4728 {
4729         struct dcerpc_srvsvc_NetShareDelSticky_state *state = tevent_req_data(
4730                 req, struct dcerpc_srvsvc_NetShareDelSticky_state);
4731         NTSTATUS status;
4732
4733         if (tevent_req_is_nterror(req, &status)) {
4734                 tevent_req_received(req);
4735                 return status;
4736         }
4737
4738         /* Steal possible out parameters to the callers context */
4739         talloc_steal(mem_ctx, state->out_mem_ctx);
4740
4741         /* Return result */
4742         *result = state->orig.out.result;
4743
4744         tevent_req_received(req);
4745         return NT_STATUS_OK;
4746 }
4747
4748 NTSTATUS dcerpc_srvsvc_NetShareDelSticky(struct dcerpc_binding_handle *h,
4749                                          TALLOC_CTX *mem_ctx,
4750                                          const char *_server_unc /* [in] [unique,charset(UTF16)] */,
4751                                          const char *_share_name /* [in] [charset(UTF16)] */,
4752                                          uint32_t _reserved /* [in]  */,
4753                                          WERROR *result)
4754 {
4755         struct srvsvc_NetShareDelSticky r;
4756         NTSTATUS status;
4757
4758         /* In parameters */
4759         r.in.server_unc = _server_unc;
4760         r.in.share_name = _share_name;
4761         r.in.reserved = _reserved;
4762
4763         status = dcerpc_srvsvc_NetShareDelSticky_r(h, mem_ctx, &r);
4764         if (!NT_STATUS_IS_OK(status)) {
4765                 return status;
4766         }
4767
4768         /* Return variables */
4769
4770         /* Return result */
4771         *result = r.out.result;
4772
4773         return NT_STATUS_OK;
4774 }
4775
4776 struct dcerpc_srvsvc_NetShareCheck_r_state {
4777         TALLOC_CTX *out_mem_ctx;
4778 };
4779
4780 static void dcerpc_srvsvc_NetShareCheck_r_done(struct tevent_req *subreq);
4781
4782 struct tevent_req *dcerpc_srvsvc_NetShareCheck_r_send(TALLOC_CTX *mem_ctx,
4783         struct tevent_context *ev,
4784         struct dcerpc_binding_handle *h,
4785         struct srvsvc_NetShareCheck *r)
4786 {
4787         struct tevent_req *req;
4788         struct dcerpc_srvsvc_NetShareCheck_r_state *state;
4789         struct tevent_req *subreq;
4790
4791         req = tevent_req_create(mem_ctx, &state,
4792                                 struct dcerpc_srvsvc_NetShareCheck_r_state);
4793         if (req == NULL) {
4794                 return NULL;
4795         }
4796
4797         state->out_mem_ctx = talloc_new(state);
4798         if (tevent_req_nomem(state->out_mem_ctx, req)) {
4799                 return tevent_req_post(req, ev);
4800         }
4801
4802         subreq = dcerpc_binding_handle_call_send(state, ev, h,
4803                         NULL, &ndr_table_srvsvc,
4804                         NDR_SRVSVC_NETSHARECHECK, state->out_mem_ctx, r);
4805         if (tevent_req_nomem(subreq, req)) {
4806                 return tevent_req_post(req, ev);
4807         }
4808         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetShareCheck_r_done, req);
4809
4810         return req;
4811 }
4812
4813 static void dcerpc_srvsvc_NetShareCheck_r_done(struct tevent_req *subreq)
4814 {
4815         struct tevent_req *req =
4816                 tevent_req_callback_data(subreq,
4817                 struct tevent_req);
4818         NTSTATUS status;
4819
4820         status = dcerpc_binding_handle_call_recv(subreq);
4821         if (!NT_STATUS_IS_OK(status)) {
4822                 tevent_req_nterror(req, status);
4823                 return;
4824         }
4825
4826         tevent_req_done(req);
4827 }
4828
4829 NTSTATUS dcerpc_srvsvc_NetShareCheck_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
4830 {
4831         struct dcerpc_srvsvc_NetShareCheck_r_state *state =
4832                 tevent_req_data(req,
4833                 struct dcerpc_srvsvc_NetShareCheck_r_state);
4834         NTSTATUS status;
4835
4836         if (tevent_req_is_nterror(req, &status)) {
4837                 tevent_req_received(req);
4838                 return status;
4839         }
4840
4841         talloc_steal(mem_ctx, state->out_mem_ctx);
4842
4843         tevent_req_received(req);
4844         return NT_STATUS_OK;
4845 }
4846
4847 NTSTATUS dcerpc_srvsvc_NetShareCheck_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetShareCheck *r)
4848 {
4849         NTSTATUS status;
4850
4851         status = dcerpc_binding_handle_call(h,
4852                         NULL, &ndr_table_srvsvc,
4853                         NDR_SRVSVC_NETSHARECHECK, mem_ctx, r);
4854
4855         return status;
4856 }
4857
4858 NTSTATUS dcerpc_srvsvc_NetShareCheck_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetShareCheck *r)
4859 {
4860         NTSTATUS status;
4861
4862         status = dcerpc_srvsvc_NetShareCheck_r(p->binding_handle, mem_ctx, r);
4863
4864         if (NT_STATUS_IS_RPC(status)) {
4865                 status = NT_STATUS_NET_WRITE_FAULT;
4866         }
4867
4868         return status;
4869 }
4870
4871 struct dcerpc_srvsvc_NetShareCheck_state {
4872         struct srvsvc_NetShareCheck orig;
4873         struct srvsvc_NetShareCheck tmp;
4874         TALLOC_CTX *out_mem_ctx;
4875 };
4876
4877 static void dcerpc_srvsvc_NetShareCheck_done(struct tevent_req *subreq);
4878
4879 struct tevent_req *dcerpc_srvsvc_NetShareCheck_send(TALLOC_CTX *mem_ctx,
4880                                                     struct tevent_context *ev,
4881                                                     struct dcerpc_binding_handle *h,
4882                                                     const char *_server_unc /* [in] [unique,charset(UTF16)] */,
4883                                                     const char *_device_name /* [in] [charset(UTF16)] */,
4884                                                     enum srvsvc_ShareType *_type /* [out] [ref] */)
4885 {
4886         struct tevent_req *req;
4887         struct dcerpc_srvsvc_NetShareCheck_state *state;
4888         struct tevent_req *subreq;
4889
4890         req = tevent_req_create(mem_ctx, &state,
4891                                 struct dcerpc_srvsvc_NetShareCheck_state);
4892         if (req == NULL) {
4893                 return NULL;
4894         }
4895         state->out_mem_ctx = NULL;
4896
4897         /* In parameters */
4898         state->orig.in.server_unc = _server_unc;
4899         state->orig.in.device_name = _device_name;
4900
4901         /* Out parameters */
4902         state->orig.out.type = _type;
4903
4904         /* Result */
4905         ZERO_STRUCT(state->orig.out.result);
4906
4907         state->out_mem_ctx = talloc_named_const(state, 0,
4908                              "dcerpc_srvsvc_NetShareCheck_out_memory");
4909         if (tevent_req_nomem(state->out_mem_ctx, req)) {
4910                 return tevent_req_post(req, ev);
4911         }
4912
4913         /* make a temporary copy, that we pass to the dispatch function */
4914         state->tmp = state->orig;
4915
4916         subreq = dcerpc_srvsvc_NetShareCheck_r_send(state, ev, h, &state->tmp);
4917         if (tevent_req_nomem(subreq, req)) {
4918                 return tevent_req_post(req, ev);
4919         }
4920         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetShareCheck_done, req);
4921         return req;
4922 }
4923
4924 static void dcerpc_srvsvc_NetShareCheck_done(struct tevent_req *subreq)
4925 {
4926         struct tevent_req *req = tevent_req_callback_data(
4927                 subreq, struct tevent_req);
4928         struct dcerpc_srvsvc_NetShareCheck_state *state = tevent_req_data(
4929                 req, struct dcerpc_srvsvc_NetShareCheck_state);
4930         NTSTATUS status;
4931         TALLOC_CTX *mem_ctx;
4932
4933         if (state->out_mem_ctx) {
4934                 mem_ctx = state->out_mem_ctx;
4935         } else {
4936                 mem_ctx = state;
4937         }
4938
4939         status = dcerpc_srvsvc_NetShareCheck_r_recv(subreq, mem_ctx);
4940         TALLOC_FREE(subreq);
4941         if (!NT_STATUS_IS_OK(status)) {
4942                 tevent_req_nterror(req, status);
4943                 return;
4944         }
4945
4946         /* Copy out parameters */
4947         *state->orig.out.type = *state->tmp.out.type;
4948
4949         /* Copy result */
4950         state->orig.out.result = state->tmp.out.result;
4951
4952         /* Reset temporary structure */
4953         ZERO_STRUCT(state->tmp);
4954
4955         tevent_req_done(req);
4956 }
4957
4958 NTSTATUS dcerpc_srvsvc_NetShareCheck_recv(struct tevent_req *req,
4959                                           TALLOC_CTX *mem_ctx,
4960                                           WERROR *result)
4961 {
4962         struct dcerpc_srvsvc_NetShareCheck_state *state = tevent_req_data(
4963                 req, struct dcerpc_srvsvc_NetShareCheck_state);
4964         NTSTATUS status;
4965
4966         if (tevent_req_is_nterror(req, &status)) {
4967                 tevent_req_received(req);
4968                 return status;
4969         }
4970
4971         /* Steal possible out parameters to the callers context */
4972         talloc_steal(mem_ctx, state->out_mem_ctx);
4973
4974         /* Return result */
4975         *result = state->orig.out.result;
4976
4977         tevent_req_received(req);
4978         return NT_STATUS_OK;
4979 }
4980
4981 NTSTATUS dcerpc_srvsvc_NetShareCheck(struct dcerpc_binding_handle *h,
4982                                      TALLOC_CTX *mem_ctx,
4983                                      const char *_server_unc /* [in] [unique,charset(UTF16)] */,
4984                                      const char *_device_name /* [in] [charset(UTF16)] */,
4985                                      enum srvsvc_ShareType *_type /* [out] [ref] */,
4986                                      WERROR *result)
4987 {
4988         struct srvsvc_NetShareCheck r;
4989         NTSTATUS status;
4990
4991         /* In parameters */
4992         r.in.server_unc = _server_unc;
4993         r.in.device_name = _device_name;
4994
4995         status = dcerpc_srvsvc_NetShareCheck_r(h, mem_ctx, &r);
4996         if (!NT_STATUS_IS_OK(status)) {
4997                 return status;
4998         }
4999
5000         /* Return variables */
5001         *_type = *r.out.type;
5002
5003         /* Return result */
5004         *result = r.out.result;
5005
5006         return NT_STATUS_OK;
5007 }
5008
5009 struct dcerpc_srvsvc_NetSrvGetInfo_r_state {
5010         TALLOC_CTX *out_mem_ctx;
5011 };
5012
5013 static void dcerpc_srvsvc_NetSrvGetInfo_r_done(struct tevent_req *subreq);
5014
5015 struct tevent_req *dcerpc_srvsvc_NetSrvGetInfo_r_send(TALLOC_CTX *mem_ctx,
5016         struct tevent_context *ev,
5017         struct dcerpc_binding_handle *h,
5018         struct srvsvc_NetSrvGetInfo *r)
5019 {
5020         struct tevent_req *req;
5021         struct dcerpc_srvsvc_NetSrvGetInfo_r_state *state;
5022         struct tevent_req *subreq;
5023
5024         req = tevent_req_create(mem_ctx, &state,
5025                                 struct dcerpc_srvsvc_NetSrvGetInfo_r_state);
5026         if (req == NULL) {
5027                 return NULL;
5028         }
5029
5030         state->out_mem_ctx = talloc_new(state);
5031         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5032                 return tevent_req_post(req, ev);
5033         }
5034
5035         subreq = dcerpc_binding_handle_call_send(state, ev, h,
5036                         NULL, &ndr_table_srvsvc,
5037                         NDR_SRVSVC_NETSRVGETINFO, state->out_mem_ctx, r);
5038         if (tevent_req_nomem(subreq, req)) {
5039                 return tevent_req_post(req, ev);
5040         }
5041         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetSrvGetInfo_r_done, req);
5042
5043         return req;
5044 }
5045
5046 static void dcerpc_srvsvc_NetSrvGetInfo_r_done(struct tevent_req *subreq)
5047 {
5048         struct tevent_req *req =
5049                 tevent_req_callback_data(subreq,
5050                 struct tevent_req);
5051         NTSTATUS status;
5052
5053         status = dcerpc_binding_handle_call_recv(subreq);
5054         if (!NT_STATUS_IS_OK(status)) {
5055                 tevent_req_nterror(req, status);
5056                 return;
5057         }
5058
5059         tevent_req_done(req);
5060 }
5061
5062 NTSTATUS dcerpc_srvsvc_NetSrvGetInfo_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
5063 {
5064         struct dcerpc_srvsvc_NetSrvGetInfo_r_state *state =
5065                 tevent_req_data(req,
5066                 struct dcerpc_srvsvc_NetSrvGetInfo_r_state);
5067         NTSTATUS status;
5068
5069         if (tevent_req_is_nterror(req, &status)) {
5070                 tevent_req_received(req);
5071                 return status;
5072         }
5073
5074         talloc_steal(mem_ctx, state->out_mem_ctx);
5075
5076         tevent_req_received(req);
5077         return NT_STATUS_OK;
5078 }
5079
5080 NTSTATUS dcerpc_srvsvc_NetSrvGetInfo_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetSrvGetInfo *r)
5081 {
5082         NTSTATUS status;
5083
5084         status = dcerpc_binding_handle_call(h,
5085                         NULL, &ndr_table_srvsvc,
5086                         NDR_SRVSVC_NETSRVGETINFO, mem_ctx, r);
5087
5088         return status;
5089 }
5090
5091 NTSTATUS dcerpc_srvsvc_NetSrvGetInfo_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetSrvGetInfo *r)
5092 {
5093         NTSTATUS status;
5094
5095         status = dcerpc_srvsvc_NetSrvGetInfo_r(p->binding_handle, mem_ctx, r);
5096
5097         if (NT_STATUS_IS_RPC(status)) {
5098                 status = NT_STATUS_NET_WRITE_FAULT;
5099         }
5100
5101         return status;
5102 }
5103
5104 struct dcerpc_srvsvc_NetSrvGetInfo_state {
5105         struct srvsvc_NetSrvGetInfo orig;
5106         struct srvsvc_NetSrvGetInfo tmp;
5107         TALLOC_CTX *out_mem_ctx;
5108 };
5109
5110 static void dcerpc_srvsvc_NetSrvGetInfo_done(struct tevent_req *subreq);
5111
5112 struct tevent_req *dcerpc_srvsvc_NetSrvGetInfo_send(TALLOC_CTX *mem_ctx,
5113                                                     struct tevent_context *ev,
5114                                                     struct dcerpc_binding_handle *h,
5115                                                     const char *_server_unc /* [in] [unique,charset(UTF16)] */,
5116                                                     uint32_t _level /* [in]  */,
5117                                                     union srvsvc_NetSrvInfo *_info /* [out] [ref,switch_is(level)] */)
5118 {
5119         struct tevent_req *req;
5120         struct dcerpc_srvsvc_NetSrvGetInfo_state *state;
5121         struct tevent_req *subreq;
5122
5123         req = tevent_req_create(mem_ctx, &state,
5124                                 struct dcerpc_srvsvc_NetSrvGetInfo_state);
5125         if (req == NULL) {
5126                 return NULL;
5127         }
5128         state->out_mem_ctx = NULL;
5129
5130         /* In parameters */
5131         state->orig.in.server_unc = _server_unc;
5132         state->orig.in.level = _level;
5133
5134         /* Out parameters */
5135         state->orig.out.info = _info;
5136
5137         /* Result */
5138         ZERO_STRUCT(state->orig.out.result);
5139
5140         state->out_mem_ctx = talloc_named_const(state, 0,
5141                              "dcerpc_srvsvc_NetSrvGetInfo_out_memory");
5142         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5143                 return tevent_req_post(req, ev);
5144         }
5145
5146         /* make a temporary copy, that we pass to the dispatch function */
5147         state->tmp = state->orig;
5148
5149         subreq = dcerpc_srvsvc_NetSrvGetInfo_r_send(state, ev, h, &state->tmp);
5150         if (tevent_req_nomem(subreq, req)) {
5151                 return tevent_req_post(req, ev);
5152         }
5153         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetSrvGetInfo_done, req);
5154         return req;
5155 }
5156
5157 static void dcerpc_srvsvc_NetSrvGetInfo_done(struct tevent_req *subreq)
5158 {
5159         struct tevent_req *req = tevent_req_callback_data(
5160                 subreq, struct tevent_req);
5161         struct dcerpc_srvsvc_NetSrvGetInfo_state *state = tevent_req_data(
5162                 req, struct dcerpc_srvsvc_NetSrvGetInfo_state);
5163         NTSTATUS status;
5164         TALLOC_CTX *mem_ctx;
5165
5166         if (state->out_mem_ctx) {
5167                 mem_ctx = state->out_mem_ctx;
5168         } else {
5169                 mem_ctx = state;
5170         }
5171
5172         status = dcerpc_srvsvc_NetSrvGetInfo_r_recv(subreq, mem_ctx);
5173         TALLOC_FREE(subreq);
5174         if (!NT_STATUS_IS_OK(status)) {
5175                 tevent_req_nterror(req, status);
5176                 return;
5177         }
5178
5179         /* Copy out parameters */
5180         *state->orig.out.info = *state->tmp.out.info;
5181
5182         /* Copy result */
5183         state->orig.out.result = state->tmp.out.result;
5184
5185         /* Reset temporary structure */
5186         ZERO_STRUCT(state->tmp);
5187
5188         tevent_req_done(req);
5189 }
5190
5191 NTSTATUS dcerpc_srvsvc_NetSrvGetInfo_recv(struct tevent_req *req,
5192                                           TALLOC_CTX *mem_ctx,
5193                                           WERROR *result)
5194 {
5195         struct dcerpc_srvsvc_NetSrvGetInfo_state *state = tevent_req_data(
5196                 req, struct dcerpc_srvsvc_NetSrvGetInfo_state);
5197         NTSTATUS status;
5198
5199         if (tevent_req_is_nterror(req, &status)) {
5200                 tevent_req_received(req);
5201                 return status;
5202         }
5203
5204         /* Steal possible out parameters to the callers context */
5205         talloc_steal(mem_ctx, state->out_mem_ctx);
5206
5207         /* Return result */
5208         *result = state->orig.out.result;
5209
5210         tevent_req_received(req);
5211         return NT_STATUS_OK;
5212 }
5213
5214 NTSTATUS dcerpc_srvsvc_NetSrvGetInfo(struct dcerpc_binding_handle *h,
5215                                      TALLOC_CTX *mem_ctx,
5216                                      const char *_server_unc /* [in] [unique,charset(UTF16)] */,
5217                                      uint32_t _level /* [in]  */,
5218                                      union srvsvc_NetSrvInfo *_info /* [out] [ref,switch_is(level)] */,
5219                                      WERROR *result)
5220 {
5221         struct srvsvc_NetSrvGetInfo r;
5222         NTSTATUS status;
5223
5224         /* In parameters */
5225         r.in.server_unc = _server_unc;
5226         r.in.level = _level;
5227
5228         status = dcerpc_srvsvc_NetSrvGetInfo_r(h, mem_ctx, &r);
5229         if (!NT_STATUS_IS_OK(status)) {
5230                 return status;
5231         }
5232
5233         /* Return variables */
5234         *_info = *r.out.info;
5235
5236         /* Return result */
5237         *result = r.out.result;
5238
5239         return NT_STATUS_OK;
5240 }
5241
5242 struct dcerpc_srvsvc_NetSrvSetInfo_r_state {
5243         TALLOC_CTX *out_mem_ctx;
5244 };
5245
5246 static void dcerpc_srvsvc_NetSrvSetInfo_r_done(struct tevent_req *subreq);
5247
5248 struct tevent_req *dcerpc_srvsvc_NetSrvSetInfo_r_send(TALLOC_CTX *mem_ctx,
5249         struct tevent_context *ev,
5250         struct dcerpc_binding_handle *h,
5251         struct srvsvc_NetSrvSetInfo *r)
5252 {
5253         struct tevent_req *req;
5254         struct dcerpc_srvsvc_NetSrvSetInfo_r_state *state;
5255         struct tevent_req *subreq;
5256
5257         req = tevent_req_create(mem_ctx, &state,
5258                                 struct dcerpc_srvsvc_NetSrvSetInfo_r_state);
5259         if (req == NULL) {
5260                 return NULL;
5261         }
5262
5263         state->out_mem_ctx = talloc_new(state);
5264         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5265                 return tevent_req_post(req, ev);
5266         }
5267
5268         subreq = dcerpc_binding_handle_call_send(state, ev, h,
5269                         NULL, &ndr_table_srvsvc,
5270                         NDR_SRVSVC_NETSRVSETINFO, state->out_mem_ctx, r);
5271         if (tevent_req_nomem(subreq, req)) {
5272                 return tevent_req_post(req, ev);
5273         }
5274         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetSrvSetInfo_r_done, req);
5275
5276         return req;
5277 }
5278
5279 static void dcerpc_srvsvc_NetSrvSetInfo_r_done(struct tevent_req *subreq)
5280 {
5281         struct tevent_req *req =
5282                 tevent_req_callback_data(subreq,
5283                 struct tevent_req);
5284         NTSTATUS status;
5285
5286         status = dcerpc_binding_handle_call_recv(subreq);
5287         if (!NT_STATUS_IS_OK(status)) {
5288                 tevent_req_nterror(req, status);
5289                 return;
5290         }
5291
5292         tevent_req_done(req);
5293 }
5294
5295 NTSTATUS dcerpc_srvsvc_NetSrvSetInfo_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
5296 {
5297         struct dcerpc_srvsvc_NetSrvSetInfo_r_state *state =
5298                 tevent_req_data(req,
5299                 struct dcerpc_srvsvc_NetSrvSetInfo_r_state);
5300         NTSTATUS status;
5301
5302         if (tevent_req_is_nterror(req, &status)) {
5303                 tevent_req_received(req);
5304                 return status;
5305         }
5306
5307         talloc_steal(mem_ctx, state->out_mem_ctx);
5308
5309         tevent_req_received(req);
5310         return NT_STATUS_OK;
5311 }
5312
5313 NTSTATUS dcerpc_srvsvc_NetSrvSetInfo_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetSrvSetInfo *r)
5314 {
5315         NTSTATUS status;
5316
5317         status = dcerpc_binding_handle_call(h,
5318                         NULL, &ndr_table_srvsvc,
5319                         NDR_SRVSVC_NETSRVSETINFO, mem_ctx, r);
5320
5321         return status;
5322 }
5323
5324 NTSTATUS dcerpc_srvsvc_NetSrvSetInfo_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetSrvSetInfo *r)
5325 {
5326         NTSTATUS status;
5327
5328         status = dcerpc_srvsvc_NetSrvSetInfo_r(p->binding_handle, mem_ctx, r);
5329
5330         if (NT_STATUS_IS_RPC(status)) {
5331                 status = NT_STATUS_NET_WRITE_FAULT;
5332         }
5333
5334         return status;
5335 }
5336
5337 struct dcerpc_srvsvc_NetSrvSetInfo_state {
5338         struct srvsvc_NetSrvSetInfo orig;
5339         struct srvsvc_NetSrvSetInfo tmp;
5340         TALLOC_CTX *out_mem_ctx;
5341 };
5342
5343 static void dcerpc_srvsvc_NetSrvSetInfo_done(struct tevent_req *subreq);
5344
5345 struct tevent_req *dcerpc_srvsvc_NetSrvSetInfo_send(TALLOC_CTX *mem_ctx,
5346                                                     struct tevent_context *ev,
5347                                                     struct dcerpc_binding_handle *h,
5348                                                     const char *_server_unc /* [in] [unique,charset(UTF16)] */,
5349                                                     uint32_t _level /* [in]  */,
5350                                                     union srvsvc_NetSrvInfo *_info /* [in] [ref,switch_is(level)] */,
5351                                                     uint32_t *_parm_error /* [in,out] [unique] */)
5352 {
5353         struct tevent_req *req;
5354         struct dcerpc_srvsvc_NetSrvSetInfo_state *state;
5355         struct tevent_req *subreq;
5356
5357         req = tevent_req_create(mem_ctx, &state,
5358                                 struct dcerpc_srvsvc_NetSrvSetInfo_state);
5359         if (req == NULL) {
5360                 return NULL;
5361         }
5362         state->out_mem_ctx = NULL;
5363
5364         /* In parameters */
5365         state->orig.in.server_unc = _server_unc;
5366         state->orig.in.level = _level;
5367         state->orig.in.info = _info;
5368         state->orig.in.parm_error = _parm_error;
5369
5370         /* Out parameters */
5371         state->orig.out.parm_error = _parm_error;
5372
5373         /* Result */
5374         ZERO_STRUCT(state->orig.out.result);
5375
5376         state->out_mem_ctx = talloc_named_const(state, 0,
5377                              "dcerpc_srvsvc_NetSrvSetInfo_out_memory");
5378         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5379                 return tevent_req_post(req, ev);
5380         }
5381
5382         /* make a temporary copy, that we pass to the dispatch function */
5383         state->tmp = state->orig;
5384
5385         subreq = dcerpc_srvsvc_NetSrvSetInfo_r_send(state, ev, h, &state->tmp);
5386         if (tevent_req_nomem(subreq, req)) {
5387                 return tevent_req_post(req, ev);
5388         }
5389         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetSrvSetInfo_done, req);
5390         return req;
5391 }
5392
5393 static void dcerpc_srvsvc_NetSrvSetInfo_done(struct tevent_req *subreq)
5394 {
5395         struct tevent_req *req = tevent_req_callback_data(
5396                 subreq, struct tevent_req);
5397         struct dcerpc_srvsvc_NetSrvSetInfo_state *state = tevent_req_data(
5398                 req, struct dcerpc_srvsvc_NetSrvSetInfo_state);
5399         NTSTATUS status;
5400         TALLOC_CTX *mem_ctx;
5401
5402         if (state->out_mem_ctx) {
5403                 mem_ctx = state->out_mem_ctx;
5404         } else {
5405                 mem_ctx = state;
5406         }
5407
5408         status = dcerpc_srvsvc_NetSrvSetInfo_r_recv(subreq, mem_ctx);
5409         TALLOC_FREE(subreq);
5410         if (!NT_STATUS_IS_OK(status)) {
5411                 tevent_req_nterror(req, status);
5412                 return;
5413         }
5414
5415         /* Copy out parameters */
5416         if (state->orig.out.parm_error && state->tmp.out.parm_error) {
5417                 *state->orig.out.parm_error = *state->tmp.out.parm_error;
5418         }
5419
5420         /* Copy result */
5421         state->orig.out.result = state->tmp.out.result;
5422
5423         /* Reset temporary structure */
5424         ZERO_STRUCT(state->tmp);
5425
5426         tevent_req_done(req);
5427 }
5428
5429 NTSTATUS dcerpc_srvsvc_NetSrvSetInfo_recv(struct tevent_req *req,
5430                                           TALLOC_CTX *mem_ctx,
5431                                           WERROR *result)
5432 {
5433         struct dcerpc_srvsvc_NetSrvSetInfo_state *state = tevent_req_data(
5434                 req, struct dcerpc_srvsvc_NetSrvSetInfo_state);
5435         NTSTATUS status;
5436
5437         if (tevent_req_is_nterror(req, &status)) {
5438                 tevent_req_received(req);
5439                 return status;
5440         }
5441
5442         /* Steal possible out parameters to the callers context */
5443         talloc_steal(mem_ctx, state->out_mem_ctx);
5444
5445         /* Return result */
5446         *result = state->orig.out.result;
5447
5448         tevent_req_received(req);
5449         return NT_STATUS_OK;
5450 }
5451
5452 NTSTATUS dcerpc_srvsvc_NetSrvSetInfo(struct dcerpc_binding_handle *h,
5453                                      TALLOC_CTX *mem_ctx,
5454                                      const char *_server_unc /* [in] [unique,charset(UTF16)] */,
5455                                      uint32_t _level /* [in]  */,
5456                                      union srvsvc_NetSrvInfo *_info /* [in] [ref,switch_is(level)] */,
5457                                      uint32_t *_parm_error /* [in,out] [unique] */,
5458                                      WERROR *result)
5459 {
5460         struct srvsvc_NetSrvSetInfo r;
5461         NTSTATUS status;
5462
5463         /* In parameters */
5464         r.in.server_unc = _server_unc;
5465         r.in.level = _level;
5466         r.in.info = _info;
5467         r.in.parm_error = _parm_error;
5468
5469         status = dcerpc_srvsvc_NetSrvSetInfo_r(h, mem_ctx, &r);
5470         if (!NT_STATUS_IS_OK(status)) {
5471                 return status;
5472         }
5473
5474         /* Return variables */
5475         if (_parm_error && r.out.parm_error) {
5476                 *_parm_error = *r.out.parm_error;
5477         }
5478
5479         /* Return result */
5480         *result = r.out.result;
5481
5482         return NT_STATUS_OK;
5483 }
5484
5485 struct dcerpc_srvsvc_NetDiskEnum_r_state {
5486         TALLOC_CTX *out_mem_ctx;
5487 };
5488
5489 static void dcerpc_srvsvc_NetDiskEnum_r_done(struct tevent_req *subreq);
5490
5491 struct tevent_req *dcerpc_srvsvc_NetDiskEnum_r_send(TALLOC_CTX *mem_ctx,
5492         struct tevent_context *ev,
5493         struct dcerpc_binding_handle *h,
5494         struct srvsvc_NetDiskEnum *r)
5495 {
5496         struct tevent_req *req;
5497         struct dcerpc_srvsvc_NetDiskEnum_r_state *state;
5498         struct tevent_req *subreq;
5499
5500         req = tevent_req_create(mem_ctx, &state,
5501                                 struct dcerpc_srvsvc_NetDiskEnum_r_state);
5502         if (req == NULL) {
5503                 return NULL;
5504         }
5505
5506         state->out_mem_ctx = talloc_new(state);
5507         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5508                 return tevent_req_post(req, ev);
5509         }
5510
5511         subreq = dcerpc_binding_handle_call_send(state, ev, h,
5512                         NULL, &ndr_table_srvsvc,
5513                         NDR_SRVSVC_NETDISKENUM, state->out_mem_ctx, r);
5514         if (tevent_req_nomem(subreq, req)) {
5515                 return tevent_req_post(req, ev);
5516         }
5517         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetDiskEnum_r_done, req);
5518
5519         return req;
5520 }
5521
5522 static void dcerpc_srvsvc_NetDiskEnum_r_done(struct tevent_req *subreq)
5523 {
5524         struct tevent_req *req =
5525                 tevent_req_callback_data(subreq,
5526                 struct tevent_req);
5527         NTSTATUS status;
5528
5529         status = dcerpc_binding_handle_call_recv(subreq);
5530         if (!NT_STATUS_IS_OK(status)) {
5531                 tevent_req_nterror(req, status);
5532                 return;
5533         }
5534
5535         tevent_req_done(req);
5536 }
5537
5538 NTSTATUS dcerpc_srvsvc_NetDiskEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
5539 {
5540         struct dcerpc_srvsvc_NetDiskEnum_r_state *state =
5541                 tevent_req_data(req,
5542                 struct dcerpc_srvsvc_NetDiskEnum_r_state);
5543         NTSTATUS status;
5544
5545         if (tevent_req_is_nterror(req, &status)) {
5546                 tevent_req_received(req);
5547                 return status;
5548         }
5549
5550         talloc_steal(mem_ctx, state->out_mem_ctx);
5551
5552         tevent_req_received(req);
5553         return NT_STATUS_OK;
5554 }
5555
5556 NTSTATUS dcerpc_srvsvc_NetDiskEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetDiskEnum *r)
5557 {
5558         NTSTATUS status;
5559
5560         status = dcerpc_binding_handle_call(h,
5561                         NULL, &ndr_table_srvsvc,
5562                         NDR_SRVSVC_NETDISKENUM, mem_ctx, r);
5563
5564         return status;
5565 }
5566
5567 NTSTATUS dcerpc_srvsvc_NetDiskEnum_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetDiskEnum *r)
5568 {
5569         NTSTATUS status;
5570
5571         status = dcerpc_srvsvc_NetDiskEnum_r(p->binding_handle, mem_ctx, r);
5572
5573         if (NT_STATUS_IS_RPC(status)) {
5574                 status = NT_STATUS_NET_WRITE_FAULT;
5575         }
5576
5577         return status;
5578 }
5579
5580 struct dcerpc_srvsvc_NetDiskEnum_state {
5581         struct srvsvc_NetDiskEnum orig;
5582         struct srvsvc_NetDiskEnum tmp;
5583         TALLOC_CTX *out_mem_ctx;
5584 };
5585
5586 static void dcerpc_srvsvc_NetDiskEnum_done(struct tevent_req *subreq);
5587
5588 struct tevent_req *dcerpc_srvsvc_NetDiskEnum_send(TALLOC_CTX *mem_ctx,
5589                                                   struct tevent_context *ev,
5590                                                   struct dcerpc_binding_handle *h,
5591                                                   const char *_server_unc /* [in] [unique,charset(UTF16)] */,
5592                                                   uint32_t _level /* [in]  */,
5593                                                   struct srvsvc_NetDiskInfo *_info /* [in,out] [ref] */,
5594                                                   uint32_t _maxlen /* [in]  */,
5595                                                   uint32_t *_totalentries /* [out] [ref] */,
5596                                                   uint32_t *_resume_handle /* [in,out] [unique] */)
5597 {
5598         struct tevent_req *req;
5599         struct dcerpc_srvsvc_NetDiskEnum_state *state;
5600         struct tevent_req *subreq;
5601
5602         req = tevent_req_create(mem_ctx, &state,
5603                                 struct dcerpc_srvsvc_NetDiskEnum_state);
5604         if (req == NULL) {
5605                 return NULL;
5606         }
5607         state->out_mem_ctx = NULL;
5608
5609         /* In parameters */
5610         state->orig.in.server_unc = _server_unc;
5611         state->orig.in.level = _level;
5612         state->orig.in.info = _info;
5613         state->orig.in.maxlen = _maxlen;
5614         state->orig.in.resume_handle = _resume_handle;
5615
5616         /* Out parameters */
5617         state->orig.out.info = _info;
5618         state->orig.out.totalentries = _totalentries;
5619         state->orig.out.resume_handle = _resume_handle;
5620
5621         /* Result */
5622         ZERO_STRUCT(state->orig.out.result);
5623
5624         state->out_mem_ctx = talloc_named_const(state, 0,
5625                              "dcerpc_srvsvc_NetDiskEnum_out_memory");
5626         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5627                 return tevent_req_post(req, ev);
5628         }
5629
5630         /* make a temporary copy, that we pass to the dispatch function */
5631         state->tmp = state->orig;
5632
5633         subreq = dcerpc_srvsvc_NetDiskEnum_r_send(state, ev, h, &state->tmp);
5634         if (tevent_req_nomem(subreq, req)) {
5635                 return tevent_req_post(req, ev);
5636         }
5637         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetDiskEnum_done, req);
5638         return req;
5639 }
5640
5641 static void dcerpc_srvsvc_NetDiskEnum_done(struct tevent_req *subreq)
5642 {
5643         struct tevent_req *req = tevent_req_callback_data(
5644                 subreq, struct tevent_req);
5645         struct dcerpc_srvsvc_NetDiskEnum_state *state = tevent_req_data(
5646                 req, struct dcerpc_srvsvc_NetDiskEnum_state);
5647         NTSTATUS status;
5648         TALLOC_CTX *mem_ctx;
5649
5650         if (state->out_mem_ctx) {
5651                 mem_ctx = state->out_mem_ctx;
5652         } else {
5653                 mem_ctx = state;
5654         }
5655
5656         status = dcerpc_srvsvc_NetDiskEnum_r_recv(subreq, mem_ctx);
5657         TALLOC_FREE(subreq);
5658         if (!NT_STATUS_IS_OK(status)) {
5659                 tevent_req_nterror(req, status);
5660                 return;
5661         }
5662
5663         /* Copy out parameters */
5664         *state->orig.out.info = *state->tmp.out.info;
5665         *state->orig.out.totalentries = *state->tmp.out.totalentries;
5666         if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
5667                 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
5668         }
5669
5670         /* Copy result */
5671         state->orig.out.result = state->tmp.out.result;
5672
5673         /* Reset temporary structure */
5674         ZERO_STRUCT(state->tmp);
5675
5676         tevent_req_done(req);
5677 }
5678
5679 NTSTATUS dcerpc_srvsvc_NetDiskEnum_recv(struct tevent_req *req,
5680                                         TALLOC_CTX *mem_ctx,
5681                                         WERROR *result)
5682 {
5683         struct dcerpc_srvsvc_NetDiskEnum_state *state = tevent_req_data(
5684                 req, struct dcerpc_srvsvc_NetDiskEnum_state);
5685         NTSTATUS status;
5686
5687         if (tevent_req_is_nterror(req, &status)) {
5688                 tevent_req_received(req);
5689                 return status;
5690         }
5691
5692         /* Steal possible out parameters to the callers context */
5693         talloc_steal(mem_ctx, state->out_mem_ctx);
5694
5695         /* Return result */
5696         *result = state->orig.out.result;
5697
5698         tevent_req_received(req);
5699         return NT_STATUS_OK;
5700 }
5701
5702 NTSTATUS dcerpc_srvsvc_NetDiskEnum(struct dcerpc_binding_handle *h,
5703                                    TALLOC_CTX *mem_ctx,
5704                                    const char *_server_unc /* [in] [unique,charset(UTF16)] */,
5705                                    uint32_t _level /* [in]  */,
5706                                    struct srvsvc_NetDiskInfo *_info /* [in,out] [ref] */,
5707                                    uint32_t _maxlen /* [in]  */,
5708                                    uint32_t *_totalentries /* [out] [ref] */,
5709                                    uint32_t *_resume_handle /* [in,out] [unique] */,
5710                                    WERROR *result)
5711 {
5712         struct srvsvc_NetDiskEnum r;
5713         NTSTATUS status;
5714
5715         /* In parameters */
5716         r.in.server_unc = _server_unc;
5717         r.in.level = _level;
5718         r.in.info = _info;
5719         r.in.maxlen = _maxlen;
5720         r.in.resume_handle = _resume_handle;
5721
5722         status = dcerpc_srvsvc_NetDiskEnum_r(h, mem_ctx, &r);
5723         if (!NT_STATUS_IS_OK(status)) {
5724                 return status;
5725         }
5726
5727         /* Return variables */
5728         *_info = *r.out.info;
5729         *_totalentries = *r.out.totalentries;
5730         if (_resume_handle && r.out.resume_handle) {
5731                 *_resume_handle = *r.out.resume_handle;
5732         }
5733
5734         /* Return result */
5735         *result = r.out.result;
5736
5737         return NT_STATUS_OK;
5738 }
5739
5740 struct dcerpc_srvsvc_NetServerStatisticsGet_r_state {
5741         TALLOC_CTX *out_mem_ctx;
5742 };
5743
5744 static void dcerpc_srvsvc_NetServerStatisticsGet_r_done(struct tevent_req *subreq);
5745
5746 struct tevent_req *dcerpc_srvsvc_NetServerStatisticsGet_r_send(TALLOC_CTX *mem_ctx,
5747         struct tevent_context *ev,
5748         struct dcerpc_binding_handle *h,
5749         struct srvsvc_NetServerStatisticsGet *r)
5750 {
5751         struct tevent_req *req;
5752         struct dcerpc_srvsvc_NetServerStatisticsGet_r_state *state;
5753         struct tevent_req *subreq;
5754
5755         req = tevent_req_create(mem_ctx, &state,
5756                                 struct dcerpc_srvsvc_NetServerStatisticsGet_r_state);
5757         if (req == NULL) {
5758                 return NULL;
5759         }
5760
5761         state->out_mem_ctx = talloc_new(state);
5762         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5763                 return tevent_req_post(req, ev);
5764         }
5765
5766         subreq = dcerpc_binding_handle_call_send(state, ev, h,
5767                         NULL, &ndr_table_srvsvc,
5768                         NDR_SRVSVC_NETSERVERSTATISTICSGET, state->out_mem_ctx, r);
5769         if (tevent_req_nomem(subreq, req)) {
5770                 return tevent_req_post(req, ev);
5771         }
5772         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetServerStatisticsGet_r_done, req);
5773
5774         return req;
5775 }
5776
5777 static void dcerpc_srvsvc_NetServerStatisticsGet_r_done(struct tevent_req *subreq)
5778 {
5779         struct tevent_req *req =
5780                 tevent_req_callback_data(subreq,
5781                 struct tevent_req);
5782         NTSTATUS status;
5783
5784         status = dcerpc_binding_handle_call_recv(subreq);
5785         if (!NT_STATUS_IS_OK(status)) {
5786                 tevent_req_nterror(req, status);
5787                 return;
5788         }
5789
5790         tevent_req_done(req);
5791 }
5792
5793 NTSTATUS dcerpc_srvsvc_NetServerStatisticsGet_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
5794 {
5795         struct dcerpc_srvsvc_NetServerStatisticsGet_r_state *state =
5796                 tevent_req_data(req,
5797                 struct dcerpc_srvsvc_NetServerStatisticsGet_r_state);
5798         NTSTATUS status;
5799
5800         if (tevent_req_is_nterror(req, &status)) {
5801                 tevent_req_received(req);
5802                 return status;
5803         }
5804
5805         talloc_steal(mem_ctx, state->out_mem_ctx);
5806
5807         tevent_req_received(req);
5808         return NT_STATUS_OK;
5809 }
5810
5811 NTSTATUS dcerpc_srvsvc_NetServerStatisticsGet_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetServerStatisticsGet *r)
5812 {
5813         NTSTATUS status;
5814
5815         status = dcerpc_binding_handle_call(h,
5816                         NULL, &ndr_table_srvsvc,
5817                         NDR_SRVSVC_NETSERVERSTATISTICSGET, mem_ctx, r);
5818
5819         return status;
5820 }
5821
5822 NTSTATUS dcerpc_srvsvc_NetServerStatisticsGet_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetServerStatisticsGet *r)
5823 {
5824         NTSTATUS status;
5825
5826         status = dcerpc_srvsvc_NetServerStatisticsGet_r(p->binding_handle, mem_ctx, r);
5827
5828         if (NT_STATUS_IS_RPC(status)) {
5829                 status = NT_STATUS_NET_WRITE_FAULT;
5830         }
5831
5832         return status;
5833 }
5834
5835 struct dcerpc_srvsvc_NetServerStatisticsGet_state {
5836         struct srvsvc_NetServerStatisticsGet orig;
5837         struct srvsvc_NetServerStatisticsGet tmp;
5838         TALLOC_CTX *out_mem_ctx;
5839 };
5840
5841 static void dcerpc_srvsvc_NetServerStatisticsGet_done(struct tevent_req *subreq);
5842
5843 struct tevent_req *dcerpc_srvsvc_NetServerStatisticsGet_send(TALLOC_CTX *mem_ctx,
5844                                                              struct tevent_context *ev,
5845                                                              struct dcerpc_binding_handle *h,
5846                                                              const char *_server_unc /* [in] [unique,charset(UTF16)] */,
5847                                                              const char *_service /* [in] [unique,charset(UTF16)] */,
5848                                                              uint32_t _level /* [in]  */,
5849                                                              uint32_t _options /* [in]  */,
5850                                                              struct srvsvc_Statistics **_stats /* [out] [ref] */)
5851 {
5852         struct tevent_req *req;
5853         struct dcerpc_srvsvc_NetServerStatisticsGet_state *state;
5854         struct tevent_req *subreq;
5855
5856         req = tevent_req_create(mem_ctx, &state,
5857                                 struct dcerpc_srvsvc_NetServerStatisticsGet_state);
5858         if (req == NULL) {
5859                 return NULL;
5860         }
5861         state->out_mem_ctx = NULL;
5862
5863         /* In parameters */
5864         state->orig.in.server_unc = _server_unc;
5865         state->orig.in.service = _service;
5866         state->orig.in.level = _level;
5867         state->orig.in.options = _options;
5868
5869         /* Out parameters */
5870         state->orig.out.stats = _stats;
5871
5872         /* Result */
5873         ZERO_STRUCT(state->orig.out.result);
5874
5875         state->out_mem_ctx = talloc_named_const(state, 0,
5876                              "dcerpc_srvsvc_NetServerStatisticsGet_out_memory");
5877         if (tevent_req_nomem(state->out_mem_ctx, req)) {
5878                 return tevent_req_post(req, ev);
5879         }
5880
5881         /* make a temporary copy, that we pass to the dispatch function */
5882         state->tmp = state->orig;
5883
5884         subreq = dcerpc_srvsvc_NetServerStatisticsGet_r_send(state, ev, h, &state->tmp);
5885         if (tevent_req_nomem(subreq, req)) {
5886                 return tevent_req_post(req, ev);
5887         }
5888         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetServerStatisticsGet_done, req);
5889         return req;
5890 }
5891
5892 static void dcerpc_srvsvc_NetServerStatisticsGet_done(struct tevent_req *subreq)
5893 {
5894         struct tevent_req *req = tevent_req_callback_data(
5895                 subreq, struct tevent_req);
5896         struct dcerpc_srvsvc_NetServerStatisticsGet_state *state = tevent_req_data(
5897                 req, struct dcerpc_srvsvc_NetServerStatisticsGet_state);
5898         NTSTATUS status;
5899         TALLOC_CTX *mem_ctx;
5900
5901         if (state->out_mem_ctx) {
5902                 mem_ctx = state->out_mem_ctx;
5903         } else {
5904                 mem_ctx = state;
5905         }
5906
5907         status = dcerpc_srvsvc_NetServerStatisticsGet_r_recv(subreq, mem_ctx);
5908         TALLOC_FREE(subreq);
5909         if (!NT_STATUS_IS_OK(status)) {
5910                 tevent_req_nterror(req, status);
5911                 return;
5912         }
5913
5914         /* Copy out parameters */
5915         *state->orig.out.stats = *state->tmp.out.stats;
5916
5917         /* Copy result */
5918         state->orig.out.result = state->tmp.out.result;
5919
5920         /* Reset temporary structure */
5921         ZERO_STRUCT(state->tmp);
5922
5923         tevent_req_done(req);
5924 }
5925
5926 NTSTATUS dcerpc_srvsvc_NetServerStatisticsGet_recv(struct tevent_req *req,
5927                                                    TALLOC_CTX *mem_ctx,
5928                                                    WERROR *result)
5929 {
5930         struct dcerpc_srvsvc_NetServerStatisticsGet_state *state = tevent_req_data(
5931                 req, struct dcerpc_srvsvc_NetServerStatisticsGet_state);
5932         NTSTATUS status;
5933
5934         if (tevent_req_is_nterror(req, &status)) {
5935                 tevent_req_received(req);
5936                 return status;
5937         }
5938
5939         /* Steal possible out parameters to the callers context */
5940         talloc_steal(mem_ctx, state->out_mem_ctx);
5941
5942         /* Return result */
5943         *result = state->orig.out.result;
5944
5945         tevent_req_received(req);
5946         return NT_STATUS_OK;
5947 }
5948
5949 NTSTATUS dcerpc_srvsvc_NetServerStatisticsGet(struct dcerpc_binding_handle *h,
5950                                               TALLOC_CTX *mem_ctx,
5951                                               const char *_server_unc /* [in] [unique,charset(UTF16)] */,
5952                                               const char *_service /* [in] [unique,charset(UTF16)] */,
5953                                               uint32_t _level /* [in]  */,
5954                                               uint32_t _options /* [in]  */,
5955                                               struct srvsvc_Statistics **_stats /* [out] [ref] */,
5956                                               WERROR *result)
5957 {
5958         struct srvsvc_NetServerStatisticsGet r;
5959         NTSTATUS status;
5960
5961         /* In parameters */
5962         r.in.server_unc = _server_unc;
5963         r.in.service = _service;
5964         r.in.level = _level;
5965         r.in.options = _options;
5966
5967         status = dcerpc_srvsvc_NetServerStatisticsGet_r(h, mem_ctx, &r);
5968         if (!NT_STATUS_IS_OK(status)) {
5969                 return status;
5970         }
5971
5972         /* Return variables */
5973         *_stats = *r.out.stats;
5974
5975         /* Return result */
5976         *result = r.out.result;
5977
5978         return NT_STATUS_OK;
5979 }
5980
5981 struct dcerpc_srvsvc_NetTransportAdd_r_state {
5982         TALLOC_CTX *out_mem_ctx;
5983 };
5984
5985 static void dcerpc_srvsvc_NetTransportAdd_r_done(struct tevent_req *subreq);
5986
5987 struct tevent_req *dcerpc_srvsvc_NetTransportAdd_r_send(TALLOC_CTX *mem_ctx,
5988         struct tevent_context *ev,
5989         struct dcerpc_binding_handle *h,
5990         struct srvsvc_NetTransportAdd *r)
5991 {
5992         struct tevent_req *req;
5993         struct dcerpc_srvsvc_NetTransportAdd_r_state *state;
5994         struct tevent_req *subreq;
5995
5996         req = tevent_req_create(mem_ctx, &state,
5997                                 struct dcerpc_srvsvc_NetTransportAdd_r_state);
5998         if (req == NULL) {
5999                 return NULL;
6000         }
6001
6002         state->out_mem_ctx = NULL;
6003         subreq = dcerpc_binding_handle_call_send(state, ev, h,
6004                         NULL, &ndr_table_srvsvc,
6005                         NDR_SRVSVC_NETTRANSPORTADD, state, r);
6006         if (tevent_req_nomem(subreq, req)) {
6007                 return tevent_req_post(req, ev);
6008         }
6009         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetTransportAdd_r_done, req);
6010
6011         return req;
6012 }
6013
6014 static void dcerpc_srvsvc_NetTransportAdd_r_done(struct tevent_req *subreq)
6015 {
6016         struct tevent_req *req =
6017                 tevent_req_callback_data(subreq,
6018                 struct tevent_req);
6019         NTSTATUS status;
6020
6021         status = dcerpc_binding_handle_call_recv(subreq);
6022         if (!NT_STATUS_IS_OK(status)) {
6023                 tevent_req_nterror(req, status);
6024                 return;
6025         }
6026
6027         tevent_req_done(req);
6028 }
6029
6030 NTSTATUS dcerpc_srvsvc_NetTransportAdd_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
6031 {
6032         struct dcerpc_srvsvc_NetTransportAdd_r_state *state =
6033                 tevent_req_data(req,
6034                 struct dcerpc_srvsvc_NetTransportAdd_r_state);
6035         NTSTATUS status;
6036
6037         if (tevent_req_is_nterror(req, &status)) {
6038                 tevent_req_received(req);
6039                 return status;
6040         }
6041
6042         talloc_steal(mem_ctx, state->out_mem_ctx);
6043
6044         tevent_req_received(req);
6045         return NT_STATUS_OK;
6046 }
6047
6048 NTSTATUS dcerpc_srvsvc_NetTransportAdd_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetTransportAdd *r)
6049 {
6050         NTSTATUS status;
6051
6052         status = dcerpc_binding_handle_call(h,
6053                         NULL, &ndr_table_srvsvc,
6054                         NDR_SRVSVC_NETTRANSPORTADD, mem_ctx, r);
6055
6056         return status;
6057 }
6058
6059 NTSTATUS dcerpc_srvsvc_NetTransportAdd_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetTransportAdd *r)
6060 {
6061         NTSTATUS status;
6062
6063         status = dcerpc_srvsvc_NetTransportAdd_r(p->binding_handle, mem_ctx, r);
6064
6065         if (NT_STATUS_IS_RPC(status)) {
6066                 status = NT_STATUS_NET_WRITE_FAULT;
6067         }
6068
6069         return status;
6070 }
6071
6072 struct dcerpc_srvsvc_NetTransportAdd_state {
6073         struct srvsvc_NetTransportAdd orig;
6074         struct srvsvc_NetTransportAdd tmp;
6075         TALLOC_CTX *out_mem_ctx;
6076 };
6077
6078 static void dcerpc_srvsvc_NetTransportAdd_done(struct tevent_req *subreq);
6079
6080 struct tevent_req *dcerpc_srvsvc_NetTransportAdd_send(TALLOC_CTX *mem_ctx,
6081                                                       struct tevent_context *ev,
6082                                                       struct dcerpc_binding_handle *h,
6083                                                       const char *_server_unc /* [in] [unique,charset(UTF16)] */,
6084                                                       uint32_t _level /* [in]  */,
6085                                                       union srvsvc_NetTransportInfo _info /* [in] [switch_is(level)] */)
6086 {
6087         struct tevent_req *req;
6088         struct dcerpc_srvsvc_NetTransportAdd_state *state;
6089         struct tevent_req *subreq;
6090
6091         req = tevent_req_create(mem_ctx, &state,
6092                                 struct dcerpc_srvsvc_NetTransportAdd_state);
6093         if (req == NULL) {
6094                 return NULL;
6095         }
6096         state->out_mem_ctx = NULL;
6097
6098         /* In parameters */
6099         state->orig.in.server_unc = _server_unc;
6100         state->orig.in.level = _level;
6101         state->orig.in.info = _info;
6102
6103         /* Out parameters */
6104
6105         /* Result */
6106         ZERO_STRUCT(state->orig.out.result);
6107
6108         /* make a temporary copy, that we pass to the dispatch function */
6109         state->tmp = state->orig;
6110
6111         subreq = dcerpc_srvsvc_NetTransportAdd_r_send(state, ev, h, &state->tmp);
6112         if (tevent_req_nomem(subreq, req)) {
6113                 return tevent_req_post(req, ev);
6114         }
6115         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetTransportAdd_done, req);
6116         return req;
6117 }
6118
6119 static void dcerpc_srvsvc_NetTransportAdd_done(struct tevent_req *subreq)
6120 {
6121         struct tevent_req *req = tevent_req_callback_data(
6122                 subreq, struct tevent_req);
6123         struct dcerpc_srvsvc_NetTransportAdd_state *state = tevent_req_data(
6124                 req, struct dcerpc_srvsvc_NetTransportAdd_state);
6125         NTSTATUS status;
6126         TALLOC_CTX *mem_ctx;
6127
6128         if (state->out_mem_ctx) {
6129                 mem_ctx = state->out_mem_ctx;
6130         } else {
6131                 mem_ctx = state;
6132         }
6133
6134         status = dcerpc_srvsvc_NetTransportAdd_r_recv(subreq, mem_ctx);
6135         TALLOC_FREE(subreq);
6136         if (!NT_STATUS_IS_OK(status)) {
6137                 tevent_req_nterror(req, status);
6138                 return;
6139         }
6140
6141         /* Copy out parameters */
6142
6143         /* Copy result */
6144         state->orig.out.result = state->tmp.out.result;
6145
6146         /* Reset temporary structure */
6147         ZERO_STRUCT(state->tmp);
6148
6149         tevent_req_done(req);
6150 }
6151
6152 NTSTATUS dcerpc_srvsvc_NetTransportAdd_recv(struct tevent_req *req,
6153                                             TALLOC_CTX *mem_ctx,
6154                                             WERROR *result)
6155 {
6156         struct dcerpc_srvsvc_NetTransportAdd_state *state = tevent_req_data(
6157                 req, struct dcerpc_srvsvc_NetTransportAdd_state);
6158         NTSTATUS status;
6159
6160         if (tevent_req_is_nterror(req, &status)) {
6161                 tevent_req_received(req);
6162                 return status;
6163         }
6164
6165         /* Steal possible out parameters to the callers context */
6166         talloc_steal(mem_ctx, state->out_mem_ctx);
6167
6168         /* Return result */
6169         *result = state->orig.out.result;
6170
6171         tevent_req_received(req);
6172         return NT_STATUS_OK;
6173 }
6174
6175 NTSTATUS dcerpc_srvsvc_NetTransportAdd(struct dcerpc_binding_handle *h,
6176                                        TALLOC_CTX *mem_ctx,
6177                                        const char *_server_unc /* [in] [unique,charset(UTF16)] */,
6178                                        uint32_t _level /* [in]  */,
6179                                        union srvsvc_NetTransportInfo _info /* [in] [switch_is(level)] */,
6180                                        WERROR *result)
6181 {
6182         struct srvsvc_NetTransportAdd r;
6183         NTSTATUS status;
6184
6185         /* In parameters */
6186         r.in.server_unc = _server_unc;
6187         r.in.level = _level;
6188         r.in.info = _info;
6189
6190         status = dcerpc_srvsvc_NetTransportAdd_r(h, mem_ctx, &r);
6191         if (!NT_STATUS_IS_OK(status)) {
6192                 return status;
6193         }
6194
6195         /* Return variables */
6196
6197         /* Return result */
6198         *result = r.out.result;
6199
6200         return NT_STATUS_OK;
6201 }
6202
6203 struct dcerpc_srvsvc_NetTransportEnum_r_state {
6204         TALLOC_CTX *out_mem_ctx;
6205 };
6206
6207 static void dcerpc_srvsvc_NetTransportEnum_r_done(struct tevent_req *subreq);
6208
6209 struct tevent_req *dcerpc_srvsvc_NetTransportEnum_r_send(TALLOC_CTX *mem_ctx,
6210         struct tevent_context *ev,
6211         struct dcerpc_binding_handle *h,
6212         struct srvsvc_NetTransportEnum *r)
6213 {
6214         struct tevent_req *req;
6215         struct dcerpc_srvsvc_NetTransportEnum_r_state *state;
6216         struct tevent_req *subreq;
6217
6218         req = tevent_req_create(mem_ctx, &state,
6219                                 struct dcerpc_srvsvc_NetTransportEnum_r_state);
6220         if (req == NULL) {
6221                 return NULL;
6222         }
6223
6224         state->out_mem_ctx = talloc_new(state);
6225         if (tevent_req_nomem(state->out_mem_ctx, req)) {
6226                 return tevent_req_post(req, ev);
6227         }
6228
6229         subreq = dcerpc_binding_handle_call_send(state, ev, h,
6230                         NULL, &ndr_table_srvsvc,
6231                         NDR_SRVSVC_NETTRANSPORTENUM, state->out_mem_ctx, r);
6232         if (tevent_req_nomem(subreq, req)) {
6233                 return tevent_req_post(req, ev);
6234         }
6235         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetTransportEnum_r_done, req);
6236
6237         return req;
6238 }
6239
6240 static void dcerpc_srvsvc_NetTransportEnum_r_done(struct tevent_req *subreq)
6241 {
6242         struct tevent_req *req =
6243                 tevent_req_callback_data(subreq,
6244                 struct tevent_req);
6245         NTSTATUS status;
6246
6247         status = dcerpc_binding_handle_call_recv(subreq);
6248         if (!NT_STATUS_IS_OK(status)) {
6249                 tevent_req_nterror(req, status);
6250                 return;
6251         }
6252
6253         tevent_req_done(req);
6254 }
6255
6256 NTSTATUS dcerpc_srvsvc_NetTransportEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
6257 {
6258         struct dcerpc_srvsvc_NetTransportEnum_r_state *state =
6259                 tevent_req_data(req,
6260                 struct dcerpc_srvsvc_NetTransportEnum_r_state);
6261         NTSTATUS status;
6262
6263         if (tevent_req_is_nterror(req, &status)) {
6264                 tevent_req_received(req);
6265                 return status;
6266         }
6267
6268         talloc_steal(mem_ctx, state->out_mem_ctx);
6269
6270         tevent_req_received(req);
6271         return NT_STATUS_OK;
6272 }
6273
6274 NTSTATUS dcerpc_srvsvc_NetTransportEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetTransportEnum *r)
6275 {
6276         NTSTATUS status;
6277
6278         status = dcerpc_binding_handle_call(h,
6279                         NULL, &ndr_table_srvsvc,
6280                         NDR_SRVSVC_NETTRANSPORTENUM, mem_ctx, r);
6281
6282         return status;
6283 }
6284
6285 NTSTATUS dcerpc_srvsvc_NetTransportEnum_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetTransportEnum *r)
6286 {
6287         NTSTATUS status;
6288
6289         status = dcerpc_srvsvc_NetTransportEnum_r(p->binding_handle, mem_ctx, r);
6290
6291         if (NT_STATUS_IS_RPC(status)) {
6292                 status = NT_STATUS_NET_WRITE_FAULT;
6293         }
6294
6295         return status;
6296 }
6297
6298 struct dcerpc_srvsvc_NetTransportEnum_state {
6299         struct srvsvc_NetTransportEnum orig;
6300         struct srvsvc_NetTransportEnum tmp;
6301         TALLOC_CTX *out_mem_ctx;
6302 };
6303
6304 static void dcerpc_srvsvc_NetTransportEnum_done(struct tevent_req *subreq);
6305
6306 struct tevent_req *dcerpc_srvsvc_NetTransportEnum_send(TALLOC_CTX *mem_ctx,
6307                                                        struct tevent_context *ev,
6308                                                        struct dcerpc_binding_handle *h,
6309                                                        const char *_server_unc /* [in] [unique,charset(UTF16)] */,
6310                                                        struct srvsvc_NetTransportInfoCtr *_transports /* [in,out] [ref] */,
6311                                                        uint32_t _max_buffer /* [in]  */,
6312                                                        uint32_t *_totalentries /* [out] [ref] */,
6313                                                        uint32_t *_resume_handle /* [in,out] [unique] */)
6314 {
6315         struct tevent_req *req;
6316         struct dcerpc_srvsvc_NetTransportEnum_state *state;
6317         struct tevent_req *subreq;
6318
6319         req = tevent_req_create(mem_ctx, &state,
6320                                 struct dcerpc_srvsvc_NetTransportEnum_state);
6321         if (req == NULL) {
6322                 return NULL;
6323         }
6324         state->out_mem_ctx = NULL;
6325
6326         /* In parameters */
6327         state->orig.in.server_unc = _server_unc;
6328         state->orig.in.transports = _transports;
6329         state->orig.in.max_buffer = _max_buffer;
6330         state->orig.in.resume_handle = _resume_handle;
6331
6332         /* Out parameters */
6333         state->orig.out.transports = _transports;
6334         state->orig.out.totalentries = _totalentries;
6335         state->orig.out.resume_handle = _resume_handle;
6336
6337         /* Result */
6338         ZERO_STRUCT(state->orig.out.result);
6339
6340         state->out_mem_ctx = talloc_named_const(state, 0,
6341                              "dcerpc_srvsvc_NetTransportEnum_out_memory");
6342         if (tevent_req_nomem(state->out_mem_ctx, req)) {
6343                 return tevent_req_post(req, ev);
6344         }
6345
6346         /* make a temporary copy, that we pass to the dispatch function */
6347         state->tmp = state->orig;
6348
6349         subreq = dcerpc_srvsvc_NetTransportEnum_r_send(state, ev, h, &state->tmp);
6350         if (tevent_req_nomem(subreq, req)) {
6351                 return tevent_req_post(req, ev);
6352         }
6353         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetTransportEnum_done, req);
6354         return req;
6355 }
6356
6357 static void dcerpc_srvsvc_NetTransportEnum_done(struct tevent_req *subreq)
6358 {
6359         struct tevent_req *req = tevent_req_callback_data(
6360                 subreq, struct tevent_req);
6361         struct dcerpc_srvsvc_NetTransportEnum_state *state = tevent_req_data(
6362                 req, struct dcerpc_srvsvc_NetTransportEnum_state);
6363         NTSTATUS status;
6364         TALLOC_CTX *mem_ctx;
6365
6366         if (state->out_mem_ctx) {
6367                 mem_ctx = state->out_mem_ctx;
6368         } else {
6369                 mem_ctx = state;
6370         }
6371
6372         status = dcerpc_srvsvc_NetTransportEnum_r_recv(subreq, mem_ctx);
6373         TALLOC_FREE(subreq);
6374         if (!NT_STATUS_IS_OK(status)) {
6375                 tevent_req_nterror(req, status);
6376                 return;
6377         }
6378
6379         /* Copy out parameters */
6380         *state->orig.out.transports = *state->tmp.out.transports;
6381         *state->orig.out.totalentries = *state->tmp.out.totalentries;
6382         if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
6383                 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
6384         }
6385
6386         /* Copy result */
6387         state->orig.out.result = state->tmp.out.result;
6388
6389         /* Reset temporary structure */
6390         ZERO_STRUCT(state->tmp);
6391
6392         tevent_req_done(req);
6393 }
6394
6395 NTSTATUS dcerpc_srvsvc_NetTransportEnum_recv(struct tevent_req *req,
6396                                              TALLOC_CTX *mem_ctx,
6397                                              WERROR *result)
6398 {
6399         struct dcerpc_srvsvc_NetTransportEnum_state *state = tevent_req_data(
6400                 req, struct dcerpc_srvsvc_NetTransportEnum_state);
6401         NTSTATUS status;
6402
6403         if (tevent_req_is_nterror(req, &status)) {
6404                 tevent_req_received(req);
6405                 return status;
6406         }
6407
6408         /* Steal possible out parameters to the callers context */
6409         talloc_steal(mem_ctx, state->out_mem_ctx);
6410
6411         /* Return result */
6412         *result = state->orig.out.result;
6413
6414         tevent_req_received(req);
6415         return NT_STATUS_OK;
6416 }
6417
6418 NTSTATUS dcerpc_srvsvc_NetTransportEnum(struct dcerpc_binding_handle *h,
6419                                         TALLOC_CTX *mem_ctx,
6420                                         const char *_server_unc /* [in] [unique,charset(UTF16)] */,
6421                                         struct srvsvc_NetTransportInfoCtr *_transports /* [in,out] [ref] */,
6422                                         uint32_t _max_buffer /* [in]  */,
6423                                         uint32_t *_totalentries /* [out] [ref] */,
6424                                         uint32_t *_resume_handle /* [in,out] [unique] */,
6425                                         WERROR *result)
6426 {
6427         struct srvsvc_NetTransportEnum r;
6428         NTSTATUS status;
6429
6430         /* In parameters */
6431         r.in.server_unc = _server_unc;
6432         r.in.transports = _transports;
6433         r.in.max_buffer = _max_buffer;
6434         r.in.resume_handle = _resume_handle;
6435
6436         status = dcerpc_srvsvc_NetTransportEnum_r(h, mem_ctx, &r);
6437         if (!NT_STATUS_IS_OK(status)) {
6438                 return status;
6439         }
6440
6441         /* Return variables */
6442         *_transports = *r.out.transports;
6443         *_totalentries = *r.out.totalentries;
6444         if (_resume_handle && r.out.resume_handle) {
6445                 *_resume_handle = *r.out.resume_handle;
6446         }
6447
6448         /* Return result */
6449         *result = r.out.result;
6450
6451         return NT_STATUS_OK;
6452 }
6453
6454 struct dcerpc_srvsvc_NetTransportDel_r_state {
6455         TALLOC_CTX *out_mem_ctx;
6456 };
6457
6458 static void dcerpc_srvsvc_NetTransportDel_r_done(struct tevent_req *subreq);
6459
6460 struct tevent_req *dcerpc_srvsvc_NetTransportDel_r_send(TALLOC_CTX *mem_ctx,
6461         struct tevent_context *ev,
6462         struct dcerpc_binding_handle *h,
6463         struct srvsvc_NetTransportDel *r)
6464 {
6465         struct tevent_req *req;
6466         struct dcerpc_srvsvc_NetTransportDel_r_state *state;
6467         struct tevent_req *subreq;
6468
6469         req = tevent_req_create(mem_ctx, &state,
6470                                 struct dcerpc_srvsvc_NetTransportDel_r_state);
6471         if (req == NULL) {
6472                 return NULL;
6473         }
6474
6475         state->out_mem_ctx = NULL;
6476         subreq = dcerpc_binding_handle_call_send(state, ev, h,
6477                         NULL, &ndr_table_srvsvc,
6478                         NDR_SRVSVC_NETTRANSPORTDEL, state, r);
6479         if (tevent_req_nomem(subreq, req)) {
6480                 return tevent_req_post(req, ev);
6481         }
6482         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetTransportDel_r_done, req);
6483
6484         return req;
6485 }
6486
6487 static void dcerpc_srvsvc_NetTransportDel_r_done(struct tevent_req *subreq)
6488 {
6489         struct tevent_req *req =
6490                 tevent_req_callback_data(subreq,
6491                 struct tevent_req);
6492         NTSTATUS status;
6493
6494         status = dcerpc_binding_handle_call_recv(subreq);
6495         if (!NT_STATUS_IS_OK(status)) {
6496                 tevent_req_nterror(req, status);
6497                 return;
6498         }
6499
6500         tevent_req_done(req);
6501 }
6502
6503 NTSTATUS dcerpc_srvsvc_NetTransportDel_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
6504 {
6505         struct dcerpc_srvsvc_NetTransportDel_r_state *state =
6506                 tevent_req_data(req,
6507                 struct dcerpc_srvsvc_NetTransportDel_r_state);
6508         NTSTATUS status;
6509
6510         if (tevent_req_is_nterror(req, &status)) {
6511                 tevent_req_received(req);
6512                 return status;
6513         }
6514
6515         talloc_steal(mem_ctx, state->out_mem_ctx);
6516
6517         tevent_req_received(req);
6518         return NT_STATUS_OK;
6519 }
6520
6521 NTSTATUS dcerpc_srvsvc_NetTransportDel_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetTransportDel *r)
6522 {
6523         NTSTATUS status;
6524
6525         status = dcerpc_binding_handle_call(h,
6526                         NULL, &ndr_table_srvsvc,
6527                         NDR_SRVSVC_NETTRANSPORTDEL, mem_ctx, r);
6528
6529         return status;
6530 }
6531
6532 NTSTATUS dcerpc_srvsvc_NetTransportDel_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetTransportDel *r)
6533 {
6534         NTSTATUS status;
6535
6536         status = dcerpc_srvsvc_NetTransportDel_r(p->binding_handle, mem_ctx, r);
6537
6538         if (NT_STATUS_IS_RPC(status)) {
6539                 status = NT_STATUS_NET_WRITE_FAULT;
6540         }
6541
6542         return status;
6543 }
6544
6545 struct dcerpc_srvsvc_NetTransportDel_state {
6546         struct srvsvc_NetTransportDel orig;
6547         struct srvsvc_NetTransportDel tmp;
6548         TALLOC_CTX *out_mem_ctx;
6549 };
6550
6551 static void dcerpc_srvsvc_NetTransportDel_done(struct tevent_req *subreq);
6552
6553 struct tevent_req *dcerpc_srvsvc_NetTransportDel_send(TALLOC_CTX *mem_ctx,
6554                                                       struct tevent_context *ev,
6555                                                       struct dcerpc_binding_handle *h,
6556                                                       const char *_server_unc /* [in] [unique,charset(UTF16)] */,
6557                                                       uint32_t _level /* [in]  */,
6558                                                       struct srvsvc_NetTransportInfo0 *_info0 /* [in] [ref] */)
6559 {
6560         struct tevent_req *req;
6561         struct dcerpc_srvsvc_NetTransportDel_state *state;
6562         struct tevent_req *subreq;
6563
6564         req = tevent_req_create(mem_ctx, &state,
6565                                 struct dcerpc_srvsvc_NetTransportDel_state);
6566         if (req == NULL) {
6567                 return NULL;
6568         }
6569         state->out_mem_ctx = NULL;
6570
6571         /* In parameters */
6572         state->orig.in.server_unc = _server_unc;
6573         state->orig.in.level = _level;
6574         state->orig.in.info0 = _info0;
6575
6576         /* Out parameters */
6577
6578         /* Result */
6579         ZERO_STRUCT(state->orig.out.result);
6580
6581         /* make a temporary copy, that we pass to the dispatch function */
6582         state->tmp = state->orig;
6583
6584         subreq = dcerpc_srvsvc_NetTransportDel_r_send(state, ev, h, &state->tmp);
6585         if (tevent_req_nomem(subreq, req)) {
6586                 return tevent_req_post(req, ev);
6587         }
6588         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetTransportDel_done, req);
6589         return req;
6590 }
6591
6592 static void dcerpc_srvsvc_NetTransportDel_done(struct tevent_req *subreq)
6593 {
6594         struct tevent_req *req = tevent_req_callback_data(
6595                 subreq, struct tevent_req);
6596         struct dcerpc_srvsvc_NetTransportDel_state *state = tevent_req_data(
6597                 req, struct dcerpc_srvsvc_NetTransportDel_state);
6598         NTSTATUS status;
6599         TALLOC_CTX *mem_ctx;
6600
6601         if (state->out_mem_ctx) {
6602                 mem_ctx = state->out_mem_ctx;
6603         } else {
6604                 mem_ctx = state;
6605         }
6606
6607         status = dcerpc_srvsvc_NetTransportDel_r_recv(subreq, mem_ctx);
6608         TALLOC_FREE(subreq);
6609         if (!NT_STATUS_IS_OK(status)) {
6610                 tevent_req_nterror(req, status);
6611                 return;
6612         }
6613
6614         /* Copy out parameters */
6615
6616         /* Copy result */
6617         state->orig.out.result = state->tmp.out.result;
6618
6619         /* Reset temporary structure */
6620         ZERO_STRUCT(state->tmp);
6621
6622         tevent_req_done(req);
6623 }
6624
6625 NTSTATUS dcerpc_srvsvc_NetTransportDel_recv(struct tevent_req *req,
6626                                             TALLOC_CTX *mem_ctx,
6627                                             WERROR *result)
6628 {
6629         struct dcerpc_srvsvc_NetTransportDel_state *state = tevent_req_data(
6630                 req, struct dcerpc_srvsvc_NetTransportDel_state);
6631         NTSTATUS status;
6632
6633         if (tevent_req_is_nterror(req, &status)) {
6634                 tevent_req_received(req);
6635                 return status;
6636         }
6637
6638         /* Steal possible out parameters to the callers context */
6639         talloc_steal(mem_ctx, state->out_mem_ctx);
6640
6641         /* Return result */
6642         *result = state->orig.out.result;
6643
6644         tevent_req_received(req);
6645         return NT_STATUS_OK;
6646 }
6647
6648 NTSTATUS dcerpc_srvsvc_NetTransportDel(struct dcerpc_binding_handle *h,
6649                                        TALLOC_CTX *mem_ctx,
6650                                        const char *_server_unc /* [in] [unique,charset(UTF16)] */,
6651                                        uint32_t _level /* [in]  */,
6652                                        struct srvsvc_NetTransportInfo0 *_info0 /* [in] [ref] */,
6653                                        WERROR *result)
6654 {
6655         struct srvsvc_NetTransportDel r;
6656         NTSTATUS status;
6657
6658         /* In parameters */
6659         r.in.server_unc = _server_unc;
6660         r.in.level = _level;
6661         r.in.info0 = _info0;
6662
6663         status = dcerpc_srvsvc_NetTransportDel_r(h, mem_ctx, &r);
6664         if (!NT_STATUS_IS_OK(status)) {
6665                 return status;
6666         }
6667
6668         /* Return variables */
6669
6670         /* Return result */
6671         *result = r.out.result;
6672
6673         return NT_STATUS_OK;
6674 }
6675
6676 struct dcerpc_srvsvc_NetRemoteTOD_r_state {
6677         TALLOC_CTX *out_mem_ctx;
6678 };
6679
6680 static void dcerpc_srvsvc_NetRemoteTOD_r_done(struct tevent_req *subreq);
6681
6682 struct tevent_req *dcerpc_srvsvc_NetRemoteTOD_r_send(TALLOC_CTX *mem_ctx,
6683         struct tevent_context *ev,
6684         struct dcerpc_binding_handle *h,
6685         struct srvsvc_NetRemoteTOD *r)
6686 {
6687         struct tevent_req *req;
6688         struct dcerpc_srvsvc_NetRemoteTOD_r_state *state;
6689         struct tevent_req *subreq;
6690
6691         req = tevent_req_create(mem_ctx, &state,
6692                                 struct dcerpc_srvsvc_NetRemoteTOD_r_state);
6693         if (req == NULL) {
6694                 return NULL;
6695         }
6696
6697         state->out_mem_ctx = talloc_new(state);
6698         if (tevent_req_nomem(state->out_mem_ctx, req)) {
6699                 return tevent_req_post(req, ev);
6700         }
6701
6702         subreq = dcerpc_binding_handle_call_send(state, ev, h,
6703                         NULL, &ndr_table_srvsvc,
6704                         NDR_SRVSVC_NETREMOTETOD, state->out_mem_ctx, r);
6705         if (tevent_req_nomem(subreq, req)) {
6706                 return tevent_req_post(req, ev);
6707         }
6708         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetRemoteTOD_r_done, req);
6709
6710         return req;
6711 }
6712
6713 static void dcerpc_srvsvc_NetRemoteTOD_r_done(struct tevent_req *subreq)
6714 {
6715         struct tevent_req *req =
6716                 tevent_req_callback_data(subreq,
6717                 struct tevent_req);
6718         NTSTATUS status;
6719
6720         status = dcerpc_binding_handle_call_recv(subreq);
6721         if (!NT_STATUS_IS_OK(status)) {
6722                 tevent_req_nterror(req, status);
6723                 return;
6724         }
6725
6726         tevent_req_done(req);
6727 }
6728
6729 NTSTATUS dcerpc_srvsvc_NetRemoteTOD_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
6730 {
6731         struct dcerpc_srvsvc_NetRemoteTOD_r_state *state =
6732                 tevent_req_data(req,
6733                 struct dcerpc_srvsvc_NetRemoteTOD_r_state);
6734         NTSTATUS status;
6735
6736         if (tevent_req_is_nterror(req, &status)) {
6737                 tevent_req_received(req);
6738                 return status;
6739         }
6740
6741         talloc_steal(mem_ctx, state->out_mem_ctx);
6742
6743         tevent_req_received(req);
6744         return NT_STATUS_OK;
6745 }
6746
6747 NTSTATUS dcerpc_srvsvc_NetRemoteTOD_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetRemoteTOD *r)
6748 {
6749         NTSTATUS status;
6750
6751         status = dcerpc_binding_handle_call(h,
6752                         NULL, &ndr_table_srvsvc,
6753                         NDR_SRVSVC_NETREMOTETOD, mem_ctx, r);
6754
6755         return status;
6756 }
6757
6758 NTSTATUS dcerpc_srvsvc_NetRemoteTOD_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetRemoteTOD *r)
6759 {
6760         NTSTATUS status;
6761
6762         status = dcerpc_srvsvc_NetRemoteTOD_r(p->binding_handle, mem_ctx, r);
6763
6764         if (NT_STATUS_IS_RPC(status)) {
6765                 status = NT_STATUS_NET_WRITE_FAULT;
6766         }
6767
6768         return status;
6769 }
6770
6771 struct dcerpc_srvsvc_NetRemoteTOD_state {
6772         struct srvsvc_NetRemoteTOD orig;
6773         struct srvsvc_NetRemoteTOD tmp;
6774         TALLOC_CTX *out_mem_ctx;
6775 };
6776
6777 static void dcerpc_srvsvc_NetRemoteTOD_done(struct tevent_req *subreq);
6778
6779 struct tevent_req *dcerpc_srvsvc_NetRemoteTOD_send(TALLOC_CTX *mem_ctx,
6780                                                    struct tevent_context *ev,
6781                                                    struct dcerpc_binding_handle *h,
6782                                                    const char *_server_unc /* [in] [unique,charset(UTF16)] */,
6783                                                    struct srvsvc_NetRemoteTODInfo **_info /* [out] [ref] */)
6784 {
6785         struct tevent_req *req;
6786         struct dcerpc_srvsvc_NetRemoteTOD_state *state;
6787         struct tevent_req *subreq;
6788
6789         req = tevent_req_create(mem_ctx, &state,
6790                                 struct dcerpc_srvsvc_NetRemoteTOD_state);
6791         if (req == NULL) {
6792                 return NULL;
6793         }
6794         state->out_mem_ctx = NULL;
6795
6796         /* In parameters */
6797         state->orig.in.server_unc = _server_unc;
6798
6799         /* Out parameters */
6800         state->orig.out.info = _info;
6801
6802         /* Result */
6803         ZERO_STRUCT(state->orig.out.result);
6804
6805         state->out_mem_ctx = talloc_named_const(state, 0,
6806                              "dcerpc_srvsvc_NetRemoteTOD_out_memory");
6807         if (tevent_req_nomem(state->out_mem_ctx, req)) {
6808                 return tevent_req_post(req, ev);
6809         }
6810
6811         /* make a temporary copy, that we pass to the dispatch function */
6812         state->tmp = state->orig;
6813
6814         subreq = dcerpc_srvsvc_NetRemoteTOD_r_send(state, ev, h, &state->tmp);
6815         if (tevent_req_nomem(subreq, req)) {
6816                 return tevent_req_post(req, ev);
6817         }
6818         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetRemoteTOD_done, req);
6819         return req;
6820 }
6821
6822 static void dcerpc_srvsvc_NetRemoteTOD_done(struct tevent_req *subreq)
6823 {
6824         struct tevent_req *req = tevent_req_callback_data(
6825                 subreq, struct tevent_req);
6826         struct dcerpc_srvsvc_NetRemoteTOD_state *state = tevent_req_data(
6827                 req, struct dcerpc_srvsvc_NetRemoteTOD_state);
6828         NTSTATUS status;
6829         TALLOC_CTX *mem_ctx;
6830
6831         if (state->out_mem_ctx) {
6832                 mem_ctx = state->out_mem_ctx;
6833         } else {
6834                 mem_ctx = state;
6835         }
6836
6837         status = dcerpc_srvsvc_NetRemoteTOD_r_recv(subreq, mem_ctx);
6838         TALLOC_FREE(subreq);
6839         if (!NT_STATUS_IS_OK(status)) {
6840                 tevent_req_nterror(req, status);
6841                 return;
6842         }
6843
6844         /* Copy out parameters */
6845         *state->orig.out.info = *state->tmp.out.info;
6846
6847         /* Copy result */
6848         state->orig.out.result = state->tmp.out.result;
6849
6850         /* Reset temporary structure */
6851         ZERO_STRUCT(state->tmp);
6852
6853         tevent_req_done(req);
6854 }
6855
6856 NTSTATUS dcerpc_srvsvc_NetRemoteTOD_recv(struct tevent_req *req,
6857                                          TALLOC_CTX *mem_ctx,
6858                                          WERROR *result)
6859 {
6860         struct dcerpc_srvsvc_NetRemoteTOD_state *state = tevent_req_data(
6861                 req, struct dcerpc_srvsvc_NetRemoteTOD_state);
6862         NTSTATUS status;
6863
6864         if (tevent_req_is_nterror(req, &status)) {
6865                 tevent_req_received(req);
6866                 return status;
6867         }
6868
6869         /* Steal possible out parameters to the callers context */
6870         talloc_steal(mem_ctx, state->out_mem_ctx);
6871
6872         /* Return result */
6873         *result = state->orig.out.result;
6874
6875         tevent_req_received(req);
6876         return NT_STATUS_OK;
6877 }
6878
6879 NTSTATUS dcerpc_srvsvc_NetRemoteTOD(struct dcerpc_binding_handle *h,
6880                                     TALLOC_CTX *mem_ctx,
6881                                     const char *_server_unc /* [in] [unique,charset(UTF16)] */,
6882                                     struct srvsvc_NetRemoteTODInfo **_info /* [out] [ref] */,
6883                                     WERROR *result)
6884 {
6885         struct srvsvc_NetRemoteTOD r;
6886         NTSTATUS status;
6887
6888         /* In parameters */
6889         r.in.server_unc = _server_unc;
6890
6891         status = dcerpc_srvsvc_NetRemoteTOD_r(h, mem_ctx, &r);
6892         if (!NT_STATUS_IS_OK(status)) {
6893                 return status;
6894         }
6895
6896         /* Return variables */
6897         *_info = *r.out.info;
6898
6899         /* Return result */
6900         *result = r.out.result;
6901
6902         return NT_STATUS_OK;
6903 }
6904
6905 struct dcerpc_srvsvc_NetSetServiceBits_r_state {
6906         TALLOC_CTX *out_mem_ctx;
6907 };
6908
6909 static void dcerpc_srvsvc_NetSetServiceBits_r_done(struct tevent_req *subreq);
6910
6911 struct tevent_req *dcerpc_srvsvc_NetSetServiceBits_r_send(TALLOC_CTX *mem_ctx,
6912         struct tevent_context *ev,
6913         struct dcerpc_binding_handle *h,
6914         struct srvsvc_NetSetServiceBits *r)
6915 {
6916         struct tevent_req *req;
6917         struct dcerpc_srvsvc_NetSetServiceBits_r_state *state;
6918         struct tevent_req *subreq;
6919
6920         req = tevent_req_create(mem_ctx, &state,
6921                                 struct dcerpc_srvsvc_NetSetServiceBits_r_state);
6922         if (req == NULL) {
6923                 return NULL;
6924         }
6925
6926         state->out_mem_ctx = NULL;
6927         subreq = dcerpc_binding_handle_call_send(state, ev, h,
6928                         NULL, &ndr_table_srvsvc,
6929                         NDR_SRVSVC_NETSETSERVICEBITS, state, r);
6930         if (tevent_req_nomem(subreq, req)) {
6931                 return tevent_req_post(req, ev);
6932         }
6933         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetSetServiceBits_r_done, req);
6934
6935         return req;
6936 }
6937
6938 static void dcerpc_srvsvc_NetSetServiceBits_r_done(struct tevent_req *subreq)
6939 {
6940         struct tevent_req *req =
6941                 tevent_req_callback_data(subreq,
6942                 struct tevent_req);
6943         NTSTATUS status;
6944
6945         status = dcerpc_binding_handle_call_recv(subreq);
6946         if (!NT_STATUS_IS_OK(status)) {
6947                 tevent_req_nterror(req, status);
6948                 return;
6949         }
6950
6951         tevent_req_done(req);
6952 }
6953
6954 NTSTATUS dcerpc_srvsvc_NetSetServiceBits_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
6955 {
6956         struct dcerpc_srvsvc_NetSetServiceBits_r_state *state =
6957                 tevent_req_data(req,
6958                 struct dcerpc_srvsvc_NetSetServiceBits_r_state);
6959         NTSTATUS status;
6960
6961         if (tevent_req_is_nterror(req, &status)) {
6962                 tevent_req_received(req);
6963                 return status;
6964         }
6965
6966         talloc_steal(mem_ctx, state->out_mem_ctx);
6967
6968         tevent_req_received(req);
6969         return NT_STATUS_OK;
6970 }
6971
6972 NTSTATUS dcerpc_srvsvc_NetSetServiceBits_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetSetServiceBits *r)
6973 {
6974         NTSTATUS status;
6975
6976         status = dcerpc_binding_handle_call(h,
6977                         NULL, &ndr_table_srvsvc,
6978                         NDR_SRVSVC_NETSETSERVICEBITS, mem_ctx, r);
6979
6980         return status;
6981 }
6982
6983 NTSTATUS dcerpc_srvsvc_NetSetServiceBits_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetSetServiceBits *r)
6984 {
6985         NTSTATUS status;
6986
6987         status = dcerpc_srvsvc_NetSetServiceBits_r(p->binding_handle, mem_ctx, r);
6988
6989         if (NT_STATUS_IS_RPC(status)) {
6990                 status = NT_STATUS_NET_WRITE_FAULT;
6991         }
6992
6993         return status;
6994 }
6995
6996 struct dcerpc_srvsvc_NetSetServiceBits_state {
6997         struct srvsvc_NetSetServiceBits orig;
6998         struct srvsvc_NetSetServiceBits tmp;
6999         TALLOC_CTX *out_mem_ctx;
7000 };
7001
7002 static void dcerpc_srvsvc_NetSetServiceBits_done(struct tevent_req *subreq);
7003
7004 struct tevent_req *dcerpc_srvsvc_NetSetServiceBits_send(TALLOC_CTX *mem_ctx,
7005                                                         struct tevent_context *ev,
7006                                                         struct dcerpc_binding_handle *h,
7007                                                         const char *_server_unc /* [in] [unique,charset(UTF16)] */,
7008                                                         const char *_transport /* [in] [unique,charset(UTF16)] */,
7009                                                         uint32_t _servicebits /* [in]  */,
7010                                                         uint32_t _updateimmediately /* [in]  */)
7011 {
7012         struct tevent_req *req;
7013         struct dcerpc_srvsvc_NetSetServiceBits_state *state;
7014         struct tevent_req *subreq;
7015
7016         req = tevent_req_create(mem_ctx, &state,
7017                                 struct dcerpc_srvsvc_NetSetServiceBits_state);
7018         if (req == NULL) {
7019                 return NULL;
7020         }
7021         state->out_mem_ctx = NULL;
7022
7023         /* In parameters */
7024         state->orig.in.server_unc = _server_unc;
7025         state->orig.in.transport = _transport;
7026         state->orig.in.servicebits = _servicebits;
7027         state->orig.in.updateimmediately = _updateimmediately;
7028
7029         /* Out parameters */
7030
7031         /* Result */
7032         ZERO_STRUCT(state->orig.out.result);
7033
7034         /* make a temporary copy, that we pass to the dispatch function */
7035         state->tmp = state->orig;
7036
7037         subreq = dcerpc_srvsvc_NetSetServiceBits_r_send(state, ev, h, &state->tmp);
7038         if (tevent_req_nomem(subreq, req)) {
7039                 return tevent_req_post(req, ev);
7040         }
7041         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetSetServiceBits_done, req);
7042         return req;
7043 }
7044
7045 static void dcerpc_srvsvc_NetSetServiceBits_done(struct tevent_req *subreq)
7046 {
7047         struct tevent_req *req = tevent_req_callback_data(
7048                 subreq, struct tevent_req);
7049         struct dcerpc_srvsvc_NetSetServiceBits_state *state = tevent_req_data(
7050                 req, struct dcerpc_srvsvc_NetSetServiceBits_state);
7051         NTSTATUS status;
7052         TALLOC_CTX *mem_ctx;
7053
7054         if (state->out_mem_ctx) {
7055                 mem_ctx = state->out_mem_ctx;
7056         } else {
7057                 mem_ctx = state;
7058         }
7059
7060         status = dcerpc_srvsvc_NetSetServiceBits_r_recv(subreq, mem_ctx);
7061         TALLOC_FREE(subreq);
7062         if (!NT_STATUS_IS_OK(status)) {
7063                 tevent_req_nterror(req, status);
7064                 return;
7065         }
7066
7067         /* Copy out parameters */
7068
7069         /* Copy result */
7070         state->orig.out.result = state->tmp.out.result;
7071
7072         /* Reset temporary structure */
7073         ZERO_STRUCT(state->tmp);
7074
7075         tevent_req_done(req);
7076 }
7077
7078 NTSTATUS dcerpc_srvsvc_NetSetServiceBits_recv(struct tevent_req *req,
7079                                               TALLOC_CTX *mem_ctx,
7080                                               WERROR *result)
7081 {
7082         struct dcerpc_srvsvc_NetSetServiceBits_state *state = tevent_req_data(
7083                 req, struct dcerpc_srvsvc_NetSetServiceBits_state);
7084         NTSTATUS status;
7085
7086         if (tevent_req_is_nterror(req, &status)) {
7087                 tevent_req_received(req);
7088                 return status;
7089         }
7090
7091         /* Steal possible out parameters to the callers context */
7092         talloc_steal(mem_ctx, state->out_mem_ctx);
7093
7094         /* Return result */
7095         *result = state->orig.out.result;
7096
7097         tevent_req_received(req);
7098         return NT_STATUS_OK;
7099 }
7100
7101 NTSTATUS dcerpc_srvsvc_NetSetServiceBits(struct dcerpc_binding_handle *h,
7102                                          TALLOC_CTX *mem_ctx,
7103                                          const char *_server_unc /* [in] [unique,charset(UTF16)] */,
7104                                          const char *_transport /* [in] [unique,charset(UTF16)] */,
7105                                          uint32_t _servicebits /* [in]  */,
7106                                          uint32_t _updateimmediately /* [in]  */,
7107                                          WERROR *result)
7108 {
7109         struct srvsvc_NetSetServiceBits r;
7110         NTSTATUS status;
7111
7112         /* In parameters */
7113         r.in.server_unc = _server_unc;
7114         r.in.transport = _transport;
7115         r.in.servicebits = _servicebits;
7116         r.in.updateimmediately = _updateimmediately;
7117
7118         status = dcerpc_srvsvc_NetSetServiceBits_r(h, mem_ctx, &r);
7119         if (!NT_STATUS_IS_OK(status)) {
7120                 return status;
7121         }
7122
7123         /* Return variables */
7124
7125         /* Return result */
7126         *result = r.out.result;
7127
7128         return NT_STATUS_OK;
7129 }
7130
7131 struct dcerpc_srvsvc_NetPathType_r_state {
7132         TALLOC_CTX *out_mem_ctx;
7133 };
7134
7135 static void dcerpc_srvsvc_NetPathType_r_done(struct tevent_req *subreq);
7136
7137 struct tevent_req *dcerpc_srvsvc_NetPathType_r_send(TALLOC_CTX *mem_ctx,
7138         struct tevent_context *ev,
7139         struct dcerpc_binding_handle *h,
7140         struct srvsvc_NetPathType *r)
7141 {
7142         struct tevent_req *req;
7143         struct dcerpc_srvsvc_NetPathType_r_state *state;
7144         struct tevent_req *subreq;
7145
7146         req = tevent_req_create(mem_ctx, &state,
7147                                 struct dcerpc_srvsvc_NetPathType_r_state);
7148         if (req == NULL) {
7149                 return NULL;
7150         }
7151
7152         state->out_mem_ctx = talloc_new(state);
7153         if (tevent_req_nomem(state->out_mem_ctx, req)) {
7154                 return tevent_req_post(req, ev);
7155         }
7156
7157         subreq = dcerpc_binding_handle_call_send(state, ev, h,
7158                         NULL, &ndr_table_srvsvc,
7159                         NDR_SRVSVC_NETPATHTYPE, state->out_mem_ctx, r);
7160         if (tevent_req_nomem(subreq, req)) {
7161                 return tevent_req_post(req, ev);
7162         }
7163         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetPathType_r_done, req);
7164
7165         return req;
7166 }
7167
7168 static void dcerpc_srvsvc_NetPathType_r_done(struct tevent_req *subreq)
7169 {
7170         struct tevent_req *req =
7171                 tevent_req_callback_data(subreq,
7172                 struct tevent_req);
7173         NTSTATUS status;
7174
7175         status = dcerpc_binding_handle_call_recv(subreq);
7176         if (!NT_STATUS_IS_OK(status)) {
7177                 tevent_req_nterror(req, status);
7178                 return;
7179         }
7180
7181         tevent_req_done(req);
7182 }
7183
7184 NTSTATUS dcerpc_srvsvc_NetPathType_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
7185 {
7186         struct dcerpc_srvsvc_NetPathType_r_state *state =
7187                 tevent_req_data(req,
7188                 struct dcerpc_srvsvc_NetPathType_r_state);
7189         NTSTATUS status;
7190
7191         if (tevent_req_is_nterror(req, &status)) {
7192                 tevent_req_received(req);
7193                 return status;
7194         }
7195
7196         talloc_steal(mem_ctx, state->out_mem_ctx);
7197
7198         tevent_req_received(req);
7199         return NT_STATUS_OK;
7200 }
7201
7202 NTSTATUS dcerpc_srvsvc_NetPathType_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetPathType *r)
7203 {
7204         NTSTATUS status;
7205
7206         status = dcerpc_binding_handle_call(h,
7207                         NULL, &ndr_table_srvsvc,
7208                         NDR_SRVSVC_NETPATHTYPE, mem_ctx, r);
7209
7210         return status;
7211 }
7212
7213 NTSTATUS dcerpc_srvsvc_NetPathType_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetPathType *r)
7214 {
7215         NTSTATUS status;
7216
7217         status = dcerpc_srvsvc_NetPathType_r(p->binding_handle, mem_ctx, r);
7218
7219         if (NT_STATUS_IS_RPC(status)) {
7220                 status = NT_STATUS_NET_WRITE_FAULT;
7221         }
7222
7223         return status;
7224 }
7225
7226 struct dcerpc_srvsvc_NetPathType_state {
7227         struct srvsvc_NetPathType orig;
7228         struct srvsvc_NetPathType tmp;
7229         TALLOC_CTX *out_mem_ctx;
7230 };
7231
7232 static void dcerpc_srvsvc_NetPathType_done(struct tevent_req *subreq);
7233
7234 struct tevent_req *dcerpc_srvsvc_NetPathType_send(TALLOC_CTX *mem_ctx,
7235                                                   struct tevent_context *ev,
7236                                                   struct dcerpc_binding_handle *h,
7237                                                   const char *_server_unc /* [in] [unique,charset(UTF16)] */,
7238                                                   const char *_path /* [in] [charset(UTF16)] */,
7239                                                   uint32_t _pathflags /* [in]  */,
7240                                                   uint32_t *_pathtype /* [out] [ref] */)
7241 {
7242         struct tevent_req *req;
7243         struct dcerpc_srvsvc_NetPathType_state *state;
7244         struct tevent_req *subreq;
7245
7246         req = tevent_req_create(mem_ctx, &state,
7247                                 struct dcerpc_srvsvc_NetPathType_state);
7248         if (req == NULL) {
7249                 return NULL;
7250         }
7251         state->out_mem_ctx = NULL;
7252
7253         /* In parameters */
7254         state->orig.in.server_unc = _server_unc;
7255         state->orig.in.path = _path;
7256         state->orig.in.pathflags = _pathflags;
7257
7258         /* Out parameters */
7259         state->orig.out.pathtype = _pathtype;
7260
7261         /* Result */
7262         ZERO_STRUCT(state->orig.out.result);
7263
7264         state->out_mem_ctx = talloc_named_const(state, 0,
7265                              "dcerpc_srvsvc_NetPathType_out_memory");
7266         if (tevent_req_nomem(state->out_mem_ctx, req)) {
7267                 return tevent_req_post(req, ev);
7268         }
7269
7270         /* make a temporary copy, that we pass to the dispatch function */
7271         state->tmp = state->orig;
7272
7273         subreq = dcerpc_srvsvc_NetPathType_r_send(state, ev, h, &state->tmp);
7274         if (tevent_req_nomem(subreq, req)) {
7275                 return tevent_req_post(req, ev);
7276         }
7277         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetPathType_done, req);
7278         return req;
7279 }
7280
7281 static void dcerpc_srvsvc_NetPathType_done(struct tevent_req *subreq)
7282 {
7283         struct tevent_req *req = tevent_req_callback_data(
7284                 subreq, struct tevent_req);
7285         struct dcerpc_srvsvc_NetPathType_state *state = tevent_req_data(
7286                 req, struct dcerpc_srvsvc_NetPathType_state);
7287         NTSTATUS status;
7288         TALLOC_CTX *mem_ctx;
7289
7290         if (state->out_mem_ctx) {
7291                 mem_ctx = state->out_mem_ctx;
7292         } else {
7293                 mem_ctx = state;
7294         }
7295
7296         status = dcerpc_srvsvc_NetPathType_r_recv(subreq, mem_ctx);
7297         TALLOC_FREE(subreq);
7298         if (!NT_STATUS_IS_OK(status)) {
7299                 tevent_req_nterror(req, status);
7300                 return;
7301         }
7302
7303         /* Copy out parameters */
7304         *state->orig.out.pathtype = *state->tmp.out.pathtype;
7305
7306         /* Copy result */
7307         state->orig.out.result = state->tmp.out.result;
7308
7309         /* Reset temporary structure */
7310         ZERO_STRUCT(state->tmp);
7311
7312         tevent_req_done(req);
7313 }
7314
7315 NTSTATUS dcerpc_srvsvc_NetPathType_recv(struct tevent_req *req,
7316                                         TALLOC_CTX *mem_ctx,
7317                                         WERROR *result)
7318 {
7319         struct dcerpc_srvsvc_NetPathType_state *state = tevent_req_data(
7320                 req, struct dcerpc_srvsvc_NetPathType_state);
7321         NTSTATUS status;
7322
7323         if (tevent_req_is_nterror(req, &status)) {
7324                 tevent_req_received(req);
7325                 return status;
7326         }
7327
7328         /* Steal possible out parameters to the callers context */
7329         talloc_steal(mem_ctx, state->out_mem_ctx);
7330
7331         /* Return result */
7332         *result = state->orig.out.result;
7333
7334         tevent_req_received(req);
7335         return NT_STATUS_OK;
7336 }
7337
7338 NTSTATUS dcerpc_srvsvc_NetPathType(struct dcerpc_binding_handle *h,
7339                                    TALLOC_CTX *mem_ctx,
7340                                    const char *_server_unc /* [in] [unique,charset(UTF16)] */,
7341                                    const char *_path /* [in] [charset(UTF16)] */,
7342                                    uint32_t _pathflags /* [in]  */,
7343                                    uint32_t *_pathtype /* [out] [ref] */,
7344                                    WERROR *result)
7345 {
7346         struct srvsvc_NetPathType r;
7347         NTSTATUS status;
7348
7349         /* In parameters */
7350         r.in.server_unc = _server_unc;
7351         r.in.path = _path;
7352         r.in.pathflags = _pathflags;
7353
7354         status = dcerpc_srvsvc_NetPathType_r(h, mem_ctx, &r);
7355         if (!NT_STATUS_IS_OK(status)) {
7356                 return status;
7357         }
7358
7359         /* Return variables */
7360         *_pathtype = *r.out.pathtype;
7361
7362         /* Return result */
7363         *result = r.out.result;
7364
7365         return NT_STATUS_OK;
7366 }
7367
7368 struct dcerpc_srvsvc_NetPathCanonicalize_r_state {
7369         TALLOC_CTX *out_mem_ctx;
7370 };
7371
7372 static void dcerpc_srvsvc_NetPathCanonicalize_r_done(struct tevent_req *subreq);
7373
7374 struct tevent_req *dcerpc_srvsvc_NetPathCanonicalize_r_send(TALLOC_CTX *mem_ctx,
7375         struct tevent_context *ev,
7376         struct dcerpc_binding_handle *h,
7377         struct srvsvc_NetPathCanonicalize *r)
7378 {
7379         struct tevent_req *req;
7380         struct dcerpc_srvsvc_NetPathCanonicalize_r_state *state;
7381         struct tevent_req *subreq;
7382
7383         req = tevent_req_create(mem_ctx, &state,
7384                                 struct dcerpc_srvsvc_NetPathCanonicalize_r_state);
7385         if (req == NULL) {
7386                 return NULL;
7387         }
7388
7389         state->out_mem_ctx = talloc_new(state);
7390         if (tevent_req_nomem(state->out_mem_ctx, req)) {
7391                 return tevent_req_post(req, ev);
7392         }
7393
7394         subreq = dcerpc_binding_handle_call_send(state, ev, h,
7395                         NULL, &ndr_table_srvsvc,
7396                         NDR_SRVSVC_NETPATHCANONICALIZE, state->out_mem_ctx, r);
7397         if (tevent_req_nomem(subreq, req)) {
7398                 return tevent_req_post(req, ev);
7399         }
7400         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetPathCanonicalize_r_done, req);
7401
7402         return req;
7403 }
7404
7405 static void dcerpc_srvsvc_NetPathCanonicalize_r_done(struct tevent_req *subreq)
7406 {
7407         struct tevent_req *req =
7408                 tevent_req_callback_data(subreq,
7409                 struct tevent_req);
7410         NTSTATUS status;
7411
7412         status = dcerpc_binding_handle_call_recv(subreq);
7413         if (!NT_STATUS_IS_OK(status)) {
7414                 tevent_req_nterror(req, status);
7415                 return;
7416         }
7417
7418         tevent_req_done(req);
7419 }
7420
7421 NTSTATUS dcerpc_srvsvc_NetPathCanonicalize_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
7422 {
7423         struct dcerpc_srvsvc_NetPathCanonicalize_r_state *state =
7424                 tevent_req_data(req,
7425                 struct dcerpc_srvsvc_NetPathCanonicalize_r_state);
7426         NTSTATUS status;
7427
7428         if (tevent_req_is_nterror(req, &status)) {
7429                 tevent_req_received(req);
7430                 return status;
7431         }
7432
7433         talloc_steal(mem_ctx, state->out_mem_ctx);
7434
7435         tevent_req_received(req);
7436         return NT_STATUS_OK;
7437 }
7438
7439 NTSTATUS dcerpc_srvsvc_NetPathCanonicalize_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetPathCanonicalize *r)
7440 {
7441         NTSTATUS status;
7442
7443         status = dcerpc_binding_handle_call(h,
7444                         NULL, &ndr_table_srvsvc,
7445                         NDR_SRVSVC_NETPATHCANONICALIZE, mem_ctx, r);
7446
7447         return status;
7448 }
7449
7450 NTSTATUS dcerpc_srvsvc_NetPathCanonicalize_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetPathCanonicalize *r)
7451 {
7452         NTSTATUS status;
7453
7454         status = dcerpc_srvsvc_NetPathCanonicalize_r(p->binding_handle, mem_ctx, r);
7455
7456         if (NT_STATUS_IS_RPC(status)) {
7457                 status = NT_STATUS_NET_WRITE_FAULT;
7458         }
7459
7460         return status;
7461 }
7462
7463 struct dcerpc_srvsvc_NetPathCanonicalize_state {
7464         struct srvsvc_NetPathCanonicalize orig;
7465         struct srvsvc_NetPathCanonicalize tmp;
7466         TALLOC_CTX *out_mem_ctx;
7467 };
7468
7469 static void dcerpc_srvsvc_NetPathCanonicalize_done(struct tevent_req *subreq);
7470
7471 struct tevent_req *dcerpc_srvsvc_NetPathCanonicalize_send(TALLOC_CTX *mem_ctx,
7472                                                           struct tevent_context *ev,
7473                                                           struct dcerpc_binding_handle *h,
7474                                                           const char *_server_unc /* [in] [unique,charset(UTF16)] */,
7475                                                           const char *_path /* [in] [charset(UTF16)] */,
7476                                                           uint8_t *_can_path /* [out] [size_is(maxbuf)] */,
7477                                                           uint32_t _maxbuf /* [in]  */,
7478                                                           const char *_prefix /* [in] [charset(UTF16)] */,
7479                                                           uint32_t *_pathtype /* [in,out] [ref] */,
7480                                                           uint32_t _pathflags /* [in]  */)
7481 {
7482         struct tevent_req *req;
7483         struct dcerpc_srvsvc_NetPathCanonicalize_state *state;
7484         struct tevent_req *subreq;
7485
7486         req = tevent_req_create(mem_ctx, &state,
7487                                 struct dcerpc_srvsvc_NetPathCanonicalize_state);
7488         if (req == NULL) {
7489                 return NULL;
7490         }
7491         state->out_mem_ctx = NULL;
7492
7493         /* In parameters */
7494         state->orig.in.server_unc = _server_unc;
7495         state->orig.in.path = _path;
7496         state->orig.in.maxbuf = _maxbuf;
7497         state->orig.in.prefix = _prefix;
7498         state->orig.in.pathtype = _pathtype;
7499         state->orig.in.pathflags = _pathflags;
7500
7501         /* Out parameters */
7502         state->orig.out.can_path = _can_path;
7503         state->orig.out.pathtype = _pathtype;
7504
7505         /* Result */
7506         ZERO_STRUCT(state->orig.out.result);
7507
7508         state->out_mem_ctx = talloc_named_const(state, 0,
7509                              "dcerpc_srvsvc_NetPathCanonicalize_out_memory");
7510         if (tevent_req_nomem(state->out_mem_ctx, req)) {
7511                 return tevent_req_post(req, ev);
7512         }
7513
7514         /* make a temporary copy, that we pass to the dispatch function */
7515         state->tmp = state->orig;
7516
7517         subreq = dcerpc_srvsvc_NetPathCanonicalize_r_send(state, ev, h, &state->tmp);
7518         if (tevent_req_nomem(subreq, req)) {
7519                 return tevent_req_post(req, ev);
7520         }
7521         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetPathCanonicalize_done, req);
7522         return req;
7523 }
7524
7525 static void dcerpc_srvsvc_NetPathCanonicalize_done(struct tevent_req *subreq)
7526 {
7527         struct tevent_req *req = tevent_req_callback_data(
7528                 subreq, struct tevent_req);
7529         struct dcerpc_srvsvc_NetPathCanonicalize_state *state = tevent_req_data(
7530                 req, struct dcerpc_srvsvc_NetPathCanonicalize_state);
7531         NTSTATUS status;
7532         TALLOC_CTX *mem_ctx;
7533
7534         if (state->out_mem_ctx) {
7535                 mem_ctx = state->out_mem_ctx;
7536         } else {
7537                 mem_ctx = state;
7538         }
7539
7540         status = dcerpc_srvsvc_NetPathCanonicalize_r_recv(subreq, mem_ctx);
7541         TALLOC_FREE(subreq);
7542         if (!NT_STATUS_IS_OK(status)) {
7543                 tevent_req_nterror(req, status);
7544                 return;
7545         }
7546
7547         /* Copy out parameters */
7548         {
7549                 size_t _copy_len_can_path;
7550                 _copy_len_can_path = state->tmp.in.maxbuf;
7551                 memcpy(state->orig.out.can_path, state->tmp.out.can_path, _copy_len_can_path * sizeof(*state->orig.out.can_path));
7552         }
7553         *state->orig.out.pathtype = *state->tmp.out.pathtype;
7554
7555         /* Copy result */
7556         state->orig.out.result = state->tmp.out.result;
7557
7558         /* Reset temporary structure */
7559         ZERO_STRUCT(state->tmp);
7560
7561         tevent_req_done(req);
7562 }
7563
7564 NTSTATUS dcerpc_srvsvc_NetPathCanonicalize_recv(struct tevent_req *req,
7565                                                 TALLOC_CTX *mem_ctx,
7566                                                 WERROR *result)
7567 {
7568         struct dcerpc_srvsvc_NetPathCanonicalize_state *state = tevent_req_data(
7569                 req, struct dcerpc_srvsvc_NetPathCanonicalize_state);
7570         NTSTATUS status;
7571
7572         if (tevent_req_is_nterror(req, &status)) {
7573                 tevent_req_received(req);
7574                 return status;
7575         }
7576
7577         /* Steal possible out parameters to the callers context */
7578         talloc_steal(mem_ctx, state->out_mem_ctx);
7579
7580         /* Return result */
7581         *result = state->orig.out.result;
7582
7583         tevent_req_received(req);
7584         return NT_STATUS_OK;
7585 }
7586
7587 NTSTATUS dcerpc_srvsvc_NetPathCanonicalize(struct dcerpc_binding_handle *h,
7588                                            TALLOC_CTX *mem_ctx,
7589                                            const char *_server_unc /* [in] [unique,charset(UTF16)] */,
7590                                            const char *_path /* [in] [charset(UTF16)] */,
7591                                            uint8_t *_can_path /* [out] [size_is(maxbuf)] */,
7592                                            uint32_t _maxbuf /* [in]  */,
7593                                            const char *_prefix /* [in] [charset(UTF16)] */,
7594                                            uint32_t *_pathtype /* [in,out] [ref] */,
7595                                            uint32_t _pathflags /* [in]  */,
7596                                            WERROR *result)
7597 {
7598         struct srvsvc_NetPathCanonicalize r;
7599         NTSTATUS status;
7600
7601         /* In parameters */
7602         r.in.server_unc = _server_unc;
7603         r.in.path = _path;
7604         r.in.maxbuf = _maxbuf;
7605         r.in.prefix = _prefix;
7606         r.in.pathtype = _pathtype;
7607         r.in.pathflags = _pathflags;
7608
7609         status = dcerpc_srvsvc_NetPathCanonicalize_r(h, mem_ctx, &r);
7610         if (!NT_STATUS_IS_OK(status)) {
7611                 return status;
7612         }
7613
7614         /* Return variables */
7615         {
7616                 size_t _copy_len_can_path;
7617                 _copy_len_can_path = r.in.maxbuf;
7618                 memcpy(_can_path, r.out.can_path, _copy_len_can_path * sizeof(*_can_path));
7619         }
7620         *_pathtype = *r.out.pathtype;
7621
7622         /* Return result */
7623         *result = r.out.result;
7624
7625         return NT_STATUS_OK;
7626 }
7627
7628 struct dcerpc_srvsvc_NetPathCompare_r_state {
7629         TALLOC_CTX *out_mem_ctx;
7630 };
7631
7632 static void dcerpc_srvsvc_NetPathCompare_r_done(struct tevent_req *subreq);
7633
7634 struct tevent_req *dcerpc_srvsvc_NetPathCompare_r_send(TALLOC_CTX *mem_ctx,
7635         struct tevent_context *ev,
7636         struct dcerpc_binding_handle *h,
7637         struct srvsvc_NetPathCompare *r)
7638 {
7639         struct tevent_req *req;
7640         struct dcerpc_srvsvc_NetPathCompare_r_state *state;
7641         struct tevent_req *subreq;
7642
7643         req = tevent_req_create(mem_ctx, &state,
7644                                 struct dcerpc_srvsvc_NetPathCompare_r_state);
7645         if (req == NULL) {
7646                 return NULL;
7647         }
7648
7649         state->out_mem_ctx = NULL;
7650         subreq = dcerpc_binding_handle_call_send(state, ev, h,
7651                         NULL, &ndr_table_srvsvc,
7652                         NDR_SRVSVC_NETPATHCOMPARE, state, r);
7653         if (tevent_req_nomem(subreq, req)) {
7654                 return tevent_req_post(req, ev);
7655         }
7656         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetPathCompare_r_done, req);
7657
7658         return req;
7659 }
7660
7661 static void dcerpc_srvsvc_NetPathCompare_r_done(struct tevent_req *subreq)
7662 {
7663         struct tevent_req *req =
7664                 tevent_req_callback_data(subreq,
7665                 struct tevent_req);
7666         NTSTATUS status;
7667
7668         status = dcerpc_binding_handle_call_recv(subreq);
7669         if (!NT_STATUS_IS_OK(status)) {
7670                 tevent_req_nterror(req, status);
7671                 return;
7672         }
7673
7674         tevent_req_done(req);
7675 }
7676
7677 NTSTATUS dcerpc_srvsvc_NetPathCompare_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
7678 {
7679         struct dcerpc_srvsvc_NetPathCompare_r_state *state =
7680                 tevent_req_data(req,
7681                 struct dcerpc_srvsvc_NetPathCompare_r_state);
7682         NTSTATUS status;
7683
7684         if (tevent_req_is_nterror(req, &status)) {
7685                 tevent_req_received(req);
7686                 return status;
7687         }
7688
7689         talloc_steal(mem_ctx, state->out_mem_ctx);
7690
7691         tevent_req_received(req);
7692         return NT_STATUS_OK;
7693 }
7694
7695 NTSTATUS dcerpc_srvsvc_NetPathCompare_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetPathCompare *r)
7696 {
7697         NTSTATUS status;
7698
7699         status = dcerpc_binding_handle_call(h,
7700                         NULL, &ndr_table_srvsvc,
7701                         NDR_SRVSVC_NETPATHCOMPARE, mem_ctx, r);
7702
7703         return status;
7704 }
7705
7706 NTSTATUS dcerpc_srvsvc_NetPathCompare_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetPathCompare *r)
7707 {
7708         NTSTATUS status;
7709
7710         status = dcerpc_srvsvc_NetPathCompare_r(p->binding_handle, mem_ctx, r);
7711
7712         if (NT_STATUS_IS_RPC(status)) {
7713                 status = NT_STATUS_NET_WRITE_FAULT;
7714         }
7715
7716         return status;
7717 }
7718
7719 struct dcerpc_srvsvc_NetPathCompare_state {
7720         struct srvsvc_NetPathCompare orig;
7721         struct srvsvc_NetPathCompare tmp;
7722         TALLOC_CTX *out_mem_ctx;
7723 };
7724
7725 static void dcerpc_srvsvc_NetPathCompare_done(struct tevent_req *subreq);
7726
7727 struct tevent_req *dcerpc_srvsvc_NetPathCompare_send(TALLOC_CTX *mem_ctx,
7728                                                      struct tevent_context *ev,
7729                                                      struct dcerpc_binding_handle *h,
7730                                                      const char *_server_unc /* [in] [unique,charset(UTF16)] */,
7731                                                      const char *_path1 /* [in] [charset(UTF16)] */,
7732                                                      const char *_path2 /* [in] [charset(UTF16)] */,
7733                                                      uint32_t _pathtype /* [in]  */,
7734                                                      uint32_t _pathflags /* [in]  */)
7735 {
7736         struct tevent_req *req;
7737         struct dcerpc_srvsvc_NetPathCompare_state *state;
7738         struct tevent_req *subreq;
7739
7740         req = tevent_req_create(mem_ctx, &state,
7741                                 struct dcerpc_srvsvc_NetPathCompare_state);
7742         if (req == NULL) {
7743                 return NULL;
7744         }
7745         state->out_mem_ctx = NULL;
7746
7747         /* In parameters */
7748         state->orig.in.server_unc = _server_unc;
7749         state->orig.in.path1 = _path1;
7750         state->orig.in.path2 = _path2;
7751         state->orig.in.pathtype = _pathtype;
7752         state->orig.in.pathflags = _pathflags;
7753
7754         /* Out parameters */
7755
7756         /* Result */
7757         ZERO_STRUCT(state->orig.out.result);
7758
7759         /* make a temporary copy, that we pass to the dispatch function */
7760         state->tmp = state->orig;
7761
7762         subreq = dcerpc_srvsvc_NetPathCompare_r_send(state, ev, h, &state->tmp);
7763         if (tevent_req_nomem(subreq, req)) {
7764                 return tevent_req_post(req, ev);
7765         }
7766         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetPathCompare_done, req);
7767         return req;
7768 }
7769
7770 static void dcerpc_srvsvc_NetPathCompare_done(struct tevent_req *subreq)
7771 {
7772         struct tevent_req *req = tevent_req_callback_data(
7773                 subreq, struct tevent_req);
7774         struct dcerpc_srvsvc_NetPathCompare_state *state = tevent_req_data(
7775                 req, struct dcerpc_srvsvc_NetPathCompare_state);
7776         NTSTATUS status;
7777         TALLOC_CTX *mem_ctx;
7778
7779         if (state->out_mem_ctx) {
7780                 mem_ctx = state->out_mem_ctx;
7781         } else {
7782                 mem_ctx = state;
7783         }
7784
7785         status = dcerpc_srvsvc_NetPathCompare_r_recv(subreq, mem_ctx);
7786         TALLOC_FREE(subreq);
7787         if (!NT_STATUS_IS_OK(status)) {
7788                 tevent_req_nterror(req, status);
7789                 return;
7790         }
7791
7792         /* Copy out parameters */
7793
7794         /* Copy result */
7795         state->orig.out.result = state->tmp.out.result;
7796
7797         /* Reset temporary structure */
7798         ZERO_STRUCT(state->tmp);
7799
7800         tevent_req_done(req);
7801 }
7802
7803 NTSTATUS dcerpc_srvsvc_NetPathCompare_recv(struct tevent_req *req,
7804                                            TALLOC_CTX *mem_ctx,
7805                                            WERROR *result)
7806 {
7807         struct dcerpc_srvsvc_NetPathCompare_state *state = tevent_req_data(
7808                 req, struct dcerpc_srvsvc_NetPathCompare_state);
7809         NTSTATUS status;
7810
7811         if (tevent_req_is_nterror(req, &status)) {
7812                 tevent_req_received(req);
7813                 return status;
7814         }
7815
7816         /* Steal possible out parameters to the callers context */
7817         talloc_steal(mem_ctx, state->out_mem_ctx);
7818
7819         /* Return result */
7820         *result = state->orig.out.result;
7821
7822         tevent_req_received(req);
7823         return NT_STATUS_OK;
7824 }
7825
7826 NTSTATUS dcerpc_srvsvc_NetPathCompare(struct dcerpc_binding_handle *h,
7827                                       TALLOC_CTX *mem_ctx,
7828                                       const char *_server_unc /* [in] [unique,charset(UTF16)] */,
7829                                       const char *_path1 /* [in] [charset(UTF16)] */,
7830                                       const char *_path2 /* [in] [charset(UTF16)] */,
7831                                       uint32_t _pathtype /* [in]  */,
7832                                       uint32_t _pathflags /* [in]  */,
7833                                       WERROR *result)
7834 {
7835         struct srvsvc_NetPathCompare r;
7836         NTSTATUS status;
7837
7838         /* In parameters */
7839         r.in.server_unc = _server_unc;
7840         r.in.path1 = _path1;
7841         r.in.path2 = _path2;
7842         r.in.pathtype = _pathtype;
7843         r.in.pathflags = _pathflags;
7844
7845         status = dcerpc_srvsvc_NetPathCompare_r(h, mem_ctx, &r);
7846         if (!NT_STATUS_IS_OK(status)) {
7847                 return status;
7848         }
7849
7850         /* Return variables */
7851
7852         /* Return result */
7853         *result = r.out.result;
7854
7855         return NT_STATUS_OK;
7856 }
7857
7858 struct dcerpc_srvsvc_NetNameValidate_r_state {
7859         TALLOC_CTX *out_mem_ctx;
7860 };
7861
7862 static void dcerpc_srvsvc_NetNameValidate_r_done(struct tevent_req *subreq);
7863
7864 struct tevent_req *dcerpc_srvsvc_NetNameValidate_r_send(TALLOC_CTX *mem_ctx,
7865         struct tevent_context *ev,
7866         struct dcerpc_binding_handle *h,
7867         struct srvsvc_NetNameValidate *r)
7868 {
7869         struct tevent_req *req;
7870         struct dcerpc_srvsvc_NetNameValidate_r_state *state;
7871         struct tevent_req *subreq;
7872
7873         req = tevent_req_create(mem_ctx, &state,
7874                                 struct dcerpc_srvsvc_NetNameValidate_r_state);
7875         if (req == NULL) {
7876                 return NULL;
7877         }
7878
7879         state->out_mem_ctx = NULL;
7880         subreq = dcerpc_binding_handle_call_send(state, ev, h,
7881                         NULL, &ndr_table_srvsvc,
7882                         NDR_SRVSVC_NETNAMEVALIDATE, state, r);
7883         if (tevent_req_nomem(subreq, req)) {
7884                 return tevent_req_post(req, ev);
7885         }
7886         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetNameValidate_r_done, req);
7887
7888         return req;
7889 }
7890
7891 static void dcerpc_srvsvc_NetNameValidate_r_done(struct tevent_req *subreq)
7892 {
7893         struct tevent_req *req =
7894                 tevent_req_callback_data(subreq,
7895                 struct tevent_req);
7896         NTSTATUS status;
7897
7898         status = dcerpc_binding_handle_call_recv(subreq);
7899         if (!NT_STATUS_IS_OK(status)) {
7900                 tevent_req_nterror(req, status);
7901                 return;
7902         }
7903
7904         tevent_req_done(req);
7905 }
7906
7907 NTSTATUS dcerpc_srvsvc_NetNameValidate_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
7908 {
7909         struct dcerpc_srvsvc_NetNameValidate_r_state *state =
7910                 tevent_req_data(req,
7911                 struct dcerpc_srvsvc_NetNameValidate_r_state);
7912         NTSTATUS status;
7913
7914         if (tevent_req_is_nterror(req, &status)) {
7915                 tevent_req_received(req);
7916                 return status;
7917         }
7918
7919         talloc_steal(mem_ctx, state->out_mem_ctx);
7920
7921         tevent_req_received(req);
7922         return NT_STATUS_OK;
7923 }
7924
7925 NTSTATUS dcerpc_srvsvc_NetNameValidate_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetNameValidate *r)
7926 {
7927         NTSTATUS status;
7928
7929         status = dcerpc_binding_handle_call(h,
7930                         NULL, &ndr_table_srvsvc,
7931                         NDR_SRVSVC_NETNAMEVALIDATE, mem_ctx, r);
7932
7933         return status;
7934 }
7935
7936 NTSTATUS dcerpc_srvsvc_NetNameValidate_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetNameValidate *r)
7937 {
7938         NTSTATUS status;
7939
7940         status = dcerpc_srvsvc_NetNameValidate_r(p->binding_handle, mem_ctx, r);
7941
7942         if (NT_STATUS_IS_RPC(status)) {
7943                 status = NT_STATUS_NET_WRITE_FAULT;
7944         }
7945
7946         return status;
7947 }
7948
7949 struct dcerpc_srvsvc_NetNameValidate_state {
7950         struct srvsvc_NetNameValidate orig;
7951         struct srvsvc_NetNameValidate tmp;
7952         TALLOC_CTX *out_mem_ctx;
7953 };
7954
7955 static void dcerpc_srvsvc_NetNameValidate_done(struct tevent_req *subreq);
7956
7957 struct tevent_req *dcerpc_srvsvc_NetNameValidate_send(TALLOC_CTX *mem_ctx,
7958                                                       struct tevent_context *ev,
7959                                                       struct dcerpc_binding_handle *h,
7960                                                       const char *_server_unc /* [in] [unique,charset(UTF16)] */,
7961                                                       const char *_name /* [in] [charset(UTF16)] */,
7962                                                       uint32_t _name_type /* [in]  */,
7963                                                       uint32_t _flags /* [in]  */)
7964 {
7965         struct tevent_req *req;
7966         struct dcerpc_srvsvc_NetNameValidate_state *state;
7967         struct tevent_req *subreq;
7968
7969         req = tevent_req_create(mem_ctx, &state,
7970                                 struct dcerpc_srvsvc_NetNameValidate_state);
7971         if (req == NULL) {
7972                 return NULL;
7973         }
7974         state->out_mem_ctx = NULL;
7975
7976         /* In parameters */
7977         state->orig.in.server_unc = _server_unc;
7978         state->orig.in.name = _name;
7979         state->orig.in.name_type = _name_type;
7980         state->orig.in.flags = _flags;
7981
7982         /* Out parameters */
7983
7984         /* Result */
7985         ZERO_STRUCT(state->orig.out.result);
7986
7987         /* make a temporary copy, that we pass to the dispatch function */
7988         state->tmp = state->orig;
7989
7990         subreq = dcerpc_srvsvc_NetNameValidate_r_send(state, ev, h, &state->tmp);
7991         if (tevent_req_nomem(subreq, req)) {
7992                 return tevent_req_post(req, ev);
7993         }
7994         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetNameValidate_done, req);
7995         return req;
7996 }
7997
7998 static void dcerpc_srvsvc_NetNameValidate_done(struct tevent_req *subreq)
7999 {
8000         struct tevent_req *req = tevent_req_callback_data(
8001                 subreq, struct tevent_req);
8002         struct dcerpc_srvsvc_NetNameValidate_state *state = tevent_req_data(
8003                 req, struct dcerpc_srvsvc_NetNameValidate_state);
8004         NTSTATUS status;
8005         TALLOC_CTX *mem_ctx;
8006
8007         if (state->out_mem_ctx) {
8008                 mem_ctx = state->out_mem_ctx;
8009         } else {
8010                 mem_ctx = state;
8011         }
8012
8013         status = dcerpc_srvsvc_NetNameValidate_r_recv(subreq, mem_ctx);
8014         TALLOC_FREE(subreq);
8015         if (!NT_STATUS_IS_OK(status)) {
8016                 tevent_req_nterror(req, status);
8017                 return;
8018         }
8019
8020         /* Copy out parameters */
8021
8022         /* Copy result */
8023         state->orig.out.result = state->tmp.out.result;
8024
8025         /* Reset temporary structure */
8026         ZERO_STRUCT(state->tmp);
8027
8028         tevent_req_done(req);
8029 }
8030
8031 NTSTATUS dcerpc_srvsvc_NetNameValidate_recv(struct tevent_req *req,
8032                                             TALLOC_CTX *mem_ctx,
8033                                             WERROR *result)
8034 {
8035         struct dcerpc_srvsvc_NetNameValidate_state *state = tevent_req_data(
8036                 req, struct dcerpc_srvsvc_NetNameValidate_state);
8037         NTSTATUS status;
8038
8039         if (tevent_req_is_nterror(req, &status)) {
8040                 tevent_req_received(req);
8041                 return status;
8042         }
8043
8044         /* Steal possible out parameters to the callers context */
8045         talloc_steal(mem_ctx, state->out_mem_ctx);
8046
8047         /* Return result */
8048         *result = state->orig.out.result;
8049
8050         tevent_req_received(req);
8051         return NT_STATUS_OK;
8052 }
8053
8054 NTSTATUS dcerpc_srvsvc_NetNameValidate(struct dcerpc_binding_handle *h,
8055                                        TALLOC_CTX *mem_ctx,
8056                                        const char *_server_unc /* [in] [unique,charset(UTF16)] */,
8057                                        const char *_name /* [in] [charset(UTF16)] */,
8058                                        uint32_t _name_type /* [in]  */,
8059                                        uint32_t _flags /* [in]  */,
8060                                        WERROR *result)
8061 {
8062         struct srvsvc_NetNameValidate r;
8063         NTSTATUS status;
8064
8065         /* In parameters */
8066         r.in.server_unc = _server_unc;
8067         r.in.name = _name;
8068         r.in.name_type = _name_type;
8069         r.in.flags = _flags;
8070
8071         status = dcerpc_srvsvc_NetNameValidate_r(h, mem_ctx, &r);
8072         if (!NT_STATUS_IS_OK(status)) {
8073                 return status;
8074         }
8075
8076         /* Return variables */
8077
8078         /* Return result */
8079         *result = r.out.result;
8080
8081         return NT_STATUS_OK;
8082 }
8083
8084 struct dcerpc_srvsvc_NetPRNameCompare_r_state {
8085         TALLOC_CTX *out_mem_ctx;
8086 };
8087
8088 static void dcerpc_srvsvc_NetPRNameCompare_r_done(struct tevent_req *subreq);
8089
8090 struct tevent_req *dcerpc_srvsvc_NetPRNameCompare_r_send(TALLOC_CTX *mem_ctx,
8091         struct tevent_context *ev,
8092         struct dcerpc_binding_handle *h,
8093         struct srvsvc_NetPRNameCompare *r)
8094 {
8095         struct tevent_req *req;
8096         struct dcerpc_srvsvc_NetPRNameCompare_r_state *state;
8097         struct tevent_req *subreq;
8098
8099         req = tevent_req_create(mem_ctx, &state,
8100                                 struct dcerpc_srvsvc_NetPRNameCompare_r_state);
8101         if (req == NULL) {
8102                 return NULL;
8103         }
8104
8105         state->out_mem_ctx = NULL;
8106         subreq = dcerpc_binding_handle_call_send(state, ev, h,
8107                         NULL, &ndr_table_srvsvc,
8108                         NDR_SRVSVC_NETPRNAMECOMPARE, state, r);
8109         if (tevent_req_nomem(subreq, req)) {
8110                 return tevent_req_post(req, ev);
8111         }
8112         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetPRNameCompare_r_done, req);
8113
8114         return req;
8115 }
8116
8117 static void dcerpc_srvsvc_NetPRNameCompare_r_done(struct tevent_req *subreq)
8118 {
8119         struct tevent_req *req =
8120                 tevent_req_callback_data(subreq,
8121                 struct tevent_req);
8122         NTSTATUS status;
8123
8124         status = dcerpc_binding_handle_call_recv(subreq);
8125         if (!NT_STATUS_IS_OK(status)) {
8126                 tevent_req_nterror(req, status);
8127                 return;
8128         }
8129
8130         tevent_req_done(req);
8131 }
8132
8133 NTSTATUS dcerpc_srvsvc_NetPRNameCompare_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
8134 {
8135         struct dcerpc_srvsvc_NetPRNameCompare_r_state *state =
8136                 tevent_req_data(req,
8137                 struct dcerpc_srvsvc_NetPRNameCompare_r_state);
8138         NTSTATUS status;
8139
8140         if (tevent_req_is_nterror(req, &status)) {
8141                 tevent_req_received(req);
8142                 return status;
8143         }
8144
8145         talloc_steal(mem_ctx, state->out_mem_ctx);
8146
8147         tevent_req_received(req);
8148         return NT_STATUS_OK;
8149 }
8150
8151 NTSTATUS dcerpc_srvsvc_NetPRNameCompare_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetPRNameCompare *r)
8152 {
8153         NTSTATUS status;
8154
8155         status = dcerpc_binding_handle_call(h,
8156                         NULL, &ndr_table_srvsvc,
8157                         NDR_SRVSVC_NETPRNAMECOMPARE, mem_ctx, r);
8158
8159         return status;
8160 }
8161
8162 NTSTATUS dcerpc_srvsvc_NetPRNameCompare_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetPRNameCompare *r)
8163 {
8164         NTSTATUS status;
8165
8166         status = dcerpc_srvsvc_NetPRNameCompare_r(p->binding_handle, mem_ctx, r);
8167
8168         if (NT_STATUS_IS_RPC(status)) {
8169                 status = NT_STATUS_NET_WRITE_FAULT;
8170         }
8171
8172         return status;
8173 }
8174
8175 struct dcerpc_srvsvc_NetPRNameCompare_state {
8176         struct srvsvc_NetPRNameCompare orig;
8177         struct srvsvc_NetPRNameCompare tmp;
8178         TALLOC_CTX *out_mem_ctx;
8179 };
8180
8181 static void dcerpc_srvsvc_NetPRNameCompare_done(struct tevent_req *subreq);
8182
8183 struct tevent_req *dcerpc_srvsvc_NetPRNameCompare_send(TALLOC_CTX *mem_ctx,
8184                                                        struct tevent_context *ev,
8185                                                        struct dcerpc_binding_handle *h,
8186                                                        const char *_server_unc /* [in] [unique,charset(UTF16)] */,
8187                                                        const char *_name1 /* [in] [charset(UTF16)] */,
8188                                                        const char *_name2 /* [in] [charset(UTF16)] */,
8189                                                        uint32_t _name_type /* [in]  */,
8190                                                        uint32_t _flags /* [in]  */)
8191 {
8192         struct tevent_req *req;
8193         struct dcerpc_srvsvc_NetPRNameCompare_state *state;
8194         struct tevent_req *subreq;
8195
8196         req = tevent_req_create(mem_ctx, &state,
8197                                 struct dcerpc_srvsvc_NetPRNameCompare_state);
8198         if (req == NULL) {
8199                 return NULL;
8200         }
8201         state->out_mem_ctx = NULL;
8202
8203         /* In parameters */
8204         state->orig.in.server_unc = _server_unc;
8205         state->orig.in.name1 = _name1;
8206         state->orig.in.name2 = _name2;
8207         state->orig.in.name_type = _name_type;
8208         state->orig.in.flags = _flags;
8209
8210         /* Out parameters */
8211
8212         /* Result */
8213         ZERO_STRUCT(state->orig.out.result);
8214
8215         /* make a temporary copy, that we pass to the dispatch function */
8216         state->tmp = state->orig;
8217
8218         subreq = dcerpc_srvsvc_NetPRNameCompare_r_send(state, ev, h, &state->tmp);
8219         if (tevent_req_nomem(subreq, req)) {
8220                 return tevent_req_post(req, ev);
8221         }
8222         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetPRNameCompare_done, req);
8223         return req;
8224 }
8225
8226 static void dcerpc_srvsvc_NetPRNameCompare_done(struct tevent_req *subreq)
8227 {
8228         struct tevent_req *req = tevent_req_callback_data(
8229                 subreq, struct tevent_req);
8230         struct dcerpc_srvsvc_NetPRNameCompare_state *state = tevent_req_data(
8231                 req, struct dcerpc_srvsvc_NetPRNameCompare_state);
8232         NTSTATUS status;
8233         TALLOC_CTX *mem_ctx;
8234
8235         if (state->out_mem_ctx) {
8236                 mem_ctx = state->out_mem_ctx;
8237         } else {
8238                 mem_ctx = state;
8239         }
8240
8241         status = dcerpc_srvsvc_NetPRNameCompare_r_recv(subreq, mem_ctx);
8242         TALLOC_FREE(subreq);
8243         if (!NT_STATUS_IS_OK(status)) {
8244                 tevent_req_nterror(req, status);
8245                 return;
8246         }
8247
8248         /* Copy out parameters */
8249
8250         /* Copy result */
8251         state->orig.out.result = state->tmp.out.result;
8252
8253         /* Reset temporary structure */
8254         ZERO_STRUCT(state->tmp);
8255
8256         tevent_req_done(req);
8257 }
8258
8259 NTSTATUS dcerpc_srvsvc_NetPRNameCompare_recv(struct tevent_req *req,
8260                                              TALLOC_CTX *mem_ctx,
8261                                              WERROR *result)
8262 {
8263         struct dcerpc_srvsvc_NetPRNameCompare_state *state = tevent_req_data(
8264                 req, struct dcerpc_srvsvc_NetPRNameCompare_state);
8265         NTSTATUS status;
8266
8267         if (tevent_req_is_nterror(req, &status)) {
8268                 tevent_req_received(req);
8269                 return status;
8270         }
8271
8272         /* Steal possible out parameters to the callers context */
8273         talloc_steal(mem_ctx, state->out_mem_ctx);
8274
8275         /* Return result */
8276         *result = state->orig.out.result;
8277
8278         tevent_req_received(req);
8279         return NT_STATUS_OK;
8280 }
8281
8282 NTSTATUS dcerpc_srvsvc_NetPRNameCompare(struct dcerpc_binding_handle *h,
8283                                         TALLOC_CTX *mem_ctx,
8284                                         const char *_server_unc /* [in] [unique,charset(UTF16)] */,
8285                                         const char *_name1 /* [in] [charset(UTF16)] */,
8286                                         const char *_name2 /* [in] [charset(UTF16)] */,
8287                                         uint32_t _name_type /* [in]  */,
8288                                         uint32_t _flags /* [in]  */,
8289                                         WERROR *result)
8290 {
8291         struct srvsvc_NetPRNameCompare r;
8292         NTSTATUS status;
8293
8294         /* In parameters */
8295         r.in.server_unc = _server_unc;
8296         r.in.name1 = _name1;
8297         r.in.name2 = _name2;
8298         r.in.name_type = _name_type;
8299         r.in.flags = _flags;
8300
8301         status = dcerpc_srvsvc_NetPRNameCompare_r(h, mem_ctx, &r);
8302         if (!NT_STATUS_IS_OK(status)) {
8303                 return status;
8304         }
8305
8306         /* Return variables */
8307
8308         /* Return result */
8309         *result = r.out.result;
8310
8311         return NT_STATUS_OK;
8312 }
8313
8314 struct dcerpc_srvsvc_NetShareEnum_r_state {
8315         TALLOC_CTX *out_mem_ctx;
8316 };
8317
8318 static void dcerpc_srvsvc_NetShareEnum_r_done(struct tevent_req *subreq);
8319
8320 struct tevent_req *dcerpc_srvsvc_NetShareEnum_r_send(TALLOC_CTX *mem_ctx,
8321         struct tevent_context *ev,
8322         struct dcerpc_binding_handle *h,
8323         struct srvsvc_NetShareEnum *r)
8324 {
8325         struct tevent_req *req;
8326         struct dcerpc_srvsvc_NetShareEnum_r_state *state;
8327         struct tevent_req *subreq;
8328
8329         req = tevent_req_create(mem_ctx, &state,
8330                                 struct dcerpc_srvsvc_NetShareEnum_r_state);
8331         if (req == NULL) {
8332                 return NULL;
8333         }
8334
8335         state->out_mem_ctx = talloc_new(state);
8336         if (tevent_req_nomem(state->out_mem_ctx, req)) {
8337                 return tevent_req_post(req, ev);
8338         }
8339
8340         subreq = dcerpc_binding_handle_call_send(state, ev, h,
8341                         NULL, &ndr_table_srvsvc,
8342                         NDR_SRVSVC_NETSHAREENUM, state->out_mem_ctx, r);
8343         if (tevent_req_nomem(subreq, req)) {
8344                 return tevent_req_post(req, ev);
8345         }
8346         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetShareEnum_r_done, req);
8347
8348         return req;
8349 }
8350
8351 static void dcerpc_srvsvc_NetShareEnum_r_done(struct tevent_req *subreq)
8352 {
8353         struct tevent_req *req =
8354                 tevent_req_callback_data(subreq,
8355                 struct tevent_req);
8356         NTSTATUS status;
8357
8358         status = dcerpc_binding_handle_call_recv(subreq);
8359         if (!NT_STATUS_IS_OK(status)) {
8360                 tevent_req_nterror(req, status);
8361                 return;
8362         }
8363
8364         tevent_req_done(req);
8365 }
8366
8367 NTSTATUS dcerpc_srvsvc_NetShareEnum_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
8368 {
8369         struct dcerpc_srvsvc_NetShareEnum_r_state *state =
8370                 tevent_req_data(req,
8371                 struct dcerpc_srvsvc_NetShareEnum_r_state);
8372         NTSTATUS status;
8373
8374         if (tevent_req_is_nterror(req, &status)) {
8375                 tevent_req_received(req);
8376                 return status;
8377         }
8378
8379         talloc_steal(mem_ctx, state->out_mem_ctx);
8380
8381         tevent_req_received(req);
8382         return NT_STATUS_OK;
8383 }
8384
8385 NTSTATUS dcerpc_srvsvc_NetShareEnum_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetShareEnum *r)
8386 {
8387         NTSTATUS status;
8388
8389         status = dcerpc_binding_handle_call(h,
8390                         NULL, &ndr_table_srvsvc,
8391                         NDR_SRVSVC_NETSHAREENUM, mem_ctx, r);
8392
8393         return status;
8394 }
8395
8396 NTSTATUS dcerpc_srvsvc_NetShareEnum_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetShareEnum *r)
8397 {
8398         NTSTATUS status;
8399
8400         status = dcerpc_srvsvc_NetShareEnum_r(p->binding_handle, mem_ctx, r);
8401
8402         if (NT_STATUS_IS_RPC(status)) {
8403                 status = NT_STATUS_NET_WRITE_FAULT;
8404         }
8405
8406         return status;
8407 }
8408
8409 struct dcerpc_srvsvc_NetShareEnum_state {
8410         struct srvsvc_NetShareEnum orig;
8411         struct srvsvc_NetShareEnum tmp;
8412         TALLOC_CTX *out_mem_ctx;
8413 };
8414
8415 static void dcerpc_srvsvc_NetShareEnum_done(struct tevent_req *subreq);
8416
8417 struct tevent_req *dcerpc_srvsvc_NetShareEnum_send(TALLOC_CTX *mem_ctx,
8418                                                    struct tevent_context *ev,
8419                                                    struct dcerpc_binding_handle *h,
8420                                                    const char *_server_unc /* [in] [unique,charset(UTF16)] */,
8421                                                    struct srvsvc_NetShareInfoCtr *_info_ctr /* [in,out] [ref] */,
8422                                                    uint32_t _max_buffer /* [in]  */,
8423                                                    uint32_t *_totalentries /* [out] [ref] */,
8424                                                    uint32_t *_resume_handle /* [in,out] [unique] */)
8425 {
8426         struct tevent_req *req;
8427         struct dcerpc_srvsvc_NetShareEnum_state *state;
8428         struct tevent_req *subreq;
8429
8430         req = tevent_req_create(mem_ctx, &state,
8431                                 struct dcerpc_srvsvc_NetShareEnum_state);
8432         if (req == NULL) {
8433                 return NULL;
8434         }
8435         state->out_mem_ctx = NULL;
8436
8437         /* In parameters */
8438         state->orig.in.server_unc = _server_unc;
8439         state->orig.in.info_ctr = _info_ctr;
8440         state->orig.in.max_buffer = _max_buffer;
8441         state->orig.in.resume_handle = _resume_handle;
8442
8443         /* Out parameters */
8444         state->orig.out.info_ctr = _info_ctr;
8445         state->orig.out.totalentries = _totalentries;
8446         state->orig.out.resume_handle = _resume_handle;
8447
8448         /* Result */
8449         ZERO_STRUCT(state->orig.out.result);
8450
8451         state->out_mem_ctx = talloc_named_const(state, 0,
8452                              "dcerpc_srvsvc_NetShareEnum_out_memory");
8453         if (tevent_req_nomem(state->out_mem_ctx, req)) {
8454                 return tevent_req_post(req, ev);
8455         }
8456
8457         /* make a temporary copy, that we pass to the dispatch function */
8458         state->tmp = state->orig;
8459
8460         subreq = dcerpc_srvsvc_NetShareEnum_r_send(state, ev, h, &state->tmp);
8461         if (tevent_req_nomem(subreq, req)) {
8462                 return tevent_req_post(req, ev);
8463         }
8464         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetShareEnum_done, req);
8465         return req;
8466 }
8467
8468 static void dcerpc_srvsvc_NetShareEnum_done(struct tevent_req *subreq)
8469 {
8470         struct tevent_req *req = tevent_req_callback_data(
8471                 subreq, struct tevent_req);
8472         struct dcerpc_srvsvc_NetShareEnum_state *state = tevent_req_data(
8473                 req, struct dcerpc_srvsvc_NetShareEnum_state);
8474         NTSTATUS status;
8475         TALLOC_CTX *mem_ctx;
8476
8477         if (state->out_mem_ctx) {
8478                 mem_ctx = state->out_mem_ctx;
8479         } else {
8480                 mem_ctx = state;
8481         }
8482
8483         status = dcerpc_srvsvc_NetShareEnum_r_recv(subreq, mem_ctx);
8484         TALLOC_FREE(subreq);
8485         if (!NT_STATUS_IS_OK(status)) {
8486                 tevent_req_nterror(req, status);
8487                 return;
8488         }
8489
8490         /* Copy out parameters */
8491         *state->orig.out.info_ctr = *state->tmp.out.info_ctr;
8492         *state->orig.out.totalentries = *state->tmp.out.totalentries;
8493         if (state->orig.out.resume_handle && state->tmp.out.resume_handle) {
8494                 *state->orig.out.resume_handle = *state->tmp.out.resume_handle;
8495         }
8496
8497         /* Copy result */
8498         state->orig.out.result = state->tmp.out.result;
8499
8500         /* Reset temporary structure */
8501         ZERO_STRUCT(state->tmp);
8502
8503         tevent_req_done(req);
8504 }
8505
8506 NTSTATUS dcerpc_srvsvc_NetShareEnum_recv(struct tevent_req *req,
8507                                          TALLOC_CTX *mem_ctx,
8508                                          WERROR *result)
8509 {
8510         struct dcerpc_srvsvc_NetShareEnum_state *state = tevent_req_data(
8511                 req, struct dcerpc_srvsvc_NetShareEnum_state);
8512         NTSTATUS status;
8513
8514         if (tevent_req_is_nterror(req, &status)) {
8515                 tevent_req_received(req);
8516                 return status;
8517         }
8518
8519         /* Steal possible out parameters to the callers context */
8520         talloc_steal(mem_ctx, state->out_mem_ctx);
8521
8522         /* Return result */
8523         *result = state->orig.out.result;
8524
8525         tevent_req_received(req);
8526         return NT_STATUS_OK;
8527 }
8528
8529 NTSTATUS dcerpc_srvsvc_NetShareEnum(struct dcerpc_binding_handle *h,
8530                                     TALLOC_CTX *mem_ctx,
8531                                     const char *_server_unc /* [in] [unique,charset(UTF16)] */,
8532                                     struct srvsvc_NetShareInfoCtr *_info_ctr /* [in,out] [ref] */,
8533                                     uint32_t _max_buffer /* [in]  */,
8534                                     uint32_t *_totalentries /* [out] [ref] */,
8535                                     uint32_t *_resume_handle /* [in,out] [unique] */,
8536                                     WERROR *result)
8537 {
8538         struct srvsvc_NetShareEnum r;
8539         NTSTATUS status;
8540
8541         /* In parameters */
8542         r.in.server_unc = _server_unc;
8543         r.in.info_ctr = _info_ctr;
8544         r.in.max_buffer = _max_buffer;
8545         r.in.resume_handle = _resume_handle;
8546
8547         status = dcerpc_srvsvc_NetShareEnum_r(h, mem_ctx, &r);
8548         if (!NT_STATUS_IS_OK(status)) {
8549                 return status;
8550         }
8551
8552         /* Return variables */
8553         *_info_ctr = *r.out.info_ctr;
8554         *_totalentries = *r.out.totalentries;
8555         if (_resume_handle && r.out.resume_handle) {
8556                 *_resume_handle = *r.out.resume_handle;
8557         }
8558
8559         /* Return result */
8560         *result = r.out.result;
8561
8562         return NT_STATUS_OK;
8563 }
8564
8565 struct dcerpc_srvsvc_NetShareDelStart_r_state {
8566         TALLOC_CTX *out_mem_ctx;
8567 };
8568
8569 static void dcerpc_srvsvc_NetShareDelStart_r_done(struct tevent_req *subreq);
8570
8571 struct tevent_req *dcerpc_srvsvc_NetShareDelStart_r_send(TALLOC_CTX *mem_ctx,
8572         struct tevent_context *ev,
8573         struct dcerpc_binding_handle *h,
8574         struct srvsvc_NetShareDelStart *r)
8575 {
8576         struct tevent_req *req;
8577         struct dcerpc_srvsvc_NetShareDelStart_r_state *state;
8578         struct tevent_req *subreq;
8579
8580         req = tevent_req_create(mem_ctx, &state,
8581                                 struct dcerpc_srvsvc_NetShareDelStart_r_state);
8582         if (req == NULL) {
8583                 return NULL;
8584         }
8585
8586         state->out_mem_ctx = talloc_new(state);
8587         if (tevent_req_nomem(state->out_mem_ctx, req)) {
8588                 return tevent_req_post(req, ev);
8589         }
8590
8591         subreq = dcerpc_binding_handle_call_send(state, ev, h,
8592                         NULL, &ndr_table_srvsvc,
8593                         NDR_SRVSVC_NETSHAREDELSTART, state->out_mem_ctx, r);
8594         if (tevent_req_nomem(subreq, req)) {
8595                 return tevent_req_post(req, ev);
8596         }
8597         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetShareDelStart_r_done, req);
8598
8599         return req;
8600 }
8601
8602 static void dcerpc_srvsvc_NetShareDelStart_r_done(struct tevent_req *subreq)
8603 {
8604         struct tevent_req *req =
8605                 tevent_req_callback_data(subreq,
8606                 struct tevent_req);
8607         NTSTATUS status;
8608
8609         status = dcerpc_binding_handle_call_recv(subreq);
8610         if (!NT_STATUS_IS_OK(status)) {
8611                 tevent_req_nterror(req, status);
8612                 return;
8613         }
8614
8615         tevent_req_done(req);
8616 }
8617
8618 NTSTATUS dcerpc_srvsvc_NetShareDelStart_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
8619 {
8620         struct dcerpc_srvsvc_NetShareDelStart_r_state *state =
8621                 tevent_req_data(req,
8622                 struct dcerpc_srvsvc_NetShareDelStart_r_state);
8623         NTSTATUS status;
8624
8625         if (tevent_req_is_nterror(req, &status)) {
8626                 tevent_req_received(req);
8627                 return status;
8628         }
8629
8630         talloc_steal(mem_ctx, state->out_mem_ctx);
8631
8632         tevent_req_received(req);
8633         return NT_STATUS_OK;
8634 }
8635
8636 NTSTATUS dcerpc_srvsvc_NetShareDelStart_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetShareDelStart *r)
8637 {
8638         NTSTATUS status;
8639
8640         status = dcerpc_binding_handle_call(h,
8641                         NULL, &ndr_table_srvsvc,
8642                         NDR_SRVSVC_NETSHAREDELSTART, mem_ctx, r);
8643
8644         return status;
8645 }
8646
8647 NTSTATUS dcerpc_srvsvc_NetShareDelStart_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetShareDelStart *r)
8648 {
8649         NTSTATUS status;
8650
8651         status = dcerpc_srvsvc_NetShareDelStart_r(p->binding_handle, mem_ctx, r);
8652
8653         if (NT_STATUS_IS_RPC(status)) {
8654                 status = NT_STATUS_NET_WRITE_FAULT;
8655         }
8656
8657         return status;
8658 }
8659
8660 struct dcerpc_srvsvc_NetShareDelStart_state {
8661         struct srvsvc_NetShareDelStart orig;
8662         struct srvsvc_NetShareDelStart tmp;
8663         TALLOC_CTX *out_mem_ctx;
8664 };
8665
8666 static void dcerpc_srvsvc_NetShareDelStart_done(struct tevent_req *subreq);
8667
8668 struct tevent_req *dcerpc_srvsvc_NetShareDelStart_send(TALLOC_CTX *mem_ctx,
8669                                                        struct tevent_context *ev,
8670                                                        struct dcerpc_binding_handle *h,
8671                                                        const char *_server_unc /* [in] [unique,charset(UTF16)] */,
8672                                                        const char *_share /* [in] [charset(UTF16)] */,
8673                                                        uint32_t _reserved /* [in]  */,
8674                                                        struct policy_handle *_hnd /* [out] [unique] */)
8675 {
8676         struct tevent_req *req;
8677         struct dcerpc_srvsvc_NetShareDelStart_state *state;
8678         struct tevent_req *subreq;
8679
8680         req = tevent_req_create(mem_ctx, &state,
8681                                 struct dcerpc_srvsvc_NetShareDelStart_state);
8682         if (req == NULL) {
8683                 return NULL;
8684         }
8685         state->out_mem_ctx = NULL;
8686
8687         /* In parameters */
8688         state->orig.in.server_unc = _server_unc;
8689         state->orig.in.share = _share;
8690         state->orig.in.reserved = _reserved;
8691
8692         /* Out parameters */
8693         state->orig.out.hnd = _hnd;
8694
8695         /* Result */
8696         ZERO_STRUCT(state->orig.out.result);
8697
8698         state->out_mem_ctx = talloc_named_const(state, 0,
8699                              "dcerpc_srvsvc_NetShareDelStart_out_memory");
8700         if (tevent_req_nomem(state->out_mem_ctx, req)) {
8701                 return tevent_req_post(req, ev);
8702         }
8703
8704         /* make a temporary copy, that we pass to the dispatch function */
8705         state->tmp = state->orig;
8706
8707         subreq = dcerpc_srvsvc_NetShareDelStart_r_send(state, ev, h, &state->tmp);
8708         if (tevent_req_nomem(subreq, req)) {
8709                 return tevent_req_post(req, ev);
8710         }
8711         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetShareDelStart_done, req);
8712         return req;
8713 }
8714
8715 static void dcerpc_srvsvc_NetShareDelStart_done(struct tevent_req *subreq)
8716 {
8717         struct tevent_req *req = tevent_req_callback_data(
8718                 subreq, struct tevent_req);
8719         struct dcerpc_srvsvc_NetShareDelStart_state *state = tevent_req_data(
8720                 req, struct dcerpc_srvsvc_NetShareDelStart_state);
8721         NTSTATUS status;
8722         TALLOC_CTX *mem_ctx;
8723
8724         if (state->out_mem_ctx) {
8725                 mem_ctx = state->out_mem_ctx;
8726         } else {
8727                 mem_ctx = state;
8728         }
8729
8730         status = dcerpc_srvsvc_NetShareDelStart_r_recv(subreq, mem_ctx);
8731         TALLOC_FREE(subreq);
8732         if (!NT_STATUS_IS_OK(status)) {
8733                 tevent_req_nterror(req, status);
8734                 return;
8735         }
8736
8737         /* Copy out parameters */
8738         if (state->orig.out.hnd && state->tmp.out.hnd) {
8739                 *state->orig.out.hnd = *state->tmp.out.hnd;
8740         }
8741
8742         /* Copy result */
8743         state->orig.out.result = state->tmp.out.result;
8744
8745         /* Reset temporary structure */
8746         ZERO_STRUCT(state->tmp);
8747
8748         tevent_req_done(req);
8749 }
8750
8751 NTSTATUS dcerpc_srvsvc_NetShareDelStart_recv(struct tevent_req *req,
8752                                              TALLOC_CTX *mem_ctx,
8753                                              WERROR *result)
8754 {
8755         struct dcerpc_srvsvc_NetShareDelStart_state *state = tevent_req_data(
8756                 req, struct dcerpc_srvsvc_NetShareDelStart_state);
8757         NTSTATUS status;
8758
8759         if (tevent_req_is_nterror(req, &status)) {
8760                 tevent_req_received(req);
8761                 return status;
8762         }
8763
8764         /* Steal possible out parameters to the callers context */
8765         talloc_steal(mem_ctx, state->out_mem_ctx);
8766
8767         /* Return result */
8768         *result = state->orig.out.result;
8769
8770         tevent_req_received(req);
8771         return NT_STATUS_OK;
8772 }
8773
8774 NTSTATUS dcerpc_srvsvc_NetShareDelStart(struct dcerpc_binding_handle *h,
8775                                         TALLOC_CTX *mem_ctx,
8776                                         const char *_server_unc /* [in] [unique,charset(UTF16)] */,
8777                                         const char *_share /* [in] [charset(UTF16)] */,
8778                                         uint32_t _reserved /* [in]  */,
8779                                         struct policy_handle *_hnd /* [out] [unique] */,
8780                                         WERROR *result)
8781 {
8782         struct srvsvc_NetShareDelStart r;
8783         NTSTATUS status;
8784
8785         /* In parameters */
8786         r.in.server_unc = _server_unc;
8787         r.in.share = _share;
8788         r.in.reserved = _reserved;
8789
8790         status = dcerpc_srvsvc_NetShareDelStart_r(h, mem_ctx, &r);
8791         if (!NT_STATUS_IS_OK(status)) {
8792                 return status;
8793         }
8794
8795         /* Return variables */
8796         if (_hnd && r.out.hnd) {
8797                 *_hnd = *r.out.hnd;
8798         }
8799
8800         /* Return result */
8801         *result = r.out.result;
8802
8803         return NT_STATUS_OK;
8804 }
8805
8806 struct dcerpc_srvsvc_NetShareDelCommit_r_state {
8807         TALLOC_CTX *out_mem_ctx;
8808 };
8809
8810 static void dcerpc_srvsvc_NetShareDelCommit_r_done(struct tevent_req *subreq);
8811
8812 struct tevent_req *dcerpc_srvsvc_NetShareDelCommit_r_send(TALLOC_CTX *mem_ctx,
8813         struct tevent_context *ev,
8814         struct dcerpc_binding_handle *h,
8815         struct srvsvc_NetShareDelCommit *r)
8816 {
8817         struct tevent_req *req;
8818         struct dcerpc_srvsvc_NetShareDelCommit_r_state *state;
8819         struct tevent_req *subreq;
8820
8821         req = tevent_req_create(mem_ctx, &state,
8822                                 struct dcerpc_srvsvc_NetShareDelCommit_r_state);
8823         if (req == NULL) {
8824                 return NULL;
8825         }
8826
8827         state->out_mem_ctx = talloc_new(state);
8828         if (tevent_req_nomem(state->out_mem_ctx, req)) {
8829                 return tevent_req_post(req, ev);
8830         }
8831
8832         subreq = dcerpc_binding_handle_call_send(state, ev, h,
8833                         NULL, &ndr_table_srvsvc,
8834                         NDR_SRVSVC_NETSHAREDELCOMMIT, state->out_mem_ctx, r);
8835         if (tevent_req_nomem(subreq, req)) {
8836                 return tevent_req_post(req, ev);
8837         }
8838         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetShareDelCommit_r_done, req);
8839
8840         return req;
8841 }
8842
8843 static void dcerpc_srvsvc_NetShareDelCommit_r_done(struct tevent_req *subreq)
8844 {
8845         struct tevent_req *req =
8846                 tevent_req_callback_data(subreq,
8847                 struct tevent_req);
8848         NTSTATUS status;
8849
8850         status = dcerpc_binding_handle_call_recv(subreq);
8851         if (!NT_STATUS_IS_OK(status)) {
8852                 tevent_req_nterror(req, status);
8853                 return;
8854         }
8855
8856         tevent_req_done(req);
8857 }
8858
8859 NTSTATUS dcerpc_srvsvc_NetShareDelCommit_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
8860 {
8861         struct dcerpc_srvsvc_NetShareDelCommit_r_state *state =
8862                 tevent_req_data(req,
8863                 struct dcerpc_srvsvc_NetShareDelCommit_r_state);
8864         NTSTATUS status;
8865
8866         if (tevent_req_is_nterror(req, &status)) {
8867                 tevent_req_received(req);
8868                 return status;
8869         }
8870
8871         talloc_steal(mem_ctx, state->out_mem_ctx);
8872
8873         tevent_req_received(req);
8874         return NT_STATUS_OK;
8875 }
8876
8877 NTSTATUS dcerpc_srvsvc_NetShareDelCommit_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetShareDelCommit *r)
8878 {
8879         NTSTATUS status;
8880
8881         status = dcerpc_binding_handle_call(h,
8882                         NULL, &ndr_table_srvsvc,
8883                         NDR_SRVSVC_NETSHAREDELCOMMIT, mem_ctx, r);
8884
8885         return status;
8886 }
8887
8888 NTSTATUS dcerpc_srvsvc_NetShareDelCommit_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetShareDelCommit *r)
8889 {
8890         NTSTATUS status;
8891
8892         status = dcerpc_srvsvc_NetShareDelCommit_r(p->binding_handle, mem_ctx, r);
8893
8894         if (NT_STATUS_IS_RPC(status)) {
8895                 status = NT_STATUS_NET_WRITE_FAULT;
8896         }
8897
8898         return status;
8899 }
8900
8901 struct dcerpc_srvsvc_NetShareDelCommit_state {
8902         struct srvsvc_NetShareDelCommit orig;
8903         struct srvsvc_NetShareDelCommit tmp;
8904         TALLOC_CTX *out_mem_ctx;
8905 };
8906
8907 static void dcerpc_srvsvc_NetShareDelCommit_done(struct tevent_req *subreq);
8908
8909 struct tevent_req *dcerpc_srvsvc_NetShareDelCommit_send(TALLOC_CTX *mem_ctx,
8910                                                         struct tevent_context *ev,
8911                                                         struct dcerpc_binding_handle *h,
8912                                                         struct policy_handle *_hnd /* [in,out] [unique] */)
8913 {
8914         struct tevent_req *req;
8915         struct dcerpc_srvsvc_NetShareDelCommit_state *state;
8916         struct tevent_req *subreq;
8917
8918         req = tevent_req_create(mem_ctx, &state,
8919                                 struct dcerpc_srvsvc_NetShareDelCommit_state);
8920         if (req == NULL) {
8921                 return NULL;
8922         }
8923         state->out_mem_ctx = NULL;
8924
8925         /* In parameters */
8926         state->orig.in.hnd = _hnd;
8927
8928         /* Out parameters */
8929         state->orig.out.hnd = _hnd;
8930
8931         /* Result */
8932         ZERO_STRUCT(state->orig.out.result);
8933
8934         state->out_mem_ctx = talloc_named_const(state, 0,
8935                              "dcerpc_srvsvc_NetShareDelCommit_out_memory");
8936         if (tevent_req_nomem(state->out_mem_ctx, req)) {
8937                 return tevent_req_post(req, ev);
8938         }
8939
8940         /* make a temporary copy, that we pass to the dispatch function */
8941         state->tmp = state->orig;
8942
8943         subreq = dcerpc_srvsvc_NetShareDelCommit_r_send(state, ev, h, &state->tmp);
8944         if (tevent_req_nomem(subreq, req)) {
8945                 return tevent_req_post(req, ev);
8946         }
8947         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetShareDelCommit_done, req);
8948         return req;
8949 }
8950
8951 static void dcerpc_srvsvc_NetShareDelCommit_done(struct tevent_req *subreq)
8952 {
8953         struct tevent_req *req = tevent_req_callback_data(
8954                 subreq, struct tevent_req);
8955         struct dcerpc_srvsvc_NetShareDelCommit_state *state = tevent_req_data(
8956                 req, struct dcerpc_srvsvc_NetShareDelCommit_state);
8957         NTSTATUS status;
8958         TALLOC_CTX *mem_ctx;
8959
8960         if (state->out_mem_ctx) {
8961                 mem_ctx = state->out_mem_ctx;
8962         } else {
8963                 mem_ctx = state;
8964         }
8965
8966         status = dcerpc_srvsvc_NetShareDelCommit_r_recv(subreq, mem_ctx);
8967         TALLOC_FREE(subreq);
8968         if (!NT_STATUS_IS_OK(status)) {
8969                 tevent_req_nterror(req, status);
8970                 return;
8971         }
8972
8973         /* Copy out parameters */
8974         if (state->orig.out.hnd && state->tmp.out.hnd) {
8975                 *state->orig.out.hnd = *state->tmp.out.hnd;
8976         }
8977
8978         /* Copy result */
8979         state->orig.out.result = state->tmp.out.result;
8980
8981         /* Reset temporary structure */
8982         ZERO_STRUCT(state->tmp);
8983
8984         tevent_req_done(req);
8985 }
8986
8987 NTSTATUS dcerpc_srvsvc_NetShareDelCommit_recv(struct tevent_req *req,
8988                                               TALLOC_CTX *mem_ctx,
8989                                               WERROR *result)
8990 {
8991         struct dcerpc_srvsvc_NetShareDelCommit_state *state = tevent_req_data(
8992                 req, struct dcerpc_srvsvc_NetShareDelCommit_state);
8993         NTSTATUS status;
8994
8995         if (tevent_req_is_nterror(req, &status)) {
8996                 tevent_req_received(req);
8997                 return status;
8998         }
8999
9000         /* Steal possible out parameters to the callers context */
9001         talloc_steal(mem_ctx, state->out_mem_ctx);
9002
9003         /* Return result */
9004         *result = state->orig.out.result;
9005
9006         tevent_req_received(req);
9007         return NT_STATUS_OK;
9008 }
9009
9010 NTSTATUS dcerpc_srvsvc_NetShareDelCommit(struct dcerpc_binding_handle *h,
9011                                          TALLOC_CTX *mem_ctx,
9012                                          struct policy_handle *_hnd /* [in,out] [unique] */,
9013                                          WERROR *result)
9014 {
9015         struct srvsvc_NetShareDelCommit r;
9016         NTSTATUS status;
9017
9018         /* In parameters */
9019         r.in.hnd = _hnd;
9020
9021         status = dcerpc_srvsvc_NetShareDelCommit_r(h, mem_ctx, &r);
9022         if (!NT_STATUS_IS_OK(status)) {
9023                 return status;
9024         }
9025
9026         /* Return variables */
9027         if (_hnd && r.out.hnd) {
9028                 *_hnd = *r.out.hnd;
9029         }
9030
9031         /* Return result */
9032         *result = r.out.result;
9033
9034         return NT_STATUS_OK;
9035 }
9036
9037 struct dcerpc_srvsvc_NetGetFileSecurity_r_state {
9038         TALLOC_CTX *out_mem_ctx;
9039 };
9040
9041 static void dcerpc_srvsvc_NetGetFileSecurity_r_done(struct tevent_req *subreq);
9042
9043 struct tevent_req *dcerpc_srvsvc_NetGetFileSecurity_r_send(TALLOC_CTX *mem_ctx,
9044         struct tevent_context *ev,
9045         struct dcerpc_binding_handle *h,
9046         struct srvsvc_NetGetFileSecurity *r)
9047 {
9048         struct tevent_req *req;
9049         struct dcerpc_srvsvc_NetGetFileSecurity_r_state *state;
9050         struct tevent_req *subreq;
9051
9052         req = tevent_req_create(mem_ctx, &state,
9053                                 struct dcerpc_srvsvc_NetGetFileSecurity_r_state);
9054         if (req == NULL) {
9055                 return NULL;
9056         }
9057
9058         state->out_mem_ctx = talloc_new(state);
9059         if (tevent_req_nomem(state->out_mem_ctx, req)) {
9060                 return tevent_req_post(req, ev);
9061         }
9062
9063         subreq = dcerpc_binding_handle_call_send(state, ev, h,
9064                         NULL, &ndr_table_srvsvc,
9065                         NDR_SRVSVC_NETGETFILESECURITY, state->out_mem_ctx, r);
9066         if (tevent_req_nomem(subreq, req)) {
9067                 return tevent_req_post(req, ev);
9068         }
9069         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetGetFileSecurity_r_done, req);
9070
9071         return req;
9072 }
9073
9074 static void dcerpc_srvsvc_NetGetFileSecurity_r_done(struct tevent_req *subreq)
9075 {
9076         struct tevent_req *req =
9077                 tevent_req_callback_data(subreq,
9078                 struct tevent_req);
9079         NTSTATUS status;
9080
9081         status = dcerpc_binding_handle_call_recv(subreq);
9082         if (!NT_STATUS_IS_OK(status)) {
9083                 tevent_req_nterror(req, status);
9084                 return;
9085         }
9086
9087         tevent_req_done(req);
9088 }
9089
9090 NTSTATUS dcerpc_srvsvc_NetGetFileSecurity_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
9091 {
9092         struct dcerpc_srvsvc_NetGetFileSecurity_r_state *state =
9093                 tevent_req_data(req,
9094                 struct dcerpc_srvsvc_NetGetFileSecurity_r_state);
9095         NTSTATUS status;
9096
9097         if (tevent_req_is_nterror(req, &status)) {
9098                 tevent_req_received(req);
9099                 return status;
9100         }
9101
9102         talloc_steal(mem_ctx, state->out_mem_ctx);
9103
9104         tevent_req_received(req);
9105         return NT_STATUS_OK;
9106 }
9107
9108 NTSTATUS dcerpc_srvsvc_NetGetFileSecurity_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetGetFileSecurity *r)
9109 {
9110         NTSTATUS status;
9111
9112         status = dcerpc_binding_handle_call(h,
9113                         NULL, &ndr_table_srvsvc,
9114                         NDR_SRVSVC_NETGETFILESECURITY, mem_ctx, r);
9115
9116         return status;
9117 }
9118
9119 NTSTATUS dcerpc_srvsvc_NetGetFileSecurity_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetGetFileSecurity *r)
9120 {
9121         NTSTATUS status;
9122
9123         status = dcerpc_srvsvc_NetGetFileSecurity_r(p->binding_handle, mem_ctx, r);
9124
9125         if (NT_STATUS_IS_RPC(status)) {
9126                 status = NT_STATUS_NET_WRITE_FAULT;
9127         }
9128
9129         return status;
9130 }
9131
9132 struct dcerpc_srvsvc_NetGetFileSecurity_state {
9133         struct srvsvc_NetGetFileSecurity orig;
9134         struct srvsvc_NetGetFileSecurity tmp;
9135         TALLOC_CTX *out_mem_ctx;
9136 };
9137
9138 static void dcerpc_srvsvc_NetGetFileSecurity_done(struct tevent_req *subreq);
9139
9140 struct tevent_req *dcerpc_srvsvc_NetGetFileSecurity_send(TALLOC_CTX *mem_ctx,
9141                                                          struct tevent_context *ev,
9142                                                          struct dcerpc_binding_handle *h,
9143                                                          const char *_server_unc /* [in] [unique,charset(UTF16)] */,
9144                                                          const char *_share /* [in] [unique,charset(UTF16)] */,
9145                                                          const char *_file /* [in] [charset(UTF16)] */,
9146                                                          uint32_t _securityinformation /* [in]  */,
9147                                                          struct sec_desc_buf **_sd_buf /* [out] [ref] */)
9148 {
9149         struct tevent_req *req;
9150         struct dcerpc_srvsvc_NetGetFileSecurity_state *state;
9151         struct tevent_req *subreq;
9152
9153         req = tevent_req_create(mem_ctx, &state,
9154                                 struct dcerpc_srvsvc_NetGetFileSecurity_state);
9155         if (req == NULL) {
9156                 return NULL;
9157         }
9158         state->out_mem_ctx = NULL;
9159
9160         /* In parameters */
9161         state->orig.in.server_unc = _server_unc;
9162         state->orig.in.share = _share;
9163         state->orig.in.file = _file;
9164         state->orig.in.securityinformation = _securityinformation;
9165
9166         /* Out parameters */
9167         state->orig.out.sd_buf = _sd_buf;
9168
9169         /* Result */
9170         ZERO_STRUCT(state->orig.out.result);
9171
9172         state->out_mem_ctx = talloc_named_const(state, 0,
9173                              "dcerpc_srvsvc_NetGetFileSecurity_out_memory");
9174         if (tevent_req_nomem(state->out_mem_ctx, req)) {
9175                 return tevent_req_post(req, ev);
9176         }
9177
9178         /* make a temporary copy, that we pass to the dispatch function */
9179         state->tmp = state->orig;
9180
9181         subreq = dcerpc_srvsvc_NetGetFileSecurity_r_send(state, ev, h, &state->tmp);
9182         if (tevent_req_nomem(subreq, req)) {
9183                 return tevent_req_post(req, ev);
9184         }
9185         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetGetFileSecurity_done, req);
9186         return req;
9187 }
9188
9189 static void dcerpc_srvsvc_NetGetFileSecurity_done(struct tevent_req *subreq)
9190 {
9191         struct tevent_req *req = tevent_req_callback_data(
9192                 subreq, struct tevent_req);
9193         struct dcerpc_srvsvc_NetGetFileSecurity_state *state = tevent_req_data(
9194                 req, struct dcerpc_srvsvc_NetGetFileSecurity_state);
9195         NTSTATUS status;
9196         TALLOC_CTX *mem_ctx;
9197
9198         if (state->out_mem_ctx) {
9199                 mem_ctx = state->out_mem_ctx;
9200         } else {
9201                 mem_ctx = state;
9202         }
9203
9204         status = dcerpc_srvsvc_NetGetFileSecurity_r_recv(subreq, mem_ctx);
9205         TALLOC_FREE(subreq);
9206         if (!NT_STATUS_IS_OK(status)) {
9207                 tevent_req_nterror(req, status);
9208                 return;
9209         }
9210
9211         /* Copy out parameters */
9212         *state->orig.out.sd_buf = *state->tmp.out.sd_buf;
9213
9214         /* Copy result */
9215         state->orig.out.result = state->tmp.out.result;
9216
9217         /* Reset temporary structure */
9218         ZERO_STRUCT(state->tmp);
9219
9220         tevent_req_done(req);
9221 }
9222
9223 NTSTATUS dcerpc_srvsvc_NetGetFileSecurity_recv(struct tevent_req *req,
9224                                                TALLOC_CTX *mem_ctx,
9225                                                WERROR *result)
9226 {
9227         struct dcerpc_srvsvc_NetGetFileSecurity_state *state = tevent_req_data(
9228                 req, struct dcerpc_srvsvc_NetGetFileSecurity_state);
9229         NTSTATUS status;
9230
9231         if (tevent_req_is_nterror(req, &status)) {
9232                 tevent_req_received(req);
9233                 return status;
9234         }
9235
9236         /* Steal possible out parameters to the callers context */
9237         talloc_steal(mem_ctx, state->out_mem_ctx);
9238
9239         /* Return result */
9240         *result = state->orig.out.result;
9241
9242         tevent_req_received(req);
9243         return NT_STATUS_OK;
9244 }
9245
9246 NTSTATUS dcerpc_srvsvc_NetGetFileSecurity(struct dcerpc_binding_handle *h,
9247                                           TALLOC_CTX *mem_ctx,
9248                                           const char *_server_unc /* [in] [unique,charset(UTF16)] */,
9249                                           const char *_share /* [in] [unique,charset(UTF16)] */,
9250                                           const char *_file /* [in] [charset(UTF16)] */,
9251                                           uint32_t _securityinformation /* [in]  */,
9252                                           struct sec_desc_buf **_sd_buf /* [out] [ref] */,
9253                                           WERROR *result)
9254 {
9255         struct srvsvc_NetGetFileSecurity r;
9256         NTSTATUS status;
9257
9258         /* In parameters */
9259         r.in.server_unc = _server_unc;
9260         r.in.share = _share;
9261         r.in.file = _file;
9262         r.in.securityinformation = _securityinformation;
9263
9264         status = dcerpc_srvsvc_NetGetFileSecurity_r(h, mem_ctx, &r);
9265         if (!NT_STATUS_IS_OK(status)) {
9266                 return status;
9267         }
9268
9269         /* Return variables */
9270         *_sd_buf = *r.out.sd_buf;
9271
9272         /* Return result */
9273         *result = r.out.result;
9274
9275         return NT_STATUS_OK;
9276 }
9277
9278 struct dcerpc_srvsvc_NetSetFileSecurity_r_state {
9279         TALLOC_CTX *out_mem_ctx;
9280 };
9281
9282 static void dcerpc_srvsvc_NetSetFileSecurity_r_done(struct tevent_req *subreq);
9283
9284 struct tevent_req *dcerpc_srvsvc_NetSetFileSecurity_r_send(TALLOC_CTX *mem_ctx,
9285         struct tevent_context *ev,
9286         struct dcerpc_binding_handle *h,
9287         struct srvsvc_NetSetFileSecurity *r)
9288 {
9289         struct tevent_req *req;
9290         struct dcerpc_srvsvc_NetSetFileSecurity_r_state *state;
9291         struct tevent_req *subreq;
9292
9293         req = tevent_req_create(mem_ctx, &state,
9294                                 struct dcerpc_srvsvc_NetSetFileSecurity_r_state);
9295         if (req == NULL) {
9296                 return NULL;
9297         }
9298
9299         state->out_mem_ctx = NULL;
9300         subreq = dcerpc_binding_handle_call_send(state, ev, h,
9301                         NULL, &ndr_table_srvsvc,
9302                         NDR_SRVSVC_NETSETFILESECURITY, state, r);
9303         if (tevent_req_nomem(subreq, req)) {
9304                 return tevent_req_post(req, ev);
9305         }
9306         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetSetFileSecurity_r_done, req);
9307
9308         return req;
9309 }
9310
9311 static void dcerpc_srvsvc_NetSetFileSecurity_r_done(struct tevent_req *subreq)
9312 {
9313         struct tevent_req *req =
9314                 tevent_req_callback_data(subreq,
9315                 struct tevent_req);
9316         NTSTATUS status;
9317
9318         status = dcerpc_binding_handle_call_recv(subreq);
9319         if (!NT_STATUS_IS_OK(status)) {
9320                 tevent_req_nterror(req, status);
9321                 return;
9322         }
9323
9324         tevent_req_done(req);
9325 }
9326
9327 NTSTATUS dcerpc_srvsvc_NetSetFileSecurity_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
9328 {
9329         struct dcerpc_srvsvc_NetSetFileSecurity_r_state *state =
9330                 tevent_req_data(req,
9331                 struct dcerpc_srvsvc_NetSetFileSecurity_r_state);
9332         NTSTATUS status;
9333
9334         if (tevent_req_is_nterror(req, &status)) {
9335                 tevent_req_received(req);
9336                 return status;
9337         }
9338
9339         talloc_steal(mem_ctx, state->out_mem_ctx);
9340
9341         tevent_req_received(req);
9342         return NT_STATUS_OK;
9343 }
9344
9345 NTSTATUS dcerpc_srvsvc_NetSetFileSecurity_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetSetFileSecurity *r)
9346 {
9347         NTSTATUS status;
9348
9349         status = dcerpc_binding_handle_call(h,
9350                         NULL, &ndr_table_srvsvc,
9351                         NDR_SRVSVC_NETSETFILESECURITY, mem_ctx, r);
9352
9353         return status;
9354 }
9355
9356 NTSTATUS dcerpc_srvsvc_NetSetFileSecurity_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetSetFileSecurity *r)
9357 {
9358         NTSTATUS status;
9359
9360         status = dcerpc_srvsvc_NetSetFileSecurity_r(p->binding_handle, mem_ctx, r);
9361
9362         if (NT_STATUS_IS_RPC(status)) {
9363                 status = NT_STATUS_NET_WRITE_FAULT;
9364         }
9365
9366         return status;
9367 }
9368
9369 struct dcerpc_srvsvc_NetSetFileSecurity_state {
9370         struct srvsvc_NetSetFileSecurity orig;
9371         struct srvsvc_NetSetFileSecurity tmp;
9372         TALLOC_CTX *out_mem_ctx;
9373 };
9374
9375 static void dcerpc_srvsvc_NetSetFileSecurity_done(struct tevent_req *subreq);
9376
9377 struct tevent_req *dcerpc_srvsvc_NetSetFileSecurity_send(TALLOC_CTX *mem_ctx,
9378                                                          struct tevent_context *ev,
9379                                                          struct dcerpc_binding_handle *h,
9380                                                          const char *_server_unc /* [in] [unique,charset(UTF16)] */,
9381                                                          const char *_share /* [in] [unique,charset(UTF16)] */,
9382                                                          const char *_file /* [in] [charset(UTF16)] */,
9383                                                          uint32_t _securityinformation /* [in]  */,
9384                                                          struct sec_desc_buf *_sd_buf /* [in] [ref] */)
9385 {
9386         struct tevent_req *req;
9387         struct dcerpc_srvsvc_NetSetFileSecurity_state *state;
9388         struct tevent_req *subreq;
9389
9390         req = tevent_req_create(mem_ctx, &state,
9391                                 struct dcerpc_srvsvc_NetSetFileSecurity_state);
9392         if (req == NULL) {
9393                 return NULL;
9394         }
9395         state->out_mem_ctx = NULL;
9396
9397         /* In parameters */
9398         state->orig.in.server_unc = _server_unc;
9399         state->orig.in.share = _share;
9400         state->orig.in.file = _file;
9401         state->orig.in.securityinformation = _securityinformation;
9402         state->orig.in.sd_buf = _sd_buf;
9403
9404         /* Out parameters */
9405
9406         /* Result */
9407         ZERO_STRUCT(state->orig.out.result);
9408
9409         /* make a temporary copy, that we pass to the dispatch function */
9410         state->tmp = state->orig;
9411
9412         subreq = dcerpc_srvsvc_NetSetFileSecurity_r_send(state, ev, h, &state->tmp);
9413         if (tevent_req_nomem(subreq, req)) {
9414                 return tevent_req_post(req, ev);
9415         }
9416         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetSetFileSecurity_done, req);
9417         return req;
9418 }
9419
9420 static void dcerpc_srvsvc_NetSetFileSecurity_done(struct tevent_req *subreq)
9421 {
9422         struct tevent_req *req = tevent_req_callback_data(
9423                 subreq, struct tevent_req);
9424         struct dcerpc_srvsvc_NetSetFileSecurity_state *state = tevent_req_data(
9425                 req, struct dcerpc_srvsvc_NetSetFileSecurity_state);
9426         NTSTATUS status;
9427         TALLOC_CTX *mem_ctx;
9428
9429         if (state->out_mem_ctx) {
9430                 mem_ctx = state->out_mem_ctx;
9431         } else {
9432                 mem_ctx = state;
9433         }
9434
9435         status = dcerpc_srvsvc_NetSetFileSecurity_r_recv(subreq, mem_ctx);
9436         TALLOC_FREE(subreq);
9437         if (!NT_STATUS_IS_OK(status)) {
9438                 tevent_req_nterror(req, status);
9439                 return;
9440         }
9441
9442         /* Copy out parameters */
9443
9444         /* Copy result */
9445         state->orig.out.result = state->tmp.out.result;
9446
9447         /* Reset temporary structure */
9448         ZERO_STRUCT(state->tmp);
9449
9450         tevent_req_done(req);
9451 }
9452
9453 NTSTATUS dcerpc_srvsvc_NetSetFileSecurity_recv(struct tevent_req *req,
9454                                                TALLOC_CTX *mem_ctx,
9455                                                WERROR *result)
9456 {
9457         struct dcerpc_srvsvc_NetSetFileSecurity_state *state = tevent_req_data(
9458                 req, struct dcerpc_srvsvc_NetSetFileSecurity_state);
9459         NTSTATUS status;
9460
9461         if (tevent_req_is_nterror(req, &status)) {
9462                 tevent_req_received(req);
9463                 return status;
9464         }
9465
9466         /* Steal possible out parameters to the callers context */
9467         talloc_steal(mem_ctx, state->out_mem_ctx);
9468
9469         /* Return result */
9470         *result = state->orig.out.result;
9471
9472         tevent_req_received(req);
9473         return NT_STATUS_OK;
9474 }
9475
9476 NTSTATUS dcerpc_srvsvc_NetSetFileSecurity(struct dcerpc_binding_handle *h,
9477                                           TALLOC_CTX *mem_ctx,
9478                                           const char *_server_unc /* [in] [unique,charset(UTF16)] */,
9479                                           const char *_share /* [in] [unique,charset(UTF16)] */,
9480                                           const char *_file /* [in] [charset(UTF16)] */,
9481                                           uint32_t _securityinformation /* [in]  */,
9482                                           struct sec_desc_buf *_sd_buf /* [in] [ref] */,
9483                                           WERROR *result)
9484 {
9485         struct srvsvc_NetSetFileSecurity r;
9486         NTSTATUS status;
9487
9488         /* In parameters */
9489         r.in.server_unc = _server_unc;
9490         r.in.share = _share;
9491         r.in.file = _file;
9492         r.in.securityinformation = _securityinformation;
9493         r.in.sd_buf = _sd_buf;
9494
9495         status = dcerpc_srvsvc_NetSetFileSecurity_r(h, mem_ctx, &r);
9496         if (!NT_STATUS_IS_OK(status)) {
9497                 return status;
9498         }
9499
9500         /* Return variables */
9501
9502         /* Return result */
9503         *result = r.out.result;
9504
9505         return NT_STATUS_OK;
9506 }
9507
9508 struct dcerpc_srvsvc_NetServerTransportAddEx_r_state {
9509         TALLOC_CTX *out_mem_ctx;
9510 };
9511
9512 static void dcerpc_srvsvc_NetServerTransportAddEx_r_done(struct tevent_req *subreq);
9513
9514 struct tevent_req *dcerpc_srvsvc_NetServerTransportAddEx_r_send(TALLOC_CTX *mem_ctx,
9515         struct tevent_context *ev,
9516         struct dcerpc_binding_handle *h,
9517         struct srvsvc_NetServerTransportAddEx *r)
9518 {
9519         struct tevent_req *req;
9520         struct dcerpc_srvsvc_NetServerTransportAddEx_r_state *state;
9521         struct tevent_req *subreq;
9522
9523         req = tevent_req_create(mem_ctx, &state,
9524                                 struct dcerpc_srvsvc_NetServerTransportAddEx_r_state);
9525         if (req == NULL) {
9526                 return NULL;
9527         }
9528
9529         state->out_mem_ctx = NULL;
9530         subreq = dcerpc_binding_handle_call_send(state, ev, h,
9531                         NULL, &ndr_table_srvsvc,
9532                         NDR_SRVSVC_NETSERVERTRANSPORTADDEX, state, r);
9533         if (tevent_req_nomem(subreq, req)) {
9534                 return tevent_req_post(req, ev);
9535         }
9536         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetServerTransportAddEx_r_done, req);
9537
9538         return req;
9539 }
9540
9541 static void dcerpc_srvsvc_NetServerTransportAddEx_r_done(struct tevent_req *subreq)
9542 {
9543         struct tevent_req *req =
9544                 tevent_req_callback_data(subreq,
9545                 struct tevent_req);
9546         NTSTATUS status;
9547
9548         status = dcerpc_binding_handle_call_recv(subreq);
9549         if (!NT_STATUS_IS_OK(status)) {
9550                 tevent_req_nterror(req, status);
9551                 return;
9552         }
9553
9554         tevent_req_done(req);
9555 }
9556
9557 NTSTATUS dcerpc_srvsvc_NetServerTransportAddEx_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
9558 {
9559         struct dcerpc_srvsvc_NetServerTransportAddEx_r_state *state =
9560                 tevent_req_data(req,
9561                 struct dcerpc_srvsvc_NetServerTransportAddEx_r_state);
9562         NTSTATUS status;
9563
9564         if (tevent_req_is_nterror(req, &status)) {
9565                 tevent_req_received(req);
9566                 return status;
9567         }
9568
9569         talloc_steal(mem_ctx, state->out_mem_ctx);
9570
9571         tevent_req_received(req);
9572         return NT_STATUS_OK;
9573 }
9574
9575 NTSTATUS dcerpc_srvsvc_NetServerTransportAddEx_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetServerTransportAddEx *r)
9576 {
9577         NTSTATUS status;
9578
9579         status = dcerpc_binding_handle_call(h,
9580                         NULL, &ndr_table_srvsvc,
9581                         NDR_SRVSVC_NETSERVERTRANSPORTADDEX, mem_ctx, r);
9582
9583         return status;
9584 }
9585
9586 NTSTATUS dcerpc_srvsvc_NetServerTransportAddEx_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetServerTransportAddEx *r)
9587 {
9588         NTSTATUS status;
9589
9590         status = dcerpc_srvsvc_NetServerTransportAddEx_r(p->binding_handle, mem_ctx, r);
9591
9592         if (NT_STATUS_IS_RPC(status)) {
9593                 status = NT_STATUS_NET_WRITE_FAULT;
9594         }
9595
9596         return status;
9597 }
9598
9599 struct dcerpc_srvsvc_NetServerTransportAddEx_state {
9600         struct srvsvc_NetServerTransportAddEx orig;
9601         struct srvsvc_NetServerTransportAddEx tmp;
9602         TALLOC_CTX *out_mem_ctx;
9603 };
9604
9605 static void dcerpc_srvsvc_NetServerTransportAddEx_done(struct tevent_req *subreq);
9606
9607 struct tevent_req *dcerpc_srvsvc_NetServerTransportAddEx_send(TALLOC_CTX *mem_ctx,
9608                                                               struct tevent_context *ev,
9609                                                               struct dcerpc_binding_handle *h,
9610                                                               const char *_server_unc /* [in] [unique,charset(UTF16)] */,
9611                                                               uint32_t _level /* [in]  */,
9612                                                               union srvsvc_NetTransportInfo _info /* [in] [switch_is(level)] */)
9613 {
9614         struct tevent_req *req;
9615         struct dcerpc_srvsvc_NetServerTransportAddEx_state *state;
9616         struct tevent_req *subreq;
9617
9618         req = tevent_req_create(mem_ctx, &state,
9619                                 struct dcerpc_srvsvc_NetServerTransportAddEx_state);
9620         if (req == NULL) {
9621                 return NULL;
9622         }
9623         state->out_mem_ctx = NULL;
9624
9625         /* In parameters */
9626         state->orig.in.server_unc = _server_unc;
9627         state->orig.in.level = _level;
9628         state->orig.in.info = _info;
9629
9630         /* Out parameters */
9631
9632         /* Result */
9633         ZERO_STRUCT(state->orig.out.result);
9634
9635         /* make a temporary copy, that we pass to the dispatch function */
9636         state->tmp = state->orig;
9637
9638         subreq = dcerpc_srvsvc_NetServerTransportAddEx_r_send(state, ev, h, &state->tmp);
9639         if (tevent_req_nomem(subreq, req)) {
9640                 return tevent_req_post(req, ev);
9641         }
9642         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetServerTransportAddEx_done, req);
9643         return req;
9644 }
9645
9646 static void dcerpc_srvsvc_NetServerTransportAddEx_done(struct tevent_req *subreq)
9647 {
9648         struct tevent_req *req = tevent_req_callback_data(
9649                 subreq, struct tevent_req);
9650         struct dcerpc_srvsvc_NetServerTransportAddEx_state *state = tevent_req_data(
9651                 req, struct dcerpc_srvsvc_NetServerTransportAddEx_state);
9652         NTSTATUS status;
9653         TALLOC_CTX *mem_ctx;
9654
9655         if (state->out_mem_ctx) {
9656                 mem_ctx = state->out_mem_ctx;
9657         } else {
9658                 mem_ctx = state;
9659         }
9660
9661         status = dcerpc_srvsvc_NetServerTransportAddEx_r_recv(subreq, mem_ctx);
9662         TALLOC_FREE(subreq);
9663         if (!NT_STATUS_IS_OK(status)) {
9664                 tevent_req_nterror(req, status);
9665                 return;
9666         }
9667
9668         /* Copy out parameters */
9669
9670         /* Copy result */
9671         state->orig.out.result = state->tmp.out.result;
9672
9673         /* Reset temporary structure */
9674         ZERO_STRUCT(state->tmp);
9675
9676         tevent_req_done(req);
9677 }
9678
9679 NTSTATUS dcerpc_srvsvc_NetServerTransportAddEx_recv(struct tevent_req *req,
9680                                                     TALLOC_CTX *mem_ctx,
9681                                                     WERROR *result)
9682 {
9683         struct dcerpc_srvsvc_NetServerTransportAddEx_state *state = tevent_req_data(
9684                 req, struct dcerpc_srvsvc_NetServerTransportAddEx_state);
9685         NTSTATUS status;
9686
9687         if (tevent_req_is_nterror(req, &status)) {
9688                 tevent_req_received(req);
9689                 return status;
9690         }
9691
9692         /* Steal possible out parameters to the callers context */
9693         talloc_steal(mem_ctx, state->out_mem_ctx);
9694
9695         /* Return result */
9696         *result = state->orig.out.result;
9697
9698         tevent_req_received(req);
9699         return NT_STATUS_OK;
9700 }
9701
9702 NTSTATUS dcerpc_srvsvc_NetServerTransportAddEx(struct dcerpc_binding_handle *h,
9703                                                TALLOC_CTX *mem_ctx,
9704                                                const char *_server_unc /* [in] [unique,charset(UTF16)] */,
9705                                                uint32_t _level /* [in]  */,
9706                                                union srvsvc_NetTransportInfo _info /* [in] [switch_is(level)] */,
9707                                                WERROR *result)
9708 {
9709         struct srvsvc_NetServerTransportAddEx r;
9710         NTSTATUS status;
9711
9712         /* In parameters */
9713         r.in.server_unc = _server_unc;
9714         r.in.level = _level;
9715         r.in.info = _info;
9716
9717         status = dcerpc_srvsvc_NetServerTransportAddEx_r(h, mem_ctx, &r);
9718         if (!NT_STATUS_IS_OK(status)) {
9719                 return status;
9720         }
9721
9722         /* Return variables */
9723
9724         /* Return result */
9725         *result = r.out.result;
9726
9727         return NT_STATUS_OK;
9728 }
9729
9730 struct dcerpc_srvsvc_NetServerSetServiceBitsEx_r_state {
9731         TALLOC_CTX *out_mem_ctx;
9732 };
9733
9734 static void dcerpc_srvsvc_NetServerSetServiceBitsEx_r_done(struct tevent_req *subreq);
9735
9736 struct tevent_req *dcerpc_srvsvc_NetServerSetServiceBitsEx_r_send(TALLOC_CTX *mem_ctx,
9737         struct tevent_context *ev,
9738         struct dcerpc_binding_handle *h,
9739         struct srvsvc_NetServerSetServiceBitsEx *r)
9740 {
9741         struct tevent_req *req;
9742         struct dcerpc_srvsvc_NetServerSetServiceBitsEx_r_state *state;
9743         struct tevent_req *subreq;
9744
9745         req = tevent_req_create(mem_ctx, &state,
9746                                 struct dcerpc_srvsvc_NetServerSetServiceBitsEx_r_state);
9747         if (req == NULL) {
9748                 return NULL;
9749         }
9750
9751         state->out_mem_ctx = NULL;
9752         subreq = dcerpc_binding_handle_call_send(state, ev, h,
9753                         NULL, &ndr_table_srvsvc,
9754                         NDR_SRVSVC_NETSERVERSETSERVICEBITSEX, state, r);
9755         if (tevent_req_nomem(subreq, req)) {
9756                 return tevent_req_post(req, ev);
9757         }
9758         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetServerSetServiceBitsEx_r_done, req);
9759
9760         return req;
9761 }
9762
9763 static void dcerpc_srvsvc_NetServerSetServiceBitsEx_r_done(struct tevent_req *subreq)
9764 {
9765         struct tevent_req *req =
9766                 tevent_req_callback_data(subreq,
9767                 struct tevent_req);
9768         NTSTATUS status;
9769
9770         status = dcerpc_binding_handle_call_recv(subreq);
9771         if (!NT_STATUS_IS_OK(status)) {
9772                 tevent_req_nterror(req, status);
9773                 return;
9774         }
9775
9776         tevent_req_done(req);
9777 }
9778
9779 NTSTATUS dcerpc_srvsvc_NetServerSetServiceBitsEx_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
9780 {
9781         struct dcerpc_srvsvc_NetServerSetServiceBitsEx_r_state *state =
9782                 tevent_req_data(req,
9783                 struct dcerpc_srvsvc_NetServerSetServiceBitsEx_r_state);
9784         NTSTATUS status;
9785
9786         if (tevent_req_is_nterror(req, &status)) {
9787                 tevent_req_received(req);
9788                 return status;
9789         }
9790
9791         talloc_steal(mem_ctx, state->out_mem_ctx);
9792
9793         tevent_req_received(req);
9794         return NT_STATUS_OK;
9795 }
9796
9797 NTSTATUS dcerpc_srvsvc_NetServerSetServiceBitsEx_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct srvsvc_NetServerSetServiceBitsEx *r)
9798 {
9799         NTSTATUS status;
9800
9801         status = dcerpc_binding_handle_call(h,
9802                         NULL, &ndr_table_srvsvc,
9803                         NDR_SRVSVC_NETSERVERSETSERVICEBITSEX, mem_ctx, r);
9804
9805         return status;
9806 }
9807
9808 NTSTATUS dcerpc_srvsvc_NetServerSetServiceBitsEx_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct srvsvc_NetServerSetServiceBitsEx *r)
9809 {
9810         NTSTATUS status;
9811
9812         status = dcerpc_srvsvc_NetServerSetServiceBitsEx_r(p->binding_handle, mem_ctx, r);
9813
9814         if (NT_STATUS_IS_RPC(status)) {
9815                 status = NT_STATUS_NET_WRITE_FAULT;
9816         }
9817
9818         return status;
9819 }
9820
9821 struct dcerpc_srvsvc_NetServerSetServiceBitsEx_state {
9822         struct srvsvc_NetServerSetServiceBitsEx orig;
9823         struct srvsvc_NetServerSetServiceBitsEx tmp;
9824         TALLOC_CTX *out_mem_ctx;
9825 };
9826
9827 static void dcerpc_srvsvc_NetServerSetServiceBitsEx_done(struct tevent_req *subreq);
9828
9829 struct tevent_req *dcerpc_srvsvc_NetServerSetServiceBitsEx_send(TALLOC_CTX *mem_ctx,
9830                                                                 struct tevent_context *ev,
9831                                                                 struct dcerpc_binding_handle *h,
9832                                                                 const char *_server_unc /* [in] [unique,charset(UTF16)] */,
9833                                                                 const char *_emulated_server_unc /* [in] [unique,charset(UTF16)] */,
9834                                                                 const char *_transport /* [in] [unique,charset(UTF16)] */,
9835                                                                 uint32_t _servicebitsofinterest /* [in]  */,
9836                                                                 uint32_t _servicebits /* [in]  */,
9837                                                                 uint32_t _updateimmediately /* [in]  */)
9838 {
9839         struct tevent_req *req;
9840         struct dcerpc_srvsvc_NetServerSetServiceBitsEx_state *state;
9841         struct tevent_req *subreq;
9842
9843         req = tevent_req_create(mem_ctx, &state,
9844                                 struct dcerpc_srvsvc_NetServerSetServiceBitsEx_state);
9845         if (req == NULL) {
9846                 return NULL;
9847         }
9848         state->out_mem_ctx = NULL;
9849
9850         /* In parameters */
9851         state->orig.in.server_unc = _server_unc;
9852         state->orig.in.emulated_server_unc = _emulated_server_unc;
9853         state->orig.in.transport = _transport;
9854         state->orig.in.servicebitsofinterest = _servicebitsofinterest;
9855         state->orig.in.servicebits = _servicebits;
9856         state->orig.in.updateimmediately = _updateimmediately;
9857
9858         /* Out parameters */
9859
9860         /* Result */
9861         ZERO_STRUCT(state->orig.out.result);
9862
9863         /* make a temporary copy, that we pass to the dispatch function */
9864         state->tmp = state->orig;
9865
9866         subreq = dcerpc_srvsvc_NetServerSetServiceBitsEx_r_send(state, ev, h, &state->tmp);
9867         if (tevent_req_nomem(subreq, req)) {
9868                 return tevent_req_post(req, ev);
9869         }
9870         tevent_req_set_callback(subreq, dcerpc_srvsvc_NetServerSetServiceBitsEx_done, req);
9871         return req;
9872 }
9873
9874 static void dcerpc_srvsvc_NetServerSetServiceBitsEx_done(struct tevent_req *subreq)
9875 {
9876         struct tevent_req *req = tevent_req_callback_data(
9877                 subreq, struct tevent_req);
9878         struct dcerpc_srvsvc_NetServerSetServiceBitsEx_state *state = tevent_req_data(
9879                 req, struct dcerpc_srvsvc_NetServerSetServiceBitsEx_state);
9880         NTSTATUS status;
9881         TALLOC_CTX *mem_ctx;
9882
9883         if (state->out_mem_ctx) {
9884                 mem_ctx = state->out_mem_ctx;
9885         } else {
9886                 mem_ctx = state;
9887         }
9888
9889         status = dcerpc_srvsvc_NetServerSetServiceBitsEx_r_recv(subreq, mem_ctx);
9890         TALLOC_FREE(subreq);
9891         if (!NT_STATUS_IS_OK(status)) {
9892                 tevent_req_nterror(req, status);
9893                 return;
9894         }
9895
9896         /* Copy out parameters */
9897
9898         /* Copy result */
9899         state->orig.out.result = state->tmp.out.result;
9900
9901         /* Reset temporary structure */
9902         ZERO_STRUCT(state->tmp);
9903
9904         tevent_req_done(req);
9905 }
9906
9907 NTSTATUS dcerpc_srvsvc_NetServerSetServiceBitsEx_recv(struct tevent_req *req,
9908                                                       TALLOC_CTX *mem_ctx,
9909                                                       WERROR *result)
9910 {
9911         struct dcerpc_srvsvc_NetServerSetServiceBitsEx_state *state = tevent_req_data(
9912                 req, struct dcerpc_srvsvc_NetServerSetServiceBitsEx_state);
9913         NTSTATUS status;
9914
9915         if (tevent_req_is_nterror(req, &status)) {
9916                 tevent_req_received(req);
9917                 return status;
9918         }
9919
9920         /* Steal possible out parameters to the callers context */
9921         talloc_steal(mem_ctx, state->out_mem_ctx);
9922
9923         /* Return result */
9924         *result = state->orig.out.result;
9925
9926         tevent_req_received(req);
9927         return NT_STATUS_OK;
9928 }
9929
9930 NTSTATUS dcerpc_srvsvc_NetServerSetServiceBitsEx(struct dcerpc_binding_handle *h,
9931                                                  TALLOC_CTX *mem_ctx,
9932                                                  const char *_server_unc /* [in] [unique,charset(UTF16)] */,
9933                                                  const char *_emulated_server_unc /* [in] [unique,charset(UTF16)] */,
9934                                                  const char *_transport /* [in] [unique,charset(UTF16)] */,
9935                                                  uint32_t _servicebitsofinterest /* [in]  */,
9936                                                  uint32_t _servicebits /* [in]  */,
9937                                                  uint32_t _updateimmediately /* [in]  */,
9938                                                  WERROR *result)
9939 {
9940         struct srvsvc_NetServerSetServiceBitsEx r;
9941         NTSTATUS status;
9942
9943         /* In parameters */
9944         r.in.server_unc = _server_unc;
9945         r.in.emulated_server_unc = _emulated_server_unc;
9946         r.in.transport = _transport;
9947         r.in.servicebitsofinterest = _servicebitsofinterest;
9948         r.in.servicebits = _servicebits;
9949         r.in.updateimmediately = _updateimmediately;
9950
9951         status = dcerpc_srvsvc_NetServerSetServiceBitsEx_r(h, mem_ctx, &r);
9952         if (!NT_STATUS_IS_OK(status)) {
9953                 return status;
9954         }
9955
9956         /* Return variables */
9957
9958         /* Return result */
9959         *result = r.out.result;
9960
9961         return NT_STATUS_OK;
9962 }
9963