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