source/librpc/gen_ndr/cli_srvsvc.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * client auto-generated by pidl. DO NOT MODIFY!
   4  */
   5
   6 #include "includes.h"
   7 #include "librpc/gen_ndr/cli_srvsvc.h"
   8
   9 NTSTATUS rpccli_srvsvc_NetCharDevEnum(struct rpc_pipe_client *cli,
  10                                       TALLOC_CTX *mem_ctx,
  11                                       const char *server_unc,
  12                                       uint32_t *level,
  13                                       union srvsvc_NetCharDevCtr *ctr,
  14                                       uint32_t max_buffer,
  15                                       uint32_t *totalentries,
  16                                       uint32_t *resume_handle,
  17                                       WERROR *werror)
  18 {
  19         struct srvsvc_NetCharDevEnum r;
  20         NTSTATUS status;
  21
  22         /* In parameters */
  23         r.in.server_unc = server_unc;
  24         r.in.level = level;
  25         r.in.ctr = ctr;
  26         r.in.max_buffer = max_buffer;
  27         r.in.resume_handle = resume_handle;
  28
  29         if (DEBUGLEVEL >= 10) {
  30                 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevEnum, &r);
  31         }
  32
  33         status = cli_do_rpc_ndr(cli,
  34                                 mem_ctx,
  35                                 PI_SRVSVC,
  36                                 &ndr_table_srvsvc,
  37                                 NDR_SRVSVC_NETCHARDEVENUM,
  38                                 &r);
  39
  40         if (!NT_STATUS_IS_OK(status)) {
  41                 return status;
  42         }
  43
  44         if (DEBUGLEVEL >= 10) {
  45                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevEnum, &r);
  46         }
  47
  48         if (NT_STATUS_IS_ERR(status)) {
  49                 return status;
  50         }
  51
  52         /* Return variables */
  53         *level = *r.out.level;
  54         *ctr = *r.out.ctr;
  55         *totalentries = *r.out.totalentries;
  56         if (resume_handle && r.out.resume_handle) {
  57                 *resume_handle = *r.out.resume_handle;
  58         }
  59
  60         /* Return result */
  61         if (werror) {
  62                 *werror = r.out.result;
  63         }
  64
  65         return werror_to_ntstatus(r.out.result);
  66 }
  67
  68 NTSTATUS rpccli_srvsvc_NetCharDevGetInfo(struct rpc_pipe_client *cli,
  69                                          TALLOC_CTX *mem_ctx,
  70                                          const char *server_unc,
  71                                          const char *device_name,
  72                                          uint32_t level,
  73                                          union srvsvc_NetCharDevInfo *info,
  74                                          WERROR *werror)
  75 {
  76         struct srvsvc_NetCharDevGetInfo r;
  77         NTSTATUS status;
  78
  79         /* In parameters */
  80         r.in.server_unc = server_unc;
  81         r.in.device_name = device_name;
  82         r.in.level = level;
  83
  84         if (DEBUGLEVEL >= 10) {
  85                 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevGetInfo, &r);
  86         }
  87
  88         status = cli_do_rpc_ndr(cli,
  89                                 mem_ctx,
  90                                 PI_SRVSVC,
  91                                 &ndr_table_srvsvc,
  92                                 NDR_SRVSVC_NETCHARDEVGETINFO,
  93                                 &r);
  94
  95         if (!NT_STATUS_IS_OK(status)) {
  96                 return status;
  97         }
  98
  99         if (DEBUGLEVEL >= 10) {
 100                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevGetInfo, &r);
 101         }
 102
 103         if (NT_STATUS_IS_ERR(status)) {
 104                 return status;
 105         }
 106
 107         /* Return variables */
 108         *info = *r.out.info;
 109
 110         /* Return result */
 111         if (werror) {
 112                 *werror = r.out.result;
 113         }
 114
 115         return werror_to_ntstatus(r.out.result);
 116 }
 117
 118 NTSTATUS rpccli_srvsvc_NetCharDevControl(struct rpc_pipe_client *cli,
 119                                          TALLOC_CTX *mem_ctx,
 120                                          const char *server_unc,
 121                                          const char *device_name,
 122                                          uint32_t opcode,
 123                                          WERROR *werror)
 124 {
 125         struct srvsvc_NetCharDevControl r;
 126         NTSTATUS status;
 127
 128         /* In parameters */
 129         r.in.server_unc = server_unc;
 130         r.in.device_name = device_name;
 131         r.in.opcode = opcode;
 132
 133         if (DEBUGLEVEL >= 10) {
 134                 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevControl, &r);
 135         }
 136
 137         status = cli_do_rpc_ndr(cli,
 138                                 mem_ctx,
 139                                 PI_SRVSVC,
 140                                 &ndr_table_srvsvc,
 141                                 NDR_SRVSVC_NETCHARDEVCONTROL,
 142                                 &r);
 143
 144         if (!NT_STATUS_IS_OK(status)) {
 145                 return status;
 146         }
 147
 148         if (DEBUGLEVEL >= 10) {
 149                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevControl, &r);
 150         }
 151
 152         if (NT_STATUS_IS_ERR(status)) {
 153                 return status;
 154         }
 155
 156         /* Return variables */
 157
 158         /* Return result */
 159         if (werror) {
 160                 *werror = r.out.result;
 161         }
 162
 163         return werror_to_ntstatus(r.out.result);
 164 }
 165
 166 NTSTATUS rpccli_srvsvc_NetCharDevQEnum(struct rpc_pipe_client *cli,
 167                                        TALLOC_CTX *mem_ctx,
 168                                        const char *server_unc,
 169                                        const char *user,
 170                                        uint32_t *level,
 171                                        union srvsvc_NetCharDevQCtr *ctr,
 172                                        uint32_t max_buffer,
 173                                        uint32_t *totalentries,
 174                                        uint32_t *resume_handle,
 175                                        WERROR *werror)
 176 {
 177         struct srvsvc_NetCharDevQEnum r;
 178         NTSTATUS status;
 179
 180         /* In parameters */
 181         r.in.server_unc = server_unc;
 182         r.in.user = user;
 183         r.in.level = level;
 184         r.in.ctr = ctr;
 185         r.in.max_buffer = max_buffer;
 186         r.in.resume_handle = resume_handle;
 187
 188         if (DEBUGLEVEL >= 10) {
 189                 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQEnum, &r);
 190         }
 191
 192         status = cli_do_rpc_ndr(cli,
 193                                 mem_ctx,
 194                                 PI_SRVSVC,
 195                                 &ndr_table_srvsvc,
 196                                 NDR_SRVSVC_NETCHARDEVQENUM,
 197                                 &r);
 198
 199         if (!NT_STATUS_IS_OK(status)) {
 200                 return status;
 201         }
 202
 203         if (DEBUGLEVEL >= 10) {
 204                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQEnum, &r);
 205         }
 206
 207         if (NT_STATUS_IS_ERR(status)) {
 208                 return status;
 209         }
 210
 211         /* Return variables */
 212         *level = *r.out.level;
 213         *ctr = *r.out.ctr;
 214         *totalentries = *r.out.totalentries;
 215         if (resume_handle && r.out.resume_handle) {
 216                 *resume_handle = *r.out.resume_handle;
 217         }
 218
 219         /* Return result */
 220         if (werror) {
 221                 *werror = r.out.result;
 222         }
 223
 224         return werror_to_ntstatus(r.out.result);
 225 }
 226
 227 NTSTATUS rpccli_srvsvc_NetCharDevQGetInfo(struct rpc_pipe_client *cli,
 228                                           TALLOC_CTX *mem_ctx,
 229                                           const char *server_unc,
 230                                           const char *queue_name,
 231                                           const char *user,
 232                                           uint32_t level,
 233                                           union srvsvc_NetCharDevQInfo *info,
 234                                           WERROR *werror)
 235 {
 236         struct srvsvc_NetCharDevQGetInfo r;
 237         NTSTATUS status;
 238
 239         /* In parameters */
 240         r.in.server_unc = server_unc;
 241         r.in.queue_name = queue_name;
 242         r.in.user = user;
 243         r.in.level = level;
 244
 245         if (DEBUGLEVEL >= 10) {
 246                 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQGetInfo, &r);
 247         }
 248
 249         status = cli_do_rpc_ndr(cli,
 250                                 mem_ctx,
 251                                 PI_SRVSVC,
 252                                 &ndr_table_srvsvc,
 253                                 NDR_SRVSVC_NETCHARDEVQGETINFO,
 254                                 &r);
 255
 256         if (!NT_STATUS_IS_OK(status)) {
 257                 return status;
 258         }
 259
 260         if (DEBUGLEVEL >= 10) {
 261                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQGetInfo, &r);
 262         }
 263
 264         if (NT_STATUS_IS_ERR(status)) {
 265                 return status;
 266         }
 267
 268         /* Return variables */
 269         *info = *r.out.info;
 270
 271         /* Return result */
 272         if (werror) {
 273                 *werror = r.out.result;
 274         }
 275
 276         return werror_to_ntstatus(r.out.result);
 277 }
 278
 279 NTSTATUS rpccli_srvsvc_NetCharDevQSetInfo(struct rpc_pipe_client *cli,
 280                                           TALLOC_CTX *mem_ctx,
 281                                           const char *server_unc,
 282                                           const char *queue_name,
 283                                           uint32_t level,
 284                                           union srvsvc_NetCharDevQInfo info,
 285                                           uint32_t *parm_error,
 286                                           WERROR *werror)
 287 {
 288         struct srvsvc_NetCharDevQSetInfo r;
 289         NTSTATUS status;
 290
 291         /* In parameters */
 292         r.in.server_unc = server_unc;
 293         r.in.queue_name = queue_name;
 294         r.in.level = level;
 295         r.in.info = info;
 296         r.in.parm_error = parm_error;
 297
 298         if (DEBUGLEVEL >= 10) {
 299                 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQSetInfo, &r);
 300         }
 301
 302         status = cli_do_rpc_ndr(cli,
 303                                 mem_ctx,
 304                                 PI_SRVSVC,
 305                                 &ndr_table_srvsvc,
 306                                 NDR_SRVSVC_NETCHARDEVQSETINFO,
 307                                 &r);
 308
 309         if (!NT_STATUS_IS_OK(status)) {
 310                 return status;
 311         }
 312
 313         if (DEBUGLEVEL >= 10) {
 314                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQSetInfo, &r);
 315         }
 316
 317         if (NT_STATUS_IS_ERR(status)) {
 318                 return status;
 319         }
 320
 321         /* Return variables */
 322         if (parm_error && r.out.parm_error) {
 323                 *parm_error = *r.out.parm_error;
 324         }
 325
 326         /* Return result */
 327         if (werror) {
 328                 *werror = r.out.result;
 329         }
 330
 331         return werror_to_ntstatus(r.out.result);
 332 }
 333
 334 NTSTATUS rpccli_srvsvc_NetCharDevQPurge(struct rpc_pipe_client *cli,
 335                                         TALLOC_CTX *mem_ctx,
 336                                         const char *server_unc,
 337                                         const char *queue_name,
 338                                         WERROR *werror)
 339 {
 340         struct srvsvc_NetCharDevQPurge r;
 341         NTSTATUS status;
 342
 343         /* In parameters */
 344         r.in.server_unc = server_unc;
 345         r.in.queue_name = queue_name;
 346
 347         if (DEBUGLEVEL >= 10) {
 348                 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQPurge, &r);
 349         }
 350
 351         status = cli_do_rpc_ndr(cli,
 352                                 mem_ctx,
 353                                 PI_SRVSVC,
 354                                 &ndr_table_srvsvc,
 355                                 NDR_SRVSVC_NETCHARDEVQPURGE,
 356                                 &r);
 357
 358         if (!NT_STATUS_IS_OK(status)) {
 359                 return status;
 360         }
 361
 362         if (DEBUGLEVEL >= 10) {
 363                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQPurge, &r);
 364         }
 365
 366         if (NT_STATUS_IS_ERR(status)) {
 367                 return status;
 368         }
 369
 370         /* Return variables */
 371
 372         /* Return result */
 373         if (werror) {
 374                 *werror = r.out.result;
 375         }
 376
 377         return werror_to_ntstatus(r.out.result);
 378 }
 379
 380 NTSTATUS rpccli_srvsvc_NetCharDevQPurgeSelf(struct rpc_pipe_client *cli,
 381                                             TALLOC_CTX *mem_ctx,
 382                                             const char *server_unc,
 383                                             const char *queue_name,
 384                                             const char *computer_name,
 385                                             WERROR *werror)
 386 {
 387         struct srvsvc_NetCharDevQPurgeSelf r;
 388         NTSTATUS status;
 389
 390         /* In parameters */
 391         r.in.server_unc = server_unc;
 392         r.in.queue_name = queue_name;
 393         r.in.computer_name = computer_name;
 394
 395         if (DEBUGLEVEL >= 10) {
 396                 NDR_PRINT_IN_DEBUG(srvsvc_NetCharDevQPurgeSelf, &r);
 397         }
 398
 399         status = cli_do_rpc_ndr(cli,
 400                                 mem_ctx,
 401                                 PI_SRVSVC,
 402                                 &ndr_table_srvsvc,
 403                                 NDR_SRVSVC_NETCHARDEVQPURGESELF,
 404                                 &r);
 405
 406         if (!NT_STATUS_IS_OK(status)) {
 407                 return status;
 408         }
 409
 410         if (DEBUGLEVEL >= 10) {
 411                 NDR_PRINT_OUT_DEBUG(srvsvc_NetCharDevQPurgeSelf, &r);
 412         }
 413
 414         if (NT_STATUS_IS_ERR(status)) {
 415                 return status;
 416         }
 417
 418         /* Return variables */
 419
 420         /* Return result */
 421         if (werror) {
 422                 *werror = r.out.result;
 423         }
 424
 425         return werror_to_ntstatus(r.out.result);
 426 }
 427
 428 NTSTATUS rpccli_srvsvc_NetConnEnum(struct rpc_pipe_client *cli,
 429                                    TALLOC_CTX *mem_ctx,
 430                                    const char *server_unc,
 431                                    const char *path,
 432                                    uint32_t *level,
 433                                    union srvsvc_NetConnCtr *ctr,
 434                                    uint32_t max_buffer,
 435                                    uint32_t *totalentries,
 436                                    uint32_t *resume_handle,
 437                                    WERROR *werror)
 438 {
 439         struct srvsvc_NetConnEnum r;
 440         NTSTATUS status;
 441
 442         /* In parameters */
 443         r.in.server_unc = server_unc;
 444         r.in.path = path;
 445         r.in.level = level;
 446         r.in.ctr = ctr;
 447         r.in.max_buffer = max_buffer;
 448         r.in.resume_handle = resume_handle;
 449
 450         if (DEBUGLEVEL >= 10) {
 451                 NDR_PRINT_IN_DEBUG(srvsvc_NetConnEnum, &r);
 452         }
 453
 454         status = cli_do_rpc_ndr(cli,
 455                                 mem_ctx,
 456                                 PI_SRVSVC,
 457                                 &ndr_table_srvsvc,
 458                                 NDR_SRVSVC_NETCONNENUM,
 459                                 &r);
 460
 461         if (!NT_STATUS_IS_OK(status)) {
 462                 return status;
 463         }
 464
 465         if (DEBUGLEVEL >= 10) {
 466                 NDR_PRINT_OUT_DEBUG(srvsvc_NetConnEnum, &r);
 467         }
 468
 469         if (NT_STATUS_IS_ERR(status)) {
 470                 return status;
 471         }
 472
 473         /* Return variables */
 474         *level = *r.out.level;
 475         *ctr = *r.out.ctr;
 476         *totalentries = *r.out.totalentries;
 477         if (resume_handle && r.out.resume_handle) {
 478                 *resume_handle = *r.out.resume_handle;
 479         }
 480
 481         /* Return result */
 482         if (werror) {
 483                 *werror = r.out.result;
 484         }
 485
 486         return werror_to_ntstatus(r.out.result);
 487 }
 488
 489 NTSTATUS rpccli_srvsvc_NetFileEnum(struct rpc_pipe_client *cli,
 490                                    TALLOC_CTX *mem_ctx,
 491                                    const char *server_unc,
 492                                    const char *path,
 493                                    const char *user,
 494                                    uint32_t *level,
 495                                    union srvsvc_NetFileCtr *ctr,
 496                                    uint32_t max_buffer,
 497                                    uint32_t *totalentries,
 498                                    uint32_t *resume_handle,
 499                                    WERROR *werror)
 500 {
 501         struct srvsvc_NetFileEnum r;
 502         NTSTATUS status;
 503
 504         /* In parameters */
 505         r.in.server_unc = server_unc;
 506         r.in.path = path;
 507         r.in.user = user;
 508         r.in.level = level;
 509         r.in.ctr = ctr;
 510         r.in.max_buffer = max_buffer;
 511         r.in.resume_handle = resume_handle;
 512
 513         if (DEBUGLEVEL >= 10) {
 514                 NDR_PRINT_IN_DEBUG(srvsvc_NetFileEnum, &r);
 515         }
 516
 517         status = cli_do_rpc_ndr(cli,
 518                                 mem_ctx,
 519                                 PI_SRVSVC,
 520                                 &ndr_table_srvsvc,
 521                                 NDR_SRVSVC_NETFILEENUM,
 522                                 &r);
 523
 524         if (!NT_STATUS_IS_OK(status)) {
 525                 return status;
 526         }
 527
 528         if (DEBUGLEVEL >= 10) {
 529                 NDR_PRINT_OUT_DEBUG(srvsvc_NetFileEnum, &r);
 530         }
 531
 532         if (NT_STATUS_IS_ERR(status)) {
 533                 return status;
 534         }
 535
 536         /* Return variables */
 537         *level = *r.out.level;
 538         *ctr = *r.out.ctr;
 539         *totalentries = *r.out.totalentries;
 540         if (resume_handle && r.out.resume_handle) {
 541                 *resume_handle = *r.out.resume_handle;
 542         }
 543
 544         /* Return result */
 545         if (werror) {
 546                 *werror = r.out.result;
 547         }
 548
 549         return werror_to_ntstatus(r.out.result);
 550 }
 551
 552 NTSTATUS rpccli_srvsvc_NetFileGetInfo(struct rpc_pipe_client *cli,
 553                                       TALLOC_CTX *mem_ctx,
 554                                       const char *server_unc,
 555                                       uint32_t fid,
 556                                       uint32_t level,
 557                                       union srvsvc_NetFileInfo *info,
 558                                       WERROR *werror)
 559 {
 560         struct srvsvc_NetFileGetInfo r;
 561         NTSTATUS status;
 562
 563         /* In parameters */
 564         r.in.server_unc = server_unc;
 565         r.in.fid = fid;
 566         r.in.level = level;
 567
 568         if (DEBUGLEVEL >= 10) {
 569                 NDR_PRINT_IN_DEBUG(srvsvc_NetFileGetInfo, &r);
 570         }
 571
 572         status = cli_do_rpc_ndr(cli,
 573                                 mem_ctx,
 574                                 PI_SRVSVC,
 575                                 &ndr_table_srvsvc,
 576                                 NDR_SRVSVC_NETFILEGETINFO,
 577                                 &r);
 578
 579         if (!NT_STATUS_IS_OK(status)) {
 580                 return status;
 581         }
 582
 583         if (DEBUGLEVEL >= 10) {
 584                 NDR_PRINT_OUT_DEBUG(srvsvc_NetFileGetInfo, &r);
 585         }
 586
 587         if (NT_STATUS_IS_ERR(status)) {
 588                 return status;
 589         }
 590
 591         /* Return variables */
 592         *info = *r.out.info;
 593
 594         /* Return result */
 595         if (werror) {
 596                 *werror = r.out.result;
 597         }
 598
 599         return werror_to_ntstatus(r.out.result);
 600 }
 601
 602 NTSTATUS rpccli_srvsvc_NetFileClose(struct rpc_pipe_client *cli,
 603                                     TALLOC_CTX *mem_ctx,
 604                                     const char *server_unc,
 605                                     uint32_t fid,
 606                                     WERROR *werror)
 607 {
 608         struct srvsvc_NetFileClose r;
 609         NTSTATUS status;
 610
 611         /* In parameters */
 612         r.in.server_unc = server_unc;
 613         r.in.fid = fid;
 614
 615         if (DEBUGLEVEL >= 10) {
 616                 NDR_PRINT_IN_DEBUG(srvsvc_NetFileClose, &r);
 617         }
 618
 619         status = cli_do_rpc_ndr(cli,
 620                                 mem_ctx,
 621                                 PI_SRVSVC,
 622                                 &ndr_table_srvsvc,
 623                                 NDR_SRVSVC_NETFILECLOSE,
 624                                 &r);
 625
 626         if (!NT_STATUS_IS_OK(status)) {
 627                 return status;
 628         }
 629
 630         if (DEBUGLEVEL >= 10) {
 631                 NDR_PRINT_OUT_DEBUG(srvsvc_NetFileClose, &r);
 632         }
 633
 634         if (NT_STATUS_IS_ERR(status)) {
 635                 return status;
 636         }
 637
 638         /* Return variables */
 639
 640         /* Return result */
 641         if (werror) {
 642                 *werror = r.out.result;
 643         }
 644
 645         return werror_to_ntstatus(r.out.result);
 646 }
 647
 648 NTSTATUS rpccli_srvsvc_NetSessEnum(struct rpc_pipe_client *cli,
 649                                    TALLOC_CTX *mem_ctx,
 650                                    const char *server_unc,
 651                                    const char *client,
 652                                    const char *user,
 653                                    uint32_t *level,
 654                                    union srvsvc_NetSessCtr *ctr,
 655                                    uint32_t max_buffer,
 656                                    uint32_t *totalentries,
 657                                    uint32_t *resume_handle,
 658                                    WERROR *werror)
 659 {
 660         struct srvsvc_NetSessEnum r;
 661         NTSTATUS status;
 662
 663         /* In parameters */
 664         r.in.server_unc = server_unc;
 665         r.in.client = client;
 666         r.in.user = user;
 667         r.in.level = level;
 668         r.in.ctr = ctr;
 669         r.in.max_buffer = max_buffer;
 670         r.in.resume_handle = resume_handle;
 671
 672         if (DEBUGLEVEL >= 10) {
 673                 NDR_PRINT_IN_DEBUG(srvsvc_NetSessEnum, &r);
 674         }
 675
 676         status = cli_do_rpc_ndr(cli,
 677                                 mem_ctx,
 678                                 PI_SRVSVC,
 679                                 &ndr_table_srvsvc,
 680                                 NDR_SRVSVC_NETSESSENUM,
 681                                 &r);
 682
 683         if (!NT_STATUS_IS_OK(status)) {
 684                 return status;
 685         }
 686
 687         if (DEBUGLEVEL >= 10) {
 688                 NDR_PRINT_OUT_DEBUG(srvsvc_NetSessEnum, &r);
 689         }
 690
 691         if (NT_STATUS_IS_ERR(status)) {
 692                 return status;
 693         }
 694
 695         /* Return variables */
 696         *level = *r.out.level;
 697         *ctr = *r.out.ctr;
 698         *totalentries = *r.out.totalentries;
 699         if (resume_handle && r.out.resume_handle) {
 700                 *resume_handle = *r.out.resume_handle;
 701         }
 702
 703         /* Return result */
 704         if (werror) {
 705                 *werror = r.out.result;
 706         }
 707
 708         return werror_to_ntstatus(r.out.result);
 709 }
 710
 711 NTSTATUS rpccli_srvsvc_NetSessDel(struct rpc_pipe_client *cli,
 712                                   TALLOC_CTX *mem_ctx,
 713                                   const char *server_unc,
 714                                   const char *client,
 715                                   const char *user,
 716                                   WERROR *werror)
 717 {
 718         struct srvsvc_NetSessDel r;
 719         NTSTATUS status;
 720
 721         /* In parameters */
 722         r.in.server_unc = server_unc;
 723         r.in.client = client;
 724         r.in.user = user;
 725
 726         if (DEBUGLEVEL >= 10) {
 727                 NDR_PRINT_IN_DEBUG(srvsvc_NetSessDel, &r);
 728         }
 729
 730         status = cli_do_rpc_ndr(cli,
 731                                 mem_ctx,
 732                                 PI_SRVSVC,
 733                                 &ndr_table_srvsvc,
 734                                 NDR_SRVSVC_NETSESSDEL,
 735                                 &r);
 736
 737         if (!NT_STATUS_IS_OK(status)) {
 738                 return status;
 739         }
 740
 741         if (DEBUGLEVEL >= 10) {
 742                 NDR_PRINT_OUT_DEBUG(srvsvc_NetSessDel, &r);
 743         }
 744
 745         if (NT_STATUS_IS_ERR(status)) {
 746                 return status;
 747         }
 748
 749         /* Return variables */
 750
 751         /* Return result */
 752         if (werror) {
 753                 *werror = r.out.result;
 754         }
 755
 756         return werror_to_ntstatus(r.out.result);
 757 }
 758
 759 NTSTATUS rpccli_srvsvc_NetShareAdd(struct rpc_pipe_client *cli,
 760                                    TALLOC_CTX *mem_ctx,
 761                                    const char *server_unc,
 762                                    uint32_t level,
 763                                    union srvsvc_NetShareInfo *info,
 764                                    uint32_t *parm_error,
 765                                    WERROR *werror)
 766 {
 767         struct srvsvc_NetShareAdd r;
 768         NTSTATUS status;
 769
 770         /* In parameters */
 771         r.in.server_unc = server_unc;
 772         r.in.level = level;
 773         r.in.info = info;
 774         r.in.parm_error = parm_error;
 775
 776         if (DEBUGLEVEL >= 10) {
 777                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareAdd, &r);
 778         }
 779
 780         status = cli_do_rpc_ndr(cli,
 781                                 mem_ctx,
 782                                 PI_SRVSVC,
 783                                 &ndr_table_srvsvc,
 784                                 NDR_SRVSVC_NETSHAREADD,
 785                                 &r);
 786
 787         if (!NT_STATUS_IS_OK(status)) {
 788                 return status;
 789         }
 790
 791         if (DEBUGLEVEL >= 10) {
 792                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareAdd, &r);
 793         }
 794
 795         if (NT_STATUS_IS_ERR(status)) {
 796                 return status;
 797         }
 798
 799         /* Return variables */
 800         if (parm_error && r.out.parm_error) {
 801                 *parm_error = *r.out.parm_error;
 802         }
 803
 804         /* Return result */
 805         if (werror) {
 806                 *werror = r.out.result;
 807         }
 808
 809         return werror_to_ntstatus(r.out.result);
 810 }
 811
 812 NTSTATUS rpccli_srvsvc_NetShareEnumAll(struct rpc_pipe_client *cli,
 813                                        TALLOC_CTX *mem_ctx,
 814                                        const char *server_unc,
 815                                        struct srvsvc_NetShareInfoCtr *info_ctr,
 816                                        uint32_t max_buffer,
 817                                        uint32_t *totalentries,
 818                                        uint32_t *resume_handle,
 819                                        WERROR *werror)
 820 {
 821         struct srvsvc_NetShareEnumAll r;
 822         NTSTATUS status;
 823
 824         /* In parameters */
 825         r.in.server_unc = server_unc;
 826         r.in.info_ctr = info_ctr;
 827         r.in.max_buffer = max_buffer;
 828         r.in.resume_handle = resume_handle;
 829
 830         if (DEBUGLEVEL >= 10) {
 831                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareEnumAll, &r);
 832         }
 833
 834         status = cli_do_rpc_ndr(cli,
 835                                 mem_ctx,
 836                                 PI_SRVSVC,
 837                                 &ndr_table_srvsvc,
 838                                 NDR_SRVSVC_NETSHAREENUMALL,
 839                                 &r);
 840
 841         if (!NT_STATUS_IS_OK(status)) {
 842                 return status;
 843         }
 844
 845         if (DEBUGLEVEL >= 10) {
 846                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareEnumAll, &r);
 847         }
 848
 849         if (NT_STATUS_IS_ERR(status)) {
 850                 return status;
 851         }
 852
 853         /* Return variables */
 854         *info_ctr = *r.out.info_ctr;
 855         *totalentries = *r.out.totalentries;
 856         if (resume_handle && r.out.resume_handle) {
 857                 *resume_handle = *r.out.resume_handle;
 858         }
 859
 860         /* Return result */
 861         if (werror) {
 862                 *werror = r.out.result;
 863         }
 864
 865         return werror_to_ntstatus(r.out.result);
 866 }
 867
 868 NTSTATUS rpccli_srvsvc_NetShareGetInfo(struct rpc_pipe_client *cli,
 869                                        TALLOC_CTX *mem_ctx,
 870                                        const char *server_unc,
 871                                        const char *share_name,
 872                                        uint32_t level,
 873                                        union srvsvc_NetShareInfo *info,
 874                                        WERROR *werror)
 875 {
 876         struct srvsvc_NetShareGetInfo r;
 877         NTSTATUS status;
 878
 879         /* In parameters */
 880         r.in.server_unc = server_unc;
 881         r.in.share_name = share_name;
 882         r.in.level = level;
 883
 884         if (DEBUGLEVEL >= 10) {
 885                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareGetInfo, &r);
 886         }
 887
 888         status = cli_do_rpc_ndr(cli,
 889                                 mem_ctx,
 890                                 PI_SRVSVC,
 891                                 &ndr_table_srvsvc,
 892                                 NDR_SRVSVC_NETSHAREGETINFO,
 893                                 &r);
 894
 895         if (!NT_STATUS_IS_OK(status)) {
 896                 return status;
 897         }
 898
 899         if (DEBUGLEVEL >= 10) {
 900                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareGetInfo, &r);
 901         }
 902
 903         if (NT_STATUS_IS_ERR(status)) {
 904                 return status;
 905         }
 906
 907         /* Return variables */
 908         *info = *r.out.info;
 909
 910         /* Return result */
 911         if (werror) {
 912                 *werror = r.out.result;
 913         }
 914
 915         return werror_to_ntstatus(r.out.result);
 916 }
 917
 918 NTSTATUS rpccli_srvsvc_NetShareSetInfo(struct rpc_pipe_client *cli,
 919                                        TALLOC_CTX *mem_ctx,
 920                                        const char *server_unc,
 921                                        const char *share_name,
 922                                        uint32_t level,
 923                                        union srvsvc_NetShareInfo *info,
 924                                        uint32_t *parm_error,
 925                                        WERROR *werror)
 926 {
 927         struct srvsvc_NetShareSetInfo r;
 928         NTSTATUS status;
 929
 930         /* In parameters */
 931         r.in.server_unc = server_unc;
 932         r.in.share_name = share_name;
 933         r.in.level = level;
 934         r.in.info = info;
 935         r.in.parm_error = parm_error;
 936
 937         if (DEBUGLEVEL >= 10) {
 938                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareSetInfo, &r);
 939         }
 940
 941         status = cli_do_rpc_ndr(cli,
 942                                 mem_ctx,
 943                                 PI_SRVSVC,
 944                                 &ndr_table_srvsvc,
 945                                 NDR_SRVSVC_NETSHARESETINFO,
 946                                 &r);
 947
 948         if (!NT_STATUS_IS_OK(status)) {
 949                 return status;
 950         }
 951
 952         if (DEBUGLEVEL >= 10) {
 953                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareSetInfo, &r);
 954         }
 955
 956         if (NT_STATUS_IS_ERR(status)) {
 957                 return status;
 958         }
 959
 960         /* Return variables */
 961         if (parm_error && r.out.parm_error) {
 962                 *parm_error = *r.out.parm_error;
 963         }
 964
 965         /* Return result */
 966         if (werror) {
 967                 *werror = r.out.result;
 968         }
 969
 970         return werror_to_ntstatus(r.out.result);
 971 }
 972
 973 NTSTATUS rpccli_srvsvc_NetShareDel(struct rpc_pipe_client *cli,
 974                                    TALLOC_CTX *mem_ctx,
 975                                    const char *server_unc,
 976                                    const char *share_name,
 977                                    uint32_t reserved,
 978                                    WERROR *werror)
 979 {
 980         struct srvsvc_NetShareDel r;
 981         NTSTATUS status;
 982
 983         /* In parameters */
 984         r.in.server_unc = server_unc;
 985         r.in.share_name = share_name;
 986         r.in.reserved = reserved;
 987
 988         if (DEBUGLEVEL >= 10) {
 989                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareDel, &r);
 990         }
 991
 992         status = cli_do_rpc_ndr(cli,
 993                                 mem_ctx,
 994                                 PI_SRVSVC,
 995                                 &ndr_table_srvsvc,
 996                                 NDR_SRVSVC_NETSHAREDEL,
 997                                 &r);
 998
 999         if (!NT_STATUS_IS_OK(status)) {
1000                 return status;
1001         }
1002
1003         if (DEBUGLEVEL >= 10) {
1004                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDel, &r);
1005         }
1006
1007         if (NT_STATUS_IS_ERR(status)) {
1008                 return status;
1009         }
1010
1011         /* Return variables */
1012
1013         /* Return result */
1014         if (werror) {
1015                 *werror = r.out.result;
1016         }
1017
1018         return werror_to_ntstatus(r.out.result);
1019 }
1020
1021 NTSTATUS rpccli_srvsvc_NetShareDelSticky(struct rpc_pipe_client *cli,
1022                                          TALLOC_CTX *mem_ctx,
1023                                          const char *server_unc,
1024                                          const char *share_name,
1025                                          uint32_t reserved,
1026                                          WERROR *werror)
1027 {
1028         struct srvsvc_NetShareDelSticky r;
1029         NTSTATUS status;
1030
1031         /* In parameters */
1032         r.in.server_unc = server_unc;
1033         r.in.share_name = share_name;
1034         r.in.reserved = reserved;
1035
1036         if (DEBUGLEVEL >= 10) {
1037                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareDelSticky, &r);
1038         }
1039
1040         status = cli_do_rpc_ndr(cli,
1041                                 mem_ctx,
1042                                 PI_SRVSVC,
1043                                 &ndr_table_srvsvc,
1044                                 NDR_SRVSVC_NETSHAREDELSTICKY,
1045                                 &r);
1046
1047         if (!NT_STATUS_IS_OK(status)) {
1048                 return status;
1049         }
1050
1051         if (DEBUGLEVEL >= 10) {
1052                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDelSticky, &r);
1053         }
1054
1055         if (NT_STATUS_IS_ERR(status)) {
1056                 return status;
1057         }
1058
1059         /* Return variables */
1060
1061         /* Return result */
1062         if (werror) {
1063                 *werror = r.out.result;
1064         }
1065
1066         return werror_to_ntstatus(r.out.result);
1067 }
1068
1069 NTSTATUS rpccli_srvsvc_NetShareCheck(struct rpc_pipe_client *cli,
1070                                      TALLOC_CTX *mem_ctx,
1071                                      const char *server_unc,
1072                                      const char *device_name,
1073                                      enum srvsvc_ShareType *type,
1074                                      WERROR *werror)
1075 {
1076         struct srvsvc_NetShareCheck r;
1077         NTSTATUS status;
1078
1079         /* In parameters */
1080         r.in.server_unc = server_unc;
1081         r.in.device_name = device_name;
1082
1083         if (DEBUGLEVEL >= 10) {
1084                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareCheck, &r);
1085         }
1086
1087         status = cli_do_rpc_ndr(cli,
1088                                 mem_ctx,
1089                                 PI_SRVSVC,
1090                                 &ndr_table_srvsvc,
1091                                 NDR_SRVSVC_NETSHARECHECK,
1092                                 &r);
1093
1094         if (!NT_STATUS_IS_OK(status)) {
1095                 return status;
1096         }
1097
1098         if (DEBUGLEVEL >= 10) {
1099                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareCheck, &r);
1100         }
1101
1102         if (NT_STATUS_IS_ERR(status)) {
1103                 return status;
1104         }
1105
1106         /* Return variables */
1107         *type = *r.out.type;
1108
1109         /* Return result */
1110         if (werror) {
1111                 *werror = r.out.result;
1112         }
1113
1114         return werror_to_ntstatus(r.out.result);
1115 }
1116
1117 NTSTATUS rpccli_srvsvc_NetSrvGetInfo(struct rpc_pipe_client *cli,
1118                                      TALLOC_CTX *mem_ctx,
1119                                      const char *server_unc,
1120                                      uint32_t level,
1121                                      union srvsvc_NetSrvInfo *info,
1122                                      WERROR *werror)
1123 {
1124         struct srvsvc_NetSrvGetInfo r;
1125         NTSTATUS status;
1126
1127         /* In parameters */
1128         r.in.server_unc = server_unc;
1129         r.in.level = level;
1130
1131         if (DEBUGLEVEL >= 10) {
1132                 NDR_PRINT_IN_DEBUG(srvsvc_NetSrvGetInfo, &r);
1133         }
1134
1135         status = cli_do_rpc_ndr(cli,
1136                                 mem_ctx,
1137                                 PI_SRVSVC,
1138                                 &ndr_table_srvsvc,
1139                                 NDR_SRVSVC_NETSRVGETINFO,
1140                                 &r);
1141
1142         if (!NT_STATUS_IS_OK(status)) {
1143                 return status;
1144         }
1145
1146         if (DEBUGLEVEL >= 10) {
1147                 NDR_PRINT_OUT_DEBUG(srvsvc_NetSrvGetInfo, &r);
1148         }
1149
1150         if (NT_STATUS_IS_ERR(status)) {
1151                 return status;
1152         }
1153
1154         /* Return variables */
1155         *info = *r.out.info;
1156
1157         /* Return result */
1158         if (werror) {
1159                 *werror = r.out.result;
1160         }
1161
1162         return werror_to_ntstatus(r.out.result);
1163 }
1164
1165 NTSTATUS rpccli_srvsvc_NetSrvSetInfo(struct rpc_pipe_client *cli,
1166                                      TALLOC_CTX *mem_ctx,
1167                                      const char *server_unc,
1168                                      uint32_t level,
1169                                      union srvsvc_NetSrvInfo *info,
1170                                      uint32_t *parm_error,
1171                                      WERROR *werror)
1172 {
1173         struct srvsvc_NetSrvSetInfo r;
1174         NTSTATUS status;
1175
1176         /* In parameters */
1177         r.in.server_unc = server_unc;
1178         r.in.level = level;
1179         r.in.info = info;
1180         r.in.parm_error = parm_error;
1181
1182         if (DEBUGLEVEL >= 10) {
1183                 NDR_PRINT_IN_DEBUG(srvsvc_NetSrvSetInfo, &r);
1184         }
1185
1186         status = cli_do_rpc_ndr(cli,
1187                                 mem_ctx,
1188                                 PI_SRVSVC,
1189                                 &ndr_table_srvsvc,
1190                                 NDR_SRVSVC_NETSRVSETINFO,
1191                                 &r);
1192
1193         if (!NT_STATUS_IS_OK(status)) {
1194                 return status;
1195         }
1196
1197         if (DEBUGLEVEL >= 10) {
1198                 NDR_PRINT_OUT_DEBUG(srvsvc_NetSrvSetInfo, &r);
1199         }
1200
1201         if (NT_STATUS_IS_ERR(status)) {
1202                 return status;
1203         }
1204
1205         /* Return variables */
1206         if (parm_error && r.out.parm_error) {
1207                 *parm_error = *r.out.parm_error;
1208         }
1209
1210         /* Return result */
1211         if (werror) {
1212                 *werror = r.out.result;
1213         }
1214
1215         return werror_to_ntstatus(r.out.result);
1216 }
1217
1218 NTSTATUS rpccli_srvsvc_NetDiskEnum(struct rpc_pipe_client *cli,
1219                                    TALLOC_CTX *mem_ctx,
1220                                    const char *server_unc,
1221                                    uint32_t level,
1222                                    struct srvsvc_NetDiskInfo *info,
1223                                    uint32_t maxlen,
1224                                    uint32_t *totalentries,
1225                                    uint32_t *resume_handle,
1226                                    WERROR *werror)
1227 {
1228         struct srvsvc_NetDiskEnum r;
1229         NTSTATUS status;
1230
1231         /* In parameters */
1232         r.in.server_unc = server_unc;
1233         r.in.level = level;
1234         r.in.info = info;
1235         r.in.maxlen = maxlen;
1236         r.in.resume_handle = resume_handle;
1237
1238         if (DEBUGLEVEL >= 10) {
1239                 NDR_PRINT_IN_DEBUG(srvsvc_NetDiskEnum, &r);
1240         }
1241
1242         status = cli_do_rpc_ndr(cli,
1243                                 mem_ctx,
1244                                 PI_SRVSVC,
1245                                 &ndr_table_srvsvc,
1246                                 NDR_SRVSVC_NETDISKENUM,
1247                                 &r);
1248
1249         if (!NT_STATUS_IS_OK(status)) {
1250                 return status;
1251         }
1252
1253         if (DEBUGLEVEL >= 10) {
1254                 NDR_PRINT_OUT_DEBUG(srvsvc_NetDiskEnum, &r);
1255         }
1256
1257         if (NT_STATUS_IS_ERR(status)) {
1258                 return status;
1259         }
1260
1261         /* Return variables */
1262         *info = *r.out.info;
1263         *totalentries = *r.out.totalentries;
1264         if (resume_handle && r.out.resume_handle) {
1265                 *resume_handle = *r.out.resume_handle;
1266         }
1267
1268         /* Return result */
1269         if (werror) {
1270                 *werror = r.out.result;
1271         }
1272
1273         return werror_to_ntstatus(r.out.result);
1274 }
1275
1276 NTSTATUS rpccli_srvsvc_NetServerStatisticsGet(struct rpc_pipe_client *cli,
1277                                               TALLOC_CTX *mem_ctx,
1278                                               const char *server_unc,
1279                                               const char *service,
1280                                               uint32_t level,
1281                                               uint32_t options,
1282                                               struct srvsvc_Statistics *stats,
1283                                               WERROR *werror)
1284 {
1285         struct srvsvc_NetServerStatisticsGet r;
1286         NTSTATUS status;
1287
1288         /* In parameters */
1289         r.in.server_unc = server_unc;
1290         r.in.service = service;
1291         r.in.level = level;
1292         r.in.options = options;
1293
1294         if (DEBUGLEVEL >= 10) {
1295                 NDR_PRINT_IN_DEBUG(srvsvc_NetServerStatisticsGet, &r);
1296         }
1297
1298         status = cli_do_rpc_ndr(cli,
1299                                 mem_ctx,
1300                                 PI_SRVSVC,
1301                                 &ndr_table_srvsvc,
1302                                 NDR_SRVSVC_NETSERVERSTATISTICSGET,
1303                                 &r);
1304
1305         if (!NT_STATUS_IS_OK(status)) {
1306                 return status;
1307         }
1308
1309         if (DEBUGLEVEL >= 10) {
1310                 NDR_PRINT_OUT_DEBUG(srvsvc_NetServerStatisticsGet, &r);
1311         }
1312
1313         if (NT_STATUS_IS_ERR(status)) {
1314                 return status;
1315         }
1316
1317         /* Return variables */
1318         *stats = *r.out.stats;
1319
1320         /* Return result */
1321         if (werror) {
1322                 *werror = r.out.result;
1323         }
1324
1325         return werror_to_ntstatus(r.out.result);
1326 }
1327
1328 NTSTATUS rpccli_srvsvc_NetTransportAdd(struct rpc_pipe_client *cli,
1329                                        TALLOC_CTX *mem_ctx,
1330                                        const char *server_unc,
1331                                        uint32_t level,
1332                                        union srvsvc_NetTransportInfo info,
1333                                        WERROR *werror)
1334 {
1335         struct srvsvc_NetTransportAdd r;
1336         NTSTATUS status;
1337
1338         /* In parameters */
1339         r.in.server_unc = server_unc;
1340         r.in.level = level;
1341         r.in.info = info;
1342
1343         if (DEBUGLEVEL >= 10) {
1344                 NDR_PRINT_IN_DEBUG(srvsvc_NetTransportAdd, &r);
1345         }
1346
1347         status = cli_do_rpc_ndr(cli,
1348                                 mem_ctx,
1349                                 PI_SRVSVC,
1350                                 &ndr_table_srvsvc,
1351                                 NDR_SRVSVC_NETTRANSPORTADD,
1352                                 &r);
1353
1354         if (!NT_STATUS_IS_OK(status)) {
1355                 return status;
1356         }
1357
1358         if (DEBUGLEVEL >= 10) {
1359                 NDR_PRINT_OUT_DEBUG(srvsvc_NetTransportAdd, &r);
1360         }
1361
1362         if (NT_STATUS_IS_ERR(status)) {
1363                 return status;
1364         }
1365
1366         /* Return variables */
1367
1368         /* Return result */
1369         if (werror) {
1370                 *werror = r.out.result;
1371         }
1372
1373         return werror_to_ntstatus(r.out.result);
1374 }
1375
1376 NTSTATUS rpccli_srvsvc_NetTransportEnum(struct rpc_pipe_client *cli,
1377                                         TALLOC_CTX *mem_ctx,
1378                                         const char *server_unc,
1379                                         uint32_t *level,
1380                                         union srvsvc_NetTransportCtr *transports,
1381                                         uint32_t max_buffer,
1382                                         uint32_t *totalentries,
1383                                         uint32_t *resume_handle,
1384                                         WERROR *werror)
1385 {
1386         struct srvsvc_NetTransportEnum r;
1387         NTSTATUS status;
1388
1389         /* In parameters */
1390         r.in.server_unc = server_unc;
1391         r.in.level = level;
1392         r.in.transports = transports;
1393         r.in.max_buffer = max_buffer;
1394         r.in.resume_handle = resume_handle;
1395
1396         if (DEBUGLEVEL >= 10) {
1397                 NDR_PRINT_IN_DEBUG(srvsvc_NetTransportEnum, &r);
1398         }
1399
1400         status = cli_do_rpc_ndr(cli,
1401                                 mem_ctx,
1402                                 PI_SRVSVC,
1403                                 &ndr_table_srvsvc,
1404                                 NDR_SRVSVC_NETTRANSPORTENUM,
1405                                 &r);
1406
1407         if (!NT_STATUS_IS_OK(status)) {
1408                 return status;
1409         }
1410
1411         if (DEBUGLEVEL >= 10) {
1412                 NDR_PRINT_OUT_DEBUG(srvsvc_NetTransportEnum, &r);
1413         }
1414
1415         if (NT_STATUS_IS_ERR(status)) {
1416                 return status;
1417         }
1418
1419         /* Return variables */
1420         *level = *r.out.level;
1421         *transports = *r.out.transports;
1422         *totalentries = *r.out.totalentries;
1423         if (resume_handle && r.out.resume_handle) {
1424                 *resume_handle = *r.out.resume_handle;
1425         }
1426
1427         /* Return result */
1428         if (werror) {
1429                 *werror = r.out.result;
1430         }
1431
1432         return werror_to_ntstatus(r.out.result);
1433 }
1434
1435 NTSTATUS rpccli_srvsvc_NetTransportDel(struct rpc_pipe_client *cli,
1436                                        TALLOC_CTX *mem_ctx,
1437                                        const char *server_unc,
1438                                        uint32_t unknown,
1439                                        struct srvsvc_NetTransportInfo0 transport,
1440                                        WERROR *werror)
1441 {
1442         struct srvsvc_NetTransportDel r;
1443         NTSTATUS status;
1444
1445         /* In parameters */
1446         r.in.server_unc = server_unc;
1447         r.in.unknown = unknown;
1448         r.in.transport = transport;
1449
1450         if (DEBUGLEVEL >= 10) {
1451                 NDR_PRINT_IN_DEBUG(srvsvc_NetTransportDel, &r);
1452         }
1453
1454         status = cli_do_rpc_ndr(cli,
1455                                 mem_ctx,
1456                                 PI_SRVSVC,
1457                                 &ndr_table_srvsvc,
1458                                 NDR_SRVSVC_NETTRANSPORTDEL,
1459                                 &r);
1460
1461         if (!NT_STATUS_IS_OK(status)) {
1462                 return status;
1463         }
1464
1465         if (DEBUGLEVEL >= 10) {
1466                 NDR_PRINT_OUT_DEBUG(srvsvc_NetTransportDel, &r);
1467         }
1468
1469         if (NT_STATUS_IS_ERR(status)) {
1470                 return status;
1471         }
1472
1473         /* Return variables */
1474
1475         /* Return result */
1476         if (werror) {
1477                 *werror = r.out.result;
1478         }
1479
1480         return werror_to_ntstatus(r.out.result);
1481 }
1482
1483 NTSTATUS rpccli_srvsvc_NetRemoteTOD(struct rpc_pipe_client *cli,
1484                                     TALLOC_CTX *mem_ctx,
1485                                     const char *server_unc,
1486                                     struct srvsvc_NetRemoteTODInfo **info,
1487                                     WERROR *werror)
1488 {
1489         struct srvsvc_NetRemoteTOD r;
1490         NTSTATUS status;
1491
1492         /* In parameters */
1493         r.in.server_unc = server_unc;
1494
1495         if (DEBUGLEVEL >= 10) {
1496                 NDR_PRINT_IN_DEBUG(srvsvc_NetRemoteTOD, &r);
1497         }
1498
1499         status = cli_do_rpc_ndr(cli,
1500                                 mem_ctx,
1501                                 PI_SRVSVC,
1502                                 &ndr_table_srvsvc,
1503                                 NDR_SRVSVC_NETREMOTETOD,
1504                                 &r);
1505
1506         if (!NT_STATUS_IS_OK(status)) {
1507                 return status;
1508         }
1509
1510         if (DEBUGLEVEL >= 10) {
1511                 NDR_PRINT_OUT_DEBUG(srvsvc_NetRemoteTOD, &r);
1512         }
1513
1514         if (NT_STATUS_IS_ERR(status)) {
1515                 return status;
1516         }
1517
1518         /* Return variables */
1519         *info = *r.out.info;
1520
1521         /* Return result */
1522         if (werror) {
1523                 *werror = r.out.result;
1524         }
1525
1526         return werror_to_ntstatus(r.out.result);
1527 }
1528
1529 NTSTATUS rpccli_srvsvc_NetSetServiceBits(struct rpc_pipe_client *cli,
1530                                          TALLOC_CTX *mem_ctx,
1531                                          const char *server_unc,
1532                                          const char *transport,
1533                                          uint32_t servicebits,
1534                                          uint32_t updateimmediately,
1535                                          WERROR *werror)
1536 {
1537         struct srvsvc_NetSetServiceBits r;
1538         NTSTATUS status;
1539
1540         /* In parameters */
1541         r.in.server_unc = server_unc;
1542         r.in.transport = transport;
1543         r.in.servicebits = servicebits;
1544         r.in.updateimmediately = updateimmediately;
1545
1546         if (DEBUGLEVEL >= 10) {
1547                 NDR_PRINT_IN_DEBUG(srvsvc_NetSetServiceBits, &r);
1548         }
1549
1550         status = cli_do_rpc_ndr(cli,
1551                                 mem_ctx,
1552                                 PI_SRVSVC,
1553                                 &ndr_table_srvsvc,
1554                                 NDR_SRVSVC_NETSETSERVICEBITS,
1555                                 &r);
1556
1557         if (!NT_STATUS_IS_OK(status)) {
1558                 return status;
1559         }
1560
1561         if (DEBUGLEVEL >= 10) {
1562                 NDR_PRINT_OUT_DEBUG(srvsvc_NetSetServiceBits, &r);
1563         }
1564
1565         if (NT_STATUS_IS_ERR(status)) {
1566                 return status;
1567         }
1568
1569         /* Return variables */
1570
1571         /* Return result */
1572         if (werror) {
1573                 *werror = r.out.result;
1574         }
1575
1576         return werror_to_ntstatus(r.out.result);
1577 }
1578
1579 NTSTATUS rpccli_srvsvc_NetPathType(struct rpc_pipe_client *cli,
1580                                    TALLOC_CTX *mem_ctx,
1581                                    const char *server_unc,
1582                                    const char *path,
1583                                    uint32_t pathflags,
1584                                    uint32_t *pathtype,
1585                                    WERROR *werror)
1586 {
1587         struct srvsvc_NetPathType r;
1588         NTSTATUS status;
1589
1590         /* In parameters */
1591         r.in.server_unc = server_unc;
1592         r.in.path = path;
1593         r.in.pathflags = pathflags;
1594
1595         if (DEBUGLEVEL >= 10) {
1596                 NDR_PRINT_IN_DEBUG(srvsvc_NetPathType, &r);
1597         }
1598
1599         status = cli_do_rpc_ndr(cli,
1600                                 mem_ctx,
1601                                 PI_SRVSVC,
1602                                 &ndr_table_srvsvc,
1603                                 NDR_SRVSVC_NETPATHTYPE,
1604                                 &r);
1605
1606         if (!NT_STATUS_IS_OK(status)) {
1607                 return status;
1608         }
1609
1610         if (DEBUGLEVEL >= 10) {
1611                 NDR_PRINT_OUT_DEBUG(srvsvc_NetPathType, &r);
1612         }
1613
1614         if (NT_STATUS_IS_ERR(status)) {
1615                 return status;
1616         }
1617
1618         /* Return variables */
1619         *pathtype = *r.out.pathtype;
1620
1621         /* Return result */
1622         if (werror) {
1623                 *werror = r.out.result;
1624         }
1625
1626         return werror_to_ntstatus(r.out.result);
1627 }
1628
1629 NTSTATUS rpccli_srvsvc_NetPathCanonicalize(struct rpc_pipe_client *cli,
1630                                            TALLOC_CTX *mem_ctx,
1631                                            const char *server_unc,
1632                                            const char *path,
1633                                            uint8_t *can_path,
1634                                            uint32_t maxbuf,
1635                                            const char *prefix,
1636                                            uint32_t *pathtype,
1637                                            uint32_t pathflags,
1638                                            WERROR *werror)
1639 {
1640         struct srvsvc_NetPathCanonicalize r;
1641         NTSTATUS status;
1642
1643         /* In parameters */
1644         r.in.server_unc = server_unc;
1645         r.in.path = path;
1646         r.in.maxbuf = maxbuf;
1647         r.in.prefix = prefix;
1648         r.in.pathtype = pathtype;
1649         r.in.pathflags = pathflags;
1650
1651         if (DEBUGLEVEL >= 10) {
1652                 NDR_PRINT_IN_DEBUG(srvsvc_NetPathCanonicalize, &r);
1653         }
1654
1655         status = cli_do_rpc_ndr(cli,
1656                                 mem_ctx,
1657                                 PI_SRVSVC,
1658                                 &ndr_table_srvsvc,
1659                                 NDR_SRVSVC_NETPATHCANONICALIZE,
1660                                 &r);
1661
1662         if (!NT_STATUS_IS_OK(status)) {
1663                 return status;
1664         }
1665
1666         if (DEBUGLEVEL >= 10) {
1667                 NDR_PRINT_OUT_DEBUG(srvsvc_NetPathCanonicalize, &r);
1668         }
1669
1670         if (NT_STATUS_IS_ERR(status)) {
1671                 return status;
1672         }
1673
1674         /* Return variables */
1675         memcpy(can_path, r.out.can_path, r.in.maxbuf);
1676         *pathtype = *r.out.pathtype;
1677
1678         /* Return result */
1679         if (werror) {
1680                 *werror = r.out.result;
1681         }
1682
1683         return werror_to_ntstatus(r.out.result);
1684 }
1685
1686 NTSTATUS rpccli_srvsvc_NetPathCompare(struct rpc_pipe_client *cli,
1687                                       TALLOC_CTX *mem_ctx,
1688                                       const char *server_unc,
1689                                       const char *path1,
1690                                       const char *path2,
1691                                       uint32_t pathtype,
1692                                       uint32_t pathflags,
1693                                       WERROR *werror)
1694 {
1695         struct srvsvc_NetPathCompare r;
1696         NTSTATUS status;
1697
1698         /* In parameters */
1699         r.in.server_unc = server_unc;
1700         r.in.path1 = path1;
1701         r.in.path2 = path2;
1702         r.in.pathtype = pathtype;
1703         r.in.pathflags = pathflags;
1704
1705         if (DEBUGLEVEL >= 10) {
1706                 NDR_PRINT_IN_DEBUG(srvsvc_NetPathCompare, &r);
1707         }
1708
1709         status = cli_do_rpc_ndr(cli,
1710                                 mem_ctx,
1711                                 PI_SRVSVC,
1712                                 &ndr_table_srvsvc,
1713                                 NDR_SRVSVC_NETPATHCOMPARE,
1714                                 &r);
1715
1716         if (!NT_STATUS_IS_OK(status)) {
1717                 return status;
1718         }
1719
1720         if (DEBUGLEVEL >= 10) {
1721                 NDR_PRINT_OUT_DEBUG(srvsvc_NetPathCompare, &r);
1722         }
1723
1724         if (NT_STATUS_IS_ERR(status)) {
1725                 return status;
1726         }
1727
1728         /* Return variables */
1729
1730         /* Return result */
1731         if (werror) {
1732                 *werror = r.out.result;
1733         }
1734
1735         return werror_to_ntstatus(r.out.result);
1736 }
1737
1738 NTSTATUS rpccli_srvsvc_NetNameValidate(struct rpc_pipe_client *cli,
1739                                        TALLOC_CTX *mem_ctx,
1740                                        const char *server_unc,
1741                                        const char *name,
1742                                        uint32_t name_type,
1743                                        uint32_t flags,
1744                                        WERROR *werror)
1745 {
1746         struct srvsvc_NetNameValidate r;
1747         NTSTATUS status;
1748
1749         /* In parameters */
1750         r.in.server_unc = server_unc;
1751         r.in.name = name;
1752         r.in.name_type = name_type;
1753         r.in.flags = flags;
1754
1755         if (DEBUGLEVEL >= 10) {
1756                 NDR_PRINT_IN_DEBUG(srvsvc_NetNameValidate, &r);
1757         }
1758
1759         status = cli_do_rpc_ndr(cli,
1760                                 mem_ctx,
1761                                 PI_SRVSVC,
1762                                 &ndr_table_srvsvc,
1763                                 NDR_SRVSVC_NETNAMEVALIDATE,
1764                                 &r);
1765
1766         if (!NT_STATUS_IS_OK(status)) {
1767                 return status;
1768         }
1769
1770         if (DEBUGLEVEL >= 10) {
1771                 NDR_PRINT_OUT_DEBUG(srvsvc_NetNameValidate, &r);
1772         }
1773
1774         if (NT_STATUS_IS_ERR(status)) {
1775                 return status;
1776         }
1777
1778         /* Return variables */
1779
1780         /* Return result */
1781         if (werror) {
1782                 *werror = r.out.result;
1783         }
1784
1785         return werror_to_ntstatus(r.out.result);
1786 }
1787
1788 NTSTATUS rpccli_srvsvc_NETRPRNAMECANONICALIZE(struct rpc_pipe_client *cli,
1789                                               TALLOC_CTX *mem_ctx,
1790                                               WERROR *werror)
1791 {
1792         struct srvsvc_NETRPRNAMECANONICALIZE r;
1793         NTSTATUS status;
1794
1795         /* In parameters */
1796
1797         if (DEBUGLEVEL >= 10) {
1798                 NDR_PRINT_IN_DEBUG(srvsvc_NETRPRNAMECANONICALIZE, &r);
1799         }
1800
1801         status = cli_do_rpc_ndr(cli,
1802                                 mem_ctx,
1803                                 PI_SRVSVC,
1804                                 &ndr_table_srvsvc,
1805                                 NDR_SRVSVC_NETRPRNAMECANONICALIZE,
1806                                 &r);
1807
1808         if (!NT_STATUS_IS_OK(status)) {
1809                 return status;
1810         }
1811
1812         if (DEBUGLEVEL >= 10) {
1813                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRPRNAMECANONICALIZE, &r);
1814         }
1815
1816         if (NT_STATUS_IS_ERR(status)) {
1817                 return status;
1818         }
1819
1820         /* Return variables */
1821
1822         /* Return result */
1823         if (werror) {
1824                 *werror = r.out.result;
1825         }
1826
1827         return werror_to_ntstatus(r.out.result);
1828 }
1829
1830 NTSTATUS rpccli_srvsvc_NetPRNameCompare(struct rpc_pipe_client *cli,
1831                                         TALLOC_CTX *mem_ctx,
1832                                         const char *server_unc,
1833                                         const char *name1,
1834                                         const char *name2,
1835                                         uint32_t name_type,
1836                                         uint32_t flags,
1837                                         WERROR *werror)
1838 {
1839         struct srvsvc_NetPRNameCompare r;
1840         NTSTATUS status;
1841
1842         /* In parameters */
1843         r.in.server_unc = server_unc;
1844         r.in.name1 = name1;
1845         r.in.name2 = name2;
1846         r.in.name_type = name_type;
1847         r.in.flags = flags;
1848
1849         if (DEBUGLEVEL >= 10) {
1850                 NDR_PRINT_IN_DEBUG(srvsvc_NetPRNameCompare, &r);
1851         }
1852
1853         status = cli_do_rpc_ndr(cli,
1854                                 mem_ctx,
1855                                 PI_SRVSVC,
1856                                 &ndr_table_srvsvc,
1857                                 NDR_SRVSVC_NETPRNAMECOMPARE,
1858                                 &r);
1859
1860         if (!NT_STATUS_IS_OK(status)) {
1861                 return status;
1862         }
1863
1864         if (DEBUGLEVEL >= 10) {
1865                 NDR_PRINT_OUT_DEBUG(srvsvc_NetPRNameCompare, &r);
1866         }
1867
1868         if (NT_STATUS_IS_ERR(status)) {
1869                 return status;
1870         }
1871
1872         /* Return variables */
1873
1874         /* Return result */
1875         if (werror) {
1876                 *werror = r.out.result;
1877         }
1878
1879         return werror_to_ntstatus(r.out.result);
1880 }
1881
1882 NTSTATUS rpccli_srvsvc_NetShareEnum(struct rpc_pipe_client *cli,
1883                                     TALLOC_CTX *mem_ctx,
1884                                     const char *server_unc,
1885                                     struct srvsvc_NetShareInfoCtr *info_ctr,
1886                                     uint32_t max_buffer,
1887                                     uint32_t *totalentries,
1888                                     uint32_t *resume_handle,
1889                                     WERROR *werror)
1890 {
1891         struct srvsvc_NetShareEnum r;
1892         NTSTATUS status;
1893
1894         /* In parameters */
1895         r.in.server_unc = server_unc;
1896         r.in.info_ctr = info_ctr;
1897         r.in.max_buffer = max_buffer;
1898         r.in.resume_handle = resume_handle;
1899
1900         if (DEBUGLEVEL >= 10) {
1901                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareEnum, &r);
1902         }
1903
1904         status = cli_do_rpc_ndr(cli,
1905                                 mem_ctx,
1906                                 PI_SRVSVC,
1907                                 &ndr_table_srvsvc,
1908                                 NDR_SRVSVC_NETSHAREENUM,
1909                                 &r);
1910
1911         if (!NT_STATUS_IS_OK(status)) {
1912                 return status;
1913         }
1914
1915         if (DEBUGLEVEL >= 10) {
1916                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareEnum, &r);
1917         }
1918
1919         if (NT_STATUS_IS_ERR(status)) {
1920                 return status;
1921         }
1922
1923         /* Return variables */
1924         *info_ctr = *r.out.info_ctr;
1925         *totalentries = *r.out.totalentries;
1926         if (resume_handle && r.out.resume_handle) {
1927                 *resume_handle = *r.out.resume_handle;
1928         }
1929
1930         /* Return result */
1931         if (werror) {
1932                 *werror = r.out.result;
1933         }
1934
1935         return werror_to_ntstatus(r.out.result);
1936 }
1937
1938 NTSTATUS rpccli_srvsvc_NetShareDelStart(struct rpc_pipe_client *cli,
1939                                         TALLOC_CTX *mem_ctx,
1940                                         const char *server_unc,
1941                                         const char *share,
1942                                         uint32_t reserved,
1943                                         struct policy_handle *hnd,
1944                                         WERROR *werror)
1945 {
1946         struct srvsvc_NetShareDelStart r;
1947         NTSTATUS status;
1948
1949         /* In parameters */
1950         r.in.server_unc = server_unc;
1951         r.in.share = share;
1952         r.in.reserved = reserved;
1953
1954         if (DEBUGLEVEL >= 10) {
1955                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareDelStart, &r);
1956         }
1957
1958         status = cli_do_rpc_ndr(cli,
1959                                 mem_ctx,
1960                                 PI_SRVSVC,
1961                                 &ndr_table_srvsvc,
1962                                 NDR_SRVSVC_NETSHAREDELSTART,
1963                                 &r);
1964
1965         if (!NT_STATUS_IS_OK(status)) {
1966                 return status;
1967         }
1968
1969         if (DEBUGLEVEL >= 10) {
1970                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDelStart, &r);
1971         }
1972
1973         if (NT_STATUS_IS_ERR(status)) {
1974                 return status;
1975         }
1976
1977         /* Return variables */
1978         if (hnd && r.out.hnd) {
1979                 *hnd = *r.out.hnd;
1980         }
1981
1982         /* Return result */
1983         if (werror) {
1984                 *werror = r.out.result;
1985         }
1986
1987         return werror_to_ntstatus(r.out.result);
1988 }
1989
1990 NTSTATUS rpccli_srvsvc_NetShareDelCommit(struct rpc_pipe_client *cli,
1991                                          TALLOC_CTX *mem_ctx,
1992                                          struct policy_handle *hnd,
1993                                          WERROR *werror)
1994 {
1995         struct srvsvc_NetShareDelCommit r;
1996         NTSTATUS status;
1997
1998         /* In parameters */
1999         r.in.hnd = hnd;
2000
2001         if (DEBUGLEVEL >= 10) {
2002                 NDR_PRINT_IN_DEBUG(srvsvc_NetShareDelCommit, &r);
2003         }
2004
2005         status = cli_do_rpc_ndr(cli,
2006                                 mem_ctx,
2007                                 PI_SRVSVC,
2008                                 &ndr_table_srvsvc,
2009                                 NDR_SRVSVC_NETSHAREDELCOMMIT,
2010                                 &r);
2011
2012         if (!NT_STATUS_IS_OK(status)) {
2013                 return status;
2014         }
2015
2016         if (DEBUGLEVEL >= 10) {
2017                 NDR_PRINT_OUT_DEBUG(srvsvc_NetShareDelCommit, &r);
2018         }
2019
2020         if (NT_STATUS_IS_ERR(status)) {
2021                 return status;
2022         }
2023
2024         /* Return variables */
2025         if (hnd && r.out.hnd) {
2026                 *hnd = *r.out.hnd;
2027         }
2028
2029         /* Return result */
2030         if (werror) {
2031                 *werror = r.out.result;
2032         }
2033
2034         return werror_to_ntstatus(r.out.result);
2035 }
2036
2037 NTSTATUS rpccli_srvsvc_NetGetFileSecurity(struct rpc_pipe_client *cli,
2038                                           TALLOC_CTX *mem_ctx,
2039                                           const char *server_unc,
2040                                           const char *share,
2041                                           const char *file,
2042                                           uint32_t securityinformation,
2043                                           struct sec_desc_buf **sd_buf,
2044                                           WERROR *werror)
2045 {
2046         struct srvsvc_NetGetFileSecurity r;
2047         NTSTATUS status;
2048
2049         /* In parameters */
2050         r.in.server_unc = server_unc;
2051         r.in.share = share;
2052         r.in.file = file;
2053         r.in.securityinformation = securityinformation;
2054
2055         if (DEBUGLEVEL >= 10) {
2056                 NDR_PRINT_IN_DEBUG(srvsvc_NetGetFileSecurity, &r);
2057         }
2058
2059         status = cli_do_rpc_ndr(cli,
2060                                 mem_ctx,
2061                                 PI_SRVSVC,
2062                                 &ndr_table_srvsvc,
2063                                 NDR_SRVSVC_NETGETFILESECURITY,
2064                                 &r);
2065
2066         if (!NT_STATUS_IS_OK(status)) {
2067                 return status;
2068         }
2069
2070         if (DEBUGLEVEL >= 10) {
2071                 NDR_PRINT_OUT_DEBUG(srvsvc_NetGetFileSecurity, &r);
2072         }
2073
2074         if (NT_STATUS_IS_ERR(status)) {
2075                 return status;
2076         }
2077
2078         /* Return variables */
2079         *sd_buf = *r.out.sd_buf;
2080
2081         /* Return result */
2082         if (werror) {
2083                 *werror = r.out.result;
2084         }
2085
2086         return werror_to_ntstatus(r.out.result);
2087 }
2088
2089 NTSTATUS rpccli_srvsvc_NetSetFileSecurity(struct rpc_pipe_client *cli,
2090                                           TALLOC_CTX *mem_ctx,
2091                                           const char *server_unc,
2092                                           const char *share,
2093                                           const char *file,
2094                                           uint32_t securityinformation,
2095                                           struct sec_desc_buf *sd_buf,
2096                                           WERROR *werror)
2097 {
2098         struct srvsvc_NetSetFileSecurity r;
2099         NTSTATUS status;
2100
2101         /* In parameters */
2102         r.in.server_unc = server_unc;
2103         r.in.share = share;
2104         r.in.file = file;
2105         r.in.securityinformation = securityinformation;
2106         r.in.sd_buf = sd_buf;
2107
2108         if (DEBUGLEVEL >= 10) {
2109                 NDR_PRINT_IN_DEBUG(srvsvc_NetSetFileSecurity, &r);
2110         }
2111
2112         status = cli_do_rpc_ndr(cli,
2113                                 mem_ctx,
2114                                 PI_SRVSVC,
2115                                 &ndr_table_srvsvc,
2116                                 NDR_SRVSVC_NETSETFILESECURITY,
2117                                 &r);
2118
2119         if (!NT_STATUS_IS_OK(status)) {
2120                 return status;
2121         }
2122
2123         if (DEBUGLEVEL >= 10) {
2124                 NDR_PRINT_OUT_DEBUG(srvsvc_NetSetFileSecurity, &r);
2125         }
2126
2127         if (NT_STATUS_IS_ERR(status)) {
2128                 return status;
2129         }
2130
2131         /* Return variables */
2132
2133         /* Return result */
2134         if (werror) {
2135                 *werror = r.out.result;
2136         }
2137
2138         return werror_to_ntstatus(r.out.result);
2139 }
2140
2141 NTSTATUS rpccli_srvsvc_NetServerTransportAddEx(struct rpc_pipe_client *cli,
2142                                                TALLOC_CTX *mem_ctx,
2143                                                const char *server_unc,
2144                                                uint32_t level,
2145                                                union srvsvc_NetTransportInfo info,
2146                                                WERROR *werror)
2147 {
2148         struct srvsvc_NetServerTransportAddEx r;
2149         NTSTATUS status;
2150
2151         /* In parameters */
2152         r.in.server_unc = server_unc;
2153         r.in.level = level;
2154         r.in.info = info;
2155
2156         if (DEBUGLEVEL >= 10) {
2157                 NDR_PRINT_IN_DEBUG(srvsvc_NetServerTransportAddEx, &r);
2158         }
2159
2160         status = cli_do_rpc_ndr(cli,
2161                                 mem_ctx,
2162                                 PI_SRVSVC,
2163                                 &ndr_table_srvsvc,
2164                                 NDR_SRVSVC_NETSERVERTRANSPORTADDEX,
2165                                 &r);
2166
2167         if (!NT_STATUS_IS_OK(status)) {
2168                 return status;
2169         }
2170
2171         if (DEBUGLEVEL >= 10) {
2172                 NDR_PRINT_OUT_DEBUG(srvsvc_NetServerTransportAddEx, &r);
2173         }
2174
2175         if (NT_STATUS_IS_ERR(status)) {
2176                 return status;
2177         }
2178
2179         /* Return variables */
2180
2181         /* Return result */
2182         if (werror) {
2183                 *werror = r.out.result;
2184         }
2185
2186         return werror_to_ntstatus(r.out.result);
2187 }
2188
2189 NTSTATUS rpccli_srvsvc_NetServerSetServiceBitsEx(struct rpc_pipe_client *cli,
2190                                                  TALLOC_CTX *mem_ctx,
2191                                                  const char *server_unc,
2192                                                  const char *emulated_server_unc,
2193                                                  const char *transport,
2194                                                  uint32_t servicebitsofinterest,
2195                                                  uint32_t servicebits,
2196                                                  uint32_t updateimmediately,
2197                                                  WERROR *werror)
2198 {
2199         struct srvsvc_NetServerSetServiceBitsEx r;
2200         NTSTATUS status;
2201
2202         /* In parameters */
2203         r.in.server_unc = server_unc;
2204         r.in.emulated_server_unc = emulated_server_unc;
2205         r.in.transport = transport;
2206         r.in.servicebitsofinterest = servicebitsofinterest;
2207         r.in.servicebits = servicebits;
2208         r.in.updateimmediately = updateimmediately;
2209
2210         if (DEBUGLEVEL >= 10) {
2211                 NDR_PRINT_IN_DEBUG(srvsvc_NetServerSetServiceBitsEx, &r);
2212         }
2213
2214         status = cli_do_rpc_ndr(cli,
2215                                 mem_ctx,
2216                                 PI_SRVSVC,
2217                                 &ndr_table_srvsvc,
2218                                 NDR_SRVSVC_NETSERVERSETSERVICEBITSEX,
2219                                 &r);
2220
2221         if (!NT_STATUS_IS_OK(status)) {
2222                 return status;
2223         }
2224
2225         if (DEBUGLEVEL >= 10) {
2226                 NDR_PRINT_OUT_DEBUG(srvsvc_NetServerSetServiceBitsEx, &r);
2227         }
2228
2229         if (NT_STATUS_IS_ERR(status)) {
2230                 return status;
2231         }
2232
2233         /* Return variables */
2234
2235         /* Return result */
2236         if (werror) {
2237                 *werror = r.out.result;
2238         }
2239
2240         return werror_to_ntstatus(r.out.result);
2241 }
2242
2243 NTSTATUS rpccli_srvsvc_NETRDFSGETVERSION(struct rpc_pipe_client *cli,
2244                                          TALLOC_CTX *mem_ctx,
2245                                          WERROR *werror)
2246 {
2247         struct srvsvc_NETRDFSGETVERSION r;
2248         NTSTATUS status;
2249
2250         /* In parameters */
2251
2252         if (DEBUGLEVEL >= 10) {
2253                 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSGETVERSION, &r);
2254         }
2255
2256         status = cli_do_rpc_ndr(cli,
2257                                 mem_ctx,
2258                                 PI_SRVSVC,
2259                                 &ndr_table_srvsvc,
2260                                 NDR_SRVSVC_NETRDFSGETVERSION,
2261                                 &r);
2262
2263         if (!NT_STATUS_IS_OK(status)) {
2264                 return status;
2265         }
2266
2267         if (DEBUGLEVEL >= 10) {
2268                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSGETVERSION, &r);
2269         }
2270
2271         if (NT_STATUS_IS_ERR(status)) {
2272                 return status;
2273         }
2274
2275         /* Return variables */
2276
2277         /* Return result */
2278         if (werror) {
2279                 *werror = r.out.result;
2280         }
2281
2282         return werror_to_ntstatus(r.out.result);
2283 }
2284
2285 NTSTATUS rpccli_srvsvc_NETRDFSCREATELOCALPARTITION(struct rpc_pipe_client *cli,
2286                                                    TALLOC_CTX *mem_ctx,
2287                                                    WERROR *werror)
2288 {
2289         struct srvsvc_NETRDFSCREATELOCALPARTITION r;
2290         NTSTATUS status;
2291
2292         /* In parameters */
2293
2294         if (DEBUGLEVEL >= 10) {
2295                 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSCREATELOCALPARTITION, &r);
2296         }
2297
2298         status = cli_do_rpc_ndr(cli,
2299                                 mem_ctx,
2300                                 PI_SRVSVC,
2301                                 &ndr_table_srvsvc,
2302                                 NDR_SRVSVC_NETRDFSCREATELOCALPARTITION,
2303                                 &r);
2304
2305         if (!NT_STATUS_IS_OK(status)) {
2306                 return status;
2307         }
2308
2309         if (DEBUGLEVEL >= 10) {
2310                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSCREATELOCALPARTITION, &r);
2311         }
2312
2313         if (NT_STATUS_IS_ERR(status)) {
2314                 return status;
2315         }
2316
2317         /* Return variables */
2318
2319         /* Return result */
2320         if (werror) {
2321                 *werror = r.out.result;
2322         }
2323
2324         return werror_to_ntstatus(r.out.result);
2325 }
2326
2327 NTSTATUS rpccli_srvsvc_NETRDFSDELETELOCALPARTITION(struct rpc_pipe_client *cli,
2328                                                    TALLOC_CTX *mem_ctx,
2329                                                    WERROR *werror)
2330 {
2331         struct srvsvc_NETRDFSDELETELOCALPARTITION r;
2332         NTSTATUS status;
2333
2334         /* In parameters */
2335
2336         if (DEBUGLEVEL >= 10) {
2337                 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSDELETELOCALPARTITION, &r);
2338         }
2339
2340         status = cli_do_rpc_ndr(cli,
2341                                 mem_ctx,
2342                                 PI_SRVSVC,
2343                                 &ndr_table_srvsvc,
2344                                 NDR_SRVSVC_NETRDFSDELETELOCALPARTITION,
2345                                 &r);
2346
2347         if (!NT_STATUS_IS_OK(status)) {
2348                 return status;
2349         }
2350
2351         if (DEBUGLEVEL >= 10) {
2352                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSDELETELOCALPARTITION, &r);
2353         }
2354
2355         if (NT_STATUS_IS_ERR(status)) {
2356                 return status;
2357         }
2358
2359         /* Return variables */
2360
2361         /* Return result */
2362         if (werror) {
2363                 *werror = r.out.result;
2364         }
2365
2366         return werror_to_ntstatus(r.out.result);
2367 }
2368
2369 NTSTATUS rpccli_srvsvc_NETRDFSSETLOCALVOLUMESTATE(struct rpc_pipe_client *cli,
2370                                                   TALLOC_CTX *mem_ctx,
2371                                                   WERROR *werror)
2372 {
2373         struct srvsvc_NETRDFSSETLOCALVOLUMESTATE r;
2374         NTSTATUS status;
2375
2376         /* In parameters */
2377
2378         if (DEBUGLEVEL >= 10) {
2379                 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSSETLOCALVOLUMESTATE, &r);
2380         }
2381
2382         status = cli_do_rpc_ndr(cli,
2383                                 mem_ctx,
2384                                 PI_SRVSVC,
2385                                 &ndr_table_srvsvc,
2386                                 NDR_SRVSVC_NETRDFSSETLOCALVOLUMESTATE,
2387                                 &r);
2388
2389         if (!NT_STATUS_IS_OK(status)) {
2390                 return status;
2391         }
2392
2393         if (DEBUGLEVEL >= 10) {
2394                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSSETLOCALVOLUMESTATE, &r);
2395         }
2396
2397         if (NT_STATUS_IS_ERR(status)) {
2398                 return status;
2399         }
2400
2401         /* Return variables */
2402
2403         /* Return result */
2404         if (werror) {
2405                 *werror = r.out.result;
2406         }
2407
2408         return werror_to_ntstatus(r.out.result);
2409 }
2410
2411 NTSTATUS rpccli_srvsvc_NETRDFSSETSERVERINFO(struct rpc_pipe_client *cli,
2412                                             TALLOC_CTX *mem_ctx,
2413                                             WERROR *werror)
2414 {
2415         struct srvsvc_NETRDFSSETSERVERINFO r;
2416         NTSTATUS status;
2417
2418         /* In parameters */
2419
2420         if (DEBUGLEVEL >= 10) {
2421                 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSSETSERVERINFO, &r);
2422         }
2423
2424         status = cli_do_rpc_ndr(cli,
2425                                 mem_ctx,
2426                                 PI_SRVSVC,
2427                                 &ndr_table_srvsvc,
2428                                 NDR_SRVSVC_NETRDFSSETSERVERINFO,
2429                                 &r);
2430
2431         if (!NT_STATUS_IS_OK(status)) {
2432                 return status;
2433         }
2434
2435         if (DEBUGLEVEL >= 10) {
2436                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSSETSERVERINFO, &r);
2437         }
2438
2439         if (NT_STATUS_IS_ERR(status)) {
2440                 return status;
2441         }
2442
2443         /* Return variables */
2444
2445         /* Return result */
2446         if (werror) {
2447                 *werror = r.out.result;
2448         }
2449
2450         return werror_to_ntstatus(r.out.result);
2451 }
2452
2453 NTSTATUS rpccli_srvsvc_NETRDFSCREATEEXITPOINT(struct rpc_pipe_client *cli,
2454                                               TALLOC_CTX *mem_ctx,
2455                                               WERROR *werror)
2456 {
2457         struct srvsvc_NETRDFSCREATEEXITPOINT r;
2458         NTSTATUS status;
2459
2460         /* In parameters */
2461
2462         if (DEBUGLEVEL >= 10) {
2463                 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSCREATEEXITPOINT, &r);
2464         }
2465
2466         status = cli_do_rpc_ndr(cli,
2467                                 mem_ctx,
2468                                 PI_SRVSVC,
2469                                 &ndr_table_srvsvc,
2470                                 NDR_SRVSVC_NETRDFSCREATEEXITPOINT,
2471                                 &r);
2472
2473         if (!NT_STATUS_IS_OK(status)) {
2474                 return status;
2475         }
2476
2477         if (DEBUGLEVEL >= 10) {
2478                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSCREATEEXITPOINT, &r);
2479         }
2480
2481         if (NT_STATUS_IS_ERR(status)) {
2482                 return status;
2483         }
2484
2485         /* Return variables */
2486
2487         /* Return result */
2488         if (werror) {
2489                 *werror = r.out.result;
2490         }
2491
2492         return werror_to_ntstatus(r.out.result);
2493 }
2494
2495 NTSTATUS rpccli_srvsvc_NETRDFSDELETEEXITPOINT(struct rpc_pipe_client *cli,
2496                                               TALLOC_CTX *mem_ctx,
2497                                               WERROR *werror)
2498 {
2499         struct srvsvc_NETRDFSDELETEEXITPOINT r;
2500         NTSTATUS status;
2501
2502         /* In parameters */
2503
2504         if (DEBUGLEVEL >= 10) {
2505                 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSDELETEEXITPOINT, &r);
2506         }
2507
2508         status = cli_do_rpc_ndr(cli,
2509                                 mem_ctx,
2510                                 PI_SRVSVC,
2511                                 &ndr_table_srvsvc,
2512                                 NDR_SRVSVC_NETRDFSDELETEEXITPOINT,
2513                                 &r);
2514
2515         if (!NT_STATUS_IS_OK(status)) {
2516                 return status;
2517         }
2518
2519         if (DEBUGLEVEL >= 10) {
2520                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSDELETEEXITPOINT, &r);
2521         }
2522
2523         if (NT_STATUS_IS_ERR(status)) {
2524                 return status;
2525         }
2526
2527         /* Return variables */
2528
2529         /* Return result */
2530         if (werror) {
2531                 *werror = r.out.result;
2532         }
2533
2534         return werror_to_ntstatus(r.out.result);
2535 }
2536
2537 NTSTATUS rpccli_srvsvc_NETRDFSMODIFYPREFIX(struct rpc_pipe_client *cli,
2538                                            TALLOC_CTX *mem_ctx,
2539                                            WERROR *werror)
2540 {
2541         struct srvsvc_NETRDFSMODIFYPREFIX r;
2542         NTSTATUS status;
2543
2544         /* In parameters */
2545
2546         if (DEBUGLEVEL >= 10) {
2547                 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSMODIFYPREFIX, &r);
2548         }
2549
2550         status = cli_do_rpc_ndr(cli,
2551                                 mem_ctx,
2552                                 PI_SRVSVC,
2553                                 &ndr_table_srvsvc,
2554                                 NDR_SRVSVC_NETRDFSMODIFYPREFIX,
2555                                 &r);
2556
2557         if (!NT_STATUS_IS_OK(status)) {
2558                 return status;
2559         }
2560
2561         if (DEBUGLEVEL >= 10) {
2562                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSMODIFYPREFIX, &r);
2563         }
2564
2565         if (NT_STATUS_IS_ERR(status)) {
2566                 return status;
2567         }
2568
2569         /* Return variables */
2570
2571         /* Return result */
2572         if (werror) {
2573                 *werror = r.out.result;
2574         }
2575
2576         return werror_to_ntstatus(r.out.result);
2577 }
2578
2579 NTSTATUS rpccli_srvsvc_NETRDFSFIXLOCALVOLUME(struct rpc_pipe_client *cli,
2580                                              TALLOC_CTX *mem_ctx,
2581                                              WERROR *werror)
2582 {
2583         struct srvsvc_NETRDFSFIXLOCALVOLUME r;
2584         NTSTATUS status;
2585
2586         /* In parameters */
2587
2588         if (DEBUGLEVEL >= 10) {
2589                 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSFIXLOCALVOLUME, &r);
2590         }
2591
2592         status = cli_do_rpc_ndr(cli,
2593                                 mem_ctx,
2594                                 PI_SRVSVC,
2595                                 &ndr_table_srvsvc,
2596                                 NDR_SRVSVC_NETRDFSFIXLOCALVOLUME,
2597                                 &r);
2598
2599         if (!NT_STATUS_IS_OK(status)) {
2600                 return status;
2601         }
2602
2603         if (DEBUGLEVEL >= 10) {
2604                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSFIXLOCALVOLUME, &r);
2605         }
2606
2607         if (NT_STATUS_IS_ERR(status)) {
2608                 return status;
2609         }
2610
2611         /* Return variables */
2612
2613         /* Return result */
2614         if (werror) {
2615                 *werror = r.out.result;
2616         }
2617
2618         return werror_to_ntstatus(r.out.result);
2619 }
2620
2621 NTSTATUS rpccli_srvsvc_NETRDFSMANAGERREPORTSITEINFO(struct rpc_pipe_client *cli,
2622                                                     TALLOC_CTX *mem_ctx,
2623                                                     WERROR *werror)
2624 {
2625         struct srvsvc_NETRDFSMANAGERREPORTSITEINFO r;
2626         NTSTATUS status;
2627
2628         /* In parameters */
2629
2630         if (DEBUGLEVEL >= 10) {
2631                 NDR_PRINT_IN_DEBUG(srvsvc_NETRDFSMANAGERREPORTSITEINFO, &r);
2632         }
2633
2634         status = cli_do_rpc_ndr(cli,
2635                                 mem_ctx,
2636                                 PI_SRVSVC,
2637                                 &ndr_table_srvsvc,
2638                                 NDR_SRVSVC_NETRDFSMANAGERREPORTSITEINFO,
2639                                 &r);
2640
2641         if (!NT_STATUS_IS_OK(status)) {
2642                 return status;
2643         }
2644
2645         if (DEBUGLEVEL >= 10) {
2646                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRDFSMANAGERREPORTSITEINFO, &r);
2647         }
2648
2649         if (NT_STATUS_IS_ERR(status)) {
2650                 return status;
2651         }
2652
2653         /* Return variables */
2654
2655         /* Return result */
2656         if (werror) {
2657                 *werror = r.out.result;
2658         }
2659
2660         return werror_to_ntstatus(r.out.result);
2661 }
2662
2663 NTSTATUS rpccli_srvsvc_NETRSERVERTRANSPORTDELEX(struct rpc_pipe_client *cli,
2664                                                 TALLOC_CTX *mem_ctx,
2665                                                 WERROR *werror)
2666 {
2667         struct srvsvc_NETRSERVERTRANSPORTDELEX r;
2668         NTSTATUS status;
2669
2670         /* In parameters */
2671
2672         if (DEBUGLEVEL >= 10) {
2673                 NDR_PRINT_IN_DEBUG(srvsvc_NETRSERVERTRANSPORTDELEX, &r);
2674         }
2675
2676         status = cli_do_rpc_ndr(cli,
2677                                 mem_ctx,
2678                                 PI_SRVSVC,
2679                                 &ndr_table_srvsvc,
2680                                 NDR_SRVSVC_NETRSERVERTRANSPORTDELEX,
2681                                 &r);
2682
2683         if (!NT_STATUS_IS_OK(status)) {
2684                 return status;
2685         }
2686
2687         if (DEBUGLEVEL >= 10) {
2688                 NDR_PRINT_OUT_DEBUG(srvsvc_NETRSERVERTRANSPORTDELEX, &r);
2689         }
2690
2691         if (NT_STATUS_IS_ERR(status)) {
2692                 return status;
2693         }
2694
2695         /* Return variables */
2696
2697         /* Return result */
2698         if (werror) {
2699                 *werror = r.out.result;
2700         }
2701
2702         return werror_to_ntstatus(r.out.result);
2703 }
2704