source3/librpc/gen_ndr/ndr_epmapper_c.c

   1 /* client functions auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include <tevent.h>
   5 #include "lib/util/tevent_ntstatus.h"
   6 #include "librpc/gen_ndr/ndr_epmapper.h"
   7 #include "librpc/gen_ndr/ndr_epmapper_c.h"
   8
   9 /* epmapper - client functions generated by pidl */
  10
  11 struct dcerpc_epm_Insert_r_state {
  12         TALLOC_CTX *out_mem_ctx;
  13 };
  14
  15 static void dcerpc_epm_Insert_r_done(struct tevent_req *subreq);
  16
  17 struct tevent_req *dcerpc_epm_Insert_r_send(TALLOC_CTX *mem_ctx,
  18         struct tevent_context *ev,
  19         struct dcerpc_binding_handle *h,
  20         struct epm_Insert *r)
  21 {
  22         struct tevent_req *req;
  23         struct dcerpc_epm_Insert_r_state *state;
  24         struct tevent_req *subreq;
  25
  26         req = tevent_req_create(mem_ctx, &state,
  27                                 struct dcerpc_epm_Insert_r_state);
  28         if (req == NULL) {
  29                 return NULL;
  30         }
  31
  32         state->out_mem_ctx = NULL;
  33         subreq = dcerpc_binding_handle_call_send(state, ev, h,
  34                         NULL, &ndr_table_epmapper,
  35                         NDR_EPM_INSERT, state, r);
  36         if (tevent_req_nomem(subreq, req)) {
  37                 return tevent_req_post(req, ev);
  38         }
  39         tevent_req_set_callback(subreq, dcerpc_epm_Insert_r_done, req);
  40
  41         return req;
  42 }
  43
  44 static void dcerpc_epm_Insert_r_done(struct tevent_req *subreq)
  45 {
  46         struct tevent_req *req =
  47                 tevent_req_callback_data(subreq,
  48                 struct tevent_req);
  49         NTSTATUS status;
  50
  51         status = dcerpc_binding_handle_call_recv(subreq);
  52         if (!NT_STATUS_IS_OK(status)) {
  53                 tevent_req_nterror(req, status);
  54                 return;
  55         }
  56
  57         tevent_req_done(req);
  58 }
  59
  60 NTSTATUS dcerpc_epm_Insert_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
  61 {
  62         struct dcerpc_epm_Insert_r_state *state =
  63                 tevent_req_data(req,
  64                 struct dcerpc_epm_Insert_r_state);
  65         NTSTATUS status;
  66
  67         if (tevent_req_is_nterror(req, &status)) {
  68                 tevent_req_received(req);
  69                 return status;
  70         }
  71
  72         talloc_steal(mem_ctx, state->out_mem_ctx);
  73
  74         tevent_req_received(req);
  75         return NT_STATUS_OK;
  76 }
  77
  78 NTSTATUS dcerpc_epm_Insert_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct epm_Insert *r)
  79 {
  80         NTSTATUS status;
  81
  82         status = dcerpc_binding_handle_call(h,
  83                         NULL, &ndr_table_epmapper,
  84                         NDR_EPM_INSERT, mem_ctx, r);
  85
  86         return status;
  87 }
  88
  89 NTSTATUS dcerpc_epm_Insert_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct epm_Insert *r)
  90 {
  91         NTSTATUS status;
  92
  93         status = dcerpc_epm_Insert_r(p->binding_handle, mem_ctx, r);
  94
  95         if (NT_STATUS_IS_RPC(status)) {
  96                 status = NT_STATUS_NET_WRITE_FAULT;
  97         }
  98
  99         return status;
 100 }
 101
 102 struct dcerpc_epm_Insert_state {
 103         struct epm_Insert orig;
 104         struct epm_Insert tmp;
 105         TALLOC_CTX *out_mem_ctx;
 106 };
 107
 108 static void dcerpc_epm_Insert_done(struct tevent_req *subreq);
 109
 110 struct tevent_req *dcerpc_epm_Insert_send(TALLOC_CTX *mem_ctx,
 111                                           struct tevent_context *ev,
 112                                           struct dcerpc_binding_handle *h,
 113                                           uint32_t _num_ents /* [in]  */,
 114                                           struct epm_entry_t *_entries /* [in] [size_is(num_ents)] */,
 115                                           uint32_t _replace /* [in]  */)
 116 {
 117         struct tevent_req *req;
 118         struct dcerpc_epm_Insert_state *state;
 119         struct tevent_req *subreq;
 120
 121         req = tevent_req_create(mem_ctx, &state,
 122                                 struct dcerpc_epm_Insert_state);
 123         if (req == NULL) {
 124                 return NULL;
 125         }
 126         state->out_mem_ctx = NULL;
 127
 128         /* In parameters */
 129         state->orig.in.num_ents = _num_ents;
 130         state->orig.in.entries = _entries;
 131         state->orig.in.replace = _replace;
 132
 133         /* Out parameters */
 134
 135         /* Result */
 136         ZERO_STRUCT(state->orig.out.result);
 137
 138         /* make a temporary copy, that we pass to the dispatch function */
 139         state->tmp = state->orig;
 140
 141         subreq = dcerpc_epm_Insert_r_send(state, ev, h, &state->tmp);
 142         if (tevent_req_nomem(subreq, req)) {
 143                 return tevent_req_post(req, ev);
 144         }
 145         tevent_req_set_callback(subreq, dcerpc_epm_Insert_done, req);
 146         return req;
 147 }
 148
 149 static void dcerpc_epm_Insert_done(struct tevent_req *subreq)
 150 {
 151         struct tevent_req *req = tevent_req_callback_data(
 152                 subreq, struct tevent_req);
 153         struct dcerpc_epm_Insert_state *state = tevent_req_data(
 154                 req, struct dcerpc_epm_Insert_state);
 155         NTSTATUS status;
 156         TALLOC_CTX *mem_ctx;
 157
 158         if (state->out_mem_ctx) {
 159                 mem_ctx = state->out_mem_ctx;
 160         } else {
 161                 mem_ctx = state;
 162         }
 163
 164         status = dcerpc_epm_Insert_r_recv(subreq, mem_ctx);
 165         TALLOC_FREE(subreq);
 166         if (!NT_STATUS_IS_OK(status)) {
 167                 tevent_req_nterror(req, status);
 168                 return;
 169         }
 170
 171         /* Copy out parameters */
 172
 173         /* Copy result */
 174         state->orig.out.result = state->tmp.out.result;
 175
 176         /* Reset temporary structure */
 177         ZERO_STRUCT(state->tmp);
 178
 179         tevent_req_done(req);
 180 }
 181
 182 NTSTATUS dcerpc_epm_Insert_recv(struct tevent_req *req,
 183                                 TALLOC_CTX *mem_ctx,
 184                                 uint32_t *result)
 185 {
 186         struct dcerpc_epm_Insert_state *state = tevent_req_data(
 187                 req, struct dcerpc_epm_Insert_state);
 188         NTSTATUS status;
 189
 190         if (tevent_req_is_nterror(req, &status)) {
 191                 tevent_req_received(req);
 192                 return status;
 193         }
 194
 195         /* Steal possible out parameters to the callers context */
 196         talloc_steal(mem_ctx, state->out_mem_ctx);
 197
 198         /* Return result */
 199         *result = state->orig.out.result;
 200
 201         tevent_req_received(req);
 202         return NT_STATUS_OK;
 203 }
 204
 205 NTSTATUS dcerpc_epm_Insert(struct dcerpc_binding_handle *h,
 206                            TALLOC_CTX *mem_ctx,
 207                            uint32_t _num_ents /* [in]  */,
 208                            struct epm_entry_t *_entries /* [in] [size_is(num_ents)] */,
 209                            uint32_t _replace /* [in]  */,
 210                            uint32_t *result)
 211 {
 212         struct epm_Insert r;
 213         NTSTATUS status;
 214
 215         /* In parameters */
 216         r.in.num_ents = _num_ents;
 217         r.in.entries = _entries;
 218         r.in.replace = _replace;
 219
 220         status = dcerpc_epm_Insert_r(h, mem_ctx, &r);
 221         if (!NT_STATUS_IS_OK(status)) {
 222                 return status;
 223         }
 224
 225         /* Return variables */
 226
 227         /* Return result */
 228         *result = r.out.result;
 229
 230         return NT_STATUS_OK;
 231 }
 232
 233 struct dcerpc_epm_Delete_r_state {
 234         TALLOC_CTX *out_mem_ctx;
 235 };
 236
 237 static void dcerpc_epm_Delete_r_done(struct tevent_req *subreq);
 238
 239 struct tevent_req *dcerpc_epm_Delete_r_send(TALLOC_CTX *mem_ctx,
 240         struct tevent_context *ev,
 241         struct dcerpc_binding_handle *h,
 242         struct epm_Delete *r)
 243 {
 244         struct tevent_req *req;
 245         struct dcerpc_epm_Delete_r_state *state;
 246         struct tevent_req *subreq;
 247
 248         req = tevent_req_create(mem_ctx, &state,
 249                                 struct dcerpc_epm_Delete_r_state);
 250         if (req == NULL) {
 251                 return NULL;
 252         }
 253
 254         state->out_mem_ctx = NULL;
 255         subreq = dcerpc_binding_handle_call_send(state, ev, h,
 256                         NULL, &ndr_table_epmapper,
 257                         NDR_EPM_DELETE, state, r);
 258         if (tevent_req_nomem(subreq, req)) {
 259                 return tevent_req_post(req, ev);
 260         }
 261         tevent_req_set_callback(subreq, dcerpc_epm_Delete_r_done, req);
 262
 263         return req;
 264 }
 265
 266 static void dcerpc_epm_Delete_r_done(struct tevent_req *subreq)
 267 {
 268         struct tevent_req *req =
 269                 tevent_req_callback_data(subreq,
 270                 struct tevent_req);
 271         NTSTATUS status;
 272
 273         status = dcerpc_binding_handle_call_recv(subreq);
 274         if (!NT_STATUS_IS_OK(status)) {
 275                 tevent_req_nterror(req, status);
 276                 return;
 277         }
 278
 279         tevent_req_done(req);
 280 }
 281
 282 NTSTATUS dcerpc_epm_Delete_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 283 {
 284         struct dcerpc_epm_Delete_r_state *state =
 285                 tevent_req_data(req,
 286                 struct dcerpc_epm_Delete_r_state);
 287         NTSTATUS status;
 288
 289         if (tevent_req_is_nterror(req, &status)) {
 290                 tevent_req_received(req);
 291                 return status;
 292         }
 293
 294         talloc_steal(mem_ctx, state->out_mem_ctx);
 295
 296         tevent_req_received(req);
 297         return NT_STATUS_OK;
 298 }
 299
 300 NTSTATUS dcerpc_epm_Delete_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct epm_Delete *r)
 301 {
 302         NTSTATUS status;
 303
 304         status = dcerpc_binding_handle_call(h,
 305                         NULL, &ndr_table_epmapper,
 306                         NDR_EPM_DELETE, mem_ctx, r);
 307
 308         return status;
 309 }
 310
 311 NTSTATUS dcerpc_epm_Delete_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct epm_Delete *r)
 312 {
 313         NTSTATUS status;
 314
 315         status = dcerpc_epm_Delete_r(p->binding_handle, mem_ctx, r);
 316
 317         if (NT_STATUS_IS_RPC(status)) {
 318                 status = NT_STATUS_NET_WRITE_FAULT;
 319         }
 320
 321         return status;
 322 }
 323
 324 struct dcerpc_epm_Delete_state {
 325         struct epm_Delete orig;
 326         struct epm_Delete tmp;
 327         TALLOC_CTX *out_mem_ctx;
 328 };
 329
 330 static void dcerpc_epm_Delete_done(struct tevent_req *subreq);
 331
 332 struct tevent_req *dcerpc_epm_Delete_send(TALLOC_CTX *mem_ctx,
 333                                           struct tevent_context *ev,
 334                                           struct dcerpc_binding_handle *h,
 335                                           uint32_t _num_ents /* [in]  */,
 336                                           struct epm_entry_t *_entries /* [in] [size_is(num_ents)] */)
 337 {
 338         struct tevent_req *req;
 339         struct dcerpc_epm_Delete_state *state;
 340         struct tevent_req *subreq;
 341
 342         req = tevent_req_create(mem_ctx, &state,
 343                                 struct dcerpc_epm_Delete_state);
 344         if (req == NULL) {
 345                 return NULL;
 346         }
 347         state->out_mem_ctx = NULL;
 348
 349         /* In parameters */
 350         state->orig.in.num_ents = _num_ents;
 351         state->orig.in.entries = _entries;
 352
 353         /* Out parameters */
 354
 355         /* Result */
 356         ZERO_STRUCT(state->orig.out.result);
 357
 358         /* make a temporary copy, that we pass to the dispatch function */
 359         state->tmp = state->orig;
 360
 361         subreq = dcerpc_epm_Delete_r_send(state, ev, h, &state->tmp);
 362         if (tevent_req_nomem(subreq, req)) {
 363                 return tevent_req_post(req, ev);
 364         }
 365         tevent_req_set_callback(subreq, dcerpc_epm_Delete_done, req);
 366         return req;
 367 }
 368
 369 static void dcerpc_epm_Delete_done(struct tevent_req *subreq)
 370 {
 371         struct tevent_req *req = tevent_req_callback_data(
 372                 subreq, struct tevent_req);
 373         struct dcerpc_epm_Delete_state *state = tevent_req_data(
 374                 req, struct dcerpc_epm_Delete_state);
 375         NTSTATUS status;
 376         TALLOC_CTX *mem_ctx;
 377
 378         if (state->out_mem_ctx) {
 379                 mem_ctx = state->out_mem_ctx;
 380         } else {
 381                 mem_ctx = state;
 382         }
 383
 384         status = dcerpc_epm_Delete_r_recv(subreq, mem_ctx);
 385         TALLOC_FREE(subreq);
 386         if (!NT_STATUS_IS_OK(status)) {
 387                 tevent_req_nterror(req, status);
 388                 return;
 389         }
 390
 391         /* Copy out parameters */
 392
 393         /* Copy result */
 394         state->orig.out.result = state->tmp.out.result;
 395
 396         /* Reset temporary structure */
 397         ZERO_STRUCT(state->tmp);
 398
 399         tevent_req_done(req);
 400 }
 401
 402 NTSTATUS dcerpc_epm_Delete_recv(struct tevent_req *req,
 403                                 TALLOC_CTX *mem_ctx,
 404                                 uint32_t *result)
 405 {
 406         struct dcerpc_epm_Delete_state *state = tevent_req_data(
 407                 req, struct dcerpc_epm_Delete_state);
 408         NTSTATUS status;
 409
 410         if (tevent_req_is_nterror(req, &status)) {
 411                 tevent_req_received(req);
 412                 return status;
 413         }
 414
 415         /* Steal possible out parameters to the callers context */
 416         talloc_steal(mem_ctx, state->out_mem_ctx);
 417
 418         /* Return result */
 419         *result = state->orig.out.result;
 420
 421         tevent_req_received(req);
 422         return NT_STATUS_OK;
 423 }
 424
 425 NTSTATUS dcerpc_epm_Delete(struct dcerpc_binding_handle *h,
 426                            TALLOC_CTX *mem_ctx,
 427                            uint32_t _num_ents /* [in]  */,
 428                            struct epm_entry_t *_entries /* [in] [size_is(num_ents)] */,
 429                            uint32_t *result)
 430 {
 431         struct epm_Delete r;
 432         NTSTATUS status;
 433
 434         /* In parameters */
 435         r.in.num_ents = _num_ents;
 436         r.in.entries = _entries;
 437
 438         status = dcerpc_epm_Delete_r(h, mem_ctx, &r);
 439         if (!NT_STATUS_IS_OK(status)) {
 440                 return status;
 441         }
 442
 443         /* Return variables */
 444
 445         /* Return result */
 446         *result = r.out.result;
 447
 448         return NT_STATUS_OK;
 449 }
 450
 451 struct dcerpc_epm_Lookup_r_state {
 452         TALLOC_CTX *out_mem_ctx;
 453 };
 454
 455 static void dcerpc_epm_Lookup_r_done(struct tevent_req *subreq);
 456
 457 struct tevent_req *dcerpc_epm_Lookup_r_send(TALLOC_CTX *mem_ctx,
 458         struct tevent_context *ev,
 459         struct dcerpc_binding_handle *h,
 460         struct epm_Lookup *r)
 461 {
 462         struct tevent_req *req;
 463         struct dcerpc_epm_Lookup_r_state *state;
 464         struct tevent_req *subreq;
 465
 466         req = tevent_req_create(mem_ctx, &state,
 467                                 struct dcerpc_epm_Lookup_r_state);
 468         if (req == NULL) {
 469                 return NULL;
 470         }
 471
 472         state->out_mem_ctx = talloc_new(state);
 473         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 474                 return tevent_req_post(req, ev);
 475         }
 476
 477         subreq = dcerpc_binding_handle_call_send(state, ev, h,
 478                         NULL, &ndr_table_epmapper,
 479                         NDR_EPM_LOOKUP, state->out_mem_ctx, r);
 480         if (tevent_req_nomem(subreq, req)) {
 481                 return tevent_req_post(req, ev);
 482         }
 483         tevent_req_set_callback(subreq, dcerpc_epm_Lookup_r_done, req);
 484
 485         return req;
 486 }
 487
 488 static void dcerpc_epm_Lookup_r_done(struct tevent_req *subreq)
 489 {
 490         struct tevent_req *req =
 491                 tevent_req_callback_data(subreq,
 492                 struct tevent_req);
 493         NTSTATUS status;
 494
 495         status = dcerpc_binding_handle_call_recv(subreq);
 496         if (!NT_STATUS_IS_OK(status)) {
 497                 tevent_req_nterror(req, status);
 498                 return;
 499         }
 500
 501         tevent_req_done(req);
 502 }
 503
 504 NTSTATUS dcerpc_epm_Lookup_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 505 {
 506         struct dcerpc_epm_Lookup_r_state *state =
 507                 tevent_req_data(req,
 508                 struct dcerpc_epm_Lookup_r_state);
 509         NTSTATUS status;
 510
 511         if (tevent_req_is_nterror(req, &status)) {
 512                 tevent_req_received(req);
 513                 return status;
 514         }
 515
 516         talloc_steal(mem_ctx, state->out_mem_ctx);
 517
 518         tevent_req_received(req);
 519         return NT_STATUS_OK;
 520 }
 521
 522 NTSTATUS dcerpc_epm_Lookup_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct epm_Lookup *r)
 523 {
 524         NTSTATUS status;
 525
 526         status = dcerpc_binding_handle_call(h,
 527                         NULL, &ndr_table_epmapper,
 528                         NDR_EPM_LOOKUP, mem_ctx, r);
 529
 530         return status;
 531 }
 532
 533 NTSTATUS dcerpc_epm_Lookup_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct epm_Lookup *r)
 534 {
 535         NTSTATUS status;
 536
 537         status = dcerpc_epm_Lookup_r(p->binding_handle, mem_ctx, r);
 538
 539         if (NT_STATUS_IS_RPC(status)) {
 540                 status = NT_STATUS_NET_WRITE_FAULT;
 541         }
 542
 543         return status;
 544 }
 545
 546 struct dcerpc_epm_Lookup_state {
 547         struct epm_Lookup orig;
 548         struct epm_Lookup tmp;
 549         TALLOC_CTX *out_mem_ctx;
 550 };
 551
 552 static void dcerpc_epm_Lookup_done(struct tevent_req *subreq);
 553
 554 struct tevent_req *dcerpc_epm_Lookup_send(TALLOC_CTX *mem_ctx,
 555                                           struct tevent_context *ev,
 556                                           struct dcerpc_binding_handle *h,
 557                                           uint32_t _inquiry_type /* [in]  */,
 558                                           struct GUID *_object /* [in] [ptr] */,
 559                                           struct rpc_if_id_t *_interface_id /* [in] [ptr] */,
 560                                           uint32_t _vers_option /* [in]  */,
 561                                           struct policy_handle *_entry_handle /* [in,out] [ref] */,
 562                                           uint32_t _max_ents /* [in]  */,
 563                                           uint32_t *_num_ents /* [out] [ref] */,
 564                                           struct epm_entry_t *_entries /* [out] [length_is(*num_ents),size_is(max_ents)] */)
 565 {
 566         struct tevent_req *req;
 567         struct dcerpc_epm_Lookup_state *state;
 568         struct tevent_req *subreq;
 569
 570         req = tevent_req_create(mem_ctx, &state,
 571                                 struct dcerpc_epm_Lookup_state);
 572         if (req == NULL) {
 573                 return NULL;
 574         }
 575         state->out_mem_ctx = NULL;
 576
 577         /* In parameters */
 578         state->orig.in.inquiry_type = _inquiry_type;
 579         state->orig.in.object = _object;
 580         state->orig.in.interface_id = _interface_id;
 581         state->orig.in.vers_option = _vers_option;
 582         state->orig.in.entry_handle = _entry_handle;
 583         state->orig.in.max_ents = _max_ents;
 584
 585         /* Out parameters */
 586         state->orig.out.entry_handle = _entry_handle;
 587         state->orig.out.num_ents = _num_ents;
 588         state->orig.out.entries = _entries;
 589
 590         /* Result */
 591         ZERO_STRUCT(state->orig.out.result);
 592
 593         state->out_mem_ctx = talloc_named_const(state, 0,
 594                              "dcerpc_epm_Lookup_out_memory");
 595         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 596                 return tevent_req_post(req, ev);
 597         }
 598
 599         /* make a temporary copy, that we pass to the dispatch function */
 600         state->tmp = state->orig;
 601
 602         subreq = dcerpc_epm_Lookup_r_send(state, ev, h, &state->tmp);
 603         if (tevent_req_nomem(subreq, req)) {
 604                 return tevent_req_post(req, ev);
 605         }
 606         tevent_req_set_callback(subreq, dcerpc_epm_Lookup_done, req);
 607         return req;
 608 }
 609
 610 static void dcerpc_epm_Lookup_done(struct tevent_req *subreq)
 611 {
 612         struct tevent_req *req = tevent_req_callback_data(
 613                 subreq, struct tevent_req);
 614         struct dcerpc_epm_Lookup_state *state = tevent_req_data(
 615                 req, struct dcerpc_epm_Lookup_state);
 616         NTSTATUS status;
 617         TALLOC_CTX *mem_ctx;
 618
 619         if (state->out_mem_ctx) {
 620                 mem_ctx = state->out_mem_ctx;
 621         } else {
 622                 mem_ctx = state;
 623         }
 624
 625         status = dcerpc_epm_Lookup_r_recv(subreq, mem_ctx);
 626         TALLOC_FREE(subreq);
 627         if (!NT_STATUS_IS_OK(status)) {
 628                 tevent_req_nterror(req, status);
 629                 return;
 630         }
 631
 632         /* Copy out parameters */
 633         *state->orig.out.entry_handle = *state->tmp.out.entry_handle;
 634         *state->orig.out.num_ents = *state->tmp.out.num_ents;
 635         {
 636                 size_t _copy_len_entries;
 637                 if ((*state->tmp.out.num_ents) > (state->tmp.in.max_ents)) {
 638                         tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
 639                         return;
 640                 }
 641                 _copy_len_entries = *state->tmp.out.num_ents;
 642                 memcpy(state->orig.out.entries, state->tmp.out.entries, _copy_len_entries * sizeof(*state->orig.out.entries));
 643         }
 644
 645         /* Copy result */
 646         state->orig.out.result = state->tmp.out.result;
 647
 648         /* Reset temporary structure */
 649         ZERO_STRUCT(state->tmp);
 650
 651         tevent_req_done(req);
 652 }
 653
 654 NTSTATUS dcerpc_epm_Lookup_recv(struct tevent_req *req,
 655                                 TALLOC_CTX *mem_ctx,
 656                                 uint32_t *result)
 657 {
 658         struct dcerpc_epm_Lookup_state *state = tevent_req_data(
 659                 req, struct dcerpc_epm_Lookup_state);
 660         NTSTATUS status;
 661
 662         if (tevent_req_is_nterror(req, &status)) {
 663                 tevent_req_received(req);
 664                 return status;
 665         }
 666
 667         /* Steal possible out parameters to the callers context */
 668         talloc_steal(mem_ctx, state->out_mem_ctx);
 669
 670         /* Return result */
 671         *result = state->orig.out.result;
 672
 673         tevent_req_received(req);
 674         return NT_STATUS_OK;
 675 }
 676
 677 NTSTATUS dcerpc_epm_Lookup(struct dcerpc_binding_handle *h,
 678                            TALLOC_CTX *mem_ctx,
 679                            uint32_t _inquiry_type /* [in]  */,
 680                            struct GUID *_object /* [in] [ptr] */,
 681                            struct rpc_if_id_t *_interface_id /* [in] [ptr] */,
 682                            uint32_t _vers_option /* [in]  */,
 683                            struct policy_handle *_entry_handle /* [in,out] [ref] */,
 684                            uint32_t _max_ents /* [in]  */,
 685                            uint32_t *_num_ents /* [out] [ref] */,
 686                            struct epm_entry_t *_entries /* [out] [length_is(*num_ents),size_is(max_ents)] */,
 687                            uint32_t *result)
 688 {
 689         struct epm_Lookup r;
 690         NTSTATUS status;
 691
 692         /* In parameters */
 693         r.in.inquiry_type = _inquiry_type;
 694         r.in.object = _object;
 695         r.in.interface_id = _interface_id;
 696         r.in.vers_option = _vers_option;
 697         r.in.entry_handle = _entry_handle;
 698         r.in.max_ents = _max_ents;
 699
 700         status = dcerpc_epm_Lookup_r(h, mem_ctx, &r);
 701         if (!NT_STATUS_IS_OK(status)) {
 702                 return status;
 703         }
 704
 705         /* Return variables */
 706         *_entry_handle = *r.out.entry_handle;
 707         *_num_ents = *r.out.num_ents;
 708         {
 709                 size_t _copy_len_entries;
 710                 if ((*r.out.num_ents) > (r.in.max_ents)) {
 711                         return NT_STATUS_INVALID_NETWORK_RESPONSE;
 712                 }
 713                 _copy_len_entries = *r.out.num_ents;
 714                 memcpy(_entries, r.out.entries, _copy_len_entries * sizeof(*_entries));
 715         }
 716
 717         /* Return result */
 718         *result = r.out.result;
 719
 720         return NT_STATUS_OK;
 721 }
 722
 723 struct dcerpc_epm_Map_r_state {
 724         TALLOC_CTX *out_mem_ctx;
 725 };
 726
 727 static void dcerpc_epm_Map_r_done(struct tevent_req *subreq);
 728
 729 struct tevent_req *dcerpc_epm_Map_r_send(TALLOC_CTX *mem_ctx,
 730         struct tevent_context *ev,
 731         struct dcerpc_binding_handle *h,
 732         struct epm_Map *r)
 733 {
 734         struct tevent_req *req;
 735         struct dcerpc_epm_Map_r_state *state;
 736         struct tevent_req *subreq;
 737
 738         req = tevent_req_create(mem_ctx, &state,
 739                                 struct dcerpc_epm_Map_r_state);
 740         if (req == NULL) {
 741                 return NULL;
 742         }
 743
 744         state->out_mem_ctx = talloc_new(state);
 745         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 746                 return tevent_req_post(req, ev);
 747         }
 748
 749         subreq = dcerpc_binding_handle_call_send(state, ev, h,
 750                         NULL, &ndr_table_epmapper,
 751                         NDR_EPM_MAP, state->out_mem_ctx, r);
 752         if (tevent_req_nomem(subreq, req)) {
 753                 return tevent_req_post(req, ev);
 754         }
 755         tevent_req_set_callback(subreq, dcerpc_epm_Map_r_done, req);
 756
 757         return req;
 758 }
 759
 760 static void dcerpc_epm_Map_r_done(struct tevent_req *subreq)
 761 {
 762         struct tevent_req *req =
 763                 tevent_req_callback_data(subreq,
 764                 struct tevent_req);
 765         NTSTATUS status;
 766
 767         status = dcerpc_binding_handle_call_recv(subreq);
 768         if (!NT_STATUS_IS_OK(status)) {
 769                 tevent_req_nterror(req, status);
 770                 return;
 771         }
 772
 773         tevent_req_done(req);
 774 }
 775
 776 NTSTATUS dcerpc_epm_Map_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
 777 {
 778         struct dcerpc_epm_Map_r_state *state =
 779                 tevent_req_data(req,
 780                 struct dcerpc_epm_Map_r_state);
 781         NTSTATUS status;
 782
 783         if (tevent_req_is_nterror(req, &status)) {
 784                 tevent_req_received(req);
 785                 return status;
 786         }
 787
 788         talloc_steal(mem_ctx, state->out_mem_ctx);
 789
 790         tevent_req_received(req);
 791         return NT_STATUS_OK;
 792 }
 793
 794 NTSTATUS dcerpc_epm_Map_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct epm_Map *r)
 795 {
 796         NTSTATUS status;
 797
 798         status = dcerpc_binding_handle_call(h,
 799                         NULL, &ndr_table_epmapper,
 800                         NDR_EPM_MAP, mem_ctx, r);
 801
 802         return status;
 803 }
 804
 805 NTSTATUS dcerpc_epm_Map_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct epm_Map *r)
 806 {
 807         NTSTATUS status;
 808
 809         status = dcerpc_epm_Map_r(p->binding_handle, mem_ctx, r);
 810
 811         if (NT_STATUS_IS_RPC(status)) {
 812                 status = NT_STATUS_NET_WRITE_FAULT;
 813         }
 814
 815         return status;
 816 }
 817
 818 struct dcerpc_epm_Map_state {
 819         struct epm_Map orig;
 820         struct epm_Map tmp;
 821         TALLOC_CTX *out_mem_ctx;
 822 };
 823
 824 static void dcerpc_epm_Map_done(struct tevent_req *subreq);
 825
 826 struct tevent_req *dcerpc_epm_Map_send(TALLOC_CTX *mem_ctx,
 827                                        struct tevent_context *ev,
 828                                        struct dcerpc_binding_handle *h,
 829                                        struct GUID *_object /* [in] [ptr] */,
 830                                        struct epm_twr_t *_map_tower /* [in] [ptr] */,
 831                                        struct policy_handle *_entry_handle /* [in,out] [ref] */,
 832                                        uint32_t _max_towers /* [in]  */,
 833                                        uint32_t *_num_towers /* [out] [ref] */,
 834                                        struct epm_twr_p_t *_towers /* [out] [length_is(*num_towers),size_is(max_towers)] */)
 835 {
 836         struct tevent_req *req;
 837         struct dcerpc_epm_Map_state *state;
 838         struct tevent_req *subreq;
 839
 840         req = tevent_req_create(mem_ctx, &state,
 841                                 struct dcerpc_epm_Map_state);
 842         if (req == NULL) {
 843                 return NULL;
 844         }
 845         state->out_mem_ctx = NULL;
 846
 847         /* In parameters */
 848         state->orig.in.object = _object;
 849         state->orig.in.map_tower = _map_tower;
 850         state->orig.in.entry_handle = _entry_handle;
 851         state->orig.in.max_towers = _max_towers;
 852
 853         /* Out parameters */
 854         state->orig.out.entry_handle = _entry_handle;
 855         state->orig.out.num_towers = _num_towers;
 856         state->orig.out.towers = _towers;
 857
 858         /* Result */
 859         ZERO_STRUCT(state->orig.out.result);
 860
 861         state->out_mem_ctx = talloc_named_const(state, 0,
 862                              "dcerpc_epm_Map_out_memory");
 863         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 864                 return tevent_req_post(req, ev);
 865         }
 866
 867         /* make a temporary copy, that we pass to the dispatch function */
 868         state->tmp = state->orig;
 869
 870         subreq = dcerpc_epm_Map_r_send(state, ev, h, &state->tmp);
 871         if (tevent_req_nomem(subreq, req)) {
 872                 return tevent_req_post(req, ev);
 873         }
 874         tevent_req_set_callback(subreq, dcerpc_epm_Map_done, req);
 875         return req;
 876 }
 877
 878 static void dcerpc_epm_Map_done(struct tevent_req *subreq)
 879 {
 880         struct tevent_req *req = tevent_req_callback_data(
 881                 subreq, struct tevent_req);
 882         struct dcerpc_epm_Map_state *state = tevent_req_data(
 883                 req, struct dcerpc_epm_Map_state);
 884         NTSTATUS status;
 885         TALLOC_CTX *mem_ctx;
 886
 887         if (state->out_mem_ctx) {
 888                 mem_ctx = state->out_mem_ctx;
 889         } else {
 890                 mem_ctx = state;
 891         }
 892
 893         status = dcerpc_epm_Map_r_recv(subreq, mem_ctx);
 894         TALLOC_FREE(subreq);
 895         if (!NT_STATUS_IS_OK(status)) {
 896                 tevent_req_nterror(req, status);
 897                 return;
 898         }
 899
 900         /* Copy out parameters */
 901         *state->orig.out.entry_handle = *state->tmp.out.entry_handle;
 902         *state->orig.out.num_towers = *state->tmp.out.num_towers;
 903         {
 904                 size_t _copy_len_towers;
 905                 if ((*state->tmp.out.num_towers) > (state->tmp.in.max_towers)) {
 906                         tevent_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
 907                         return;
 908                 }
 909                 _copy_len_towers = *state->tmp.out.num_towers;
 910                 memcpy(state->orig.out.towers, state->tmp.out.towers, _copy_len_towers * sizeof(*state->orig.out.towers));
 911         }
 912
 913         /* Copy result */
 914         state->orig.out.result = state->tmp.out.result;
 915
 916         /* Reset temporary structure */
 917         ZERO_STRUCT(state->tmp);
 918
 919         tevent_req_done(req);
 920 }
 921
 922 NTSTATUS dcerpc_epm_Map_recv(struct tevent_req *req,
 923                              TALLOC_CTX *mem_ctx,
 924                              uint32_t *result)
 925 {
 926         struct dcerpc_epm_Map_state *state = tevent_req_data(
 927                 req, struct dcerpc_epm_Map_state);
 928         NTSTATUS status;
 929
 930         if (tevent_req_is_nterror(req, &status)) {
 931                 tevent_req_received(req);
 932                 return status;
 933         }
 934
 935         /* Steal possible out parameters to the callers context */
 936         talloc_steal(mem_ctx, state->out_mem_ctx);
 937
 938         /* Return result */
 939         *result = state->orig.out.result;
 940
 941         tevent_req_received(req);
 942         return NT_STATUS_OK;
 943 }
 944
 945 NTSTATUS dcerpc_epm_Map(struct dcerpc_binding_handle *h,
 946                         TALLOC_CTX *mem_ctx,
 947                         struct GUID *_object /* [in] [ptr] */,
 948                         struct epm_twr_t *_map_tower /* [in] [ptr] */,
 949                         struct policy_handle *_entry_handle /* [in,out] [ref] */,
 950                         uint32_t _max_towers /* [in]  */,
 951                         uint32_t *_num_towers /* [out] [ref] */,
 952                         struct epm_twr_p_t *_towers /* [out] [length_is(*num_towers),size_is(max_towers)] */,
 953                         uint32_t *result)
 954 {
 955         struct epm_Map r;
 956         NTSTATUS status;
 957
 958         /* In parameters */
 959         r.in.object = _object;
 960         r.in.map_tower = _map_tower;
 961         r.in.entry_handle = _entry_handle;
 962         r.in.max_towers = _max_towers;
 963
 964         status = dcerpc_epm_Map_r(h, mem_ctx, &r);
 965         if (!NT_STATUS_IS_OK(status)) {
 966                 return status;
 967         }
 968
 969         /* Return variables */
 970         *_entry_handle = *r.out.entry_handle;
 971         *_num_towers = *r.out.num_towers;
 972         {
 973                 size_t _copy_len_towers;
 974                 if ((*r.out.num_towers) > (r.in.max_towers)) {
 975                         return NT_STATUS_INVALID_NETWORK_RESPONSE;
 976                 }
 977                 _copy_len_towers = *r.out.num_towers;
 978                 memcpy(_towers, r.out.towers, _copy_len_towers * sizeof(*_towers));
 979         }
 980
 981         /* Return result */
 982         *result = r.out.result;
 983
 984         return NT_STATUS_OK;
 985 }
 986
 987 struct dcerpc_epm_LookupHandleFree_r_state {
 988         TALLOC_CTX *out_mem_ctx;
 989 };
 990
 991 static void dcerpc_epm_LookupHandleFree_r_done(struct tevent_req *subreq);
 992
 993 struct tevent_req *dcerpc_epm_LookupHandleFree_r_send(TALLOC_CTX *mem_ctx,
 994         struct tevent_context *ev,
 995         struct dcerpc_binding_handle *h,
 996         struct epm_LookupHandleFree *r)
 997 {
 998         struct tevent_req *req;
 999         struct dcerpc_epm_LookupHandleFree_r_state *state;
1000         struct tevent_req *subreq;
1001
1002         req = tevent_req_create(mem_ctx, &state,
1003                                 struct dcerpc_epm_LookupHandleFree_r_state);
1004         if (req == NULL) {
1005                 return NULL;
1006         }
1007
1008         state->out_mem_ctx = talloc_new(state);
1009         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1010                 return tevent_req_post(req, ev);
1011         }
1012
1013         subreq = dcerpc_binding_handle_call_send(state, ev, h,
1014                         NULL, &ndr_table_epmapper,
1015                         NDR_EPM_LOOKUPHANDLEFREE, state->out_mem_ctx, r);
1016         if (tevent_req_nomem(subreq, req)) {
1017                 return tevent_req_post(req, ev);
1018         }
1019         tevent_req_set_callback(subreq, dcerpc_epm_LookupHandleFree_r_done, req);
1020
1021         return req;
1022 }
1023
1024 static void dcerpc_epm_LookupHandleFree_r_done(struct tevent_req *subreq)
1025 {
1026         struct tevent_req *req =
1027                 tevent_req_callback_data(subreq,
1028                 struct tevent_req);
1029         NTSTATUS status;
1030
1031         status = dcerpc_binding_handle_call_recv(subreq);
1032         if (!NT_STATUS_IS_OK(status)) {
1033                 tevent_req_nterror(req, status);
1034                 return;
1035         }
1036
1037         tevent_req_done(req);
1038 }
1039
1040 NTSTATUS dcerpc_epm_LookupHandleFree_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
1041 {
1042         struct dcerpc_epm_LookupHandleFree_r_state *state =
1043                 tevent_req_data(req,
1044                 struct dcerpc_epm_LookupHandleFree_r_state);
1045         NTSTATUS status;
1046
1047         if (tevent_req_is_nterror(req, &status)) {
1048                 tevent_req_received(req);
1049                 return status;
1050         }
1051
1052         talloc_steal(mem_ctx, state->out_mem_ctx);
1053
1054         tevent_req_received(req);
1055         return NT_STATUS_OK;
1056 }
1057
1058 NTSTATUS dcerpc_epm_LookupHandleFree_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct epm_LookupHandleFree *r)
1059 {
1060         NTSTATUS status;
1061
1062         status = dcerpc_binding_handle_call(h,
1063                         NULL, &ndr_table_epmapper,
1064                         NDR_EPM_LOOKUPHANDLEFREE, mem_ctx, r);
1065
1066         return status;
1067 }
1068
1069 NTSTATUS dcerpc_epm_LookupHandleFree_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct epm_LookupHandleFree *r)
1070 {
1071         NTSTATUS status;
1072
1073         status = dcerpc_epm_LookupHandleFree_r(p->binding_handle, mem_ctx, r);
1074
1075         if (NT_STATUS_IS_RPC(status)) {
1076                 status = NT_STATUS_NET_WRITE_FAULT;
1077         }
1078
1079         return status;
1080 }
1081
1082 struct dcerpc_epm_LookupHandleFree_state {
1083         struct epm_LookupHandleFree orig;
1084         struct epm_LookupHandleFree tmp;
1085         TALLOC_CTX *out_mem_ctx;
1086 };
1087
1088 static void dcerpc_epm_LookupHandleFree_done(struct tevent_req *subreq);
1089
1090 struct tevent_req *dcerpc_epm_LookupHandleFree_send(TALLOC_CTX *mem_ctx,
1091                                                     struct tevent_context *ev,
1092                                                     struct dcerpc_binding_handle *h,
1093                                                     struct policy_handle *_entry_handle /* [in,out] [ref] */)
1094 {
1095         struct tevent_req *req;
1096         struct dcerpc_epm_LookupHandleFree_state *state;
1097         struct tevent_req *subreq;
1098
1099         req = tevent_req_create(mem_ctx, &state,
1100                                 struct dcerpc_epm_LookupHandleFree_state);
1101         if (req == NULL) {
1102                 return NULL;
1103         }
1104         state->out_mem_ctx = NULL;
1105
1106         /* In parameters */
1107         state->orig.in.entry_handle = _entry_handle;
1108
1109         /* Out parameters */
1110         state->orig.out.entry_handle = _entry_handle;
1111
1112         /* Result */
1113         ZERO_STRUCT(state->orig.out.result);
1114
1115         state->out_mem_ctx = talloc_named_const(state, 0,
1116                              "dcerpc_epm_LookupHandleFree_out_memory");
1117         if (tevent_req_nomem(state->out_mem_ctx, req)) {
1118                 return tevent_req_post(req, ev);
1119         }
1120
1121         /* make a temporary copy, that we pass to the dispatch function */
1122         state->tmp = state->orig;
1123
1124         subreq = dcerpc_epm_LookupHandleFree_r_send(state, ev, h, &state->tmp);
1125         if (tevent_req_nomem(subreq, req)) {
1126                 return tevent_req_post(req, ev);
1127         }
1128         tevent_req_set_callback(subreq, dcerpc_epm_LookupHandleFree_done, req);
1129         return req;
1130 }
1131
1132 static void dcerpc_epm_LookupHandleFree_done(struct tevent_req *subreq)
1133 {
1134         struct tevent_req *req = tevent_req_callback_data(
1135                 subreq, struct tevent_req);
1136         struct dcerpc_epm_LookupHandleFree_state *state = tevent_req_data(
1137                 req, struct dcerpc_epm_LookupHandleFree_state);
1138         NTSTATUS status;
1139         TALLOC_CTX *mem_ctx;
1140
1141         if (state->out_mem_ctx) {
1142                 mem_ctx = state->out_mem_ctx;
1143         } else {
1144                 mem_ctx = state;
1145         }
1146
1147         status = dcerpc_epm_LookupHandleFree_r_recv(subreq, mem_ctx);
1148         TALLOC_FREE(subreq);
1149         if (!NT_STATUS_IS_OK(status)) {
1150                 tevent_req_nterror(req, status);
1151                 return;
1152         }
1153
1154         /* Copy out parameters */
1155         *state->orig.out.entry_handle = *state->tmp.out.entry_handle;
1156
1157         /* Copy result */
1158         state->orig.out.result = state->tmp.out.result;
1159
1160         /* Reset temporary structure */
1161         ZERO_STRUCT(state->tmp);
1162
1163         tevent_req_done(req);
1164 }
1165
1166 NTSTATUS dcerpc_epm_LookupHandleFree_recv(struct tevent_req *req,
1167                                           TALLOC_CTX *mem_ctx,
1168                                           uint32_t *result)
1169 {
1170         struct dcerpc_epm_LookupHandleFree_state *state = tevent_req_data(
1171                 req, struct dcerpc_epm_LookupHandleFree_state);
1172         NTSTATUS status;
1173
1174         if (tevent_req_is_nterror(req, &status)) {
1175                 tevent_req_received(req);
1176                 return status;
1177         }
1178
1179         /* Steal possible out parameters to the callers context */
1180         talloc_steal(mem_ctx, state->out_mem_ctx);
1181
1182         /* Return result */
1183         *result = state->orig.out.result;
1184
1185         tevent_req_received(req);
1186         return NT_STATUS_OK;
1187 }
1188
1189 NTSTATUS dcerpc_epm_LookupHandleFree(struct dcerpc_binding_handle *h,
1190                                      TALLOC_CTX *mem_ctx,
1191                                      struct policy_handle *_entry_handle /* [in,out] [ref] */,
1192                                      uint32_t *result)
1193 {
1194         struct epm_LookupHandleFree r;
1195         NTSTATUS status;
1196
1197         /* In parameters */
1198         r.in.entry_handle = _entry_handle;
1199
1200         status = dcerpc_epm_LookupHandleFree_r(h, mem_ctx, &r);
1201         if (!NT_STATUS_IS_OK(status)) {
1202                 return status;
1203         }
1204
1205         /* Return variables */
1206         *_entry_handle = *r.out.entry_handle;
1207
1208         /* Return result */
1209         *result = r.out.result;
1210
1211         return NT_STATUS_OK;
1212 }
1213
1214 struct dcerpc_epm_InqObject_r_state {
1215         TALLOC_CTX *out_mem_ctx;
1216 };
1217
1218 static void dcerpc_epm_InqObject_r_done(struct tevent_req *subreq);
1219
1220 struct tevent_req *dcerpc_epm_InqObject_r_send(TALLOC_CTX *mem_ctx,
1221         struct tevent_context *ev,
1222         struct dcerpc_binding_handle *h,
1223         struct epm_InqObject *r)
1224 {
1225         struct tevent_req *req;
1226         struct dcerpc_epm_InqObject_r_state *state;
1227         struct tevent_req *subreq;
1228
1229         req = tevent_req_create(mem_ctx, &state,
1230                                 struct dcerpc_epm_InqObject_r_state);
1231         if (req == NULL) {
1232                 return NULL;
1233         }
1234
1235         state->out_mem_ctx = NULL;
1236         subreq = dcerpc_binding_handle_call_send(state, ev, h,
1237                         NULL, &ndr_table_epmapper,
1238                         NDR_EPM_INQOBJECT, state, r);
1239         if (tevent_req_nomem(subreq, req)) {
1240                 return tevent_req_post(req, ev);
1241         }
1242         tevent_req_set_callback(subreq, dcerpc_epm_InqObject_r_done, req);
1243
1244         return req;
1245 }
1246
1247 static void dcerpc_epm_InqObject_r_done(struct tevent_req *subreq)
1248 {
1249         struct tevent_req *req =
1250                 tevent_req_callback_data(subreq,
1251                 struct tevent_req);
1252         NTSTATUS status;
1253
1254         status = dcerpc_binding_handle_call_recv(subreq);
1255         if (!NT_STATUS_IS_OK(status)) {
1256                 tevent_req_nterror(req, status);
1257                 return;
1258         }
1259
1260         tevent_req_done(req);
1261 }
1262
1263 NTSTATUS dcerpc_epm_InqObject_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
1264 {
1265         struct dcerpc_epm_InqObject_r_state *state =
1266                 tevent_req_data(req,
1267                 struct dcerpc_epm_InqObject_r_state);
1268         NTSTATUS status;
1269
1270         if (tevent_req_is_nterror(req, &status)) {
1271                 tevent_req_received(req);
1272                 return status;
1273         }
1274
1275         talloc_steal(mem_ctx, state->out_mem_ctx);
1276
1277         tevent_req_received(req);
1278         return NT_STATUS_OK;
1279 }
1280
1281 NTSTATUS dcerpc_epm_InqObject_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct epm_InqObject *r)
1282 {
1283         NTSTATUS status;
1284
1285         status = dcerpc_binding_handle_call(h,
1286                         NULL, &ndr_table_epmapper,
1287                         NDR_EPM_INQOBJECT, mem_ctx, r);
1288
1289         return status;
1290 }
1291
1292 NTSTATUS dcerpc_epm_InqObject_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct epm_InqObject *r)
1293 {
1294         NTSTATUS status;
1295
1296         status = dcerpc_epm_InqObject_r(p->binding_handle, mem_ctx, r);
1297
1298         if (NT_STATUS_IS_RPC(status)) {
1299                 status = NT_STATUS_NET_WRITE_FAULT;
1300         }
1301
1302         return status;
1303 }
1304
1305 struct dcerpc_epm_InqObject_state {
1306         struct epm_InqObject orig;
1307         struct epm_InqObject tmp;
1308         TALLOC_CTX *out_mem_ctx;
1309 };
1310
1311 static void dcerpc_epm_InqObject_done(struct tevent_req *subreq);
1312
1313 struct tevent_req *dcerpc_epm_InqObject_send(TALLOC_CTX *mem_ctx,
1314                                              struct tevent_context *ev,
1315                                              struct dcerpc_binding_handle *h,
1316                                              struct GUID *_epm_object /* [in] [ref] */)
1317 {
1318         struct tevent_req *req;
1319         struct dcerpc_epm_InqObject_state *state;
1320         struct tevent_req *subreq;
1321
1322         req = tevent_req_create(mem_ctx, &state,
1323                                 struct dcerpc_epm_InqObject_state);
1324         if (req == NULL) {
1325                 return NULL;
1326         }
1327         state->out_mem_ctx = NULL;
1328
1329         /* In parameters */
1330         state->orig.in.epm_object = _epm_object;
1331
1332         /* Out parameters */
1333
1334         /* Result */
1335         ZERO_STRUCT(state->orig.out.result);
1336
1337         /* make a temporary copy, that we pass to the dispatch function */
1338         state->tmp = state->orig;
1339
1340         subreq = dcerpc_epm_InqObject_r_send(state, ev, h, &state->tmp);
1341         if (tevent_req_nomem(subreq, req)) {
1342                 return tevent_req_post(req, ev);
1343         }
1344         tevent_req_set_callback(subreq, dcerpc_epm_InqObject_done, req);
1345         return req;
1346 }
1347
1348 static void dcerpc_epm_InqObject_done(struct tevent_req *subreq)
1349 {
1350         struct tevent_req *req = tevent_req_callback_data(
1351                 subreq, struct tevent_req);
1352         struct dcerpc_epm_InqObject_state *state = tevent_req_data(
1353                 req, struct dcerpc_epm_InqObject_state);
1354         NTSTATUS status;
1355         TALLOC_CTX *mem_ctx;
1356
1357         if (state->out_mem_ctx) {
1358                 mem_ctx = state->out_mem_ctx;
1359         } else {
1360                 mem_ctx = state;
1361         }
1362
1363         status = dcerpc_epm_InqObject_r_recv(subreq, mem_ctx);
1364         TALLOC_FREE(subreq);
1365         if (!NT_STATUS_IS_OK(status)) {
1366                 tevent_req_nterror(req, status);
1367                 return;
1368         }
1369
1370         /* Copy out parameters */
1371
1372         /* Copy result */
1373         state->orig.out.result = state->tmp.out.result;
1374
1375         /* Reset temporary structure */
1376         ZERO_STRUCT(state->tmp);
1377
1378         tevent_req_done(req);
1379 }
1380
1381 NTSTATUS dcerpc_epm_InqObject_recv(struct tevent_req *req,
1382                                    TALLOC_CTX *mem_ctx,
1383                                    uint32_t *result)
1384 {
1385         struct dcerpc_epm_InqObject_state *state = tevent_req_data(
1386                 req, struct dcerpc_epm_InqObject_state);
1387         NTSTATUS status;
1388
1389         if (tevent_req_is_nterror(req, &status)) {
1390                 tevent_req_received(req);
1391                 return status;
1392         }
1393
1394         /* Steal possible out parameters to the callers context */
1395         talloc_steal(mem_ctx, state->out_mem_ctx);
1396
1397         /* Return result */
1398         *result = state->orig.out.result;
1399
1400         tevent_req_received(req);
1401         return NT_STATUS_OK;
1402 }
1403
1404 NTSTATUS dcerpc_epm_InqObject(struct dcerpc_binding_handle *h,
1405                               TALLOC_CTX *mem_ctx,
1406                               struct GUID *_epm_object /* [in] [ref] */,
1407                               uint32_t *result)
1408 {
1409         struct epm_InqObject r;
1410         NTSTATUS status;
1411
1412         /* In parameters */
1413         r.in.epm_object = _epm_object;
1414
1415         status = dcerpc_epm_InqObject_r(h, mem_ctx, &r);
1416         if (!NT_STATUS_IS_OK(status)) {
1417                 return status;
1418         }
1419
1420         /* Return variables */
1421
1422         /* Return result */
1423         *result = r.out.result;
1424
1425         return NT_STATUS_OK;
1426 }
1427
1428 struct dcerpc_epm_MgmtDelete_r_state {
1429         TALLOC_CTX *out_mem_ctx;
1430 };
1431
1432 static void dcerpc_epm_MgmtDelete_r_done(struct tevent_req *subreq);
1433
1434 struct tevent_req *dcerpc_epm_MgmtDelete_r_send(TALLOC_CTX *mem_ctx,
1435         struct tevent_context *ev,
1436         struct dcerpc_binding_handle *h,
1437         struct epm_MgmtDelete *r)
1438 {
1439         struct tevent_req *req;
1440         struct dcerpc_epm_MgmtDelete_r_state *state;
1441         struct tevent_req *subreq;
1442
1443         req = tevent_req_create(mem_ctx, &state,
1444                                 struct dcerpc_epm_MgmtDelete_r_state);
1445         if (req == NULL) {
1446                 return NULL;
1447         }
1448
1449         state->out_mem_ctx = NULL;
1450         subreq = dcerpc_binding_handle_call_send(state, ev, h,
1451                         NULL, &ndr_table_epmapper,
1452                         NDR_EPM_MGMTDELETE, state, r);
1453         if (tevent_req_nomem(subreq, req)) {
1454                 return tevent_req_post(req, ev);
1455         }
1456         tevent_req_set_callback(subreq, dcerpc_epm_MgmtDelete_r_done, req);
1457
1458         return req;
1459 }
1460
1461 static void dcerpc_epm_MgmtDelete_r_done(struct tevent_req *subreq)
1462 {
1463         struct tevent_req *req =
1464                 tevent_req_callback_data(subreq,
1465                 struct tevent_req);
1466         NTSTATUS status;
1467
1468         status = dcerpc_binding_handle_call_recv(subreq);
1469         if (!NT_STATUS_IS_OK(status)) {
1470                 tevent_req_nterror(req, status);
1471                 return;
1472         }
1473
1474         tevent_req_done(req);
1475 }
1476
1477 NTSTATUS dcerpc_epm_MgmtDelete_r_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx)
1478 {
1479         struct dcerpc_epm_MgmtDelete_r_state *state =
1480                 tevent_req_data(req,
1481                 struct dcerpc_epm_MgmtDelete_r_state);
1482         NTSTATUS status;
1483
1484         if (tevent_req_is_nterror(req, &status)) {
1485                 tevent_req_received(req);
1486                 return status;
1487         }
1488
1489         talloc_steal(mem_ctx, state->out_mem_ctx);
1490
1491         tevent_req_received(req);
1492         return NT_STATUS_OK;
1493 }
1494
1495 NTSTATUS dcerpc_epm_MgmtDelete_r(struct dcerpc_binding_handle *h, TALLOC_CTX *mem_ctx, struct epm_MgmtDelete *r)
1496 {
1497         NTSTATUS status;
1498
1499         status = dcerpc_binding_handle_call(h,
1500                         NULL, &ndr_table_epmapper,
1501                         NDR_EPM_MGMTDELETE, mem_ctx, r);
1502
1503         return status;
1504 }
1505
1506 NTSTATUS dcerpc_epm_MgmtDelete_compat(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct epm_MgmtDelete *r)
1507 {
1508         NTSTATUS status;
1509
1510         status = dcerpc_epm_MgmtDelete_r(p->binding_handle, mem_ctx, r);
1511
1512         if (NT_STATUS_IS_RPC(status)) {
1513                 status = NT_STATUS_NET_WRITE_FAULT;
1514         }
1515
1516         return status;
1517 }
1518
1519 struct dcerpc_epm_MgmtDelete_state {
1520         struct epm_MgmtDelete orig;
1521         struct epm_MgmtDelete tmp;
1522         TALLOC_CTX *out_mem_ctx;
1523 };
1524
1525 static void dcerpc_epm_MgmtDelete_done(struct tevent_req *subreq);
1526
1527 struct tevent_req *dcerpc_epm_MgmtDelete_send(TALLOC_CTX *mem_ctx,
1528                                               struct tevent_context *ev,
1529                                               struct dcerpc_binding_handle *h,
1530                                               uint32_t _object_speced /* [in]  */,
1531                                               struct GUID *_object /* [in] [ptr] */,
1532                                               struct epm_twr_t *_tower /* [in] [ptr] */)
1533 {
1534         struct tevent_req *req;
1535         struct dcerpc_epm_MgmtDelete_state *state;
1536         struct tevent_req *subreq;
1537
1538         req = tevent_req_create(mem_ctx, &state,
1539                                 struct dcerpc_epm_MgmtDelete_state);
1540         if (req == NULL) {
1541                 return NULL;
1542         }
1543         state->out_mem_ctx = NULL;
1544
1545         /* In parameters */
1546         state->orig.in.object_speced = _object_speced;
1547         state->orig.in.object = _object;
1548         state->orig.in.tower = _tower;
1549
1550         /* Out parameters */
1551
1552         /* Result */
1553         ZERO_STRUCT(state->orig.out.result);
1554
1555         /* make a temporary copy, that we pass to the dispatch function */
1556         state->tmp = state->orig;
1557
1558         subreq = dcerpc_epm_MgmtDelete_r_send(state, ev, h, &state->tmp);
1559         if (tevent_req_nomem(subreq, req)) {
1560                 return tevent_req_post(req, ev);
1561         }
1562         tevent_req_set_callback(subreq, dcerpc_epm_MgmtDelete_done, req);
1563         return req;
1564 }
1565
1566 static void dcerpc_epm_MgmtDelete_done(struct tevent_req *subreq)
1567 {
1568         struct tevent_req *req = tevent_req_callback_data(
1569                 subreq, struct tevent_req);
1570         struct dcerpc_epm_MgmtDelete_state *state = tevent_req_data(
1571                 req, struct dcerpc_epm_MgmtDelete_state);
1572         NTSTATUS status;
1573         TALLOC_CTX *mem_ctx;
1574
1575         if (state->out_mem_ctx) {
1576                 mem_ctx = state->out_mem_ctx;
1577         } else {
1578                 mem_ctx = state;
1579         }
1580
1581         status = dcerpc_epm_MgmtDelete_r_recv(subreq, mem_ctx);
1582         TALLOC_FREE(subreq);
1583         if (!NT_STATUS_IS_OK(status)) {
1584                 tevent_req_nterror(req, status);
1585                 return;
1586         }
1587
1588         /* Copy out parameters */
1589
1590         /* Copy result */
1591         state->orig.out.result = state->tmp.out.result;
1592
1593         /* Reset temporary structure */
1594         ZERO_STRUCT(state->tmp);
1595
1596         tevent_req_done(req);
1597 }
1598
1599 NTSTATUS dcerpc_epm_MgmtDelete_recv(struct tevent_req *req,
1600                                     TALLOC_CTX *mem_ctx,
1601                                     uint32_t *result)
1602 {
1603         struct dcerpc_epm_MgmtDelete_state *state = tevent_req_data(
1604                 req, struct dcerpc_epm_MgmtDelete_state);
1605         NTSTATUS status;
1606
1607         if (tevent_req_is_nterror(req, &status)) {
1608                 tevent_req_received(req);
1609                 return status;
1610         }
1611
1612         /* Steal possible out parameters to the callers context */
1613         talloc_steal(mem_ctx, state->out_mem_ctx);
1614
1615         /* Return result */
1616         *result = state->orig.out.result;
1617
1618         tevent_req_received(req);
1619         return NT_STATUS_OK;
1620 }
1621
1622 NTSTATUS dcerpc_epm_MgmtDelete(struct dcerpc_binding_handle *h,
1623                                TALLOC_CTX *mem_ctx,
1624                                uint32_t _object_speced /* [in]  */,
1625                                struct GUID *_object /* [in] [ptr] */,
1626                                struct epm_twr_t *_tower /* [in] [ptr] */,
1627                                uint32_t *result)
1628 {
1629         struct epm_MgmtDelete r;
1630         NTSTATUS status;
1631
1632         /* In parameters */
1633         r.in.object_speced = _object_speced;
1634         r.in.object = _object;
1635         r.in.tower = _tower;
1636
1637         status = dcerpc_epm_MgmtDelete_r(h, mem_ctx, &r);
1638         if (!NT_STATUS_IS_OK(status)) {
1639                 return status;
1640         }
1641
1642         /* Return variables */
1643
1644         /* Return result */
1645         *result = r.out.result;
1646
1647         return NT_STATUS_OK;
1648 }
1649