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