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