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