bin.gen_ndr/default/librpc/gen_ndr/ndr_dnsserver_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/librpc/gen_ndr/ndr_dnsserver.h"
   7 #include "bin/default/librpc/gen_ndr/ndr_dnsserver_c.h"
   8
   9 /* dnsserver - client functions generated by pidl */
  10
  11 struct dcerpc_DnssrvOperation_r_state {
  12         TALLOC_CTX *out_mem_ctx;
  13 };
  14
  15 static void dcerpc_DnssrvOperation_r_done(struct tevent_req *subreq);
  16
  17 struct tevent_req *dcerpc_DnssrvOperation_r_send(TALLOC_CTX *mem_ctx,
  18         struct tevent_context *ev,
  19         struct dcerpc_binding_handle *h,
  20         struct DnssrvOperation *r)
  21 {
  22         struct tevent_req *req;
  23         struct dcerpc_DnssrvOperation_r_state *state;
  24         struct tevent_req *subreq;
  25
  26         req = tevent_req_create(mem_ctx, &state,
  27                                 struct dcerpc_DnssrvOperation_r_state);
  28         if (req == NULL) {
  29                 return NULL;
  30         }
  31
  32         state->out_mem_ctx = NULL;
  33
  34         subreq = dcerpc_binding_handle_call_send(state, ev, h,
  35                         NULL, &ndr_table_dnsserver,
  36                         NDR_DNSSRVOPERATION, state, r);
  37         if (tevent_req_nomem(subreq, req)) {
  38                 return tevent_req_post(req, ev);
  39         }
  40         tevent_req_set_callback(subreq, dcerpc_DnssrvOperation_r_done, req);
  41
  42         return req;
  43 }
  44
  45 static void dcerpc_DnssrvOperation_r_done(struct tevent_req *subreq)
  46 {
  47         struct tevent_req *req =
  48                 tevent_req_callback_data(subreq,
  49                 struct tevent_req);
  50         NTSTATUS status;
  51
  52         status = dcerpc_binding_handle_call_recv(subreq);
  53         TALLOC_FREE(subreq);
  54         if (tevent_req_nterror(req, status)) {
  55                 return;
  56         }
  57
  58         tevent_req_done(req);
  59 }
  60
  61 NTSTATUS dcerpc_DnssrvOperation_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
  62 {
  63         struct dcerpc_DnssrvOperation_r_state *state =
  64                 tevent_req_data(req,
  65                 struct dcerpc_DnssrvOperation_r_state);
  66         NTSTATUS status;
  67
  68         if (tevent_req_is_nterror(req, &status)) {
  69                 tevent_req_received(req);
  70                 return status;
  71         }
  72
  73         talloc_steal(mem_ctx, state->out_mem_ctx);
  74
  75         tevent_req_received(req);
  76         return NT_STATUS_OK;
  77 }
  78
  79 NTSTATUS dcerpc_DnssrvOperation_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct DnssrvOperation *r)
  80 {
  81         NTSTATUS status;
  82
  83         status = dcerpc_binding_handle_call(h,
  84                         NULL, &ndr_table_dnsserver,
  85                         NDR_DNSSRVOPERATION, mem_ctx, r);
  86
  87         return status;
  88 }
  89
  90 struct dcerpc_DnssrvOperation_state {
  91         struct DnssrvOperation orig;
  92         struct DnssrvOperation tmp;
  93         TALLOC_CTX *out_mem_ctx;
  94 };
  95
  96 static void dcerpc_DnssrvOperation_done(struct tevent_req *subreq);
  97
  98 struct tevent_req *dcerpc_DnssrvOperation_send(TALLOC_CTX *mem_ctx,
  99                                                struct tevent_context *ev,
 100                                                struct dcerpc_binding_handle *h,
 101                                                const char *_pwszServerName /* [in] [unique,charset(UTF16)] */,
 102                                                const char *_pszZone /* [in] [unique,charset(UTF8)] */,
 103                                                uint32_t _dwContext /* [in]  */,
 104                                                const char *_pszOperation /* [in] [unique,charset(UTF8)] */,
 105                                                enum DNS_RPC_TYPEID _dwTypeId /* [in]  */,
 106                                                union DNSSRV_RPC_UNION _pData /* [in] [switch_is(dwTypeId)] */)
 107 {
 108         struct tevent_req *req;
 109         struct dcerpc_DnssrvOperation_state *state;
 110         struct tevent_req *subreq;
 111
 112         req = tevent_req_create(mem_ctx, &state,
 113                                 struct dcerpc_DnssrvOperation_state);
 114         if (req == NULL) {
 115                 return NULL;
 116         }
 117         state->out_mem_ctx = NULL;
 118
 119         /* In parameters */
 120         state->orig.in.pwszServerName = _pwszServerName;
 121         state->orig.in.pszZone = _pszZone;
 122         state->orig.in.dwContext = _dwContext;
 123         state->orig.in.pszOperation = _pszOperation;
 124         state->orig.in.dwTypeId = _dwTypeId;
 125         state->orig.in.pData = _pData;
 126
 127         /* Out parameters */
 128
 129         /* Result */
 130         ZERO_STRUCT(state->orig.out.result);
 131
 132         /* make a temporary copy, that we pass to the dispatch function */
 133         state->tmp = state->orig;
 134
 135         subreq = dcerpc_DnssrvOperation_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_DnssrvOperation_done, req);
 140         return req;
 141 }
 142
 143 static void dcerpc_DnssrvOperation_done(struct tevent_req *subreq)
 144 {
 145         struct tevent_req *req = tevent_req_callback_data(
 146                 subreq, struct tevent_req);
 147         struct dcerpc_DnssrvOperation_state *state = tevent_req_data(
 148                 req, struct dcerpc_DnssrvOperation_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_DnssrvOperation_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
 166         /* Copy result */
 167         state->orig.out.result = state->tmp.out.result;
 168
 169         /* Reset temporary structure */
 170         ZERO_STRUCT(state->tmp);
 171
 172         tevent_req_done(req);
 173 }
 174
 175 NTSTATUS dcerpc_DnssrvOperation_recv(struct tevent_req *req,
 176                                      TALLOC_CTX *mem_ctx,
 177                                      WERROR *result)
 178 {
 179         struct dcerpc_DnssrvOperation_state *state = tevent_req_data(
 180                 req, struct dcerpc_DnssrvOperation_state);
 181         NTSTATUS status;
 182
 183         if (tevent_req_is_nterror(req, &status)) {
 184                 tevent_req_received(req);
 185                 return status;
 186         }
 187
 188         /* Steal possible out parameters to the callers context */
 189         talloc_steal(mem_ctx, state->out_mem_ctx);
 190
 191         /* Return result */
 192         *result = state->orig.out.result;
 193
 194         tevent_req_received(req);
 195         return NT_STATUS_OK;
 196 }
 197
 198 NTSTATUS dcerpc_DnssrvOperation(struct dcerpc_binding_handle *h,
 199                                 TALLOC_CTX *mem_ctx,
 200                                 const char *_pwszServerName /* [in] [unique,charset(UTF16)] */,
 201                                 const char *_pszZone /* [in] [unique,charset(UTF8)] */,
 202                                 uint32_t _dwContext /* [in]  */,
 203                                 const char *_pszOperation /* [in] [unique,charset(UTF8)] */,
 204                                 enum DNS_RPC_TYPEID _dwTypeId /* [in]  */,
 205                                 union DNSSRV_RPC_UNION _pData /* [in] [switch_is(dwTypeId)] */,
 206                                 WERROR *result)
 207 {
 208         struct DnssrvOperation r;
 209         NTSTATUS status;
 210
 211         /* In parameters */
 212         r.in.pwszServerName = _pwszServerName;
 213         r.in.pszZone = _pszZone;
 214         r.in.dwContext = _dwContext;
 215         r.in.pszOperation = _pszOperation;
 216         r.in.dwTypeId = _dwTypeId;
 217         r.in.pData = _pData;
 218
 219         status = dcerpc_DnssrvOperation_r(h, mem_ctx, &r);
 220         if (!NT_STATUS_IS_OK(status)) {
 221                 return status;
 222         }
 223
 224         /* Return variables */
 225
 226         /* Return result */
 227         *result = r.out.result;
 228
 229         return NT_STATUS_OK;
 230 }
 231
 232 struct dcerpc_DnssrvQuery_r_state {
 233         TALLOC_CTX *out_mem_ctx;
 234 };
 235
 236 static void dcerpc_DnssrvQuery_r_done(struct tevent_req *subreq);
 237
 238 struct tevent_req *dcerpc_DnssrvQuery_r_send(TALLOC_CTX *mem_ctx,
 239         struct tevent_context *ev,
 240         struct dcerpc_binding_handle *h,
 241         struct DnssrvQuery *r)
 242 {
 243         struct tevent_req *req;
 244         struct dcerpc_DnssrvQuery_r_state *state;
 245         struct tevent_req *subreq;
 246
 247         req = tevent_req_create(mem_ctx, &state,
 248                                 struct dcerpc_DnssrvQuery_r_state);
 249         if (req == NULL) {
 250                 return NULL;
 251         }
 252
 253         state->out_mem_ctx = talloc_new(state);
 254         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 255                 return tevent_req_post(req, ev);
 256         }
 257
 258         subreq = dcerpc_binding_handle_call_send(state, ev, h,
 259                         NULL, &ndr_table_dnsserver,
 260                         NDR_DNSSRVQUERY, state->out_mem_ctx, r);
 261         if (tevent_req_nomem(subreq, req)) {
 262                 return tevent_req_post(req, ev);
 263         }
 264         tevent_req_set_callback(subreq, dcerpc_DnssrvQuery_r_done, req);
 265
 266         return req;
 267 }
 268
 269 static void dcerpc_DnssrvQuery_r_done(struct tevent_req *subreq)
 270 {
 271         struct tevent_req *req =
 272                 tevent_req_callback_data(subreq,
 273                 struct tevent_req);
 274         NTSTATUS status;
 275
 276         status = dcerpc_binding_handle_call_recv(subreq);
 277         TALLOC_FREE(subreq);
 278         if (tevent_req_nterror(req, status)) {
 279                 return;
 280         }
 281
 282         tevent_req_done(req);
 283 }
 284
 285 NTSTATUS dcerpc_DnssrvQuery_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 286 {
 287         struct dcerpc_DnssrvQuery_r_state *state =
 288                 tevent_req_data(req,
 289                 struct dcerpc_DnssrvQuery_r_state);
 290         NTSTATUS status;
 291
 292         if (tevent_req_is_nterror(req, &status)) {
 293                 tevent_req_received(req);
 294                 return status;
 295         }
 296
 297         talloc_steal(mem_ctx, state->out_mem_ctx);
 298
 299         tevent_req_received(req);
 300         return NT_STATUS_OK;
 301 }
 302
 303 NTSTATUS dcerpc_DnssrvQuery_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct DnssrvQuery *r)
 304 {
 305         NTSTATUS status;
 306
 307         status = dcerpc_binding_handle_call(h,
 308                         NULL, &ndr_table_dnsserver,
 309                         NDR_DNSSRVQUERY, mem_ctx, r);
 310
 311         return status;
 312 }
 313
 314 struct dcerpc_DnssrvQuery_state {
 315         struct DnssrvQuery orig;
 316         struct DnssrvQuery tmp;
 317         TALLOC_CTX *out_mem_ctx;
 318 };
 319
 320 static void dcerpc_DnssrvQuery_done(struct tevent_req *subreq);
 321
 322 struct tevent_req *dcerpc_DnssrvQuery_send(TALLOC_CTX *mem_ctx,
 323                                            struct tevent_context *ev,
 324                                            struct dcerpc_binding_handle *h,
 325                                            const char *_pwszServerName /* [in] [unique,charset(UTF16)] */,
 326                                            const char *_pszZone /* [in] [unique,charset(UTF8)] */,
 327                                            const char *_pszOperation /* [in] [unique,charset(UTF8)] */,
 328                                            enum DNS_RPC_TYPEID *_pdwTypeId /* [out] [ref] */,
 329                                            union DNSSRV_RPC_UNION *_ppData /* [out] [ref,switch_is(*pdwTypeId)] */)
 330 {
 331         struct tevent_req *req;
 332         struct dcerpc_DnssrvQuery_state *state;
 333         struct tevent_req *subreq;
 334
 335         req = tevent_req_create(mem_ctx, &state,
 336                                 struct dcerpc_DnssrvQuery_state);
 337         if (req == NULL) {
 338                 return NULL;
 339         }
 340         state->out_mem_ctx = NULL;
 341
 342         /* In parameters */
 343         state->orig.in.pwszServerName = _pwszServerName;
 344         state->orig.in.pszZone = _pszZone;
 345         state->orig.in.pszOperation = _pszOperation;
 346
 347         /* Out parameters */
 348         state->orig.out.pdwTypeId = _pdwTypeId;
 349         state->orig.out.ppData = _ppData;
 350
 351         /* Result */
 352         ZERO_STRUCT(state->orig.out.result);
 353
 354         state->out_mem_ctx = talloc_named_const(state, 0,
 355                              "dcerpc_DnssrvQuery_out_memory");
 356         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 357                 return tevent_req_post(req, ev);
 358         }
 359
 360         /* make a temporary copy, that we pass to the dispatch function */
 361         state->tmp = state->orig;
 362
 363         subreq = dcerpc_DnssrvQuery_r_send(state, ev, h, &state->tmp);
 364         if (tevent_req_nomem(subreq, req)) {
 365                 return tevent_req_post(req, ev);
 366         }
 367         tevent_req_set_callback(subreq, dcerpc_DnssrvQuery_done, req);
 368         return req;
 369 }
 370
 371 static void dcerpc_DnssrvQuery_done(struct tevent_req *subreq)
 372 {
 373         struct tevent_req *req = tevent_req_callback_data(
 374                 subreq, struct tevent_req);
 375         struct dcerpc_DnssrvQuery_state *state = tevent_req_data(
 376                 req, struct dcerpc_DnssrvQuery_state);
 377         NTSTATUS status;
 378         TALLOC_CTX *mem_ctx;
 379
 380         if (state->out_mem_ctx) {
 381                 mem_ctx = state->out_mem_ctx;
 382         } else {
 383                 mem_ctx = state;
 384         }
 385
 386         status = dcerpc_DnssrvQuery_r_recv(subreq, mem_ctx);
 387         TALLOC_FREE(subreq);
 388         if (tevent_req_nterror(req, status)) {
 389                 return;
 390         }
 391
 392         /* Copy out parameters */
 393         *state->orig.out.pdwTypeId = *state->tmp.out.pdwTypeId;
 394         *state->orig.out.ppData = *state->tmp.out.ppData;
 395
 396         /* Copy result */
 397         state->orig.out.result = state->tmp.out.result;
 398
 399         /* Reset temporary structure */
 400         ZERO_STRUCT(state->tmp);
 401
 402         tevent_req_done(req);
 403 }
 404
 405 NTSTATUS dcerpc_DnssrvQuery_recv(struct tevent_req *req,
 406                                  TALLOC_CTX *mem_ctx,
 407                                  WERROR *result)
 408 {
 409         struct dcerpc_DnssrvQuery_state *state = tevent_req_data(
 410                 req, struct dcerpc_DnssrvQuery_state);
 411         NTSTATUS status;
 412
 413         if (tevent_req_is_nterror(req, &status)) {
 414                 tevent_req_received(req);
 415                 return status;
 416         }
 417
 418         /* Steal possible out parameters to the callers context */
 419         talloc_steal(mem_ctx, state->out_mem_ctx);
 420
 421         /* Return result */
 422         *result = state->orig.out.result;
 423
 424         tevent_req_received(req);
 425         return NT_STATUS_OK;
 426 }
 427
 428 NTSTATUS dcerpc_DnssrvQuery(struct dcerpc_binding_handle *h,
 429                             TALLOC_CTX *mem_ctx,
 430                             const char *_pwszServerName /* [in] [unique,charset(UTF16)] */,
 431                             const char *_pszZone /* [in] [unique,charset(UTF8)] */,
 432                             const char *_pszOperation /* [in] [unique,charset(UTF8)] */,
 433                             enum DNS_RPC_TYPEID *_pdwTypeId /* [out] [ref] */,
 434                             union DNSSRV_RPC_UNION *_ppData /* [out] [ref,switch_is(*pdwTypeId)] */,
 435                             WERROR *result)
 436 {
 437         struct DnssrvQuery r;
 438         NTSTATUS status;
 439
 440         /* In parameters */
 441         r.in.pwszServerName = _pwszServerName;
 442         r.in.pszZone = _pszZone;
 443         r.in.pszOperation = _pszOperation;
 444
 445         status = dcerpc_DnssrvQuery_r(h, mem_ctx, &r);
 446         if (!NT_STATUS_IS_OK(status)) {
 447                 return status;
 448         }
 449
 450         /* Return variables */
 451         *_pdwTypeId = *r.out.pdwTypeId;
 452         *_ppData = *r.out.ppData;
 453
 454         /* Return result */
 455         *result = r.out.result;
 456
 457         return NT_STATUS_OK;
 458 }
 459
 460 struct dcerpc_DnssrvComplexOperation_r_state {
 461         TALLOC_CTX *out_mem_ctx;
 462 };
 463
 464 static void dcerpc_DnssrvComplexOperation_r_done(struct tevent_req *subreq);
 465
 466 struct tevent_req *dcerpc_DnssrvComplexOperation_r_send(TALLOC_CTX *mem_ctx,
 467         struct tevent_context *ev,
 468         struct dcerpc_binding_handle *h,
 469         struct DnssrvComplexOperation *r)
 470 {
 471         struct tevent_req *req;
 472         struct dcerpc_DnssrvComplexOperation_r_state *state;
 473         struct tevent_req *subreq;
 474
 475         req = tevent_req_create(mem_ctx, &state,
 476                                 struct dcerpc_DnssrvComplexOperation_r_state);
 477         if (req == NULL) {
 478                 return NULL;
 479         }
 480
 481         state->out_mem_ctx = talloc_new(state);
 482         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 483                 return tevent_req_post(req, ev);
 484         }
 485
 486         subreq = dcerpc_binding_handle_call_send(state, ev, h,
 487                         NULL, &ndr_table_dnsserver,
 488                         NDR_DNSSRVCOMPLEXOPERATION, state->out_mem_ctx, r);
 489         if (tevent_req_nomem(subreq, req)) {
 490                 return tevent_req_post(req, ev);
 491         }
 492         tevent_req_set_callback(subreq, dcerpc_DnssrvComplexOperation_r_done, req);
 493
 494         return req;
 495 }
 496
 497 static void dcerpc_DnssrvComplexOperation_r_done(struct tevent_req *subreq)
 498 {
 499         struct tevent_req *req =
 500                 tevent_req_callback_data(subreq,
 501                 struct tevent_req);
 502         NTSTATUS status;
 503
 504         status = dcerpc_binding_handle_call_recv(subreq);
 505         TALLOC_FREE(subreq);
 506         if (tevent_req_nterror(req, status)) {
 507                 return;
 508         }
 509
 510         tevent_req_done(req);
 511 }
 512
 513 NTSTATUS dcerpc_DnssrvComplexOperation_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 514 {
 515         struct dcerpc_DnssrvComplexOperation_r_state *state =
 516                 tevent_req_data(req,
 517                 struct dcerpc_DnssrvComplexOperation_r_state);
 518         NTSTATUS status;
 519
 520         if (tevent_req_is_nterror(req, &status)) {
 521                 tevent_req_received(req);
 522                 return status;
 523         }
 524
 525         talloc_steal(mem_ctx, state->out_mem_ctx);
 526
 527         tevent_req_received(req);
 528         return NT_STATUS_OK;
 529 }
 530
 531 NTSTATUS dcerpc_DnssrvComplexOperation_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct DnssrvComplexOperation *r)
 532 {
 533         NTSTATUS status;
 534
 535         status = dcerpc_binding_handle_call(h,
 536                         NULL, &ndr_table_dnsserver,
 537                         NDR_DNSSRVCOMPLEXOPERATION, mem_ctx, r);
 538
 539         return status;
 540 }
 541
 542 struct dcerpc_DnssrvComplexOperation_state {
 543         struct DnssrvComplexOperation orig;
 544         struct DnssrvComplexOperation tmp;
 545         TALLOC_CTX *out_mem_ctx;
 546 };
 547
 548 static void dcerpc_DnssrvComplexOperation_done(struct tevent_req *subreq);
 549
 550 struct tevent_req *dcerpc_DnssrvComplexOperation_send(TALLOC_CTX *mem_ctx,
 551                                                       struct tevent_context *ev,
 552                                                       struct dcerpc_binding_handle *h,
 553                                                       const char *_pwszServerName /* [in] [unique,charset(UTF16)] */,
 554                                                       const char *_pszZone /* [in] [unique,charset(UTF8)] */,
 555                                                       const char *_pszOperation /* [in] [unique,charset(UTF8)] */,
 556                                                       enum DNS_RPC_TYPEID _dwTypeIn /* [in]  */,
 557                                                       union DNSSRV_RPC_UNION _pDataIn /* [in] [switch_is(dwTypeIn)] */,
 558                                                       enum DNS_RPC_TYPEID *_pdwTypeOut /* [out] [ref] */,
 559                                                       union DNSSRV_RPC_UNION *_ppDataOut /* [out] [ref,switch_is(*pdwTypeOut)] */)
 560 {
 561         struct tevent_req *req;
 562         struct dcerpc_DnssrvComplexOperation_state *state;
 563         struct tevent_req *subreq;
 564
 565         req = tevent_req_create(mem_ctx, &state,
 566                                 struct dcerpc_DnssrvComplexOperation_state);
 567         if (req == NULL) {
 568                 return NULL;
 569         }
 570         state->out_mem_ctx = NULL;
 571
 572         /* In parameters */
 573         state->orig.in.pwszServerName = _pwszServerName;
 574         state->orig.in.pszZone = _pszZone;
 575         state->orig.in.pszOperation = _pszOperation;
 576         state->orig.in.dwTypeIn = _dwTypeIn;
 577         state->orig.in.pDataIn = _pDataIn;
 578
 579         /* Out parameters */
 580         state->orig.out.pdwTypeOut = _pdwTypeOut;
 581         state->orig.out.ppDataOut = _ppDataOut;
 582
 583         /* Result */
 584         ZERO_STRUCT(state->orig.out.result);
 585
 586         state->out_mem_ctx = talloc_named_const(state, 0,
 587                              "dcerpc_DnssrvComplexOperation_out_memory");
 588         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 589                 return tevent_req_post(req, ev);
 590         }
 591
 592         /* make a temporary copy, that we pass to the dispatch function */
 593         state->tmp = state->orig;
 594
 595         subreq = dcerpc_DnssrvComplexOperation_r_send(state, ev, h, &state->tmp);
 596         if (tevent_req_nomem(subreq, req)) {
 597                 return tevent_req_post(req, ev);
 598         }
 599         tevent_req_set_callback(subreq, dcerpc_DnssrvComplexOperation_done, req);
 600         return req;
 601 }
 602
 603 static void dcerpc_DnssrvComplexOperation_done(struct tevent_req *subreq)
 604 {
 605         struct tevent_req *req = tevent_req_callback_data(
 606                 subreq, struct tevent_req);
 607         struct dcerpc_DnssrvComplexOperation_state *state = tevent_req_data(
 608                 req, struct dcerpc_DnssrvComplexOperation_state);
 609         NTSTATUS status;
 610         TALLOC_CTX *mem_ctx;
 611
 612         if (state->out_mem_ctx) {
 613                 mem_ctx = state->out_mem_ctx;
 614         } else {
 615                 mem_ctx = state;
 616         }
 617
 618         status = dcerpc_DnssrvComplexOperation_r_recv(subreq, mem_ctx);
 619         TALLOC_FREE(subreq);
 620         if (tevent_req_nterror(req, status)) {
 621                 return;
 622         }
 623
 624         /* Copy out parameters */
 625         *state->orig.out.pdwTypeOut = *state->tmp.out.pdwTypeOut;
 626         *state->orig.out.ppDataOut = *state->tmp.out.ppDataOut;
 627
 628         /* Copy result */
 629         state->orig.out.result = state->tmp.out.result;
 630
 631         /* Reset temporary structure */
 632         ZERO_STRUCT(state->tmp);
 633
 634         tevent_req_done(req);
 635 }
 636
 637 NTSTATUS dcerpc_DnssrvComplexOperation_recv(struct tevent_req *req,
 638                                             TALLOC_CTX *mem_ctx,
 639                                             WERROR *result)
 640 {
 641         struct dcerpc_DnssrvComplexOperation_state *state = tevent_req_data(
 642                 req, struct dcerpc_DnssrvComplexOperation_state);
 643         NTSTATUS status;
 644
 645         if (tevent_req_is_nterror(req, &status)) {
 646                 tevent_req_received(req);
 647                 return status;
 648         }
 649
 650         /* Steal possible out parameters to the callers context */
 651         talloc_steal(mem_ctx, state->out_mem_ctx);
 652
 653         /* Return result */
 654         *result = state->orig.out.result;
 655
 656         tevent_req_received(req);
 657         return NT_STATUS_OK;
 658 }
 659
 660 NTSTATUS dcerpc_DnssrvComplexOperation(struct dcerpc_binding_handle *h,
 661                                        TALLOC_CTX *mem_ctx,
 662                                        const char *_pwszServerName /* [in] [unique,charset(UTF16)] */,
 663                                        const char *_pszZone /* [in] [unique,charset(UTF8)] */,
 664                                        const char *_pszOperation /* [in] [unique,charset(UTF8)] */,
 665                                        enum DNS_RPC_TYPEID _dwTypeIn /* [in]  */,
 666                                        union DNSSRV_RPC_UNION _pDataIn /* [in] [switch_is(dwTypeIn)] */,
 667                                        enum DNS_RPC_TYPEID *_pdwTypeOut /* [out] [ref] */,
 668                                        union DNSSRV_RPC_UNION *_ppDataOut /* [out] [ref,switch_is(*pdwTypeOut)] */,
 669                                        WERROR *result)
 670 {
 671         struct DnssrvComplexOperation r;
 672         NTSTATUS status;
 673
 674         /* In parameters */
 675         r.in.pwszServerName = _pwszServerName;
 676         r.in.pszZone = _pszZone;
 677         r.in.pszOperation = _pszOperation;
 678         r.in.dwTypeIn = _dwTypeIn;
 679         r.in.pDataIn = _pDataIn;
 680
 681         status = dcerpc_DnssrvComplexOperation_r(h, mem_ctx, &r);
 682         if (!NT_STATUS_IS_OK(status)) {
 683                 return status;
 684         }
 685
 686         /* Return variables */
 687         *_pdwTypeOut = *r.out.pdwTypeOut;
 688         *_ppDataOut = *r.out.ppDataOut;
 689
 690         /* Return result */
 691         *result = r.out.result;
 692
 693         return NT_STATUS_OK;
 694 }
 695
 696 struct dcerpc_DnssrvEnumRecords_r_state {
 697         TALLOC_CTX *out_mem_ctx;
 698 };
 699
 700 static void dcerpc_DnssrvEnumRecords_r_done(struct tevent_req *subreq);
 701
 702 struct tevent_req *dcerpc_DnssrvEnumRecords_r_send(TALLOC_CTX *mem_ctx,
 703         struct tevent_context *ev,
 704         struct dcerpc_binding_handle *h,
 705         struct DnssrvEnumRecords *r)
 706 {
 707         struct tevent_req *req;
 708         struct dcerpc_DnssrvEnumRecords_r_state *state;
 709         struct tevent_req *subreq;
 710
 711         req = tevent_req_create(mem_ctx, &state,
 712                                 struct dcerpc_DnssrvEnumRecords_r_state);
 713         if (req == NULL) {
 714                 return NULL;
 715         }
 716
 717         state->out_mem_ctx = talloc_new(state);
 718         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 719                 return tevent_req_post(req, ev);
 720         }
 721
 722         subreq = dcerpc_binding_handle_call_send(state, ev, h,
 723                         NULL, &ndr_table_dnsserver,
 724                         NDR_DNSSRVENUMRECORDS, state->out_mem_ctx, r);
 725         if (tevent_req_nomem(subreq, req)) {
 726                 return tevent_req_post(req, ev);
 727         }
 728         tevent_req_set_callback(subreq, dcerpc_DnssrvEnumRecords_r_done, req);
 729
 730         return req;
 731 }
 732
 733 static void dcerpc_DnssrvEnumRecords_r_done(struct tevent_req *subreq)
 734 {
 735         struct tevent_req *req =
 736                 tevent_req_callback_data(subreq,
 737                 struct tevent_req);
 738         NTSTATUS status;
 739
 740         status = dcerpc_binding_handle_call_recv(subreq);
 741         TALLOC_FREE(subreq);
 742         if (tevent_req_nterror(req, status)) {
 743                 return;
 744         }
 745
 746         tevent_req_done(req);
 747 }
 748
 749 NTSTATUS dcerpc_DnssrvEnumRecords_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 750 {
 751         struct dcerpc_DnssrvEnumRecords_r_state *state =
 752                 tevent_req_data(req,
 753                 struct dcerpc_DnssrvEnumRecords_r_state);
 754         NTSTATUS status;
 755
 756         if (tevent_req_is_nterror(req, &status)) {
 757                 tevent_req_received(req);
 758                 return status;
 759         }
 760
 761         talloc_steal(mem_ctx, state->out_mem_ctx);
 762
 763         tevent_req_received(req);
 764         return NT_STATUS_OK;
 765 }
 766
 767 NTSTATUS dcerpc_DnssrvEnumRecords_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct DnssrvEnumRecords *r)
 768 {
 769         NTSTATUS status;
 770
 771         status = dcerpc_binding_handle_call(h,
 772                         NULL, &ndr_table_dnsserver,
 773                         NDR_DNSSRVENUMRECORDS, mem_ctx, r);
 774
 775         return status;
 776 }
 777
 778 struct dcerpc_DnssrvEnumRecords_state {
 779         struct DnssrvEnumRecords orig;
 780         struct DnssrvEnumRecords tmp;
 781         TALLOC_CTX *out_mem_ctx;
 782 };
 783
 784 static void dcerpc_DnssrvEnumRecords_done(struct tevent_req *subreq);
 785
 786 struct tevent_req *dcerpc_DnssrvEnumRecords_send(TALLOC_CTX *mem_ctx,
 787                                                  struct tevent_context *ev,
 788                                                  struct dcerpc_binding_handle *h,
 789                                                  const char *_pwszServerName /* [in] [unique,charset(UTF16)] */,
 790                                                  const char *_pszZone /* [in] [unique,charset(UTF8)] */,
 791                                                  const char *_pszNodeName /* [in] [unique,charset(UTF8)] */,
 792                                                  const char *_pszStartChild /* [in] [unique,charset(UTF8)] */,
 793                                                  enum dns_record_type _wRecordType /* [in]  */,
 794                                                  uint32_t _fSelectFlag /* [in]  */,
 795                                                  const char *_pszFilterStart /* [in] [unique,charset(UTF8)] */,
 796                                                  const char *_pszFilterStop /* [in] [unique,charset(UTF8)] */,
 797                                                  uint32_t *_pdwBufferLength /* [out] [ref] */,
 798                                                  struct DNS_RPC_RECORDS_ARRAY **_pBuffer /* [out] [subcontext_size(*pdwBufferLength),subcontext(4),ref] */)
 799 {
 800         struct tevent_req *req;
 801         struct dcerpc_DnssrvEnumRecords_state *state;
 802         struct tevent_req *subreq;
 803
 804         req = tevent_req_create(mem_ctx, &state,
 805                                 struct dcerpc_DnssrvEnumRecords_state);
 806         if (req == NULL) {
 807                 return NULL;
 808         }
 809         state->out_mem_ctx = NULL;
 810
 811         /* In parameters */
 812         state->orig.in.pwszServerName = _pwszServerName;
 813         state->orig.in.pszZone = _pszZone;
 814         state->orig.in.pszNodeName = _pszNodeName;
 815         state->orig.in.pszStartChild = _pszStartChild;
 816         state->orig.in.wRecordType = _wRecordType;
 817         state->orig.in.fSelectFlag = _fSelectFlag;
 818         state->orig.in.pszFilterStart = _pszFilterStart;
 819         state->orig.in.pszFilterStop = _pszFilterStop;
 820
 821         /* Out parameters */
 822         state->orig.out.pdwBufferLength = _pdwBufferLength;
 823         state->orig.out.pBuffer = _pBuffer;
 824
 825         /* Result */
 826         ZERO_STRUCT(state->orig.out.result);
 827
 828         state->out_mem_ctx = talloc_named_const(state, 0,
 829                              "dcerpc_DnssrvEnumRecords_out_memory");
 830         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 831                 return tevent_req_post(req, ev);
 832         }
 833
 834         /* make a temporary copy, that we pass to the dispatch function */
 835         state->tmp = state->orig;
 836
 837         subreq = dcerpc_DnssrvEnumRecords_r_send(state, ev, h, &state->tmp);
 838         if (tevent_req_nomem(subreq, req)) {
 839                 return tevent_req_post(req, ev);
 840         }
 841         tevent_req_set_callback(subreq, dcerpc_DnssrvEnumRecords_done, req);
 842         return req;
 843 }
 844
 845 static void dcerpc_DnssrvEnumRecords_done(struct tevent_req *subreq)
 846 {
 847         struct tevent_req *req = tevent_req_callback_data(
 848                 subreq, struct tevent_req);
 849         struct dcerpc_DnssrvEnumRecords_state *state = tevent_req_data(
 850                 req, struct dcerpc_DnssrvEnumRecords_state);
 851         NTSTATUS status;
 852         TALLOC_CTX *mem_ctx;
 853
 854         if (state->out_mem_ctx) {
 855                 mem_ctx = state->out_mem_ctx;
 856         } else {
 857                 mem_ctx = state;
 858         }
 859
 860         status = dcerpc_DnssrvEnumRecords_r_recv(subreq, mem_ctx);
 861         TALLOC_FREE(subreq);
 862         if (tevent_req_nterror(req, status)) {
 863                 return;
 864         }
 865
 866         /* Copy out parameters */
 867         *state->orig.out.pdwBufferLength = *state->tmp.out.pdwBufferLength;
 868         *state->orig.out.pBuffer = *state->tmp.out.pBuffer;
 869
 870         /* Copy result */
 871         state->orig.out.result = state->tmp.out.result;
 872
 873         /* Reset temporary structure */
 874         ZERO_STRUCT(state->tmp);
 875
 876         tevent_req_done(req);
 877 }
 878
 879 NTSTATUS dcerpc_DnssrvEnumRecords_recv(struct tevent_req *req,
 880                                        TALLOC_CTX *mem_ctx,
 881                                        WERROR *result)
 882 {
 883         struct dcerpc_DnssrvEnumRecords_state *state = tevent_req_data(
 884                 req, struct dcerpc_DnssrvEnumRecords_state);
 885         NTSTATUS status;
 886
 887         if (tevent_req_is_nterror(req, &status)) {
 888                 tevent_req_received(req);
 889                 return status;
 890         }
 891
 892         /* Steal possible out parameters to the callers context */
 893         talloc_steal(mem_ctx, state->out_mem_ctx);
 894
 895         /* Return result */
 896         *result = state->orig.out.result;
 897
 898         tevent_req_received(req);
 899         return NT_STATUS_OK;
 900 }
 901
 902 NTSTATUS dcerpc_DnssrvEnumRecords(struct dcerpc_binding_handle *h,
 903                                   TALLOC_CTX *mem_ctx,
 904                                   const char *_pwszServerName /* [in] [unique,charset(UTF16)] */,
 905                                   const char *_pszZone /* [in] [unique,charset(UTF8)] */,
 906                                   const char *_pszNodeName /* [in] [unique,charset(UTF8)] */,
 907                                   const char *_pszStartChild /* [in] [unique,charset(UTF8)] */,
 908                                   enum dns_record_type _wRecordType /* [in]  */,
 909                                   uint32_t _fSelectFlag /* [in]  */,
 910                                   const char *_pszFilterStart /* [in] [unique,charset(UTF8)] */,
 911                                   const char *_pszFilterStop /* [in] [unique,charset(UTF8)] */,
 912                                   uint32_t *_pdwBufferLength /* [out] [ref] */,
 913                                   struct DNS_RPC_RECORDS_ARRAY **_pBuffer /* [out] [subcontext_size(*pdwBufferLength),subcontext(4),ref] */,
 914                                   WERROR *result)
 915 {
 916         struct DnssrvEnumRecords r;
 917         NTSTATUS status;
 918
 919         /* In parameters */
 920         r.in.pwszServerName = _pwszServerName;
 921         r.in.pszZone = _pszZone;
 922         r.in.pszNodeName = _pszNodeName;
 923         r.in.pszStartChild = _pszStartChild;
 924         r.in.wRecordType = _wRecordType;
 925         r.in.fSelectFlag = _fSelectFlag;
 926         r.in.pszFilterStart = _pszFilterStart;
 927         r.in.pszFilterStop = _pszFilterStop;
 928
 929         status = dcerpc_DnssrvEnumRecords_r(h, mem_ctx, &r);
 930         if (!NT_STATUS_IS_OK(status)) {
 931                 return status;
 932         }
 933
 934         /* Return variables */
 935         *_pdwBufferLength = *r.out.pdwBufferLength;
 936         *_pBuffer = *r.out.pBuffer;
 937
 938         /* Return result */
 939         *result = r.out.result;
 940
 941         return NT_STATUS_OK;
 942 }
 943
 944 struct dcerpc_DnssrvUpdateRecord_r_state {
 945         TALLOC_CTX *out_mem_ctx;
 946 };
 947
 948 static void dcerpc_DnssrvUpdateRecord_r_done(struct tevent_req *subreq);
 949
 950 struct tevent_req *dcerpc_DnssrvUpdateRecord_r_send(TALLOC_CTX *mem_ctx,
 951         struct tevent_context *ev,
 952         struct dcerpc_binding_handle *h,
 953         struct DnssrvUpdateRecord *r)
 954 {
 955         struct tevent_req *req;
 956         struct dcerpc_DnssrvUpdateRecord_r_state *state;
 957         struct tevent_req *subreq;
 958
 959         req = tevent_req_create(mem_ctx, &state,
 960                                 struct dcerpc_DnssrvUpdateRecord_r_state);
 961         if (req == NULL) {
 962                 return NULL;
 963         }
 964
 965         state->out_mem_ctx = NULL;
 966
 967         subreq = dcerpc_binding_handle_call_send(state, ev, h,
 968                         NULL, &ndr_table_dnsserver,
 969                         NDR_DNSSRVUPDATERECORD, state, r);
 970         if (tevent_req_nomem(subreq, req)) {
 971                 return tevent_req_post(req, ev);
 972         }
 973         tevent_req_set_callback(subreq, dcerpc_DnssrvUpdateRecord_r_done, req);
 974
 975         return req;
 976 }
 977
 978 static void dcerpc_DnssrvUpdateRecord_r_done(struct tevent_req *subreq)
 979 {
 980         struct tevent_req *req =
 981                 tevent_req_callback_data(subreq,
 982                 struct tevent_req);
 983         NTSTATUS status;
 984
 985         status = dcerpc_binding_handle_call_recv(subreq);
 986         TALLOC_FREE(subreq);
 987         if (tevent_req_nterror(req, status)) {
 988                 return;
 989         }
 990
 991         tevent_req_done(req);
 992 }
 993
 994 NTSTATUS dcerpc_DnssrvUpdateRecord_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 995 {
 996         struct dcerpc_DnssrvUpdateRecord_r_state *state =
 997                 tevent_req_data(req,
 998                 struct dcerpc_DnssrvUpdateRecord_r_state);
 999         NTSTATUS status;
1000
1001         if (tevent_req_is_nterror(req, &status)) {
1002                 tevent_req_received(req);
1003                 return status;
1004         }
1005
1006         talloc_steal(mem_ctx, state->out_mem_ctx);
1007
1008         tevent_req_received(req);
1009         return NT_STATUS_OK;
1010 }
1011
1012 NTSTATUS dcerpc_DnssrvUpdateRecord_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct DnssrvUpdateRecord *r)
1013 {
1014         NTSTATUS status;
1015
1016         status = dcerpc_binding_handle_call(h,
1017                         NULL, &ndr_table_dnsserver,
1018                         NDR_DNSSRVUPDATERECORD, mem_ctx, r);
1019
1020         return status;
1021 }
1022
1023 struct dcerpc_DnssrvUpdateRecord_state {
1024         struct DnssrvUpdateRecord orig;
1025         struct DnssrvUpdateRecord tmp;
1026         TALLOC_CTX *out_mem_ctx;
1027 };
1028
1029 static void dcerpc_DnssrvUpdateRecord_done(struct tevent_req *subreq);
1030
1031 struct tevent_req *dcerpc_DnssrvUpdateRecord_send(TALLOC_CTX *mem_ctx,
1032                                                   struct tevent_context *ev,
1033                                                   struct dcerpc_binding_handle *h,
1034                                                   const char *_pwszServerName /* [in] [unique,charset(UTF16)] */,
1035                                                   const char *_pszZone /* [in] [unique,charset(UTF8)] */,
1036                                                   const char *_pszNodeName /* [in] [unique,charset(UTF8)] */,
1037                                                   struct DNS_RPC_RECORD_BUF *_pAddRecord /* [in] [unique] */,
1038                                                   struct DNS_RPC_RECORD_BUF *_pDeleteRecord /* [in] [unique] */)
1039 {
1040         struct tevent_req *req;
1041         struct dcerpc_DnssrvUpdateRecord_state *state;
1042         struct tevent_req *subreq;
1043
1044         req = tevent_req_create(mem_ctx, &state,
1045                                 struct dcerpc_DnssrvUpdateRecord_state);
1046         if (req == NULL) {
1047                 return NULL;
1048         }
1049         state->out_mem_ctx = NULL;
1050
1051         /* In parameters */
1052         state->orig.in.pwszServerName = _pwszServerName;
1053         state->orig.in.pszZone = _pszZone;
1054         state->orig.in.pszNodeName = _pszNodeName;
1055         state->orig.in.pAddRecord = _pAddRecord;
1056         state->orig.in.pDeleteRecord = _pDeleteRecord;
1057
1058         /* Out parameters */
1059
1060         /* Result */
1061         ZERO_STRUCT(state->orig.out.result);
1062
1063         /* make a temporary copy, that we pass to the dispatch function */
1064         state->tmp = state->orig;
1065
1066         subreq = dcerpc_DnssrvUpdateRecord_r_send(state, ev, h, &state->tmp);
1067         if (tevent_req_nomem(subreq, req)) {
1068                 return tevent_req_post(req, ev);
1069         }
1070         tevent_req_set_callback(subreq, dcerpc_DnssrvUpdateRecord_done, req);
1071         return req;
1072 }
1073
1074 static void dcerpc_DnssrvUpdateRecord_done(struct tevent_req *subreq)
1075 {
1076         struct tevent_req *req = tevent_req_callback_data(
1077                 subreq, struct tevent_req);
1078         struct dcerpc_DnssrvUpdateRecord_state *state = tevent_req_data(
1079                 req, struct dcerpc_DnssrvUpdateRecord_state);
1080         NTSTATUS status;
1081         TALLOC_CTX *mem_ctx;
1082
1083         if (state->out_mem_ctx) {
1084                 mem_ctx = state->out_mem_ctx;
1085         } else {
1086                 mem_ctx = state;
1087         }
1088
1089         status = dcerpc_DnssrvUpdateRecord_r_recv(subreq, mem_ctx);
1090         TALLOC_FREE(subreq);
1091         if (tevent_req_nterror(req, status)) {
1092                 return;
1093         }
1094
1095         /* Copy out parameters */
1096
1097         /* Copy result */
1098         state->orig.out.result = state->tmp.out.result;
1099
1100         /* Reset temporary structure */
1101         ZERO_STRUCT(state->tmp);
1102
1103         tevent_req_done(req);
1104 }
1105
1106 NTSTATUS dcerpc_DnssrvUpdateRecord_recv(struct tevent_req *req,
1107                                         TALLOC_CTX *mem_ctx,
1108                                         WERROR *result)
1109 {
1110         struct dcerpc_DnssrvUpdateRecord_state *state = tevent_req_data(
1111                 req, struct dcerpc_DnssrvUpdateRecord_state);
1112         NTSTATUS status;
1113
1114         if (tevent_req_is_nterror(req, &status)) {
1115                 tevent_req_received(req);
1116                 return status;
1117         }
1118
1119         /* Steal possible out parameters to the callers context */
1120         talloc_steal(mem_ctx, state->out_mem_ctx);
1121
1122         /* Return result */
1123         *result = state->orig.out.result;
1124
1125         tevent_req_received(req);
1126         return NT_STATUS_OK;
1127 }
1128
1129 NTSTATUS dcerpc_DnssrvUpdateRecord(struct dcerpc_binding_handle *h,
1130                                    TALLOC_CTX *mem_ctx,
1131                                    const char *_pwszServerName /* [in] [unique,charset(UTF16)] */,
1132                                    const char *_pszZone /* [in] [unique,charset(UTF8)] */,
1133                                    const char *_pszNodeName /* [in] [unique,charset(UTF8)] */,
1134                                    struct DNS_RPC_RECORD_BUF *_pAddRecord /* [in] [unique] */,
1135                                    struct DNS_RPC_RECORD_BUF *_pDeleteRecord /* [in] [unique] */,
1136                                    WERROR *result)
1137 {
1138         struct DnssrvUpdateRecord r;
1139         NTSTATUS status;
1140
1141         /* In parameters */
1142         r.in.pwszServerName = _pwszServerName;
1143         r.in.pszZone = _pszZone;
1144         r.in.pszNodeName = _pszNodeName;
1145         r.in.pAddRecord = _pAddRecord;
1146         r.in.pDeleteRecord = _pDeleteRecord;
1147
1148         status = dcerpc_DnssrvUpdateRecord_r(h, mem_ctx, &r);
1149         if (!NT_STATUS_IS_OK(status)) {
1150                 return status;
1151         }
1152
1153         /* Return variables */
1154
1155         /* Return result */
1156         *result = r.out.result;
1157
1158         return NT_STATUS_OK;
1159 }
1160
1161 struct dcerpc_DnssrvOperation2_r_state {
1162         TALLOC_CTX *out_mem_ctx;
1163 };
1164
1165 static void dcerpc_DnssrvOperation2_r_done(struct tevent_req *subreq);
1166
1167 struct tevent_req *dcerpc_DnssrvOperation2_r_send(TALLOC_CTX *mem_ctx,
1168         struct tevent_context *ev,
1169         struct dcerpc_binding_handle *h,
1170         struct DnssrvOperation2 *r)
1171 {
1172         struct tevent_req *req;
1173         struct dcerpc_DnssrvOperation2_r_state *state;
1174         struct tevent_req *subreq;
1175
1176         req = tevent_req_create(mem_ctx, &state,
1177                                 struct dcerpc_DnssrvOperation2_r_state);
1178         if (req == NULL) {
1179                 return NULL;
1180         }
1181
1182         state->out_mem_ctx = NULL;
1183
1184         subreq = dcerpc_binding_handle_call_send(state, ev, h,
1185                         NULL, &ndr_table_dnsserver,
1186                         NDR_DNSSRVOPERATION2, state, r);
1187         if (tevent_req_nomem(subreq, req)) {
1188                 return tevent_req_post(req, ev);
1189         }
1190         tevent_req_set_callback(subreq, dcerpc_DnssrvOperation2_r_done, req);
1191
1192         return req;
1193 }
1194
1195 static void dcerpc_DnssrvOperation2_r_done(struct tevent_req *subreq)
1196 {
1197         struct tevent_req *req =
1198                 tevent_req_callback_data(subreq,
1199                 struct tevent_req);
1200         NTSTATUS status;
1201
1202         status = dcerpc_binding_handle_call_recv(subreq);
1203         TALLOC_FREE(subreq);
1204         if (tevent_req_nterror(req, status)) {
1205                 return;
1206         }
1207
1208         tevent_req_done(req);
1209 }
1210
1211 NTSTATUS dcerpc_DnssrvOperation2_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
1212 {
1213         struct dcerpc_DnssrvOperation2_r_state *state =
1214                 tevent_req_data(req,
1215                 struct dcerpc_DnssrvOperation2_r_state);
1216         NTSTATUS status;
1217
1218         if (tevent_req_is_nterror(req, &status)) {
1219                 tevent_req_received(req);
1220                 return status;
1221         }
1222
1223         talloc_steal(mem_ctx, state->out_mem_ctx);
1224
1225         tevent_req_received(req);
1226         return NT_STATUS_OK;
1227 }
1228
1229 NTSTATUS dcerpc_DnssrvOperation2_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct DnssrvOperation2 *r)
1230 {
1231         NTSTATUS status;
1232
1233         status = dcerpc_binding_handle_call(h,
1234                         NULL, &ndr_table_dnsserver,
1235                         NDR_DNSSRVOPERATION2, mem_ctx, r);
1236
1237         return status;
1238 }
1239
1240 struct dcerpc_DnssrvOperation2_state {
1241         struct DnssrvOperation2 orig;
1242         struct DnssrvOperation2 tmp;
1243         TALLOC_CTX *out_mem_ctx;
1244 };
1245
1246 static void dcerpc_DnssrvOperation2_done(struct tevent_req *subreq);
1247
1248 struct tevent_req *dcerpc_DnssrvOperation2_send(TALLOC_CTX *mem_ctx,
1249                                                 struct tevent_context *ev,
1250                                                 struct dcerpc_binding_handle *h,
1251                                                 enum DNS_RPC_CLIENT_VERSION _dwClientVersion /* [in]  */,
1252                                                 uint32_t _dwSettingFlags /* [in]  */,
1253                                                 const char *_pwszServerName /* [in] [unique,charset(UTF16)] */,
1254                                                 const char *_pszZone /* [in] [unique,charset(UTF8)] */,
1255                                                 uint32_t _dwContext /* [in]  */,
1256                                                 const char *_pszOperation /* [in] [unique,charset(UTF8)] */,
1257                                                 enum DNS_RPC_TYPEID _dwTypeId /* [in]  */,
1258                                                 union DNSSRV_RPC_UNION _pData /* [in] [switch_is(dwTypeId)] */)
1259 {
1260         struct tevent_req *req;
1261         struct dcerpc_DnssrvOperation2_state *state;
1262         struct tevent_req *subreq;
1263
1264         req = tevent_req_create(mem_ctx, &state,
1265                                 struct dcerpc_DnssrvOperation2_state);
1266         if (req == NULL) {
1267                 return NULL;
1268         }
1269         state->out_mem_ctx = NULL;
1270
1271         /* In parameters */
1272         state->orig.in.dwClientVersion = _dwClientVersion;
1273         state->orig.in.dwSettingFlags = _dwSettingFlags;
1274         state->orig.in.pwszServerName = _pwszServerName;
1275         state->orig.in.pszZone = _pszZone;
1276         state->orig.in.dwContext = _dwContext;
1277         state->orig.in.pszOperation = _pszOperation;
1278         state->orig.in.dwTypeId = _dwTypeId;
1279         state->orig.in.pData = _pData;
1280
1281         /* Out parameters */
1282
1283         /* Result */
1284         ZERO_STRUCT(state->orig.out.result);
1285
1286         /* make a temporary copy, that we pass to the dispatch function */
1287         state->tmp = state->orig;
1288
1289         subreq = dcerpc_DnssrvOperation2_r_send(state, ev, h, &state->tmp);
1290         if (tevent_req_nomem(subreq, req)) {
1291                 return tevent_req_post(req, ev);
1292         }
1293         tevent_req_set_callback(subreq, dcerpc_DnssrvOperation2_done, req);
1294         return req;
1295 }
1296
1297 static void dcerpc_DnssrvOperation2_done(struct tevent_req *subreq)
1298 {
1299         struct tevent_req *req = tevent_req_callback_data(
1300                 subreq, struct tevent_req);
1301         struct dcerpc_DnssrvOperation2_state *state = tevent_req_data(
1302                 req, struct dcerpc_DnssrvOperation2_state);
1303         NTSTATUS status;
1304         TALLOC_CTX *mem_ctx;
1305
1306         if (state->out_mem_ctx) {
1307                 mem_ctx = state->out_mem_ctx;
1308         } else {
1309                 mem_ctx = state;
1310         }
1311
1312         status = dcerpc_DnssrvOperation2_r_recv(subreq, mem_ctx);
1313         TALLOC_FREE(subreq);
1314         if (tevent_req_nterror(req, status)) {
1315                 return;
1316         }
1317
1318         /* Copy out parameters */
1319
1320         /* Copy result */
1321         state->orig.out.result = state->tmp.out.result;
1322
1323         /* Reset temporary structure */
1324         ZERO_STRUCT(state->tmp);
1325
1326         tevent_req_done(req);
1327 }
1328
1329 NTSTATUS dcerpc_DnssrvOperation2_recv(struct tevent_req *req,
1330                                       TALLOC_CTX *mem_ctx,
1331                                       WERROR *result)
1332 {
1333         struct dcerpc_DnssrvOperation2_state *state = tevent_req_data(
1334                 req, struct dcerpc_DnssrvOperation2_state);
1335         NTSTATUS status;
1336
1337         if (tevent_req_is_nterror(req, &status)) {
1338                 tevent_req_received(req);
1339                 return status;
1340         }
1341
1342         /* Steal possible out parameters to the callers context */
1343         talloc_steal(mem_ctx, state->out_mem_ctx);
1344
1345         /* Return result */
1346         *result = state->orig.out.result;
1347
1348         tevent_req_received(req);
1349         return NT_STATUS_OK;
1350 }
1351
1352 NTSTATUS dcerpc_DnssrvOperation2(struct dcerpc_binding_handle *h,
1353                                  TALLOC_CTX *mem_ctx,
1354                                  enum DNS_RPC_CLIENT_VERSION _dwClientVersion /* [in]  */,
1355                                  uint32_t _dwSettingFlags /* [in]  */,
1356                                  const char *_pwszServerName /* [in] [unique,charset(UTF16)] */,
1357                                  const char *_pszZone /* [in] [unique,charset(UTF8)] */,
1358                                  uint32_t _dwContext /* [in]  */,
1359                                  const char *_pszOperation /* [in] [unique,charset(UTF8)] */,
1360                                  enum DNS_RPC_TYPEID _dwTypeId /* [in]  */,
1361                                  union DNSSRV_RPC_UNION _pData /* [in] [switch_is(dwTypeId)] */,
1362                                  WERROR *result)
1363 {
1364         struct DnssrvOperation2 r;
1365         NTSTATUS status;
1366
1367         /* In parameters */
1368         r.in.dwClientVersion = _dwClientVersion;
1369         r.in.dwSettingFlags = _dwSettingFlags;
1370         r.in.pwszServerName = _pwszServerName;
1371         r.in.pszZone = _pszZone;
1372         r.in.dwContext = _dwContext;
1373         r.in.pszOperation = _pszOperation;
1374         r.in.dwTypeId = _dwTypeId;
1375         r.in.pData = _pData;
1376
1377         status = dcerpc_DnssrvOperation2_r(h, mem_ctx, &r);
1378         if (!NT_STATUS_IS_OK(status)) {
1379                 return status;
1380         }
1381
1382         /* Return variables */
1383
1384         /* Return result */
1385         *result = r.out.result;
1386
1387         return NT_STATUS_OK;
1388 }
1389
1390 struct dcerpc_DnssrvQuery2_r_state {
1391         TALLOC_CTX *out_mem_ctx;
1392 };
1393
1394 static void dcerpc_DnssrvQuery2_r_done(struct tevent_req *subreq);
1395
1396 struct tevent_req *dcerpc_DnssrvQuery2_r_send(TALLOC_CTX *mem_ctx,
1397         struct tevent_context *ev,
1398         struct dcerpc_binding_handle *h,
1399         struct DnssrvQuery2 *r)
1400 {
1401         struct tevent_req *req;
1402         struct dcerpc_DnssrvQuery2_r_state *state;
1403         struct tevent_req *subreq;
1404
1405         req = tevent_req_create(mem_ctx, &state,
1406                                 struct dcerpc_DnssrvQuery2_r_state);
1407         if (req == NULL) {
1408                 return NULL;
1409         }
1410
1411         state->out_mem_ctx = talloc_new(state);
1412         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1413                 return tevent_req_post(req, ev);
1414         }
1415
1416         subreq = dcerpc_binding_handle_call_send(state, ev, h,
1417                         NULL, &ndr_table_dnsserver,
1418                         NDR_DNSSRVQUERY2, state->out_mem_ctx, r);
1419         if (tevent_req_nomem(subreq, req)) {
1420                 return tevent_req_post(req, ev);
1421         }
1422         tevent_req_set_callback(subreq, dcerpc_DnssrvQuery2_r_done, req);
1423
1424         return req;
1425 }
1426
1427 static void dcerpc_DnssrvQuery2_r_done(struct tevent_req *subreq)
1428 {
1429         struct tevent_req *req =
1430                 tevent_req_callback_data(subreq,
1431                 struct tevent_req);
1432         NTSTATUS status;
1433
1434         status = dcerpc_binding_handle_call_recv(subreq);
1435         TALLOC_FREE(subreq);
1436         if (tevent_req_nterror(req, status)) {
1437                 return;
1438         }
1439
1440         tevent_req_done(req);
1441 }
1442
1443 NTSTATUS dcerpc_DnssrvQuery2_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
1444 {
1445         struct dcerpc_DnssrvQuery2_r_state *state =
1446                 tevent_req_data(req,
1447                 struct dcerpc_DnssrvQuery2_r_state);
1448         NTSTATUS status;
1449
1450         if (tevent_req_is_nterror(req, &status)) {
1451                 tevent_req_received(req);
1452                 return status;
1453         }
1454
1455         talloc_steal(mem_ctx, state->out_mem_ctx);
1456
1457         tevent_req_received(req);
1458         return NT_STATUS_OK;
1459 }
1460
1461 NTSTATUS dcerpc_DnssrvQuery2_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct DnssrvQuery2 *r)
1462 {
1463         NTSTATUS status;
1464
1465         status = dcerpc_binding_handle_call(h,
1466                         NULL, &ndr_table_dnsserver,
1467                         NDR_DNSSRVQUERY2, mem_ctx, r);
1468
1469         return status;
1470 }
1471
1472 struct dcerpc_DnssrvQuery2_state {
1473         struct DnssrvQuery2 orig;
1474         struct DnssrvQuery2 tmp;
1475         TALLOC_CTX *out_mem_ctx;
1476 };
1477
1478 static void dcerpc_DnssrvQuery2_done(struct tevent_req *subreq);
1479
1480 struct tevent_req *dcerpc_DnssrvQuery2_send(TALLOC_CTX *mem_ctx,
1481                                             struct tevent_context *ev,
1482                                             struct dcerpc_binding_handle *h,
1483                                             enum DNS_RPC_CLIENT_VERSION _dwClientVersion /* [in]  */,
1484                                             uint32_t _dwSettingFlags /* [in]  */,
1485                                             const char *_pwszServerName /* [in] [unique,charset(UTF16)] */,
1486                                             const char *_pszZone /* [in] [unique,charset(UTF8)] */,
1487                                             const char *_pszOperation /* [in] [unique,charset(UTF8)] */,
1488                                             enum DNS_RPC_TYPEID *_pdwTypeId /* [out] [ref] */,
1489                                             union DNSSRV_RPC_UNION *_ppData /* [out] [ref,switch_is(*pdwTypeId)] */)
1490 {
1491         struct tevent_req *req;
1492         struct dcerpc_DnssrvQuery2_state *state;
1493         struct tevent_req *subreq;
1494
1495         req = tevent_req_create(mem_ctx, &state,
1496                                 struct dcerpc_DnssrvQuery2_state);
1497         if (req == NULL) {
1498                 return NULL;
1499         }
1500         state->out_mem_ctx = NULL;
1501
1502         /* In parameters */
1503         state->orig.in.dwClientVersion = _dwClientVersion;
1504         state->orig.in.dwSettingFlags = _dwSettingFlags;
1505         state->orig.in.pwszServerName = _pwszServerName;
1506         state->orig.in.pszZone = _pszZone;
1507         state->orig.in.pszOperation = _pszOperation;
1508
1509         /* Out parameters */
1510         state->orig.out.pdwTypeId = _pdwTypeId;
1511         state->orig.out.ppData = _ppData;
1512
1513         /* Result */
1514         ZERO_STRUCT(state->orig.out.result);
1515
1516         state->out_mem_ctx = talloc_named_const(state, 0,
1517                              "dcerpc_DnssrvQuery2_out_memory");
1518         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1519                 return tevent_req_post(req, ev);
1520         }
1521
1522         /* make a temporary copy, that we pass to the dispatch function */
1523         state->tmp = state->orig;
1524
1525         subreq = dcerpc_DnssrvQuery2_r_send(state, ev, h, &state->tmp);
1526         if (tevent_req_nomem(subreq, req)) {
1527                 return tevent_req_post(req, ev);
1528         }
1529         tevent_req_set_callback(subreq, dcerpc_DnssrvQuery2_done, req);
1530         return req;
1531 }
1532
1533 static void dcerpc_DnssrvQuery2_done(struct tevent_req *subreq)
1534 {
1535         struct tevent_req *req = tevent_req_callback_data(
1536                 subreq, struct tevent_req);
1537         struct dcerpc_DnssrvQuery2_state *state = tevent_req_data(
1538                 req, struct dcerpc_DnssrvQuery2_state);
1539         NTSTATUS status;
1540         TALLOC_CTX *mem_ctx;
1541
1542         if (state->out_mem_ctx) {
1543                 mem_ctx = state->out_mem_ctx;
1544         } else {
1545                 mem_ctx = state;
1546         }
1547
1548         status = dcerpc_DnssrvQuery2_r_recv(subreq, mem_ctx);
1549         TALLOC_FREE(subreq);
1550         if (tevent_req_nterror(req, status)) {
1551                 return;
1552         }
1553
1554         /* Copy out parameters */
1555         *state->orig.out.pdwTypeId = *state->tmp.out.pdwTypeId;
1556         *state->orig.out.ppData = *state->tmp.out.ppData;
1557
1558         /* Copy result */
1559         state->orig.out.result = state->tmp.out.result;
1560
1561         /* Reset temporary structure */
1562         ZERO_STRUCT(state->tmp);
1563
1564         tevent_req_done(req);
1565 }
1566
1567 NTSTATUS dcerpc_DnssrvQuery2_recv(struct tevent_req *req,
1568                                   TALLOC_CTX *mem_ctx,
1569                                   WERROR *result)
1570 {
1571         struct dcerpc_DnssrvQuery2_state *state = tevent_req_data(
1572                 req, struct dcerpc_DnssrvQuery2_state);
1573         NTSTATUS status;
1574
1575         if (tevent_req_is_nterror(req, &status)) {
1576                 tevent_req_received(req);
1577                 return status;
1578         }
1579
1580         /* Steal possible out parameters to the callers context */
1581         talloc_steal(mem_ctx, state->out_mem_ctx);
1582
1583         /* Return result */
1584         *result = state->orig.out.result;
1585
1586         tevent_req_received(req);
1587         return NT_STATUS_OK;
1588 }
1589
1590 NTSTATUS dcerpc_DnssrvQuery2(struct dcerpc_binding_handle *h,
1591                              TALLOC_CTX *mem_ctx,
1592                              enum DNS_RPC_CLIENT_VERSION _dwClientVersion /* [in]  */,
1593                              uint32_t _dwSettingFlags /* [in]  */,
1594                              const char *_pwszServerName /* [in] [unique,charset(UTF16)] */,
1595                              const char *_pszZone /* [in] [unique,charset(UTF8)] */,
1596                              const char *_pszOperation /* [in] [unique,charset(UTF8)] */,
1597                              enum DNS_RPC_TYPEID *_pdwTypeId /* [out] [ref] */,
1598                              union DNSSRV_RPC_UNION *_ppData /* [out] [ref,switch_is(*pdwTypeId)] */,
1599                              WERROR *result)
1600 {
1601         struct DnssrvQuery2 r;
1602         NTSTATUS status;
1603
1604         /* In parameters */
1605         r.in.dwClientVersion = _dwClientVersion;
1606         r.in.dwSettingFlags = _dwSettingFlags;
1607         r.in.pwszServerName = _pwszServerName;
1608         r.in.pszZone = _pszZone;
1609         r.in.pszOperation = _pszOperation;
1610
1611         status = dcerpc_DnssrvQuery2_r(h, mem_ctx, &r);
1612         if (!NT_STATUS_IS_OK(status)) {
1613                 return status;
1614         }
1615
1616         /* Return variables */
1617         *_pdwTypeId = *r.out.pdwTypeId;
1618         *_ppData = *r.out.ppData;
1619
1620         /* Return result */
1621         *result = r.out.result;
1622
1623         return NT_STATUS_OK;
1624 }
1625
1626 struct dcerpc_DnssrvComplexOperation2_r_state {
1627         TALLOC_CTX *out_mem_ctx;
1628 };
1629
1630 static void dcerpc_DnssrvComplexOperation2_r_done(struct tevent_req *subreq);
1631
1632 struct tevent_req *dcerpc_DnssrvComplexOperation2_r_send(TALLOC_CTX *mem_ctx,
1633         struct tevent_context *ev,
1634         struct dcerpc_binding_handle *h,
1635         struct DnssrvComplexOperation2 *r)
1636 {
1637         struct tevent_req *req;
1638         struct dcerpc_DnssrvComplexOperation2_r_state *state;
1639         struct tevent_req *subreq;
1640
1641         req = tevent_req_create(mem_ctx, &state,
1642                                 struct dcerpc_DnssrvComplexOperation2_r_state);
1643         if (req == NULL) {
1644                 return NULL;
1645         }
1646
1647         state->out_mem_ctx = talloc_new(state);
1648         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1649                 return tevent_req_post(req, ev);
1650         }
1651
1652         subreq = dcerpc_binding_handle_call_send(state, ev, h,
1653                         NULL, &ndr_table_dnsserver,
1654                         NDR_DNSSRVCOMPLEXOPERATION2, state->out_mem_ctx, r);
1655         if (tevent_req_nomem(subreq, req)) {
1656                 return tevent_req_post(req, ev);
1657         }
1658         tevent_req_set_callback(subreq, dcerpc_DnssrvComplexOperation2_r_done, req);
1659
1660         return req;
1661 }
1662
1663 static void dcerpc_DnssrvComplexOperation2_r_done(struct tevent_req *subreq)
1664 {
1665         struct tevent_req *req =
1666                 tevent_req_callback_data(subreq,
1667                 struct tevent_req);
1668         NTSTATUS status;
1669
1670         status = dcerpc_binding_handle_call_recv(subreq);
1671         TALLOC_FREE(subreq);
1672         if (tevent_req_nterror(req, status)) {
1673                 return;
1674         }
1675
1676         tevent_req_done(req);
1677 }
1678
1679 NTSTATUS dcerpc_DnssrvComplexOperation2_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
1680 {
1681         struct dcerpc_DnssrvComplexOperation2_r_state *state =
1682                 tevent_req_data(req,
1683                 struct dcerpc_DnssrvComplexOperation2_r_state);
1684         NTSTATUS status;
1685
1686         if (tevent_req_is_nterror(req, &status)) {
1687                 tevent_req_received(req);
1688                 return status;
1689         }
1690
1691         talloc_steal(mem_ctx, state->out_mem_ctx);
1692
1693         tevent_req_received(req);
1694         return NT_STATUS_OK;
1695 }
1696
1697 NTSTATUS dcerpc_DnssrvComplexOperation2_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct DnssrvComplexOperation2 *r)
1698 {
1699         NTSTATUS status;
1700
1701         status = dcerpc_binding_handle_call(h,
1702                         NULL, &ndr_table_dnsserver,
1703                         NDR_DNSSRVCOMPLEXOPERATION2, mem_ctx, r);
1704
1705         return status;
1706 }
1707
1708 struct dcerpc_DnssrvComplexOperation2_state {
1709         struct DnssrvComplexOperation2 orig;
1710         struct DnssrvComplexOperation2 tmp;
1711         TALLOC_CTX *out_mem_ctx;
1712 };
1713
1714 static void dcerpc_DnssrvComplexOperation2_done(struct tevent_req *subreq);
1715
1716 struct tevent_req *dcerpc_DnssrvComplexOperation2_send(TALLOC_CTX *mem_ctx,
1717                                                        struct tevent_context *ev,
1718                                                        struct dcerpc_binding_handle *h,
1719                                                        enum DNS_RPC_CLIENT_VERSION _dwClientVersion /* [in]  */,
1720                                                        uint32_t _dwSettingFlags /* [in]  */,
1721                                                        const char *_pwszServerName /* [in] [unique,charset(UTF16)] */,
1722                                                        const char *_pszZone /* [in] [unique,charset(UTF8)] */,
1723                                                        const char *_pszOperation /* [in] [unique,charset(UTF8)] */,
1724                                                        enum DNS_RPC_TYPEID _dwTypeIn /* [in]  */,
1725                                                        union DNSSRV_RPC_UNION _pDataIn /* [in] [switch_is(dwTypeIn)] */,
1726                                                        enum DNS_RPC_TYPEID *_pdwTypeOut /* [out] [ref] */,
1727                                                        union DNSSRV_RPC_UNION *_ppDataOut /* [out] [ref,switch_is(*pdwTypeOut)] */)
1728 {
1729         struct tevent_req *req;
1730         struct dcerpc_DnssrvComplexOperation2_state *state;
1731         struct tevent_req *subreq;
1732
1733         req = tevent_req_create(mem_ctx, &state,
1734                                 struct dcerpc_DnssrvComplexOperation2_state);
1735         if (req == NULL) {
1736                 return NULL;
1737         }
1738         state->out_mem_ctx = NULL;
1739
1740         /* In parameters */
1741         state->orig.in.dwClientVersion = _dwClientVersion;
1742         state->orig.in.dwSettingFlags = _dwSettingFlags;
1743         state->orig.in.pwszServerName = _pwszServerName;
1744         state->orig.in.pszZone = _pszZone;
1745         state->orig.in.pszOperation = _pszOperation;
1746         state->orig.in.dwTypeIn = _dwTypeIn;
1747         state->orig.in.pDataIn = _pDataIn;
1748
1749         /* Out parameters */
1750         state->orig.out.pdwTypeOut = _pdwTypeOut;
1751         state->orig.out.ppDataOut = _ppDataOut;
1752
1753         /* Result */
1754         ZERO_STRUCT(state->orig.out.result);
1755
1756         state->out_mem_ctx = talloc_named_const(state, 0,
1757                              "dcerpc_DnssrvComplexOperation2_out_memory");
1758         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1759                 return tevent_req_post(req, ev);
1760         }
1761
1762         /* make a temporary copy, that we pass to the dispatch function */
1763         state->tmp = state->orig;
1764
1765         subreq = dcerpc_DnssrvComplexOperation2_r_send(state, ev, h, &state->tmp);
1766         if (tevent_req_nomem(subreq, req)) {
1767                 return tevent_req_post(req, ev);
1768         }
1769         tevent_req_set_callback(subreq, dcerpc_DnssrvComplexOperation2_done, req);
1770         return req;
1771 }
1772
1773 static void dcerpc_DnssrvComplexOperation2_done(struct tevent_req *subreq)
1774 {
1775         struct tevent_req *req = tevent_req_callback_data(
1776                 subreq, struct tevent_req);
1777         struct dcerpc_DnssrvComplexOperation2_state *state = tevent_req_data(
1778                 req, struct dcerpc_DnssrvComplexOperation2_state);
1779         NTSTATUS status;
1780         TALLOC_CTX *mem_ctx;
1781
1782         if (state->out_mem_ctx) {
1783                 mem_ctx = state->out_mem_ctx;
1784         } else {
1785                 mem_ctx = state;
1786         }
1787
1788         status = dcerpc_DnssrvComplexOperation2_r_recv(subreq, mem_ctx);
1789         TALLOC_FREE(subreq);
1790         if (tevent_req_nterror(req, status)) {
1791                 return;
1792         }
1793
1794         /* Copy out parameters */
1795         *state->orig.out.pdwTypeOut = *state->tmp.out.pdwTypeOut;
1796         *state->orig.out.ppDataOut = *state->tmp.out.ppDataOut;
1797
1798         /* Copy result */
1799         state->orig.out.result = state->tmp.out.result;
1800
1801         /* Reset temporary structure */
1802         ZERO_STRUCT(state->tmp);
1803
1804         tevent_req_done(req);
1805 }
1806
1807 NTSTATUS dcerpc_DnssrvComplexOperation2_recv(struct tevent_req *req,
1808                                              TALLOC_CTX *mem_ctx,
1809                                              WERROR *result)
1810 {
1811         struct dcerpc_DnssrvComplexOperation2_state *state = tevent_req_data(
1812                 req, struct dcerpc_DnssrvComplexOperation2_state);
1813         NTSTATUS status;
1814
1815         if (tevent_req_is_nterror(req, &status)) {
1816                 tevent_req_received(req);
1817                 return status;
1818         }
1819
1820         /* Steal possible out parameters to the callers context */
1821         talloc_steal(mem_ctx, state->out_mem_ctx);
1822
1823         /* Return result */
1824         *result = state->orig.out.result;
1825
1826         tevent_req_received(req);
1827         return NT_STATUS_OK;
1828 }
1829
1830 NTSTATUS dcerpc_DnssrvComplexOperation2(struct dcerpc_binding_handle *h,
1831                                         TALLOC_CTX *mem_ctx,
1832                                         enum DNS_RPC_CLIENT_VERSION _dwClientVersion /* [in]  */,
1833                                         uint32_t _dwSettingFlags /* [in]  */,
1834                                         const char *_pwszServerName /* [in] [unique,charset(UTF16)] */,
1835                                         const char *_pszZone /* [in] [unique,charset(UTF8)] */,
1836                                         const char *_pszOperation /* [in] [unique,charset(UTF8)] */,
1837                                         enum DNS_RPC_TYPEID _dwTypeIn /* [in]  */,
1838                                         union DNSSRV_RPC_UNION _pDataIn /* [in] [switch_is(dwTypeIn)] */,
1839                                         enum DNS_RPC_TYPEID *_pdwTypeOut /* [out] [ref] */,
1840                                         union DNSSRV_RPC_UNION *_ppDataOut /* [out] [ref,switch_is(*pdwTypeOut)] */,
1841                                         WERROR *result)
1842 {
1843         struct DnssrvComplexOperation2 r;
1844         NTSTATUS status;
1845
1846         /* In parameters */
1847         r.in.dwClientVersion = _dwClientVersion;
1848         r.in.dwSettingFlags = _dwSettingFlags;
1849         r.in.pwszServerName = _pwszServerName;
1850         r.in.pszZone = _pszZone;
1851         r.in.pszOperation = _pszOperation;
1852         r.in.dwTypeIn = _dwTypeIn;
1853         r.in.pDataIn = _pDataIn;
1854
1855         status = dcerpc_DnssrvComplexOperation2_r(h, mem_ctx, &r);
1856         if (!NT_STATUS_IS_OK(status)) {
1857                 return status;
1858         }
1859
1860         /* Return variables */
1861         *_pdwTypeOut = *r.out.pdwTypeOut;
1862         *_ppDataOut = *r.out.ppDataOut;
1863
1864         /* Return result */
1865         *result = r.out.result;
1866
1867         return NT_STATUS_OK;
1868 }
1869
1870 struct dcerpc_DnssrvEnumRecords2_r_state {
1871         TALLOC_CTX *out_mem_ctx;
1872 };
1873
1874 static void dcerpc_DnssrvEnumRecords2_r_done(struct tevent_req *subreq);
1875
1876 struct tevent_req *dcerpc_DnssrvEnumRecords2_r_send(TALLOC_CTX *mem_ctx,
1877         struct tevent_context *ev,
1878         struct dcerpc_binding_handle *h,
1879         struct DnssrvEnumRecords2 *r)
1880 {
1881         struct tevent_req *req;
1882         struct dcerpc_DnssrvEnumRecords2_r_state *state;
1883         struct tevent_req *subreq;
1884
1885         req = tevent_req_create(mem_ctx, &state,
1886                                 struct dcerpc_DnssrvEnumRecords2_r_state);
1887         if (req == NULL) {
1888                 return NULL;
1889         }
1890
1891         state->out_mem_ctx = talloc_new(state);
1892         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1893                 return tevent_req_post(req, ev);
1894         }
1895
1896         subreq = dcerpc_binding_handle_call_send(state, ev, h,
1897                         NULL, &ndr_table_dnsserver,
1898                         NDR_DNSSRVENUMRECORDS2, state->out_mem_ctx, r);
1899         if (tevent_req_nomem(subreq, req)) {
1900                 return tevent_req_post(req, ev);
1901         }
1902         tevent_req_set_callback(subreq, dcerpc_DnssrvEnumRecords2_r_done, req);
1903
1904         return req;
1905 }
1906
1907 static void dcerpc_DnssrvEnumRecords2_r_done(struct tevent_req *subreq)
1908 {
1909         struct tevent_req *req =
1910                 tevent_req_callback_data(subreq,
1911                 struct tevent_req);
1912         NTSTATUS status;
1913
1914         status = dcerpc_binding_handle_call_recv(subreq);
1915         TALLOC_FREE(subreq);
1916         if (tevent_req_nterror(req, status)) {
1917                 return;
1918         }
1919
1920         tevent_req_done(req);
1921 }
1922
1923 NTSTATUS dcerpc_DnssrvEnumRecords2_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
1924 {
1925         struct dcerpc_DnssrvEnumRecords2_r_state *state =
1926                 tevent_req_data(req,
1927                 struct dcerpc_DnssrvEnumRecords2_r_state);
1928         NTSTATUS status;
1929
1930         if (tevent_req_is_nterror(req, &status)) {
1931                 tevent_req_received(req);
1932                 return status;
1933         }
1934
1935         talloc_steal(mem_ctx, state->out_mem_ctx);
1936
1937         tevent_req_received(req);
1938         return NT_STATUS_OK;
1939 }
1940
1941 NTSTATUS dcerpc_DnssrvEnumRecords2_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct DnssrvEnumRecords2 *r)
1942 {
1943         NTSTATUS status;
1944
1945         status = dcerpc_binding_handle_call(h,
1946                         NULL, &ndr_table_dnsserver,
1947                         NDR_DNSSRVENUMRECORDS2, mem_ctx, r);
1948
1949         return status;
1950 }
1951
1952 struct dcerpc_DnssrvEnumRecords2_state {
1953         struct DnssrvEnumRecords2 orig;
1954         struct DnssrvEnumRecords2 tmp;
1955         TALLOC_CTX *out_mem_ctx;
1956 };
1957
1958 static void dcerpc_DnssrvEnumRecords2_done(struct tevent_req *subreq);
1959
1960 struct tevent_req *dcerpc_DnssrvEnumRecords2_send(TALLOC_CTX *mem_ctx,
1961                                                   struct tevent_context *ev,
1962                                                   struct dcerpc_binding_handle *h,
1963                                                   enum DNS_RPC_CLIENT_VERSION _dwClientVersion /* [in]  */,
1964                                                   uint32_t _dwSettingFlags /* [in]  */,
1965                                                   const char *_pwszServerName /* [in] [unique,charset(UTF16)] */,
1966                                                   const char *_pszZone /* [in] [unique,charset(UTF8)] */,
1967                                                   const char *_pszNodeName /* [in] [unique,charset(UTF8)] */,
1968                                                   const char *_pszStartChild /* [in] [unique,charset(UTF8)] */,
1969                                                   enum dns_record_type _wRecordType /* [in]  */,
1970                                                   uint32_t _fSelectFlag /* [in]  */,
1971                                                   const char *_pszFilterStart /* [in] [unique,charset(UTF8)] */,
1972                                                   const char *_pszFilterStop /* [in] [unique,charset(UTF8)] */,
1973                                                   uint32_t *_pdwBufferLength /* [out] [ref] */,
1974                                                   struct DNS_RPC_RECORDS_ARRAY **_pBuffer /* [out] [subcontext_size(*pdwBufferLength),subcontext(4),ref] */)
1975 {
1976         struct tevent_req *req;
1977         struct dcerpc_DnssrvEnumRecords2_state *state;
1978         struct tevent_req *subreq;
1979
1980         req = tevent_req_create(mem_ctx, &state,
1981                                 struct dcerpc_DnssrvEnumRecords2_state);
1982         if (req == NULL) {
1983                 return NULL;
1984         }
1985         state->out_mem_ctx = NULL;
1986
1987         /* In parameters */
1988         state->orig.in.dwClientVersion = _dwClientVersion;
1989         state->orig.in.dwSettingFlags = _dwSettingFlags;
1990         state->orig.in.pwszServerName = _pwszServerName;
1991         state->orig.in.pszZone = _pszZone;
1992         state->orig.in.pszNodeName = _pszNodeName;
1993         state->orig.in.pszStartChild = _pszStartChild;
1994         state->orig.in.wRecordType = _wRecordType;
1995         state->orig.in.fSelectFlag = _fSelectFlag;
1996         state->orig.in.pszFilterStart = _pszFilterStart;
1997         state->orig.in.pszFilterStop = _pszFilterStop;
1998
1999         /* Out parameters */
2000         state->orig.out.pdwBufferLength = _pdwBufferLength;
2001         state->orig.out.pBuffer = _pBuffer;
2002
2003         /* Result */
2004         ZERO_STRUCT(state->orig.out.result);
2005
2006         state->out_mem_ctx = talloc_named_const(state, 0,
2007                              "dcerpc_DnssrvEnumRecords2_out_memory");
2008         if (tevent_req_nomem(state->out_mem_ctx, req)) {
2009                 return tevent_req_post(req, ev);
2010         }
2011
2012         /* make a temporary copy, that we pass to the dispatch function */
2013         state->tmp = state->orig;
2014
2015         subreq = dcerpc_DnssrvEnumRecords2_r_send(state, ev, h, &state->tmp);
2016         if (tevent_req_nomem(subreq, req)) {
2017                 return tevent_req_post(req, ev);
2018         }
2019         tevent_req_set_callback(subreq, dcerpc_DnssrvEnumRecords2_done, req);
2020         return req;
2021 }
2022
2023 static void dcerpc_DnssrvEnumRecords2_done(struct tevent_req *subreq)
2024 {
2025         struct tevent_req *req = tevent_req_callback_data(
2026                 subreq, struct tevent_req);
2027         struct dcerpc_DnssrvEnumRecords2_state *state = tevent_req_data(
2028                 req, struct dcerpc_DnssrvEnumRecords2_state);
2029         NTSTATUS status;
2030         TALLOC_CTX *mem_ctx;
2031
2032         if (state->out_mem_ctx) {
2033                 mem_ctx = state->out_mem_ctx;
2034         } else {
2035                 mem_ctx = state;
2036         }
2037
2038         status = dcerpc_DnssrvEnumRecords2_r_recv(subreq, mem_ctx);
2039         TALLOC_FREE(subreq);
2040         if (tevent_req_nterror(req, status)) {
2041                 return;
2042         }
2043
2044         /* Copy out parameters */
2045         *state->orig.out.pdwBufferLength = *state->tmp.out.pdwBufferLength;
2046         *state->orig.out.pBuffer = *state->tmp.out.pBuffer;
2047
2048         /* Copy result */
2049         state->orig.out.result = state->tmp.out.result;
2050
2051         /* Reset temporary structure */
2052         ZERO_STRUCT(state->tmp);
2053
2054         tevent_req_done(req);
2055 }
2056
2057 NTSTATUS dcerpc_DnssrvEnumRecords2_recv(struct tevent_req *req,
2058                                         TALLOC_CTX *mem_ctx,
2059                                         WERROR *result)
2060 {
2061         struct dcerpc_DnssrvEnumRecords2_state *state = tevent_req_data(
2062                 req, struct dcerpc_DnssrvEnumRecords2_state);
2063         NTSTATUS status;
2064
2065         if (tevent_req_is_nterror(req, &status)) {
2066                 tevent_req_received(req);
2067                 return status;
2068         }
2069
2070         /* Steal possible out parameters to the callers context */
2071         talloc_steal(mem_ctx, state->out_mem_ctx);
2072
2073         /* Return result */
2074         *result = state->orig.out.result;
2075
2076         tevent_req_received(req);
2077         return NT_STATUS_OK;
2078 }
2079
2080 NTSTATUS dcerpc_DnssrvEnumRecords2(struct dcerpc_binding_handle *h,
2081                                    TALLOC_CTX *mem_ctx,
2082                                    enum DNS_RPC_CLIENT_VERSION _dwClientVersion /* [in]  */,
2083                                    uint32_t _dwSettingFlags /* [in]  */,
2084                                    const char *_pwszServerName /* [in] [unique,charset(UTF16)] */,
2085                                    const char *_pszZone /* [in] [unique,charset(UTF8)] */,
2086                                    const char *_pszNodeName /* [in] [unique,charset(UTF8)] */,
2087                                    const char *_pszStartChild /* [in] [unique,charset(UTF8)] */,
2088                                    enum dns_record_type _wRecordType /* [in]  */,
2089                                    uint32_t _fSelectFlag /* [in]  */,
2090                                    const char *_pszFilterStart /* [in] [unique,charset(UTF8)] */,
2091                                    const char *_pszFilterStop /* [in] [unique,charset(UTF8)] */,
2092                                    uint32_t *_pdwBufferLength /* [out] [ref] */,
2093                                    struct DNS_RPC_RECORDS_ARRAY **_pBuffer /* [out] [subcontext_size(*pdwBufferLength),subcontext(4),ref] */,
2094                                    WERROR *result)
2095 {
2096         struct DnssrvEnumRecords2 r;
2097         NTSTATUS status;
2098
2099         /* In parameters */
2100         r.in.dwClientVersion = _dwClientVersion;
2101         r.in.dwSettingFlags = _dwSettingFlags;
2102         r.in.pwszServerName = _pwszServerName;
2103         r.in.pszZone = _pszZone;
2104         r.in.pszNodeName = _pszNodeName;
2105         r.in.pszStartChild = _pszStartChild;
2106         r.in.wRecordType = _wRecordType;
2107         r.in.fSelectFlag = _fSelectFlag;
2108         r.in.pszFilterStart = _pszFilterStart;
2109         r.in.pszFilterStop = _pszFilterStop;
2110
2111         status = dcerpc_DnssrvEnumRecords2_r(h, mem_ctx, &r);
2112         if (!NT_STATUS_IS_OK(status)) {
2113                 return status;
2114         }
2115
2116         /* Return variables */
2117         *_pdwBufferLength = *r.out.pdwBufferLength;
2118         *_pBuffer = *r.out.pBuffer;
2119
2120         /* Return result */
2121         *result = r.out.result;
2122
2123         return NT_STATUS_OK;
2124 }
2125
2126 struct dcerpc_DnssrvUpdateRecord2_r_state {
2127         TALLOC_CTX *out_mem_ctx;
2128 };
2129
2130 static void dcerpc_DnssrvUpdateRecord2_r_done(struct tevent_req *subreq);
2131
2132 struct tevent_req *dcerpc_DnssrvUpdateRecord2_r_send(TALLOC_CTX *mem_ctx,
2133         struct tevent_context *ev,
2134         struct dcerpc_binding_handle *h,
2135         struct DnssrvUpdateRecord2 *r)
2136 {
2137         struct tevent_req *req;
2138         struct dcerpc_DnssrvUpdateRecord2_r_state *state;
2139         struct tevent_req *subreq;
2140
2141         req = tevent_req_create(mem_ctx, &state,
2142                                 struct dcerpc_DnssrvUpdateRecord2_r_state);
2143         if (req == NULL) {
2144                 return NULL;
2145         }
2146
2147         state->out_mem_ctx = NULL;
2148
2149         subreq = dcerpc_binding_handle_call_send(state, ev, h,
2150                         NULL, &ndr_table_dnsserver,
2151                         NDR_DNSSRVUPDATERECORD2, state, r);
2152         if (tevent_req_nomem(subreq, req)) {
2153                 return tevent_req_post(req, ev);
2154         }
2155         tevent_req_set_callback(subreq, dcerpc_DnssrvUpdateRecord2_r_done, req);
2156
2157         return req;
2158 }
2159
2160 static void dcerpc_DnssrvUpdateRecord2_r_done(struct tevent_req *subreq)
2161 {
2162         struct tevent_req *req =
2163                 tevent_req_callback_data(subreq,
2164                 struct tevent_req);
2165         NTSTATUS status;
2166
2167         status = dcerpc_binding_handle_call_recv(subreq);
2168         TALLOC_FREE(subreq);
2169         if (tevent_req_nterror(req, status)) {
2170                 return;
2171         }
2172
2173         tevent_req_done(req);
2174 }
2175
2176 NTSTATUS dcerpc_DnssrvUpdateRecord2_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
2177 {
2178         struct dcerpc_DnssrvUpdateRecord2_r_state *state =
2179                 tevent_req_data(req,
2180                 struct dcerpc_DnssrvUpdateRecord2_r_state);
2181         NTSTATUS status;
2182
2183         if (tevent_req_is_nterror(req, &status)) {
2184                 tevent_req_received(req);
2185                 return status;
2186         }
2187
2188         talloc_steal(mem_ctx, state->out_mem_ctx);
2189
2190         tevent_req_received(req);
2191         return NT_STATUS_OK;
2192 }
2193
2194 NTSTATUS dcerpc_DnssrvUpdateRecord2_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct DnssrvUpdateRecord2 *r)
2195 {
2196         NTSTATUS status;
2197
2198         status = dcerpc_binding_handle_call(h,
2199                         NULL, &ndr_table_dnsserver,
2200                         NDR_DNSSRVUPDATERECORD2, mem_ctx, r);
2201
2202         return status;
2203 }
2204
2205 struct dcerpc_DnssrvUpdateRecord2_state {
2206         struct DnssrvUpdateRecord2 orig;
2207         struct DnssrvUpdateRecord2 tmp;
2208         TALLOC_CTX *out_mem_ctx;
2209 };
2210
2211 static void dcerpc_DnssrvUpdateRecord2_done(struct tevent_req *subreq);
2212
2213 struct tevent_req *dcerpc_DnssrvUpdateRecord2_send(TALLOC_CTX *mem_ctx,
2214                                                    struct tevent_context *ev,
2215                                                    struct dcerpc_binding_handle *h,
2216                                                    enum DNS_RPC_CLIENT_VERSION _dwClientVersion /* [in]  */,
2217                                                    uint32_t _dwSettingFlags /* [in]  */,
2218                                                    const char *_pwszServerName /* [in] [unique,charset(UTF16)] */,
2219                                                    const char *_pszZone /* [in] [unique,charset(UTF8)] */,
2220                                                    const char *_pszNodeName /* [in] [ref,charset(UTF8)] */,
2221                                                    struct DNS_RPC_RECORD_BUF *_pAddRecord /* [in] [unique] */,
2222                                                    struct DNS_RPC_RECORD_BUF *_pDeleteRecord /* [in] [unique] */)
2223 {
2224         struct tevent_req *req;
2225         struct dcerpc_DnssrvUpdateRecord2_state *state;
2226         struct tevent_req *subreq;
2227
2228         req = tevent_req_create(mem_ctx, &state,
2229                                 struct dcerpc_DnssrvUpdateRecord2_state);
2230         if (req == NULL) {
2231                 return NULL;
2232         }
2233         state->out_mem_ctx = NULL;
2234
2235         /* In parameters */
2236         state->orig.in.dwClientVersion = _dwClientVersion;
2237         state->orig.in.dwSettingFlags = _dwSettingFlags;
2238         state->orig.in.pwszServerName = _pwszServerName;
2239         state->orig.in.pszZone = _pszZone;
2240         state->orig.in.pszNodeName = _pszNodeName;
2241         state->orig.in.pAddRecord = _pAddRecord;
2242         state->orig.in.pDeleteRecord = _pDeleteRecord;
2243
2244         /* Out parameters */
2245
2246         /* Result */
2247         ZERO_STRUCT(state->orig.out.result);
2248
2249         /* make a temporary copy, that we pass to the dispatch function */
2250         state->tmp = state->orig;
2251
2252         subreq = dcerpc_DnssrvUpdateRecord2_r_send(state, ev, h, &state->tmp);
2253         if (tevent_req_nomem(subreq, req)) {
2254                 return tevent_req_post(req, ev);
2255         }
2256         tevent_req_set_callback(subreq, dcerpc_DnssrvUpdateRecord2_done, req);
2257         return req;
2258 }
2259
2260 static void dcerpc_DnssrvUpdateRecord2_done(struct tevent_req *subreq)
2261 {
2262         struct tevent_req *req = tevent_req_callback_data(
2263                 subreq, struct tevent_req);
2264         struct dcerpc_DnssrvUpdateRecord2_state *state = tevent_req_data(
2265                 req, struct dcerpc_DnssrvUpdateRecord2_state);
2266         NTSTATUS status;
2267         TALLOC_CTX *mem_ctx;
2268
2269         if (state->out_mem_ctx) {
2270                 mem_ctx = state->out_mem_ctx;
2271         } else {
2272                 mem_ctx = state;
2273         }
2274
2275         status = dcerpc_DnssrvUpdateRecord2_r_recv(subreq, mem_ctx);
2276         TALLOC_FREE(subreq);
2277         if (tevent_req_nterror(req, status)) {
2278                 return;
2279         }
2280
2281         /* Copy out parameters */
2282
2283         /* Copy result */
2284         state->orig.out.result = state->tmp.out.result;
2285
2286         /* Reset temporary structure */
2287         ZERO_STRUCT(state->tmp);
2288
2289         tevent_req_done(req);
2290 }
2291
2292 NTSTATUS dcerpc_DnssrvUpdateRecord2_recv(struct tevent_req *req,
2293                                          TALLOC_CTX *mem_ctx,
2294                                          WERROR *result)
2295 {
2296         struct dcerpc_DnssrvUpdateRecord2_state *state = tevent_req_data(
2297                 req, struct dcerpc_DnssrvUpdateRecord2_state);
2298         NTSTATUS status;
2299
2300         if (tevent_req_is_nterror(req, &status)) {
2301                 tevent_req_received(req);
2302                 return status;
2303         }
2304
2305         /* Steal possible out parameters to the callers context */
2306         talloc_steal(mem_ctx, state->out_mem_ctx);
2307
2308         /* Return result */
2309         *result = state->orig.out.result;
2310
2311         tevent_req_received(req);
2312         return NT_STATUS_OK;
2313 }
2314
2315 NTSTATUS dcerpc_DnssrvUpdateRecord2(struct dcerpc_binding_handle *h,
2316                                     TALLOC_CTX *mem_ctx,
2317                                     enum DNS_RPC_CLIENT_VERSION _dwClientVersion /* [in]  */,
2318                                     uint32_t _dwSettingFlags /* [in]  */,
2319                                     const char *_pwszServerName /* [in] [unique,charset(UTF16)] */,
2320                                     const char *_pszZone /* [in] [unique,charset(UTF8)] */,
2321                                     const char *_pszNodeName /* [in] [ref,charset(UTF8)] */,
2322                                     struct DNS_RPC_RECORD_BUF *_pAddRecord /* [in] [unique] */,
2323                                     struct DNS_RPC_RECORD_BUF *_pDeleteRecord /* [in] [unique] */,
2324                                     WERROR *result)
2325 {
2326         struct DnssrvUpdateRecord2 r;
2327         NTSTATUS status;
2328
2329         /* In parameters */
2330         r.in.dwClientVersion = _dwClientVersion;
2331         r.in.dwSettingFlags = _dwSettingFlags;
2332         r.in.pwszServerName = _pwszServerName;
2333         r.in.pszZone = _pszZone;
2334         r.in.pszNodeName = _pszNodeName;
2335         r.in.pAddRecord = _pAddRecord;
2336         r.in.pDeleteRecord = _pDeleteRecord;
2337
2338         status = dcerpc_DnssrvUpdateRecord2_r(h, mem_ctx, &r);
2339         if (!NT_STATUS_IS_OK(status)) {
2340                 return status;
2341         }
2342
2343         /* Return variables */
2344
2345         /* Return result */
2346         *result = r.out.result;
2347
2348         return NT_STATUS_OK;
2349 }
2350