bin.gen_ndr/default/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 "ntdomain.h"
   8 #include "bin/default/librpc/gen_ndr/srv_echo.h"
   9
  10 static bool api_echo_AddOne(struct pipes_struct *p)
  11 {
  12         const struct ndr_interface_call *call;
  13         struct ndr_pull *pull;
  14         struct ndr_push *push;
  15         enum ndr_err_code ndr_err;
  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         pull = ndr_pull_init_blob(&p->in_data.data, r);
  26         if (pull == NULL) {
  27                 talloc_free(r);
  28                 return false;
  29         }
  30
  31         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
  32         if (p->endian) {
  33                 pull->flags |= LIBNDR_FLAG_BIGENDIAN;
  34         }
  35         ndr_err = call->ndr_pull(pull, NDR_IN, r);
  36         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  37                 talloc_free(r);
  38                 return false;
  39         }
  40
  41         if (DEBUGLEVEL >= 10) {
  42                 NDR_PRINT_FUNCTION_DEBUG(echo_AddOne, NDR_IN, r);
  43         }
  44
  45         ZERO_STRUCT(r->out);
  46         r->out.out_data = talloc_zero(r, uint32_t);
  47         if (r->out.out_data == NULL) {
  48                 talloc_free(r);
  49                 return false;
  50         }
  51
  52         _echo_AddOne(p, r);
  53
  54         if (p->fault_state) {
  55                 talloc_free(r);
  56                 /* Return true here, srv_pipe_hnd.c will take care */
  57                 return true;
  58         }
  59
  60         if (DEBUGLEVEL >= 10) {
  61                 NDR_PRINT_FUNCTION_DEBUG(echo_AddOne, NDR_OUT | NDR_SET_VALUES, r);
  62         }
  63
  64         push = ndr_push_init_ctx(r);
  65         if (push == NULL) {
  66                 talloc_free(r);
  67                 return false;
  68         }
  69
  70         /*
  71          * carry over the pointer count to the reply in case we are
  72          * using full pointer. See NDR specification for full pointers
  73          */
  74         push->ptr_count = pull->ptr_count;
  75
  76         ndr_err = call->ndr_push(push, NDR_OUT, r);
  77         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  78                 talloc_free(r);
  79                 return false;
  80         }
  81
  82         p->out_data.rdata = ndr_push_blob(push);
  83         talloc_steal(p->mem_ctx, p->out_data.rdata.data);
  84
  85         talloc_free(r);
  86
  87         return true;
  88 }
  89
  90 static bool api_echo_EchoData(struct pipes_struct *p)
  91 {
  92         const struct ndr_interface_call *call;
  93         struct ndr_pull *pull;
  94         struct ndr_push *push;
  95         enum ndr_err_code ndr_err;
  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         pull = ndr_pull_init_blob(&p->in_data.data, r);
 106         if (pull == NULL) {
 107                 talloc_free(r);
 108                 return false;
 109         }
 110
 111         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 112         if (p->endian) {
 113                 pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 114         }
 115         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 116         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 117                 talloc_free(r);
 118                 return false;
 119         }
 120
 121         if (DEBUGLEVEL >= 10) {
 122                 NDR_PRINT_FUNCTION_DEBUG(echo_EchoData, NDR_IN, r);
 123         }
 124
 125         ZERO_STRUCT(r->out);
 126         r->out.out_data = talloc_zero_array(r, uint8_t, r->in.len);
 127         if (r->out.out_data == NULL) {
 128                 talloc_free(r);
 129                 return false;
 130         }
 131
 132         _echo_EchoData(p, r);
 133
 134         if (p->fault_state) {
 135                 talloc_free(r);
 136                 /* Return true here, srv_pipe_hnd.c will take care */
 137                 return true;
 138         }
 139
 140         if (DEBUGLEVEL >= 10) {
 141                 NDR_PRINT_FUNCTION_DEBUG(echo_EchoData, NDR_OUT | NDR_SET_VALUES, r);
 142         }
 143
 144         push = ndr_push_init_ctx(r);
 145         if (push == NULL) {
 146                 talloc_free(r);
 147                 return false;
 148         }
 149
 150         /*
 151          * carry over the pointer count to the reply in case we are
 152          * using full pointer. See NDR specification for full pointers
 153          */
 154         push->ptr_count = pull->ptr_count;
 155
 156         ndr_err = call->ndr_push(push, NDR_OUT, r);
 157         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 158                 talloc_free(r);
 159                 return false;
 160         }
 161
 162         p->out_data.rdata = ndr_push_blob(push);
 163         talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 164
 165         talloc_free(r);
 166
 167         return true;
 168 }
 169
 170 static bool api_echo_SinkData(struct pipes_struct *p)
 171 {
 172         const struct ndr_interface_call *call;
 173         struct ndr_pull *pull;
 174         struct ndr_push *push;
 175         enum ndr_err_code ndr_err;
 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         pull = ndr_pull_init_blob(&p->in_data.data, r);
 186         if (pull == NULL) {
 187                 talloc_free(r);
 188                 return false;
 189         }
 190
 191         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 192         if (p->endian) {
 193                 pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 194         }
 195         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 196         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 197                 talloc_free(r);
 198                 return false;
 199         }
 200
 201         if (DEBUGLEVEL >= 10) {
 202                 NDR_PRINT_FUNCTION_DEBUG(echo_SinkData, NDR_IN, r);
 203         }
 204
 205         _echo_SinkData(p, r);
 206
 207         if (p->fault_state) {
 208                 talloc_free(r);
 209                 /* Return true here, srv_pipe_hnd.c will take care */
 210                 return true;
 211         }
 212
 213         if (DEBUGLEVEL >= 10) {
 214                 NDR_PRINT_FUNCTION_DEBUG(echo_SinkData, NDR_OUT | NDR_SET_VALUES, r);
 215         }
 216
 217         push = ndr_push_init_ctx(r);
 218         if (push == NULL) {
 219                 talloc_free(r);
 220                 return false;
 221         }
 222
 223         /*
 224          * carry over the pointer count to the reply in case we are
 225          * using full pointer. See NDR specification for full pointers
 226          */
 227         push->ptr_count = pull->ptr_count;
 228
 229         ndr_err = call->ndr_push(push, NDR_OUT, r);
 230         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 231                 talloc_free(r);
 232                 return false;
 233         }
 234
 235         p->out_data.rdata = ndr_push_blob(push);
 236         talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 237
 238         talloc_free(r);
 239
 240         return true;
 241 }
 242
 243 static bool api_echo_SourceData(struct pipes_struct *p)
 244 {
 245         const struct ndr_interface_call *call;
 246         struct ndr_pull *pull;
 247         struct ndr_push *push;
 248         enum ndr_err_code ndr_err;
 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         pull = ndr_pull_init_blob(&p->in_data.data, r);
 259         if (pull == NULL) {
 260                 talloc_free(r);
 261                 return false;
 262         }
 263
 264         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 265         if (p->endian) {
 266                 pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 267         }
 268         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 269         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 270                 talloc_free(r);
 271                 return false;
 272         }
 273
 274         if (DEBUGLEVEL >= 10) {
 275                 NDR_PRINT_FUNCTION_DEBUG(echo_SourceData, NDR_IN, r);
 276         }
 277
 278         ZERO_STRUCT(r->out);
 279         r->out.data = talloc_zero_array(r, uint8_t, r->in.len);
 280         if (r->out.data == NULL) {
 281                 talloc_free(r);
 282                 return false;
 283         }
 284
 285         _echo_SourceData(p, r);
 286
 287         if (p->fault_state) {
 288                 talloc_free(r);
 289                 /* Return true here, srv_pipe_hnd.c will take care */
 290                 return true;
 291         }
 292
 293         if (DEBUGLEVEL >= 10) {
 294                 NDR_PRINT_FUNCTION_DEBUG(echo_SourceData, NDR_OUT | NDR_SET_VALUES, r);
 295         }
 296
 297         push = ndr_push_init_ctx(r);
 298         if (push == NULL) {
 299                 talloc_free(r);
 300                 return false;
 301         }
 302
 303         /*
 304          * carry over the pointer count to the reply in case we are
 305          * using full pointer. See NDR specification for full pointers
 306          */
 307         push->ptr_count = pull->ptr_count;
 308
 309         ndr_err = call->ndr_push(push, NDR_OUT, r);
 310         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 311                 talloc_free(r);
 312                 return false;
 313         }
 314
 315         p->out_data.rdata = ndr_push_blob(push);
 316         talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 317
 318         talloc_free(r);
 319
 320         return true;
 321 }
 322
 323 static bool api_echo_TestCall(struct pipes_struct *p)
 324 {
 325         const struct ndr_interface_call *call;
 326         struct ndr_pull *pull;
 327         struct ndr_push *push;
 328         enum ndr_err_code ndr_err;
 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         pull = ndr_pull_init_blob(&p->in_data.data, r);
 339         if (pull == NULL) {
 340                 talloc_free(r);
 341                 return false;
 342         }
 343
 344         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 345         if (p->endian) {
 346                 pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 347         }
 348         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 349         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 350                 talloc_free(r);
 351                 return false;
 352         }
 353
 354         if (DEBUGLEVEL >= 10) {
 355                 NDR_PRINT_FUNCTION_DEBUG(echo_TestCall, NDR_IN, r);
 356         }
 357
 358         ZERO_STRUCT(r->out);
 359         r->out.s2 = talloc_zero(r, const char *);
 360         if (r->out.s2 == NULL) {
 361                 talloc_free(r);
 362                 return false;
 363         }
 364
 365         _echo_TestCall(p, r);
 366
 367         if (p->fault_state) {
 368                 talloc_free(r);
 369                 /* Return true here, srv_pipe_hnd.c will take care */
 370                 return true;
 371         }
 372
 373         if (DEBUGLEVEL >= 10) {
 374                 NDR_PRINT_FUNCTION_DEBUG(echo_TestCall, NDR_OUT | NDR_SET_VALUES, r);
 375         }
 376
 377         push = ndr_push_init_ctx(r);
 378         if (push == NULL) {
 379                 talloc_free(r);
 380                 return false;
 381         }
 382
 383         /*
 384          * carry over the pointer count to the reply in case we are
 385          * using full pointer. See NDR specification for full pointers
 386          */
 387         push->ptr_count = pull->ptr_count;
 388
 389         ndr_err = call->ndr_push(push, NDR_OUT, r);
 390         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 391                 talloc_free(r);
 392                 return false;
 393         }
 394
 395         p->out_data.rdata = ndr_push_blob(push);
 396         talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 397
 398         talloc_free(r);
 399
 400         return true;
 401 }
 402
 403 static bool api_echo_TestCall2(struct pipes_struct *p)
 404 {
 405         const struct ndr_interface_call *call;
 406         struct ndr_pull *pull;
 407         struct ndr_push *push;
 408         enum ndr_err_code ndr_err;
 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         pull = ndr_pull_init_blob(&p->in_data.data, r);
 419         if (pull == NULL) {
 420                 talloc_free(r);
 421                 return false;
 422         }
 423
 424         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 425         if (p->endian) {
 426                 pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 427         }
 428         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 429         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 430                 talloc_free(r);
 431                 return false;
 432         }
 433
 434         if (DEBUGLEVEL >= 10) {
 435                 NDR_PRINT_FUNCTION_DEBUG(echo_TestCall2, NDR_IN, r);
 436         }
 437
 438         ZERO_STRUCT(r->out);
 439         r->out.info = talloc_zero(r, union echo_Info);
 440         if (r->out.info == NULL) {
 441                 talloc_free(r);
 442                 return false;
 443         }
 444
 445         r->out.result = _echo_TestCall2(p, r);
 446
 447         if (p->fault_state) {
 448                 talloc_free(r);
 449                 /* Return true here, srv_pipe_hnd.c will take care */
 450                 return true;
 451         }
 452
 453         if (DEBUGLEVEL >= 10) {
 454                 NDR_PRINT_FUNCTION_DEBUG(echo_TestCall2, NDR_OUT | NDR_SET_VALUES, r);
 455         }
 456
 457         push = ndr_push_init_ctx(r);
 458         if (push == NULL) {
 459                 talloc_free(r);
 460                 return false;
 461         }
 462
 463         /*
 464          * carry over the pointer count to the reply in case we are
 465          * using full pointer. See NDR specification for full pointers
 466          */
 467         push->ptr_count = pull->ptr_count;
 468
 469         ndr_err = call->ndr_push(push, NDR_OUT, r);
 470         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 471                 talloc_free(r);
 472                 return false;
 473         }
 474
 475         p->out_data.rdata = ndr_push_blob(push);
 476         talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 477
 478         talloc_free(r);
 479
 480         return true;
 481 }
 482
 483 static bool api_echo_TestSleep(struct pipes_struct *p)
 484 {
 485         const struct ndr_interface_call *call;
 486         struct ndr_pull *pull;
 487         struct ndr_push *push;
 488         enum ndr_err_code ndr_err;
 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         pull = ndr_pull_init_blob(&p->in_data.data, r);
 499         if (pull == NULL) {
 500                 talloc_free(r);
 501                 return false;
 502         }
 503
 504         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 505         if (p->endian) {
 506                 pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 507         }
 508         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 509         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 510                 talloc_free(r);
 511                 return false;
 512         }
 513
 514         if (DEBUGLEVEL >= 10) {
 515                 NDR_PRINT_FUNCTION_DEBUG(echo_TestSleep, NDR_IN, r);
 516         }
 517
 518         r->out.result = _echo_TestSleep(p, r);
 519
 520         if (p->fault_state) {
 521                 talloc_free(r);
 522                 /* Return true here, srv_pipe_hnd.c will take care */
 523                 return true;
 524         }
 525
 526         if (DEBUGLEVEL >= 10) {
 527                 NDR_PRINT_FUNCTION_DEBUG(echo_TestSleep, NDR_OUT | NDR_SET_VALUES, r);
 528         }
 529
 530         push = ndr_push_init_ctx(r);
 531         if (push == NULL) {
 532                 talloc_free(r);
 533                 return false;
 534         }
 535
 536         /*
 537          * carry over the pointer count to the reply in case we are
 538          * using full pointer. See NDR specification for full pointers
 539          */
 540         push->ptr_count = pull->ptr_count;
 541
 542         ndr_err = call->ndr_push(push, NDR_OUT, r);
 543         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 544                 talloc_free(r);
 545                 return false;
 546         }
 547
 548         p->out_data.rdata = ndr_push_blob(push);
 549         talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 550
 551         talloc_free(r);
 552
 553         return true;
 554 }
 555
 556 static bool api_echo_TestEnum(struct pipes_struct *p)
 557 {
 558         const struct ndr_interface_call *call;
 559         struct ndr_pull *pull;
 560         struct ndr_push *push;
 561         enum ndr_err_code ndr_err;
 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         pull = ndr_pull_init_blob(&p->in_data.data, r);
 572         if (pull == NULL) {
 573                 talloc_free(r);
 574                 return false;
 575         }
 576
 577         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 578         if (p->endian) {
 579                 pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 580         }
 581         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 582         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 583                 talloc_free(r);
 584                 return false;
 585         }
 586
 587         if (DEBUGLEVEL >= 10) {
 588                 NDR_PRINT_FUNCTION_DEBUG(echo_TestEnum, NDR_IN, r);
 589         }
 590
 591         ZERO_STRUCT(r->out);
 592         r->out.foo1 = r->in.foo1;
 593         r->out.foo2 = r->in.foo2;
 594         r->out.foo3 = r->in.foo3;
 595         _echo_TestEnum(p, r);
 596
 597         if (p->fault_state) {
 598                 talloc_free(r);
 599                 /* Return true here, srv_pipe_hnd.c will take care */
 600                 return true;
 601         }
 602
 603         if (DEBUGLEVEL >= 10) {
 604                 NDR_PRINT_FUNCTION_DEBUG(echo_TestEnum, NDR_OUT | NDR_SET_VALUES, r);
 605         }
 606
 607         push = ndr_push_init_ctx(r);
 608         if (push == NULL) {
 609                 talloc_free(r);
 610                 return false;
 611         }
 612
 613         /*
 614          * carry over the pointer count to the reply in case we are
 615          * using full pointer. See NDR specification for full pointers
 616          */
 617         push->ptr_count = pull->ptr_count;
 618
 619         ndr_err = call->ndr_push(push, NDR_OUT, r);
 620         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 621                 talloc_free(r);
 622                 return false;
 623         }
 624
 625         p->out_data.rdata = ndr_push_blob(push);
 626         talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 627
 628         talloc_free(r);
 629
 630         return true;
 631 }
 632
 633 static bool api_echo_TestSurrounding(struct pipes_struct *p)
 634 {
 635         const struct ndr_interface_call *call;
 636         struct ndr_pull *pull;
 637         struct ndr_push *push;
 638         enum ndr_err_code ndr_err;
 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         pull = ndr_pull_init_blob(&p->in_data.data, r);
 649         if (pull == NULL) {
 650                 talloc_free(r);
 651                 return false;
 652         }
 653
 654         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 655         if (p->endian) {
 656                 pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 657         }
 658         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 659         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 660                 talloc_free(r);
 661                 return false;
 662         }
 663
 664         if (DEBUGLEVEL >= 10) {
 665                 NDR_PRINT_FUNCTION_DEBUG(echo_TestSurrounding, NDR_IN, r);
 666         }
 667
 668         ZERO_STRUCT(r->out);
 669         r->out.data = r->in.data;
 670         _echo_TestSurrounding(p, r);
 671
 672         if (p->fault_state) {
 673                 talloc_free(r);
 674                 /* Return true here, srv_pipe_hnd.c will take care */
 675                 return true;
 676         }
 677
 678         if (DEBUGLEVEL >= 10) {
 679                 NDR_PRINT_FUNCTION_DEBUG(echo_TestSurrounding, NDR_OUT | NDR_SET_VALUES, r);
 680         }
 681
 682         push = ndr_push_init_ctx(r);
 683         if (push == NULL) {
 684                 talloc_free(r);
 685                 return false;
 686         }
 687
 688         /*
 689          * carry over the pointer count to the reply in case we are
 690          * using full pointer. See NDR specification for full pointers
 691          */
 692         push->ptr_count = pull->ptr_count;
 693
 694         ndr_err = call->ndr_push(push, NDR_OUT, r);
 695         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 696                 talloc_free(r);
 697                 return false;
 698         }
 699
 700         p->out_data.rdata = ndr_push_blob(push);
 701         talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 702
 703         talloc_free(r);
 704
 705         return true;
 706 }
 707
 708 static bool api_echo_TestDoublePointer(struct pipes_struct *p)
 709 {
 710         const struct ndr_interface_call *call;
 711         struct ndr_pull *pull;
 712         struct ndr_push *push;
 713         enum ndr_err_code ndr_err;
 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         pull = ndr_pull_init_blob(&p->in_data.data, r);
 724         if (pull == NULL) {
 725                 talloc_free(r);
 726                 return false;
 727         }
 728
 729         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 730         if (p->endian) {
 731                 pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 732         }
 733         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 734         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 735                 talloc_free(r);
 736                 return false;
 737         }
 738
 739         if (DEBUGLEVEL >= 10) {
 740                 NDR_PRINT_FUNCTION_DEBUG(echo_TestDoublePointer, NDR_IN, r);
 741         }
 742
 743         r->out.result = _echo_TestDoublePointer(p, r);
 744
 745         if (p->fault_state) {
 746                 talloc_free(r);
 747                 /* Return true here, srv_pipe_hnd.c will take care */
 748                 return true;
 749         }
 750
 751         if (DEBUGLEVEL >= 10) {
 752                 NDR_PRINT_FUNCTION_DEBUG(echo_TestDoublePointer, NDR_OUT | NDR_SET_VALUES, r);
 753         }
 754
 755         push = ndr_push_init_ctx(r);
 756         if (push == NULL) {
 757                 talloc_free(r);
 758                 return false;
 759         }
 760
 761         /*
 762          * carry over the pointer count to the reply in case we are
 763          * using full pointer. See NDR specification for full pointers
 764          */
 765         push->ptr_count = pull->ptr_count;
 766
 767         ndr_err = call->ndr_push(push, NDR_OUT, r);
 768         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 769                 talloc_free(r);
 770                 return false;
 771         }
 772
 773         p->out_data.rdata = ndr_push_blob(push);
 774         talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 775
 776         talloc_free(r);
 777
 778         return true;
 779 }
 780
 781 static bool api_echo_TestBytePipeIn(struct pipes_struct *p)
 782 {
 783         const struct ndr_interface_call *call;
 784         struct ndr_pull *pull;
 785         struct ndr_push *push;
 786         enum ndr_err_code ndr_err;
 787         struct echo_TestBytePipeIn *r;
 788
 789         call = &ndr_table_rpcecho.calls[NDR_ECHO_TESTBYTEPIPEIN];
 790
 791         r = talloc(talloc_tos(), struct echo_TestBytePipeIn);
 792         if (r == NULL) {
 793                 return false;
 794         }
 795
 796         pull = ndr_pull_init_blob(&p->in_data.data, r);
 797         if (pull == NULL) {
 798                 talloc_free(r);
 799                 return false;
 800         }
 801
 802         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 803         if (p->endian) {
 804                 pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 805         }
 806         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 807         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 808                 talloc_free(r);
 809                 return false;
 810         }
 811
 812         if (DEBUGLEVEL >= 10) {
 813                 NDR_PRINT_FUNCTION_DEBUG(echo_TestBytePipeIn, NDR_IN, r);
 814         }
 815
 816         r->out.result = _echo_TestBytePipeIn(p, r);
 817
 818         if (p->fault_state) {
 819                 talloc_free(r);
 820                 /* Return true here, srv_pipe_hnd.c will take care */
 821                 return true;
 822         }
 823
 824         if (DEBUGLEVEL >= 10) {
 825                 NDR_PRINT_FUNCTION_DEBUG(echo_TestBytePipeIn, NDR_OUT | NDR_SET_VALUES, r);
 826         }
 827
 828         push = ndr_push_init_ctx(r);
 829         if (push == NULL) {
 830                 talloc_free(r);
 831                 return false;
 832         }
 833
 834         /*
 835          * carry over the pointer count to the reply in case we are
 836          * using full pointer. See NDR specification for full pointers
 837          */
 838         push->ptr_count = pull->ptr_count;
 839
 840         ndr_err = call->ndr_push(push, NDR_OUT, r);
 841         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 842                 talloc_free(r);
 843                 return false;
 844         }
 845
 846         p->out_data.rdata = ndr_push_blob(push);
 847         talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 848
 849         talloc_free(r);
 850
 851         return true;
 852 }
 853
 854 static bool api_echo_TestBytePipeOut(struct pipes_struct *p)
 855 {
 856         const struct ndr_interface_call *call;
 857         struct ndr_pull *pull;
 858         struct ndr_push *push;
 859         enum ndr_err_code ndr_err;
 860         struct echo_TestBytePipeOut *r;
 861
 862         call = &ndr_table_rpcecho.calls[NDR_ECHO_TESTBYTEPIPEOUT];
 863
 864         r = talloc(talloc_tos(), struct echo_TestBytePipeOut);
 865         if (r == NULL) {
 866                 return false;
 867         }
 868
 869         pull = ndr_pull_init_blob(&p->in_data.data, r);
 870         if (pull == NULL) {
 871                 talloc_free(r);
 872                 return false;
 873         }
 874
 875         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 876         if (p->endian) {
 877                 pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 878         }
 879         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 880         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 881                 talloc_free(r);
 882                 return false;
 883         }
 884
 885         if (DEBUGLEVEL >= 10) {
 886                 NDR_PRINT_FUNCTION_DEBUG(echo_TestBytePipeOut, NDR_IN, r);
 887         }
 888
 889         ZERO_STRUCT(r->out);
 890         r->out.result = _echo_TestBytePipeOut(p, r);
 891
 892         if (p->fault_state) {
 893                 talloc_free(r);
 894                 /* Return true here, srv_pipe_hnd.c will take care */
 895                 return true;
 896         }
 897
 898         if (DEBUGLEVEL >= 10) {
 899                 NDR_PRINT_FUNCTION_DEBUG(echo_TestBytePipeOut, NDR_OUT | NDR_SET_VALUES, r);
 900         }
 901
 902         push = ndr_push_init_ctx(r);
 903         if (push == NULL) {
 904                 talloc_free(r);
 905                 return false;
 906         }
 907
 908         /*
 909          * carry over the pointer count to the reply in case we are
 910          * using full pointer. See NDR specification for full pointers
 911          */
 912         push->ptr_count = pull->ptr_count;
 913
 914         ndr_err = call->ndr_push(push, NDR_OUT, r);
 915         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 916                 talloc_free(r);
 917                 return false;
 918         }
 919
 920         p->out_data.rdata = ndr_push_blob(push);
 921         talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 922
 923         talloc_free(r);
 924
 925         return true;
 926 }
 927
 928 static bool api_echo_TestBytePipeInOut(struct pipes_struct *p)
 929 {
 930         const struct ndr_interface_call *call;
 931         struct ndr_pull *pull;
 932         struct ndr_push *push;
 933         enum ndr_err_code ndr_err;
 934         struct echo_TestBytePipeInOut *r;
 935
 936         call = &ndr_table_rpcecho.calls[NDR_ECHO_TESTBYTEPIPEINOUT];
 937
 938         r = talloc(talloc_tos(), struct echo_TestBytePipeInOut);
 939         if (r == NULL) {
 940                 return false;
 941         }
 942
 943         pull = ndr_pull_init_blob(&p->in_data.data, r);
 944         if (pull == NULL) {
 945                 talloc_free(r);
 946                 return false;
 947         }
 948
 949         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 950         if (p->endian) {
 951                 pull->flags |= LIBNDR_FLAG_BIGENDIAN;
 952         }
 953         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 954         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 955                 talloc_free(r);
 956                 return false;
 957         }
 958
 959         if (DEBUGLEVEL >= 10) {
 960                 NDR_PRINT_FUNCTION_DEBUG(echo_TestBytePipeInOut, NDR_IN, r);
 961         }
 962
 963         ZERO_STRUCT(r->out);
 964         r->out.out_pipe = r->in.out_pipe;
 965         r->out.result = _echo_TestBytePipeInOut(p, r);
 966
 967         if (p->fault_state) {
 968                 talloc_free(r);
 969                 /* Return true here, srv_pipe_hnd.c will take care */
 970                 return true;
 971         }
 972
 973         if (DEBUGLEVEL >= 10) {
 974                 NDR_PRINT_FUNCTION_DEBUG(echo_TestBytePipeInOut, NDR_OUT | NDR_SET_VALUES, r);
 975         }
 976
 977         push = ndr_push_init_ctx(r);
 978         if (push == NULL) {
 979                 talloc_free(r);
 980                 return false;
 981         }
 982
 983         /*
 984          * carry over the pointer count to the reply in case we are
 985          * using full pointer. See NDR specification for full pointers
 986          */
 987         push->ptr_count = pull->ptr_count;
 988
 989         ndr_err = call->ndr_push(push, NDR_OUT, r);
 990         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 991                 talloc_free(r);
 992                 return false;
 993         }
 994
 995         p->out_data.rdata = ndr_push_blob(push);
 996         talloc_steal(p->mem_ctx, p->out_data.rdata.data);
 997
 998         talloc_free(r);
 999
