source3/librpc/gen_ndr/srv_srvsvc.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_srvsvc.h"
   8
   9 static bool api_srvsvc_NetCharDevEnum(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 srvsvc_NetCharDevEnum *r;
  17
  18         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVENUM];
  19
  20         r = talloc(talloc_tos(), struct srvsvc_NetCharDevEnum);
  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(srvsvc_NetCharDevEnum, r);
  45         }
  46
  47         ZERO_STRUCT(r->out);
  48         r->out.level = r->in.level;
  49         r->out.ctr = r->in.ctr;
  50         r->out.totalentries = talloc_zero(r, uint32_t);
  51         if (r->out.totalentries == NULL) {
  52                 talloc_free(r);
  53                 return false;
  54         }
  55
  56         r->out.resume_handle = r->in.resume_handle;
  57         r->out.result = _srvsvc_NetCharDevEnum(p, r);
  58
  59         if (p->rng_fault_state) {
  60                 talloc_free(r);
  61                 /* Return true here, srv_pipe_hnd.c will take care */
  62                 return true;
  63         }
  64
  65         if (DEBUGLEVEL >= 10) {
  66                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevEnum, r);
  67         }
  68
  69         push = ndr_push_init_ctx(r, NULL);
  70         if (push == NULL) {
  71                 talloc_free(r);
  72                 return false;
  73         }
  74
  75         ndr_err = call->ndr_push(push, NDR_OUT, r);
  76         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
  77                 talloc_free(r);
  78                 return false;
  79         }
  80
  81         blob = ndr_push_blob(push);
  82         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
  83                 talloc_free(r);
  84                 return false;
  85         }
  86
  87         talloc_free(r);
  88
  89         return true;
  90 }
  91
  92 static bool api_srvsvc_NetCharDevGetInfo(pipes_struct *p)
  93 {
  94         const struct ndr_interface_call *call;
  95         struct ndr_pull *pull;
  96         struct ndr_push *push;
  97         enum ndr_err_code ndr_err;
  98         DATA_BLOB blob;
  99         struct srvsvc_NetCharDevGetInfo *r;
 100
 101         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVGETINFO];
 102
 103         r = talloc(talloc_tos(), struct srvsvc_NetCharDevGetInfo);
 104         if (r == NULL) {
 105                 return false;
 106         }
 107
 108         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 109                 talloc_free(r);
 110                 return false;
 111         }
 112
 113         pull = ndr_pull_init_blob(&blob, r, NULL);
 114         if (pull == NULL) {
 115                 talloc_free(r);
 116                 return false;
 117         }
 118
 119         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 120         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 121         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 122                 talloc_free(r);
 123                 return false;
 124         }
 125
 126         if (DEBUGLEVEL >= 10) {
 127                 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevGetInfo, r);
 128         }
 129
 130         ZERO_STRUCT(r->out);
 131         r->out.info = talloc_zero(r, union srvsvc_NetCharDevInfo);
 132         if (r->out.info == NULL) {
 133                 talloc_free(r);
 134                 return false;
 135         }
 136
 137         r->out.result = _srvsvc_NetCharDevGetInfo(p, r);
 138
 139         if (p->rng_fault_state) {
 140                 talloc_free(r);
 141                 /* Return true here, srv_pipe_hnd.c will take care */
 142                 return true;
 143         }
 144
 145         if (DEBUGLEVEL >= 10) {
 146                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevGetInfo, r);
 147         }
 148
 149         push = ndr_push_init_ctx(r, NULL);
 150         if (push == NULL) {
 151                 talloc_free(r);
 152                 return false;
 153         }
 154
 155         ndr_err = call->ndr_push(push, NDR_OUT, r);
 156         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 157                 talloc_free(r);
 158                 return false;
 159         }
 160
 161         blob = ndr_push_blob(push);
 162         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 163                 talloc_free(r);
 164                 return false;
 165         }
 166
 167         talloc_free(r);
 168
 169         return true;
 170 }
 171
 172 static bool api_srvsvc_NetCharDevControl(pipes_struct *p)
 173 {
 174         const struct ndr_interface_call *call;
 175         struct ndr_pull *pull;
 176         struct ndr_push *push;
 177         enum ndr_err_code ndr_err;
 178         DATA_BLOB blob;
 179         struct srvsvc_NetCharDevControl *r;
 180
 181         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVCONTROL];
 182
 183         r = talloc(talloc_tos(), struct srvsvc_NetCharDevControl);
 184         if (r == NULL) {
 185                 return false;
 186         }
 187
 188         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 189                 talloc_free(r);
 190                 return false;
 191         }
 192
 193         pull = ndr_pull_init_blob(&blob, r, NULL);
 194         if (pull == NULL) {
 195                 talloc_free(r);
 196                 return false;
 197         }
 198
 199         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 200         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 201         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 202                 talloc_free(r);
 203                 return false;
 204         }
 205
 206         if (DEBUGLEVEL >= 10) {
 207                 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevControl, r);
 208         }
 209
 210         r->out.result = _srvsvc_NetCharDevControl(p, r);
 211
 212         if (p->rng_fault_state) {
 213                 talloc_free(r);
 214                 /* Return true here, srv_pipe_hnd.c will take care */
 215                 return true;
 216         }
 217
 218         if (DEBUGLEVEL >= 10) {
 219                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevControl, r);
 220         }
 221
 222         push = ndr_push_init_ctx(r, NULL);
 223         if (push == NULL) {
 224                 talloc_free(r);
 225                 return false;
 226         }
 227
 228         ndr_err = call->ndr_push(push, NDR_OUT, r);
 229         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 230                 talloc_free(r);
 231                 return false;
 232         }
 233
 234         blob = ndr_push_blob(push);
 235         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 236                 talloc_free(r);
 237                 return false;
 238         }
 239
 240         talloc_free(r);
 241
 242         return true;
 243 }
 244
 245 static bool api_srvsvc_NetCharDevQEnum(pipes_struct *p)
 246 {
 247         const struct ndr_interface_call *call;
 248         struct ndr_pull *pull;
 249         struct ndr_push *push;
 250         enum ndr_err_code ndr_err;
 251         DATA_BLOB blob;
 252         struct srvsvc_NetCharDevQEnum *r;
 253
 254         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVQENUM];
 255
 256         r = talloc(talloc_tos(), struct srvsvc_NetCharDevQEnum);
 257         if (r == NULL) {
 258                 return false;
 259         }
 260
 261         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 262                 talloc_free(r);
 263                 return false;
 264         }
 265
 266         pull = ndr_pull_init_blob(&blob, r, NULL);
 267         if (pull == NULL) {
 268                 talloc_free(r);
 269                 return false;
 270         }
 271
 272         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 273         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 274         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 275                 talloc_free(r);
 276                 return false;
 277         }
 278
 279         if (DEBUGLEVEL >= 10) {
 280                 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQEnum, r);
 281         }
 282
 283         ZERO_STRUCT(r->out);
 284         r->out.level = r->in.level;
 285         r->out.ctr = r->in.ctr;
 286         r->out.totalentries = talloc_zero(r, uint32_t);
 287         if (r->out.totalentries == NULL) {
 288                 talloc_free(r);
 289                 return false;
 290         }
 291
 292         r->out.resume_handle = r->in.resume_handle;
 293         r->out.result = _srvsvc_NetCharDevQEnum(p, r);
 294
 295         if (p->rng_fault_state) {
 296                 talloc_free(r);
 297                 /* Return true here, srv_pipe_hnd.c will take care */
 298                 return true;
 299         }
 300
 301         if (DEBUGLEVEL >= 10) {
 302                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQEnum, r);
 303         }
 304
 305         push = ndr_push_init_ctx(r, NULL);
 306         if (push == NULL) {
 307                 talloc_free(r);
 308                 return false;
 309         }
 310
 311         ndr_err = call->ndr_push(push, NDR_OUT, r);
 312         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 313                 talloc_free(r);
 314                 return false;
 315         }
 316
 317         blob = ndr_push_blob(push);
 318         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 319                 talloc_free(r);
 320                 return false;
 321         }
 322
 323         talloc_free(r);
 324
 325         return true;
 326 }
 327
 328 static bool api_srvsvc_NetCharDevQGetInfo(pipes_struct *p)
 329 {
 330         const struct ndr_interface_call *call;
 331         struct ndr_pull *pull;
 332         struct ndr_push *push;
 333         enum ndr_err_code ndr_err;
 334         DATA_BLOB blob;
 335         struct srvsvc_NetCharDevQGetInfo *r;
 336
 337         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVQGETINFO];
 338
 339         r = talloc(talloc_tos(), struct srvsvc_NetCharDevQGetInfo);
 340         if (r == NULL) {
 341                 return false;
 342         }
 343
 344         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 345                 talloc_free(r);
 346                 return false;
 347         }
 348
 349         pull = ndr_pull_init_blob(&blob, r, NULL);
 350         if (pull == NULL) {
 351                 talloc_free(r);
 352                 return false;
 353         }
 354
 355         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 356         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 357         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 358                 talloc_free(r);
 359                 return false;
 360         }
 361
 362         if (DEBUGLEVEL >= 10) {
 363                 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQGetInfo, r);
 364         }
 365
 366         ZERO_STRUCT(r->out);
 367         r->out.info = talloc_zero(r, union srvsvc_NetCharDevQInfo);
 368         if (r->out.info == NULL) {
 369                 talloc_free(r);
 370                 return false;
 371         }
 372
 373         r->out.result = _srvsvc_NetCharDevQGetInfo(p, r);
 374
 375         if (p->rng_fault_state) {
 376                 talloc_free(r);
 377                 /* Return true here, srv_pipe_hnd.c will take care */
 378                 return true;
 379         }
 380
 381         if (DEBUGLEVEL >= 10) {
 382                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQGetInfo, r);
 383         }
 384
 385         push = ndr_push_init_ctx(r, NULL);
 386         if (push == NULL) {
 387                 talloc_free(r);
 388                 return false;
 389         }
 390
 391         ndr_err = call->ndr_push(push, NDR_OUT, r);
 392         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 393                 talloc_free(r);
 394                 return false;
 395         }
 396
 397         blob = ndr_push_blob(push);
 398         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 399                 talloc_free(r);
 400                 return false;
 401         }
 402
 403         talloc_free(r);
 404
 405         return true;
 406 }
 407
 408 static bool api_srvsvc_NetCharDevQSetInfo(pipes_struct *p)
 409 {
 410         const struct ndr_interface_call *call;
 411         struct ndr_pull *pull;
 412         struct ndr_push *push;
 413         enum ndr_err_code ndr_err;
 414         DATA_BLOB blob;
 415         struct srvsvc_NetCharDevQSetInfo *r;
 416
 417         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVQSETINFO];
 418
 419         r = talloc(talloc_tos(), struct srvsvc_NetCharDevQSetInfo);
 420         if (r == NULL) {
 421                 return false;
 422         }
 423
 424         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 425                 talloc_free(r);
 426                 return false;
 427         }
 428
 429         pull = ndr_pull_init_blob(&blob, r, NULL);
 430         if (pull == NULL) {
 431                 talloc_free(r);
 432                 return false;
 433         }
 434
 435         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 436         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 437         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 438                 talloc_free(r);
 439                 return false;
 440         }
 441
 442         if (DEBUGLEVEL >= 10) {
 443                 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQSetInfo, r);
 444         }
 445
 446         ZERO_STRUCT(r->out);
 447         r->out.parm_error = r->in.parm_error;
 448         r->out.result = _srvsvc_NetCharDevQSetInfo(p, r);
 449
 450         if (p->rng_fault_state) {
 451                 talloc_free(r);
 452                 /* Return true here, srv_pipe_hnd.c will take care */
 453                 return true;
 454         }
 455
 456         if (DEBUGLEVEL >= 10) {
 457                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQSetInfo, r);
 458         }
 459
 460         push = ndr_push_init_ctx(r, NULL);
 461         if (push == NULL) {
 462                 talloc_free(r);
 463                 return false;
 464         }
 465
 466         ndr_err = call->ndr_push(push, NDR_OUT, r);
 467         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 468                 talloc_free(r);
 469                 return false;
 470         }
 471
 472         blob = ndr_push_blob(push);
 473         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 474                 talloc_free(r);
 475                 return false;
 476         }
 477
 478         talloc_free(r);
 479
 480         return true;
 481 }
 482
 483 static bool api_srvsvc_NetCharDevQPurge(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         DATA_BLOB blob;
 490         struct srvsvc_NetCharDevQPurge *r;
 491
 492         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVQPURGE];
 493
 494         r = talloc(talloc_tos(), struct srvsvc_NetCharDevQPurge);
 495         if (r == NULL) {
 496                 return false;
 497         }
 498
 499         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 500                 talloc_free(r);
 501                 return false;
 502         }
 503
 504         pull = ndr_pull_init_blob(&blob, r, NULL);
 505         if (pull == NULL) {
 506                 talloc_free(r);
 507                 return false;
 508         }
 509
 510         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 511         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 512         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 513                 talloc_free(r);
 514                 return false;
 515         }
 516
 517         if (DEBUGLEVEL >= 10) {
 518                 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQPurge, r);
 519         }
 520
 521         r->out.result = _srvsvc_NetCharDevQPurge(p, r);
 522
 523         if (p->rng_fault_state) {
 524                 talloc_free(r);
 525                 /* Return true here, srv_pipe_hnd.c will take care */
 526                 return true;
 527         }
 528
 529         if (DEBUGLEVEL >= 10) {
 530                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQPurge, r);
 531         }
 532
 533         push = ndr_push_init_ctx(r, NULL);
 534         if (push == NULL) {
 535                 talloc_free(r);
 536                 return false;
 537         }
 538
 539         ndr_err = call->ndr_push(push, NDR_OUT, r);
 540         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 541                 talloc_free(r);
 542                 return false;
 543         }
 544
 545         blob = ndr_push_blob(push);
 546         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 547                 talloc_free(r);
 548                 return false;
 549         }
 550
 551         talloc_free(r);
 552
 553         return true;
 554 }
 555
 556 static bool api_srvsvc_NetCharDevQPurgeSelf(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         DATA_BLOB blob;
 563         struct srvsvc_NetCharDevQPurgeSelf *r;
 564
 565         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCHARDEVQPURGESELF];
 566
 567         r = talloc(talloc_tos(), struct srvsvc_NetCharDevQPurgeSelf);
 568         if (r == NULL) {
 569                 return false;
 570         }
 571
 572         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 573                 talloc_free(r);
 574                 return false;
 575         }
 576
 577         pull = ndr_pull_init_blob(&blob, r, NULL);
 578         if (pull == NULL) {
 579                 talloc_free(r);
 580                 return false;
 581         }
 582
 583         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 584         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 585         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 586                 talloc_free(r);
 587                 return false;
 588         }
 589
 590         if (DEBUGLEVEL >= 10) {
 591                 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQPurgeSelf, r);
 592         }
 593
 594         r->out.result = _srvsvc_NetCharDevQPurgeSelf(p, r);
 595
 596         if (p->rng_fault_state) {
 597                 talloc_free(r);
 598                 /* Return true here, srv_pipe_hnd.c will take care */
 599                 return true;
 600         }
 601
 602         if (DEBUGLEVEL >= 10) {
 603                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQPurgeSelf, r);
 604         }
 605
 606         push = ndr_push_init_ctx(r, NULL);
 607         if (push == NULL) {
 608                 talloc_free(r);
 609                 return false;
 610         }
 611
 612         ndr_err = call->ndr_push(push, NDR_OUT, r);
 613         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 614                 talloc_free(r);
 615                 return false;
 616         }
 617
 618         blob = ndr_push_blob(push);
 619         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 620                 talloc_free(r);
 621                 return false;
 622         }
 623
 624         talloc_free(r);
 625
 626         return true;
 627 }
 628
 629 static bool api_srvsvc_NetConnEnum(pipes_struct *p)
 630 {
 631         const struct ndr_interface_call *call;
 632         struct ndr_pull *pull;
 633         struct ndr_push *push;
 634         enum ndr_err_code ndr_err;
 635         DATA_BLOB blob;
 636         struct srvsvc_NetConnEnum *r;
 637
 638         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETCONNENUM];
 639
 640         r = talloc(talloc_tos(), struct srvsvc_NetConnEnum);
 641         if (r == NULL) {
 642                 return false;
 643         }
 644
 645         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 646                 talloc_free(r);
 647                 return false;
 648         }
 649
 650         pull = ndr_pull_init_blob(&blob, r, NULL);
 651         if (pull == NULL) {
 652                 talloc_free(r);
 653                 return false;
 654         }
 655
 656         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 657         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 658         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 659                 talloc_free(r);
 660                 return false;
 661         }
 662
 663         if (DEBUGLEVEL >= 10) {
 664                 NDR_PRINT_IN_DEBUG(srvsvc_NetConnEnum, r);
 665         }
 666
 667         ZERO_STRUCT(r->out);
 668         r->out.info_ctr = r->in.info_ctr;
 669         r->out.totalentries = talloc_zero(r, uint32_t);
 670         if (r->out.totalentries == NULL) {
 671                 talloc_free(r);
 672                 return false;
 673         }
 674
 675         r->out.resume_handle = r->in.resume_handle;
 676         r->out.result = _srvsvc_NetConnEnum(p, r);
 677
 678         if (p->rng_fault_state) {
 679                 talloc_free(r);
 680                 /* Return true here, srv_pipe_hnd.c will take care */
 681                 return true;
 682         }
 683
 684         if (DEBUGLEVEL >= 10) {
 685                 NDR_PRINT_OUT_DEBUG(srvsvc_NetConnEnum, r);
 686         }
 687
 688         push = ndr_push_init_ctx(r, NULL);
 689         if (push == NULL) {
 690                 talloc_free(r);
 691                 return false;
 692         }
 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         blob = ndr_push_blob(push);
 701         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 702                 talloc_free(r);
 703                 return false;
 704         }
 705
 706         talloc_free(r);
 707
 708         return true;
 709 }
 710
 711 static bool api_srvsvc_NetFileEnum(pipes_struct *p)
 712 {
 713         const struct ndr_interface_call *call;
 714         struct ndr_pull *pull;
 715         struct ndr_push *push;
 716         enum ndr_err_code ndr_err;
 717         DATA_BLOB blob;
 718         struct srvsvc_NetFileEnum *r;
 719
 720         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETFILEENUM];
 721
 722         r = talloc(talloc_tos(), struct srvsvc_NetFileEnum);
 723         if (r == NULL) {
 724                 return false;
 725         }
 726
 727         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 728                 talloc_free(r);
 729                 return false;
 730         }
 731
 732         pull = ndr_pull_init_blob(&blob, r, NULL);
 733         if (pull == NULL) {
 734                 talloc_free(r);
 735                 return false;
 736         }
 737
 738         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 739         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 740         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 741                 talloc_free(r);
 742                 return false;
 743         }
 744
 745         if (DEBUGLEVEL >= 10) {
 746                 NDR_PRINT_IN_DEBUG(srvsvc_NetFileEnum, r);
 747         }
 748
 749         ZERO_STRUCT(r->out);
 750         r->out.info_ctr = r->in.info_ctr;
 751         r->out.totalentries = talloc_zero(r, uint32_t);
 752         if (r->out.totalentries == NULL) {
 753                 talloc_free(r);
 754                 return false;
 755         }
 756
 757         r->out.resume_handle = r->in.resume_handle;
 758         r->out.result = _srvsvc_NetFileEnum(p, r);
 759
 760         if (p->rng_fault_state) {
 761                 talloc_free(r);
 762                 /* Return true here, srv_pipe_hnd.c will take care */
 763                 return true;
 764         }
 765
 766         if (DEBUGLEVEL >= 10) {
 767                 NDR_PRINT_OUT_DEBUG(srvsvc_NetFileEnum, r);
 768         }
 769
 770         push = ndr_push_init_ctx(r, NULL);
 771         if (push == NULL) {
 772                 talloc_free(r);
 773                 return false;
 774         }
 775
 776         ndr_err = call->ndr_push(push, NDR_OUT, r);
 777         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 778                 talloc_free(r);
 779                 return false;
 780         }
 781
 782         blob = ndr_push_blob(push);
 783         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 784                 talloc_free(r);
 785                 return false;
 786         }
 787
 788         talloc_free(r);
 789
 790         return true;
 791 }
 792
 793 static bool api_srvsvc_NetFileGetInfo(pipes_struct *p)
 794 {
 795         const struct ndr_interface_call *call;
 796         struct ndr_pull *pull;
 797         struct ndr_push *push;
 798         enum ndr_err_code ndr_err;
 799         DATA_BLOB blob;
 800         struct srvsvc_NetFileGetInfo *r;
 801
 802         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETFILEGETINFO];
 803
 804         r = talloc(talloc_tos(), struct srvsvc_NetFileGetInfo);
 805         if (r == NULL) {
 806                 return false;
 807         }
 808
 809         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 810                 talloc_free(r);
 811                 return false;
 812         }
 813
 814         pull = ndr_pull_init_blob(&blob, r, NULL);
 815         if (pull == NULL) {
 816                 talloc_free(r);
 817                 return false;
 818         }
 819
 820         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 821         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 822         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 823                 talloc_free(r);
 824                 return false;
 825         }
 826
 827         if (DEBUGLEVEL >= 10) {
 828                 NDR_PRINT_IN_DEBUG(srvsvc_NetFileGetInfo, r);
 829         }
 830
 831         ZERO_STRUCT(r->out);
 832         r->out.info = talloc_zero(r, union srvsvc_NetFileInfo);
 833         if (r->out.info == NULL) {
 834                 talloc_free(r);
 835                 return false;
 836         }
 837
 838         r->out.result = _srvsvc_NetFileGetInfo(p, r);
 839
 840         if (p->rng_fault_state) {
 841                 talloc_free(r);
 842                 /* Return true here, srv_pipe_hnd.c will take care */
 843                 return true;
 844         }
 845
 846         if (DEBUGLEVEL >= 10) {
 847                 NDR_PRINT_OUT_DEBUG(srvsvc_NetFileGetInfo, r);
 848         }
 849
 850         push = ndr_push_init_ctx(r, NULL);
 851         if (push == NULL) {
 852                 talloc_free(r);
 853                 return false;
 854         }
 855
 856         ndr_err = call->ndr_push(push, NDR_OUT, r);
 857         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 858                 talloc_free(r);
 859                 return false;
 860         }
 861
 862         blob = ndr_push_blob(push);
 863         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 864                 talloc_free(r);
 865                 return false;
 866         }
 867
 868         talloc_free(r);
 869
 870         return true;
 871 }
 872
 873 static bool api_srvsvc_NetFileClose(pipes_struct *p)
 874 {
 875         const struct ndr_interface_call *call;
 876         struct ndr_pull *pull;
 877         struct ndr_push *push;
 878         enum ndr_err_code ndr_err;
 879         DATA_BLOB blob;
 880         struct srvsvc_NetFileClose *r;
 881
 882         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETFILECLOSE];
 883
 884         r = talloc(talloc_tos(), struct srvsvc_NetFileClose);
 885         if (r == NULL) {
 886                 return false;
 887         }
 888
 889         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 890                 talloc_free(r);
 891                 return false;
 892         }
 893
 894         pull = ndr_pull_init_blob(&blob, r, NULL);
 895         if (pull == NULL) {
 896                 talloc_free(r);
 897                 return false;
 898         }
 899
 900         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 901         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 902         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 903                 talloc_free(r);
 904                 return false;
 905         }
 906
 907         if (DEBUGLEVEL >= 10) {
 908                 NDR_PRINT_IN_DEBUG(srvsvc_NetFileClose, r);
 909         }
 910
 911         r->out.result = _srvsvc_NetFileClose(p, r);
 912
 913         if (p->rng_fault_state) {
 914                 talloc_free(r);
 915                 /* Return true here, srv_pipe_hnd.c will take care */
 916                 return true;
 917         }
 918
 919         if (DEBUGLEVEL >= 10) {
 920                 NDR_PRINT_OUT_DEBUG(srvsvc_NetFileClose, r);
 921         }
 922
 923         push = ndr_push_init_ctx(r, NULL);
 924         if (push == NULL) {
 925                 talloc_free(r);
 926                 return false;
 927         }
 928
 929         ndr_err = call->ndr_push(push, NDR_OUT, r);
 930         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 931                 talloc_free(r);
 932                 return false;
 933         }
 934
 935         blob = ndr_push_blob(push);
 936         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
 937                 talloc_free(r);
 938                 return false;
 939         }
 940
 941         talloc_free(r);
 942
 943         return true;
 944 }
 945
 946 static bool api_srvsvc_NetSessEnum(pipes_struct *p)
 947 {
 948         const struct ndr_interface_call *call;
 949         struct ndr_pull *pull;
 950         struct ndr_push *push;
 951         enum ndr_err_code ndr_err;
 952         DATA_BLOB blob;
 953         struct srvsvc_NetSessEnum *r;
 954
 955         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSESSENUM];
 956
 957         r = talloc(talloc_tos(), struct srvsvc_NetSessEnum);
 958         if (r == NULL) {
 959                 return false;
 960         }
 961
 962         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
 963                 talloc_free(r);
 964                 return false;
 965         }
 966
 967         pull = ndr_pull_init_blob(&blob, r, NULL);
 968         if (pull == NULL) {
 969                 talloc_free(r);
 970                 return false;
 971         }
 972
 973         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
 974         ndr_err = call->ndr_pull(pull, NDR_IN, r);
 975         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 976                 talloc_free(r);
 977                 return false;
 978         }
 979
 980         if (DEBUGLEVEL >= 10) {
 981                 NDR_PRINT_IN_DEBUG(srvsvc_NetSessEnum, r);
 982         }
 983
 984         ZERO_STRUCT(r->out);
 985         r->out.info_ctr = r->in.info_ctr;
 986         r->out.totalentries = talloc_zero(r, uint32_t);
 987         if (r->out.totalentries == NULL) {
 988                 talloc_free(r);
 989                 return false;
 990         }
 991
 992         r->out.resume_handle = r->in.resume_handle;
 993         r->out.result = _srvsvc_NetSessEnum(p, r);
 994
 995         if (p->rng_fault_state) {
 996                 talloc_free(r);
 997                 /* Return true here, srv_pipe_hnd.c will take care */
 998                 return true;
 999         }
