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