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