source3/lib/netapi/libnetapi.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  NetApi Support
   4  *  Copyright (C) Guenther Deschner 2007-2008
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 3 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "includes.h"
  21 #include "librpc/gen_ndr/libnetapi.h"
  22 #include "lib/netapi/netapi.h"
  23 #include "lib/netapi/netapi_private.h"
  24 #include "lib/netapi/libnetapi.h"
  25 #include "librpc/gen_ndr/ndr_libnetapi.h"
  26
  27 /****************************************************************
  28  NetJoinDomain
  29 ****************************************************************/
  30
  31 NET_API_STATUS NetJoinDomain(const char * server /* [in] [unique] */,
  32                              const char * domain /* [in] [ref] */,
  33                              const char * account_ou /* [in] [unique] */,
  34                              const char * account /* [in] [unique] */,
  35                              const char * password /* [in] [unique] */,
  36                              uint32_t join_flags /* [in] */)
  37 {
  38         struct NetJoinDomain r;
  39         struct libnetapi_ctx *ctx = NULL;
  40         NET_API_STATUS status;
  41         WERROR werr;
  42         TALLOC_CTX *frame = talloc_stackframe();
  43
  44         ZERO_STRUCT(r);
  45
  46         status = libnetapi_getctx(&ctx);
  47         if (status != 0) {
  48                 TALLOC_FREE(frame);
  49                 return status;
  50         }
  51
  52         /* In parameters */
  53         r.in.server = server;
  54         r.in.domain = domain;
  55         r.in.account_ou = account_ou;
  56         r.in.account = account;
  57         r.in.password = password;
  58         r.in.join_flags = join_flags;
  59
  60         /* Out parameters */
  61
  62         if (DEBUGLEVEL >= 10) {
  63                 NDR_PRINT_IN_DEBUG(NetJoinDomain, &r);
  64         }
  65
  66         if (LIBNETAPI_LOCAL_SERVER(server)) {
  67                 werr = NetJoinDomain_l(ctx, &r);
  68         } else {
  69                 werr = NetJoinDomain_r(ctx, &r);
  70         }
  71
  72         r.out.result = W_ERROR_V(werr);
  73
  74         if (DEBUGLEVEL >= 10) {
  75                 NDR_PRINT_OUT_DEBUG(NetJoinDomain, &r);
  76         }
  77
  78         TALLOC_FREE(frame);
  79         return (NET_API_STATUS)r.out.result;
  80 }
  81
  82 /****************************************************************
  83  NetUnjoinDomain
  84 ****************************************************************/
  85
  86 NET_API_STATUS NetUnjoinDomain(const char * server_name /* [in] [unique] */,
  87                                const char * account /* [in] [unique] */,
  88                                const char * password /* [in] [unique] */,
  89                                uint32_t unjoin_flags /* [in] */)
  90 {
  91         struct NetUnjoinDomain r;
  92         struct libnetapi_ctx *ctx = NULL;
  93         NET_API_STATUS status;
  94         WERROR werr;
  95         TALLOC_CTX *frame = talloc_stackframe();
  96
  97         ZERO_STRUCT(r);
  98
  99         status = libnetapi_getctx(&ctx);
 100         if (status != 0) {
 101                 TALLOC_FREE(frame);
 102                 return status;
 103         }
 104
 105         /* In parameters */
 106         r.in.server_name = server_name;
 107         r.in.account = account;
 108         r.in.password = password;
 109         r.in.unjoin_flags = unjoin_flags;
 110
 111         /* Out parameters */
 112
 113         if (DEBUGLEVEL >= 10) {
 114                 NDR_PRINT_IN_DEBUG(NetUnjoinDomain, &r);
 115         }
 116
 117         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 118                 werr = NetUnjoinDomain_l(ctx, &r);
 119         } else {
 120                 werr = NetUnjoinDomain_r(ctx, &r);
 121         }
 122
 123         r.out.result = W_ERROR_V(werr);
 124
 125         if (DEBUGLEVEL >= 10) {
 126                 NDR_PRINT_OUT_DEBUG(NetUnjoinDomain, &r);
 127         }
 128
 129         TALLOC_FREE(frame);
 130         return (NET_API_STATUS)r.out.result;
 131 }
 132
 133 /****************************************************************
 134  NetGetJoinInformation
 135 ****************************************************************/
 136
 137 NET_API_STATUS NetGetJoinInformation(const char * server_name /* [in] [unique] */,
 138                                      const char * *name_buffer /* [out] [ref] */,
 139                                      uint16_t *name_type /* [out] [ref] */)
 140 {
 141         struct NetGetJoinInformation r;
 142         struct libnetapi_ctx *ctx = NULL;
 143         NET_API_STATUS status;
 144         WERROR werr;
 145         TALLOC_CTX *frame = talloc_stackframe();
 146
 147         ZERO_STRUCT(r);
 148
 149         status = libnetapi_getctx(&ctx);
 150         if (status != 0) {
 151                 TALLOC_FREE(frame);
 152                 return status;
 153         }
 154
 155         /* In parameters */
 156         r.in.server_name = server_name;
 157
 158         /* Out parameters */
 159         r.out.name_buffer = name_buffer;
 160         r.out.name_type = name_type;
 161
 162         if (DEBUGLEVEL >= 10) {
 163                 NDR_PRINT_IN_DEBUG(NetGetJoinInformation, &r);
 164         }
 165
 166         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 167                 werr = NetGetJoinInformation_l(ctx, &r);
 168         } else {
 169                 werr = NetGetJoinInformation_r(ctx, &r);
 170         }
 171
 172         r.out.result = W_ERROR_V(werr);
 173
 174         if (DEBUGLEVEL >= 10) {
 175                 NDR_PRINT_OUT_DEBUG(NetGetJoinInformation, &r);
 176         }
 177
 178         TALLOC_FREE(frame);
 179         return (NET_API_STATUS)r.out.result;
 180 }
 181
 182 /****************************************************************
 183  NetGetJoinableOUs
 184 ****************************************************************/
 185
 186 NET_API_STATUS NetGetJoinableOUs(const char * server_name /* [in] [unique] */,
 187                                  const char * domain /* [in] [ref] */,
 188                                  const char * account /* [in] [unique] */,
 189                                  const char * password /* [in] [unique] */,
 190                                  uint32_t *ou_count /* [out] [ref] */,
 191                                  const char * **ous /* [out] [ref] */)
 192 {
 193         struct NetGetJoinableOUs r;
 194         struct libnetapi_ctx *ctx = NULL;
 195         NET_API_STATUS status;
 196         WERROR werr;
 197         TALLOC_CTX *frame = talloc_stackframe();
 198
 199         ZERO_STRUCT(r);
 200
 201         status = libnetapi_getctx(&ctx);
 202         if (status != 0) {
 203                 TALLOC_FREE(frame);
 204                 return status;
 205         }
 206
 207         /* In parameters */
 208         r.in.server_name = server_name;
 209         r.in.domain = domain;
 210         r.in.account = account;
 211         r.in.password = password;
 212
 213         /* Out parameters */
 214         r.out.ou_count = ou_count;
 215         r.out.ous = ous;
 216
 217         if (DEBUGLEVEL >= 10) {
 218                 NDR_PRINT_IN_DEBUG(NetGetJoinableOUs, &r);
 219         }
 220
 221         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 222                 werr = NetGetJoinableOUs_l(ctx, &r);
 223         } else {
 224                 werr = NetGetJoinableOUs_r(ctx, &r);
 225         }
 226
 227         r.out.result = W_ERROR_V(werr);
 228
 229         if (DEBUGLEVEL >= 10) {
 230                 NDR_PRINT_OUT_DEBUG(NetGetJoinableOUs, &r);
 231         }
 232
 233         TALLOC_FREE(frame);
 234         return (NET_API_STATUS)r.out.result;
 235 }
 236
 237 /****************************************************************
 238  NetRenameMachineInDomain
 239 ****************************************************************/
 240
 241 NET_API_STATUS NetRenameMachineInDomain(const char * server_name /* [in] */,
 242                                         const char * new_machine_name /* [in] */,
 243                                         const char * account /* [in] */,
 244                                         const char * password /* [in] */,
 245                                         uint32_t rename_options /* [in] */)
 246 {
 247         struct NetRenameMachineInDomain r;
 248         struct libnetapi_ctx *ctx = NULL;
 249         NET_API_STATUS status;
 250         WERROR werr;
 251         TALLOC_CTX *frame = talloc_stackframe();
 252
 253         ZERO_STRUCT(r);
 254
 255         status = libnetapi_getctx(&ctx);
 256         if (status != 0) {
 257                 TALLOC_FREE(frame);
 258                 return status;
 259         }
 260
 261         /* In parameters */
 262         r.in.server_name = server_name;
 263         r.in.new_machine_name = new_machine_name;
 264         r.in.account = account;
 265         r.in.password = password;
 266         r.in.rename_options = rename_options;
 267
 268         /* Out parameters */
 269
 270         if (DEBUGLEVEL >= 10) {
 271                 NDR_PRINT_IN_DEBUG(NetRenameMachineInDomain, &r);
 272         }
 273
 274         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 275                 werr = NetRenameMachineInDomain_l(ctx, &r);
 276         } else {
 277                 werr = NetRenameMachineInDomain_r(ctx, &r);
 278         }
 279
 280         r.out.result = W_ERROR_V(werr);
 281
 282         if (DEBUGLEVEL >= 10) {
 283                 NDR_PRINT_OUT_DEBUG(NetRenameMachineInDomain, &r);
 284         }
 285
 286         TALLOC_FREE(frame);
 287         return (NET_API_STATUS)r.out.result;
 288 }
 289
 290 /****************************************************************
 291  NetProvisionComputerAccount
 292 ****************************************************************/
 293
 294 NET_API_STATUS NetProvisionComputerAccount(const char * domain /* [in] [ref] */,
 295                                            const char * machine_name /* [in] [ref] */,
 296                                            const char * machine_account_ou /* [in] [unique] */,
 297                                            const char * dcname /* [in] [unique] */,
 298                                            uint32_t options /* [in] */,
 299                                            uint8_t **provision_bin_data /* [in,out] [unique] */,
 300                                            uint32_t *provision_bin_data_size /* [in,out] [unique] */,
 301                                            const char * *provision_text_data /* [in,out] [unique] */)
 302 {
 303         struct NetProvisionComputerAccount r;
 304         struct libnetapi_ctx *ctx = NULL;
 305         NET_API_STATUS status;
 306         WERROR werr;
 307         TALLOC_CTX *frame = talloc_stackframe();
 308
 309         ZERO_STRUCT(r);
 310
 311         status = libnetapi_getctx(&ctx);
 312         if (status != 0) {
 313                 TALLOC_FREE(frame);
 314                 return status;
 315         }
 316
 317         /* In parameters */
 318         r.in.domain = domain;
 319         r.in.machine_name = machine_name;
 320         r.in.machine_account_ou = machine_account_ou;
 321         r.in.dcname = dcname;
 322         r.in.options = options;
 323         r.in.provision_bin_data = provision_bin_data;
 324         r.in.provision_bin_data_size = provision_bin_data_size;
 325         r.in.provision_text_data = provision_text_data;
 326
 327         /* Out parameters */
 328         r.out.provision_bin_data = provision_bin_data;
 329         r.out.provision_bin_data_size = provision_bin_data_size;
 330         r.out.provision_text_data = provision_text_data;
 331
 332         if (DEBUGLEVEL >= 10) {
 333                 NDR_PRINT_IN_DEBUG(NetProvisionComputerAccount, &r);
 334         }
 335
 336         werr = NetProvisionComputerAccount_l(ctx, &r);
 337
 338         r.out.result = W_ERROR_V(werr);
 339
 340         if (DEBUGLEVEL >= 10) {
 341                 NDR_PRINT_OUT_DEBUG(NetProvisionComputerAccount, &r);
 342         }
 343
 344         TALLOC_FREE(frame);
 345         return (NET_API_STATUS)r.out.result;
 346 }
 347
 348 /****************************************************************
 349  NetRequestOfflineDomainJoin
 350 ****************************************************************/
 351
 352 NET_API_STATUS NetRequestOfflineDomainJoin(uint8_t *provision_bin_data /* [in] [unique] */,
 353                                            uint32_t provision_bin_data_size /* [in] */,
 354                                            uint32_t options /* [in] */,
 355                                            const char * windows_path /* [in] [unique] */)
 356 {
 357         struct NetRequestOfflineDomainJoin r;
 358         struct libnetapi_ctx *ctx = NULL;
 359         NET_API_STATUS status;
 360         WERROR werr;
 361         TALLOC_CTX *frame = talloc_stackframe();
 362
 363         ZERO_STRUCT(r);
 364
 365         status = libnetapi_getctx(&ctx);
 366         if (status != 0) {
 367                 TALLOC_FREE(frame);
 368                 return status;
 369         }
 370
 371         /* In parameters */
 372         r.in.provision_bin_data = provision_bin_data;
 373         r.in.provision_bin_data_size = provision_bin_data_size;
 374         r.in.options = options;
 375         r.in.windows_path = windows_path;
 376
 377         /* Out parameters */
 378
 379         if (DEBUGLEVEL >= 10) {
 380                 NDR_PRINT_IN_DEBUG(NetRequestOfflineDomainJoin, &r);
 381         }
 382
 383         werr = NetRequestOfflineDomainJoin_l(ctx, &r);
 384
 385         r.out.result = W_ERROR_V(werr);
 386
 387         if (DEBUGLEVEL >= 10) {
 388                 NDR_PRINT_OUT_DEBUG(NetRequestOfflineDomainJoin, &r);
 389         }
 390
 391         TALLOC_FREE(frame);
 392         return (NET_API_STATUS)r.out.result;
 393 }
 394
 395 /****************************************************************
 396  NetServerGetInfo
 397 ****************************************************************/
 398
 399 NET_API_STATUS NetServerGetInfo(const char * server_name /* [in] [unique] */,
 400                                 uint32_t level /* [in] */,
 401                                 uint8_t **buffer /* [out] [ref] */)
 402 {
 403         struct NetServerGetInfo r;
 404         struct libnetapi_ctx *ctx = NULL;
 405         NET_API_STATUS status;
 406         WERROR werr;
 407         TALLOC_CTX *frame = talloc_stackframe();
 408
 409         ZERO_STRUCT(r);
 410
 411         status = libnetapi_getctx(&ctx);
 412         if (status != 0) {
 413                 TALLOC_FREE(frame);
 414                 return status;
 415         }
 416
 417         /* In parameters */
 418         r.in.server_name = server_name;
 419         r.in.level = level;
 420
 421         /* Out parameters */
 422         r.out.buffer = buffer;
 423
 424         if (DEBUGLEVEL >= 10) {
 425                 NDR_PRINT_IN_DEBUG(NetServerGetInfo, &r);
 426         }
 427
 428         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 429                 werr = NetServerGetInfo_l(ctx, &r);
 430         } else {
 431                 werr = NetServerGetInfo_r(ctx, &r);
 432         }
 433
 434         r.out.result = W_ERROR_V(werr);
 435
 436         if (DEBUGLEVEL >= 10) {
 437                 NDR_PRINT_OUT_DEBUG(NetServerGetInfo, &r);
 438         }
 439
 440         TALLOC_FREE(frame);
 441         return (NET_API_STATUS)r.out.result;
 442 }
 443
 444 /****************************************************************
 445  NetServerSetInfo
 446 ****************************************************************/
 447
 448 NET_API_STATUS NetServerSetInfo(const char * server_name /* [in] [unique] */,
 449                                 uint32_t level /* [in] */,
 450                                 uint8_t *buffer /* [in] [ref] */,
 451                                 uint32_t *parm_error /* [out] [ref] */)
 452 {
 453         struct NetServerSetInfo r;
 454         struct libnetapi_ctx *ctx = NULL;
 455         NET_API_STATUS status;
 456         WERROR werr;
 457         TALLOC_CTX *frame = talloc_stackframe();
 458
 459         ZERO_STRUCT(r);
 460
 461         status = libnetapi_getctx(&ctx);
 462         if (status != 0) {
 463                 TALLOC_FREE(frame);
 464                 return status;
 465         }
 466
 467         /* In parameters */
 468         r.in.server_name = server_name;
 469         r.in.level = level;
 470         r.in.buffer = buffer;
 471
 472         /* Out parameters */
 473         r.out.parm_error = parm_error;
 474
 475         if (DEBUGLEVEL >= 10) {
 476                 NDR_PRINT_IN_DEBUG(NetServerSetInfo, &r);
 477         }
 478
 479         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 480                 werr = NetServerSetInfo_l(ctx, &r);
 481         } else {
 482                 werr = NetServerSetInfo_r(ctx, &r);
 483         }
 484
 485         r.out.result = W_ERROR_V(werr);
 486
 487         if (DEBUGLEVEL >= 10) {
 488                 NDR_PRINT_OUT_DEBUG(NetServerSetInfo, &r);
 489         }
 490
 491         TALLOC_FREE(frame);
 492         return (NET_API_STATUS)r.out.result;
 493 }
 494
 495 /****************************************************************
 496  NetWkstaGetInfo
 497 ****************************************************************/
 498
 499 NET_API_STATUS NetWkstaGetInfo(const char * server_name /* [in] [unique] */,
 500                                uint32_t level /* [in] */,
 501                                uint8_t **buffer /* [out] [ref] */)
 502 {
 503         struct NetWkstaGetInfo r;
 504         struct libnetapi_ctx *ctx = NULL;
 505         NET_API_STATUS status;
 506         WERROR werr;
 507         TALLOC_CTX *frame = talloc_stackframe();
 508
 509         ZERO_STRUCT(r);
 510
 511         status = libnetapi_getctx(&ctx);
 512         if (status != 0) {
 513                 TALLOC_FREE(frame);
 514                 return status;
 515         }
 516
 517         /* In parameters */
 518         r.in.server_name = server_name;
 519         r.in.level = level;
 520
 521         /* Out parameters */
 522         r.out.buffer = buffer;
 523
 524         if (DEBUGLEVEL >= 10) {
 525                 NDR_PRINT_IN_DEBUG(NetWkstaGetInfo, &r);
 526         }
 527
 528         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 529                 werr = NetWkstaGetInfo_l(ctx, &r);
 530         } else {
 531                 werr = NetWkstaGetInfo_r(ctx, &r);
 532         }
 533
 534         r.out.result = W_ERROR_V(werr);
 535
 536         if (DEBUGLEVEL >= 10) {
 537                 NDR_PRINT_OUT_DEBUG(NetWkstaGetInfo, &r);
 538         }
 539
 540         TALLOC_FREE(frame);
 541         return (NET_API_STATUS)r.out.result;
 542 }
 543
 544 /****************************************************************
 545  NetGetDCName
 546 ****************************************************************/
 547
 548 NET_API_STATUS NetGetDCName(const char * server_name /* [in] [unique] */,
 549                             const char * domain_name /* [in] [unique] */,
 550                             uint8_t **buffer /* [out] [ref] */)
 551 {
 552         struct NetGetDCName r;
 553         struct libnetapi_ctx *ctx = NULL;
 554         NET_API_STATUS status;
 555         WERROR werr;
 556         TALLOC_CTX *frame = talloc_stackframe();
 557
 558         ZERO_STRUCT(r);
 559
 560         status = libnetapi_getctx(&ctx);
 561         if (status != 0) {
 562                 TALLOC_FREE(frame);
 563                 return status;
 564         }
 565
 566         /* In parameters */
 567         r.in.server_name = server_name;
 568         r.in.domain_name = domain_name;
 569
 570         /* Out parameters */
 571         r.out.buffer = buffer;
 572
 573         if (DEBUGLEVEL >= 10) {
 574                 NDR_PRINT_IN_DEBUG(NetGetDCName, &r);
 575         }
 576
 577         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 578                 werr = NetGetDCName_l(ctx, &r);
 579         } else {
 580                 werr = NetGetDCName_r(ctx, &r);
 581         }
 582
 583         r.out.result = W_ERROR_V(werr);
 584
 585         if (DEBUGLEVEL >= 10) {
 586                 NDR_PRINT_OUT_DEBUG(NetGetDCName, &r);
 587         }
 588
 589         TALLOC_FREE(frame);
 590         return (NET_API_STATUS)r.out.result;
 591 }
 592
 593 /****************************************************************
 594  NetGetAnyDCName
 595 ****************************************************************/
 596
 597 NET_API_STATUS NetGetAnyDCName(const char * server_name /* [in] [unique] */,
 598                                const char * domain_name /* [in] [unique] */,
 599                                uint8_t **buffer /* [out] [ref] */)
 600 {
 601         struct NetGetAnyDCName r;
 602         struct libnetapi_ctx *ctx = NULL;
 603         NET_API_STATUS status;
 604         WERROR werr;
 605         TALLOC_CTX *frame = talloc_stackframe();
 606
 607         ZERO_STRUCT(r);
 608
 609         status = libnetapi_getctx(&ctx);
 610         if (status != 0) {
 611                 TALLOC_FREE(frame);
 612                 return status;
 613         }
 614
 615         /* In parameters */
 616         r.in.server_name = server_name;
 617         r.in.domain_name = domain_name;
 618
 619         /* Out parameters */
 620         r.out.buffer = buffer;
 621
 622         if (DEBUGLEVEL >= 10) {
 623                 NDR_PRINT_IN_DEBUG(NetGetAnyDCName, &r);
 624         }
 625
 626         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 627                 werr = NetGetAnyDCName_l(ctx, &r);
 628         } else {
 629                 werr = NetGetAnyDCName_r(ctx, &r);
 630         }
 631
 632         r.out.result = W_ERROR_V(werr);
 633
 634         if (DEBUGLEVEL >= 10) {
 635                 NDR_PRINT_OUT_DEBUG(NetGetAnyDCName, &r);
 636         }
 637
 638         TALLOC_FREE(frame);
 639         return (NET_API_STATUS)r.out.result;
 640 }
 641
 642 /****************************************************************
 643  DsGetDcName
 644 ****************************************************************/
 645
 646 NET_API_STATUS DsGetDcName(const char * server_name /* [in] [unique] */,
 647                            const char * domain_name /* [in] [ref] */,
 648                            struct GUID *domain_guid /* [in] [unique] */,
 649                            const char * site_name /* [in] [unique] */,
 650                            uint32_t flags /* [in] */,
 651                            struct DOMAIN_CONTROLLER_INFO **dc_info /* [out] [ref] */)
 652 {
 653         struct DsGetDcName r;
 654         struct libnetapi_ctx *ctx = NULL;
 655         NET_API_STATUS status;
 656         WERROR werr;
 657         TALLOC_CTX *frame = talloc_stackframe();
 658
 659         ZERO_STRUCT(r);
 660
 661         status = libnetapi_getctx(&ctx);
 662         if (status != 0) {
 663                 TALLOC_FREE(frame);
 664                 return status;
 665         }
 666
 667         /* In parameters */
 668         r.in.server_name = server_name;
 669         r.in.domain_name = domain_name;
 670         r.in.domain_guid = domain_guid;
 671         r.in.site_name = site_name;
 672         r.in.flags = flags;
 673
 674         /* Out parameters */
 675         r.out.dc_info = dc_info;
 676
 677         if (DEBUGLEVEL >= 10) {
 678                 NDR_PRINT_IN_DEBUG(DsGetDcName, &r);
 679         }
 680
 681         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 682                 werr = DsGetDcName_l(ctx, &r);
 683         } else {
 684                 werr = DsGetDcName_r(ctx, &r);
 685         }
 686
 687         r.out.result = W_ERROR_V(werr);
 688
 689         if (DEBUGLEVEL >= 10) {
 690                 NDR_PRINT_OUT_DEBUG(DsGetDcName, &r);
 691         }
 692
 693         TALLOC_FREE(frame);
 694         return (NET_API_STATUS)r.out.result;
 695 }
 696
 697 /****************************************************************
 698  NetUserAdd
 699 ****************************************************************/
 700
 701 NET_API_STATUS NetUserAdd(const char * server_name /* [in] [unique] */,
 702                           uint32_t level /* [in] */,
 703                           uint8_t *buffer /* [in] [ref] */,
 704                           uint32_t *parm_error /* [out] [ref] */)
 705 {
 706         struct NetUserAdd r;
 707         struct libnetapi_ctx *ctx = NULL;
 708         NET_API_STATUS status;
 709         WERROR werr;
 710         TALLOC_CTX *frame = talloc_stackframe();
 711
 712         ZERO_STRUCT(r);
 713
 714         status = libnetapi_getctx(&ctx);
 715         if (status != 0) {
 716                 TALLOC_FREE(frame);
 717                 return status;
 718         }
 719
 720         /* In parameters */
 721         r.in.server_name = server_name;
 722         r.in.level = level;
 723         r.in.buffer = buffer;
 724
 725         /* Out parameters */
 726         r.out.parm_error = parm_error;
 727
 728         if (DEBUGLEVEL >= 10) {
 729                 NDR_PRINT_IN_DEBUG(NetUserAdd, &r);
 730         }
 731
 732         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 733                 werr = NetUserAdd_l(ctx, &r);
 734         } else {
 735                 werr = NetUserAdd_r(ctx, &r);
 736         }
 737
 738         r.out.result = W_ERROR_V(werr);
 739
 740         if (DEBUGLEVEL >= 10) {
 741                 NDR_PRINT_OUT_DEBUG(NetUserAdd, &r);
 742         }
 743
 744         TALLOC_FREE(frame);
 745         return (NET_API_STATUS)r.out.result;
 746 }
 747
 748 /****************************************************************
 749  NetUserDel
 750 ****************************************************************/
 751
 752 NET_API_STATUS NetUserDel(const char * server_name /* [in] [unique] */,
 753                           const char * user_name /* [in] [ref] */)
 754 {
 755         struct NetUserDel r;
 756         struct libnetapi_ctx *ctx = NULL;
 757         NET_API_STATUS status;
 758         WERROR werr;
 759         TALLOC_CTX *frame = talloc_stackframe();
 760
 761         ZERO_STRUCT(r);
 762
 763         status = libnetapi_getctx(&ctx);
 764         if (status != 0) {
 765                 TALLOC_FREE(frame);
 766                 return status;
 767         }
 768
 769         /* In parameters */
 770         r.in.server_name = server_name;
 771         r.in.user_name = user_name;
 772
 773         /* Out parameters */
 774
 775         if (DEBUGLEVEL >= 10) {
 776                 NDR_PRINT_IN_DEBUG(NetUserDel, &r);
 777         }
 778
 779         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 780                 werr = NetUserDel_l(ctx, &r);
 781         } else {
 782                 werr = NetUserDel_r(ctx, &r);
 783         }
 784
 785         r.out.result = W_ERROR_V(werr);
 786
 787         if (DEBUGLEVEL >= 10) {
 788                 NDR_PRINT_OUT_DEBUG(NetUserDel, &r);
 789         }
 790
 791         TALLOC_FREE(frame);
 792         return (NET_API_STATUS)r.out.result;
 793 }
 794
 795 /****************************************************************
 796  NetUserEnum
 797 ****************************************************************/
 798
 799 NET_API_STATUS NetUserEnum(const char * server_name /* [in] [unique] */,
 800                            uint32_t level /* [in] */,
 801                            uint32_t filter /* [in] */,
 802                            uint8_t **buffer /* [out] [ref] */,
 803                            uint32_t prefmaxlen /* [in] */,
 804                            uint32_t *entries_read /* [out] [ref] */,
 805                            uint32_t *total_entries /* [out] [ref] */,
 806                            uint32_t *resume_handle /* [in,out] [ref] */)
 807 {
 808         struct NetUserEnum r;
 809         struct libnetapi_ctx *ctx = NULL;
 810         NET_API_STATUS status;
 811         WERROR werr;
 812         TALLOC_CTX *frame = talloc_stackframe();
 813
 814         ZERO_STRUCT(r);
 815
 816         status = libnetapi_getctx(&ctx);
 817         if (status != 0) {
 818                 TALLOC_FREE(frame);
 819                 return status;
 820         }
 821
 822         /* In parameters */
 823         r.in.server_name = server_name;
 824         r.in.level = level;
 825         r.in.filter = filter;
 826         r.in.prefmaxlen = prefmaxlen;
 827         r.in.resume_handle = resume_handle;
 828
 829         /* Out parameters */
 830         r.out.buffer = buffer;
 831         r.out.entries_read = entries_read;
 832         r.out.total_entries = total_entries;
 833         r.out.resume_handle = resume_handle;
 834
 835         if (DEBUGLEVEL >= 10) {
 836                 NDR_PRINT_IN_DEBUG(NetUserEnum, &r);
 837         }
 838
 839         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 840                 werr = NetUserEnum_l(ctx, &r);
 841         } else {
 842                 werr = NetUserEnum_r(ctx, &r);
 843         }
 844
 845         r.out.result = W_ERROR_V(werr);
 846
 847         if (DEBUGLEVEL >= 10) {
 848                 NDR_PRINT_OUT_DEBUG(NetUserEnum, &r);
 849         }
 850
 851         TALLOC_FREE(frame);
 852         return (NET_API_STATUS)r.out.result;
 853 }
 854
 855 /****************************************************************
 856  NetUserChangePassword
 857 ****************************************************************/
 858
 859 NET_API_STATUS NetUserChangePassword(const char * domain_name /* [in] */,
 860                                      const char * user_name /* [in] */,
 861                                      const char * old_password /* [in] */,
 862                                      const char * new_password /* [in] */)
 863 {
 864         struct NetUserChangePassword r;
 865         struct libnetapi_ctx *ctx = NULL;
 866         NET_API_STATUS status;
 867         WERROR werr;
 868         TALLOC_CTX *frame = talloc_stackframe();
 869
 870         ZERO_STRUCT(r);
 871
 872         status = libnetapi_getctx(&ctx);
 873         if (status != 0) {
 874                 TALLOC_FREE(frame);
 875                 return status;
 876         }
 877
 878         /* In parameters */
 879         r.in.domain_name = domain_name;
 880         r.in.user_name = user_name;
 881         r.in.old_password = old_password;
 882         r.in.new_password = new_password;
 883
 884         /* Out parameters */
 885
 886         if (DEBUGLEVEL >= 10) {
 887                 NDR_PRINT_IN_DEBUG(NetUserChangePassword, &r);
 888         }
 889
 890         werr = NetUserChangePassword_l(ctx, &r);
 891
 892         r.out.result = W_ERROR_V(werr);
 893
 894         if (DEBUGLEVEL >= 10) {
 895                 NDR_PRINT_OUT_DEBUG(NetUserChangePassword, &r);
 896         }
 897
 898         TALLOC_FREE(frame);
 899         return (NET_API_STATUS)r.out.result;
 900 }
 901
 902 /****************************************************************
 903  NetUserGetInfo
 904 ****************************************************************/
 905
 906 NET_API_STATUS NetUserGetInfo(const char * server_name /* [in] */,
 907                               const char * user_name /* [in] */,
 908                               uint32_t level /* [in] */,
 909                               uint8_t **buffer /* [out] [ref] */)
 910 {
 911         struct NetUserGetInfo r;
 912         struct libnetapi_ctx *ctx = NULL;
 913         NET_API_STATUS status;
 914         WERROR werr;
 915         TALLOC_CTX *frame = talloc_stackframe();
 916
 917         ZERO_STRUCT(r);
 918
 919         status = libnetapi_getctx(&ctx);
 920         if (status != 0) {
 921                 TALLOC_FREE(frame);
 922                 return status;
 923         }
 924
 925         /* In parameters */
 926         r.in.server_name = server_name;
 927         r.in.user_name = user_name;
 928         r.in.level = level;
 929
 930         /* Out parameters */
 931         r.out.buffer = buffer;
 932
 933         if (DEBUGLEVEL >= 10) {
 934                 NDR_PRINT_IN_DEBUG(NetUserGetInfo, &r);
 935         }
 936
 937         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 938                 werr = NetUserGetInfo_l(ctx, &r);
 939         } else {
 940                 werr = NetUserGetInfo_r(ctx, &r);
 941         }
 942
 943         r.out.result = W_ERROR_V(werr);
 944
 945         if (DEBUGLEVEL >= 10) {
 946                 NDR_PRINT_OUT_DEBUG(NetUserGetInfo, &r);
 947         }
 948
 949         TALLOC_FREE(frame);
 950         return (NET_API_STATUS)r.out.result;
 951 }
 952
 953 /****************************************************************
 954  NetUserSetInfo
 955 ****************************************************************/
 956
 957 NET_API_STATUS NetUserSetInfo(const char * server_name /* [in] */,
 958                               const char * user_name /* [in] */,
 959                               uint32_t level /* [in] */,
 960                               uint8_t *buffer /* [in] [ref] */,
 961                               uint32_t *parm_err /* [out] [ref] */)
 962 {
 963         struct NetUserSetInfo r;
 964         struct libnetapi_ctx *ctx = NULL;
 965         NET_API_STATUS status;
 966         WERROR werr;
 967         TALLOC_CTX *frame = talloc_stackframe();
 968
 969         ZERO_STRUCT(r);
 970
 971         status = libnetapi_getctx(&ctx);
 972         if (status != 0) {
 973                 TALLOC_FREE(frame);
 974                 return status;
 975         }
 976
 977         /* In parameters */
 978         r.in.server_name = server_name;
 979         r.in.user_name = user_name;
 980         r.in.level = level;
 981         r.in.buffer = buffer;
 982
 983         /* Out parameters */
 984         r.out.parm_err = parm_err;
 985
 986         if (DEBUGLEVEL >= 10) {
 987                 NDR_PRINT_IN_DEBUG(NetUserSetInfo, &r);
 988         }
 989
 990         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 991                 werr = NetUserSetInfo_l(ctx, &r);
 992         } else {
 993                 werr = NetUserSetInfo_r(ctx, &r);
 994         }
 995
 996         r.out.result = W_ERROR_V(werr);
 997
 998         if (DEBUGLEVEL >= 10) {
 999                 NDR_PRINT_OUT_DEBUG(NetUserSetInfo, &r);
1000         }
1001
1002         TALLOC_FREE(frame);
1003         return (NET_API_STATUS)r.out.result;
1004 }
1005
1006 /****************************************************************
1007  NetUserGetGroups
1008 ****************************************************************/
1009
1010 NET_API_STATUS NetUserGetGroups(const char * server_name /* [in] */,
1011                                 const char * user_name /* [in] */,
1012                                 uint32_t level /* [in] */,
1013                                 uint8_t **buffer /* [out] [ref] */,
1014                                 uint32_t prefmaxlen /* [in] */,
1015                                 uint32_t *entries_read /* [out] [ref] */,
1016                                 uint32_t *total_entries /* [out] [ref] */)
1017 {
1018         struct NetUserGetGroups r;
1019         struct libnetapi_ctx *ctx = NULL;
1020         NET_API_STATUS status;
1021         WERROR werr;
1022         TALLOC_CTX *frame = talloc_stackframe();
1023
1024         ZERO_STRUCT(r);
1025
1026         status = libnetapi_getctx(&ctx);
1027         if (status != 0) {
1028                 TALLOC_FREE(frame);
1029                 return status;
1030         }
1031
1032         /* In parameters */
1033         r.in.server_name = server_name;
1034         r.in.user_name = user_name;
1035         r.in.level = level;
1036         r.in.prefmaxlen = prefmaxlen;
1037
1038         /* Out parameters */
1039         r.out.buffer = buffer;
1040         r.out.entries_read = entries_read;
1041         r.out.total_entries = total_entries;
1042
1043         if (DEBUGLEVEL >= 10) {
1044                 NDR_PRINT_IN_DEBUG(NetUserGetGroups, &r);
1045         }
1046
1047         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1048                 werr = NetUserGetGroups_l(ctx, &r);
1049         } else {
1050                 werr = NetUserGetGroups_r(ctx, &r);
1051         }
1052
1053         r.out.result = W_ERROR_V(werr);
1054
1055         if (DEBUGLEVEL >= 10) {
1056                 NDR_PRINT_OUT_DEBUG(NetUserGetGroups, &r);
1057         }
1058
1059         TALLOC_FREE(frame);
1060         return (NET_API_STATUS)r.out.result;
1061 }
1062
1063 /****************************************************************
1064  NetUserSetGroups
1065 ****************************************************************/
1066
1067 NET_API_STATUS NetUserSetGroups(const char * server_name /* [in] */,
1068                                 const char * user_name /* [in] */,
1069                                 uint32_t level /* [in] */,
1070                                 uint8_t *buffer /* [in] [ref] */,
1071                                 uint32_t num_entries /* [in] */)
1072 {
1073         struct NetUserSetGroups r;
1074         struct libnetapi_ctx *ctx = NULL;
1075         NET_API_STATUS status;
1076         WERROR werr;
1077         TALLOC_CTX *frame = talloc_stackframe();
1078
1079         ZERO_STRUCT(r);
1080
1081         status = libnetapi_getctx(&ctx);
1082         if (status != 0) {
1083                 TALLOC_FREE(frame);
1084                 return status;
1085         }
1086
1087         /* In parameters */
1088         r.in.server_name = server_name;
1089         r.in.user_name = user_name;
1090         r.in.level = level;
1091         r.in.buffer = buffer;
1092         r.in.num_entries = num_entries;
1093
1094         /* Out parameters */
1095
1096         if (DEBUGLEVEL >= 10) {
1097                 NDR_PRINT_IN_DEBUG(NetUserSetGroups, &r);
1098         }
1099
1100         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1101                 werr = NetUserSetGroups_l(ctx, &r);
1102         } else {
1103                 werr = NetUserSetGroups_r(ctx, &r);
1104         }
1105
1106         r.out.result = W_ERROR_V(werr);
1107
1108         if (DEBUGLEVEL >= 10) {
1109                 NDR_PRINT_OUT_DEBUG(NetUserSetGroups, &r);
1110         }
1111
1112         TALLOC_FREE(frame);
1113         return (NET_API_STATUS)r.out.result;
1114 }
1115
1116 /****************************************************************
1117  NetUserGetLocalGroups
1118 ****************************************************************/
1119
1120 NET_API_STATUS NetUserGetLocalGroups(const char * server_name /* [in] */,
1121                                      const char * user_name /* [in] */,
1122                                      uint32_t level /* [in] */,
1123                                      uint32_t flags /* [in] */,
1124                                      uint8_t **buffer /* [out] [ref] */,
1125                                      uint32_t prefmaxlen /* [in] */,
1126                                      uint32_t *entries_read /* [out] [ref] */,
1127                                      uint32_t *total_entries /* [out] [ref] */)
1128 {
1129         struct NetUserGetLocalGroups r;
1130         struct libnetapi_ctx *ctx = NULL;
1131         NET_API_STATUS status;
1132         WERROR werr;
1133         TALLOC_CTX *frame = talloc_stackframe();
1134
1135         ZERO_STRUCT(r);
1136
1137         status = libnetapi_getctx(&ctx);
1138         if (status != 0) {
1139                 TALLOC_FREE(frame);
1140                 return status;
1141         }
1142
1143         /* In parameters */
1144         r.in.server_name = server_name;
1145         r.in.user_name = user_name;
1146         r.in.level = level;
1147         r.in.flags = flags;
1148         r.in.prefmaxlen = prefmaxlen;
1149
1150         /* Out parameters */
1151         r.out.buffer = buffer;
1152         r.out.entries_read = entries_read;
1153         r.out.total_entries = total_entries;
1154
1155         if (DEBUGLEVEL >= 10) {
1156                 NDR_PRINT_IN_DEBUG(NetUserGetLocalGroups, &r);
1157         }
1158
1159         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1160                 werr = NetUserGetLocalGroups_l(ctx, &r);
1161         } else {
1162                 werr = NetUserGetLocalGroups_r(ctx, &r);
1163         }
1164
1165         r.out.result = W_ERROR_V(werr);
1166
1167         if (DEBUGLEVEL >= 10) {
1168                 NDR_PRINT_OUT_DEBUG(NetUserGetLocalGroups, &r);
1169         }
1170
1171         TALLOC_FREE(frame);
1172         return (NET_API_STATUS)r.out.result;
1173 }
1174
1175 /****************************************************************
1176  NetUserModalsGet
1177 ****************************************************************/
1178
1179 NET_API_STATUS NetUserModalsGet(const char * server_name /* [in] */,
1180                                 uint32_t level /* [in] */,
1181                                 uint8_t **buffer /* [out] [ref] */)
1182 {
1183         struct NetUserModalsGet r;
1184         struct libnetapi_ctx *ctx = NULL;
1185         NET_API_STATUS status;
1186         WERROR werr;
1187         TALLOC_CTX *frame = talloc_stackframe();
1188
1189         ZERO_STRUCT(r);
1190
1191         status = libnetapi_getctx(&ctx);
1192         if (status != 0) {
1193                 TALLOC_FREE(frame);
1194                 return status;
1195         }
1196
1197         /* In parameters */
1198         r.in.server_name = server_name;
1199         r.in.level = level;
1200
1201         /* Out parameters */
1202         r.out.buffer = buffer;
1203
1204         if (DEBUGLEVEL >= 10) {
1205                 NDR_PRINT_IN_DEBUG(NetUserModalsGet, &r);
1206         }
1207
1208         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1209                 werr = NetUserModalsGet_l(ctx, &r);
1210         } else {
1211                 werr = NetUserModalsGet_r(ctx, &r);
1212         }
1213
1214         r.out.result = W_ERROR_V(werr);
1215
1216         if (DEBUGLEVEL >= 10) {
1217                 NDR_PRINT_OUT_DEBUG(NetUserModalsGet, &r);
1218         }
1219
1220         TALLOC_FREE(frame);
1221         return (NET_API_STATUS)r.out.result;
1222 }
1223
1224 /****************************************************************
1225  NetUserModalsSet
1226 ****************************************************************/
1227
1228 NET_API_STATUS NetUserModalsSet(const char * server_name /* [in] */,
1229                                 uint32_t level /* [in] */,
1230                                 uint8_t *buffer /* [in] [ref] */,
1231                                 uint32_t *parm_err /* [out] [ref] */)
1232 {
1233         struct NetUserModalsSet r;
1234         struct libnetapi_ctx *ctx = NULL;
1235         NET_API_STATUS status;
1236         WERROR werr;
1237         TALLOC_CTX *frame = talloc_stackframe();
1238
1239         ZERO_STRUCT(r);
1240
1241         status = libnetapi_getctx(&ctx);
1242         if (status != 0) {
1243                 TALLOC_FREE(frame);
1244                 return status;
1245         }
1246
1247         /* In parameters */
1248         r.in.server_name = server_name;
1249         r.in.level = level;
1250         r.in.buffer = buffer;
1251
1252         /* Out parameters */
1253         r.out.parm_err = parm_err;
1254
1255         if (DEBUGLEVEL >= 10) {
1256                 NDR_PRINT_IN_DEBUG(NetUserModalsSet, &r);
1257         }
1258
1259         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1260                 werr = NetUserModalsSet_l(ctx, &r);
1261         } else {
1262                 werr = NetUserModalsSet_r(ctx, &r);
1263         }
1264
1265         r.out.result = W_ERROR_V(werr);
1266
1267         if (DEBUGLEVEL >= 10) {
1268                 NDR_PRINT_OUT_DEBUG(NetUserModalsSet, &r);
1269         }
1270
1271         TALLOC_FREE(frame);
1272         return (NET_API_STATUS)r.out.result;
1273 }
1274
1275 /****************************************************************
1276  NetQueryDisplayInformation
1277 ****************************************************************/
1278
1279 NET_API_STATUS NetQueryDisplayInformation(const char * server_name /* [in] [unique] */,
1280                                           uint32_t level /* [in] */,
1281                                           uint32_t idx /* [in] */,
1282                                           uint32_t entries_requested /* [in] */,
1283                                           uint32_t prefmaxlen /* [in] */,
1284                                           uint32_t *entries_read /* [out] [ref] */,
1285                                           void **buffer /* [out] [noprint,ref] */)
1286 {
1287         struct NetQueryDisplayInformation r;
1288         struct libnetapi_ctx *ctx = NULL;
1289         NET_API_STATUS status;
1290         WERROR werr;
1291         TALLOC_CTX *frame = talloc_stackframe();
1292
1293         ZERO_STRUCT(r);
1294
1295         status = libnetapi_getctx(&ctx);
1296         if (status != 0) {
1297                 TALLOC_FREE(frame);
1298                 return status;
1299         }
1300
1301         /* In parameters */
1302         r.in.server_name = server_name;
1303         r.in.level = level;
1304         r.in.idx = idx;
1305         r.in.entries_requested = entries_requested;
1306         r.in.prefmaxlen = prefmaxlen;
1307
1308         /* Out parameters */
1309         r.out.entries_read = entries_read;
1310         r.out.buffer = buffer;
1311
1312         if (DEBUGLEVEL >= 10) {
1313                 NDR_PRINT_IN_DEBUG(NetQueryDisplayInformation, &r);
1314         }
1315
1316         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1317                 werr = NetQueryDisplayInformation_l(ctx, &r);
1318         } else {
1319                 werr = NetQueryDisplayInformation_r(ctx, &r);
1320         }
1321
1322         r.out.result = W_ERROR_V(werr);
1323
1324         if (DEBUGLEVEL >= 10) {
1325                 NDR_PRINT_OUT_DEBUG(NetQueryDisplayInformation, &r);
1326         }
1327
1328         TALLOC_FREE(frame);
1329         return (NET_API_STATUS)r.out.result;
1330 }
1331
1332 /****************************************************************
1333  NetGroupAdd
1334 ****************************************************************/
1335
1336 NET_API_STATUS NetGroupAdd(const char * server_name /* [in] */,
1337                            uint32_t level /* [in] */,
1338                            uint8_t *buffer /* [in] [ref] */,
1339                            uint32_t *parm_err /* [out] [ref] */)
1340 {
1341         struct NetGroupAdd r;
1342         struct libnetapi_ctx *ctx = NULL;
1343         NET_API_STATUS status;
1344         WERROR werr;
1345         TALLOC_CTX *frame = talloc_stackframe();
1346
1347         ZERO_STRUCT(r);
1348
1349         status = libnetapi_getctx(&ctx);
1350         if (status != 0) {
1351                 TALLOC_FREE(frame);
1352                 return status;
1353         }
1354
1355         /* In parameters */
1356         r.in.server_name = server_name;
1357         r.in.level = level;
1358         r.in.buffer = buffer;
1359
1360         /* Out parameters */
1361         r.out.parm_err = parm_err;
1362
1363         if (DEBUGLEVEL >= 10) {
1364                 NDR_PRINT_IN_DEBUG(NetGroupAdd, &r);
1365         }
1366
1367         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1368                 werr = NetGroupAdd_l(ctx, &r);
1369         } else {
1370                 werr = NetGroupAdd_r(ctx, &r);
1371         }
1372
1373         r.out.result = W_ERROR_V(werr);
1374
1375         if (DEBUGLEVEL >= 10) {
1376                 NDR_PRINT_OUT_DEBUG(NetGroupAdd, &r);
1377         }
1378
1379         TALLOC_FREE(frame);
1380         return (NET_API_STATUS)r.out.result;
1381 }
1382
1383 /****************************************************************
1384  NetGroupDel
1385 ****************************************************************/
1386
1387 NET_API_STATUS NetGroupDel(const char * server_name /* [in] */,
1388                            const char * group_name /* [in] */)
1389 {
1390         struct NetGroupDel r;
1391         struct libnetapi_ctx *ctx = NULL;
1392         NET_API_STATUS status;
1393         WERROR werr;
1394         TALLOC_CTX *frame = talloc_stackframe();
1395
1396         ZERO_STRUCT(r);
1397
1398         status = libnetapi_getctx(&ctx);
1399         if (status != 0) {
1400                 TALLOC_FREE(frame);
1401                 return status;
1402         }
1403
1404         /* In parameters */
1405         r.in.server_name = server_name;
1406         r.in.group_name = group_name;
1407
1408         /* Out parameters */
1409
1410         if (DEBUGLEVEL >= 10) {
1411                 NDR_PRINT_IN_DEBUG(NetGroupDel, &r);
1412         }
1413
1414         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1415                 werr = NetGroupDel_l(ctx, &r);
1416         } else {
1417                 werr = NetGroupDel_r(ctx, &r);
1418         }
1419
1420         r.out.result = W_ERROR_V(werr);
1421
1422         if (DEBUGLEVEL >= 10) {
1423                 NDR_PRINT_OUT_DEBUG(NetGroupDel, &r);
1424         }
1425
1426         TALLOC_FREE(frame);
1427         return (NET_API_STATUS)r.out.result;
1428 }
1429
1430 /****************************************************************
1431  NetGroupEnum
1432 ****************************************************************/
1433
1434 NET_API_STATUS NetGroupEnum(const char * server_name /* [in] */,
1435                             uint32_t level /* [in] */,
1436                             uint8_t **buffer /* [out] [ref] */,
1437                             uint32_t prefmaxlen /* [in] */,
1438                             uint32_t *entries_read /* [out] [ref] */,
1439                             uint32_t *total_entries /* [out] [ref] */,
1440                             uint32_t *resume_handle /* [in,out] [ref] */)
1441 {
1442         struct NetGroupEnum r;
1443         struct libnetapi_ctx *ctx = NULL;
1444         NET_API_STATUS status;
1445         WERROR werr;
1446         TALLOC_CTX *frame = talloc_stackframe();
1447
1448         ZERO_STRUCT(r);
1449
1450         status = libnetapi_getctx(&ctx);
1451         if (status != 0) {
1452                 TALLOC_FREE(frame);
1453                 return status;
1454         }
1455
1456         /* In parameters */
1457         r.in.server_name = server_name;
1458         r.in.level = level;
1459         r.in.prefmaxlen = prefmaxlen;
1460         r.in.resume_handle = resume_handle;
1461
1462         /* Out parameters */
1463         r.out.buffer = buffer;
1464         r.out.entries_read = entries_read;
1465         r.out.total_entries = total_entries;
1466         r.out.resume_handle = resume_handle;
1467
1468         if (DEBUGLEVEL >= 10) {
1469                 NDR_PRINT_IN_DEBUG(NetGroupEnum, &r);
1470         }
1471
1472         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1473                 werr = NetGroupEnum_l(ctx, &r);
1474         } else {
1475                 werr = NetGroupEnum_r(ctx, &r);
1476         }
1477
1478         r.out.result = W_ERROR_V(werr);
1479
1480         if (DEBUGLEVEL >= 10) {
1481                 NDR_PRINT_OUT_DEBUG(NetGroupEnum, &r);
1482         }
1483
1484         TALLOC_FREE(frame);
1485         return (NET_API_STATUS)r.out.result;
1486 }
1487
1488 /****************************************************************
1489  NetGroupSetInfo
1490 ****************************************************************/
1491
1492 NET_API_STATUS NetGroupSetInfo(const char * server_name /* [in] */,
1493                                const char * group_name /* [in] */,
1494                                uint32_t level /* [in] */,
1495                                uint8_t *buffer /* [in] [ref] */,
1496                                uint32_t *parm_err /* [out] [ref] */)
1497 {
1498         struct NetGroupSetInfo r;
1499         struct libnetapi_ctx *ctx = NULL;
1500         NET_API_STATUS status;
1501         WERROR werr;
1502         TALLOC_CTX *frame = talloc_stackframe();
1503
1504         ZERO_STRUCT(r);
1505
1506         status = libnetapi_getctx(&ctx);
1507         if (status != 0) {
1508                 TALLOC_FREE(frame);
1509                 return status;
1510         }
1511
1512         /* In parameters */
1513         r.in.server_name = server_name;
1514         r.in.group_name = group_name;
1515         r.in.level = level;
1516         r.in.buffer = buffer;
1517
1518         /* Out parameters */
1519         r.out.parm_err = parm_err;
1520
1521         if (DEBUGLEVEL >= 10) {
1522                 NDR_PRINT_IN_DEBUG(NetGroupSetInfo, &r);
1523         }
1524
1525         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1526                 werr = NetGroupSetInfo_l(ctx, &r);
1527         } else {
1528                 werr = NetGroupSetInfo_r(ctx, &r);
1529         }
1530
1531         r.out.result = W_ERROR_V(werr);
1532
1533         if (DEBUGLEVEL >= 10) {
1534                 NDR_PRINT_OUT_DEBUG(NetGroupSetInfo, &r);
1535         }
1536
1537         TALLOC_FREE(frame);
1538         return (NET_API_STATUS)r.out.result;
1539 }
1540
1541 /****************************************************************
1542  NetGroupGetInfo
1543 ****************************************************************/
1544
1545 NET_API_STATUS NetGroupGetInfo(const char * server_name /* [in] */,
1546                                const char * group_name /* [in] */,
1547                                uint32_t level /* [in] */,
1548                                uint8_t **buffer /* [out] [ref] */)
1549 {
1550         struct NetGroupGetInfo r;
1551         struct libnetapi_ctx *ctx = NULL;
1552         NET_API_STATUS status;
1553         WERROR werr;
1554         TALLOC_CTX *frame = talloc_stackframe();
1555
1556         ZERO_STRUCT(r);
1557
1558         status = libnetapi_getctx(&ctx);
1559         if (status != 0) {
1560                 TALLOC_FREE(frame);
1561                 return status;
1562         }
1563
1564         /* In parameters */
1565         r.in.server_name = server_name;
1566         r.in.group_name = group_name;
1567         r.in.level = level;
1568
1569         /* Out parameters */
1570         r.out.buffer = buffer;
1571
1572         if (DEBUGLEVEL >= 10) {
1573                 NDR_PRINT_IN_DEBUG(NetGroupGetInfo, &r);
1574         }
1575
1576         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1577                 werr = NetGroupGetInfo_l(ctx, &r);
1578         } else {
1579                 werr = NetGroupGetInfo_r(ctx, &r);
1580         }
1581
1582         r.out.result = W_ERROR_V(werr);
1583
1584         if (DEBUGLEVEL >= 10) {
1585                 NDR_PRINT_OUT_DEBUG(NetGroupGetInfo, &r);
1586         }
1587
1588         TALLOC_FREE(frame);
1589         return (NET_API_STATUS)r.out.result;
1590 }
1591
1592 /****************************************************************
1593  NetGroupAddUser
1594 ****************************************************************/
1595
1596 NET_API_STATUS NetGroupAddUser(const char * server_name /* [in] */,
1597                                const char * group_name /* [in] */,
1598                                const char * user_name /* [in] */)
1599 {
1600         struct NetGroupAddUser r;
1601         struct libnetapi_ctx *ctx = NULL;
1602         NET_API_STATUS status;
1603         WERROR werr;
1604         TALLOC_CTX *frame = talloc_stackframe();
1605
1606         ZERO_STRUCT(r);
1607
1608         status = libnetapi_getctx(&ctx);
1609         if (status != 0) {
1610                 TALLOC_FREE(frame);
1611                 return status;
1612         }
1613
1614         /* In parameters */
1615         r.in.server_name = server_name;
1616         r.in.group_name = group_name;
1617         r.in.user_name = user_name;
1618
1619         /* Out parameters */
1620
1621         if (DEBUGLEVEL >= 10) {
1622                 NDR_PRINT_IN_DEBUG(NetGroupAddUser, &r);
1623         }
1624
1625         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1626                 werr = NetGroupAddUser_l(ctx, &r);
1627         } else {
1628                 werr = NetGroupAddUser_r(ctx, &r);
1629         }
1630
1631         r.out.result = W_ERROR_V(werr);
1632
1633         if (DEBUGLEVEL >= 10) {
1634                 NDR_PRINT_OUT_DEBUG(NetGroupAddUser, &r);
1635         }
1636
1637         TALLOC_FREE(frame);
1638         return (NET_API_STATUS)r.out.result;
1639 }
1640
1641 /****************************************************************
1642  NetGroupDelUser
1643 ****************************************************************/
1644
1645 NET_API_STATUS NetGroupDelUser(const char * server_name /* [in] */,
1646                                const char * group_name /* [in] */,
1647                                const char * user_name /* [in] */)
1648 {
1649         struct NetGroupDelUser r;
1650         struct libnetapi_ctx *ctx = NULL;
1651         NET_API_STATUS status;
1652         WERROR werr;
1653         TALLOC_CTX *frame = talloc_stackframe();
1654
1655         ZERO_STRUCT(r);
1656
1657         status = libnetapi_getctx(&ctx);
1658         if (status != 0) {
1659                 TALLOC_FREE(frame);
1660                 return status;
1661         }
1662
1663         /* In parameters */
1664         r.in.server_name = server_name;
1665         r.in.group_name = group_name;
1666         r.in.user_name = user_name;
1667
1668         /* Out parameters */
1669
1670         if (DEBUGLEVEL >= 10) {
1671                 NDR_PRINT_IN_DEBUG(NetGroupDelUser, &r);
1672         }
1673
1674         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1675                 werr = NetGroupDelUser_l(ctx, &r);
1676         } else {
1677                 werr = NetGroupDelUser_r(ctx, &r);
1678         }
1679
1680         r.out.result = W_ERROR_V(werr);
1681
1682         if (DEBUGLEVEL >= 10) {
1683                 NDR_PRINT_OUT_DEBUG(NetGroupDelUser, &r);
1684         }
1685
1686         TALLOC_FREE(frame);
1687         return (NET_API_STATUS)r.out.result;
1688 }
1689
1690 /****************************************************************
1691  NetGroupGetUsers
1692 ****************************************************************/
1693
1694 NET_API_STATUS NetGroupGetUsers(const char * server_name /* [in] */,
1695                                 const char * group_name /* [in] */,
1696                                 uint32_t level /* [in] */,
1697                                 uint8_t **buffer /* [out] [ref] */,
1698                                 uint32_t prefmaxlen /* [in] */,
1699                                 uint32_t *entries_read /* [out] [ref] */,
1700                                 uint32_t *total_entries /* [out] [ref] */,
1701                                 uint32_t *resume_handle /* [in,out] [ref] */)
1702 {
1703         struct NetGroupGetUsers r;
1704         struct libnetapi_ctx *ctx = NULL;
1705         NET_API_STATUS status;
1706         WERROR werr;
1707         TALLOC_CTX *frame = talloc_stackframe();
1708
1709         ZERO_STRUCT(r);
1710
1711         status = libnetapi_getctx(&ctx);
1712         if (status != 0) {
1713                 TALLOC_FREE(frame);
1714                 return status;
1715         }
1716
1717         /* In parameters */
1718         r.in.server_name = server_name;
1719         r.in.group_name = group_name;
1720         r.in.level = level;
1721         r.in.prefmaxlen = prefmaxlen;
1722         r.in.resume_handle = resume_handle;
1723
1724         /* Out parameters */
1725         r.out.buffer = buffer;
1726         r.out.entries_read = entries_read;
1727         r.out.total_entries = total_entries;
1728         r.out.resume_handle = resume_handle;
1729
1730         if (DEBUGLEVEL >= 10) {
1731                 NDR_PRINT_IN_DEBUG(NetGroupGetUsers, &r);
1732         }
1733
1734         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1735                 werr = NetGroupGetUsers_l(ctx, &r);
1736         } else {
1737                 werr = NetGroupGetUsers_r(ctx, &r);
1738         }
1739
1740         r.out.result = W_ERROR_V(werr);
1741
1742         if (DEBUGLEVEL >= 10) {
1743                 NDR_PRINT_OUT_DEBUG(NetGroupGetUsers, &r);
1744         }
1745
1746         TALLOC_FREE(frame);
1747         return (NET_API_STATUS)r.out.result;
1748 }
1749
1750 /****************************************************************
1751  NetGroupSetUsers
1752 ****************************************************************/
1753
1754 NET_API_STATUS NetGroupSetUsers(const char * server_name /* [in] */,
1755                                 const char * group_name /* [in] */,
1756                                 uint32_t level /* [in] */,
1757                                 uint8_t *buffer /* [in] [ref] */,
1758                                 uint32_t num_entries /* [in] */)
1759 {
1760         struct NetGroupSetUsers r;
1761         struct libnetapi_ctx *ctx = NULL;
1762         NET_API_STATUS status;
1763         WERROR werr;
1764         TALLOC_CTX *frame = talloc_stackframe();
1765
1766         ZERO_STRUCT(r);
1767
1768         status = libnetapi_getctx(&ctx);
1769         if (status != 0) {
1770                 TALLOC_FREE(frame);
1771                 return status;
1772         }
1773
1774         /* In parameters */
1775         r.in.server_name = server_name;
1776         r.in.group_name = group_name;
1777         r.in.level = level;
1778         r.in.buffer = buffer;
1779         r.in.num_entries = num_entries;
1780
1781         /* Out parameters */
1782
1783         if (DEBUGLEVEL >= 10) {
1784                 NDR_PRINT_IN_DEBUG(NetGroupSetUsers, &r);
1785         }
1786
1787         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1788                 werr = NetGroupSetUsers_l(ctx, &r);
1789         } else {
1790                 werr = NetGroupSetUsers_r(ctx, &r);
1791         }
1792
1793         r.out.result = W_ERROR_V(werr);
1794
1795         if (DEBUGLEVEL >= 10) {
1796                 NDR_PRINT_OUT_DEBUG(NetGroupSetUsers, &r);
1797         }
1798
1799         TALLOC_FREE(frame);
1800         return (NET_API_STATUS)r.out.result;
1801 }
1802
1803 /****************************************************************
1804  NetLocalGroupAdd
1805 ****************************************************************/
1806
1807 NET_API_STATUS NetLocalGroupAdd(const char * server_name /* [in] */,
1808                                 uint32_t level /* [in] */,
1809                                 uint8_t *buffer /* [in] [ref] */,
1810                                 uint32_t *parm_err /* [out] [ref] */)
1811 {
1812         struct NetLocalGroupAdd r;
1813         struct libnetapi_ctx *ctx = NULL;
1814         NET_API_STATUS status;
1815         WERROR werr;
1816         TALLOC_CTX *frame = talloc_stackframe();
1817
1818         ZERO_STRUCT(r);
1819
1820         status = libnetapi_getctx(&ctx);
1821         if (status != 0) {
1822                 TALLOC_FREE(frame);
1823                 return status;
1824         }
1825
1826         /* In parameters */
1827         r.in.server_name = server_name;
1828         r.in.level = level;
1829         r.in.buffer = buffer;
1830
1831         /* Out parameters */
1832         r.out.parm_err = parm_err;
1833
1834         if (DEBUGLEVEL >= 10) {
1835                 NDR_PRINT_IN_DEBUG(NetLocalGroupAdd, &r);
1836         }
1837
1838         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1839                 werr = NetLocalGroupAdd_l(ctx, &r);
1840         } else {
1841                 werr = NetLocalGroupAdd_r(ctx, &r);
1842         }
1843
1844         r.out.result = W_ERROR_V(werr);
1845
1846         if (DEBUGLEVEL >= 10) {
1847                 NDR_PRINT_OUT_DEBUG(NetLocalGroupAdd, &r);
1848         }
1849
1850         TALLOC_FREE(frame);
1851         return (NET_API_STATUS)r.out.result;
1852 }
1853
1854 /****************************************************************
1855  NetLocalGroupDel
1856 ****************************************************************/
1857
1858 NET_API_STATUS NetLocalGroupDel(const char * server_name /* [in] */,
1859                                 const char * group_name /* [in] */)
1860 {
1861         struct NetLocalGroupDel r;
1862         struct libnetapi_ctx *ctx = NULL;
1863         NET_API_STATUS status;
1864         WERROR werr;
1865         TALLOC_CTX *frame = talloc_stackframe();
1866
1867         ZERO_STRUCT(r);
1868
1869         status = libnetapi_getctx(&ctx);
1870         if (status != 0) {
1871                 TALLOC_FREE(frame);
1872                 return status;
1873         }
1874
1875         /* In parameters */
1876         r.in.server_name = server_name;
1877         r.in.group_name = group_name;
1878
1879         /* Out parameters */
1880
1881         if (DEBUGLEVEL >= 10) {
1882                 NDR_PRINT_IN_DEBUG(NetLocalGroupDel, &r);
1883         }
1884
1885         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1886                 werr = NetLocalGroupDel_l(ctx, &r);
1887         } else {
1888                 werr = NetLocalGroupDel_r(ctx, &r);
1889         }
1890
1891         r.out.result = W_ERROR_V(werr);
1892
1893         if (DEBUGLEVEL >= 10) {
1894                 NDR_PRINT_OUT_DEBUG(NetLocalGroupDel, &r);
1895         }
1896
1897         TALLOC_FREE(frame);
1898         return (NET_API_STATUS)r.out.result;
1899 }
1900
1901 /****************************************************************
1902  NetLocalGroupGetInfo
1903 ****************************************************************/
1904
1905 NET_API_STATUS NetLocalGroupGetInfo(const char * server_name /* [in] */,
1906                                     const char * group_name /* [in] */,
1907                                     uint32_t level /* [in] */,
1908                                     uint8_t **buffer /* [out] [ref] */)
1909 {
1910         struct NetLocalGroupGetInfo r;
1911         struct libnetapi_ctx *ctx = NULL;
1912         NET_API_STATUS status;
1913         WERROR werr;
1914         TALLOC_CTX *frame = talloc_stackframe();
1915
1916         ZERO_STRUCT(r);
1917
1918         status = libnetapi_getctx(&ctx);
1919         if (status != 0) {
1920                 TALLOC_FREE(frame);
1921                 return status;
1922         }
1923
1924         /* In parameters */
1925         r.in.server_name = server_name;
1926         r.in.group_name = group_name;
1927         r.in.level = level;
1928
1929         /* Out parameters */
1930         r.out.buffer = buffer;
1931
1932         if (DEBUGLEVEL >= 10) {
1933                 NDR_PRINT_IN_DEBUG(NetLocalGroupGetInfo, &r);
1934         }
1935
1936         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1937                 werr = NetLocalGroupGetInfo_l(ctx, &r);
1938         } else {
1939                 werr = NetLocalGroupGetInfo_r(ctx, &r);
1940         }
1941
1942         r.out.result = W_ERROR_V(werr);
1943
1944         if (DEBUGLEVEL >= 10) {
1945                 NDR_PRINT_OUT_DEBUG(NetLocalGroupGetInfo, &r);
1946         }
1947
1948         TALLOC_FREE(frame);
1949         return (NET_API_STATUS)r.out.result;
1950 }
1951
1952 /****************************************************************
1953  NetLocalGroupSetInfo
1954 ****************************************************************/
1955
1956 NET_API_STATUS NetLocalGroupSetInfo(const char * server_name /* [in] */,
1957                                     const char * group_name /* [in] */,
1958                                     uint32_t level /* [in] */,
1959                                     uint8_t *buffer /* [in] [ref] */,
1960                                     uint32_t *parm_err /* [out] [ref] */)
1961 {
1962         struct NetLocalGroupSetInfo r;
1963         struct libnetapi_ctx *ctx = NULL;
1964         NET_API_STATUS status;
1965         WERROR werr;
1966         TALLOC_CTX *frame = talloc_stackframe();
1967
1968         ZERO_STRUCT(r);
1969
1970         status = libnetapi_getctx(&ctx);
1971         if (status != 0) {
1972                 TALLOC_FREE(frame);
1973                 return status;
1974         }
1975
1976         /* In parameters */
1977         r.in.server_name = server_name;
1978         r.in.group_name = group_name;
1979         r.in.level = level;
1980         r.in.buffer = buffer;
1981
1982         /* Out parameters */
1983         r.out.parm_err = parm_err;
1984
1985         if (DEBUGLEVEL >= 10) {
1986                 NDR_PRINT_IN_DEBUG(NetLocalGroupSetInfo, &r);
1987         }
1988
1989         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1990                 werr = NetLocalGroupSetInfo_l(ctx, &r);
1991         } else {
1992                 werr = NetLocalGroupSetInfo_r(ctx, &r);
1993         }
1994
1995         r.out.result = W_ERROR_V(werr);
1996
1997         if (DEBUGLEVEL >= 10) {
1998                 NDR_PRINT_OUT_DEBUG(NetLocalGroupSetInfo, &r);
1999         }
2000
2001         TALLOC_FREE(frame);
2002         return (NET_API_STATUS)r.out.result;
2003 }
2004
2005 /****************************************************************
2006  NetLocalGroupEnum
2007 ****************************************************************/
2008
2009 NET_API_STATUS NetLocalGroupEnum(const char * server_name /* [in] */,
2010                                  uint32_t level /* [in] */,
2011                                  uint8_t **buffer /* [out] [ref] */,
2012                                  uint32_t prefmaxlen /* [in] */,
2013                                  uint32_t *entries_read /* [out] [ref] */,
2014                                  uint32_t *total_entries /* [out] [ref] */,
2015                                  uint32_t *resume_handle /* [in,out] [ref] */)
2016 {
2017         struct NetLocalGroupEnum r;
2018         struct libnetapi_ctx *ctx = NULL;
2019         NET_API_STATUS status;
2020         WERROR werr;
2021         TALLOC_CTX *frame = talloc_stackframe();
2022
2023         ZERO_STRUCT(r);
2024
2025         status = libnetapi_getctx(&ctx);
2026         if (status != 0) {
2027                 TALLOC_FREE(frame);
2028                 return status;
2029         }
2030
2031         /* In parameters */
2032         r.in.server_name = server_name;
2033         r.in.level = level;
2034         r.in.prefmaxlen = prefmaxlen;
2035         r.in.resume_handle = resume_handle;
2036
2037         /* Out parameters */
2038         r.out.buffer = buffer;
2039         r.out.entries_read = entries_read;
2040         r.out.total_entries = total_entries;
2041         r.out.resume_handle = resume_handle;
2042
2043         if (DEBUGLEVEL >= 10) {
2044                 NDR_PRINT_IN_DEBUG(NetLocalGroupEnum, &r);
2045         }
2046
2047         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2048                 werr = NetLocalGroupEnum_l(ctx, &r);
2049         } else {
2050                 werr = NetLocalGroupEnum_r(ctx, &r);
2051         }
2052
2053         r.out.result = W_ERROR_V(werr);
2054
2055         if (DEBUGLEVEL >= 10) {
2056                 NDR_PRINT_OUT_DEBUG(NetLocalGroupEnum, &r);
2057         }
2058
2059         TALLOC_FREE(frame);
2060         return (NET_API_STATUS)r.out.result;
2061 }
2062
2063 /****************************************************************
2064  NetLocalGroupAddMembers
2065 ****************************************************************/
2066
2067 NET_API_STATUS NetLocalGroupAddMembers(const char * server_name /* [in] */,
2068                                        const char * group_name /* [in] */,
2069                                        uint32_t level /* [in] */,
2070                                        uint8_t *buffer /* [in] [ref] */,
2071                                        uint32_t total_entries /* [in] */)
2072 {
2073         struct NetLocalGroupAddMembers r;
2074         struct libnetapi_ctx *ctx = NULL;
2075         NET_API_STATUS status;
2076         WERROR werr;
2077         TALLOC_CTX *frame = talloc_stackframe();
2078
2079         ZERO_STRUCT(r);
2080
2081         status = libnetapi_getctx(&ctx);
2082         if (status != 0) {
2083                 TALLOC_FREE(frame);
2084                 return status;
2085         }
2086
2087         /* In parameters */
2088         r.in.server_name = server_name;
2089         r.in.group_name = group_name;
2090         r.in.level = level;
2091         r.in.buffer = buffer;
2092         r.in.total_entries = total_entries;
2093
2094         /* Out parameters */
2095
2096         if (DEBUGLEVEL >= 10) {
2097                 NDR_PRINT_IN_DEBUG(NetLocalGroupAddMembers, &r);
2098         }
2099
2100         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2101                 werr = NetLocalGroupAddMembers_l(ctx, &r);
2102         } else {
2103                 werr = NetLocalGroupAddMembers_r(ctx, &r);
2104         }
2105
2106         r.out.result = W_ERROR_V(werr);
2107
2108         if (DEBUGLEVEL >= 10) {
2109                 NDR_PRINT_OUT_DEBUG(NetLocalGroupAddMembers, &r);
2110         }
2111
2112         TALLOC_FREE(frame);
2113         return (NET_API_STATUS)r.out.result;
2114 }
2115
2116 /****************************************************************
2117  NetLocalGroupDelMembers
2118 ****************************************************************/
2119
2120 NET_API_STATUS NetLocalGroupDelMembers(const char * server_name /* [in] */,
2121                                        const char * group_name /* [in] */,
2122                                        uint32_t level /* [in] */,
2123                                        uint8_t *buffer /* [in] [ref] */,
2124                                        uint32_t total_entries /* [in] */)
2125 {
2126         struct NetLocalGroupDelMembers r;
2127         struct libnetapi_ctx *ctx = NULL;
2128         NET_API_STATUS status;
2129         WERROR werr;
2130         TALLOC_CTX *frame = talloc_stackframe();
2131
2132         ZERO_STRUCT(r);
2133
2134         status = libnetapi_getctx(&ctx);
2135         if (status != 0) {
2136                 TALLOC_FREE(frame);
2137                 return status;
2138         }
2139
2140         /* In parameters */
2141         r.in.server_name = server_name;
2142         r.in.group_name = group_name;
2143         r.in.level = level;
2144         r.in.buffer = buffer;
2145         r.in.total_entries = total_entries;
2146
2147         /* Out parameters */
2148
2149         if (DEBUGLEVEL >= 10) {
2150                 NDR_PRINT_IN_DEBUG(NetLocalGroupDelMembers, &r);
2151         }
2152
2153         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2154                 werr = NetLocalGroupDelMembers_l(ctx, &r);
2155         } else {
2156                 werr = NetLocalGroupDelMembers_r(ctx, &r);
2157         }
2158
2159         r.out.result = W_ERROR_V(werr);
2160
2161         if (DEBUGLEVEL >= 10) {
2162                 NDR_PRINT_OUT_DEBUG(NetLocalGroupDelMembers, &r);
2163         }
2164
2165         TALLOC_FREE(frame);
2166         return (NET_API_STATUS)r.out.result;
2167 }
2168
2169 /****************************************************************
2170  NetLocalGroupGetMembers
2171 ****************************************************************/
2172
2173 NET_API_STATUS NetLocalGroupGetMembers(const char * server_name /* [in] */,
2174                                        const char * local_group_name /* [in] */,
2175                                        uint32_t level /* [in] */,
2176                                        uint8_t **buffer /* [out] [ref] */,
2177                                        uint32_t prefmaxlen /* [in] */,
2178                                        uint32_t *entries_read /* [out] [ref] */,
2179                                        uint32_t *total_entries /* [out] [ref] */,
2180                                        uint32_t *resume_handle /* [in,out] [ref] */)
2181 {
2182         struct NetLocalGroupGetMembers r;
2183         struct libnetapi_ctx *ctx = NULL;
2184         NET_API_STATUS status;
2185         WERROR werr;
2186         TALLOC_CTX *frame = talloc_stackframe();
2187
2188         ZERO_STRUCT(r);
2189
2190         status = libnetapi_getctx(&ctx);
2191         if (status != 0) {
2192                 TALLOC_FREE(frame);
2193                 return status;
2194         }
2195
2196         /* In parameters */
2197         r.in.server_name = server_name;
2198         r.in.local_group_name = local_group_name;
2199         r.in.level = level;
2200         r.in.prefmaxlen = prefmaxlen;
2201         r.in.resume_handle = resume_handle;
2202
2203         /* Out parameters */
2204         r.out.buffer = buffer;
2205         r.out.entries_read = entries_read;
2206         r.out.total_entries = total_entries;
2207         r.out.resume_handle = resume_handle;
2208
2209         if (DEBUGLEVEL >= 10) {
2210                 NDR_PRINT_IN_DEBUG(NetLocalGroupGetMembers, &r);
2211         }
2212
2213         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2214                 werr = NetLocalGroupGetMembers_l(ctx, &r);
2215         } else {
2216                 werr = NetLocalGroupGetMembers_r(ctx, &r);
2217         }
2218
2219         r.out.result = W_ERROR_V(werr);
2220
2221         if (DEBUGLEVEL >= 10) {
2222                 NDR_PRINT_OUT_DEBUG(NetLocalGroupGetMembers, &r);
2223         }
2224
2225         TALLOC_FREE(frame);
2226         return (NET_API_STATUS)r.out.result;
2227 }
2228
2229 /****************************************************************
2230  NetLocalGroupSetMembers
2231 ****************************************************************/
2232
2233 NET_API_STATUS NetLocalGroupSetMembers(const char * server_name /* [in] */,
2234                                        const char * group_name /* [in] */,
2235                                        uint32_t level /* [in] */,
2236                                        uint8_t *buffer /* [in] [ref] */,
2237                                        uint32_t total_entries /* [in] */)
2238 {
2239         struct NetLocalGroupSetMembers r;
2240         struct libnetapi_ctx *ctx = NULL;
2241         NET_API_STATUS status;
2242         WERROR werr;
2243         TALLOC_CTX *frame = talloc_stackframe();
2244
2245         ZERO_STRUCT(r);
2246
2247         status = libnetapi_getctx(&ctx);
2248         if (status != 0) {
2249                 TALLOC_FREE(frame);
2250                 return status;
2251         }
2252
2253         /* In parameters */
2254         r.in.server_name = server_name;
2255         r.in.group_name = group_name;
2256         r.in.level = level;
2257         r.in.buffer = buffer;
2258         r.in.total_entries = total_entries;
2259
2260         /* Out parameters */
2261
2262         if (DEBUGLEVEL >= 10) {
2263                 NDR_PRINT_IN_DEBUG(NetLocalGroupSetMembers, &r);
2264         }
2265
2266         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2267                 werr = NetLocalGroupSetMembers_l(ctx, &r);
2268         } else {
2269                 werr = NetLocalGroupSetMembers_r(ctx, &r);
2270         }
2271
2272         r.out.result = W_ERROR_V(werr);
2273
2274         if (DEBUGLEVEL >= 10) {
2275                 NDR_PRINT_OUT_DEBUG(NetLocalGroupSetMembers, &r);
2276         }
2277
2278         TALLOC_FREE(frame);
2279         return (NET_API_STATUS)r.out.result;
2280 }
2281
2282 /****************************************************************
2283  NetRemoteTOD
2284 ****************************************************************/
2285
2286 NET_API_STATUS NetRemoteTOD(const char * server_name /* [in] */,
2287                             uint8_t **buffer /* [out] [ref] */)
2288 {
2289         struct NetRemoteTOD r;
2290         struct libnetapi_ctx *ctx = NULL;
2291         NET_API_STATUS status;
2292         WERROR werr;
2293         TALLOC_CTX *frame = talloc_stackframe();
2294
2295         ZERO_STRUCT(r);
2296
2297         status = libnetapi_getctx(&ctx);
2298         if (status != 0) {
2299                 TALLOC_FREE(frame);
2300                 return status;
2301         }
2302
2303         /* In parameters */
2304         r.in.server_name = server_name;
2305
2306         /* Out parameters */
2307         r.out.buffer = buffer;
2308
2309         if (DEBUGLEVEL >= 10) {
2310                 NDR_PRINT_IN_DEBUG(NetRemoteTOD, &r);
2311         }
2312
2313         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2314                 werr = NetRemoteTOD_l(ctx, &r);
2315         } else {
2316                 werr = NetRemoteTOD_r(ctx, &r);
2317         }
2318
2319         r.out.result = W_ERROR_V(werr);
2320
2321         if (DEBUGLEVEL >= 10) {
2322                 NDR_PRINT_OUT_DEBUG(NetRemoteTOD, &r);
2323         }
2324
2325         TALLOC_FREE(frame);
2326         return (NET_API_STATUS)r.out.result;
2327 }
2328
2329 /****************************************************************
2330  NetShareAdd
2331 ****************************************************************/
2332
2333 NET_API_STATUS NetShareAdd(const char * server_name /* [in] */,
2334                            uint32_t level /* [in] */,
2335                            uint8_t *buffer /* [in] [ref] */,
2336                            uint32_t *parm_err /* [out] [ref] */)
2337 {
2338         struct NetShareAdd r;
2339         struct libnetapi_ctx *ctx = NULL;
2340         NET_API_STATUS status;
2341         WERROR werr;
2342         TALLOC_CTX *frame = talloc_stackframe();
2343
2344         ZERO_STRUCT(r);
2345
2346         status = libnetapi_getctx(&ctx);
2347         if (status != 0) {
2348                 TALLOC_FREE(frame);
2349                 return status;
2350         }
2351
2352         /* In parameters */
2353         r.in.server_name = server_name;
2354         r.in.level = level;
2355         r.in.buffer = buffer;
2356
2357         /* Out parameters */
2358         r.out.parm_err = parm_err;
2359
2360         if (DEBUGLEVEL >= 10) {
2361                 NDR_PRINT_IN_DEBUG(NetShareAdd, &r);
2362         }
2363
2364         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2365                 werr = NetShareAdd_l(ctx, &r);
2366         } else {
2367                 werr = NetShareAdd_r(ctx, &r);
2368         }
2369
2370         r.out.result = W_ERROR_V(werr);
2371
2372         if (DEBUGLEVEL >= 10) {
2373                 NDR_PRINT_OUT_DEBUG(NetShareAdd, &r);
2374         }
2375
2376         TALLOC_FREE(frame);
2377         return (NET_API_STATUS)r.out.result;
2378 }
2379
2380 /****************************************************************
2381  NetShareDel
2382 ****************************************************************/
2383
2384 NET_API_STATUS NetShareDel(const char * server_name /* [in] */,
2385                            const char * net_name /* [in] */,
2386                            uint32_t reserved /* [in] */)
2387 {
2388         struct NetShareDel r;
2389         struct libnetapi_ctx *ctx = NULL;
2390         NET_API_STATUS status;
2391         WERROR werr;
2392         TALLOC_CTX *frame = talloc_stackframe();
2393
2394         ZERO_STRUCT(r);
2395
2396         status = libnetapi_getctx(&ctx);
2397         if (status != 0) {
2398                 TALLOC_FREE(frame);
2399                 return status;
2400         }
2401
2402         /* In parameters */
2403         r.in.server_name = server_name;
2404         r.in.net_name = net_name;
2405         r.in.reserved = reserved;
2406
2407         /* Out parameters */
2408
2409         if (DEBUGLEVEL >= 10) {
2410                 NDR_PRINT_IN_DEBUG(NetShareDel, &r);
2411         }
2412
2413         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2414                 werr = NetShareDel_l(ctx, &r);
2415         } else {
2416                 werr = NetShareDel_r(ctx, &r);
2417         }
2418
2419         r.out.result = W_ERROR_V(werr);
2420
2421         if (DEBUGLEVEL >= 10) {
2422                 NDR_PRINT_OUT_DEBUG(NetShareDel, &r);
2423         }
2424
2425         TALLOC_FREE(frame);
2426         return (NET_API_STATUS)r.out.result;
2427 }
2428
2429 /****************************************************************
2430  NetShareEnum
2431 ****************************************************************/
2432
2433 NET_API_STATUS NetShareEnum(const char * server_name /* [in] */,
2434                             uint32_t level /* [in] */,
2435                             uint8_t **buffer /* [out] [ref] */,
2436                             uint32_t prefmaxlen /* [in] */,
2437                             uint32_t *entries_read /* [out] [ref] */,
2438                             uint32_t *total_entries /* [out] [ref] */,
2439                             uint32_t *resume_handle /* [in,out] [ref] */)
2440 {
2441         struct NetShareEnum r;
2442         struct libnetapi_ctx *ctx = NULL;
2443         NET_API_STATUS status;
2444         WERROR werr;
2445         TALLOC_CTX *frame = talloc_stackframe();
2446
2447         ZERO_STRUCT(r);
2448
2449         status = libnetapi_getctx(&ctx);
2450         if (status != 0) {
2451                 TALLOC_FREE(frame);
2452                 return status;
2453         }
2454
2455         /* In parameters */
2456         r.in.server_name = server_name;
2457         r.in.level = level;
2458         r.in.prefmaxlen = prefmaxlen;
2459         r.in.resume_handle = resume_handle;
2460
2461         /* Out parameters */
2462         r.out.buffer = buffer;
2463         r.out.entries_read = entries_read;
2464         r.out.total_entries = total_entries;
2465         r.out.resume_handle = resume_handle;
2466
2467         if (DEBUGLEVEL >= 10) {
2468                 NDR_PRINT_IN_DEBUG(NetShareEnum, &r);
2469         }
2470
2471         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2472                 werr = NetShareEnum_l(ctx, &r);
2473         } else {
2474                 werr = NetShareEnum_r(ctx, &r);
2475         }
2476
2477         r.out.result = W_ERROR_V(werr);
2478
2479         if (DEBUGLEVEL >= 10) {
2480                 NDR_PRINT_OUT_DEBUG(NetShareEnum, &r);
2481         }
2482
2483         TALLOC_FREE(frame);
2484         return (NET_API_STATUS)r.out.result;
2485 }
2486
2487 /****************************************************************
2488  NetShareGetInfo
2489 ****************************************************************/
2490
2491 NET_API_STATUS NetShareGetInfo(const char * server_name /* [in] */,
2492                                const char * net_name /* [in] */,
2493                                uint32_t level /* [in] */,
2494                                uint8_t **buffer /* [out] [ref] */)
2495 {
2496         struct NetShareGetInfo r;
2497         struct libnetapi_ctx *ctx = NULL;
2498         NET_API_STATUS status;
2499         WERROR werr;
2500         TALLOC_CTX *frame = talloc_stackframe();
2501
2502         ZERO_STRUCT(r);
2503
2504         status = libnetapi_getctx(&ctx);
2505         if (status != 0) {
2506                 TALLOC_FREE(frame);
2507                 return status;
2508         }
2509
2510         /* In parameters */
2511         r.in.server_name = server_name;
2512         r.in.net_name = net_name;
2513         r.in.level = level;
2514
2515         /* Out parameters */
2516         r.out.buffer = buffer;
2517
2518         if (DEBUGLEVEL >= 10) {
2519                 NDR_PRINT_IN_DEBUG(NetShareGetInfo, &r);
2520         }
2521
2522         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2523                 werr = NetShareGetInfo_l(ctx, &r);
2524         } else {
2525                 werr = NetShareGetInfo_r(ctx, &r);
2526         }
2527
2528         r.out.result = W_ERROR_V(werr);
2529
2530         if (DEBUGLEVEL >= 10) {
2531                 NDR_PRINT_OUT_DEBUG(NetShareGetInfo, &r);
2532         }
2533
2534         TALLOC_FREE(frame);
2535         return (NET_API_STATUS)r.out.result;
2536 }
2537
2538 /****************************************************************
2539  NetShareSetInfo
2540 ****************************************************************/
2541
2542 NET_API_STATUS NetShareSetInfo(const char * server_name /* [in] */,
2543                                const char * net_name /* [in] */,
2544                                uint32_t level /* [in] */,
2545                                uint8_t *buffer /* [in] [ref] */,
2546                                uint32_t *parm_err /* [out] [ref] */)
2547 {
2548         struct NetShareSetInfo r;
2549         struct libnetapi_ctx *ctx = NULL;
2550         NET_API_STATUS status;
2551         WERROR werr;
2552         TALLOC_CTX *frame = talloc_stackframe();
2553
2554         ZERO_STRUCT(r);
2555
2556         status = libnetapi_getctx(&ctx);
2557         if (status != 0) {
2558                 TALLOC_FREE(frame);
2559                 return status;
2560         }
2561
2562         /* In parameters */
2563         r.in.server_name = server_name;
2564         r.in.net_name = net_name;
2565         r.in.level = level;
2566         r.in.buffer = buffer;
2567
2568         /* Out parameters */
2569         r.out.parm_err = parm_err;
2570
2571         if (DEBUGLEVEL >= 10) {
2572                 NDR_PRINT_IN_DEBUG(NetShareSetInfo, &r);
2573         }
2574
2575         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2576                 werr = NetShareSetInfo_l(ctx, &r);
2577         } else {
2578                 werr = NetShareSetInfo_r(ctx, &r);
2579         }
2580
2581         r.out.result = W_ERROR_V(werr);
2582
2583         if (DEBUGLEVEL >= 10) {
2584                 NDR_PRINT_OUT_DEBUG(NetShareSetInfo, &r);
2585         }
2586
2587         TALLOC_FREE(frame);
2588         return (NET_API_STATUS)r.out.result;
2589 }
2590
2591 /****************************************************************
2592  NetFileClose
2593 ****************************************************************/
2594
2595 NET_API_STATUS NetFileClose(const char * server_name /* [in] */,
2596                             uint32_t fileid /* [in] */)
2597 {
2598         struct NetFileClose r;
2599         struct libnetapi_ctx *ctx = NULL;
2600         NET_API_STATUS status;
2601         WERROR werr;
2602         TALLOC_CTX *frame = talloc_stackframe();
2603
2604         ZERO_STRUCT(r);
2605
2606         status = libnetapi_getctx(&ctx);
2607         if (status != 0) {
2608                 TALLOC_FREE(frame);
2609                 return status;
2610         }
2611
2612         /* In parameters */
2613         r.in.server_name = server_name;
2614         r.in.fileid = fileid;
2615
2616         /* Out parameters */
2617
2618         if (DEBUGLEVEL >= 10) {
2619                 NDR_PRINT_IN_DEBUG(NetFileClose, &r);
2620         }
2621
2622         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2623                 werr = NetFileClose_l(ctx, &r);
2624         } else {
2625                 werr = NetFileClose_r(ctx, &r);
2626         }
2627
2628         r.out.result = W_ERROR_V(werr);
2629
2630         if (DEBUGLEVEL >= 10) {
2631                 NDR_PRINT_OUT_DEBUG(NetFileClose, &r);
2632         }
2633
2634         TALLOC_FREE(frame);
2635         return (NET_API_STATUS)r.out.result;
2636 }
2637
2638 /****************************************************************
2639  NetFileGetInfo
2640 ****************************************************************/
2641
2642 NET_API_STATUS NetFileGetInfo(const char * server_name /* [in] */,
2643                               uint32_t fileid /* [in] */,
2644                               uint32_t level /* [in] */,
2645                               uint8_t **buffer /* [out] [ref] */)
2646 {
2647         struct NetFileGetInfo r;
2648         struct libnetapi_ctx *ctx = NULL;
2649         NET_API_STATUS status;
2650         WERROR werr;
2651         TALLOC_CTX *frame = talloc_stackframe();
2652
2653         ZERO_STRUCT(r);
2654
2655         status = libnetapi_getctx(&ctx);
2656         if (status != 0) {
2657                 TALLOC_FREE(frame);
2658                 return status;
2659         }
2660
2661         /* In parameters */
2662         r.in.server_name = server_name;
2663         r.in.fileid = fileid;
2664         r.in.level = level;
2665
2666         /* Out parameters */
2667         r.out.buffer = buffer;
2668
2669         if (DEBUGLEVEL >= 10) {
2670                 NDR_PRINT_IN_DEBUG(NetFileGetInfo, &r);
2671         }
2672
2673         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2674                 werr = NetFileGetInfo_l(ctx, &r);
2675         } else {
2676                 werr = NetFileGetInfo_r(ctx, &r);
2677         }
2678
2679         r.out.result = W_ERROR_V(werr);
2680
2681         if (DEBUGLEVEL >= 10) {
2682                 NDR_PRINT_OUT_DEBUG(NetFileGetInfo, &r);
2683         }
2684
2685         TALLOC_FREE(frame);
2686         return (NET_API_STATUS)r.out.result;
2687 }
2688
2689 /****************************************************************
2690  NetFileEnum
2691 ****************************************************************/
2692
2693 NET_API_STATUS NetFileEnum(const char * server_name /* [in] */,
2694                            const char * base_path /* [in] */,
2695                            const char * user_name /* [in] */,
2696                            uint32_t level /* [in] */,
2697                            uint8_t **buffer /* [out] [ref] */,
2698                            uint32_t prefmaxlen /* [in] */,
2699                            uint32_t *entries_read /* [out] [ref] */,
2700                            uint32_t *total_entries /* [out] [ref] */,
2701                            uint32_t *resume_handle /* [in,out] [ref] */)
2702 {
2703         struct NetFileEnum r;
2704         struct libnetapi_ctx *ctx = NULL;
2705         NET_API_STATUS status;
2706         WERROR werr;
2707         TALLOC_CTX *frame = talloc_stackframe();
2708
2709         ZERO_STRUCT(r);
2710
2711         status = libnetapi_getctx(&ctx);
2712         if (status != 0) {
2713                 TALLOC_FREE(frame);
2714                 return status;
2715         }
2716
2717         /* In parameters */
2718         r.in.server_name = server_name;
2719         r.in.base_path = base_path;
2720         r.in.user_name = user_name;
2721         r.in.level = level;
2722         r.in.prefmaxlen = prefmaxlen;
2723         r.in.resume_handle = resume_handle;
2724
2725         /* Out parameters */
2726         r.out.buffer = buffer;
2727         r.out.entries_read = entries_read;
2728         r.out.total_entries = total_entries;
2729         r.out.resume_handle = resume_handle;
2730
2731         if (DEBUGLEVEL >= 10) {
2732                 NDR_PRINT_IN_DEBUG(NetFileEnum, &r);
2733         }
2734
2735         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2736                 werr = NetFileEnum_l(ctx, &r);
2737         } else {
2738                 werr = NetFileEnum_r(ctx, &r);
2739         }
2740
2741         r.out.result = W_ERROR_V(werr);
2742
2743         if (DEBUGLEVEL >= 10) {
2744                 NDR_PRINT_OUT_DEBUG(NetFileEnum, &r);
2745         }
2746
2747         TALLOC_FREE(frame);
2748         return (NET_API_STATUS)r.out.result;
2749 }
2750
2751 /****************************************************************
2752  NetShutdownInit
2753 ****************************************************************/
2754
2755 NET_API_STATUS NetShutdownInit(const char * server_name /* [in] */,
2756                                const char * message /* [in] */,
2757                                uint32_t timeout /* [in] */,
2758                                uint8_t force_apps /* [in] */,
2759                                uint8_t do_reboot /* [in] */)
2760 {
2761         struct NetShutdownInit r;
2762         struct libnetapi_ctx *ctx = NULL;
2763         NET_API_STATUS status;
2764         WERROR werr;
2765         TALLOC_CTX *frame = talloc_stackframe();
2766
2767         ZERO_STRUCT(r);
2768
2769         status = libnetapi_getctx(&ctx);
2770         if (status != 0) {
2771                 TALLOC_FREE(frame);
2772                 return status;
2773         }
2774
2775         /* In parameters */
2776         r.in.server_name = server_name;
2777         r.in.message = message;
2778         r.in.timeout = timeout;
2779         r.in.force_apps = force_apps;
2780         r.in.do_reboot = do_reboot;
2781
2782         /* Out parameters */
2783
2784         if (DEBUGLEVEL >= 10) {
2785                 NDR_PRINT_IN_DEBUG(NetShutdownInit, &r);
2786         }
2787
2788         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2789                 werr = NetShutdownInit_l(ctx, &r);
2790         } else {
2791                 werr = NetShutdownInit_r(ctx, &r);
2792         }
2793
2794         r.out.result = W_ERROR_V(werr);
2795
2796         if (DEBUGLEVEL >= 10) {
2797                 NDR_PRINT_OUT_DEBUG(NetShutdownInit, &r);
2798         }
2799
2800         TALLOC_FREE(frame);
2801         return (NET_API_STATUS)r.out.result;
2802 }
2803
2804 /****************************************************************
2805  NetShutdownAbort
2806 ****************************************************************/
2807
2808 NET_API_STATUS NetShutdownAbort(const char * server_name /* [in] */)
2809 {
2810         struct NetShutdownAbort r;
2811         struct libnetapi_ctx *ctx = NULL;
2812         NET_API_STATUS status;
2813         WERROR werr;
2814         TALLOC_CTX *frame = talloc_stackframe();
2815
2816         ZERO_STRUCT(r);
2817
2818         status = libnetapi_getctx(&ctx);
2819         if (status != 0) {
2820                 TALLOC_FREE(frame);
2821                 return status;
2822         }
2823
2824         /* In parameters */
2825         r.in.server_name = server_name;
2826
2827         /* Out parameters */
2828
2829         if (DEBUGLEVEL >= 10) {
2830                 NDR_PRINT_IN_DEBUG(NetShutdownAbort, &r);
2831         }
2832
2833         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2834                 werr = NetShutdownAbort_l(ctx, &r);
2835         } else {
2836                 werr = NetShutdownAbort_r(ctx, &r);
2837         }
2838
2839         r.out.result = W_ERROR_V(werr);
2840
2841         if (DEBUGLEVEL >= 10) {
2842                 NDR_PRINT_OUT_DEBUG(NetShutdownAbort, &r);
2843         }
2844
2845         TALLOC_FREE(frame);
2846         return (NET_API_STATUS)r.out.result;
2847 }
2848
2849 /****************************************************************
2850  I_NetLogonControl
2851 ****************************************************************/
2852
2853 NET_API_STATUS I_NetLogonControl(const char * server_name /* [in] */,
2854                                  uint32_t function_code /* [in] */,
2855                                  uint32_t query_level /* [in] */,
2856                                  uint8_t **buffer /* [out] [ref] */)
2857 {
2858         struct I_NetLogonControl r;
2859         struct libnetapi_ctx *ctx = NULL;
2860         NET_API_STATUS status;
2861         WERROR werr;
2862         TALLOC_CTX *frame = talloc_stackframe();
2863
2864         ZERO_STRUCT(r);
2865
2866         status = libnetapi_getctx(&ctx);
2867         if (status != 0) {
2868                 TALLOC_FREE(frame);
2869                 return status;
2870         }
2871
2872         /* In parameters */
2873         r.in.server_name = server_name;
2874         r.in.function_code = function_code;
2875         r.in.query_level = query_level;
2876
2877         /* Out parameters */
2878         r.out.buffer = buffer;
2879
2880         if (DEBUGLEVEL >= 10) {
2881                 NDR_PRINT_IN_DEBUG(I_NetLogonControl, &r);
2882         }
2883
2884         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2885                 werr = I_NetLogonControl_l(ctx, &r);
2886         } else {
2887                 werr = I_NetLogonControl_r(ctx, &r);
2888         }
2889
2890         r.out.result = W_ERROR_V(werr);
2891
2892         if (DEBUGLEVEL >= 10) {
2893                 NDR_PRINT_OUT_DEBUG(I_NetLogonControl, &r);
2894         }
2895
2896         TALLOC_FREE(frame);
2897         return (NET_API_STATUS)r.out.result;
2898 }
2899
2900 /****************************************************************
2901  I_NetLogonControl2
2902 ****************************************************************/
2903
2904 NET_API_STATUS I_NetLogonControl2(const char * server_name /* [in] */,
2905                                   uint32_t function_code /* [in] */,
2906                                   uint32_t query_level /* [in] */,
2907                                   uint8_t *data /* [in] [unique] */,
2908                                   uint8_t **buffer /* [out] [ref] */)
2909 {
2910         struct I_NetLogonControl2 r;
2911         struct libnetapi_ctx *ctx = NULL;
2912         NET_API_STATUS status;
2913         WERROR werr;
2914         TALLOC_CTX *frame = talloc_stackframe();
2915
2916         ZERO_STRUCT(r);
2917
2918         status = libnetapi_getctx(&ctx);
2919         if (status != 0) {
2920                 TALLOC_FREE(frame);
2921                 return status;
2922         }
2923
2924         /* In parameters */
2925         r.in.server_name = server_name;
2926         r.in.function_code = function_code;
2927         r.in.query_level = query_level;
2928         r.in.data = data;
2929
2930         /* Out parameters */
2931         r.out.buffer = buffer;
2932
2933         if (DEBUGLEVEL >= 10) {
2934                 NDR_PRINT_IN_DEBUG(I_NetLogonControl2, &r);
2935         }
2936
2937         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2938                 werr = I_NetLogonControl2_l(ctx, &r);
2939         } else {
2940                 werr = I_NetLogonControl2_r(ctx, &r);
2941         }
2942
2943         r.out.result = W_ERROR_V(werr);
2944
2945         if (DEBUGLEVEL >= 10) {
2946                 NDR_PRINT_OUT_DEBUG(I_NetLogonControl2, &r);
2947         }
2948
2949         TALLOC_FREE(frame);
2950         return (NET_API_STATUS)r.out.result;
2951 }
2952