source/librpc/gen_ndr/cli_dfs.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * client auto-generated by pidl. DO NOT MODIFY!
   4  */
   5
   6 #include "includes.h"
   7 #include "librpc/gen_ndr/cli_dfs.h"
   8
   9 NTSTATUS rpccli_dfs_GetManagerVersion(struct rpc_pipe_client *cli,
  10                                       TALLOC_CTX *mem_ctx,
  11                                       enum dfs_ManagerVersion *version /* [out] [ref] */)
  12 {
  13         struct dfs_GetManagerVersion r;
  14         NTSTATUS status;
  15
  16         /* In parameters */
  17
  18         if (DEBUGLEVEL >= 10) {
  19                 NDR_PRINT_IN_DEBUG(dfs_GetManagerVersion, &r);
  20         }
  21
  22         status = cli_do_rpc_ndr(cli,
  23                                 mem_ctx,
  24                                 PI_NETDFS,
  25                                 &ndr_table_netdfs,
  26                                 NDR_DFS_GETMANAGERVERSION,
  27                                 &r);
  28
  29         if (!NT_STATUS_IS_OK(status)) {
  30                 return status;
  31         }
  32
  33         if (DEBUGLEVEL >= 10) {
  34                 NDR_PRINT_OUT_DEBUG(dfs_GetManagerVersion, &r);
  35         }
  36
  37         if (NT_STATUS_IS_ERR(status)) {
  38                 return status;
  39         }
  40
  41         /* Return variables */
  42         *version = *r.out.version;
  43
  44         /* Return result */
  45         return NT_STATUS_OK;
  46 }
  47
  48 NTSTATUS rpccli_dfs_Add(struct rpc_pipe_client *cli,
  49                         TALLOC_CTX *mem_ctx,
  50                         const char *path /* [in] [ref,charset(UTF16)] */,
  51                         const char *server /* [in] [ref,charset(UTF16)] */,
  52                         const char *share /* [in] [unique,charset(UTF16)] */,
  53                         const char *comment /* [in] [unique,charset(UTF16)] */,
  54                         uint32_t flags /* [in]  */,
  55                         WERROR *werror)
  56 {
  57         struct dfs_Add r;
  58         NTSTATUS status;
  59
  60         /* In parameters */
  61         r.in.path = path;
  62         r.in.server = server;
  63         r.in.share = share;
  64         r.in.comment = comment;
  65         r.in.flags = flags;
  66
  67         if (DEBUGLEVEL >= 10) {
  68                 NDR_PRINT_IN_DEBUG(dfs_Add, &r);
  69         }
  70
  71         status = cli_do_rpc_ndr(cli,
  72                                 mem_ctx,
  73                                 PI_NETDFS,
  74                                 &ndr_table_netdfs,
  75                                 NDR_DFS_ADD,
  76                                 &r);
  77
  78         if (!NT_STATUS_IS_OK(status)) {
  79                 return status;
  80         }
  81
  82         if (DEBUGLEVEL >= 10) {
  83                 NDR_PRINT_OUT_DEBUG(dfs_Add, &r);
  84         }
  85
  86         if (NT_STATUS_IS_ERR(status)) {
  87                 return status;
  88         }
  89
  90         /* Return variables */
  91
  92         /* Return result */
  93         if (werror) {
  94                 *werror = r.out.result;
  95         }
  96
  97         return werror_to_ntstatus(r.out.result);
  98 }
  99
 100 NTSTATUS rpccli_dfs_Remove(struct rpc_pipe_client *cli,
 101                            TALLOC_CTX *mem_ctx,
 102                            const char *dfs_entry_path /* [in] [ref,charset(UTF16)] */,
 103                            const char *servername /* [in] [unique,charset(UTF16)] */,
 104                            const char *sharename /* [in] [unique,charset(UTF16)] */,
 105                            WERROR *werror)
 106 {
 107         struct dfs_Remove r;
 108         NTSTATUS status;
 109
 110         /* In parameters */
 111         r.in.dfs_entry_path = dfs_entry_path;
 112         r.in.servername = servername;
 113         r.in.sharename = sharename;
 114
 115         if (DEBUGLEVEL >= 10) {
 116                 NDR_PRINT_IN_DEBUG(dfs_Remove, &r);
 117         }
 118
 119         status = cli_do_rpc_ndr(cli,
 120                                 mem_ctx,
 121                                 PI_NETDFS,
 122                                 &ndr_table_netdfs,
 123                                 NDR_DFS_REMOVE,
 124                                 &r);
 125
 126         if (!NT_STATUS_IS_OK(status)) {
 127                 return status;
 128         }
 129
 130         if (DEBUGLEVEL >= 10) {
 131                 NDR_PRINT_OUT_DEBUG(dfs_Remove, &r);
 132         }
 133
 134         if (NT_STATUS_IS_ERR(status)) {
 135                 return status;
 136         }
 137
 138         /* Return variables */
 139
 140         /* Return result */
 141         if (werror) {
 142                 *werror = r.out.result;
 143         }
 144
 145         return werror_to_ntstatus(r.out.result);
 146 }
 147
 148 NTSTATUS rpccli_dfs_SetInfo(struct rpc_pipe_client *cli,
 149                             TALLOC_CTX *mem_ctx,
 150                             const char *dfs_entry_path /* [in] [charset(UTF16)] */,
 151                             const char *servername /* [in] [unique,charset(UTF16)] */,
 152                             const char *sharename /* [in] [unique,charset(UTF16)] */,
 153                             uint32_t level /* [in]  */,
 154                             union dfs_Info *info /* [in] [ref,switch_is(level)] */,
 155                             WERROR *werror)
 156 {
 157         struct dfs_SetInfo r;
 158         NTSTATUS status;
 159
 160         /* In parameters */
 161         r.in.dfs_entry_path = dfs_entry_path;
 162         r.in.servername = servername;
 163         r.in.sharename = sharename;
 164         r.in.level = level;
 165         r.in.info = info;
 166
 167         if (DEBUGLEVEL >= 10) {
 168                 NDR_PRINT_IN_DEBUG(dfs_SetInfo, &r);
 169         }
 170
 171         status = cli_do_rpc_ndr(cli,
 172                                 mem_ctx,
 173                                 PI_NETDFS,
 174                                 &ndr_table_netdfs,
 175                                 NDR_DFS_SETINFO,
 176                                 &r);
 177
 178         if (!NT_STATUS_IS_OK(status)) {
 179                 return status;
 180         }
 181
 182         if (DEBUGLEVEL >= 10) {
 183                 NDR_PRINT_OUT_DEBUG(dfs_SetInfo, &r);
 184         }
 185
 186         if (NT_STATUS_IS_ERR(status)) {
 187                 return status;
 188         }
 189
 190         /* Return variables */
 191
 192         /* Return result */
 193         if (werror) {
 194                 *werror = r.out.result;
 195         }
 196
 197         return werror_to_ntstatus(r.out.result);
 198 }
 199
 200 NTSTATUS rpccli_dfs_GetInfo(struct rpc_pipe_client *cli,
 201                             TALLOC_CTX *mem_ctx,
 202                             const char *dfs_entry_path /* [in] [charset(UTF16)] */,
 203                             const char *servername /* [in] [unique,charset(UTF16)] */,
 204                             const char *sharename /* [in] [unique,charset(UTF16)] */,
 205                             uint32_t level /* [in]  */,
 206                             union dfs_Info *info /* [out] [ref,switch_is(level)] */,
 207                             WERROR *werror)
 208 {
 209         struct dfs_GetInfo r;
 210         NTSTATUS status;
 211
 212         /* In parameters */
 213         r.in.dfs_entry_path = dfs_entry_path;
 214         r.in.servername = servername;
 215         r.in.sharename = sharename;
 216         r.in.level = level;
 217
 218         if (DEBUGLEVEL >= 10) {
 219                 NDR_PRINT_IN_DEBUG(dfs_GetInfo, &r);
 220         }
 221
 222         status = cli_do_rpc_ndr(cli,
 223                                 mem_ctx,
 224                                 PI_NETDFS,
 225                                 &ndr_table_netdfs,
 226                                 NDR_DFS_GETINFO,
 227                                 &r);
 228
 229         if (!NT_STATUS_IS_OK(status)) {
 230                 return status;
 231         }
 232
 233         if (DEBUGLEVEL >= 10) {
 234                 NDR_PRINT_OUT_DEBUG(dfs_GetInfo, &r);
 235         }
 236
 237         if (NT_STATUS_IS_ERR(status)) {
 238                 return status;
 239         }
 240
 241         /* Return variables */
 242         *info = *r.out.info;
 243
 244         /* Return result */
 245         if (werror) {
 246                 *werror = r.out.result;
 247         }
 248
 249         return werror_to_ntstatus(r.out.result);
 250 }
 251
 252 NTSTATUS rpccli_dfs_Enum(struct rpc_pipe_client *cli,
 253                          TALLOC_CTX *mem_ctx,
 254                          uint32_t level /* [in]  */,
 255                          uint32_t bufsize /* [in]  */,
 256                          struct dfs_EnumStruct *info /* [in,out] [unique] */,
 257                          uint32_t *total /* [in,out] [unique] */,
 258                          WERROR *werror)
 259 {
 260         struct dfs_Enum r;
 261         NTSTATUS status;
 262
 263         /* In parameters */
 264         r.in.level = level;
 265         r.in.bufsize = bufsize;
 266         r.in.info = info;
 267         r.in.total = total;
 268
 269         if (DEBUGLEVEL >= 10) {
 270                 NDR_PRINT_IN_DEBUG(dfs_Enum, &r);
 271         }
 272
 273         status = cli_do_rpc_ndr(cli,
 274                                 mem_ctx,
 275                                 PI_NETDFS,
 276                                 &ndr_table_netdfs,
 277                                 NDR_DFS_ENUM,
 278                                 &r);
 279
 280         if (!NT_STATUS_IS_OK(status)) {
 281                 return status;
 282         }
 283
 284         if (DEBUGLEVEL >= 10) {
 285                 NDR_PRINT_OUT_DEBUG(dfs_Enum, &r);
 286         }
 287
 288         if (NT_STATUS_IS_ERR(status)) {
 289                 return status;
 290         }
 291
 292         /* Return variables */
 293         if (info && r.out.info) {
 294                 *info = *r.out.info;
 295         }
 296         if (total && r.out.total) {
 297                 *total = *r.out.total;
 298         }
 299
 300         /* Return result */
 301         if (werror) {
 302                 *werror = r.out.result;
 303         }
 304
 305         return werror_to_ntstatus(r.out.result);
 306 }
 307
 308 NTSTATUS rpccli_dfs_Rename(struct rpc_pipe_client *cli,
 309                            TALLOC_CTX *mem_ctx,
 310                            WERROR *werror)
 311 {
 312         struct dfs_Rename r;
 313         NTSTATUS status;
 314
 315         /* In parameters */
 316
 317         if (DEBUGLEVEL >= 10) {
 318                 NDR_PRINT_IN_DEBUG(dfs_Rename, &r);
 319         }
 320
 321         status = cli_do_rpc_ndr(cli,
 322                                 mem_ctx,
 323                                 PI_NETDFS,
 324                                 &ndr_table_netdfs,
 325                                 NDR_DFS_RENAME,
 326                                 &r);
 327
 328         if (!NT_STATUS_IS_OK(status)) {
 329                 return status;
 330         }
 331
 332         if (DEBUGLEVEL >= 10) {
 333                 NDR_PRINT_OUT_DEBUG(dfs_Rename, &r);
 334         }
 335
 336         if (NT_STATUS_IS_ERR(status)) {
 337                 return status;
 338         }
 339
 340         /* Return variables */
 341
 342         /* Return result */
 343         if (werror) {
 344                 *werror = r.out.result;
 345         }
 346
 347         return werror_to_ntstatus(r.out.result);
 348 }
 349
 350 NTSTATUS rpccli_dfs_Move(struct rpc_pipe_client *cli,
 351                          TALLOC_CTX *mem_ctx,
 352                          WERROR *werror)
 353 {
 354         struct dfs_Move r;
 355         NTSTATUS status;
 356
 357         /* In parameters */
 358
 359         if (DEBUGLEVEL >= 10) {
 360                 NDR_PRINT_IN_DEBUG(dfs_Move, &r);
 361         }
 362
 363         status = cli_do_rpc_ndr(cli,
 364                                 mem_ctx,
 365                                 PI_NETDFS,
 366                                 &ndr_table_netdfs,
 367                                 NDR_DFS_MOVE,
 368                                 &r);
 369
 370         if (!NT_STATUS_IS_OK(status)) {
 371                 return status;
 372         }
 373
 374         if (DEBUGLEVEL >= 10) {
 375                 NDR_PRINT_OUT_DEBUG(dfs_Move, &r);
 376         }
 377
 378         if (NT_STATUS_IS_ERR(status)) {
 379                 return status;
 380         }
 381
 382         /* Return variables */
 383
 384         /* Return result */
 385         if (werror) {
 386                 *werror = r.out.result;
 387         }
 388
 389         return werror_to_ntstatus(r.out.result);
 390 }
 391
 392 NTSTATUS rpccli_dfs_ManagerGetConfigInfo(struct rpc_pipe_client *cli,
 393                                          TALLOC_CTX *mem_ctx,
 394                                          WERROR *werror)
 395 {
 396         struct dfs_ManagerGetConfigInfo r;
 397         NTSTATUS status;
 398
 399         /* In parameters */
 400
 401         if (DEBUGLEVEL >= 10) {
 402                 NDR_PRINT_IN_DEBUG(dfs_ManagerGetConfigInfo, &r);
 403         }
 404
 405         status = cli_do_rpc_ndr(cli,
 406                                 mem_ctx,
 407                                 PI_NETDFS,
 408                                 &ndr_table_netdfs,
 409                                 NDR_DFS_MANAGERGETCONFIGINFO,
 410                                 &r);
 411
 412         if (!NT_STATUS_IS_OK(status)) {
 413                 return status;
 414         }
 415
 416         if (DEBUGLEVEL >= 10) {
 417                 NDR_PRINT_OUT_DEBUG(dfs_ManagerGetConfigInfo, &r);
 418         }
 419
 420         if (NT_STATUS_IS_ERR(status)) {
 421                 return status;
 422         }
 423
 424         /* Return variables */
 425
 426         /* Return result */
 427         if (werror) {
 428                 *werror = r.out.result;
 429         }
 430
 431         return werror_to_ntstatus(r.out.result);
 432 }
 433
 434 NTSTATUS rpccli_dfs_ManagerSendSiteInfo(struct rpc_pipe_client *cli,
 435                                         TALLOC_CTX *mem_ctx,
 436                                         WERROR *werror)
 437 {
 438         struct dfs_ManagerSendSiteInfo r;
 439         NTSTATUS status;
 440
 441         /* In parameters */
 442
 443         if (DEBUGLEVEL >= 10) {
 444                 NDR_PRINT_IN_DEBUG(dfs_ManagerSendSiteInfo, &r);
 445         }
 446
 447         status = cli_do_rpc_ndr(cli,
 448                                 mem_ctx,
 449                                 PI_NETDFS,
 450                                 &ndr_table_netdfs,
 451                                 NDR_DFS_MANAGERSENDSITEINFO,
 452                                 &r);
 453
 454         if (!NT_STATUS_IS_OK(status)) {
 455                 return status;
 456         }
 457
 458         if (DEBUGLEVEL >= 10) {
 459                 NDR_PRINT_OUT_DEBUG(dfs_ManagerSendSiteInfo, &r);
 460         }
 461
 462         if (NT_STATUS_IS_ERR(status)) {
 463                 return status;
 464         }
 465
 466         /* Return variables */
 467
 468         /* Return result */
 469         if (werror) {
 470                 *werror = r.out.result;
 471         }
 472
 473         return werror_to_ntstatus(r.out.result);
 474 }
 475
 476 NTSTATUS rpccli_dfs_AddFtRoot(struct rpc_pipe_client *cli,
 477                               TALLOC_CTX *mem_ctx,
 478                               const char *servername /* [in] [charset(UTF16)] */,
 479                               const char *dns_servername /* [in] [charset(UTF16)] */,
 480                               const char *dfsname /* [in] [charset(UTF16)] */,
 481                               const char *rootshare /* [in] [charset(UTF16)] */,
 482                               const char *comment /* [in] [charset(UTF16)] */,
 483                               const char *dfs_config_dn /* [in] [charset(UTF16)] */,
 484                               uint8_t unknown1 /* [in]  */,
 485                               uint32_t flags /* [in]  */,
 486                               struct dfs_UnknownStruct **unknown2 /* [in,out] [unique] */,
 487                               WERROR *werror)
 488 {
 489         struct dfs_AddFtRoot r;
 490         NTSTATUS status;
 491
 492         /* In parameters */
 493         r.in.servername = servername;
 494         r.in.dns_servername = dns_servername;
 495         r.in.dfsname = dfsname;
 496         r.in.rootshare = rootshare;
 497         r.in.comment = comment;
 498         r.in.dfs_config_dn = dfs_config_dn;
 499         r.in.unknown1 = unknown1;
 500         r.in.flags = flags;
 501         r.in.unknown2 = unknown2;
 502
 503         if (DEBUGLEVEL >= 10) {
 504                 NDR_PRINT_IN_DEBUG(dfs_AddFtRoot, &r);
 505         }
 506
 507         status = cli_do_rpc_ndr(cli,
 508                                 mem_ctx,
 509                                 PI_NETDFS,
 510                                 &ndr_table_netdfs,
 511                                 NDR_DFS_ADDFTROOT,
 512                                 &r);
 513
 514         if (!NT_STATUS_IS_OK(status)) {
 515                 return status;
 516         }
 517
 518         if (DEBUGLEVEL >= 10) {
 519                 NDR_PRINT_OUT_DEBUG(dfs_AddFtRoot, &r);
 520         }
 521
 522         if (NT_STATUS_IS_ERR(status)) {
 523                 return status;
 524         }
 525
 526         /* Return variables */
 527         if (unknown2 && r.out.unknown2) {
 528                 *unknown2 = *r.out.unknown2;
 529         }
 530
 531         /* Return result */
 532         if (werror) {
 533                 *werror = r.out.result;
 534         }
 535
 536         return werror_to_ntstatus(r.out.result);
 537 }
 538
 539 NTSTATUS rpccli_dfs_RemoveFtRoot(struct rpc_pipe_client *cli,
 540                                  TALLOC_CTX *mem_ctx,
 541                                  const char *servername /* [in] [charset(UTF16)] */,
 542                                  const char *dns_servername /* [in] [charset(UTF16)] */,
 543                                  const char *dfsname /* [in] [charset(UTF16)] */,
 544                                  const char *rootshare /* [in] [charset(UTF16)] */,
 545                                  uint32_t flags /* [in]  */,
 546                                  struct dfs_UnknownStruct **unknown /* [in,out] [unique] */,
 547                                  WERROR *werror)
 548 {
 549         struct dfs_RemoveFtRoot r;
 550         NTSTATUS status;
 551
 552         /* In parameters */
 553         r.in.servername = servername;
 554         r.in.dns_servername = dns_servername;
 555         r.in.dfsname = dfsname;
 556         r.in.rootshare = rootshare;
 557         r.in.flags = flags;
 558         r.in.unknown = unknown;
 559
 560         if (DEBUGLEVEL >= 10) {
 561                 NDR_PRINT_IN_DEBUG(dfs_RemoveFtRoot, &r);
 562         }
 563
 564         status = cli_do_rpc_ndr(cli,
 565                                 mem_ctx,
 566                                 PI_NETDFS,
 567                                 &ndr_table_netdfs,
 568                                 NDR_DFS_REMOVEFTROOT,
 569                                 &r);
 570
 571         if (!NT_STATUS_IS_OK(status)) {
 572                 return status;
 573         }
 574
 575         if (DEBUGLEVEL >= 10) {
 576                 NDR_PRINT_OUT_DEBUG(dfs_RemoveFtRoot, &r);
 577         }
 578
 579         if (NT_STATUS_IS_ERR(status)) {
 580                 return status;
 581         }
 582
 583         /* Return variables */
 584         if (unknown && r.out.unknown) {
 585                 *unknown = *r.out.unknown;
 586         }
 587
 588         /* Return result */
 589         if (werror) {
 590                 *werror = r.out.result;
 591         }
 592
 593         return werror_to_ntstatus(r.out.result);
 594 }
 595
 596 NTSTATUS rpccli_dfs_AddStdRoot(struct rpc_pipe_client *cli,
 597                                TALLOC_CTX *mem_ctx,
 598                                const char *servername /* [in] [charset(UTF16)] */,
 599                                const char *rootshare /* [in] [charset(UTF16)] */,
 600                                const char *comment /* [in] [charset(UTF16)] */,
 601                                uint32_t flags /* [in]  */,
 602                                WERROR *werror)
 603 {
 604         struct dfs_AddStdRoot r;
 605         NTSTATUS status;
 606
 607         /* In parameters */
 608         r.in.servername = servername;
 609         r.in.rootshare = rootshare;
 610         r.in.comment = comment;
 611         r.in.flags = flags;
 612
 613         if (DEBUGLEVEL >= 10) {
 614                 NDR_PRINT_IN_DEBUG(dfs_AddStdRoot, &r);
 615         }
 616
 617         status = cli_do_rpc_ndr(cli,
 618                                 mem_ctx,
 619                                 PI_NETDFS,
 620                                 &ndr_table_netdfs,
 621                                 NDR_DFS_ADDSTDROOT,
 622                                 &r);
 623
 624         if (!NT_STATUS_IS_OK(status)) {
 625                 return status;
 626         }
 627
 628         if (DEBUGLEVEL >= 10) {
 629                 NDR_PRINT_OUT_DEBUG(dfs_AddStdRoot, &r);
 630         }
 631
 632         if (NT_STATUS_IS_ERR(status)) {
 633                 return status;
 634         }
 635
 636         /* Return variables */
 637
 638         /* Return result */
 639         if (werror) {
 640                 *werror = r.out.result;
 641         }
 642
 643         return werror_to_ntstatus(r.out.result);
 644 }
 645
 646 NTSTATUS rpccli_dfs_RemoveStdRoot(struct rpc_pipe_client *cli,
 647                                   TALLOC_CTX *mem_ctx,
 648                                   const char *servername /* [in] [charset(UTF16)] */,
 649                                   const char *rootshare /* [in] [charset(UTF16)] */,
 650                                   uint32_t flags /* [in]  */,
 651                                   WERROR *werror)
 652 {
 653         struct dfs_RemoveStdRoot r;
 654         NTSTATUS status;
 655
 656         /* In parameters */
 657         r.in.servername = servername;
 658         r.in.rootshare = rootshare;
 659         r.in.flags = flags;
 660
 661         if (DEBUGLEVEL >= 10) {
 662                 NDR_PRINT_IN_DEBUG(dfs_RemoveStdRoot, &r);
 663         }
 664
 665         status = cli_do_rpc_ndr(cli,
 666                                 mem_ctx,
 667                                 PI_NETDFS,
 668                                 &ndr_table_netdfs,
 669                                 NDR_DFS_REMOVESTDROOT,
 670                                 &r);
 671
 672         if (!NT_STATUS_IS_OK(status)) {
 673                 return status;
 674         }
 675
 676         if (DEBUGLEVEL >= 10) {
 677                 NDR_PRINT_OUT_DEBUG(dfs_RemoveStdRoot, &r);
 678         }
 679
 680         if (NT_STATUS_IS_ERR(status)) {
 681                 return status;
 682         }
 683
 684         /* Return variables */
 685
 686         /* Return result */
 687         if (werror) {
 688                 *werror = r.out.result;
 689         }
 690
 691         return werror_to_ntstatus(r.out.result);
 692 }
 693
 694 NTSTATUS rpccli_dfs_ManagerInitialize(struct rpc_pipe_client *cli,
 695                                       TALLOC_CTX *mem_ctx,
 696                                       const char *servername /* [in] [ref,charset(UTF16)] */,
 697                                       uint32_t flags /* [in]  */,
 698                                       WERROR *werror)
 699 {
 700         struct dfs_ManagerInitialize r;
 701         NTSTATUS status;
 702
 703         /* In parameters */
 704         r.in.servername = servername;
 705         r.in.flags = flags;
 706
 707         if (DEBUGLEVEL >= 10) {
 708                 NDR_PRINT_IN_DEBUG(dfs_ManagerInitialize, &r);
 709         }
 710
 711         status = cli_do_rpc_ndr(cli,
 712                                 mem_ctx,
 713                                 PI_NETDFS,
 714                                 &ndr_table_netdfs,
 715                                 NDR_DFS_MANAGERINITIALIZE,
 716                                 &r);
 717
 718         if (!NT_STATUS_IS_OK(status)) {
 719                 return status;
 720         }
 721
 722         if (DEBUGLEVEL >= 10) {
 723                 NDR_PRINT_OUT_DEBUG(dfs_ManagerInitialize, &r);
 724         }
 725
 726         if (NT_STATUS_IS_ERR(status)) {
 727                 return status;
 728         }
 729
 730         /* Return variables */
 731
 732         /* Return result */
 733         if (werror) {
 734                 *werror = r.out.result;
 735         }
 736
 737         return werror_to_ntstatus(r.out.result);
 738 }
 739
 740 NTSTATUS rpccli_dfs_AddStdRootForced(struct rpc_pipe_client *cli,
 741                                      TALLOC_CTX *mem_ctx,
 742                                      const char *servername /* [in] [charset(UTF16)] */,
 743                                      const char *rootshare /* [in] [charset(UTF16)] */,
 744                                      const char *comment /* [in] [charset(UTF16)] */,
 745                                      const char *store /* [in] [charset(UTF16)] */,
 746                                      WERROR *werror)
 747 {
 748         struct dfs_AddStdRootForced r;
 749         NTSTATUS status;
 750
 751         /* In parameters */
 752         r.in.servername = servername;
 753         r.in.rootshare = rootshare;
 754         r.in.comment = comment;
 755         r.in.store = store;
 756
 757         if (DEBUGLEVEL >= 10) {
 758                 NDR_PRINT_IN_DEBUG(dfs_AddStdRootForced, &r);
 759         }
 760
 761         status = cli_do_rpc_ndr(cli,
 762                                 mem_ctx,
 763                                 PI_NETDFS,
 764                                 &ndr_table_netdfs,
 765                                 NDR_DFS_ADDSTDROOTFORCED,
 766                                 &r);
 767
 768         if (!NT_STATUS_IS_OK(status)) {
 769                 return status;
 770         }
 771
 772         if (DEBUGLEVEL >= 10) {
 773                 NDR_PRINT_OUT_DEBUG(dfs_AddStdRootForced, &r);
 774         }
 775
 776         if (NT_STATUS_IS_ERR(status)) {
 777                 return status;
 778         }
 779
 780         /* Return variables */
 781
 782         /* Return result */
 783         if (werror) {
 784                 *werror = r.out.result;
 785         }
 786
 787         return werror_to_ntstatus(r.out.result);
 788 }
 789
 790 NTSTATUS rpccli_dfs_GetDcAddress(struct rpc_pipe_client *cli,
 791                                  TALLOC_CTX *mem_ctx,
 792                                  const char *servername /* [in] [charset(UTF16)] */,
 793                                  const char **server_fullname /* [in,out] [ref,charset(UTF16)] */,
 794                                  uint8_t *is_root /* [in,out] [ref] */,
 795                                  uint32_t *ttl /* [in,out] [ref] */,
 796                                  WERROR *werror)
 797 {
 798         struct dfs_GetDcAddress r;
 799         NTSTATUS status;
 800
 801         /* In parameters */
 802         r.in.servername = servername;
 803         r.in.server_fullname = server_fullname;
 804         r.in.is_root = is_root;
 805         r.in.ttl = ttl;
 806
 807         if (DEBUGLEVEL >= 10) {
 808                 NDR_PRINT_IN_DEBUG(dfs_GetDcAddress, &r);
 809         }
 810
 811         status = cli_do_rpc_ndr(cli,
 812                                 mem_ctx,
 813                                 PI_NETDFS,
 814                                 &ndr_table_netdfs,
 815                                 NDR_DFS_GETDCADDRESS,
 816                                 &r);
 817
 818         if (!NT_STATUS_IS_OK(status)) {
 819                 return status;
 820         }
 821
 822         if (DEBUGLEVEL >= 10) {
 823                 NDR_PRINT_OUT_DEBUG(dfs_GetDcAddress, &r);
 824         }
 825
 826         if (NT_STATUS_IS_ERR(status)) {
 827                 return status;
 828         }
 829
 830         /* Return variables */
 831         *server_fullname = *r.out.server_fullname;
 832         *is_root = *r.out.is_root;
 833         *ttl = *r.out.ttl;
 834
 835         /* Return result */
 836         if (werror) {
 837                 *werror = r.out.result;
 838         }
 839
 840         return werror_to_ntstatus(r.out.result);
 841 }
 842
 843 NTSTATUS rpccli_dfs_SetDcAddress(struct rpc_pipe_client *cli,
 844                                  TALLOC_CTX *mem_ctx,
 845                                  const char *servername /* [in] [charset(UTF16)] */,
 846                                  const char *server_fullname /* [in] [charset(UTF16)] */,
 847                                  uint32_t flags /* [in]  */,
 848                                  uint32_t ttl /* [in]  */,
 849                                  WERROR *werror)
 850 {
 851         struct dfs_SetDcAddress r;
 852         NTSTATUS status;
 853
 854         /* In parameters */
 855         r.in.servername = servername;
 856         r.in.server_fullname = server_fullname;
 857         r.in.flags = flags;
 858         r.in.ttl = ttl;
 859
 860         if (DEBUGLEVEL >= 10) {
 861                 NDR_PRINT_IN_DEBUG(dfs_SetDcAddress, &r);
 862         }
 863
 864         status = cli_do_rpc_ndr(cli,
 865                                 mem_ctx,
 866                                 PI_NETDFS,
 867                                 &ndr_table_netdfs,
 868                                 NDR_DFS_SETDCADDRESS,
 869                                 &r);
 870
 871         if (!NT_STATUS_IS_OK(status)) {
 872                 return status;
 873         }
 874
 875         if (DEBUGLEVEL >= 10) {
 876                 NDR_PRINT_OUT_DEBUG(dfs_SetDcAddress, &r);
 877         }
 878
 879         if (NT_STATUS_IS_ERR(status)) {
 880                 return status;
 881         }
 882
 883         /* Return variables */
 884
 885         /* Return result */
 886         if (werror) {
 887                 *werror = r.out.result;
 888         }
 889
 890         return werror_to_ntstatus(r.out.result);
 891 }
 892
 893 NTSTATUS rpccli_dfs_FlushFtTable(struct rpc_pipe_client *cli,
 894                                  TALLOC_CTX *mem_ctx,
 895                                  const char *servername /* [in] [charset(UTF16)] */,
 896                                  const char *rootshare /* [in] [charset(UTF16)] */,
 897                                  WERROR *werror)
 898 {
 899         struct dfs_FlushFtTable r;
 900         NTSTATUS status;
 901
 902         /* In parameters */
 903         r.in.servername = servername;
 904         r.in.rootshare = rootshare;
 905
 906         if (DEBUGLEVEL >= 10) {
 907                 NDR_PRINT_IN_DEBUG(dfs_FlushFtTable, &r);
 908         }
 909
 910         status = cli_do_rpc_ndr(cli,
 911                                 mem_ctx,
 912                                 PI_NETDFS,
 913                                 &ndr_table_netdfs,
 914                                 NDR_DFS_FLUSHFTTABLE,
 915                                 &r);
 916
 917         if (!NT_STATUS_IS_OK(status)) {
 918                 return status;
 919         }
 920
 921         if (DEBUGLEVEL >= 10) {
 922                 NDR_PRINT_OUT_DEBUG(dfs_FlushFtTable, &r);
 923         }
 924
 925         if (NT_STATUS_IS_ERR(status)) {
 926                 return status;
 927         }
 928
 929         /* Return variables */
 930
 931         /* Return result */
 932         if (werror) {
 933                 *werror = r.out.result;
 934         }
 935
 936         return werror_to_ntstatus(r.out.result);
 937 }
 938
 939 NTSTATUS rpccli_dfs_Add2(struct rpc_pipe_client *cli,
 940                          TALLOC_CTX *mem_ctx,
 941                          WERROR *werror)
 942 {
 943         struct dfs_Add2 r;
 944         NTSTATUS status;
 945
 946         /* In parameters */
 947
 948         if (DEBUGLEVEL >= 10) {
 949                 NDR_PRINT_IN_DEBUG(dfs_Add2, &r);
 950         }
 951
 952         status = cli_do_rpc_ndr(cli,
 953                                 mem_ctx,
 954                                 PI_NETDFS,
 955                                 &ndr_table_netdfs,
 956                                 NDR_DFS_ADD2,
 957                                 &r);
 958
 959         if (!NT_STATUS_IS_OK(status)) {
 960                 return status;
 961         }
 962
 963         if (DEBUGLEVEL >= 10) {
 964                 NDR_PRINT_OUT_DEBUG(dfs_Add2, &r);
 965         }
 966
 967         if (NT_STATUS_IS_ERR(status)) {
 968                 return status;
 969         }
 970
 971         /* Return variables */
 972
 973         /* Return result */
 974         if (werror) {
 975                 *werror = r.out.result;
 976         }
 977
 978         return werror_to_ntstatus(r.out.result);
 979 }
 980
 981 NTSTATUS rpccli_dfs_Remove2(struct rpc_pipe_client *cli,
 982                             TALLOC_CTX *mem_ctx,
 983                             WERROR *werror)
 984 {
 985         struct dfs_Remove2 r;
 986         NTSTATUS status;
 987
 988         /* In parameters */
 989
 990         if (DEBUGLEVEL >= 10) {
 991                 NDR_PRINT_IN_DEBUG(dfs_Remove2, &r);
 992         }
 993
 994         status = cli_do_rpc_ndr(cli,
 995                                 mem_ctx,
 996                                 PI_NETDFS,
 997                                 &ndr_table_netdfs,
 998                                 NDR_DFS_REMOVE2,
 999                                 &r);
1000
1001         if (!NT_STATUS_IS_OK(status)) {
1002                 return status;
1003         }
1004
1005         if (DEBUGLEVEL >= 10) {
1006                 NDR_PRINT_OUT_DEBUG(dfs_Remove2, &r);
1007         }
1008
1009         if (NT_STATUS_IS_ERR(status)) {
1010                 return status;
1011         }
1012
1013         /* Return variables */
1014
1015         /* Return result */
1016         if (werror) {
1017                 *werror = r.out.result;
1018         }
1019
1020         return werror_to_ntstatus(r.out.result);
1021 }
1022
1023 NTSTATUS rpccli_dfs_EnumEx(struct rpc_pipe_client *cli,
1024                            TALLOC_CTX *mem_ctx,
1025                            const char *dfs_name /* [in] [charset(UTF16)] */,
1026                            uint32_t level /* [in]  */,
1027                            uint32_t bufsize /* [in]  */,
1028                            struct dfs_EnumStruct *info /* [in,out] [unique] */,
1029                            uint32_t *total /* [in,out] [unique] */,
1030                            WERROR *werror)
1031 {
1032         struct dfs_EnumEx r;
1033         NTSTATUS status;
1034
1035         /* In parameters */
1036         r.in.dfs_name = dfs_name;
1037         r.in.level = level;
1038         r.in.bufsize = bufsize;
1039         r.in.info = info;
1040         r.in.total = total;
1041
1042         if (DEBUGLEVEL >= 10) {
1043                 NDR_PRINT_IN_DEBUG(dfs_EnumEx, &r);
1044         }
1045
1046         status = cli_do_rpc_ndr(cli,
1047                                 mem_ctx,
1048                                 PI_NETDFS,
1049                                 &ndr_table_netdfs,
1050                                 NDR_DFS_ENUMEX,
1051                                 &r);
1052
1053         if (!NT_STATUS_IS_OK(status)) {
1054                 return status;
1055         }
1056
1057         if (DEBUGLEVEL >= 10) {
1058                 NDR_PRINT_OUT_DEBUG(dfs_EnumEx, &r);
1059         }
1060
1061         if (NT_STATUS_IS_ERR(status)) {
1062                 return status;
1063         }
1064
1065         /* Return variables */
1066         if (info && r.out.info) {
1067                 *info = *r.out.info;
1068         }
1069         if (total && r.out.total) {
1070                 *total = *r.out.total;
1071         }
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_dfs_SetInfo2(struct rpc_pipe_client *cli,
1082                              TALLOC_CTX *mem_ctx,
1083                              WERROR *werror)
1084 {
1085         struct dfs_SetInfo2 r;
1086         NTSTATUS status;
1087
1088         /* In parameters */
1089
1090         if (DEBUGLEVEL >= 10) {
1091                 NDR_PRINT_IN_DEBUG(dfs_SetInfo2, &r);
1092         }
1093
1094         status = cli_do_rpc_ndr(cli,
1095                                 mem_ctx,
1096                                 PI_NETDFS,
1097                                 &ndr_table_netdfs,
1098                                 NDR_DFS_SETINFO2,
1099                                 &r);
1100
1101         if (!NT_STATUS_IS_OK(status)) {
1102                 return status;
1103         }
1104
1105         if (DEBUGLEVEL >= 10) {
1106                 NDR_PRINT_OUT_DEBUG(dfs_SetInfo2, &r);
1107         }
1108
1109         if (NT_STATUS_IS_ERR(status)) {
1110                 return status;
1111         }
1112
1113         /* Return variables */
1114
1115         /* Return result */
1116         if (werror) {
1117                 *werror = r.out.result;
1118         }
1119
1120         return werror_to_ntstatus(r.out.result);
1121 }
1122