1000
1001         if (DEBUGLEVEL >= 10) {
1002                 NDR_PRINT_OUT_DEBUG(srvsvc_NetSessEnum, r);
1003         }
1004
1005         push = ndr_push_init_ctx(r, NULL);
1006         if (push == NULL) {
1007                 talloc_free(r);
1008                 return false;
1009         }
1010
1011         ndr_err = call->ndr_push(push, NDR_OUT, r);
1012         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1013                 talloc_free(r);
1014                 return false;
1015         }
1016
1017         blob = ndr_push_blob(push);
1018         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1019                 talloc_free(r);
1020                 return false;
1021         }
1022
1023         talloc_free(r);
1024
1025         return true;
1026 }
1027
1028 static bool api_srvsvc_NetSessDel(pipes_struct *p)
1029 {
1030         const struct ndr_interface_call *call;
1031         struct ndr_pull *pull;
1032         struct ndr_push *push;
1033         enum ndr_err_code ndr_err;
1034         DATA_BLOB blob;
1035         struct srvsvc_NetSessDel *r;
1036
1037         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSESSDEL];
1038
1039         r = talloc(talloc_tos(), struct srvsvc_NetSessDel);
1040         if (r == NULL) {
1041                 return false;
1042         }
1043
1044         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1045                 talloc_free(r);
1046                 return false;
1047         }
1048
1049         pull = ndr_pull_init_blob(&blob, r, NULL);
1050         if (pull == NULL) {
1051                 talloc_free(r);
1052                 return false;
1053         }
1054
1055         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1056         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1057         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1058                 talloc_free(r);
1059                 return false;
1060         }
1061
1062         if (DEBUGLEVEL >= 10) {
1063                 NDR_PRINT_IN_DEBUG(srvsvc_NetSessDel, r);
1064         }
1065
1066         r->out.result = _srvsvc_NetSessDel(p, r);
1067
1068         if (p->rng_fault_state) {
1069                 talloc_free(r);
1070                 /* Return true here, srv_pipe_hnd.c will take care */
1071                 return true;
1072         }
1073
1074         if (DEBUGLEVEL >= 10) {
1075                 NDR_PRINT_OUT_DEBUG(srvsvc_NetSessDel, r);
1076         }
1077
1078         push = ndr_push_init_ctx(r, NULL);
1079         if (push == NULL) {
1080                 talloc_free(r);
1081                 return false;
1082         }
1083
1084         ndr_err = call->ndr_push(push, NDR_OUT, r);
1085         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1086                 talloc_free(r);
1087                 return false;
1088         }
1089
1090         blob = ndr_push_blob(push);
1091         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1092                 talloc_free(r);
1093                 return false;
1094         }
1095
1096         talloc_free(r);
1097
1098         return true;
1099 }
1100
1101 static bool api_srvsvc_NetShareAdd(pipes_struct *p)
1102 {
1103         const struct ndr_interface_call *call;
1104         struct ndr_pull *pull;
1105         struct ndr_push *push;
1106         enum ndr_err_code ndr_err;
1107         DATA_BLOB blob;
1108         struct srvsvc_NetShareAdd *r;
1109
1110         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREADD];
1111
1112         r = talloc(talloc_tos(), struct srvsvc_NetShareAdd);
1113         if (r == NULL) {
1114                 return false;
1115         }
1116
1117         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1118                 talloc_free(r);
1119                 return false;
1120         }
1121
1122         pull = ndr_pull_init_blob(&blob, r, NULL);
1123         if (pull == NULL) {
1124                 talloc_free(r);
1125                 return false;
1126         }
1127
1128         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1129         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1130         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1131                 talloc_free(r);
1132                 return false;
1133         }
1134
1135         if (DEBUGLEVEL >= 10) {
1136                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareAdd, r);
1137         }
1138
1139         ZERO_STRUCT(r->out);
1140         r->out.parm_error = r->in.parm_error;
1141         r->out.result = _srvsvc_NetShareAdd(p, r);
1142
1143         if (p->rng_fault_state) {
1144                 talloc_free(r);
1145                 /* Return true here, srv_pipe_hnd.c will take care */
1146                 return true;
1147         }
1148
1149         if (DEBUGLEVEL >= 10) {
1150                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareAdd, r);
1151         }
1152
1153         push = ndr_push_init_ctx(r, NULL);
1154         if (push == NULL) {
1155                 talloc_free(r);
1156                 return false;
1157         }
1158
1159         ndr_err = call->ndr_push(push, NDR_OUT, r);
1160         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1161                 talloc_free(r);
1162                 return false;
1163         }
1164
1165         blob = ndr_push_blob(push);
1166         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1167                 talloc_free(r);
1168                 return false;
1169         }
1170
1171         talloc_free(r);
1172
1173         return true;
1174 }
1175
1176 static bool api_srvsvc_NetShareEnumAll(pipes_struct *p)
1177 {
1178         const struct ndr_interface_call *call;
1179         struct ndr_pull *pull;
1180         struct ndr_push *push;
1181         enum ndr_err_code ndr_err;
1182         DATA_BLOB blob;
1183         struct srvsvc_NetShareEnumAll *r;
1184
1185         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREENUMALL];
1186
1187         r = talloc(talloc_tos(), struct srvsvc_NetShareEnumAll);
1188         if (r == NULL) {
1189                 return false;
1190         }
1191
1192         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1193                 talloc_free(r);
1194                 return false;
1195         }
1196
1197         pull = ndr_pull_init_blob(&blob, r, NULL);
1198         if (pull == NULL) {
1199                 talloc_free(r);
1200                 return false;
1201         }
1202
1203         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1204         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1205         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1206                 talloc_free(r);
1207                 return false;
1208         }
1209
1210         if (DEBUGLEVEL >= 10) {
1211                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareEnumAll, r);
1212         }
1213
1214         ZERO_STRUCT(r->out);
1215         r->out.info_ctr = r->in.info_ctr;
1216         r->out.totalentries = talloc_zero(r, uint32_t);
1217         if (r->out.totalentries == NULL) {
1218                 talloc_free(r);
1219                 return false;
1220         }
1221
1222         r->out.resume_handle = r->in.resume_handle;
1223         r->out.result = _srvsvc_NetShareEnumAll(p, r);
1224
1225         if (p->rng_fault_state) {
1226                 talloc_free(r);
1227                 /* Return true here, srv_pipe_hnd.c will take care */
1228                 return true;
1229         }
1230
1231         if (DEBUGLEVEL >= 10) {
1232                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareEnumAll, r);
1233         }
1234
1235         push = ndr_push_init_ctx(r, NULL);
1236         if (push == NULL) {
1237                 talloc_free(r);
1238                 return false;
1239         }
1240
1241         ndr_err = call->ndr_push(push, NDR_OUT, r);
1242         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1243                 talloc_free(r);
1244                 return false;
1245         }
1246
1247         blob = ndr_push_blob(push);
1248         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1249                 talloc_free(r);
1250                 return false;
1251         }
1252
1253         talloc_free(r);
1254
1255         return true;
1256 }
1257
1258 static bool api_srvsvc_NetShareGetInfo(pipes_struct *p)
1259 {
1260         const struct ndr_interface_call *call;
1261         struct ndr_pull *pull;
1262         struct ndr_push *push;
1263         enum ndr_err_code ndr_err;
1264         DATA_BLOB blob;
1265         struct srvsvc_NetShareGetInfo *r;
1266
1267         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREGETINFO];
1268
1269         r = talloc(talloc_tos(), struct srvsvc_NetShareGetInfo);
1270         if (r == NULL) {
1271                 return false;
1272         }
1273
1274         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1275                 talloc_free(r);
1276                 return false;
1277         }
1278
1279         pull = ndr_pull_init_blob(&blob, r, NULL);
1280         if (pull == NULL) {
1281                 talloc_free(r);
1282                 return false;
1283         }
1284
1285         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1286         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1287         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1288                 talloc_free(r);
1289                 return false;
1290         }
1291
1292         if (DEBUGLEVEL >= 10) {
1293                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareGetInfo, r);
1294         }
1295
1296         ZERO_STRUCT(r->out);
1297         r->out.info = talloc_zero(r, union srvsvc_NetShareInfo);
1298         if (r->out.info == NULL) {
1299                 talloc_free(r);
1300                 return false;
1301         }
1302
1303         r->out.result = _srvsvc_NetShareGetInfo(p, r);
1304
1305         if (p->rng_fault_state) {
1306                 talloc_free(r);
1307                 /* Return true here, srv_pipe_hnd.c will take care */
1308                 return true;
1309         }
1310
1311         if (DEBUGLEVEL >= 10) {
1312                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareGetInfo, r);
1313         }
1314
1315         push = ndr_push_init_ctx(r, NULL);
1316         if (push == NULL) {
1317                 talloc_free(r);
1318                 return false;
1319         }
1320
1321         ndr_err = call->ndr_push(push, NDR_OUT, r);
1322         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1323                 talloc_free(r);
1324                 return false;
1325         }
1326
1327         blob = ndr_push_blob(push);
1328         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1329                 talloc_free(r);
1330                 return false;
1331         }
1332
1333         talloc_free(r);
1334
1335         return true;
1336 }
1337
1338 static bool api_srvsvc_NetShareSetInfo(pipes_struct *p)
1339 {
1340         const struct ndr_interface_call *call;
1341         struct ndr_pull *pull;
1342         struct ndr_push *push;
1343         enum ndr_err_code ndr_err;
1344         DATA_BLOB blob;
1345         struct srvsvc_NetShareSetInfo *r;
1346
1347         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHARESETINFO];
1348
1349         r = talloc(talloc_tos(), struct srvsvc_NetShareSetInfo);
1350         if (r == NULL) {
1351                 return false;
1352         }
1353
1354         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1355                 talloc_free(r);
1356                 return false;
1357         }
1358
1359         pull = ndr_pull_init_blob(&blob, r, NULL);
1360         if (pull == NULL) {
1361                 talloc_free(r);
1362                 return false;
1363         }
1364
1365         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1366         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1367         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1368                 talloc_free(r);
1369                 return false;
1370         }
1371
1372         if (DEBUGLEVEL >= 10) {
1373                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareSetInfo, r);
1374         }
1375
1376         ZERO_STRUCT(r->out);
1377         r->out.parm_error = r->in.parm_error;
1378         r->out.result = _srvsvc_NetShareSetInfo(p, r);
1379
1380         if (p->rng_fault_state) {
1381                 talloc_free(r);
1382                 /* Return true here, srv_pipe_hnd.c will take care */
1383                 return true;
1384         }
1385
1386         if (DEBUGLEVEL >= 10) {
1387                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareSetInfo, r);
1388         }
1389
1390         push = ndr_push_init_ctx(r, NULL);
1391         if (push == NULL) {
1392                 talloc_free(r);
1393                 return false;
1394         }
1395
1396         ndr_err = call->ndr_push(push, NDR_OUT, r);
1397         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1398                 talloc_free(r);
1399                 return false;
1400         }
1401
1402         blob = ndr_push_blob(push);
1403         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1404                 talloc_free(r);
1405                 return false;
1406         }
1407
1408         talloc_free(r);
1409
1410         return true;
1411 }
1412
1413 static bool api_srvsvc_NetShareDel(pipes_struct *p)
1414 {
1415         const struct ndr_interface_call *call;
1416         struct ndr_pull *pull;
1417         struct ndr_push *push;
1418         enum ndr_err_code ndr_err;
1419         DATA_BLOB blob;
1420         struct srvsvc_NetShareDel *r;
1421
1422         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREDEL];
1423
1424         r = talloc(talloc_tos(), struct srvsvc_NetShareDel);
1425         if (r == NULL) {
1426                 return false;
1427         }
1428
1429         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1430                 talloc_free(r);
1431                 return false;
1432         }
1433
1434         pull = ndr_pull_init_blob(&blob, r, NULL);
1435         if (pull == NULL) {
1436                 talloc_free(r);
1437                 return false;
1438         }
1439
1440         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1441         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1442         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1443                 talloc_free(r);
1444                 return false;
1445         }
1446
1447         if (DEBUGLEVEL >= 10) {
1448                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareDel, r);
1449         }
1450
1451         r->out.result = _srvsvc_NetShareDel(p, r);
1452
1453         if (p->rng_fault_state) {
1454                 talloc_free(r);
1455                 /* Return true here, srv_pipe_hnd.c will take care */
1456                 return true;
1457         }
1458
1459         if (DEBUGLEVEL >= 10) {
1460                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDel, r);
1461         }
1462
1463         push = ndr_push_init_ctx(r, NULL);
1464         if (push == NULL) {
1465                 talloc_free(r);
1466                 return false;
1467         }
1468
1469         ndr_err = call->ndr_push(push, NDR_OUT, r);
1470         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1471                 talloc_free(r);
1472                 return false;
1473         }
1474
1475         blob = ndr_push_blob(push);
1476         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1477                 talloc_free(r);
1478                 return false;
1479         }
1480
1481         talloc_free(r);
1482
1483         return true;
1484 }
1485
1486 static bool api_srvsvc_NetShareDelSticky(pipes_struct *p)
1487 {
1488         const struct ndr_interface_call *call;
1489         struct ndr_pull *pull;
1490         struct ndr_push *push;
1491         enum ndr_err_code ndr_err;
1492         DATA_BLOB blob;
1493         struct srvsvc_NetShareDelSticky *r;
1494
1495         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREDELSTICKY];
1496
1497         r = talloc(talloc_tos(), struct srvsvc_NetShareDelSticky);
1498         if (r == NULL) {
1499                 return false;
1500         }
1501
1502         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1503                 talloc_free(r);
1504                 return false;
1505         }
1506
1507         pull = ndr_pull_init_blob(&blob, r, NULL);
1508         if (pull == NULL) {
1509                 talloc_free(r);
1510                 return false;
1511         }
1512
1513         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1514         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1515         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1516                 talloc_free(r);
1517                 return false;
1518         }
1519
1520         if (DEBUGLEVEL >= 10) {
1521                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareDelSticky, r);
1522         }
1523
1524         r->out.result = _srvsvc_NetShareDelSticky(p, r);
1525
1526         if (p->rng_fault_state) {
1527                 talloc_free(r);
1528                 /* Return true here, srv_pipe_hnd.c will take care */
1529                 return true;
1530         }
1531
1532         if (DEBUGLEVEL >= 10) {
1533                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDelSticky, r);
1534         }
1535
1536         push = ndr_push_init_ctx(r, NULL);
1537         if (push == NULL) {
1538                 talloc_free(r);
1539                 return false;
1540         }
1541
1542         ndr_err = call->ndr_push(push, NDR_OUT, r);
1543         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1544                 talloc_free(r);
1545                 return false;
1546         }
1547
1548         blob = ndr_push_blob(push);
1549         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1550                 talloc_free(r);
1551                 return false;
1552         }
1553
1554         talloc_free(r);
1555
1556         return true;
1557 }
1558
1559 static bool api_srvsvc_NetShareCheck(pipes_struct *p)
1560 {
1561         const struct ndr_interface_call *call;
1562         struct ndr_pull *pull;
1563         struct ndr_push *push;
1564         enum ndr_err_code ndr_err;
1565         DATA_BLOB blob;
1566         struct srvsvc_NetShareCheck *r;
1567
1568         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHARECHECK];
1569
1570         r = talloc(talloc_tos(), struct srvsvc_NetShareCheck);
1571         if (r == NULL) {
1572                 return false;
1573         }
1574
1575         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1576                 talloc_free(r);
1577                 return false;
1578         }
1579
1580         pull = ndr_pull_init_blob(&blob, r, NULL);
1581         if (pull == NULL) {
1582                 talloc_free(r);
1583                 return false;
1584         }
1585
1586         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1587         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1588         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1589                 talloc_free(r);
1590                 return false;
1591         }
1592
1593         if (DEBUGLEVEL >= 10) {
1594                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareCheck, r);
1595         }
1596
1597         ZERO_STRUCT(r->out);
1598         r->out.type = talloc_zero(r, enum srvsvc_ShareType);
1599         if (r->out.type == NULL) {
1600                 talloc_free(r);
1601                 return false;
1602         }
1603
1604         r->out.result = _srvsvc_NetShareCheck(p, r);
1605
1606         if (p->rng_fault_state) {
1607                 talloc_free(r);
1608                 /* Return true here, srv_pipe_hnd.c will take care */
1609                 return true;
1610         }
1611
1612         if (DEBUGLEVEL >= 10) {
1613                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareCheck, r);
1614         }
1615
1616         push = ndr_push_init_ctx(r, NULL);
1617         if (push == NULL) {
1618                 talloc_free(r);
1619                 return false;
1620         }
1621
1622         ndr_err = call->ndr_push(push, NDR_OUT, r);
1623         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1624                 talloc_free(r);
1625                 return false;
1626         }
1627
1628         blob = ndr_push_blob(push);
1629         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1630                 talloc_free(r);
1631                 return false;
1632         }
1633
1634         talloc_free(r);
1635
1636         return true;
1637 }
1638
1639 static bool api_srvsvc_NetSrvGetInfo(pipes_struct *p)
1640 {
1641         const struct ndr_interface_call *call;
1642         struct ndr_pull *pull;
1643         struct ndr_push *push;
1644         enum ndr_err_code ndr_err;
1645         DATA_BLOB blob;
1646         struct srvsvc_NetSrvGetInfo *r;
1647
1648         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSRVGETINFO];
1649
1650         r = talloc(talloc_tos(), struct srvsvc_NetSrvGetInfo);
1651         if (r == NULL) {
1652                 return false;
1653         }
1654
1655         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1656                 talloc_free(r);
1657                 return false;
1658         }
1659
1660         pull = ndr_pull_init_blob(&blob, r, NULL);
1661         if (pull == NULL) {
1662                 talloc_free(r);
1663                 return false;
1664         }
1665
1666         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1667         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1668         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1669                 talloc_free(r);
1670                 return false;
1671         }
1672
1673         if (DEBUGLEVEL >= 10) {
1674                 NDR_PRINT_IN_DEBUG(srvsvc_NetSrvGetInfo, r);
1675         }
1676
1677         ZERO_STRUCT(r->out);
1678         r->out.info = talloc_zero(r, union srvsvc_NetSrvInfo);
1679         if (r->out.info == NULL) {
1680                 talloc_free(r);
1681                 return false;
1682         }
1683
1684         r->out.result = _srvsvc_NetSrvGetInfo(p, r);
1685
1686         if (p->rng_fault_state) {
1687                 talloc_free(r);
1688                 /* Return true here, srv_pipe_hnd.c will take care */
1689                 return true;
1690         }
1691
1692         if (DEBUGLEVEL >= 10) {
1693                 NDR_PRINT_OUT_DEBUG(srvsvc_NetSrvGetInfo, r);
1694         }
1695
1696         push = ndr_push_init_ctx(r, NULL);
1697         if (push == NULL) {
1698                 talloc_free(r);
1699                 return false;
1700         }
1701
1702         ndr_err = call->ndr_push(push, NDR_OUT, r);
1703         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1704                 talloc_free(r);
1705                 return false;
1706         }
1707
1708         blob = ndr_push_blob(push);
1709         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1710                 talloc_free(r);
1711                 return false;
1712         }
1713
1714         talloc_free(r);
1715
1716         return true;
1717 }
1718
1719 static bool api_srvsvc_NetSrvSetInfo(pipes_struct *p)
1720 {
1721         const struct ndr_interface_call *call;
1722         struct ndr_pull *pull;
1723         struct ndr_push *push;
1724         enum ndr_err_code ndr_err;
1725         DATA_BLOB blob;
1726         struct srvsvc_NetSrvSetInfo *r;
1727
1728         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSRVSETINFO];
1729
1730         r = talloc(talloc_tos(), struct srvsvc_NetSrvSetInfo);
1731         if (r == NULL) {
1732                 return false;
1733         }
1734
1735         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1736                 talloc_free(r);
1737                 return false;
1738         }
1739
1740         pull = ndr_pull_init_blob(&blob, r, NULL);
1741         if (pull == NULL) {
1742                 talloc_free(r);
1743                 return false;
1744         }
1745
1746         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1747         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1748         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1749                 talloc_free(r);
1750                 return false;
1751         }
1752
1753         if (DEBUGLEVEL >= 10) {
1754                 NDR_PRINT_IN_DEBUG(srvsvc_NetSrvSetInfo, r);
1755         }
1756
1757         ZERO_STRUCT(r->out);
1758         r->out.parm_error = r->in.parm_error;
1759         r->out.result = _srvsvc_NetSrvSetInfo(p, r);
1760
1761         if (p->rng_fault_state) {
1762                 talloc_free(r);
1763                 /* Return true here, srv_pipe_hnd.c will take care */
1764                 return true;
1765         }
1766
1767         if (DEBUGLEVEL >= 10) {
1768                 NDR_PRINT_OUT_DEBUG(srvsvc_NetSrvSetInfo, r);
1769         }
1770
1771         push = ndr_push_init_ctx(r, NULL);
1772         if (push == NULL) {
1773                 talloc_free(r);
1774                 return false;
1775         }
1776
1777         ndr_err = call->ndr_push(push, NDR_OUT, r);
1778         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1779                 talloc_free(r);
1780                 return false;
1781         }
1782
1783         blob = ndr_push_blob(push);
1784         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1785                 talloc_free(r);
1786                 return false;
1787         }
1788
1789         talloc_free(r);
1790
1791         return true;
1792 }
1793
1794 static bool api_srvsvc_NetDiskEnum(pipes_struct *p)
1795 {
1796         const struct ndr_interface_call *call;
1797         struct ndr_pull *pull;
1798         struct ndr_push *push;
1799         enum ndr_err_code ndr_err;
1800         DATA_BLOB blob;
1801         struct srvsvc_NetDiskEnum *r;
1802
1803         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETDISKENUM];
1804
1805         r = talloc(talloc_tos(), struct srvsvc_NetDiskEnum);
1806         if (r == NULL) {
1807                 return false;
1808         }
1809
1810         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1811                 talloc_free(r);
1812                 return false;
1813         }
1814
1815         pull = ndr_pull_init_blob(&blob, r, NULL);
1816         if (pull == NULL) {
1817                 talloc_free(r);
1818                 return false;
1819         }
1820
1821         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1822         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1823         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1824                 talloc_free(r);
1825                 return false;
1826         }
1827
1828         if (DEBUGLEVEL >= 10) {
1829                 NDR_PRINT_IN_DEBUG(srvsvc_NetDiskEnum, r);
1830         }
1831
1832         ZERO_STRUCT(r->out);
1833         r->out.info = r->in.info;
1834         r->out.totalentries = talloc_zero(r, uint32_t);
1835         if (r->out.totalentries == NULL) {
1836                 talloc_free(r);
1837                 return false;
1838         }
1839
1840         r->out.resume_handle = r->in.resume_handle;
1841         r->out.result = _srvsvc_NetDiskEnum(p, r);
1842
1843         if (p->rng_fault_state) {
1844                 talloc_free(r);
1845                 /* Return true here, srv_pipe_hnd.c will take care */
1846                 return true;
1847         }
1848
1849         if (DEBUGLEVEL >= 10) {
1850                 NDR_PRINT_OUT_DEBUG(srvsvc_NetDiskEnum, r);
1851         }
1852
1853         push = ndr_push_init_ctx(r, NULL);
1854         if (push == NULL) {
1855                 talloc_free(r);
1856                 return false;
1857         }
1858
1859         ndr_err = call->ndr_push(push, NDR_OUT, r);
1860         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1861                 talloc_free(r);
1862                 return false;
1863         }
1864
1865         blob = ndr_push_blob(push);
1866         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1867                 talloc_free(r);
1868                 return false;
1869         }
1870
1871         talloc_free(r);
1872
1873         return true;
1874 }
1875
1876 static bool api_srvsvc_NetServerStatisticsGet(pipes_struct *p)
1877 {
1878         const struct ndr_interface_call *call;
1879         struct ndr_pull *pull;
1880         struct ndr_push *push;
1881         enum ndr_err_code ndr_err;
1882         DATA_BLOB blob;
1883         struct srvsvc_NetServerStatisticsGet *r;
1884
1885         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSERVERSTATISTICSGET];
1886
1887         r = talloc(talloc_tos(), struct srvsvc_NetServerStatisticsGet);
1888         if (r == NULL) {
1889                 return false;
1890         }
1891
1892         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1893                 talloc_free(r);
1894                 return false;
1895         }
1896
1897         pull = ndr_pull_init_blob(&blob, r, NULL);
1898         if (pull == NULL) {
1899                 talloc_free(r);
1900                 return false;
1901         }
1902
1903         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1904         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1905         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1906                 talloc_free(r);
1907                 return false;
1908         }
1909
1910         if (DEBUGLEVEL >= 10) {
1911                 NDR_PRINT_IN_DEBUG(srvsvc_NetServerStatisticsGet, r);
1912         }
1913
1914         ZERO_STRUCT(r->out);
1915         r->out.stats = talloc_zero(r, struct srvsvc_Statistics);
1916         if (r->out.stats == NULL) {
1917                 talloc_free(r);
1918                 return false;
1919         }
1920
1921         r->out.result = _srvsvc_NetServerStatisticsGet(p, r);
1922
1923         if (p->rng_fault_state) {
1924                 talloc_free(r);
1925                 /* Return true here, srv_pipe_hnd.c will take care */
1926                 return true;
1927         }
1928
1929         if (DEBUGLEVEL >= 10) {
1930                 NDR_PRINT_OUT_DEBUG(srvsvc_NetServerStatisticsGet, r);
1931         }
1932
1933         push = ndr_push_init_ctx(r, NULL);
1934         if (push == NULL) {
1935                 talloc_free(r);
1936                 return false;
1937         }
1938
1939         ndr_err = call->ndr_push(push, NDR_OUT, r);
1940         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1941                 talloc_free(r);
1942                 return false;
1943         }
1944
1945         blob = ndr_push_blob(push);
1946         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1947                 talloc_free(r);
1948                 return false;
1949         }
1950
1951         talloc_free(r);
1952
1953         return true;
1954 }
1955
1956 static bool api_srvsvc_NetTransportAdd(pipes_struct *p)
1957 {
1958         const struct ndr_interface_call *call;
1959         struct ndr_pull *pull;
1960         struct ndr_push *push;
1961         enum ndr_err_code ndr_err;
1962         DATA_BLOB blob;
1963         struct srvsvc_NetTransportAdd *r;
1964
1965         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETTRANSPORTADD];
1966
1967         r = talloc(talloc_tos(), struct srvsvc_NetTransportAdd);
1968         if (r == NULL) {
1969                 return false;
1970         }
1971
1972         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1973                 talloc_free(r);
1974                 return false;
1975         }
1976
1977         pull = ndr_pull_init_blob(&blob, r, NULL);
1978         if (pull == NULL) {
1979                 talloc_free(r);
1980                 return false;
1981         }
1982
1983         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1984         ndr_err = call->ndr_pull(pull, NDR_IN, r);
1985         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1986                 talloc_free(r);
1987                 return false;
1988         }
1989
1990         if (DEBUGLEVEL >= 10) {
1991                 NDR_PRINT_IN_DEBUG(srvsvc_NetTransportAdd, r);
1992         }
1993
1994         r->out.result = _srvsvc_NetTransportAdd(p, r);
1995
1996         if (p->rng_fault_state) {
1997                 talloc_free(r);
1998                 /* Return true here, srv_pipe_hnd.c will take care */
1999                 return true;
2000         }
2001
2002         if (DEBUGLEVEL >= 10) {
2003                 NDR_PRINT_OUT_DEBUG(srvsvc_NetTransportAdd, r);
2004         }
2005
2006         push = ndr_push_init_ctx(r, NULL);
2007         if (push == NULL) {
2008                 talloc_free(r);
2009                 return false;
2010         }
2011
2012         ndr_err = call->ndr_push(push, NDR_OUT, r);
2013         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2014                 talloc_free(r);
2015                 return false;
2016         }
2017
2018         blob = ndr_push_blob(push);
2019         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2020                 talloc_free(r);
2021                 return false;
2022         }
2023
2024         talloc_free(r);
2025
2026         return true;
2027 }
2028
2029 static bool api_srvsvc_NetTransportEnum(pipes_struct *p)
2030 {
2031         const struct ndr_interface_call *call;
2032         struct ndr_pull *pull;
2033         struct ndr_push *push;
2034         enum ndr_err_code ndr_err;
2035         DATA_BLOB blob;
2036         struct srvsvc_NetTransportEnum *r;
2037
2038         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETTRANSPORTENUM];
2039
2040         r = talloc(talloc_tos(), struct srvsvc_NetTransportEnum);
2041         if (r == NULL) {
2042                 return false;
2043         }
2044
2045         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2046                 talloc_free(r);
2047                 return false;
2048         }
2049
2050         pull = ndr_pull_init_blob(&blob, r, NULL);
2051         if (pull == NULL) {
2052                 talloc_free(r);
2053                 return false;
2054         }
2055
2056         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2057         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2058         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2059                 talloc_free(r);
2060                 return false;
2061         }
2062
2063         if (DEBUGLEVEL >= 10) {
2064                 NDR_PRINT_IN_DEBUG(srvsvc_NetTransportEnum, r);
2065         }
2066
2067         ZERO_STRUCT(r->out);
2068         r->out.level = r->in.level;
2069         r->out.transports = r->in.transports;
2070         r->out.totalentries = talloc_zero(r, uint32_t);
2071         if (r->out.totalentries == NULL) {
2072                 talloc_free(r);
2073                 return false;
2074         }
2075
2076         r->out.resume_handle = r->in.resume_handle;
2077         r->out.result = _srvsvc_NetTransportEnum(p, r);
2078
2079         if (p->rng_fault_state) {
2080                 talloc_free(r);
2081                 /* Return true here, srv_pipe_hnd.c will take care */
2082                 return true;
2083         }
2084
2085         if (DEBUGLEVEL >= 10) {
2086                 NDR_PRINT_OUT_DEBUG(srvsvc_NetTransportEnum, r);
2087         }
2088
2089         push = ndr_push_init_ctx(r, NULL);
2090         if (push == NULL) {
2091                 talloc_free(r);
2092                 return false;
2093         }
2094
2095         ndr_err = call->ndr_push(push, NDR_OUT, r);
2096         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2097                 talloc_free(r);
2098                 return false;
2099         }
2100
2101         blob = ndr_push_blob(push);
2102         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2103                 talloc_free(r);
2104                 return false;
2105         }
2106
2107         talloc_free(r);
2108
2109         return true;
2110 }
2111
2112 static bool api_srvsvc_NetTransportDel(pipes_struct *p)
2113 {
2114         const struct ndr_interface_call *call;
2115         struct ndr_pull *pull;
2116         struct ndr_push *push;
2117         enum ndr_err_code ndr_err;
2118         DATA_BLOB blob;
2119         struct srvsvc_NetTransportDel *r;
2120
2121         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETTRANSPORTDEL];
2122
2123         r = talloc(talloc_tos(), struct srvsvc_NetTransportDel);
2124         if (r == NULL) {
2125                 return false;
2126         }
2127
2128         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2129                 talloc_free(r);
2130                 return false;
2131         }
2132
2133         pull = ndr_pull_init_blob(&blob, r, NULL);
2134         if (pull == NULL) {
2135                 talloc_free(r);
2136                 return false;
2137         }
2138
2139         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2140         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2141         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2142                 talloc_free(r);
2143                 return false;
2144         }
2145
2146         if (DEBUGLEVEL >= 10) {
2147                 NDR_PRINT_IN_DEBUG(srvsvc_NetTransportDel, r);
2148         }
2149
2150         r->out.result = _srvsvc_NetTransportDel(p, r);
2151
2152         if (p->rng_fault_state) {
2153                 talloc_free(r);
2154                 /* Return true here, srv_pipe_hnd.c will take care */
2155                 return true;
2156         }
2157
2158         if (DEBUGLEVEL >= 10) {
2159                 NDR_PRINT_OUT_DEBUG(srvsvc_NetTransportDel, r);
2160         }
2161
2162         push = ndr_push_init_ctx(r, NULL);
2163         if (push == NULL) {
2164                 talloc_free(r);
2165                 return false;
2166         }
2167
2168         ndr_err = call->ndr_push(push, NDR_OUT, r);
2169         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2170                 talloc_free(r);
2171                 return false;
2172         }
2173
2174         blob = ndr_push_blob(push);
2175         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2176                 talloc_free(r);
2177                 return false;
2178         }
2179
2180         talloc_free(r);
2181
2182         return true;
2183 }
2184
2185 static bool api_srvsvc_NetRemoteTOD(pipes_struct *p)
2186 {
2187         const struct ndr_interface_call *call;
2188         struct ndr_pull *pull;
2189         struct ndr_push *push;
2190         enum ndr_err_code ndr_err;
2191         DATA_BLOB blob;
2192         struct srvsvc_NetRemoteTOD *r;
2193
2194         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETREMOTETOD];
2195
2196         r = talloc(talloc_tos(), struct srvsvc_NetRemoteTOD);
2197         if (r == NULL) {
2198                 return false;
2199         }
2200
2201         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2202                 talloc_free(r);
2203                 return false;
2204         }
2205
2206         pull = ndr_pull_init_blob(&blob, r, NULL);
2207         if (pull == NULL) {
2208                 talloc_free(r);
2209                 return false;
2210         }
2211
2212         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2213         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2214         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2215                 talloc_free(r);
2216                 return false;
2217         }
2218
2219         if (DEBUGLEVEL >= 10) {
2220                 NDR_PRINT_IN_DEBUG(srvsvc_NetRemoteTOD, r);
2221         }
2222
2223         ZERO_STRUCT(r->out);
2224         r->out.info = talloc_zero(r, struct srvsvc_NetRemoteTODInfo *);
2225         if (r->out.info == NULL) {
2226                 talloc_free(r);
2227                 return false;
2228         }
2229
2230         r->out.result = _srvsvc_NetRemoteTOD(p, r);
2231
2232         if (p->rng_fault_state) {
2233                 talloc_free(r);
2234                 /* Return true here, srv_pipe_hnd.c will take care */
2235                 return true;
2236         }
2237
2238         if (DEBUGLEVEL >= 10) {
2239                 NDR_PRINT_OUT_DEBUG(srvsvc_NetRemoteTOD, r);
2240         }
2241
2242         push = ndr_push_init_ctx(r, NULL);
2243         if (push == NULL) {
2244                 talloc_free(r);
2245                 return false;
2246         }
2247
2248         ndr_err = call->ndr_push(push, NDR_OUT, r);
2249         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2250                 talloc_free(r);
2251                 return false;
2252         }
2253
2254         blob = ndr_push_blob(push);
2255         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2256                 talloc_free(r);
2257                 return false;
2258         }
2259
2260         talloc_free(r);
2261
2262         return true;
2263 }
2264
2265 static bool api_srvsvc_NetSetServiceBits(pipes_struct *p)
2266 {
2267         const struct ndr_interface_call *call;
2268         struct ndr_pull *pull;
2269         struct ndr_push *push;
2270         enum ndr_err_code ndr_err;
2271         DATA_BLOB blob;
2272         struct srvsvc_NetSetServiceBits *r;
2273
2274         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSETSERVICEBITS];
2275
2276         r = talloc(talloc_tos(), struct srvsvc_NetSetServiceBits);
2277         if (r == NULL) {
2278                 return false;
2279         }
2280
2281         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2282                 talloc_free(r);
2283                 return false;
2284         }
2285
2286         pull = ndr_pull_init_blob(&blob, r, NULL);
2287         if (pull == NULL) {
2288                 talloc_free(r);
2289                 return false;
2290         }
2291
2292         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2293         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2294         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2295                 talloc_free(r);
2296                 return false;
2297         }
2298
2299         if (DEBUGLEVEL >= 10) {
2300                 NDR_PRINT_IN_DEBUG(srvsvc_NetSetServiceBits, r);
2301         }
2302
2303         r->out.result = _srvsvc_NetSetServiceBits(p, r);
2304
2305         if (p->rng_fault_state) {
2306                 talloc_free(r);
2307                 /* Return true here, srv_pipe_hnd.c will take care */
2308                 return true;
2309         }
2310
2311         if (DEBUGLEVEL >= 10) {
2312                 NDR_PRINT_OUT_DEBUG(srvsvc_NetSetServiceBits, r);
2313         }
2314
2315         push = ndr_push_init_ctx(r, NULL);
2316         if (push == NULL) {
2317                 talloc_free(r);
2318                 return false;
2319         }
2320
2321         ndr_err = call->ndr_push(push, NDR_OUT, r);
2322         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2323                 talloc_free(r);
2324                 return false;
2325         }
2326
2327         blob = ndr_push_blob(push);
2328         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2329                 talloc_free(r);
2330                 return false;
2331         }
2332
2333         talloc_free(r);
2334
2335         return true;
2336 }
2337
2338 static bool api_srvsvc_NetPathType(pipes_struct *p)
2339 {
2340         const struct ndr_interface_call *call;
2341         struct ndr_pull *pull;
2342         struct ndr_push *push;
2343         enum ndr_err_code ndr_err;
2344         DATA_BLOB blob;
2345         struct srvsvc_NetPathType *r;
2346
2347         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETPATHTYPE];
2348
2349         r = talloc(talloc_tos(), struct srvsvc_NetPathType);
2350         if (r == NULL) {
2351                 return false;
2352         }
2353
2354         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2355                 talloc_free(r);
2356                 return false;
2357         }
2358
2359         pull = ndr_pull_init_blob(&blob, r, NULL);
2360         if (pull == NULL) {
2361                 talloc_free(r);
2362                 return false;
2363         }
2364
2365         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2366         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2367         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2368                 talloc_free(r);
2369                 return false;
2370         }
2371
2372         if (DEBUGLEVEL >= 10) {
2373                 NDR_PRINT_IN_DEBUG(srvsvc_NetPathType, r);
2374         }
2375
2376         ZERO_STRUCT(r->out);
2377         r->out.pathtype = talloc_zero(r, uint32_t);
2378         if (r->out.pathtype == NULL) {
2379                 talloc_free(r);
2380                 return false;
2381         }
2382
2383         r->out.result = _srvsvc_NetPathType(p, r);
2384
2385         if (p->rng_fault_state) {
2386                 talloc_free(r);
2387                 /* Return true here, srv_pipe_hnd.c will take care */
2388                 return true;
2389         }
2390
2391         if (DEBUGLEVEL >= 10) {
2392                 NDR_PRINT_OUT_DEBUG(srvsvc_NetPathType, r);
2393         }
2394
2395         push = ndr_push_init_ctx(r, NULL);
2396         if (push == NULL) {
2397                 talloc_free(r);
2398                 return false;
2399         }
2400
2401         ndr_err = call->ndr_push(push, NDR_OUT, r);
2402         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2403                 talloc_free(r);
2404                 return false;
2405         }
2406
2407         blob = ndr_push_blob(push);
2408         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2409                 talloc_free(r);
2410                 return false;
2411         }
2412
2413         talloc_free(r);
2414
2415         return true;
2416 }
2417
2418 static bool api_srvsvc_NetPathCanonicalize(pipes_struct *p)
2419 {
2420         const struct ndr_interface_call *call;
2421         struct ndr_pull *pull;
2422         struct ndr_push *push;
2423         enum ndr_err_code ndr_err;
2424         DATA_BLOB blob;
2425         struct srvsvc_NetPathCanonicalize *r;
2426
2427         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETPATHCANONICALIZE];
2428
2429         r = talloc(talloc_tos(), struct srvsvc_NetPathCanonicalize);
2430         if (r == NULL) {
2431                 return false;
2432         }
2433
2434         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2435                 talloc_free(r);
2436                 return false;
2437         }
2438
2439         pull = ndr_pull_init_blob(&blob, r, NULL);
2440         if (pull == NULL) {
2441                 talloc_free(r);
2442                 return false;
2443         }
2444
2445         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2446         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2447         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2448                 talloc_free(r);
2449                 return false;
2450         }
2451
2452         if (DEBUGLEVEL >= 10) {
2453                 NDR_PRINT_IN_DEBUG(srvsvc_NetPathCanonicalize, r);
2454         }
2455
2456         ZERO_STRUCT(r->out);
2457         r->out.can_path = talloc_zero_array(r, uint8_t, r->in.maxbuf);
2458         if (r->out.can_path == NULL) {
2459                 talloc_free(r);
2460                 return false;
2461         }
2462
2463         r->out.pathtype = r->in.pathtype;
2464         r->out.result = _srvsvc_NetPathCanonicalize(p, r);
2465
2466         if (p->rng_fault_state) {
2467                 talloc_free(r);
2468                 /* Return true here, srv_pipe_hnd.c will take care */
2469                 return true;
2470         }
2471
2472         if (DEBUGLEVEL >= 10) {
2473                 NDR_PRINT_OUT_DEBUG(srvsvc_NetPathCanonicalize, r);
2474         }
2475
2476         push = ndr_push_init_ctx(r, NULL);
2477         if (push == NULL) {
2478                 talloc_free(r);
2479                 return false;
2480         }
2481
2482         ndr_err = call->ndr_push(push, NDR_OUT, r);
2483         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2484                 talloc_free(r);
2485                 return false;
2486         }
2487
2488         blob = ndr_push_blob(push);
2489         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2490                 talloc_free(r);
2491                 return false;
2492         }
2493
2494         talloc_free(r);
2495
2496         return true;
2497 }
2498
2499 static bool api_srvsvc_NetPathCompare(pipes_struct *p)
2500 {
2501         const struct ndr_interface_call *call;
2502         struct ndr_pull *pull;
2503         struct ndr_push *push;
2504         enum ndr_err_code ndr_err;
2505         DATA_BLOB blob;
2506         struct srvsvc_NetPathCompare *r;
2507
2508         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETPATHCOMPARE];
2509
2510         r = talloc(talloc_tos(), struct srvsvc_NetPathCompare);
2511         if (r == NULL) {
2512                 return false;
2513         }
2514
2515         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2516                 talloc_free(r);
2517                 return false;
2518         }
2519
2520         pull = ndr_pull_init_blob(&blob, r, NULL);
2521         if (pull == NULL) {
2522                 talloc_free(r);
2523                 return false;
2524         }
2525
2526         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2527         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2528         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2529                 talloc_free(r);
2530                 return false;
2531         }
2532
2533         if (DEBUGLEVEL >= 10) {
2534                 NDR_PRINT_IN_DEBUG(srvsvc_NetPathCompare, r);
2535         }
2536
2537         r->out.result = _srvsvc_NetPathCompare(p, r);
2538
2539         if (p->rng_fault_state) {
2540                 talloc_free(r);
2541                 /* Return true here, srv_pipe_hnd.c will take care */
2542                 return true;
2543         }
2544
2545         if (DEBUGLEVEL >= 10) {
2546                 NDR_PRINT_OUT_DEBUG(srvsvc_NetPathCompare, r);
2547         }
2548
2549         push = ndr_push_init_ctx(r, NULL);
2550         if (push == NULL) {
2551                 talloc_free(r);
2552                 return false;
2553         }
2554
2555         ndr_err = call->ndr_push(push, NDR_OUT, r);
2556         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2557                 talloc_free(r);
2558                 return false;
2559         }
2560
2561         blob = ndr_push_blob(push);
2562         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2563                 talloc_free(r);
2564                 return false;
2565         }
2566
2567         talloc_free(r);
2568
2569         return true;
2570 }
2571
2572 static bool api_srvsvc_NetNameValidate(pipes_struct *p)
2573 {
2574         const struct ndr_interface_call *call;
2575         struct ndr_pull *pull;
2576         struct ndr_push *push;
2577         enum ndr_err_code ndr_err;
2578         DATA_BLOB blob;
2579         struct srvsvc_NetNameValidate *r;
2580
2581         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETNAMEVALIDATE];
2582
2583         r = talloc(talloc_tos(), struct srvsvc_NetNameValidate);
2584         if (r == NULL) {
2585                 return false;
2586         }
2587
2588         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2589                 talloc_free(r);
2590                 return false;
2591         }
2592
2593         pull = ndr_pull_init_blob(&blob, r, NULL);
2594         if (pull == NULL) {
2595                 talloc_free(r);
2596                 return false;
2597         }
2598
2599         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2600         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2601         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2602                 talloc_free(r);
2603                 return false;
2604         }
2605
2606         if (DEBUGLEVEL >= 10) {
2607                 NDR_PRINT_IN_DEBUG(srvsvc_NetNameValidate, r);
2608         }
2609
2610         r->out.result = _srvsvc_NetNameValidate(p, r);
2611
2612         if (p->rng_fault_state) {
2613                 talloc_free(r);
2614                 /* Return true here, srv_pipe_hnd.c will take care */
2615                 return true;
2616         }
2617
2618         if (DEBUGLEVEL >= 10) {
2619                 NDR_PRINT_OUT_DEBUG(srvsvc_NetNameValidate, r);
2620         }
2621
2622         push = ndr_push_init_ctx(r, NULL);
2623         if (push == NULL) {
2624                 talloc_free(r);
2625                 return false;
2626         }
2627
2628         ndr_err = call->ndr_push(push, NDR_OUT, r);
2629         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2630                 talloc_free(r);
2631                 return false;
2632         }
2633
2634         blob = ndr_push_blob(push);
2635         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2636                 talloc_free(r);
2637                 return false;
2638         }
2639
2640         talloc_free(r);
2641
2642         return true;
2643 }
2644
2645 static bool api_srvsvc_NETRPRNAMECANONICALIZE(pipes_struct *p)
2646 {
2647         const struct ndr_interface_call *call;
2648         struct ndr_pull *pull;
2649         struct ndr_push *push;
2650         enum ndr_err_code ndr_err;
2651         DATA_BLOB blob;
2652         struct srvsvc_NETRPRNAMECANONICALIZE *r;
2653
2654         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRPRNAMECANONICALIZE];
2655
2656         r = talloc(talloc_tos(), struct srvsvc_NETRPRNAMECANONICALIZE);
2657         if (r == NULL) {
2658                 return false;
2659         }
2660
2661         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2662                 talloc_free(r);
2663                 return false;
2664         }
2665
2666         pull = ndr_pull_init_blob(&blob, r, NULL);
2667         if (pull == NULL) {
2668                 talloc_free(r);
2669                 return false;
2670         }
2671
2672         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2673         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2674         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2675                 talloc_free(r);
2676                 return false;
2677         }
2678
2679         if (DEBUGLEVEL >= 10) {
2680                 NDR_PRINT_IN_DEBUG(srvsvc_NETRPRNAMECANONICALIZE, r);
2681         }
2682
2683         r->out.result = _srvsvc_NETRPRNAMECANONICALIZE(p, r);
2684
2685         if (p->rng_fault_state) {
2686                 talloc_free(r);
2687                 /* Return true here, srv_pipe_hnd.c will take care */
2688                 return true;
2689         }
2690
2691         if (DEBUGLEVEL >= 10) {
2692                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRPRNAMECANONICALIZE, r);
2693         }
2694
2695         push = ndr_push_init_ctx(r, NULL);
2696         if (push == NULL) {
2697                 talloc_free(r);
2698                 return false;
2699         }
2700
2701         ndr_err = call->ndr_push(push, NDR_OUT, r);
2702         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2703                 talloc_free(r);
2704                 return false;
2705         }
2706
2707         blob = ndr_push_blob(push);
2708         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2709                 talloc_free(r);
2710                 return false;
2711         }
2712
2713         talloc_free(r);
2714
2715         return true;
2716 }
2717
2718 static bool api_srvsvc_NetPRNameCompare(pipes_struct *p)
2719 {
2720         const struct ndr_interface_call *call;
2721         struct ndr_pull *pull;
2722         struct ndr_push *push;
2723         enum ndr_err_code ndr_err;
2724         DATA_BLOB blob;
2725         struct srvsvc_NetPRNameCompare *r;
2726
2727         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETPRNAMECOMPARE];
2728
2729         r = talloc(talloc_tos(), struct srvsvc_NetPRNameCompare);
2730         if (r == NULL) {
2731                 return false;
2732         }
2733
2734         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2735                 talloc_free(r);
2736                 return false;
2737         }
2738
2739         pull = ndr_pull_init_blob(&blob, r, NULL);
2740         if (pull == NULL) {
2741                 talloc_free(r);
2742                 return false;
2743         }
2744
2745         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2746         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2747         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2748                 talloc_free(r);
2749                 return false;
2750         }
2751
2752         if (DEBUGLEVEL >= 10) {
2753                 NDR_PRINT_IN_DEBUG(srvsvc_NetPRNameCompare, r);
2754         }
2755
2756         r->out.result = _srvsvc_NetPRNameCompare(p, r);
2757
2758         if (p->rng_fault_state) {
2759                 talloc_free(r);
2760                 /* Return true here, srv_pipe_hnd.c will take care */
2761                 return true;
2762         }
2763
2764         if (DEBUGLEVEL >= 10) {
2765                 NDR_PRINT_OUT_DEBUG(srvsvc_NetPRNameCompare, r);
2766         }
2767
2768         push = ndr_push_init_ctx(r, NULL);
2769         if (push == NULL) {
2770                 talloc_free(r);
2771                 return false;
2772         }
2773
2774         ndr_err = call->ndr_push(push, NDR_OUT, r);
2775         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2776                 talloc_free(r);
2777                 return false;
2778         }
2779
2780         blob = ndr_push_blob(push);
2781         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2782                 talloc_free(r);
2783                 return false;
2784         }
2785
2786         talloc_free(r);
2787
2788         return true;
2789 }
2790
2791 static bool api_srvsvc_NetShareEnum(pipes_struct *p)
2792 {
2793         const struct ndr_interface_call *call;
2794         struct ndr_pull *pull;
2795         struct ndr_push *push;
2796         enum ndr_err_code ndr_err;
2797         DATA_BLOB blob;
2798         struct srvsvc_NetShareEnum *r;
2799
2800         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREENUM];
2801
2802         r = talloc(talloc_tos(), struct srvsvc_NetShareEnum);
2803         if (r == NULL) {
2804                 return false;
2805         }
2806
2807         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2808                 talloc_free(r);
2809                 return false;
2810         }
2811
2812         pull = ndr_pull_init_blob(&blob, r, NULL);
2813         if (pull == NULL) {
2814                 talloc_free(r);
2815                 return false;
2816         }
2817
2818         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2819         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2820         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2821                 talloc_free(r);
2822                 return false;
2823         }
2824
2825         if (DEBUGLEVEL >= 10) {
2826                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareEnum, r);
2827         }
2828
2829         ZERO_STRUCT(r->out);
2830         r->out.info_ctr = r->in.info_ctr;
2831         r->out.totalentries = talloc_zero(r, uint32_t);
2832         if (r->out.totalentries == NULL) {
2833                 talloc_free(r);
2834                 return false;
2835         }
2836
2837         r->out.resume_handle = r->in.resume_handle;
2838         r->out.result = _srvsvc_NetShareEnum(p, r);
2839
2840         if (p->rng_fault_state) {
2841                 talloc_free(r);
2842                 /* Return true here, srv_pipe_hnd.c will take care */
2843                 return true;
2844         }
2845
2846         if (DEBUGLEVEL >= 10) {
2847                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareEnum, r);
2848         }
2849
2850         push = ndr_push_init_ctx(r, NULL);
2851         if (push == NULL) {
2852                 talloc_free(r);
2853                 return false;
2854         }
2855
2856         ndr_err = call->ndr_push(push, NDR_OUT, r);
2857         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2858                 talloc_free(r);
2859                 return false;
2860         }
2861
2862         blob = ndr_push_blob(push);
2863         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2864                 talloc_free(r);
2865                 return false;
2866         }
2867
2868         talloc_free(r);
2869
2870         return true;
2871 }
2872
2873 static bool api_srvsvc_NetShareDelStart(pipes_struct *p)
2874 {
2875         const struct ndr_interface_call *call;
2876         struct ndr_pull *pull;
2877         struct ndr_push *push;
2878         enum ndr_err_code ndr_err;
2879         DATA_BLOB blob;
2880         struct srvsvc_NetShareDelStart *r;
2881
2882         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREDELSTART];
2883
2884         r = talloc(talloc_tos(), struct srvsvc_NetShareDelStart);
2885         if (r == NULL) {
2886                 return false;
2887         }
2888
2889         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2890                 talloc_free(r);
2891                 return false;
2892         }
2893
2894         pull = ndr_pull_init_blob(&blob, r, NULL);
2895         if (pull == NULL) {
2896                 talloc_free(r);
2897                 return false;
2898         }
2899
2900         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2901         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2902         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2903                 talloc_free(r);
2904                 return false;
2905         }
2906
2907         if (DEBUGLEVEL >= 10) {
2908                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareDelStart, r);
2909         }
2910
2911         ZERO_STRUCT(r->out);
2912         r->out.hnd = talloc_zero(r, struct policy_handle);
2913         if (r->out.hnd == NULL) {
2914                 talloc_free(r);
2915                 return false;
2916         }
2917
2918         r->out.result = _srvsvc_NetShareDelStart(p, r);
2919
2920         if (p->rng_fault_state) {
2921                 talloc_free(r);
2922                 /* Return true here, srv_pipe_hnd.c will take care */
2923                 return true;
2924         }
2925
2926         if (DEBUGLEVEL >= 10) {
2927                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDelStart, r);
2928         }
2929
2930         push = ndr_push_init_ctx(r, NULL);
2931         if (push == NULL) {
2932                 talloc_free(r);
2933                 return false;
2934         }
2935
2936         ndr_err = call->ndr_push(push, NDR_OUT, r);
2937         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2938                 talloc_free(r);
2939                 return false;
2940         }
2941
2942         blob = ndr_push_blob(push);
2943         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2944                 talloc_free(r);
2945                 return false;
2946         }
2947
2948         talloc_free(r);
2949
2950         return true;
2951 }
2952
2953 static bool api_srvsvc_NetShareDelCommit(pipes_struct *p)
2954 {
2955         const struct ndr_interface_call *call;
2956         struct ndr_pull *pull;
2957         struct ndr_push *push;
2958         enum ndr_err_code ndr_err;
2959         DATA_BLOB blob;
2960         struct srvsvc_NetShareDelCommit *r;
2961
2962         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSHAREDELCOMMIT];
2963
2964         r = talloc(talloc_tos(), struct srvsvc_NetShareDelCommit);
2965         if (r == NULL) {
2966                 return false;
2967         }
2968
2969         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2970                 talloc_free(r);
2971                 return false;
2972         }
2973
2974         pull = ndr_pull_init_blob(&blob, r, NULL);
2975         if (pull == NULL) {
2976                 talloc_free(r);
2977                 return false;
2978         }
2979
2980         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2981         ndr_err = call->ndr_pull(pull, NDR_IN, r);
2982         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2983                 talloc_free(r);
2984                 return false;
2985         }
2986
2987         if (DEBUGLEVEL >= 10) {
2988                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareDelCommit, r);
2989         }
2990
2991         ZERO_STRUCT(r->out);
2992         r->out.hnd = r->in.hnd;
2993         r->out.result = _srvsvc_NetShareDelCommit(p, r);
2994
2995         if (p->rng_fault_state) {
2996                 talloc_free(r);
2997                 /* Return true here, srv_pipe_hnd.c will take care */
2998                 return true;
2999         }
3000
3001         if (DEBUGLEVEL >= 10) {
3002                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDelCommit, r);
3003         }
3004
3005         push = ndr_push_init_ctx(r, NULL);
3006         if (push == NULL) {
3007                 talloc_free(r);
3008                 return false;
3009         }
3010
3011         ndr_err = call->ndr_push(push, NDR_OUT, r);
3012         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3013                 talloc_free(r);
3014                 return false;
3015         }
3016
3017         blob = ndr_push_blob(push);
3018         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3019                 talloc_free(r);
3020                 return false;
3021         }
3022
3023         talloc_free(r);
3024
3025         return true;
3026 }
3027
3028 static bool api_srvsvc_NetGetFileSecurity(pipes_struct *p)
3029 {
3030         const struct ndr_interface_call *call;
3031         struct ndr_pull *pull;
3032         struct ndr_push *push;
3033         enum ndr_err_code ndr_err;
3034         DATA_BLOB blob;
3035         struct srvsvc_NetGetFileSecurity *r;
3036
3037         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETGETFILESECURITY];
3038
3039         r = talloc(talloc_tos(), struct srvsvc_NetGetFileSecurity);
3040         if (r == NULL) {
3041                 return false;
3042         }
3043
3044         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3045                 talloc_free(r);
3046                 return false;
3047         }
3048
3049         pull = ndr_pull_init_blob(&blob, r, NULL);
3050         if (pull == NULL) {
3051                 talloc_free(r);
3052                 return false;
3053         }
3054
3055         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3056         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3057         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3058                 talloc_free(r);
3059                 return false;
3060         }
3061
3062         if (DEBUGLEVEL >= 10) {
3063                 NDR_PRINT_IN_DEBUG(srvsvc_NetGetFileSecurity, r);
3064         }
3065
3066         ZERO_STRUCT(r->out);
3067         r->out.sd_buf = talloc_zero(r, struct sec_desc_buf *);
3068         if (r->out.sd_buf == NULL) {
3069                 talloc_free(r);
3070                 return false;
3071         }
3072
3073         r->out.result = _srvsvc_NetGetFileSecurity(p, r);
3074
3075         if (p->rng_fault_state) {
3076                 talloc_free(r);
3077                 /* Return true here, srv_pipe_hnd.c will take care */
3078                 return true;
3079         }
3080
3081         if (DEBUGLEVEL >= 10) {
3082                 NDR_PRINT_OUT_DEBUG(srvsvc_NetGetFileSecurity, r);
3083         }
3084
3085         push = ndr_push_init_ctx(r, NULL);
3086         if (push == NULL) {
3087                 talloc_free(r);
3088                 return false;
3089         }
3090
3091         ndr_err = call->ndr_push(push, NDR_OUT, r);
3092         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3093                 talloc_free(r);
3094                 return false;
3095         }
3096
3097         blob = ndr_push_blob(push);
3098         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3099                 talloc_free(r);
3100                 return false;
3101         }
3102
3103         talloc_free(r);
3104
3105         return true;
3106 }
3107
3108 static bool api_srvsvc_NetSetFileSecurity(pipes_struct *p)
3109 {
3110         const struct ndr_interface_call *call;
3111         struct ndr_pull *pull;
3112         struct ndr_push *push;
3113         enum ndr_err_code ndr_err;
3114         DATA_BLOB blob;
3115         struct srvsvc_NetSetFileSecurity *r;
3116
3117         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSETFILESECURITY];
3118
3119         r = talloc(talloc_tos(), struct srvsvc_NetSetFileSecurity);
3120         if (r == NULL) {
3121                 return false;
3122         }
3123
3124         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3125                 talloc_free(r);
3126                 return false;
3127         }
3128
3129         pull = ndr_pull_init_blob(&blob, r, NULL);
3130         if (pull == NULL) {
3131                 talloc_free(r);
3132                 return false;
3133         }
3134
3135         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3136         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3137         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3138                 talloc_free(r);
3139                 return false;
3140         }
3141
3142         if (DEBUGLEVEL >= 10) {
3143                 NDR_PRINT_IN_DEBUG(srvsvc_NetSetFileSecurity, r);
3144         }
3145
3146         r->out.result = _srvsvc_NetSetFileSecurity(p, r);
3147
3148         if (p->rng_fault_state) {
3149                 talloc_free(r);
3150                 /* Return true here, srv_pipe_hnd.c will take care */
3151                 return true;
3152         }
3153
3154         if (DEBUGLEVEL >= 10) {
3155                 NDR_PRINT_OUT_DEBUG(srvsvc_NetSetFileSecurity, r);
3156         }
3157
3158         push = ndr_push_init_ctx(r, NULL);
3159         if (push == NULL) {
3160                 talloc_free(r);
3161                 return false;
3162         }
3163
3164         ndr_err = call->ndr_push(push, NDR_OUT, r);
3165         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3166                 talloc_free(r);
3167                 return false;
3168         }
3169
3170         blob = ndr_push_blob(push);
3171         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3172                 talloc_free(r);
3173                 return false;
3174         }
3175
3176         talloc_free(r);
3177
3178         return true;
3179 }
3180
3181 static bool api_srvsvc_NetServerTransportAddEx(pipes_struct *p)
3182 {
3183         const struct ndr_interface_call *call;
3184         struct ndr_pull *pull;
3185         struct ndr_push *push;
3186         enum ndr_err_code ndr_err;
3187         DATA_BLOB blob;
3188         struct srvsvc_NetServerTransportAddEx *r;
3189
3190         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSERVERTRANSPORTADDEX];
3191
3192         r = talloc(talloc_tos(), struct srvsvc_NetServerTransportAddEx);
3193         if (r == NULL) {
3194                 return false;
3195         }
3196
3197         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3198                 talloc_free(r);
3199                 return false;
3200         }
3201
3202         pull = ndr_pull_init_blob(&blob, r, NULL);
3203         if (pull == NULL) {
3204                 talloc_free(r);
3205                 return false;
3206         }
3207
3208         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3209         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3210         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3211                 talloc_free(r);
3212                 return false;
3213         }
3214
3215         if (DEBUGLEVEL >= 10) {
3216                 NDR_PRINT_IN_DEBUG(srvsvc_NetServerTransportAddEx, r);
3217         }
3218
3219         r->out.result = _srvsvc_NetServerTransportAddEx(p, r);
3220
3221         if (p->rng_fault_state) {
3222                 talloc_free(r);
3223                 /* Return true here, srv_pipe_hnd.c will take care */
3224                 return true;
3225         }
3226
3227         if (DEBUGLEVEL >= 10) {
3228                 NDR_PRINT_OUT_DEBUG(srvsvc_NetServerTransportAddEx, r);
3229         }
3230
3231         push = ndr_push_init_ctx(r, NULL);
3232         if (push == NULL) {
3233                 talloc_free(r);
3234                 return false;
3235         }
3236
3237         ndr_err = call->ndr_push(push, NDR_OUT, r);
3238         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3239                 talloc_free(r);
3240                 return false;
3241         }
3242
3243         blob = ndr_push_blob(push);
3244         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3245                 talloc_free(r);
3246                 return false;
3247         }
3248
3249         talloc_free(r);
3250
3251         return true;
3252 }
3253
3254 static bool api_srvsvc_NetServerSetServiceBitsEx(pipes_struct *p)
3255 {
3256         const struct ndr_interface_call *call;
3257         struct ndr_pull *pull;
3258         struct ndr_push *push;
3259         enum ndr_err_code ndr_err;
3260         DATA_BLOB blob;
3261         struct srvsvc_NetServerSetServiceBitsEx *r;
3262
3263         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETSERVERSETSERVICEBITSEX];
3264
3265         r = talloc(talloc_tos(), struct srvsvc_NetServerSetServiceBitsEx);
3266         if (r == NULL) {
3267                 return false;
3268         }
3269
3270         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3271                 talloc_free(r);
3272                 return false;
3273         }
3274
3275         pull = ndr_pull_init_blob(&blob, r, NULL);
3276         if (pull == NULL) {
3277                 talloc_free(r);
3278                 return false;
3279         }
3280
3281         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3282         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3283         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3284                 talloc_free(r);
3285                 return false;
3286         }
3287
3288         if (DEBUGLEVEL >= 10) {
3289                 NDR_PRINT_IN_DEBUG(srvsvc_NetServerSetServiceBitsEx, r);
3290         }
3291
3292         r->out.result = _srvsvc_NetServerSetServiceBitsEx(p, r);
3293
3294         if (p->rng_fault_state) {
3295                 talloc_free(r);
3296                 /* Return true here, srv_pipe_hnd.c will take care */
3297                 return true;
3298         }
3299
3300         if (DEBUGLEVEL >= 10) {
3301                 NDR_PRINT_OUT_DEBUG(srvsvc_NetServerSetServiceBitsEx, r);
3302         }
3303
3304         push = ndr_push_init_ctx(r, NULL);
3305         if (push == NULL) {
3306                 talloc_free(r);
3307                 return false;
3308         }
3309
3310         ndr_err = call->ndr_push(push, NDR_OUT, r);
3311         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3312                 talloc_free(r);
3313                 return false;
3314         }
3315
3316         blob = ndr_push_blob(push);
3317         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3318                 talloc_free(r);
3319                 return false;
3320         }
3321
3322         talloc_free(r);
3323
3324         return true;
3325 }
3326
3327 static bool api_srvsvc_NETRDFSGETVERSION(pipes_struct *p)
3328 {
3329         const struct ndr_interface_call *call;
3330         struct ndr_pull *pull;
3331         struct ndr_push *push;
3332         enum ndr_err_code ndr_err;
3333         DATA_BLOB blob;
3334         struct srvsvc_NETRDFSGETVERSION *r;
3335
3336         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSGETVERSION];
3337
3338         r = talloc(talloc_tos(), struct srvsvc_NETRDFSGETVERSION);
3339         if (r == NULL) {
3340                 return false;
3341         }
3342
3343         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3344                 talloc_free(r);
3345                 return false;
3346         }
3347
3348         pull = ndr_pull_init_blob(&blob, r, NULL);
3349         if (pull == NULL) {
3350                 talloc_free(r);
3351                 return false;
3352         }
3353
3354         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3355         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3356         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3357                 talloc_free(r);
3358                 return false;
3359         }
3360
3361         if (DEBUGLEVEL >= 10) {
3362                 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSGETVERSION, r);
3363         }
3364
3365         r->out.result = _srvsvc_NETRDFSGETVERSION(p, r);
3366
3367         if (p->rng_fault_state) {
3368                 talloc_free(r);
3369                 /* Return true here, srv_pipe_hnd.c will take care */
3370                 return true;
3371         }
3372
3373         if (DEBUGLEVEL >= 10) {
3374                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSGETVERSION, r);
3375         }
3376
3377         push = ndr_push_init_ctx(r, NULL);
3378         if (push == NULL) {
3379                 talloc_free(r);
3380                 return false;
3381         }
3382
3383         ndr_err = call->ndr_push(push, NDR_OUT, r);
3384         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3385                 talloc_free(r);
3386                 return false;
3387         }
3388
3389         blob = ndr_push_blob(push);
3390         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3391                 talloc_free(r);
3392                 return false;
3393         }
3394
3395         talloc_free(r);
3396
3397         return true;
3398 }
3399
3400 static bool api_srvsvc_NETRDFSCREATELOCALPARTITION(pipes_struct *p)
3401 {
3402         const struct ndr_interface_call *call;
3403         struct ndr_pull *pull;
3404         struct ndr_push *push;
3405         enum ndr_err_code ndr_err;
3406         DATA_BLOB blob;
3407         struct srvsvc_NETRDFSCREATELOCALPARTITION *r;
3408
3409         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSCREATELOCALPARTITION];
3410
3411         r = talloc(talloc_tos(), struct srvsvc_NETRDFSCREATELOCALPARTITION);
3412         if (r == NULL) {
3413                 return false;
3414         }
3415
3416         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3417                 talloc_free(r);
3418                 return false;
3419         }
3420
3421         pull = ndr_pull_init_blob(&blob, r, NULL);
3422         if (pull == NULL) {
3423                 talloc_free(r);
3424                 return false;
3425         }
3426
3427         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3428         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3429         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3430                 talloc_free(r);
3431                 return false;
3432         }
3433
3434         if (DEBUGLEVEL >= 10) {
3435                 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSCREATELOCALPARTITION, r);
3436         }
3437
3438         r->out.result = _srvsvc_NETRDFSCREATELOCALPARTITION(p, r);
3439
3440         if (p->rng_fault_state) {
3441                 talloc_free(r);
3442                 /* Return true here, srv_pipe_hnd.c will take care */
3443                 return true;
3444         }
3445
3446         if (DEBUGLEVEL >= 10) {
3447                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSCREATELOCALPARTITION, r);
3448         }
3449
3450         push = ndr_push_init_ctx(r, NULL);
3451         if (push == NULL) {
3452                 talloc_free(r);
3453                 return false;
3454         }
3455
3456         ndr_err = call->ndr_push(push, NDR_OUT, r);
3457         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3458                 talloc_free(r);
3459                 return false;
3460         }
3461
3462         blob = ndr_push_blob(push);
3463         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3464                 talloc_free(r);
3465                 return false;
3466         }
3467
3468         talloc_free(r);
3469
3470         return true;
3471 }
3472
3473 static bool api_srvsvc_NETRDFSDELETELOCALPARTITION(pipes_struct *p)
3474 {
3475         const struct ndr_interface_call *call;
3476         struct ndr_pull *pull;
3477         struct ndr_push *push;
3478         enum ndr_err_code ndr_err;
3479         DATA_BLOB blob;
3480         struct srvsvc_NETRDFSDELETELOCALPARTITION *r;
3481
3482         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSDELETELOCALPARTITION];
3483
3484         r = talloc(talloc_tos(), struct srvsvc_NETRDFSDELETELOCALPARTITION);
3485         if (r == NULL) {
3486                 return false;
3487         }
3488
3489         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3490                 talloc_free(r);
3491                 return false;
3492         }
3493
3494         pull = ndr_pull_init_blob(&blob, r, NULL);
3495         if (pull == NULL) {
3496                 talloc_free(r);
3497                 return false;
3498         }
3499
3500         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3501         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3502         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3503                 talloc_free(r);
3504                 return false;
3505         }
3506
3507         if (DEBUGLEVEL >= 10) {
3508                 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSDELETELOCALPARTITION, r);
3509         }
3510
3511         r->out.result = _srvsvc_NETRDFSDELETELOCALPARTITION(p, r);
3512
3513         if (p->rng_fault_state) {
3514                 talloc_free(r);
3515                 /* Return true here, srv_pipe_hnd.c will take care */
3516                 return true;
3517         }
3518
3519         if (DEBUGLEVEL >= 10) {
3520                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSDELETELOCALPARTITION, r);
3521         }
3522
3523         push = ndr_push_init_ctx(r, NULL);
3524         if (push == NULL) {
3525                 talloc_free(r);
3526                 return false;
3527         }
3528
3529         ndr_err = call->ndr_push(push, NDR_OUT, r);
3530         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3531                 talloc_free(r);
3532                 return false;
3533         }
3534
3535         blob = ndr_push_blob(push);
3536         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3537                 talloc_free(r);
3538                 return false;
3539         }
3540
3541         talloc_free(r);
3542
3543         return true;
3544 }
3545
3546 static bool api_srvsvc_NETRDFSSETLOCALVOLUMESTATE(pipes_struct *p)
3547 {
3548         const struct ndr_interface_call *call;
3549         struct ndr_pull *pull;
3550         struct ndr_push *push;
3551         enum ndr_err_code ndr_err;
3552         DATA_BLOB blob;
3553         struct srvsvc_NETRDFSSETLOCALVOLUMESTATE *r;
3554
3555         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSSETLOCALVOLUMESTATE];
3556
3557         r = talloc(talloc_tos(), struct srvsvc_NETRDFSSETLOCALVOLUMESTATE);
3558         if (r == NULL) {
3559                 return false;
3560         }
3561
3562         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3563                 talloc_free(r);
3564                 return false;
3565         }
3566
3567         pull = ndr_pull_init_blob(&blob, r, NULL);
3568         if (pull == NULL) {
3569                 talloc_free(r);
3570                 return false;
3571         }
3572
3573         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3574         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3575         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3576                 talloc_free(r);
3577                 return false;
3578         }
3579
3580         if (DEBUGLEVEL >= 10) {
3581                 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSSETLOCALVOLUMESTATE, r);
3582         }
3583
3584         r->out.result = _srvsvc_NETRDFSSETLOCALVOLUMESTATE(p, r);
3585
3586         if (p->rng_fault_state) {
3587                 talloc_free(r);
3588                 /* Return true here, srv_pipe_hnd.c will take care */
3589                 return true;
3590         }
3591
3592         if (DEBUGLEVEL >= 10) {
3593                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSSETLOCALVOLUMESTATE, r);
3594         }
3595
3596         push = ndr_push_init_ctx(r, NULL);
3597         if (push == NULL) {
3598                 talloc_free(r);
3599                 return false;
3600         }
3601
3602         ndr_err = call->ndr_push(push, NDR_OUT, r);
3603         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3604                 talloc_free(r);
3605                 return false;
3606         }
3607
3608         blob = ndr_push_blob(push);
3609         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3610                 talloc_free(r);
3611                 return false;
3612         }
3613
3614         talloc_free(r);
3615
3616         return true;
3617 }
3618
3619 static bool api_srvsvc_NETRDFSSETSERVERINFO(pipes_struct *p)
3620 {
3621         const struct ndr_interface_call *call;
3622         struct ndr_pull *pull;
3623         struct ndr_push *push;
3624         enum ndr_err_code ndr_err;
3625         DATA_BLOB blob;
3626         struct srvsvc_NETRDFSSETSERVERINFO *r;
3627
3628         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSSETSERVERINFO];
3629
3630         r = talloc(talloc_tos(), struct srvsvc_NETRDFSSETSERVERINFO);
3631         if (r == NULL) {
3632                 return false;
3633         }
3634
3635         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3636                 talloc_free(r);
3637                 return false;
3638         }
3639
3640         pull = ndr_pull_init_blob(&blob, r, NULL);
3641         if (pull == NULL) {
3642                 talloc_free(r);
3643                 return false;
3644         }
3645
3646         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3647         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3648         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3649                 talloc_free(r);
3650                 return false;
3651         }
3652
3653         if (DEBUGLEVEL >= 10) {
3654                 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSSETSERVERINFO, r);
3655         }
3656
3657         r->out.result = _srvsvc_NETRDFSSETSERVERINFO(p, r);
3658
3659         if (p->rng_fault_state) {
3660                 talloc_free(r);
3661                 /* Return true here, srv_pipe_hnd.c will take care */
3662                 return true;
3663         }
3664
3665         if (DEBUGLEVEL >= 10) {
3666                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSSETSERVERINFO, r);
3667         }
3668
3669         push = ndr_push_init_ctx(r, NULL);
3670         if (push == NULL) {
3671                 talloc_free(r);
3672                 return false;
3673         }
3674
3675         ndr_err = call->ndr_push(push, NDR_OUT, r);
3676         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3677                 talloc_free(r);
3678                 return false;
3679         }
3680
3681         blob = ndr_push_blob(push);
3682         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3683                 talloc_free(r);
3684                 return false;
3685         }
3686
3687         talloc_free(r);
3688
3689         return true;
3690 }
3691
3692 static bool api_srvsvc_NETRDFSCREATEEXITPOINT(pipes_struct *p)
3693 {
3694         const struct ndr_interface_call *call;
3695         struct ndr_pull *pull;
3696         struct ndr_push *push;
3697         enum ndr_err_code ndr_err;
3698         DATA_BLOB blob;
3699         struct srvsvc_NETRDFSCREATEEXITPOINT *r;
3700
3701         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSCREATEEXITPOINT];
3702
3703         r = talloc(talloc_tos(), struct srvsvc_NETRDFSCREATEEXITPOINT);
3704         if (r == NULL) {
3705                 return false;
3706         }
3707
3708         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3709                 talloc_free(r);
3710                 return false;
3711         }
3712
3713         pull = ndr_pull_init_blob(&blob, r, NULL);
3714         if (pull == NULL) {
3715                 talloc_free(r);
3716                 return false;
3717         }
3718
3719         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3720         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3721         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3722                 talloc_free(r);
3723                 return false;
3724         }
3725
3726         if (DEBUGLEVEL >= 10) {
3727                 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSCREATEEXITPOINT, r);
3728         }
3729
3730         r->out.result = _srvsvc_NETRDFSCREATEEXITPOINT(p, r);
3731
3732         if (p->rng_fault_state) {
3733                 talloc_free(r);
3734                 /* Return true here, srv_pipe_hnd.c will take care */
3735                 return true;
3736         }
3737
3738         if (DEBUGLEVEL >= 10) {
3739                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSCREATEEXITPOINT, r);
3740         }
3741
3742         push = ndr_push_init_ctx(r, NULL);
3743         if (push == NULL) {
3744                 talloc_free(r);
3745                 return false;
3746         }
3747
3748         ndr_err = call->ndr_push(push, NDR_OUT, r);
3749         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3750                 talloc_free(r);
3751                 return false;
3752         }
3753
3754         blob = ndr_push_blob(push);
3755         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3756                 talloc_free(r);
3757                 return false;
3758         }
3759
3760         talloc_free(r);
3761
3762         return true;
3763 }
3764
3765 static bool api_srvsvc_NETRDFSDELETEEXITPOINT(pipes_struct *p)
3766 {
3767         const struct ndr_interface_call *call;
3768         struct ndr_pull *pull;
3769         struct ndr_push *push;
3770         enum ndr_err_code ndr_err;
3771         DATA_BLOB blob;
3772         struct srvsvc_NETRDFSDELETEEXITPOINT *r;
3773
3774         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSDELETEEXITPOINT];
3775
3776         r = talloc(talloc_tos(), struct srvsvc_NETRDFSDELETEEXITPOINT);
3777         if (r == NULL) {
3778                 return false;
3779         }
3780
3781         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3782                 talloc_free(r);
3783                 return false;
3784         }
3785
3786         pull = ndr_pull_init_blob(&blob, r, NULL);
3787         if (pull == NULL) {
3788                 talloc_free(r);
3789                 return false;
3790         }
3791
3792         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3793         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3794         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3795                 talloc_free(r);
3796                 return false;
3797         }
3798
3799         if (DEBUGLEVEL >= 10) {
3800                 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSDELETEEXITPOINT, r);
3801         }
3802
3803         r->out.result = _srvsvc_NETRDFSDELETEEXITPOINT(p, r);
3804
3805         if (p->rng_fault_state) {
3806                 talloc_free(r);
3807                 /* Return true here, srv_pipe_hnd.c will take care */
3808                 return true;
3809         }
3810
3811         if (DEBUGLEVEL >= 10) {
3812                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSDELETEEXITPOINT, r);
3813         }
3814
3815         push = ndr_push_init_ctx(r, NULL);
3816         if (push == NULL) {
3817                 talloc_free(r);
3818                 return false;
3819         }
3820
3821         ndr_err = call->ndr_push(push, NDR_OUT, r);
3822         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3823                 talloc_free(r);
3824                 return false;
3825         }
3826
3827         blob = ndr_push_blob(push);
3828         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3829                 talloc_free(r);
3830                 return false;
3831         }
3832
3833         talloc_free(r);
3834
3835         return true;
3836 }
3837
3838 static bool api_srvsvc_NETRDFSMODIFYPREFIX(pipes_struct *p)
3839 {
3840         const struct ndr_interface_call *call;
3841         struct ndr_pull *pull;
3842         struct ndr_push *push;
3843         enum ndr_err_code ndr_err;
3844         DATA_BLOB blob;
3845         struct srvsvc_NETRDFSMODIFYPREFIX *r;
3846
3847         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSMODIFYPREFIX];
3848
3849         r = talloc(talloc_tos(), struct srvsvc_NETRDFSMODIFYPREFIX);
3850         if (r == NULL) {
3851                 return false;
3852         }
3853
3854         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3855                 talloc_free(r);
3856                 return false;
3857         }
3858
3859         pull = ndr_pull_init_blob(&blob, r, NULL);
3860         if (pull == NULL) {
3861                 talloc_free(r);
3862                 return false;
3863         }
3864
3865         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3866         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3867         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3868                 talloc_free(r);
3869                 return false;
3870         }
3871
3872         if (DEBUGLEVEL >= 10) {
3873                 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSMODIFYPREFIX, r);
3874         }
3875
3876         r->out.result = _srvsvc_NETRDFSMODIFYPREFIX(p, r);
3877
3878         if (p->rng_fault_state) {
3879                 talloc_free(r);
3880                 /* Return true here, srv_pipe_hnd.c will take care */
3881                 return true;
3882         }
3883
3884         if (DEBUGLEVEL >= 10) {
3885                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSMODIFYPREFIX, r);
3886         }
3887
3888         push = ndr_push_init_ctx(r, NULL);
3889         if (push == NULL) {
3890                 talloc_free(r);
3891                 return false;
3892         }
3893
3894         ndr_err = call->ndr_push(push, NDR_OUT, r);
3895         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3896                 talloc_free(r);
3897                 return false;
3898         }
3899
3900         blob = ndr_push_blob(push);
3901         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3902                 talloc_free(r);
3903                 return false;
3904         }
3905
3906         talloc_free(r);
3907
3908         return true;
3909 }
3910
3911 static bool api_srvsvc_NETRDFSFIXLOCALVOLUME(pipes_struct *p)
3912 {
3913         const struct ndr_interface_call *call;
3914         struct ndr_pull *pull;
3915         struct ndr_push *push;
3916         enum ndr_err_code ndr_err;
3917         DATA_BLOB blob;
3918         struct srvsvc_NETRDFSFIXLOCALVOLUME *r;
3919
3920         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSFIXLOCALVOLUME];
3921
3922         r = talloc(talloc_tos(), struct srvsvc_NETRDFSFIXLOCALVOLUME);
3923         if (r == NULL) {
3924                 return false;
3925         }
3926
3927         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
3928                 talloc_free(r);
3929                 return false;
3930         }
3931
3932         pull = ndr_pull_init_blob(&blob, r, NULL);
3933         if (pull == NULL) {
3934                 talloc_free(r);
3935                 return false;
3936         }
3937
3938         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
3939         ndr_err = call->ndr_pull(pull, NDR_IN, r);
3940         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3941                 talloc_free(r);
3942                 return false;
3943         }
3944
3945         if (DEBUGLEVEL >= 10) {
3946                 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSFIXLOCALVOLUME, r);
3947         }
3948
3949         r->out.result = _srvsvc_NETRDFSFIXLOCALVOLUME(p, r);
3950
3951         if (p->rng_fault_state) {
3952                 talloc_free(r);
3953                 /* Return true here, srv_pipe_hnd.c will take care */
3954                 return true;
3955         }
3956
3957         if (DEBUGLEVEL >= 10) {
3958                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSFIXLOCALVOLUME, r);
3959         }
3960
3961         push = ndr_push_init_ctx(r, NULL);
3962         if (push == NULL) {
3963                 talloc_free(r);
3964                 return false;
3965         }
3966
3967         ndr_err = call->ndr_push(push, NDR_OUT, r);
3968         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
3969                 talloc_free(r);
3970                 return false;
3971         }
3972
3973         blob = ndr_push_blob(push);
3974         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
3975                 talloc_free(r);
3976                 return false;
3977         }
3978
3979         talloc_free(r);
3980
3981         return true;
3982 }
3983
3984 static bool api_srvsvc_NETRDFSMANAGERREPORTSITEINFO(pipes_struct *p)
3985 {
3986         const struct ndr_interface_call *call;
3987         struct ndr_pull *pull;
3988         struct ndr_push *push;
3989         enum ndr_err_code ndr_err;
3990         DATA_BLOB blob;
3991         struct srvsvc_NETRDFSMANAGERREPORTSITEINFO *r;
3992
3993         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRDFSMANAGERREPORTSITEINFO];
3994
3995         r = talloc(talloc_tos(), struct srvsvc_NETRDFSMANAGERREPORTSITEINFO);
3996         if (r == NULL) {
3997                 return false;
3998         }
3999
4000         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4001                 talloc_free(r);
4002                 return false;
4003         }
4004
4005         pull = ndr_pull_init_blob(&blob, r, NULL);
4006         if (pull == NULL) {
4007                 talloc_free(r);
4008                 return false;
4009         }
4010
4011         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4012         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4013         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4014                 talloc_free(r);
4015                 return false;
4016         }
4017
4018         if (DEBUGLEVEL >= 10) {
4019                 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSMANAGERREPORTSITEINFO, r);
4020         }
4021
4022         r->out.result = _srvsvc_NETRDFSMANAGERREPORTSITEINFO(p, r);
4023
4024         if (p->rng_fault_state) {
4025                 talloc_free(r);
4026                 /* Return true here, srv_pipe_hnd.c will take care */
4027                 return true;
4028         }
4029
4030         if (DEBUGLEVEL >= 10) {
4031                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSMANAGERREPORTSITEINFO, r);
4032         }
4033
4034         push = ndr_push_init_ctx(r, NULL);
4035         if (push == NULL) {
4036                 talloc_free(r);
4037                 return false;
4038         }
4039
4040         ndr_err = call->ndr_push(push, NDR_OUT, r);
4041         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4042                 talloc_free(r);
4043                 return false;
4044         }
4045
4046         blob = ndr_push_blob(push);
4047         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4048                 talloc_free(r);
4049                 return false;
4050         }
4051
4052         talloc_free(r);
4053
4054         return true;
4055 }
4056
4057 static bool api_srvsvc_NETRSERVERTRANSPORTDELEX(pipes_struct *p)
4058 {
4059         const struct ndr_interface_call *call;
4060         struct ndr_pull *pull;
4061         struct ndr_push *push;
4062         enum ndr_err_code ndr_err;
4063         DATA_BLOB blob;
4064         struct srvsvc_NETRSERVERTRANSPORTDELEX *r;
4065
4066         call = &ndr_table_srvsvc.calls[NDR_SRVSVC_NETRSERVERTRANSPORTDELEX];
4067
4068         r = talloc(talloc_tos(), struct srvsvc_NETRSERVERTRANSPORTDELEX);
4069         if (r == NULL) {
4070                 return false;
4071         }
4072
4073         if (!prs_data_blob(&p->in_data.data, &blob, r)) {
4074                 talloc_free(r);
4075                 return false;
4076         }
4077
4078         pull = ndr_pull_init_blob(&blob, r, NULL);
4079         if (pull == NULL) {
4080                 talloc_free(r);
4081                 return false;
4082         }
4083
4084         pull->flags |= LIBNDR_FLAG_REF_ALLOC;
4085         ndr_err = call->ndr_pull(pull, NDR_IN, r);
4086         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4087                 talloc_free(r);
4088                 return false;
4089         }
4090
4091         if (DEBUGLEVEL >= 10) {
4092                 NDR_PRINT_IN_DEBUG(srvsvc_NETRSERVERTRANSPORTDELEX, r);
4093         }
4094
4095         r->out.result = _srvsvc_NETRSERVERTRANSPORTDELEX(p, r);
4096
4097         if (p->rng_fault_state) {
4098                 talloc_free(r);
4099                 /* Return true here, srv_pipe_hnd.c will take care */
4100                 return true;
4101         }
4102
4103         if (DEBUGLEVEL >= 10) {
4104                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRSERVERTRANSPORTDELEX, r);
4105         }
4106
4107         push = ndr_push_init_ctx(r, NULL);
4108         if (push == NULL) {
4109                 talloc_free(r);
4110                 return false;
4111         }
4112
4113         ndr_err = call->ndr_push(push, NDR_OUT, r);
4114         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
4115                 talloc_free(r);
4116                 return false;
4117         }
4118
4119         blob = ndr_push_blob(push);
4120         if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
4121                 talloc_free(r);
4122                 return false;
4123         }
4124
4125         talloc_free(r);
4126
4127         return true;
4128 }
4129
4130
4131 /* Tables */
4132 static struct api_struct api_srvsvc_cmds[] =
4133 {
4134         {"SRVSVC_NETCHARDEVENUM", NDR_SRVSVC_NETCHARDEVENUM, api_srvsvc_NetCharDevEnum},
4135         {"SRVSVC_NETCHARDEVGETINFO", NDR_SRVSVC_NETCHARDEVGETINFO, api_srvsvc_NetCharDevGetInfo},
4136         {"SRVSVC_NETCHARDEVCONTROL", NDR_SRVSVC_NETCHARDEVCONTROL, api_srvsvc_NetCharDevControl},
4137         {"SRVSVC_NETCHARDEVQENUM", NDR_SRVSVC_NETCHARDEVQENUM, api_srvsvc_NetCharDevQEnum},
4138         {"SRVSVC_NETCHARDEVQGETINFO", NDR_SRVSVC_NETCHARDEVQGETINFO, api_srvsvc_NetCharDevQGetInfo},
4139         {"SRVSVC_NETCHARDEVQSETINFO", NDR_SRVSVC_NETCHARDEVQSETINFO, api_srvsvc_NetCharDevQSetInfo},
4140         {"SRVSVC_NETCHARDEVQPURGE", NDR_SRVSVC_NETCHARDEVQPURGE, api_srvsvc_NetCharDevQPurge},
4141         {"SRVSVC_NETCHARDEVQPURGESELF", NDR_SRVSVC_NETCHARDEVQPURGESELF, api_srvsvc_NetCharDevQPurgeSelf},
4142         {"SRVSVC_NETCONNENUM", NDR_SRVSVC_NETCONNENUM, api_srvsvc_NetConnEnum},
4143         {"SRVSVC_NETFILEENUM", NDR_SRVSVC_NETFILEENUM, api_srvsvc_NetFileEnum},
4144         {"SRVSVC_NETFILEGETINFO", NDR_SRVSVC_NETFILEGETINFO, api_srvsvc_NetFileGetInfo},
4145         {"SRVSVC_NETFILECLOSE", NDR_SRVSVC_NETFILECLOSE, api_srvsvc_NetFileClose},
4146         {"SRVSVC_NETSESSENUM", NDR_SRVSVC_NETSESSENUM, api_srvsvc_NetSessEnum},
4147         {"SRVSVC_NETSESSDEL", NDR_SRVSVC_NETSESSDEL, api_srvsvc_NetSessDel},
4148         {"SRVSVC_NETSHAREADD", NDR_SRVSVC_NETSHAREADD, api_srvsvc_NetShareAdd},
4149         {"SRVSVC_NETSHAREENUMALL", NDR_SRVSVC_NETSHAREENUMALL, api_srvsvc_NetShareEnumAll},
4150         {"SRVSVC_NETSHAREGETINFO", NDR_SRVSVC_NETSHAREGETINFO, api_srvsvc_NetShareGetInfo},
4151         {"SRVSVC_NETSHARESETINFO", NDR_SRVSVC_NETSHARESETINFO, api_srvsvc_NetShareSetInfo},
4152         {"SRVSVC_NETSHAREDEL", NDR_SRVSVC_NETSHAREDEL, api_srvsvc_NetShareDel},
4153         {"SRVSVC_NETSHAREDELSTICKY", NDR_SRVSVC_NETSHAREDELSTICKY, api_srvsvc_NetShareDelSticky},
4154         {"SRVSVC_NETSHARECHECK", NDR_SRVSVC_NETSHARECHECK, api_srvsvc_NetShareCheck},
4155         {"SRVSVC_NETSRVGETINFO", NDR_SRVSVC_NETSRVGETINFO, api_srvsvc_NetSrvGetInfo},
4156         {"SRVSVC_NETSRVSETINFO", NDR_SRVSVC_NETSRVSETINFO, api_srvsvc_NetSrvSetInfo},
4157         {"SRVSVC_NETDISKENUM", NDR_SRVSVC_NETDISKENUM, api_srvsvc_NetDiskEnum},
4158         {"SRVSVC_NETSERVERSTATISTICSGET", NDR_SRVSVC_NETSERVERSTATISTICSGET, api_srvsvc_NetServerStatisticsGet},
4159         {"SRVSVC_NETTRANSPORTADD", NDR_SRVSVC_NETTRANSPORTADD, api_srvsvc_NetTransportAdd},
4160         {"SRVSVC_NETTRANSPORTENUM", NDR_SRVSVC_NETTRANSPORTENUM, api_srvsvc_NetTransportEnum},
4161         {"SRVSVC_NETTRANSPORTDEL", NDR_SRVSVC_NETTRANSPORTDEL, api_srvsvc_NetTransportDel},
4162         {"SRVSVC_NETREMOTETOD", NDR_SRVSVC_NETREMOTETOD, api_srvsvc_NetRemoteTOD},
4163         {"SRVSVC_NETSETSERVICEBITS", NDR_SRVSVC_NETSETSERVICEBITS, api_srvsvc_NetSetServiceBits},
4164         {"SRVSVC_NETPATHTYPE", NDR_SRVSVC_NETPATHTYPE, api_srvsvc_NetPathType},
4165         {"SRVSVC_NETPATHCANONICALIZE", NDR_SRVSVC_NETPATHCANONICALIZE, api_srvsvc_NetPathCanonicalize},
4166         {"SRVSVC_NETPATHCOMPARE", NDR_SRVSVC_NETPATHCOMPARE, api_srvsvc_NetPathCompare},
4167         {"SRVSVC_NETNAMEVALIDATE", NDR_SRVSVC_NETNAMEVALIDATE, api_srvsvc_NetNameValidate},
4168         {"SRVSVC_NETRPRNAMECANONICALIZE", NDR_SRVSVC_NETRPRNAMECANONICALIZE, api_srvsvc_NETRPRNAMECANONICALIZE},
4169         {"SRVSVC_NETPRNAMECOMPARE", NDR_SRVSVC_NETPRNAMECOMPARE, api_srvsvc_NetPRNameCompare},
4170         {"SRVSVC_NETSHAREENUM", NDR_SRVSVC_NETSHAREENUM, api_srvsvc_NetShareEnum},
4171         {"SRVSVC_NETSHAREDELSTART", NDR_SRVSVC_NETSHAREDELSTART, api_srvsvc_NetShareDelStart},
4172         {"SRVSVC_NETSHAREDELCOMMIT", NDR_SRVSVC_NETSHAREDELCOMMIT, api_srvsvc_NetShareDelCommit},
4173         {"SRVSVC_NETGETFILESECURITY", NDR_SRVSVC_NETGETFILESECURITY, api_srvsvc_NetGetFileSecurity},
4174         {"SRVSVC_NETSETFILESECURITY", NDR_SRVSVC_NETSETFILESECURITY, api_srvsvc_NetSetFileSecurity},
4175         {"SRVSVC_NETSERVERTRANSPORTADDEX", NDR_SRVSVC_NETSERVERTRANSPORTADDEX, api_srvsvc_NetServerTransportAddEx},
4176         {"SRVSVC_NETSERVERSETSERVICEBITSEX", NDR_SRVSVC_NETSERVERSETSERVICEBITSEX, api_srvsvc_NetServerSetServiceBitsEx},
4177         {"SRVSVC_NETRDFSGETVERSION", NDR_SRVSVC_NETRDFSGETVERSION, api_srvsvc_NETRDFSGETVERSION},
4178         {"SRVSVC_NETRDFSCREATELOCALPARTITION", NDR_SRVSVC_NETRDFSCREATELOCALPARTITION, api_srvsvc_NETRDFSCREATELOCALPARTITION},
4179         {"SRVSVC_NETRDFSDELETELOCALPARTITION", NDR_SRVSVC_NETRDFSDELETELOCALPARTITION, api_srvsvc_NETRDFSDELETELOCALPARTITION},
4180         {"SRVSVC_NETRDFSSETLOCALVOLUMESTATE", NDR_SRVSVC_NETRDFSSETLOCALVOLUMESTATE, api_srvsvc_NETRDFSSETLOCALVOLUMESTATE},
4181         {"SRVSVC_NETRDFSSETSERVERINFO", NDR_SRVSVC_NETRDFSSETSERVERINFO, api_srvsvc_NETRDFSSETSERVERINFO},
4182         {"SRVSVC_NETRDFSCREATEEXITPOINT", NDR_SRVSVC_NETRDFSCREATEEXITPOINT, api_srvsvc_NETRDFSCREATEEXITPOINT},
4183         {"SRVSVC_NETRDFSDELETEEXITPOINT", NDR_SRVSVC_NETRDFSDELETEEXITPOINT, api_srvsvc_NETRDFSDELETEEXITPOINT},
4184         {"SRVSVC_NETRDFSMODIFYPREFIX", NDR_SRVSVC_NETRDFSMODIFYPREFIX, api_srvsvc_NETRDFSMODIFYPREFIX},
4185         {"SRVSVC_NETRDFSFIXLOCALVOLUME", NDR_SRVSVC_NETRDFSFIXLOCALVOLUME, api_srvsvc_NETRDFSFIXLOCALVOLUME},
4186         {"SRVSVC_NETRDFSMANAGERREPORTSITEINFO", NDR_SRVSVC_NETRDFSMANAGERREPORTSITEINFO, api_srvsvc_NETRDFSMANAGERREPORTSITEINFO},
4187         {"SRVSVC_NETRSERVERTRANSPORTDELEX", NDR_SRVSVC_NETRSERVERTRANSPORTDELEX, api_srvsvc_NETRSERVERTRANSPORTDELEX},
4188 };
4189
4190 void srvsvc_get_pipe_fns(struct api_struct **fns, int *n_fns)
4191 {
4192         *fns = api_srvsvc_cmds;
4193         *n_fns = sizeof(api_srvsvc_cmds) / sizeof(struct api_struct);
4194 }
4195
4196 NTSTATUS rpc_srvsvc_init(void)
4197 {
4198         return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "srvsvc", "srvsvc", &ndr_table_srvsvc.syntax_id, api_srvsvc_cmds, sizeof(api_srvsvc_cmds) / sizeof(struct api_struct));
4199 }