root/librpc/gen_ndr/cli_srvsvc.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. rpccli_srvsvc_NetCharDevEnum
  2. rpccli_srvsvc_NetCharDevGetInfo
  3. rpccli_srvsvc_NetCharDevControl
  4. rpccli_srvsvc_NetCharDevQEnum
  5. rpccli_srvsvc_NetCharDevQGetInfo
  6. rpccli_srvsvc_NetCharDevQSetInfo
  7. rpccli_srvsvc_NetCharDevQPurge
  8. rpccli_srvsvc_NetCharDevQPurgeSelf
  9. rpccli_srvsvc_NetConnEnum
  10. rpccli_srvsvc_NetFileEnum
  11. rpccli_srvsvc_NetFileGetInfo
  12. rpccli_srvsvc_NetFileClose
  13. rpccli_srvsvc_NetSessEnum
  14. rpccli_srvsvc_NetSessDel
  15. rpccli_srvsvc_NetShareAdd
  16. rpccli_srvsvc_NetShareEnumAll
  17. rpccli_srvsvc_NetShareGetInfo
  18. rpccli_srvsvc_NetShareSetInfo
  19. rpccli_srvsvc_NetShareDel
  20. rpccli_srvsvc_NetShareDelSticky
  21. rpccli_srvsvc_NetShareCheck
  22. rpccli_srvsvc_NetSrvGetInfo
  23. rpccli_srvsvc_NetSrvSetInfo
  24. rpccli_srvsvc_NetDiskEnum
  25. rpccli_srvsvc_NetServerStatisticsGet
  26. rpccli_srvsvc_NetTransportAdd
  27. rpccli_srvsvc_NetTransportEnum
  28. rpccli_srvsvc_NetTransportDel
  29. rpccli_srvsvc_NetRemoteTOD
  30. rpccli_srvsvc_NetSetServiceBits
  31. rpccli_srvsvc_NetPathType
  32. rpccli_srvsvc_NetPathCanonicalize
  33. rpccli_srvsvc_NetPathCompare
  34. rpccli_srvsvc_NetNameValidate
  35. rpccli_srvsvc_NETRPRNAMECANONICALIZE
  36. rpccli_srvsvc_NetPRNameCompare
  37. rpccli_srvsvc_NetShareEnum
  38. rpccli_srvsvc_NetShareDelStart
  39. rpccli_srvsvc_NetShareDelCommit
  40. rpccli_srvsvc_NetGetFileSecurity
  41. rpccli_srvsvc_NetSetFileSecurity
  42. rpccli_srvsvc_NetServerTransportAddEx
  43. rpccli_srvsvc_NetServerSetServiceBitsEx
  44. rpccli_srvsvc_NETRDFSGETVERSION
  45. rpccli_srvsvc_NETRDFSCREATELOCALPARTITION
  46. rpccli_srvsvc_NETRDFSDELETELOCALPARTITION
  47. rpccli_srvsvc_NETRDFSSETLOCALVOLUMESTATE
  48. rpccli_srvsvc_NETRDFSSETSERVERINFO
  49. rpccli_srvsvc_NETRDFSCREATEEXITPOINT
  50. rpccli_srvsvc_NETRDFSDELETEEXITPOINT
  51. rpccli_srvsvc_NETRDFSMODIFYPREFIX
  52. rpccli_srvsvc_NETRDFSFIXLOCALVOLUME
  53. rpccli_srvsvc_NETRDFSMANAGERREPORTSITEINFO
  54. rpccli_srvsvc_NETRSERVERTRANSPORTDELEX

   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,
     /* [<][>][^][v][top][bottom][index][help] */
  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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
  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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
 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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
 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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
 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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
 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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
 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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
 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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
 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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
 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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
 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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
 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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
 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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
 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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
 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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
 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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
 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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
 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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
 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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
 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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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,
     /* [<][>][^][v][top][bottom][index][help] */
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->dispatch(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 

/* [<][>][^][v][top][bottom][index][help] */