librpc/gen_ndr/srv_srvsvc.c

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