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