1000         return true;
1001 }
1002
1003
1004 /* Tables */
1005 static struct api_struct api_rpcecho_cmds[] =
1006 {
1007         {"ECHO_ADDONE", NDR_ECHO_ADDONE, api_echo_AddOne},
1008         {"ECHO_ECHODATA", NDR_ECHO_ECHODATA, api_echo_EchoData},
1009         {"ECHO_SINKDATA", NDR_ECHO_SINKDATA, api_echo_SinkData},
1010         {"ECHO_SOURCEDATA", NDR_ECHO_SOURCEDATA, api_echo_SourceData},
1011         {"ECHO_TESTCALL", NDR_ECHO_TESTCALL, api_echo_TestCall},
1012         {"ECHO_TESTCALL2", NDR_ECHO_TESTCALL2, api_echo_TestCall2},
1013         {"ECHO_TESTSLEEP", NDR_ECHO_TESTSLEEP, api_echo_TestSleep},
1014         {"ECHO_TESTENUM", NDR_ECHO_TESTENUM, api_echo_TestEnum},
1015         {"ECHO_TESTSURROUNDING", NDR_ECHO_TESTSURROUNDING, api_echo_TestSurrounding},
1016         {"ECHO_TESTDOUBLEPOINTER", NDR_ECHO_TESTDOUBLEPOINTER, api_echo_TestDoublePointer},
1017         {"ECHO_TESTBYTEPIPEIN", NDR_ECHO_TESTBYTEPIPEIN, api_echo_TestBytePipeIn},
1018         {"ECHO_TESTBYTEPIPEOUT", NDR_ECHO_TESTBYTEPIPEOUT, api_echo_TestBytePipeOut},
1019         {"ECHO_TESTBYTEPIPEINOUT", NDR_ECHO_TESTBYTEPIPEINOUT, api_echo_TestBytePipeInOut},
1020 };
1021
1022 void rpcecho_get_pipe_fns(struct api_struct **fns, int *n_fns)
1023 {
1024         *fns = api_rpcecho_cmds;
1025         *n_fns = sizeof(api_rpcecho_cmds) / sizeof(struct api_struct);
1026 }
1027
1028 NTSTATUS rpc_rpcecho_init(const struct rpc_srv_callbacks *rpc_srv_cb)
1029 {
1030         return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "rpcecho", "rpcecho", &ndr_table_rpcecho, api_rpcecho_cmds, sizeof(api_rpcecho_cmds) / sizeof(struct api_struct), rpc_srv_cb);
1031 }
1032
1033 NTSTATUS rpc_rpcecho_shutdown(void)
1034 {
1035         return rpc_srv_unregister(&ndr_table_rpcecho);
1036 }