librpc/gen_ndr/srv_echo.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * server auto-generated by pidl. DO NOT MODIFY!
   4  */
   5
   6 #include "includes.h"
   7 #include "../librpc/gen_ndr/srv_echo.h"
   8
   9 static bool api_echo_AddOne(pipes_struct *p)
  10 {
  11         const struct ndr_interface_call *call;
  12         struct ndr_pull *pull;
  13         struct ndr_push *push;
  14         enum ndr_err_code ndr_err;
  15         DATA_BLOB blob;
  16         struct echo_AddOne *r;
  17
  18         call = &ndr_table_rpcecho.calls[NDR_ECHO_ADDONE];
  19
  20         r = talloc(talloc_tos(), struct echo_AddOne);
  21         if (r == NULL) {
  22                 return false;
  23         }
  24
  25         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
  26                 talloc_free(r);
  27                 return false;
  28         }
  29
  30         pull = ndr_pull_init_blob(&blob, r, NULL);
  31         if (pull == NULL) {
  32                 talloc_free(r);
  33                 return false;
  34         }
  35
  36         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
  37         ndr_err = call->ndr_pull(pull, NDR_IN, r);
  38         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  39                 talloc_free(r);
  40                 return false;
  41         }
  42
  43         if (DEBUGLEVEL >= 10) {
  44                 NDR_PRINT_IN_DEBUG(echo_AddOne, r);
  45         }
  46
  47         ZERO_STRUCT(r->out);
  48         r->out.out_data = talloc_zero(r, uint32_t);
  49         if (r->out.out_data == NULL) {
  50                 talloc_free(r);
  51                 return false;
  52         }
  53
  54         _echo_AddOne(p, r);
  55
  56         if (p->rng_fault_state) {
  57                 talloc_free(r);
  58                 /* Return true here, srv_pipe_hnd.c will take care */
  59                 return true;
  60         }
  61
  62         if (DEBUGLEVEL >= 10) {
  63                 NDR_PRINT_OUT_DEBUG(echo_AddOne, r);
  64         }
  65
  66         push = ndr_push_init_ctx(r, NULL);
  67         if (push == NULL) {
  68                 talloc_free(r);
  69                 return false;
  70         }
  71
  72         ndr_err = call->ndr_push(push, NDR_OUT, r);
  73         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  74                 talloc_free(r);
  75                 return false;
  76         }
  77
  78         blob = ndr_push_blob(push);
  79         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
  80                 talloc_free(r);
  81                 return false;
  82         }
  83
  84         talloc_free(r);
  85
  86         return true;
  87 }
  88
  89 static bool api_echo_EchoData(pipes_struct *p)
  90 {
  91         const struct ndr_interface_call *call;
  92         struct ndr_pull *pull;
  93         struct ndr_push *push;
  94         enum ndr_err_code ndr_err;
  95         DATA_BLOB blob;
  96         struct echo_EchoData *r;
  97
  98         call = &ndr_table_rpcecho.calls[NDR_ECHO_ECHODATA];
  99
 100         r = talloc(talloc_tos(), struct echo_EchoData);
 101         if (r == NULL) {
 102                 return false;
 103         }
 104
 105         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 106                 talloc_free(r);
 107                 return false;
 108         }
 109
 110         pull = ndr_pull_init_blob(&blob, r, NULL);
 111         if (pull == NULL) {
 112                 talloc_free(r);
 113                 return false;
 114         }
 115
 116         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 117         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 118         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 119                 talloc_free(r);
 120                 return false;
 121         }
 122
 123         if (DEBUGLEVEL >= 10) {
 124                 NDR_PRINT_IN_DEBUG(echo_EchoData, r);
 125         }
 126
 127         ZERO_STRUCT(r->out);
 128         r->out.out_data = talloc_zero_array(r, uint8_t, r->in.len);
 129         if (r->out.out_data == NULL) {
 130                 talloc_free(r);
 131                 return false;
 132         }
 133
 134         _echo_EchoData(p, r);
 135
 136         if (p->rng_fault_state) {
 137                 talloc_free(r);
 138                 /* Return true here, srv_pipe_hnd.c will take care */
 139                 return true;
 140         }
 141
 142         if (DEBUGLEVEL >= 10) {
 143                 NDR_PRINT_OUT_DEBUG(echo_EchoData, r);
 144         }
 145
 146         push = ndr_push_init_ctx(r, NULL);
 147         if (push == NULL) {
 148                 talloc_free(r);
 149                 return false;
 150         }
 151
 152         ndr_err = call->ndr_push(push, NDR_OUT, r);
 153         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 154                 talloc_free(r);
 155                 return false;
 156         }
 157
 158         blob = ndr_push_blob(push);
 159         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 160                 talloc_free(r);
 161                 return false;
 162         }
 163
 164         talloc_free(r);
 165
 166         return true;
 167 }
 168
 169 static bool api_echo_SinkData(pipes_struct *p)
 170 {
 171         const struct ndr_interface_call *call;
 172         struct ndr_pull *pull;
 173         struct ndr_push *push;
 174         enum ndr_err_code ndr_err;
 175         DATA_BLOB blob;
 176         struct echo_SinkData *r;
 177
 178         call = &ndr_table_rpcecho.calls[NDR_ECHO_SINKDATA];
 179
 180         r = talloc(talloc_tos(), struct echo_SinkData);
 181         if (r == NULL) {
 182                 return false;
 183         }
 184
 185         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 186                 talloc_free(r);
 187                 return false;
 188         }
 189
 190         pull = ndr_pull_init_blob(&blob, r, NULL);
 191         if (pull == NULL) {
 192                 talloc_free(r);
 193                 return false;
 194         }
 195
 196         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 197         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 198         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 199                 talloc_free(r);
 200                 return false;
 201         }
 202
 203         if (DEBUGLEVEL >= 10) {
 204                 NDR_PRINT_IN_DEBUG(echo_SinkData, r);
 205         }
 206
 207         _echo_SinkData(p, r);
 208
 209         if (p->rng_fault_state) {
 210                 talloc_free(r);
 211                 /* Return true here, srv_pipe_hnd.c will take care */
 212                 return true;
 213         }
 214
 215         if (DEBUGLEVEL >= 10) {
 216                 NDR_PRINT_OUT_DEBUG(echo_SinkData, r);
 217         }
 218
 219         push = ndr_push_init_ctx(r, NULL);
 220         if (push == NULL) {
 221                 talloc_free(r);
 222                 return false;
 223         }
 224
 225         ndr_err = call->ndr_push(push, NDR_OUT, r);
 226         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 227                 talloc_free(r);
 228                 return false;
 229         }
 230
 231         blob = ndr_push_blob(push);
 232         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 233                 talloc_free(r);
 234                 return false;
 235         }
 236
 237         talloc_free(r);
 238
 239         return true;
 240 }
 241
 242 static bool api_echo_SourceData(pipes_struct *p)
 243 {
 244         const struct ndr_interface_call *call;
 245         struct ndr_pull *pull;
 246         struct ndr_push *push;
 247         enum ndr_err_code ndr_err;
 248         DATA_BLOB blob;
 249         struct echo_SourceData *r;
 250
 251         call = &ndr_table_rpcecho.calls[NDR_ECHO_SOURCEDATA];
 252
 253         r = talloc(talloc_tos(), struct echo_SourceData);
 254         if (r == NULL) {
 255                 return false;
 256         }
 257
 258         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 259                 talloc_free(r);
 260                 return false;
 261         }
 262
 263         pull = ndr_pull_init_blob(&blob, r, NULL);
 264         if (pull == NULL) {
 265                 talloc_free(r);
 266                 return false;
 267         }
 268
 269         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 270         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 271         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 272                 talloc_free(r);
 273                 return false;
 274         }
 275
 276         if (DEBUGLEVEL >= 10) {
 277                 NDR_PRINT_IN_DEBUG(echo_SourceData, r);
 278         }
 279
 280         ZERO_STRUCT(r->out);
 281         r->out.data = talloc_zero_array(r, uint8_t, r->in.len);
 282         if (r->out.data == NULL) {
 283                 talloc_free(r);
 284                 return false;
 285         }
 286
 287         _echo_SourceData(p, r);
 288
 289         if (p->rng_fault_state) {
 290                 talloc_free(r);
 291                 /* Return true here, srv_pipe_hnd.c will take care */
 292                 return true;
 293         }
 294
 295         if (DEBUGLEVEL >= 10) {
 296                 NDR_PRINT_OUT_DEBUG(echo_SourceData, r);
 297         }
 298
 299         push = ndr_push_init_ctx(r, NULL);
 300         if (push == NULL) {
 301                 talloc_free(r);
 302                 return false;
 303         }
 304
 305         ndr_err = call->ndr_push(push, NDR_OUT, r);
 306         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 307                 talloc_free(r);
 308                 return false;
 309         }
 310
 311         blob = ndr_push_blob(push);
 312         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 313                 talloc_free(r);
 314                 return false;
 315         }
 316
 317         talloc_free(r);
 318
 319         return true;
 320 }
 321
 322 static bool api_echo_TestCall(pipes_struct *p)
 323 {
 324         const struct ndr_interface_call *call;
 325         struct ndr_pull *pull;
 326         struct ndr_push *push;
 327         enum ndr_err_code ndr_err;
 328         DATA_BLOB blob;
 329         struct echo_TestCall *r;
 330
 331         call = &ndr_table_rpcecho.calls[NDR_ECHO_TESTCALL];
 332
 333         r = talloc(talloc_tos(), struct echo_TestCall);
 334         if (r == NULL) {
 335                 return false;
 336         }
 337
 338         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 339                 talloc_free(r);
 340                 return false;
 341         }
 342
 343         pull = ndr_pull_init_blob(&blob, r, NULL);
 344         if (pull == NULL) {
 345                 talloc_free(r);
 346                 return false;
 347         }
 348
 349         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 350         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 351         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 352                 talloc_free(r);
 353                 return false;
 354         }
 355
 356         if (DEBUGLEVEL >= 10) {
 357                 NDR_PRINT_IN_DEBUG(echo_TestCall, r);
 358         }
 359
 360         ZERO_STRUCT(r->out);
 361         r->out.s2 = talloc_zero(r, const char *);
 362         if (r->out.s2 == NULL) {
 363                 talloc_free(r);
 364                 return false;
 365         }
 366
 367         _echo_TestCall(p, r);
 368
 369         if (p->rng_fault_state) {
 370                 talloc_free(r);
 371                 /* Return true here, srv_pipe_hnd.c will take care */
 372                 return true;
 373         }
 374
 375         if (DEBUGLEVEL >= 10) {
 376                 NDR_PRINT_OUT_DEBUG(echo_TestCall, r);
 377         }
 378
 379         push = ndr_push_init_ctx(r, NULL);
 380         if (push == NULL) {
 381                 talloc_free(r);
 382                 return false;
 383         }
 384
 385         ndr_err = call->ndr_push(push, NDR_OUT, r);
 386         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 387                 talloc_free(r);
 388                 return false;
 389         }
 390
 391         blob = ndr_push_blob(push);
 392         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 393                 talloc_free(r);
 394                 return false;
 395         }
 396
 397         talloc_free(r);
 398
 399         return true;
 400 }
 401
 402 static bool api_echo_TestCall2(pipes_struct *p)
 403 {
 404         const struct ndr_interface_call *call;
 405         struct ndr_pull *pull;
 406         struct ndr_push *push;
 407         enum ndr_err_code ndr_err;
 408         DATA_BLOB blob;
 409         struct echo_TestCall2 *r;
 410
 411         call = &ndr_table_rpcecho.calls[NDR_ECHO_TESTCALL2];
 412
 413         r = talloc(talloc_tos(), struct echo_TestCall2);
 414         if (r == NULL) {
 415                 return false;
 416         }
 417
 418         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 419                 talloc_free(r);
 420                 return false;
 421         }
 422
 423         pull = ndr_pull_init_blob(&blob, r, NULL);
 424         if (pull == NULL) {
 425                 talloc_free(r);
 426                 return false;
 427         }
 428
 429         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 430         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 431         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 432                 talloc_free(r);
 433                 return false;
 434         }
 435
 436         if (DEBUGLEVEL >= 10) {
 437                 NDR_PRINT_IN_DEBUG(echo_TestCall2, r);
 438         }
 439
 440         ZERO_STRUCT(r->out);
 441         r->out.info = talloc_zero(r, union echo_Info);
 442         if (r->out.info == NULL) {
 443                 talloc_free(r);
 444                 return false;
 445         }
 446
 447         r->out.result = _echo_TestCall2(p, r);
 448
 449         if (p->rng_fault_state) {
 450                 talloc_free(r);
 451                 /* Return true here, srv_pipe_hnd.c will take care */
 452                 return true;
 453         }
 454
 455         if (DEBUGLEVEL >= 10) {
 456                 NDR_PRINT_OUT_DEBUG(echo_TestCall2, r);
 457         }
 458
 459         push = ndr_push_init_ctx(r, NULL);
 460         if (push == NULL) {
 461                 talloc_free(r);
 462                 return false;
 463         }
 464
 465         ndr_err = call->ndr_push(push, NDR_OUT, r);
 466         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 467                 talloc_free(r);
 468                 return false;
 469         }
 470
 471         blob = ndr_push_blob(push);
 472         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 473                 talloc_free(r);
 474                 return false;
 475         }
 476
 477         talloc_free(r);
 478
 479         return true;
 480 }
 481
 482 static bool api_echo_TestSleep(pipes_struct *p)
 483 {
 484         const struct ndr_interface_call *call;
 485         struct ndr_pull *pull;
 486         struct ndr_push *push;
 487         enum ndr_err_code ndr_err;
 488         DATA_BLOB blob;
 489         struct echo_TestSleep *r;
 490
 491         call = &ndr_table_rpcecho.calls[NDR_ECHO_TESTSLEEP];
 492
 493         r = talloc(talloc_tos(), struct echo_TestSleep);
 494         if (r == NULL) {
 495                 return false;
 496         }
 497
 498         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 499                 talloc_free(r);
 500                 return false;
 501         }
 502
 503         pull = ndr_pull_init_blob(&blob, r, NULL);
 504         if (pull == NULL) {
 505                 talloc_free(r);
 506                 return false;
 507         }
 508
 509         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 510         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 511         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 512                 talloc_free(r);
 513                 return false;
 514         }
 515
 516         if (DEBUGLEVEL >= 10) {
 517                 NDR_PRINT_IN_DEBUG(echo_TestSleep, r);
 518         }
 519
 520         r->out.result = _echo_TestSleep(p, r);
 521
 522         if (p->rng_fault_state) {
 523                 talloc_free(r);
 524                 /* Return true here, srv_pipe_hnd.c will take care */
 525                 return true;
 526         }
 527
 528         if (DEBUGLEVEL >= 10) {
 529                 NDR_PRINT_OUT_DEBUG(echo_TestSleep, r);
 530         }
 531
 532         push = ndr_push_init_ctx(r, NULL);
 533         if (push == NULL) {
 534                 talloc_free(r);
 535                 return false;
 536         }
 537
 538         ndr_err = call->ndr_push(push, NDR_OUT, r);
 539         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 540                 talloc_free(r);
 541                 return false;
 542         }
 543
 544         blob = ndr_push_blob(push);
 545         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 546                 talloc_free(r);
 547                 return false;
 548         }
 549
 550         talloc_free(r);
 551
 552         return true;
 553 }
 554
 555 static bool api_echo_TestEnum(pipes_struct *p)
 556 {
 557         const struct ndr_interface_call *call;
 558         struct ndr_pull *pull;
 559         struct ndr_push *push;
 560         enum ndr_err_code ndr_err;
 561         DATA_BLOB blob;
 562         struct echo_TestEnum *r;
 563
 564         call = &ndr_table_rpcecho.calls[NDR_ECHO_TESTENUM];
 565
 566         r = talloc(talloc_tos(), struct echo_TestEnum);
 567         if (r == NULL) {
 568                 return false;
 569         }
 570
 571         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 572                 talloc_free(r);
 573                 return false;
 574         }
 575
 576         pull = ndr_pull_init_blob(&blob, r, NULL);
 577         if (pull == NULL) {
 578                 talloc_free(r);
 579                 return false;
 580         }
 581
 582         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 583         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 584         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 585                 talloc_free(r);
 586                 return false;
 587         }
 588
 589         if (DEBUGLEVEL >= 10) {
 590                 NDR_PRINT_IN_DEBUG(echo_TestEnum, r);
 591         }
 592
 593         ZERO_STRUCT(r->out);
 594         r->out.foo1 = r->in.foo1;
 595         r->out.foo2 = r->in.foo2;
 596         r->out.foo3 = r->in.foo3;
 597         _echo_TestEnum(p, r);
 598
 599         if (p->rng_fault_state) {
 600                 talloc_free(r);
 601                 /* Return true here, srv_pipe_hnd.c will take care */
 602                 return true;
 603         }
 604
 605         if (DEBUGLEVEL >= 10) {
 606                 NDR_PRINT_OUT_DEBUG(echo_TestEnum, r);
 607         }
 608
 609         push = ndr_push_init_ctx(r, NULL);
 610         if (push == NULL) {
 611                 talloc_free(r);
 612                 return false;
 613         }
 614
 615         ndr_err = call->ndr_push(push, NDR_OUT, r);
 616         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 617                 talloc_free(r);
 618                 return false;
 619         }
 620
 621         blob = ndr_push_blob(push);
 622         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 623                 talloc_free(r);
 624                 return false;
 625         }
 626
 627         talloc_free(r);
 628
 629         return true;
 630 }
 631
 632 static bool api_echo_TestSurrounding(pipes_struct *p)
 633 {
 634         const struct ndr_interface_call *call;
 635         struct ndr_pull *pull;
 636         struct ndr_push *push;
 637         enum ndr_err_code ndr_err;
 638         DATA_BLOB blob;
 639         struct echo_TestSurrounding *r;
 640
 641         call = &ndr_table_rpcecho.calls[NDR_ECHO_TESTSURROUNDING];
 642
 643         r = talloc(talloc_tos(), struct echo_TestSurrounding);
 644         if (r == NULL) {
 645                 return false;
 646         }
 647
 648         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 649                 talloc_free(r);
 650                 return false;
 651         }
 652
 653         pull = ndr_pull_init_blob(&blob, r, NULL);
 654         if (pull == NULL) {
 655                 talloc_free(r);
 656                 return false;
 657         }
 658
 659         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 660         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 661         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 662                 talloc_free(r);
 663                 return false;
 664         }
 665
 666         if (DEBUGLEVEL >= 10) {
 667                 NDR_PRINT_IN_DEBUG(echo_TestSurrounding, r);
 668         }
 669
 670         ZERO_STRUCT(r->out);
 671         r->out.data = r->in.data;
 672         _echo_TestSurrounding(p, r);
 673
 674         if (p->rng_fault_state) {
 675                 talloc_free(r);
 676                 /* Return true here, srv_pipe_hnd.c will take care */
 677                 return true;
 678         }
 679
 680         if (DEBUGLEVEL >= 10) {
 681                 NDR_PRINT_OUT_DEBUG(echo_TestSurrounding, r);
 682         }
 683
 684         push = ndr_push_init_ctx(r, NULL);
 685         if (push == NULL) {
 686                 talloc_free(r);
 687                 return false;
 688         }
 689
 690         ndr_err = call->ndr_push(push, NDR_OUT, r);
 691         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 692                 talloc_free(r);
 693                 return false;
 694         }
 695
 696         blob = ndr_push_blob(push);
 697         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 698                 talloc_free(r);
 699                 return false;
 700         }
 701
 702         talloc_free(r);
 703
 704         return true;
 705 }
 706
 707 static bool api_echo_TestDoublePointer(pipes_struct *p)
 708 {
 709         const struct ndr_interface_call *call;
 710         struct ndr_pull *pull;
 711         struct ndr_push *push;
 712         enum ndr_err_code ndr_err;
 713         DATA_BLOB blob;
 714         struct echo_TestDoublePointer *r;
 715
 716         call = &ndr_table_rpcecho.calls[NDR_ECHO_TESTDOUBLEPOINTER];
 717
 718         r = talloc(talloc_tos(), struct echo_TestDoublePointer);
 719         if (r == NULL) {
 720                 return false;
 721         }
 722
 723         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 724                 talloc_free(r);
 725                 return false;
 726         }
 727
 728         pull = ndr_pull_init_blob(&blob, r, NULL);
 729         if (pull == NULL) {
 730                 talloc_free(r);
 731                 return false;
 732         }
 733
 734         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 735         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 736         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 737                 talloc_free(r);
 738                 return false;
 739         }
 740
 741         if (DEBUGLEVEL >= 10) {
 742                 NDR_PRINT_IN_DEBUG(echo_TestDoublePointer, r);
 743         }
 744
 745         r->out.result = _echo_TestDoublePointer(p, r);
 746
 747         if (p->rng_fault_state) {
 748                 talloc_free(r);
 749                 /* Return true here, srv_pipe_hnd.c will take care */
 750                 return true;
 751         }
 752
 753         if (DEBUGLEVEL >= 10) {
 754                 NDR_PRINT_OUT_DEBUG(echo_TestDoublePointer, r);
 755         }
 756
 757         push = ndr_push_init_ctx(r, NULL);
 758         if (push == NULL) {
 759                 talloc_free(r);
 760                 return false;
 761         }
 762
 763         ndr_err = call->ndr_push(push, NDR_OUT, r);
 764         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 765                 talloc_free(r);
 766                 return false;
 767         }
 768
 769         blob = ndr_push_blob(push);
 770         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 771                 talloc_free(r);
 772                 return false;
 773         }
 774
 775         talloc_free(r);
 776
 777         return true;
 778 }
 779
 780
 781 /* Tables */
 782 static struct api_struct api_rpcecho_cmds[] =
 783 {
 784         {"ECHO_ADDONE", NDR_ECHO_ADDONE, api_echo_AddOne},
 785         {"ECHO_ECHODATA", NDR_ECHO_ECHODATA, api_echo_EchoData},
 786         {"ECHO_SINKDATA", NDR_ECHO_SINKDATA, api_echo_SinkData},
 787         {"ECHO_SOURCEDATA", NDR_ECHO_SOURCEDATA, api_echo_SourceData},
 788         {"ECHO_TESTCALL", NDR_ECHO_TESTCALL, api_echo_TestCall},
 789         {"ECHO_TESTCALL2", NDR_ECHO_TESTCALL2, api_echo_TestCall2},
 790         {"ECHO_TESTSLEEP", NDR_ECHO_TESTSLEEP, api_echo_TestSleep},
 791         {"ECHO_TESTENUM", NDR_ECHO_TESTENUM, api_echo_TestEnum},
 792         {"ECHO_TESTSURROUNDING", NDR_ECHO_TESTSURROUNDING, api_echo_TestSurrounding},
 793         {"ECHO_TESTDOUBLEPOINTER", NDR_ECHO_TESTDOUBLEPOINTER, api_echo_TestDoublePointer},
 794 };
 795
 796 void rpcecho_get_pipe_fns(struct api_struct **fns, int *n_fns)
 797 {
 798         *fns = api_rpcecho_cmds;
 799         *n_fns = sizeof(api_rpcecho_cmds) / sizeof(struct api_struct);
 800 }
 801
 802 NTSTATUS rpc_rpcecho_init(void)
 803 {
 804         return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "rpcecho", "rpcecho", &ndr_table_rpcecho.syntax_id, api_rpcecho_cmds, sizeof(api_rpcecho_cmds) / sizeof(struct api_struct));
 805 }