librpc/gen_ndr/cli_epmapper.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * client auto-generated by pidl. DO NOT MODIFY!
   4  */
   5
   6 #include "includes.h"
   7 #include "../librpc/gen_ndr/cli_epmapper.h"
   8
   9 struct rpccli_epm_Insert_state {
  10         struct epm_Insert orig;
  11         struct epm_Insert tmp;
  12         TALLOC_CTX *out_mem_ctx;
  13         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
  14 };
  15
  16 static void rpccli_epm_Insert_done(struct tevent_req *subreq);
  17
  18 struct tevent_req *rpccli_epm_Insert_send(TALLOC_CTX *mem_ctx,
  19                                           struct tevent_context *ev,
  20                                           struct rpc_pipe_client *cli,
  21                                           uint32_t _num_ents /* [in]  */,
  22                                           struct epm_entry_t *_entries /* [in] [size_is(num_ents)] */,
  23                                           uint32_t _replace /* [in]  */)
  24 {
  25         struct tevent_req *req;
  26         struct rpccli_epm_Insert_state *state;
  27         struct tevent_req *subreq;
  28
  29         req = tevent_req_create(mem_ctx, &state,
  30                                 struct rpccli_epm_Insert_state);
  31         if (req == NULL) {
  32                 return NULL;
  33         }
  34         state->out_mem_ctx = NULL;
  35         state->dispatch_recv = cli->dispatch_recv;
  36
  37         /* In parameters */
  38         state->orig.in.num_ents = _num_ents;
  39         state->orig.in.entries = _entries;
  40         state->orig.in.replace = _replace;
  41
  42         /* Out parameters */
  43
  44         /* Result */
  45         ZERO_STRUCT(state->orig.out.result);
  46
  47         if (DEBUGLEVEL >= 10) {
  48                 NDR_PRINT_IN_DEBUG(epm_Insert, &state->orig);
  49         }
  50
  51         /* make a temporary copy, that we pass to the dispatch function */
  52         state->tmp = state->orig;
  53
  54         subreq = cli->dispatch_send(state, ev, cli,
  55                                     &ndr_table_epmapper,
  56                                     NDR_EPM_INSERT,
  57                                     &state->tmp);
  58         if (tevent_req_nomem(subreq, req)) {
  59                 return tevent_req_post(req, ev);
  60         }
  61         tevent_req_set_callback(subreq, rpccli_epm_Insert_done, req);
  62         return req;
  63 }
  64
  65 static void rpccli_epm_Insert_done(struct tevent_req *subreq)
  66 {
  67         struct tevent_req *req = tevent_req_callback_data(
  68                 subreq, struct tevent_req);
  69         struct rpccli_epm_Insert_state *state = tevent_req_data(
  70                 req, struct rpccli_epm_Insert_state);
  71         NTSTATUS status;
  72         TALLOC_CTX *mem_ctx;
  73
  74         if (state->out_mem_ctx) {
  75                 mem_ctx = state->out_mem_ctx;
  76         } else {
  77                 mem_ctx = state;
  78         }
  79
  80         status = state->dispatch_recv(subreq, mem_ctx);
  81         TALLOC_FREE(subreq);
  82         if (!NT_STATUS_IS_OK(status)) {
  83                 tevent_req_nterror(req, status);
  84                 return;
  85         }
  86
  87         /* Copy out parameters */
  88
  89         /* Copy result */
  90         state->orig.out.result = state->tmp.out.result;
  91
  92         /* Reset temporary structure */
  93         ZERO_STRUCT(state->tmp);
  94
  95         if (DEBUGLEVEL >= 10) {
  96                 NDR_PRINT_OUT_DEBUG(epm_Insert, &state->orig);
  97         }
  98
  99         tevent_req_done(req);
 100 }
 101
 102 NTSTATUS rpccli_epm_Insert_recv(struct tevent_req *req,
 103                                 TALLOC_CTX *mem_ctx,
 104                                 uint32 *result)
 105 {
 106         struct rpccli_epm_Insert_state *state = tevent_req_data(
 107                 req, struct rpccli_epm_Insert_state);
 108         NTSTATUS status;
 109
 110         if (tevent_req_is_nterror(req, &status)) {
 111                 tevent_req_received(req);
 112                 return status;
 113         }
 114
 115         /* Steal possbile out parameters to the callers context */
 116         talloc_steal(mem_ctx, state->out_mem_ctx);
 117
 118         /* Return result */
 119         *result = state->orig.out.result;
 120
 121         tevent_req_received(req);
 122         return NT_STATUS_OK;
 123 }
 124
 125 NTSTATUS rpccli_epm_Insert(struct rpc_pipe_client *cli,
 126                            TALLOC_CTX *mem_ctx,
 127                            uint32_t num_ents /* [in]  */,
 128                            struct epm_entry_t *entries /* [in] [size_is(num_ents)] */,
 129                            uint32_t replace /* [in]  */)
 130 {
 131         struct epm_Insert r;
 132         NTSTATUS status;
 133
 134         /* In parameters */
 135         r.in.num_ents = num_ents;
 136         r.in.entries = entries;
 137         r.in.replace = replace;
 138
 139         if (DEBUGLEVEL >= 10) {
 140                 NDR_PRINT_IN_DEBUG(epm_Insert, &r);
 141         }
 142
 143         status = cli->dispatch(cli,
 144                                 mem_ctx,
 145                                 &ndr_table_epmapper,
 146                                 NDR_EPM_INSERT,
 147                                 &r);
 148
 149         if (!NT_STATUS_IS_OK(status)) {
 150                 return status;
 151         }
 152
 153         if (DEBUGLEVEL >= 10) {
 154                 NDR_PRINT_OUT_DEBUG(epm_Insert, &r);
 155         }
 156
 157         if (NT_STATUS_IS_ERR(status)) {
 158                 return status;
 159         }
 160
 161         /* Return variables */
 162
 163         /* Return result */
 164         return NT_STATUS_OK;
 165 }
 166
 167 struct rpccli_epm_Delete_state {
 168         struct epm_Delete orig;
 169         struct epm_Delete tmp;
 170         TALLOC_CTX *out_mem_ctx;
 171         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 172 };
 173
 174 static void rpccli_epm_Delete_done(struct tevent_req *subreq);
 175
 176 struct tevent_req *rpccli_epm_Delete_send(TALLOC_CTX *mem_ctx,
 177                                           struct tevent_context *ev,
 178                                           struct rpc_pipe_client *cli,
 179                                           uint32_t _num_ents /* [in]  */,
 180                                           struct epm_entry_t *_entries /* [in] [size_is(num_ents)] */)
 181 {
 182         struct tevent_req *req;
 183         struct rpccli_epm_Delete_state *state;
 184         struct tevent_req *subreq;
 185
 186         req = tevent_req_create(mem_ctx, &state,
 187                                 struct rpccli_epm_Delete_state);
 188         if (req == NULL) {
 189                 return NULL;
 190         }
 191         state->out_mem_ctx = NULL;
 192         state->dispatch_recv = cli->dispatch_recv;
 193
 194         /* In parameters */
 195         state->orig.in.num_ents = _num_ents;
 196         state->orig.in.entries = _entries;
 197
 198         /* Out parameters */
 199
 200         /* Result */
 201         ZERO_STRUCT(state->orig.out.result);
 202
 203         if (DEBUGLEVEL >= 10) {
 204                 NDR_PRINT_IN_DEBUG(epm_Delete, &state->orig);
 205         }
 206
 207         /* make a temporary copy, that we pass to the dispatch function */
 208         state->tmp = state->orig;
 209
 210         subreq = cli->dispatch_send(state, ev, cli,
 211                                     &ndr_table_epmapper,
 212                                     NDR_EPM_DELETE,
 213                                     &state->tmp);
 214         if (tevent_req_nomem(subreq, req)) {
 215                 return tevent_req_post(req, ev);
 216         }
 217         tevent_req_set_callback(subreq, rpccli_epm_Delete_done, req);
 218         return req;
 219 }
 220
 221 static void rpccli_epm_Delete_done(struct tevent_req *subreq)
 222 {
 223         struct tevent_req *req = tevent_req_callback_data(
 224                 subreq, struct tevent_req);
 225         struct rpccli_epm_Delete_state *state = tevent_req_data(
 226                 req, struct rpccli_epm_Delete_state);
 227         NTSTATUS status;
 228         TALLOC_CTX *mem_ctx;
 229
 230         if (state->out_mem_ctx) {
 231                 mem_ctx = state->out_mem_ctx;
 232         } else {
 233                 mem_ctx = state;
 234         }
 235
 236         status = state->dispatch_recv(subreq, mem_ctx);
 237         TALLOC_FREE(subreq);
 238         if (!NT_STATUS_IS_OK(status)) {
 239                 tevent_req_nterror(req, status);
 240                 return;
 241         }
 242
 243         /* Copy out parameters */
 244
 245         /* Copy result */
 246         state->orig.out.result = state->tmp.out.result;
 247
 248         /* Reset temporary structure */
 249         ZERO_STRUCT(state->tmp);
 250
 251         if (DEBUGLEVEL >= 10) {
 252                 NDR_PRINT_OUT_DEBUG(epm_Delete, &state->orig);
 253         }
 254
 255         tevent_req_done(req);
 256 }
 257
 258 NTSTATUS rpccli_epm_Delete_recv(struct tevent_req *req,
 259                                 TALLOC_CTX *mem_ctx,
 260                                 uint32 *result)
 261 {
 262         struct rpccli_epm_Delete_state *state = tevent_req_data(
 263                 req, struct rpccli_epm_Delete_state);
 264         NTSTATUS status;
 265
 266         if (tevent_req_is_nterror(req, &status)) {
 267                 tevent_req_received(req);
 268                 return status;
 269         }
 270
 271         /* Steal possbile out parameters to the callers context */
 272         talloc_steal(mem_ctx, state->out_mem_ctx);
 273
 274         /* Return result */
 275         *result = state->orig.out.result;
 276
 277         tevent_req_received(req);
 278         return NT_STATUS_OK;
 279 }
 280
 281 NTSTATUS rpccli_epm_Delete(struct rpc_pipe_client *cli,
 282                            TALLOC_CTX *mem_ctx,
 283                            uint32_t num_ents /* [in]  */,
 284                            struct epm_entry_t *entries /* [in] [size_is(num_ents)] */)
 285 {
 286         struct epm_Delete r;
 287         NTSTATUS status;
 288
 289         /* In parameters */
 290         r.in.num_ents = num_ents;
 291         r.in.entries = entries;
 292
 293         if (DEBUGLEVEL >= 10) {
 294                 NDR_PRINT_IN_DEBUG(epm_Delete, &r);
 295         }
 296
 297         status = cli->dispatch(cli,
 298                                 mem_ctx,
 299                                 &ndr_table_epmapper,
 300                                 NDR_EPM_DELETE,
 301                                 &r);
 302
 303         if (!NT_STATUS_IS_OK(status)) {
 304                 return status;
 305         }
 306
 307         if (DEBUGLEVEL >= 10) {
 308                 NDR_PRINT_OUT_DEBUG(epm_Delete, &r);
 309         }
 310
 311         if (NT_STATUS_IS_ERR(status)) {
 312                 return status;
 313         }
 314
 315         /* Return variables */
 316
 317         /* Return result */
 318         return NT_STATUS_OK;
 319 }
 320
 321 struct rpccli_epm_Lookup_state {
 322         struct epm_Lookup orig;
 323         struct epm_Lookup tmp;
 324         TALLOC_CTX *out_mem_ctx;
 325         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 326 };
 327
 328 static void rpccli_epm_Lookup_done(struct tevent_req *subreq);
 329
 330 struct tevent_req *rpccli_epm_Lookup_send(TALLOC_CTX *mem_ctx,
 331                                           struct tevent_context *ev,
 332                                           struct rpc_pipe_client *cli,
 333                                           uint32_t _inquiry_type /* [in]  */,
 334                                           struct GUID *_object /* [in] [ptr] */,
 335                                           struct rpc_if_id_t *_interface_id /* [in] [ptr] */,
 336                                           uint32_t _vers_option /* [in]  */,
 337                                           struct policy_handle *_entry_handle /* [in,out] [ref] */,
 338                                           uint32_t _max_ents /* [in]  */,
 339                                           uint32_t *_num_ents /* [out] [ref] */,
 340                                           struct epm_entry_t *_entries /* [out] [length_is(*num_ents),size_is(max_ents)] */)
 341 {
 342         struct tevent_req *req;
 343         struct rpccli_epm_Lookup_state *state;
 344         struct tevent_req *subreq;
 345
 346         req = tevent_req_create(mem_ctx, &state,
 347                                 struct rpccli_epm_Lookup_state);
 348         if (req == NULL) {
 349                 return NULL;
 350         }
 351         state->out_mem_ctx = NULL;
 352         state->dispatch_recv = cli->dispatch_recv;
 353
 354         /* In parameters */
 355         state->orig.in.inquiry_type = _inquiry_type;
 356         state->orig.in.object = _object;
 357         state->orig.in.interface_id = _interface_id;
 358         state->orig.in.vers_option = _vers_option;
 359         state->orig.in.entry_handle = _entry_handle;
 360         state->orig.in.max_ents = _max_ents;
 361
 362         /* Out parameters */
 363         state->orig.out.entry_handle = _entry_handle;
 364         state->orig.out.num_ents = _num_ents;
 365         state->orig.out.entries = _entries;
 366
 367         /* Result */
 368         ZERO_STRUCT(state->orig.out.result);
 369
 370         if (DEBUGLEVEL >= 10) {
 371                 NDR_PRINT_IN_DEBUG(epm_Lookup, &state->orig);
 372         }
 373
 374         state->out_mem_ctx = talloc_named_const(state, 0,
 375                              "rpccli_epm_Lookup_out_memory");
 376         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 377                 return tevent_req_post(req, ev);
 378         }
 379
 380         /* make a temporary copy, that we pass to the dispatch function */
 381         state->tmp = state->orig;
 382
 383         subreq = cli->dispatch_send(state, ev, cli,
 384                                     &ndr_table_epmapper,
 385                                     NDR_EPM_LOOKUP,
 386                                     &state->tmp);
 387         if (tevent_req_nomem(subreq, req)) {
 388                 return tevent_req_post(req, ev);
 389         }
 390         tevent_req_set_callback(subreq, rpccli_epm_Lookup_done, req);
 391         return req;
 392 }
 393
 394 static void rpccli_epm_Lookup_done(struct tevent_req *subreq)
 395 {
 396         struct tevent_req *req = tevent_req_callback_data(
 397                 subreq, struct tevent_req);
 398         struct rpccli_epm_Lookup_state *state = tevent_req_data(
 399                 req, struct rpccli_epm_Lookup_state);
 400         NTSTATUS status;
 401         TALLOC_CTX *mem_ctx;
 402
 403         if (state->out_mem_ctx) {
 404                 mem_ctx = state->out_mem_ctx;
 405         } else {
 406                 mem_ctx = state;
 407         }
 408
 409         status = state->dispatch_recv(subreq, mem_ctx);
 410         TALLOC_FREE(subreq);
 411         if (!NT_STATUS_IS_OK(status)) {
 412                 tevent_req_nterror(req, status);
 413                 return;
 414         }
 415
 416         /* Copy out parameters */
 417         *state->orig.out.entry_handle = *state->tmp.out.entry_handle;
 418         *state->orig.out.num_ents = *state->tmp.out.num_ents;
 419         memcpy(state->orig.out.entries, state->tmp.out.entries, state->tmp.in.max_ents * sizeof(*state->orig.out.entries));
 420
 421         /* Copy result */
 422         state->orig.out.result = state->tmp.out.result;
 423
 424         /* Reset temporary structure */
 425         ZERO_STRUCT(state->tmp);
 426
 427         if (DEBUGLEVEL >= 10) {
 428                 NDR_PRINT_OUT_DEBUG(epm_Lookup, &state->orig);
 429         }
 430
 431         tevent_req_done(req);
 432 }
 433
 434 NTSTATUS rpccli_epm_Lookup_recv(struct tevent_req *req,
 435                                 TALLOC_CTX *mem_ctx,
 436                                 uint32 *result)
 437 {
 438         struct rpccli_epm_Lookup_state *state = tevent_req_data(
 439                 req, struct rpccli_epm_Lookup_state);
 440         NTSTATUS status;
 441
 442         if (tevent_req_is_nterror(req, &status)) {
 443                 tevent_req_received(req);
 444                 return status;
 445         }
 446
 447         /* Steal possbile out parameters to the callers context */
 448         talloc_steal(mem_ctx, state->out_mem_ctx);
 449
 450         /* Return result */
 451         *result = state->orig.out.result;
 452
 453         tevent_req_received(req);
 454         return NT_STATUS_OK;
 455 }
 456
 457 NTSTATUS rpccli_epm_Lookup(struct rpc_pipe_client *cli,
 458                            TALLOC_CTX *mem_ctx,
 459                            uint32_t inquiry_type /* [in]  */,
 460                            struct GUID *object /* [in] [ptr] */,
 461                            struct rpc_if_id_t *interface_id /* [in] [ptr] */,
 462                            uint32_t vers_option /* [in]  */,
 463                            struct policy_handle *entry_handle /* [in,out] [ref] */,
 464                            uint32_t max_ents /* [in]  */,
 465                            uint32_t *num_ents /* [out] [ref] */,
 466                            struct epm_entry_t *entries /* [out] [length_is(*num_ents),size_is(max_ents)] */)
 467 {
 468         struct epm_Lookup r;
 469         NTSTATUS status;
 470
 471         /* In parameters */
 472         r.in.inquiry_type = inquiry_type;
 473         r.in.object = object;
 474         r.in.interface_id = interface_id;
 475         r.in.vers_option = vers_option;
 476         r.in.entry_handle = entry_handle;
 477         r.in.max_ents = max_ents;
 478
 479         if (DEBUGLEVEL >= 10) {
 480                 NDR_PRINT_IN_DEBUG(epm_Lookup, &r);
 481         }
 482
 483         status = cli->dispatch(cli,
 484                                 mem_ctx,
 485                                 &ndr_table_epmapper,
 486                                 NDR_EPM_LOOKUP,
 487                                 &r);
 488
 489         if (!NT_STATUS_IS_OK(status)) {
 490                 return status;
 491         }
 492
 493         if (DEBUGLEVEL >= 10) {
 494                 NDR_PRINT_OUT_DEBUG(epm_Lookup, &r);
 495         }
 496
 497         if (NT_STATUS_IS_ERR(status)) {
 498                 return status;
 499         }
 500
 501         /* Return variables */
 502         *entry_handle = *r.out.entry_handle;
 503         *num_ents = *r.out.num_ents;
 504         memcpy(entries, r.out.entries, r.in.max_ents * sizeof(*entries));
 505
 506         /* Return result */
 507         return NT_STATUS_OK;
 508 }
 509
 510 struct rpccli_epm_Map_state {
 511         struct epm_Map orig;
 512         struct epm_Map tmp;
 513         TALLOC_CTX *out_mem_ctx;
 514         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 515 };
 516
 517 static void rpccli_epm_Map_done(struct tevent_req *subreq);
 518
 519 struct tevent_req *rpccli_epm_Map_send(TALLOC_CTX *mem_ctx,
 520                                        struct tevent_context *ev,
 521                                        struct rpc_pipe_client *cli,
 522                                        struct GUID *_object /* [in] [ptr] */,
 523                                        struct epm_twr_t *_map_tower /* [in] [ptr] */,
 524                                        struct policy_handle *_entry_handle /* [in,out] [ref] */,
 525                                        uint32_t _max_towers /* [in]  */,
 526                                        uint32_t *_num_towers /* [out] [ref] */,
 527                                        struct epm_twr_p_t *_towers /* [out] [length_is(*num_towers),size_is(max_towers)] */)
 528 {
 529         struct tevent_req *req;
 530         struct rpccli_epm_Map_state *state;
 531         struct tevent_req *subreq;
 532
 533         req = tevent_req_create(mem_ctx, &state,
 534                                 struct rpccli_epm_Map_state);
 535         if (req == NULL) {
 536                 return NULL;
 537         }
 538         state->out_mem_ctx = NULL;
 539         state->dispatch_recv = cli->dispatch_recv;
 540
 541         /* In parameters */
 542         state->orig.in.object = _object;
 543         state->orig.in.map_tower = _map_tower;
 544         state->orig.in.entry_handle = _entry_handle;
 545         state->orig.in.max_towers = _max_towers;
 546
 547         /* Out parameters */
 548         state->orig.out.entry_handle = _entry_handle;
 549         state->orig.out.num_towers = _num_towers;
 550         state->orig.out.towers = _towers;
 551
 552         /* Result */
 553         ZERO_STRUCT(state->orig.out.result);
 554
 555         if (DEBUGLEVEL >= 10) {
 556                 NDR_PRINT_IN_DEBUG(epm_Map, &state->orig);
 557         }
 558
 559         state->out_mem_ctx = talloc_named_const(state, 0,
 560                              "rpccli_epm_Map_out_memory");
 561         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 562                 return tevent_req_post(req, ev);
 563         }
 564
 565         /* make a temporary copy, that we pass to the dispatch function */
 566         state->tmp = state->orig;
 567
 568         subreq = cli->dispatch_send(state, ev, cli,
 569                                     &ndr_table_epmapper,
 570                                     NDR_EPM_MAP,
 571                                     &state->tmp);
 572         if (tevent_req_nomem(subreq, req)) {
 573                 return tevent_req_post(req, ev);
 574         }
 575         tevent_req_set_callback(subreq, rpccli_epm_Map_done, req);
 576         return req;
 577 }
 578
 579 static void rpccli_epm_Map_done(struct tevent_req *subreq)
 580 {
 581         struct tevent_req *req = tevent_req_callback_data(
 582                 subreq, struct tevent_req);
 583         struct rpccli_epm_Map_state *state = tevent_req_data(
 584                 req, struct rpccli_epm_Map_state);
 585         NTSTATUS status;
 586         TALLOC_CTX *mem_ctx;
 587
 588         if (state->out_mem_ctx) {
 589                 mem_ctx = state->out_mem_ctx;
 590         } else {
 591                 mem_ctx = state;
 592         }
 593
 594         status = state->dispatch_recv(subreq, mem_ctx);
 595         TALLOC_FREE(subreq);
 596         if (!NT_STATUS_IS_OK(status)) {
 597                 tevent_req_nterror(req, status);
 598                 return;
 599         }
 600
 601         /* Copy out parameters */
 602         *state->orig.out.entry_handle = *state->tmp.out.entry_handle;
 603         *state->orig.out.num_towers = *state->tmp.out.num_towers;
 604         memcpy(state->orig.out.towers, state->tmp.out.towers, state->tmp.in.max_towers * sizeof(*state->orig.out.towers));
 605
 606         /* Copy result */
 607         state->orig.out.result = state->tmp.out.result;
 608
 609         /* Reset temporary structure */
 610         ZERO_STRUCT(state->tmp);
 611
 612         if (DEBUGLEVEL >= 10) {
 613                 NDR_PRINT_OUT_DEBUG(epm_Map, &state->orig);
 614         }
 615
 616         tevent_req_done(req);
 617 }
 618
 619 NTSTATUS rpccli_epm_Map_recv(struct tevent_req *req,
 620                              TALLOC_CTX *mem_ctx,
 621                              uint32 *result)
 622 {
 623         struct rpccli_epm_Map_state *state = tevent_req_data(
 624                 req, struct rpccli_epm_Map_state);
 625         NTSTATUS status;
 626
 627         if (tevent_req_is_nterror(req, &status)) {
 628                 tevent_req_received(req);
 629                 return status;
 630         }
 631
 632         /* Steal possbile out parameters to the callers context */
 633         talloc_steal(mem_ctx, state->out_mem_ctx);
 634
 635         /* Return result */
 636         *result = state->orig.out.result;
 637
 638         tevent_req_received(req);
 639         return NT_STATUS_OK;
 640 }
 641
 642 NTSTATUS rpccli_epm_Map(struct rpc_pipe_client *cli,
 643                         TALLOC_CTX *mem_ctx,
 644                         struct GUID *object /* [in] [ptr] */,
 645                         struct epm_twr_t *map_tower /* [in] [ptr] */,
 646                         struct policy_handle *entry_handle /* [in,out] [ref] */,
 647                         uint32_t max_towers /* [in]  */,
 648                         uint32_t *num_towers /* [out] [ref] */,
 649                         struct epm_twr_p_t *towers /* [out] [length_is(*num_towers),size_is(max_towers)] */)
 650 {
 651         struct epm_Map r;
 652         NTSTATUS status;
 653
 654         /* In parameters */
 655         r.in.object = object;
 656         r.in.map_tower = map_tower;
 657         r.in.entry_handle = entry_handle;
 658         r.in.max_towers = max_towers;
 659
 660         if (DEBUGLEVEL >= 10) {
 661                 NDR_PRINT_IN_DEBUG(epm_Map, &r);
 662         }
 663
 664         status = cli->dispatch(cli,
 665                                 mem_ctx,
 666                                 &ndr_table_epmapper,
 667                                 NDR_EPM_MAP,
 668                                 &r);
 669
 670         if (!NT_STATUS_IS_OK(status)) {
 671                 return status;
 672         }
 673
 674         if (DEBUGLEVEL >= 10) {
 675                 NDR_PRINT_OUT_DEBUG(epm_Map, &r);
 676         }
 677
 678         if (NT_STATUS_IS_ERR(status)) {
 679                 return status;
 680         }
 681
 682         /* Return variables */
 683         *entry_handle = *r.out.entry_handle;
 684         *num_towers = *r.out.num_towers;
 685         memcpy(towers, r.out.towers, r.in.max_towers * sizeof(*towers));
 686
 687         /* Return result */
 688         return NT_STATUS_OK;
 689 }
 690
 691 struct rpccli_epm_LookupHandleFree_state {
 692         struct epm_LookupHandleFree orig;
 693         struct epm_LookupHandleFree tmp;
 694         TALLOC_CTX *out_mem_ctx;
 695         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 696 };
 697
 698 static void rpccli_epm_LookupHandleFree_done(struct tevent_req *subreq);
 699
 700 struct tevent_req *rpccli_epm_LookupHandleFree_send(TALLOC_CTX *mem_ctx,
 701                                                     struct tevent_context *ev,
 702                                                     struct rpc_pipe_client *cli,
 703                                                     struct policy_handle *_entry_handle /* [in,out] [ref] */)
 704 {
 705         struct tevent_req *req;
 706         struct rpccli_epm_LookupHandleFree_state *state;
 707         struct tevent_req *subreq;
 708
 709         req = tevent_req_create(mem_ctx, &state,
 710                                 struct rpccli_epm_LookupHandleFree_state);
 711         if (req == NULL) {
 712                 return NULL;
 713         }
 714         state->out_mem_ctx = NULL;
 715         state->dispatch_recv = cli->dispatch_recv;
 716
 717         /* In parameters */
 718         state->orig.in.entry_handle = _entry_handle;
 719
 720         /* Out parameters */
 721         state->orig.out.entry_handle = _entry_handle;
 722
 723         /* Result */
 724         ZERO_STRUCT(state->orig.out.result);
 725
 726         if (DEBUGLEVEL >= 10) {
 727                 NDR_PRINT_IN_DEBUG(epm_LookupHandleFree, &state->orig);
 728         }
 729
 730         state->out_mem_ctx = talloc_named_const(state, 0,
 731                              "rpccli_epm_LookupHandleFree_out_memory");
 732         if (tevent_req_nomem(state->out_mem_ctx, req)) {
 733                 return tevent_req_post(req, ev);
 734         }
 735
 736         /* make a temporary copy, that we pass to the dispatch function */
 737         state->tmp = state->orig;
 738
 739         subreq = cli->dispatch_send(state, ev, cli,
 740                                     &ndr_table_epmapper,
 741                                     NDR_EPM_LOOKUPHANDLEFREE,
 742                                     &state->tmp);
 743         if (tevent_req_nomem(subreq, req)) {
 744                 return tevent_req_post(req, ev);
 745         }
 746         tevent_req_set_callback(subreq, rpccli_epm_LookupHandleFree_done, req);
 747         return req;
 748 }
 749
 750 static void rpccli_epm_LookupHandleFree_done(struct tevent_req *subreq)
 751 {
 752         struct tevent_req *req = tevent_req_callback_data(
 753                 subreq, struct tevent_req);
 754         struct rpccli_epm_LookupHandleFree_state *state = tevent_req_data(
 755                 req, struct rpccli_epm_LookupHandleFree_state);
 756         NTSTATUS status;
 757         TALLOC_CTX *mem_ctx;
 758
 759         if (state->out_mem_ctx) {
 760                 mem_ctx = state->out_mem_ctx;
 761         } else {
 762                 mem_ctx = state;
 763         }
 764
 765         status = state->dispatch_recv(subreq, mem_ctx);
 766         TALLOC_FREE(subreq);
 767         if (!NT_STATUS_IS_OK(status)) {
 768                 tevent_req_nterror(req, status);
 769                 return;
 770         }
 771
 772         /* Copy out parameters */
 773         *state->orig.out.entry_handle = *state->tmp.out.entry_handle;
 774
 775         /* Copy result */
 776         state->orig.out.result = state->tmp.out.result;
 777
 778         /* Reset temporary structure */
 779         ZERO_STRUCT(state->tmp);
 780
 781         if (DEBUGLEVEL >= 10) {
 782                 NDR_PRINT_OUT_DEBUG(epm_LookupHandleFree, &state->orig);
 783         }
 784
 785         tevent_req_done(req);
 786 }
 787
 788 NTSTATUS rpccli_epm_LookupHandleFree_recv(struct tevent_req *req,
 789                                           TALLOC_CTX *mem_ctx,
 790                                           uint32 *result)
 791 {
 792         struct rpccli_epm_LookupHandleFree_state *state = tevent_req_data(
 793                 req, struct rpccli_epm_LookupHandleFree_state);
 794         NTSTATUS status;
 795
 796         if (tevent_req_is_nterror(req, &status)) {
 797                 tevent_req_received(req);
 798                 return status;
 799         }
 800
 801         /* Steal possbile out parameters to the callers context */
 802         talloc_steal(mem_ctx, state->out_mem_ctx);
 803
 804         /* Return result */
 805         *result = state->orig.out.result;
 806
 807         tevent_req_received(req);
 808         return NT_STATUS_OK;
 809 }
 810
 811 NTSTATUS rpccli_epm_LookupHandleFree(struct rpc_pipe_client *cli,
 812                                      TALLOC_CTX *mem_ctx,
 813                                      struct policy_handle *entry_handle /* [in,out] [ref] */)
 814 {
 815         struct epm_LookupHandleFree r;
 816         NTSTATUS status;
 817
 818         /* In parameters */
 819         r.in.entry_handle = entry_handle;
 820
 821         if (DEBUGLEVEL >= 10) {
 822                 NDR_PRINT_IN_DEBUG(epm_LookupHandleFree, &r);
 823         }
 824
 825         status = cli->dispatch(cli,
 826                                 mem_ctx,
 827                                 &ndr_table_epmapper,
 828                                 NDR_EPM_LOOKUPHANDLEFREE,
 829                                 &r);
 830
 831         if (!NT_STATUS_IS_OK(status)) {
 832                 return status;
 833         }
 834
 835         if (DEBUGLEVEL >= 10) {
 836                 NDR_PRINT_OUT_DEBUG(epm_LookupHandleFree, &r);
 837         }
 838
 839         if (NT_STATUS_IS_ERR(status)) {
 840                 return status;
 841         }
 842
 843         /* Return variables */
 844         *entry_handle = *r.out.entry_handle;
 845
 846         /* Return result */
 847         return NT_STATUS_OK;
 848 }
 849
 850 struct rpccli_epm_InqObject_state {
 851         struct epm_InqObject orig;
 852         struct epm_InqObject tmp;
 853         TALLOC_CTX *out_mem_ctx;
 854         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
 855 };
 856
 857 static void rpccli_epm_InqObject_done(struct tevent_req *subreq);
 858
 859 struct tevent_req *rpccli_epm_InqObject_send(TALLOC_CTX *mem_ctx,
 860                                              struct tevent_context *ev,
 861                                              struct rpc_pipe_client *cli,
 862                                              struct GUID *_epm_object /* [in] [ref] */)
 863 {
 864         struct tevent_req *req;
 865         struct rpccli_epm_InqObject_state *state;
 866         struct tevent_req *subreq;
 867
 868         req = tevent_req_create(mem_ctx, &state,
 869                                 struct rpccli_epm_InqObject_state);
 870         if (req == NULL) {
 871                 return NULL;
 872         }
 873         state->out_mem_ctx = NULL;
 874         state->dispatch_recv = cli->dispatch_recv;
 875
 876         /* In parameters */
 877         state->orig.in.epm_object = _epm_object;
 878
 879         /* Out parameters */
 880
 881         /* Result */
 882         ZERO_STRUCT(state->orig.out.result);
 883
 884         if (DEBUGLEVEL >= 10) {
 885                 NDR_PRINT_IN_DEBUG(epm_InqObject, &state->orig);
 886         }
 887
 888         /* make a temporary copy, that we pass to the dispatch function */
 889         state->tmp = state->orig;
 890
 891         subreq = cli->dispatch_send(state, ev, cli,
 892                                     &ndr_table_epmapper,
 893                                     NDR_EPM_INQOBJECT,
 894                                     &state->tmp);
 895         if (tevent_req_nomem(subreq, req)) {
 896                 return tevent_req_post(req, ev);
 897         }
 898         tevent_req_set_callback(subreq, rpccli_epm_InqObject_done, req);
 899         return req;
 900 }
 901
 902 static void rpccli_epm_InqObject_done(struct tevent_req *subreq)
 903 {
 904         struct tevent_req *req = tevent_req_callback_data(
 905                 subreq, struct tevent_req);
 906         struct rpccli_epm_InqObject_state *state = tevent_req_data(
 907                 req, struct rpccli_epm_InqObject_state);
 908         NTSTATUS status;
 909         TALLOC_CTX *mem_ctx;
 910
 911         if (state->out_mem_ctx) {
 912                 mem_ctx = state->out_mem_ctx;
 913         } else {
 914                 mem_ctx = state;
 915         }
 916
 917         status = state->dispatch_recv(subreq, mem_ctx);
 918         TALLOC_FREE(subreq);
 919         if (!NT_STATUS_IS_OK(status)) {
 920                 tevent_req_nterror(req, status);
 921                 return;
 922         }
 923
 924         /* Copy out parameters */
 925
 926         /* Copy result */
 927         state->orig.out.result = state->tmp.out.result;
 928
 929         /* Reset temporary structure */
 930         ZERO_STRUCT(state->tmp);
 931
 932         if (DEBUGLEVEL >= 10) {
 933                 NDR_PRINT_OUT_DEBUG(epm_InqObject, &state->orig);
 934         }
 935
 936         tevent_req_done(req);
 937 }
 938
 939 NTSTATUS rpccli_epm_InqObject_recv(struct tevent_req *req,
 940                                    TALLOC_CTX *mem_ctx,
 941                                    uint32 *result)
 942 {
 943         struct rpccli_epm_InqObject_state *state = tevent_req_data(
 944                 req, struct rpccli_epm_InqObject_state);
 945         NTSTATUS status;
 946
 947         if (tevent_req_is_nterror(req, &status)) {
 948                 tevent_req_received(req);
 949                 return status;
 950         }
 951
 952         /* Steal possbile out parameters to the callers context */
 953         talloc_steal(mem_ctx, state->out_mem_ctx);
 954
 955         /* Return result */
 956         *result = state->orig.out.result;
 957
 958         tevent_req_received(req);
 959         return NT_STATUS_OK;
 960 }
 961
 962 NTSTATUS rpccli_epm_InqObject(struct rpc_pipe_client *cli,
 963                               TALLOC_CTX *mem_ctx,
 964                               struct GUID *epm_object /* [in] [ref] */)
 965 {
 966         struct epm_InqObject r;
 967         NTSTATUS status;
 968
 969         /* In parameters */
 970         r.in.epm_object = epm_object;
 971
 972         if (DEBUGLEVEL >= 10) {
 973                 NDR_PRINT_IN_DEBUG(epm_InqObject, &r);
 974         }
 975
 976         status = cli->dispatch(cli,
 977                                 mem_ctx,
 978                                 &ndr_table_epmapper,
 979                                 NDR_EPM_INQOBJECT,
 980                                 &r);
 981
 982         if (!NT_STATUS_IS_OK(status)) {
 983                 return status;
 984         }
 985
 986         if (DEBUGLEVEL >= 10) {
 987                 NDR_PRINT_OUT_DEBUG(epm_InqObject, &r);
 988         }
 989
 990         if (NT_STATUS_IS_ERR(status)) {
 991                 return status;
 992         }
 993
 994         /* Return variables */
 995
 996         /* Return result */
 997         return NT_STATUS_OK;
 998 }
 999
1000 struct rpccli_epm_MgmtDelete_state {
1001         struct epm_MgmtDelete orig;
1002         struct epm_MgmtDelete tmp;
1003         TALLOC_CTX *out_mem_ctx;
1004         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1005 };
1006
1007 static void rpccli_epm_MgmtDelete_done(struct tevent_req *subreq);
1008
1009 struct tevent_req *rpccli_epm_MgmtDelete_send(TALLOC_CTX *mem_ctx,
1010                                               struct tevent_context *ev,
1011                                               struct rpc_pipe_client *cli,
1012                                               uint32_t _object_speced /* [in]  */,
1013                                               struct GUID *_object /* [in] [ptr] */,
1014                                               struct epm_twr_t *_tower /* [in] [ptr] */)
1015 {
1016         struct tevent_req *req;
1017         struct rpccli_epm_MgmtDelete_state *state;
1018         struct tevent_req *subreq;
1019
1020         req = tevent_req_create(mem_ctx, &state,
1021                                 struct rpccli_epm_MgmtDelete_state);
1022         if (req == NULL) {
1023                 return NULL;
1024         }
1025         state->out_mem_ctx = NULL;
1026         state->dispatch_recv = cli->dispatch_recv;
1027
1028         /* In parameters */
1029         state->orig.in.object_speced = _object_speced;
1030         state->orig.in.object = _object;
1031         state->orig.in.tower = _tower;
1032
1033         /* Out parameters */
1034
1035         /* Result */
1036         ZERO_STRUCT(state->orig.out.result);
1037
1038         if (DEBUGLEVEL >= 10) {
1039                 NDR_PRINT_IN_DEBUG(epm_MgmtDelete, &state->orig);
1040         }
1041
1042         /* make a temporary copy, that we pass to the dispatch function */
1043         state->tmp = state->orig;
1044
1045         subreq = cli->dispatch_send(state, ev, cli,
1046                                     &ndr_table_epmapper,
1047                                     NDR_EPM_MGMTDELETE,
1048                                     &state->tmp);
1049         if (tevent_req_nomem(subreq, req)) {
1050                 return tevent_req_post(req, ev);
1051         }
1052         tevent_req_set_callback(subreq, rpccli_epm_MgmtDelete_done, req);
1053         return req;
1054 }
1055
1056 static void rpccli_epm_MgmtDelete_done(struct tevent_req *subreq)
1057 {
1058         struct tevent_req *req = tevent_req_callback_data(
1059                 subreq, struct tevent_req);
1060         struct rpccli_epm_MgmtDelete_state *state = tevent_req_data(
1061                 req, struct rpccli_epm_MgmtDelete_state);
1062         NTSTATUS status;
1063         TALLOC_CTX *mem_ctx;
1064
1065         if (state->out_mem_ctx) {
1066                 mem_ctx = state->out_mem_ctx;
1067         } else {
1068                 mem_ctx = state;
1069         }
1070
1071         status = state->dispatch_recv(subreq, mem_ctx);
1072         TALLOC_FREE(subreq);
1073         if (!NT_STATUS_IS_OK(status)) {
1074                 tevent_req_nterror(req, status);
1075                 return;
1076         }
1077
1078         /* Copy out parameters */
1079
1080         /* Copy result */
1081         state->orig.out.result = state->tmp.out.result;
1082
1083         /* Reset temporary structure */
1084         ZERO_STRUCT(state->tmp);
1085
1086         if (DEBUGLEVEL >= 10) {
1087                 NDR_PRINT_OUT_DEBUG(epm_MgmtDelete, &state->orig);
1088         }
1089
1090         tevent_req_done(req);
1091 }
1092
1093 NTSTATUS rpccli_epm_MgmtDelete_recv(struct tevent_req *req,
1094                                     TALLOC_CTX *mem_ctx,
1095                                     uint32 *result)
1096 {
1097         struct rpccli_epm_MgmtDelete_state *state = tevent_req_data(
1098                 req, struct rpccli_epm_MgmtDelete_state);
1099         NTSTATUS status;
1100
1101         if (tevent_req_is_nterror(req, &status)) {
1102                 tevent_req_received(req);
1103                 return status;
1104         }
1105
1106         /* Steal possbile out parameters to the callers context */
1107         talloc_steal(mem_ctx, state->out_mem_ctx);
1108
1109         /* Return result */
1110         *result = state->orig.out.result;
1111
1112         tevent_req_received(req);
1113         return NT_STATUS_OK;
1114 }
1115
1116 NTSTATUS rpccli_epm_MgmtDelete(struct rpc_pipe_client *cli,
1117                                TALLOC_CTX *mem_ctx,
1118                                uint32_t object_speced /* [in]  */,
1119                                struct GUID *object /* [in] [ptr] */,
1120                                struct epm_twr_t *tower /* [in] [ptr] */)
1121 {
1122         struct epm_MgmtDelete r;
1123         NTSTATUS status;
1124
1125         /* In parameters */
1126         r.in.object_speced = object_speced;
1127         r.in.object = object;
1128         r.in.tower = tower;
1129
1130         if (DEBUGLEVEL >= 10) {
1131                 NDR_PRINT_IN_DEBUG(epm_MgmtDelete, &r);
1132         }
1133
1134         status = cli->dispatch(cli,
1135                                 mem_ctx,
1136                                 &ndr_table_epmapper,
1137                                 NDR_EPM_MGMTDELETE,
1138                                 &r);
1139
1140         if (!NT_STATUS_IS_OK(status)) {
1141                 return status;
1142         }
1143
1144         if (DEBUGLEVEL >= 10) {
1145                 NDR_PRINT_OUT_DEBUG(epm_MgmtDelete, &r);
1146         }
1147
1148         if (NT_STATUS_IS_ERR(status)) {
1149                 return status;
1150         }
1151
1152         /* Return variables */
1153
1154         /* Return result */
1155         return NT_STATUS_OK;
1156 }
1157
1158 struct rpccli_epm_MapAuth_state {
1159         struct epm_MapAuth orig;
1160         struct epm_MapAuth tmp;
1161         TALLOC_CTX *out_mem_ctx;
1162         NTSTATUS (*dispatch_recv)(struct tevent_req *req, TALLOC_CTX *mem_ctx);
1163 };
1164
1165 static void rpccli_epm_MapAuth_done(struct tevent_req *subreq);
1166
1167 struct tevent_req *rpccli_epm_MapAuth_send(TALLOC_CTX *mem_ctx,
1168                                            struct tevent_context *ev,
1169                                            struct rpc_pipe_client *cli)
1170 {
1171         struct tevent_req *req;
1172         struct rpccli_epm_MapAuth_state *state;
1173         struct tevent_req *subreq;
1174
1175         req = tevent_req_create(mem_ctx, &state,
1176                                 struct rpccli_epm_MapAuth_state);
1177         if (req == NULL) {
1178                 return NULL;
1179         }
1180         state->out_mem_ctx = NULL;
1181         state->dispatch_recv = cli->dispatch_recv;
1182
1183         /* In parameters */
1184
1185         /* Out parameters */
1186
1187         /* Result */
1188         ZERO_STRUCT(state->orig.out.result);
1189
1190         if (DEBUGLEVEL >= 10) {
1191                 NDR_PRINT_IN_DEBUG(epm_MapAuth, &state->orig);
1192         }
1193
1194         /* make a temporary copy, that we pass to the dispatch function */
1195         state->tmp = state->orig;
1196
1197         subreq = cli->dispatch_send(state, ev, cli,
1198                                     &ndr_table_epmapper,
1199                                     NDR_EPM_MAPAUTH,
1200                                     &state->tmp);
1201         if (tevent_req_nomem(subreq, req)) {
1202                 return tevent_req_post(req, ev);
1203         }
1204         tevent_req_set_callback(subreq, rpccli_epm_MapAuth_done, req);
1205         return req;
1206 }
1207
1208 static void rpccli_epm_MapAuth_done(struct tevent_req *subreq)
1209 {
1210         struct tevent_req *req = tevent_req_callback_data(
1211                 subreq, struct tevent_req);
1212         struct rpccli_epm_MapAuth_state *state = tevent_req_data(
1213                 req, struct rpccli_epm_MapAuth_state);
1214         NTSTATUS status;
1215         TALLOC_CTX *mem_ctx;
1216
1217         if (state->out_mem_ctx) {
1218                 mem_ctx = state->out_mem_ctx;
1219         } else {
1220                 mem_ctx = state;
1221         }
1222
1223         status = state->dispatch_recv(subreq, mem_ctx);
1224         TALLOC_FREE(subreq);
1225         if (!NT_STATUS_IS_OK(status)) {
1226                 tevent_req_nterror(req, status);
1227                 return;
1228         }
1229
1230         /* Copy out parameters */
1231
1232         /* Copy result */
1233         state->orig.out.result = state->tmp.out.result;
1234
1235         /* Reset temporary structure */
1236         ZERO_STRUCT(state->tmp);
1237
1238         if (DEBUGLEVEL >= 10) {
1239                 NDR_PRINT_OUT_DEBUG(epm_MapAuth, &state->orig);
1240         }
1241
1242         tevent_req_done(req);
1243 }
1244
1245 NTSTATUS rpccli_epm_MapAuth_recv(struct tevent_req *req,
1246                                  TALLOC_CTX *mem_ctx,
1247                                  uint32 *result)
1248 {
1249         struct rpccli_epm_MapAuth_state *state = tevent_req_data(
1250                 req, struct rpccli_epm_MapAuth_state);
1251         NTSTATUS status;
1252
1253         if (tevent_req_is_nterror(req, &status)) {
1254                 tevent_req_received(req);
1255                 return status;
1256         }
1257
1258         /* Steal possbile out parameters to the callers context */
1259         talloc_steal(mem_ctx, state->out_mem_ctx);
1260
1261         /* Return result */
1262         *result = state->orig.out.result;
1263
1264         tevent_req_received(req);
1265         return NT_STATUS_OK;
1266 }
1267
1268 NTSTATUS rpccli_epm_MapAuth(struct rpc_pipe_client *cli,
1269                             TALLOC_CTX *mem_ctx)
1270 {
1271         struct epm_MapAuth r;
1272         NTSTATUS status;
1273
1274         /* In parameters */
1275
1276         if (DEBUGLEVEL >= 10) {
1277                 NDR_PRINT_IN_DEBUG(epm_MapAuth, &r);
1278         }
1279
1280         status = cli->dispatch(cli,
1281                                 mem_ctx,
1282                                 &ndr_table_epmapper,
1283                                 NDR_EPM_MAPAUTH,
1284                                 &r);
1285
1286         if (!NT_STATUS_IS_OK(status)) {
1287                 return status;
1288         }
1289
1290         if (DEBUGLEVEL >= 10) {
1291                 NDR_PRINT_OUT_DEBUG(epm_MapAuth, &r);
1292         }
1293
1294         if (NT_STATUS_IS_ERR(status)) {
1295                 return status;
1296         }
1297
1298         /* Return variables */
1299
1300         /* Return result */
1301         return NT_STATUS_OK;
1302 }
1303