root/source3/lib/netapi/libnetapi.c

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

DEFINITIONS

This source file includes following definitions.
  1. NetJoinDomain
  2. NetUnjoinDomain
  3. NetGetJoinInformation
  4. NetGetJoinableOUs
  5. NetRenameMachineInDomain
  6. NetServerGetInfo
  7. NetServerSetInfo
  8. NetGetDCName
  9. NetGetAnyDCName
  10. DsGetDcName
  11. NetUserAdd
  12. NetUserDel
  13. NetUserEnum
  14. NetUserChangePassword
  15. NetUserGetInfo
  16. NetUserSetInfo
  17. NetUserGetGroups
  18. NetUserSetGroups
  19. NetUserGetLocalGroups
  20. NetUserModalsGet
  21. NetUserModalsSet
  22. NetQueryDisplayInformation
  23. NetGroupAdd
  24. NetGroupDel
  25. NetGroupEnum
  26. NetGroupSetInfo
  27. NetGroupGetInfo
  28. NetGroupAddUser
  29. NetGroupDelUser
  30. NetGroupGetUsers
  31. NetGroupSetUsers
  32. NetLocalGroupAdd
  33. NetLocalGroupDel
  34. NetLocalGroupGetInfo
  35. NetLocalGroupSetInfo
  36. NetLocalGroupEnum
  37. NetLocalGroupAddMembers
  38. NetLocalGroupDelMembers
  39. NetLocalGroupGetMembers
  40. NetLocalGroupSetMembers
  41. NetRemoteTOD
  42. NetShareAdd
  43. NetShareDel
  44. NetShareEnum
  45. NetShareGetInfo
  46. NetShareSetInfo
  47. NetFileClose
  48. NetFileGetInfo
  49. NetFileEnum
  50. NetShutdownInit
  51. NetShutdownAbort

   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] */,
     /* [<][>][^][v][top][bottom][index][help] */
  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 
  43         status = libnetapi_getctx(&ctx);
  44         if (status != 0) {
  45                 return status;
  46         }
  47 
  48         /* In parameters */
  49         r.in.server = server;
  50         r.in.domain = domain;
  51         r.in.account_ou = account_ou;
  52         r.in.account = account;
  53         r.in.password = password;
  54         r.in.join_flags = join_flags;
  55 
  56         /* Out parameters */
  57 
  58         if (DEBUGLEVEL >= 10) {
  59                 NDR_PRINT_IN_DEBUG(NetJoinDomain, &r);
  60         }
  61 
  62         if (LIBNETAPI_LOCAL_SERVER(server)) {
  63                 werr = NetJoinDomain_l(ctx, &r);
  64         } else {
  65                 werr = NetJoinDomain_r(ctx, &r);
  66         }
  67 
  68         r.out.result = W_ERROR_V(werr);
  69 
  70         if (DEBUGLEVEL >= 10) {
  71                 NDR_PRINT_OUT_DEBUG(NetJoinDomain, &r);
  72         }
  73 
  74         return r.out.result;
  75 }
  76 
  77 /****************************************************************
  78  NetUnjoinDomain
  79 ****************************************************************/
  80 
  81 NET_API_STATUS NetUnjoinDomain(const char * server_name /* [in] [unique] */,
     /* [<][>][^][v][top][bottom][index][help] */
  82                                const char * account /* [in] [unique] */,
  83                                const char * password /* [in] [unique] */,
  84                                uint32_t unjoin_flags /* [in] */)
  85 {
  86         struct NetUnjoinDomain r;
  87         struct libnetapi_ctx *ctx = NULL;
  88         NET_API_STATUS status;
  89         WERROR werr;
  90 
  91         status = libnetapi_getctx(&ctx);
  92         if (status != 0) {
  93                 return status;
  94         }
  95 
  96         /* In parameters */
  97         r.in.server_name = server_name;
  98         r.in.account = account;
  99         r.in.password = password;
 100         r.in.unjoin_flags = unjoin_flags;
 101 
 102         /* Out parameters */
 103 
 104         if (DEBUGLEVEL >= 10) {
 105                 NDR_PRINT_IN_DEBUG(NetUnjoinDomain, &r);
 106         }
 107 
 108         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 109                 werr = NetUnjoinDomain_l(ctx, &r);
 110         } else {
 111                 werr = NetUnjoinDomain_r(ctx, &r);
 112         }
 113 
 114         r.out.result = W_ERROR_V(werr);
 115 
 116         if (DEBUGLEVEL >= 10) {
 117                 NDR_PRINT_OUT_DEBUG(NetUnjoinDomain, &r);
 118         }
 119 
 120         return r.out.result;
 121 }
 122 
 123 /****************************************************************
 124  NetGetJoinInformation
 125 ****************************************************************/
 126 
 127 NET_API_STATUS NetGetJoinInformation(const char * server_name /* [in] [unique] */,
     /* [<][>][^][v][top][bottom][index][help] */
 128                                      const char * *name_buffer /* [out] [ref] */,
 129                                      uint16_t *name_type /* [out] [ref] */)
 130 {
 131         struct NetGetJoinInformation r;
 132         struct libnetapi_ctx *ctx = NULL;
 133         NET_API_STATUS status;
 134         WERROR werr;
 135 
 136         status = libnetapi_getctx(&ctx);
 137         if (status != 0) {
 138                 return status;
 139         }
 140 
 141         /* In parameters */
 142         r.in.server_name = server_name;
 143 
 144         /* Out parameters */
 145         r.out.name_buffer = name_buffer;
 146         r.out.name_type = name_type;
 147 
 148         if (DEBUGLEVEL >= 10) {
 149                 NDR_PRINT_IN_DEBUG(NetGetJoinInformation, &r);
 150         }
 151 
 152         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 153                 werr = NetGetJoinInformation_l(ctx, &r);
 154         } else {
 155                 werr = NetGetJoinInformation_r(ctx, &r);
 156         }
 157 
 158         r.out.result = W_ERROR_V(werr);
 159 
 160         if (DEBUGLEVEL >= 10) {
 161                 NDR_PRINT_OUT_DEBUG(NetGetJoinInformation, &r);
 162         }
 163 
 164         return r.out.result;
 165 }
 166 
 167 /****************************************************************
 168  NetGetJoinableOUs
 169 ****************************************************************/
 170 
 171 NET_API_STATUS NetGetJoinableOUs(const char * server_name /* [in] [unique] */,
     /* [<][>][^][v][top][bottom][index][help] */
 172                                  const char * domain /* [in] [ref] */,
 173                                  const char * account /* [in] [unique] */,
 174                                  const char * password /* [in] [unique] */,
 175                                  uint32_t *ou_count /* [out] [ref] */,
 176                                  const char * **ous /* [out] [ref] */)
 177 {
 178         struct NetGetJoinableOUs r;
 179         struct libnetapi_ctx *ctx = NULL;
 180         NET_API_STATUS status;
 181         WERROR werr;
 182 
 183         status = libnetapi_getctx(&ctx);
 184         if (status != 0) {
 185                 return status;
 186         }
 187 
 188         /* In parameters */
 189         r.in.server_name = server_name;
 190         r.in.domain = domain;
 191         r.in.account = account;
 192         r.in.password = password;
 193 
 194         /* Out parameters */
 195         r.out.ou_count = ou_count;
 196         r.out.ous = ous;
 197 
 198         if (DEBUGLEVEL >= 10) {
 199                 NDR_PRINT_IN_DEBUG(NetGetJoinableOUs, &r);
 200         }
 201 
 202         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 203                 werr = NetGetJoinableOUs_l(ctx, &r);
 204         } else {
 205                 werr = NetGetJoinableOUs_r(ctx, &r);
 206         }
 207 
 208         r.out.result = W_ERROR_V(werr);
 209 
 210         if (DEBUGLEVEL >= 10) {
 211                 NDR_PRINT_OUT_DEBUG(NetGetJoinableOUs, &r);
 212         }
 213 
 214         return r.out.result;
 215 }
 216 
 217 /****************************************************************
 218  NetRenameMachineInDomain
 219 ****************************************************************/
 220 
 221 NET_API_STATUS NetRenameMachineInDomain(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
 222                                         const char * new_machine_name /* [in] */,
 223                                         const char * account /* [in] */,
 224                                         const char * password /* [in] */,
 225                                         uint32_t rename_options /* [in] */)
 226 {
 227         struct NetRenameMachineInDomain r;
 228         struct libnetapi_ctx *ctx = NULL;
 229         NET_API_STATUS status;
 230         WERROR werr;
 231 
 232         status = libnetapi_getctx(&ctx);
 233         if (status != 0) {
 234                 return status;
 235         }
 236 
 237         /* In parameters */
 238         r.in.server_name = server_name;
 239         r.in.new_machine_name = new_machine_name;
 240         r.in.account = account;
 241         r.in.password = password;
 242         r.in.rename_options = rename_options;
 243 
 244         /* Out parameters */
 245 
 246         if (DEBUGLEVEL >= 10) {
 247                 NDR_PRINT_IN_DEBUG(NetRenameMachineInDomain, &r);
 248         }
 249 
 250         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 251                 werr = NetRenameMachineInDomain_l(ctx, &r);
 252         } else {
 253                 werr = NetRenameMachineInDomain_r(ctx, &r);
 254         }
 255 
 256         r.out.result = W_ERROR_V(werr);
 257 
 258         if (DEBUGLEVEL >= 10) {
 259                 NDR_PRINT_OUT_DEBUG(NetRenameMachineInDomain, &r);
 260         }
 261 
 262         return r.out.result;
 263 }
 264 
 265 /****************************************************************
 266  NetServerGetInfo
 267 ****************************************************************/
 268 
 269 NET_API_STATUS NetServerGetInfo(const char * server_name /* [in] [unique] */,
     /* [<][>][^][v][top][bottom][index][help] */
 270                                 uint32_t level /* [in] */,
 271                                 uint8_t **buffer /* [out] [ref] */)
 272 {
 273         struct NetServerGetInfo r;
 274         struct libnetapi_ctx *ctx = NULL;
 275         NET_API_STATUS status;
 276         WERROR werr;
 277 
 278         status = libnetapi_getctx(&ctx);
 279         if (status != 0) {
 280                 return status;
 281         }
 282 
 283         /* In parameters */
 284         r.in.server_name = server_name;
 285         r.in.level = level;
 286 
 287         /* Out parameters */
 288         r.out.buffer = buffer;
 289 
 290         if (DEBUGLEVEL >= 10) {
 291                 NDR_PRINT_IN_DEBUG(NetServerGetInfo, &r);
 292         }
 293 
 294         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 295                 werr = NetServerGetInfo_l(ctx, &r);
 296         } else {
 297                 werr = NetServerGetInfo_r(ctx, &r);
 298         }
 299 
 300         r.out.result = W_ERROR_V(werr);
 301 
 302         if (DEBUGLEVEL >= 10) {
 303                 NDR_PRINT_OUT_DEBUG(NetServerGetInfo, &r);
 304         }
 305 
 306         return r.out.result;
 307 }
 308 
 309 /****************************************************************
 310  NetServerSetInfo
 311 ****************************************************************/
 312 
 313 NET_API_STATUS NetServerSetInfo(const char * server_name /* [in] [unique] */,
     /* [<][>][^][v][top][bottom][index][help] */
 314                                 uint32_t level /* [in] */,
 315                                 uint8_t *buffer /* [in] [ref] */,
 316                                 uint32_t *parm_error /* [out] [ref] */)
 317 {
 318         struct NetServerSetInfo r;
 319         struct libnetapi_ctx *ctx = NULL;
 320         NET_API_STATUS status;
 321         WERROR werr;
 322 
 323         status = libnetapi_getctx(&ctx);
 324         if (status != 0) {
 325                 return status;
 326         }
 327 
 328         /* In parameters */
 329         r.in.server_name = server_name;
 330         r.in.level = level;
 331         r.in.buffer = buffer;
 332 
 333         /* Out parameters */
 334         r.out.parm_error = parm_error;
 335 
 336         if (DEBUGLEVEL >= 10) {
 337                 NDR_PRINT_IN_DEBUG(NetServerSetInfo, &r);
 338         }
 339 
 340         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 341                 werr = NetServerSetInfo_l(ctx, &r);
 342         } else {
 343                 werr = NetServerSetInfo_r(ctx, &r);
 344         }
 345 
 346         r.out.result = W_ERROR_V(werr);
 347 
 348         if (DEBUGLEVEL >= 10) {
 349                 NDR_PRINT_OUT_DEBUG(NetServerSetInfo, &r);
 350         }
 351 
 352         return r.out.result;
 353 }
 354 
 355 /****************************************************************
 356  NetGetDCName
 357 ****************************************************************/
 358 
 359 NET_API_STATUS NetGetDCName(const char * server_name /* [in] [unique] */,
     /* [<][>][^][v][top][bottom][index][help] */
 360                             const char * domain_name /* [in] [unique] */,
 361                             uint8_t **buffer /* [out] [ref] */)
 362 {
 363         struct NetGetDCName r;
 364         struct libnetapi_ctx *ctx = NULL;
 365         NET_API_STATUS status;
 366         WERROR werr;
 367 
 368         status = libnetapi_getctx(&ctx);
 369         if (status != 0) {
 370                 return status;
 371         }
 372 
 373         /* In parameters */
 374         r.in.server_name = server_name;
 375         r.in.domain_name = domain_name;
 376 
 377         /* Out parameters */
 378         r.out.buffer = buffer;
 379 
 380         if (DEBUGLEVEL >= 10) {
 381                 NDR_PRINT_IN_DEBUG(NetGetDCName, &r);
 382         }
 383 
 384         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 385                 werr = NetGetDCName_l(ctx, &r);
 386         } else {
 387                 werr = NetGetDCName_r(ctx, &r);
 388         }
 389 
 390         r.out.result = W_ERROR_V(werr);
 391 
 392         if (DEBUGLEVEL >= 10) {
 393                 NDR_PRINT_OUT_DEBUG(NetGetDCName, &r);
 394         }
 395 
 396         return r.out.result;
 397 }
 398 
 399 /****************************************************************
 400  NetGetAnyDCName
 401 ****************************************************************/
 402 
 403 NET_API_STATUS NetGetAnyDCName(const char * server_name /* [in] [unique] */,
     /* [<][>][^][v][top][bottom][index][help] */
 404                                const char * domain_name /* [in] [unique] */,
 405                                uint8_t **buffer /* [out] [ref] */)
 406 {
 407         struct NetGetAnyDCName r;
 408         struct libnetapi_ctx *ctx = NULL;
 409         NET_API_STATUS status;
 410         WERROR werr;
 411 
 412         status = libnetapi_getctx(&ctx);
 413         if (status != 0) {
 414                 return status;
 415         }
 416 
 417         /* In parameters */
 418         r.in.server_name = server_name;
 419         r.in.domain_name = domain_name;
 420 
 421         /* Out parameters */
 422         r.out.buffer = buffer;
 423 
 424         if (DEBUGLEVEL >= 10) {
 425                 NDR_PRINT_IN_DEBUG(NetGetAnyDCName, &r);
 426         }
 427 
 428         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 429                 werr = NetGetAnyDCName_l(ctx, &r);
 430         } else {
 431                 werr = NetGetAnyDCName_r(ctx, &r);
 432         }
 433 
 434         r.out.result = W_ERROR_V(werr);
 435 
 436         if (DEBUGLEVEL >= 10) {
 437                 NDR_PRINT_OUT_DEBUG(NetGetAnyDCName, &r);
 438         }
 439 
 440         return r.out.result;
 441 }
 442 
 443 /****************************************************************
 444  DsGetDcName
 445 ****************************************************************/
 446 
 447 NET_API_STATUS DsGetDcName(const char * server_name /* [in] [unique] */,
     /* [<][>][^][v][top][bottom][index][help] */
 448                            const char * domain_name /* [in] [ref] */,
 449                            struct GUID *domain_guid /* [in] [unique] */,
 450                            const char * site_name /* [in] [unique] */,
 451                            uint32_t flags /* [in] */,
 452                            struct DOMAIN_CONTROLLER_INFO **dc_info /* [out] [ref] */)
 453 {
 454         struct DsGetDcName r;
 455         struct libnetapi_ctx *ctx = NULL;
 456         NET_API_STATUS status;
 457         WERROR werr;
 458 
 459         status = libnetapi_getctx(&ctx);
 460         if (status != 0) {
 461                 return status;
 462         }
 463 
 464         /* In parameters */
 465         r.in.server_name = server_name;
 466         r.in.domain_name = domain_name;
 467         r.in.domain_guid = domain_guid;
 468         r.in.site_name = site_name;
 469         r.in.flags = flags;
 470 
 471         /* Out parameters */
 472         r.out.dc_info = dc_info;
 473 
 474         if (DEBUGLEVEL >= 10) {
 475                 NDR_PRINT_IN_DEBUG(DsGetDcName, &r);
 476         }
 477 
 478         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 479                 werr = DsGetDcName_l(ctx, &r);
 480         } else {
 481                 werr = DsGetDcName_r(ctx, &r);
 482         }
 483 
 484         r.out.result = W_ERROR_V(werr);
 485 
 486         if (DEBUGLEVEL >= 10) {
 487                 NDR_PRINT_OUT_DEBUG(DsGetDcName, &r);
 488         }
 489 
 490         return r.out.result;
 491 }
 492 
 493 /****************************************************************
 494  NetUserAdd
 495 ****************************************************************/
 496 
 497 NET_API_STATUS NetUserAdd(const char * server_name /* [in] [unique] */,
     /* [<][>][^][v][top][bottom][index][help] */
 498                           uint32_t level /* [in] */,
 499                           uint8_t *buffer /* [in] [ref] */,
 500                           uint32_t *parm_error /* [out] [ref] */)
 501 {
 502         struct NetUserAdd r;
 503         struct libnetapi_ctx *ctx = NULL;
 504         NET_API_STATUS status;
 505         WERROR werr;
 506 
 507         status = libnetapi_getctx(&ctx);
 508         if (status != 0) {
 509                 return status;
 510         }
 511 
 512         /* In parameters */
 513         r.in.server_name = server_name;
 514         r.in.level = level;
 515         r.in.buffer = buffer;
 516 
 517         /* Out parameters */
 518         r.out.parm_error = parm_error;
 519 
 520         if (DEBUGLEVEL >= 10) {
 521                 NDR_PRINT_IN_DEBUG(NetUserAdd, &r);
 522         }
 523 
 524         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 525                 werr = NetUserAdd_l(ctx, &r);
 526         } else {
 527                 werr = NetUserAdd_r(ctx, &r);
 528         }
 529 
 530         r.out.result = W_ERROR_V(werr);
 531 
 532         if (DEBUGLEVEL >= 10) {
 533                 NDR_PRINT_OUT_DEBUG(NetUserAdd, &r);
 534         }
 535 
 536         return r.out.result;
 537 }
 538 
 539 /****************************************************************
 540  NetUserDel
 541 ****************************************************************/
 542 
 543 NET_API_STATUS NetUserDel(const char * server_name /* [in] [unique] */,
     /* [<][>][^][v][top][bottom][index][help] */
 544                           const char * user_name /* [in] [ref] */)
 545 {
 546         struct NetUserDel r;
 547         struct libnetapi_ctx *ctx = NULL;
 548         NET_API_STATUS status;
 549         WERROR werr;
 550 
 551         status = libnetapi_getctx(&ctx);
 552         if (status != 0) {
 553                 return status;
 554         }
 555 
 556         /* In parameters */
 557         r.in.server_name = server_name;
 558         r.in.user_name = user_name;
 559 
 560         /* Out parameters */
 561 
 562         if (DEBUGLEVEL >= 10) {
 563                 NDR_PRINT_IN_DEBUG(NetUserDel, &r);
 564         }
 565 
 566         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 567                 werr = NetUserDel_l(ctx, &r);
 568         } else {
 569                 werr = NetUserDel_r(ctx, &r);
 570         }
 571 
 572         r.out.result = W_ERROR_V(werr);
 573 
 574         if (DEBUGLEVEL >= 10) {
 575                 NDR_PRINT_OUT_DEBUG(NetUserDel, &r);
 576         }
 577 
 578         return r.out.result;
 579 }
 580 
 581 /****************************************************************
 582  NetUserEnum
 583 ****************************************************************/
 584 
 585 NET_API_STATUS NetUserEnum(const char * server_name /* [in] [unique] */,
     /* [<][>][^][v][top][bottom][index][help] */
 586                            uint32_t level /* [in] */,
 587                            uint32_t filter /* [in] */,
 588                            uint8_t **buffer /* [out] [ref] */,
 589                            uint32_t prefmaxlen /* [in] */,
 590                            uint32_t *entries_read /* [out] [ref] */,
 591                            uint32_t *total_entries /* [out] [ref] */,
 592                            uint32_t *resume_handle /* [in,out] [ref] */)
 593 {
 594         struct NetUserEnum r;
 595         struct libnetapi_ctx *ctx = NULL;
 596         NET_API_STATUS status;
 597         WERROR werr;
 598 
 599         status = libnetapi_getctx(&ctx);
 600         if (status != 0) {
 601                 return status;
 602         }
 603 
 604         /* In parameters */
 605         r.in.server_name = server_name;
 606         r.in.level = level;
 607         r.in.filter = filter;
 608         r.in.prefmaxlen = prefmaxlen;
 609         r.in.resume_handle = resume_handle;
 610 
 611         /* Out parameters */
 612         r.out.buffer = buffer;
 613         r.out.entries_read = entries_read;
 614         r.out.total_entries = total_entries;
 615         r.out.resume_handle = resume_handle;
 616 
 617         if (DEBUGLEVEL >= 10) {
 618                 NDR_PRINT_IN_DEBUG(NetUserEnum, &r);
 619         }
 620 
 621         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 622                 werr = NetUserEnum_l(ctx, &r);
 623         } else {
 624                 werr = NetUserEnum_r(ctx, &r);
 625         }
 626 
 627         r.out.result = W_ERROR_V(werr);
 628 
 629         if (DEBUGLEVEL >= 10) {
 630                 NDR_PRINT_OUT_DEBUG(NetUserEnum, &r);
 631         }
 632 
 633         return r.out.result;
 634 }
 635 
 636 /****************************************************************
 637  NetUserChangePassword
 638 ****************************************************************/
 639 
 640 NET_API_STATUS NetUserChangePassword(const char * domain_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
 641                                      const char * user_name /* [in] */,
 642                                      const char * old_password /* [in] */,
 643                                      const char * new_password /* [in] */)
 644 {
 645         struct NetUserChangePassword r;
 646         struct libnetapi_ctx *ctx = NULL;
 647         NET_API_STATUS status;
 648         WERROR werr;
 649 
 650         status = libnetapi_getctx(&ctx);
 651         if (status != 0) {
 652                 return status;
 653         }
 654 
 655         /* In parameters */
 656         r.in.domain_name = domain_name;
 657         r.in.user_name = user_name;
 658         r.in.old_password = old_password;
 659         r.in.new_password = new_password;
 660 
 661         /* Out parameters */
 662 
 663         if (DEBUGLEVEL >= 10) {
 664                 NDR_PRINT_IN_DEBUG(NetUserChangePassword, &r);
 665         }
 666 
 667         if (LIBNETAPI_LOCAL_SERVER(domain_name)) {
 668                 werr = NetUserChangePassword_l(ctx, &r);
 669         } else {
 670                 werr = NetUserChangePassword_r(ctx, &r);
 671         }
 672 
 673         r.out.result = W_ERROR_V(werr);
 674 
 675         if (DEBUGLEVEL >= 10) {
 676                 NDR_PRINT_OUT_DEBUG(NetUserChangePassword, &r);
 677         }
 678 
 679         return r.out.result;
 680 }
 681 
 682 /****************************************************************
 683  NetUserGetInfo
 684 ****************************************************************/
 685 
 686 NET_API_STATUS NetUserGetInfo(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
 687                               const char * user_name /* [in] */,
 688                               uint32_t level /* [in] */,
 689                               uint8_t **buffer /* [out] [ref] */)
 690 {
 691         struct NetUserGetInfo r;
 692         struct libnetapi_ctx *ctx = NULL;
 693         NET_API_STATUS status;
 694         WERROR werr;
 695 
 696         status = libnetapi_getctx(&ctx);
 697         if (status != 0) {
 698                 return status;
 699         }
 700 
 701         /* In parameters */
 702         r.in.server_name = server_name;
 703         r.in.user_name = user_name;
 704         r.in.level = level;
 705 
 706         /* Out parameters */
 707         r.out.buffer = buffer;
 708 
 709         if (DEBUGLEVEL >= 10) {
 710                 NDR_PRINT_IN_DEBUG(NetUserGetInfo, &r);
 711         }
 712 
 713         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 714                 werr = NetUserGetInfo_l(ctx, &r);
 715         } else {
 716                 werr = NetUserGetInfo_r(ctx, &r);
 717         }
 718 
 719         r.out.result = W_ERROR_V(werr);
 720 
 721         if (DEBUGLEVEL >= 10) {
 722                 NDR_PRINT_OUT_DEBUG(NetUserGetInfo, &r);
 723         }
 724 
 725         return r.out.result;
 726 }
 727 
 728 /****************************************************************
 729  NetUserSetInfo
 730 ****************************************************************/
 731 
 732 NET_API_STATUS NetUserSetInfo(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
 733                               const char * user_name /* [in] */,
 734                               uint32_t level /* [in] */,
 735                               uint8_t *buffer /* [in] [ref] */,
 736                               uint32_t *parm_err /* [out] [ref] */)
 737 {
 738         struct NetUserSetInfo r;
 739         struct libnetapi_ctx *ctx = NULL;
 740         NET_API_STATUS status;
 741         WERROR werr;
 742 
 743         status = libnetapi_getctx(&ctx);
 744         if (status != 0) {
 745                 return status;
 746         }
 747 
 748         /* In parameters */
 749         r.in.server_name = server_name;
 750         r.in.user_name = user_name;
 751         r.in.level = level;
 752         r.in.buffer = buffer;
 753 
 754         /* Out parameters */
 755         r.out.parm_err = parm_err;
 756 
 757         if (DEBUGLEVEL >= 10) {
 758                 NDR_PRINT_IN_DEBUG(NetUserSetInfo, &r);
 759         }
 760 
 761         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 762                 werr = NetUserSetInfo_l(ctx, &r);
 763         } else {
 764                 werr = NetUserSetInfo_r(ctx, &r);
 765         }
 766 
 767         r.out.result = W_ERROR_V(werr);
 768 
 769         if (DEBUGLEVEL >= 10) {
 770                 NDR_PRINT_OUT_DEBUG(NetUserSetInfo, &r);
 771         }
 772 
 773         return r.out.result;
 774 }
 775 
 776 /****************************************************************
 777  NetUserGetGroups
 778 ****************************************************************/
 779 
 780 NET_API_STATUS NetUserGetGroups(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
 781                                 const char * user_name /* [in] */,
 782                                 uint32_t level /* [in] */,
 783                                 uint8_t **buffer /* [out] [ref] */,
 784                                 uint32_t prefmaxlen /* [in] */,
 785                                 uint32_t *entries_read /* [out] [ref] */,
 786                                 uint32_t *total_entries /* [out] [ref] */)
 787 {
 788         struct NetUserGetGroups r;
 789         struct libnetapi_ctx *ctx = NULL;
 790         NET_API_STATUS status;
 791         WERROR werr;
 792 
 793         status = libnetapi_getctx(&ctx);
 794         if (status != 0) {
 795                 return status;
 796         }
 797 
 798         /* In parameters */
 799         r.in.server_name = server_name;
 800         r.in.user_name = user_name;
 801         r.in.level = level;
 802         r.in.prefmaxlen = prefmaxlen;
 803 
 804         /* Out parameters */
 805         r.out.buffer = buffer;
 806         r.out.entries_read = entries_read;
 807         r.out.total_entries = total_entries;
 808 
 809         if (DEBUGLEVEL >= 10) {
 810                 NDR_PRINT_IN_DEBUG(NetUserGetGroups, &r);
 811         }
 812 
 813         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 814                 werr = NetUserGetGroups_l(ctx, &r);
 815         } else {
 816                 werr = NetUserGetGroups_r(ctx, &r);
 817         }
 818 
 819         r.out.result = W_ERROR_V(werr);
 820 
 821         if (DEBUGLEVEL >= 10) {
 822                 NDR_PRINT_OUT_DEBUG(NetUserGetGroups, &r);
 823         }
 824 
 825         return r.out.result;
 826 }
 827 
 828 /****************************************************************
 829  NetUserSetGroups
 830 ****************************************************************/
 831 
 832 NET_API_STATUS NetUserSetGroups(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
 833                                 const char * user_name /* [in] */,
 834                                 uint32_t level /* [in] */,
 835                                 uint8_t *buffer /* [in] [ref] */,
 836                                 uint32_t num_entries /* [in] */)
 837 {
 838         struct NetUserSetGroups r;
 839         struct libnetapi_ctx *ctx = NULL;
 840         NET_API_STATUS status;
 841         WERROR werr;
 842 
 843         status = libnetapi_getctx(&ctx);
 844         if (status != 0) {
 845                 return status;
 846         }
 847 
 848         /* In parameters */
 849         r.in.server_name = server_name;
 850         r.in.user_name = user_name;
 851         r.in.level = level;
 852         r.in.buffer = buffer;
 853         r.in.num_entries = num_entries;
 854 
 855         /* Out parameters */
 856 
 857         if (DEBUGLEVEL >= 10) {
 858                 NDR_PRINT_IN_DEBUG(NetUserSetGroups, &r);
 859         }
 860 
 861         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 862                 werr = NetUserSetGroups_l(ctx, &r);
 863         } else {
 864                 werr = NetUserSetGroups_r(ctx, &r);
 865         }
 866 
 867         r.out.result = W_ERROR_V(werr);
 868 
 869         if (DEBUGLEVEL >= 10) {
 870                 NDR_PRINT_OUT_DEBUG(NetUserSetGroups, &r);
 871         }
 872 
 873         return r.out.result;
 874 }
 875 
 876 /****************************************************************
 877  NetUserGetLocalGroups
 878 ****************************************************************/
 879 
 880 NET_API_STATUS NetUserGetLocalGroups(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
 881                                      const char * user_name /* [in] */,
 882                                      uint32_t level /* [in] */,
 883                                      uint32_t flags /* [in] */,
 884                                      uint8_t **buffer /* [out] [ref] */,
 885                                      uint32_t prefmaxlen /* [in] */,
 886                                      uint32_t *entries_read /* [out] [ref] */,
 887                                      uint32_t *total_entries /* [out] [ref] */)
 888 {
 889         struct NetUserGetLocalGroups r;
 890         struct libnetapi_ctx *ctx = NULL;
 891         NET_API_STATUS status;
 892         WERROR werr;
 893 
 894         status = libnetapi_getctx(&ctx);
 895         if (status != 0) {
 896                 return status;
 897         }
 898 
 899         /* In parameters */
 900         r.in.server_name = server_name;
 901         r.in.user_name = user_name;
 902         r.in.level = level;
 903         r.in.flags = flags;
 904         r.in.prefmaxlen = prefmaxlen;
 905 
 906         /* Out parameters */
 907         r.out.buffer = buffer;
 908         r.out.entries_read = entries_read;
 909         r.out.total_entries = total_entries;
 910 
 911         if (DEBUGLEVEL >= 10) {
 912                 NDR_PRINT_IN_DEBUG(NetUserGetLocalGroups, &r);
 913         }
 914 
 915         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 916                 werr = NetUserGetLocalGroups_l(ctx, &r);
 917         } else {
 918                 werr = NetUserGetLocalGroups_r(ctx, &r);
 919         }
 920 
 921         r.out.result = W_ERROR_V(werr);
 922 
 923         if (DEBUGLEVEL >= 10) {
 924                 NDR_PRINT_OUT_DEBUG(NetUserGetLocalGroups, &r);
 925         }
 926 
 927         return r.out.result;
 928 }
 929 
 930 /****************************************************************
 931  NetUserModalsGet
 932 ****************************************************************/
 933 
 934 NET_API_STATUS NetUserModalsGet(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
 935                                 uint32_t level /* [in] */,
 936                                 uint8_t **buffer /* [out] [ref] */)
 937 {
 938         struct NetUserModalsGet r;
 939         struct libnetapi_ctx *ctx = NULL;
 940         NET_API_STATUS status;
 941         WERROR werr;
 942 
 943         status = libnetapi_getctx(&ctx);
 944         if (status != 0) {
 945                 return status;
 946         }
 947 
 948         /* In parameters */
 949         r.in.server_name = server_name;
 950         r.in.level = level;
 951 
 952         /* Out parameters */
 953         r.out.buffer = buffer;
 954 
 955         if (DEBUGLEVEL >= 10) {
 956                 NDR_PRINT_IN_DEBUG(NetUserModalsGet, &r);
 957         }
 958 
 959         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
 960                 werr = NetUserModalsGet_l(ctx, &r);
 961         } else {
 962                 werr = NetUserModalsGet_r(ctx, &r);
 963         }
 964 
 965         r.out.result = W_ERROR_V(werr);
 966 
 967         if (DEBUGLEVEL >= 10) {
 968                 NDR_PRINT_OUT_DEBUG(NetUserModalsGet, &r);
 969         }
 970 
 971         return r.out.result;
 972 }
 973 
 974 /****************************************************************
 975  NetUserModalsSet
 976 ****************************************************************/
 977 
 978 NET_API_STATUS NetUserModalsSet(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
 979                                 uint32_t level /* [in] */,
 980                                 uint8_t *buffer /* [in] [ref] */,
 981                                 uint32_t *parm_err /* [out] [ref] */)
 982 {
 983         struct NetUserModalsSet r;
 984         struct libnetapi_ctx *ctx = NULL;
 985         NET_API_STATUS status;
 986         WERROR werr;
 987 
 988         status = libnetapi_getctx(&ctx);
 989         if (status != 0) {
 990                 return status;
 991         }
 992 
 993         /* In parameters */
 994         r.in.server_name = server_name;
 995         r.in.level = level;
 996         r.in.buffer = buffer;
 997 
 998         /* Out parameters */
 999         r.out.parm_err = parm_err;
1000 
1001         if (DEBUGLEVEL >= 10) {
1002                 NDR_PRINT_IN_DEBUG(NetUserModalsSet, &r);
1003         }
1004 
1005         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1006                 werr = NetUserModalsSet_l(ctx, &r);
1007         } else {
1008                 werr = NetUserModalsSet_r(ctx, &r);
1009         }
1010 
1011         r.out.result = W_ERROR_V(werr);
1012 
1013         if (DEBUGLEVEL >= 10) {
1014                 NDR_PRINT_OUT_DEBUG(NetUserModalsSet, &r);
1015         }
1016 
1017         return r.out.result;
1018 }
1019 
1020 /****************************************************************
1021  NetQueryDisplayInformation
1022 ****************************************************************/
1023 
1024 NET_API_STATUS NetQueryDisplayInformation(const char * server_name /* [in] [unique] */,
     /* [<][>][^][v][top][bottom][index][help] */
1025                                           uint32_t level /* [in] */,
1026                                           uint32_t idx /* [in] */,
1027                                           uint32_t entries_requested /* [in] */,
1028                                           uint32_t prefmaxlen /* [in] */,
1029                                           uint32_t *entries_read /* [out] [ref] */,
1030                                           void **buffer /* [out] [noprint,ref] */)
1031 {
1032         struct NetQueryDisplayInformation r;
1033         struct libnetapi_ctx *ctx = NULL;
1034         NET_API_STATUS status;
1035         WERROR werr;
1036 
1037         status = libnetapi_getctx(&ctx);
1038         if (status != 0) {
1039                 return status;
1040         }
1041 
1042         /* In parameters */
1043         r.in.server_name = server_name;
1044         r.in.level = level;
1045         r.in.idx = idx;
1046         r.in.entries_requested = entries_requested;
1047         r.in.prefmaxlen = prefmaxlen;
1048 
1049         /* Out parameters */
1050         r.out.entries_read = entries_read;
1051         r.out.buffer = buffer;
1052 
1053         if (DEBUGLEVEL >= 10) {
1054                 NDR_PRINT_IN_DEBUG(NetQueryDisplayInformation, &r);
1055         }
1056 
1057         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1058                 werr = NetQueryDisplayInformation_l(ctx, &r);
1059         } else {
1060                 werr = NetQueryDisplayInformation_r(ctx, &r);
1061         }
1062 
1063         r.out.result = W_ERROR_V(werr);
1064 
1065         if (DEBUGLEVEL >= 10) {
1066                 NDR_PRINT_OUT_DEBUG(NetQueryDisplayInformation, &r);
1067         }
1068 
1069         return r.out.result;
1070 }
1071 
1072 /****************************************************************
1073  NetGroupAdd
1074 ****************************************************************/
1075 
1076 NET_API_STATUS NetGroupAdd(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
1077                            uint32_t level /* [in] */,
1078                            uint8_t *buffer /* [in] [ref] */,
1079                            uint32_t *parm_err /* [out] [ref] */)
1080 {
1081         struct NetGroupAdd r;
1082         struct libnetapi_ctx *ctx = NULL;
1083         NET_API_STATUS status;
1084         WERROR werr;
1085 
1086         status = libnetapi_getctx(&ctx);
1087         if (status != 0) {
1088                 return status;
1089         }
1090 
1091         /* In parameters */
1092         r.in.server_name = server_name;
1093         r.in.level = level;
1094         r.in.buffer = buffer;
1095 
1096         /* Out parameters */
1097         r.out.parm_err = parm_err;
1098 
1099         if (DEBUGLEVEL >= 10) {
1100                 NDR_PRINT_IN_DEBUG(NetGroupAdd, &r);
1101         }
1102 
1103         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1104                 werr = NetGroupAdd_l(ctx, &r);
1105         } else {
1106                 werr = NetGroupAdd_r(ctx, &r);
1107         }
1108 
1109         r.out.result = W_ERROR_V(werr);
1110 
1111         if (DEBUGLEVEL >= 10) {
1112                 NDR_PRINT_OUT_DEBUG(NetGroupAdd, &r);
1113         }
1114 
1115         return r.out.result;
1116 }
1117 
1118 /****************************************************************
1119  NetGroupDel
1120 ****************************************************************/
1121 
1122 NET_API_STATUS NetGroupDel(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
1123                            const char * group_name /* [in] */)
1124 {
1125         struct NetGroupDel r;
1126         struct libnetapi_ctx *ctx = NULL;
1127         NET_API_STATUS status;
1128         WERROR werr;
1129 
1130         status = libnetapi_getctx(&ctx);
1131         if (status != 0) {
1132                 return status;
1133         }
1134 
1135         /* In parameters */
1136         r.in.server_name = server_name;
1137         r.in.group_name = group_name;
1138 
1139         /* Out parameters */
1140 
1141         if (DEBUGLEVEL >= 10) {
1142                 NDR_PRINT_IN_DEBUG(NetGroupDel, &r);
1143         }
1144 
1145         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1146                 werr = NetGroupDel_l(ctx, &r);
1147         } else {
1148                 werr = NetGroupDel_r(ctx, &r);
1149         }
1150 
1151         r.out.result = W_ERROR_V(werr);
1152 
1153         if (DEBUGLEVEL >= 10) {
1154                 NDR_PRINT_OUT_DEBUG(NetGroupDel, &r);
1155         }
1156 
1157         return r.out.result;
1158 }
1159 
1160 /****************************************************************
1161  NetGroupEnum
1162 ****************************************************************/
1163 
1164 NET_API_STATUS NetGroupEnum(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
1165                             uint32_t level /* [in] */,
1166                             uint8_t **buffer /* [out] [ref] */,
1167                             uint32_t prefmaxlen /* [in] */,
1168                             uint32_t *entries_read /* [out] [ref] */,
1169                             uint32_t *total_entries /* [out] [ref] */,
1170                             uint32_t *resume_handle /* [in,out] [ref] */)
1171 {
1172         struct NetGroupEnum r;
1173         struct libnetapi_ctx *ctx = NULL;
1174         NET_API_STATUS status;
1175         WERROR werr;
1176 
1177         status = libnetapi_getctx(&ctx);
1178         if (status != 0) {
1179                 return status;
1180         }
1181 
1182         /* In parameters */
1183         r.in.server_name = server_name;
1184         r.in.level = level;
1185         r.in.prefmaxlen = prefmaxlen;
1186         r.in.resume_handle = resume_handle;
1187 
1188         /* Out parameters */
1189         r.out.buffer = buffer;
1190         r.out.entries_read = entries_read;
1191         r.out.total_entries = total_entries;
1192         r.out.resume_handle = resume_handle;
1193 
1194         if (DEBUGLEVEL >= 10) {
1195                 NDR_PRINT_IN_DEBUG(NetGroupEnum, &r);
1196         }
1197 
1198         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1199                 werr = NetGroupEnum_l(ctx, &r);
1200         } else {
1201                 werr = NetGroupEnum_r(ctx, &r);
1202         }
1203 
1204         r.out.result = W_ERROR_V(werr);
1205 
1206         if (DEBUGLEVEL >= 10) {
1207                 NDR_PRINT_OUT_DEBUG(NetGroupEnum, &r);
1208         }
1209 
1210         return r.out.result;
1211 }
1212 
1213 /****************************************************************
1214  NetGroupSetInfo
1215 ****************************************************************/
1216 
1217 NET_API_STATUS NetGroupSetInfo(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
1218                                const char * group_name /* [in] */,
1219                                uint32_t level /* [in] */,
1220                                uint8_t *buffer /* [in] [ref] */,
1221                                uint32_t *parm_err /* [out] [ref] */)
1222 {
1223         struct NetGroupSetInfo r;
1224         struct libnetapi_ctx *ctx = NULL;
1225         NET_API_STATUS status;
1226         WERROR werr;
1227 
1228         status = libnetapi_getctx(&ctx);
1229         if (status != 0) {
1230                 return status;
1231         }
1232 
1233         /* In parameters */
1234         r.in.server_name = server_name;
1235         r.in.group_name = group_name;
1236         r.in.level = level;
1237         r.in.buffer = buffer;
1238 
1239         /* Out parameters */
1240         r.out.parm_err = parm_err;
1241 
1242         if (DEBUGLEVEL >= 10) {
1243                 NDR_PRINT_IN_DEBUG(NetGroupSetInfo, &r);
1244         }
1245 
1246         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1247                 werr = NetGroupSetInfo_l(ctx, &r);
1248         } else {
1249                 werr = NetGroupSetInfo_r(ctx, &r);
1250         }
1251 
1252         r.out.result = W_ERROR_V(werr);
1253 
1254         if (DEBUGLEVEL >= 10) {
1255                 NDR_PRINT_OUT_DEBUG(NetGroupSetInfo, &r);
1256         }
1257 
1258         return r.out.result;
1259 }
1260 
1261 /****************************************************************
1262  NetGroupGetInfo
1263 ****************************************************************/
1264 
1265 NET_API_STATUS NetGroupGetInfo(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
1266                                const char * group_name /* [in] */,
1267                                uint32_t level /* [in] */,
1268                                uint8_t **buffer /* [out] [ref] */)
1269 {
1270         struct NetGroupGetInfo r;
1271         struct libnetapi_ctx *ctx = NULL;
1272         NET_API_STATUS status;
1273         WERROR werr;
1274 
1275         status = libnetapi_getctx(&ctx);
1276         if (status != 0) {
1277                 return status;
1278         }
1279 
1280         /* In parameters */
1281         r.in.server_name = server_name;
1282         r.in.group_name = group_name;
1283         r.in.level = level;
1284 
1285         /* Out parameters */
1286         r.out.buffer = buffer;
1287 
1288         if (DEBUGLEVEL >= 10) {
1289                 NDR_PRINT_IN_DEBUG(NetGroupGetInfo, &r);
1290         }
1291 
1292         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1293                 werr = NetGroupGetInfo_l(ctx, &r);
1294         } else {
1295                 werr = NetGroupGetInfo_r(ctx, &r);
1296         }
1297 
1298         r.out.result = W_ERROR_V(werr);
1299 
1300         if (DEBUGLEVEL >= 10) {
1301                 NDR_PRINT_OUT_DEBUG(NetGroupGetInfo, &r);
1302         }
1303 
1304         return r.out.result;
1305 }
1306 
1307 /****************************************************************
1308  NetGroupAddUser
1309 ****************************************************************/
1310 
1311 NET_API_STATUS NetGroupAddUser(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
1312                                const char * group_name /* [in] */,
1313                                const char * user_name /* [in] */)
1314 {
1315         struct NetGroupAddUser r;
1316         struct libnetapi_ctx *ctx = NULL;
1317         NET_API_STATUS status;
1318         WERROR werr;
1319 
1320         status = libnetapi_getctx(&ctx);
1321         if (status != 0) {
1322                 return status;
1323         }
1324 
1325         /* In parameters */
1326         r.in.server_name = server_name;
1327         r.in.group_name = group_name;
1328         r.in.user_name = user_name;
1329 
1330         /* Out parameters */
1331 
1332         if (DEBUGLEVEL >= 10) {
1333                 NDR_PRINT_IN_DEBUG(NetGroupAddUser, &r);
1334         }
1335 
1336         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1337                 werr = NetGroupAddUser_l(ctx, &r);
1338         } else {
1339                 werr = NetGroupAddUser_r(ctx, &r);
1340         }
1341 
1342         r.out.result = W_ERROR_V(werr);
1343 
1344         if (DEBUGLEVEL >= 10) {
1345                 NDR_PRINT_OUT_DEBUG(NetGroupAddUser, &r);
1346         }
1347 
1348         return r.out.result;
1349 }
1350 
1351 /****************************************************************
1352  NetGroupDelUser
1353 ****************************************************************/
1354 
1355 NET_API_STATUS NetGroupDelUser(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
1356                                const char * group_name /* [in] */,
1357                                const char * user_name /* [in] */)
1358 {
1359         struct NetGroupDelUser r;
1360         struct libnetapi_ctx *ctx = NULL;
1361         NET_API_STATUS status;
1362         WERROR werr;
1363 
1364         status = libnetapi_getctx(&ctx);
1365         if (status != 0) {
1366                 return status;
1367         }
1368 
1369         /* In parameters */
1370         r.in.server_name = server_name;
1371         r.in.group_name = group_name;
1372         r.in.user_name = user_name;
1373 
1374         /* Out parameters */
1375 
1376         if (DEBUGLEVEL >= 10) {
1377                 NDR_PRINT_IN_DEBUG(NetGroupDelUser, &r);
1378         }
1379 
1380         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1381                 werr = NetGroupDelUser_l(ctx, &r);
1382         } else {
1383                 werr = NetGroupDelUser_r(ctx, &r);
1384         }
1385 
1386         r.out.result = W_ERROR_V(werr);
1387 
1388         if (DEBUGLEVEL >= 10) {
1389                 NDR_PRINT_OUT_DEBUG(NetGroupDelUser, &r);
1390         }
1391 
1392         return r.out.result;
1393 }
1394 
1395 /****************************************************************
1396  NetGroupGetUsers
1397 ****************************************************************/
1398 
1399 NET_API_STATUS NetGroupGetUsers(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
1400                                 const char * group_name /* [in] */,
1401                                 uint32_t level /* [in] */,
1402                                 uint8_t **buffer /* [out] [ref] */,
1403                                 uint32_t prefmaxlen /* [in] */,
1404                                 uint32_t *entries_read /* [out] [ref] */,
1405                                 uint32_t *total_entries /* [out] [ref] */,
1406                                 uint32_t *resume_handle /* [in,out] [ref] */)
1407 {
1408         struct NetGroupGetUsers r;
1409         struct libnetapi_ctx *ctx = NULL;
1410         NET_API_STATUS status;
1411         WERROR werr;
1412 
1413         status = libnetapi_getctx(&ctx);
1414         if (status != 0) {
1415                 return status;
1416         }
1417 
1418         /* In parameters */
1419         r.in.server_name = server_name;
1420         r.in.group_name = group_name;
1421         r.in.level = level;
1422         r.in.prefmaxlen = prefmaxlen;
1423         r.in.resume_handle = resume_handle;
1424 
1425         /* Out parameters */
1426         r.out.buffer = buffer;
1427         r.out.entries_read = entries_read;
1428         r.out.total_entries = total_entries;
1429         r.out.resume_handle = resume_handle;
1430 
1431         if (DEBUGLEVEL >= 10) {
1432                 NDR_PRINT_IN_DEBUG(NetGroupGetUsers, &r);
1433         }
1434 
1435         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1436                 werr = NetGroupGetUsers_l(ctx, &r);
1437         } else {
1438                 werr = NetGroupGetUsers_r(ctx, &r);
1439         }
1440 
1441         r.out.result = W_ERROR_V(werr);
1442 
1443         if (DEBUGLEVEL >= 10) {
1444                 NDR_PRINT_OUT_DEBUG(NetGroupGetUsers, &r);
1445         }
1446 
1447         return r.out.result;
1448 }
1449 
1450 /****************************************************************
1451  NetGroupSetUsers
1452 ****************************************************************/
1453 
1454 NET_API_STATUS NetGroupSetUsers(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
1455                                 const char * group_name /* [in] */,
1456                                 uint32_t level /* [in] */,
1457                                 uint8_t *buffer /* [in] [ref] */,
1458                                 uint32_t num_entries /* [in] */)
1459 {
1460         struct NetGroupSetUsers r;
1461         struct libnetapi_ctx *ctx = NULL;
1462         NET_API_STATUS status;
1463         WERROR werr;
1464 
1465         status = libnetapi_getctx(&ctx);
1466         if (status != 0) {
1467                 return status;
1468         }
1469 
1470         /* In parameters */
1471         r.in.server_name = server_name;
1472         r.in.group_name = group_name;
1473         r.in.level = level;
1474         r.in.buffer = buffer;
1475         r.in.num_entries = num_entries;
1476 
1477         /* Out parameters */
1478 
1479         if (DEBUGLEVEL >= 10) {
1480                 NDR_PRINT_IN_DEBUG(NetGroupSetUsers, &r);
1481         }
1482 
1483         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1484                 werr = NetGroupSetUsers_l(ctx, &r);
1485         } else {
1486                 werr = NetGroupSetUsers_r(ctx, &r);
1487         }
1488 
1489         r.out.result = W_ERROR_V(werr);
1490 
1491         if (DEBUGLEVEL >= 10) {
1492                 NDR_PRINT_OUT_DEBUG(NetGroupSetUsers, &r);
1493         }
1494 
1495         return r.out.result;
1496 }
1497 
1498 /****************************************************************
1499  NetLocalGroupAdd
1500 ****************************************************************/
1501 
1502 NET_API_STATUS NetLocalGroupAdd(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
1503                                 uint32_t level /* [in] */,
1504                                 uint8_t *buffer /* [in] [ref] */,
1505                                 uint32_t *parm_err /* [out] [ref] */)
1506 {
1507         struct NetLocalGroupAdd r;
1508         struct libnetapi_ctx *ctx = NULL;
1509         NET_API_STATUS status;
1510         WERROR werr;
1511 
1512         status = libnetapi_getctx(&ctx);
1513         if (status != 0) {
1514                 return status;
1515         }
1516 
1517         /* In parameters */
1518         r.in.server_name = server_name;
1519         r.in.level = level;
1520         r.in.buffer = buffer;
1521 
1522         /* Out parameters */
1523         r.out.parm_err = parm_err;
1524 
1525         if (DEBUGLEVEL >= 10) {
1526                 NDR_PRINT_IN_DEBUG(NetLocalGroupAdd, &r);
1527         }
1528 
1529         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1530                 werr = NetLocalGroupAdd_l(ctx, &r);
1531         } else {
1532                 werr = NetLocalGroupAdd_r(ctx, &r);
1533         }
1534 
1535         r.out.result = W_ERROR_V(werr);
1536 
1537         if (DEBUGLEVEL >= 10) {
1538                 NDR_PRINT_OUT_DEBUG(NetLocalGroupAdd, &r);
1539         }
1540 
1541         return r.out.result;
1542 }
1543 
1544 /****************************************************************
1545  NetLocalGroupDel
1546 ****************************************************************/
1547 
1548 NET_API_STATUS NetLocalGroupDel(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
1549                                 const char * group_name /* [in] */)
1550 {
1551         struct NetLocalGroupDel r;
1552         struct libnetapi_ctx *ctx = NULL;
1553         NET_API_STATUS status;
1554         WERROR werr;
1555 
1556         status = libnetapi_getctx(&ctx);
1557         if (status != 0) {
1558                 return status;
1559         }
1560 
1561         /* In parameters */
1562         r.in.server_name = server_name;
1563         r.in.group_name = group_name;
1564 
1565         /* Out parameters */
1566 
1567         if (DEBUGLEVEL >= 10) {
1568                 NDR_PRINT_IN_DEBUG(NetLocalGroupDel, &r);
1569         }
1570 
1571         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1572                 werr = NetLocalGroupDel_l(ctx, &r);
1573         } else {
1574                 werr = NetLocalGroupDel_r(ctx, &r);
1575         }
1576 
1577         r.out.result = W_ERROR_V(werr);
1578 
1579         if (DEBUGLEVEL >= 10) {
1580                 NDR_PRINT_OUT_DEBUG(NetLocalGroupDel, &r);
1581         }
1582 
1583         return r.out.result;
1584 }
1585 
1586 /****************************************************************
1587  NetLocalGroupGetInfo
1588 ****************************************************************/
1589 
1590 NET_API_STATUS NetLocalGroupGetInfo(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
1591                                     const char * group_name /* [in] */,
1592                                     uint32_t level /* [in] */,
1593                                     uint8_t **buffer /* [out] [ref] */)
1594 {
1595         struct NetLocalGroupGetInfo r;
1596         struct libnetapi_ctx *ctx = NULL;
1597         NET_API_STATUS status;
1598         WERROR werr;
1599 
1600         status = libnetapi_getctx(&ctx);
1601         if (status != 0) {
1602                 return status;
1603         }
1604 
1605         /* In parameters */
1606         r.in.server_name = server_name;
1607         r.in.group_name = group_name;
1608         r.in.level = level;
1609 
1610         /* Out parameters */
1611         r.out.buffer = buffer;
1612 
1613         if (DEBUGLEVEL >= 10) {
1614                 NDR_PRINT_IN_DEBUG(NetLocalGroupGetInfo, &r);
1615         }
1616 
1617         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1618                 werr = NetLocalGroupGetInfo_l(ctx, &r);
1619         } else {
1620                 werr = NetLocalGroupGetInfo_r(ctx, &r);
1621         }
1622 
1623         r.out.result = W_ERROR_V(werr);
1624 
1625         if (DEBUGLEVEL >= 10) {
1626                 NDR_PRINT_OUT_DEBUG(NetLocalGroupGetInfo, &r);
1627         }
1628 
1629         return r.out.result;
1630 }
1631 
1632 /****************************************************************
1633  NetLocalGroupSetInfo
1634 ****************************************************************/
1635 
1636 NET_API_STATUS NetLocalGroupSetInfo(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
1637                                     const char * group_name /* [in] */,
1638                                     uint32_t level /* [in] */,
1639                                     uint8_t *buffer /* [in] [ref] */,
1640                                     uint32_t *parm_err /* [out] [ref] */)
1641 {
1642         struct NetLocalGroupSetInfo r;
1643         struct libnetapi_ctx *ctx = NULL;
1644         NET_API_STATUS status;
1645         WERROR werr;
1646 
1647         status = libnetapi_getctx(&ctx);
1648         if (status != 0) {
1649                 return status;
1650         }
1651 
1652         /* In parameters */
1653         r.in.server_name = server_name;
1654         r.in.group_name = group_name;
1655         r.in.level = level;
1656         r.in.buffer = buffer;
1657 
1658         /* Out parameters */
1659         r.out.parm_err = parm_err;
1660 
1661         if (DEBUGLEVEL >= 10) {
1662                 NDR_PRINT_IN_DEBUG(NetLocalGroupSetInfo, &r);
1663         }
1664 
1665         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1666                 werr = NetLocalGroupSetInfo_l(ctx, &r);
1667         } else {
1668                 werr = NetLocalGroupSetInfo_r(ctx, &r);
1669         }
1670 
1671         r.out.result = W_ERROR_V(werr);
1672 
1673         if (DEBUGLEVEL >= 10) {
1674                 NDR_PRINT_OUT_DEBUG(NetLocalGroupSetInfo, &r);
1675         }
1676 
1677         return r.out.result;
1678 }
1679 
1680 /****************************************************************
1681  NetLocalGroupEnum
1682 ****************************************************************/
1683 
1684 NET_API_STATUS NetLocalGroupEnum(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
1685                                  uint32_t level /* [in] */,
1686                                  uint8_t **buffer /* [out] [ref] */,
1687                                  uint32_t prefmaxlen /* [in] */,
1688                                  uint32_t *entries_read /* [out] [ref] */,
1689                                  uint32_t *total_entries /* [out] [ref] */,
1690                                  uint32_t *resume_handle /* [in,out] [ref] */)
1691 {
1692         struct NetLocalGroupEnum r;
1693         struct libnetapi_ctx *ctx = NULL;
1694         NET_API_STATUS status;
1695         WERROR werr;
1696 
1697         status = libnetapi_getctx(&ctx);
1698         if (status != 0) {
1699                 return status;
1700         }
1701 
1702         /* In parameters */
1703         r.in.server_name = server_name;
1704         r.in.level = level;
1705         r.in.prefmaxlen = prefmaxlen;
1706         r.in.resume_handle = resume_handle;
1707 
1708         /* Out parameters */
1709         r.out.buffer = buffer;
1710         r.out.entries_read = entries_read;
1711         r.out.total_entries = total_entries;
1712         r.out.resume_handle = resume_handle;
1713 
1714         if (DEBUGLEVEL >= 10) {
1715                 NDR_PRINT_IN_DEBUG(NetLocalGroupEnum, &r);
1716         }
1717 
1718         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1719                 werr = NetLocalGroupEnum_l(ctx, &r);
1720         } else {
1721                 werr = NetLocalGroupEnum_r(ctx, &r);
1722         }
1723 
1724         r.out.result = W_ERROR_V(werr);
1725 
1726         if (DEBUGLEVEL >= 10) {
1727                 NDR_PRINT_OUT_DEBUG(NetLocalGroupEnum, &r);
1728         }
1729 
1730         return r.out.result;
1731 }
1732 
1733 /****************************************************************
1734  NetLocalGroupAddMembers
1735 ****************************************************************/
1736 
1737 NET_API_STATUS NetLocalGroupAddMembers(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
1738                                        const char * group_name /* [in] */,
1739                                        uint32_t level /* [in] */,
1740                                        uint8_t *buffer /* [in] [ref] */,
1741                                        uint32_t total_entries /* [in] */)
1742 {
1743         struct NetLocalGroupAddMembers r;
1744         struct libnetapi_ctx *ctx = NULL;
1745         NET_API_STATUS status;
1746         WERROR werr;
1747 
1748         status = libnetapi_getctx(&ctx);
1749         if (status != 0) {
1750                 return status;
1751         }
1752 
1753         /* In parameters */
1754         r.in.server_name = server_name;
1755         r.in.group_name = group_name;
1756         r.in.level = level;
1757         r.in.buffer = buffer;
1758         r.in.total_entries = total_entries;
1759 
1760         /* Out parameters */
1761 
1762         if (DEBUGLEVEL >= 10) {
1763                 NDR_PRINT_IN_DEBUG(NetLocalGroupAddMembers, &r);
1764         }
1765 
1766         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1767                 werr = NetLocalGroupAddMembers_l(ctx, &r);
1768         } else {
1769                 werr = NetLocalGroupAddMembers_r(ctx, &r);
1770         }
1771 
1772         r.out.result = W_ERROR_V(werr);
1773 
1774         if (DEBUGLEVEL >= 10) {
1775                 NDR_PRINT_OUT_DEBUG(NetLocalGroupAddMembers, &r);
1776         }
1777 
1778         return r.out.result;
1779 }
1780 
1781 /****************************************************************
1782  NetLocalGroupDelMembers
1783 ****************************************************************/
1784 
1785 NET_API_STATUS NetLocalGroupDelMembers(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
1786                                        const char * group_name /* [in] */,
1787                                        uint32_t level /* [in] */,
1788                                        uint8_t *buffer /* [in] [ref] */,
1789                                        uint32_t total_entries /* [in] */)
1790 {
1791         struct NetLocalGroupDelMembers r;
1792         struct libnetapi_ctx *ctx = NULL;
1793         NET_API_STATUS status;
1794         WERROR werr;
1795 
1796         status = libnetapi_getctx(&ctx);
1797         if (status != 0) {
1798                 return status;
1799         }
1800 
1801         /* In parameters */
1802         r.in.server_name = server_name;
1803         r.in.group_name = group_name;
1804         r.in.level = level;
1805         r.in.buffer = buffer;
1806         r.in.total_entries = total_entries;
1807 
1808         /* Out parameters */
1809 
1810         if (DEBUGLEVEL >= 10) {
1811                 NDR_PRINT_IN_DEBUG(NetLocalGroupDelMembers, &r);
1812         }
1813 
1814         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1815                 werr = NetLocalGroupDelMembers_l(ctx, &r);
1816         } else {
1817                 werr = NetLocalGroupDelMembers_r(ctx, &r);
1818         }
1819 
1820         r.out.result = W_ERROR_V(werr);
1821 
1822         if (DEBUGLEVEL >= 10) {
1823                 NDR_PRINT_OUT_DEBUG(NetLocalGroupDelMembers, &r);
1824         }
1825 
1826         return r.out.result;
1827 }
1828 
1829 /****************************************************************
1830  NetLocalGroupGetMembers
1831 ****************************************************************/
1832 
1833 NET_API_STATUS NetLocalGroupGetMembers(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
1834                                        const char * local_group_name /* [in] */,
1835                                        uint32_t level /* [in] */,
1836                                        uint8_t **buffer /* [out] [ref] */,
1837                                        uint32_t prefmaxlen /* [in] */,
1838                                        uint32_t *entries_read /* [out] [ref] */,
1839                                        uint32_t *total_entries /* [out] [ref] */,
1840                                        uint32_t *resume_handle /* [in,out] [ref] */)
1841 {
1842         struct NetLocalGroupGetMembers r;
1843         struct libnetapi_ctx *ctx = NULL;
1844         NET_API_STATUS status;
1845         WERROR werr;
1846 
1847         status = libnetapi_getctx(&ctx);
1848         if (status != 0) {
1849                 return status;
1850         }
1851 
1852         /* In parameters */
1853         r.in.server_name = server_name;
1854         r.in.local_group_name = local_group_name;
1855         r.in.level = level;
1856         r.in.prefmaxlen = prefmaxlen;
1857         r.in.resume_handle = resume_handle;
1858 
1859         /* Out parameters */
1860         r.out.buffer = buffer;
1861         r.out.entries_read = entries_read;
1862         r.out.total_entries = total_entries;
1863         r.out.resume_handle = resume_handle;
1864 
1865         if (DEBUGLEVEL >= 10) {
1866                 NDR_PRINT_IN_DEBUG(NetLocalGroupGetMembers, &r);
1867         }
1868 
1869         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1870                 werr = NetLocalGroupGetMembers_l(ctx, &r);
1871         } else {
1872                 werr = NetLocalGroupGetMembers_r(ctx, &r);
1873         }
1874 
1875         r.out.result = W_ERROR_V(werr);
1876 
1877         if (DEBUGLEVEL >= 10) {
1878                 NDR_PRINT_OUT_DEBUG(NetLocalGroupGetMembers, &r);
1879         }
1880 
1881         return r.out.result;
1882 }
1883 
1884 /****************************************************************
1885  NetLocalGroupSetMembers
1886 ****************************************************************/
1887 
1888 NET_API_STATUS NetLocalGroupSetMembers(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
1889                                        const char * group_name /* [in] */,
1890                                        uint32_t level /* [in] */,
1891                                        uint8_t *buffer /* [in] [ref] */,
1892                                        uint32_t total_entries /* [in] */)
1893 {
1894         struct NetLocalGroupSetMembers r;
1895         struct libnetapi_ctx *ctx = NULL;
1896         NET_API_STATUS status;
1897         WERROR werr;
1898 
1899         status = libnetapi_getctx(&ctx);
1900         if (status != 0) {
1901                 return status;
1902         }
1903 
1904         /* In parameters */
1905         r.in.server_name = server_name;
1906         r.in.group_name = group_name;
1907         r.in.level = level;
1908         r.in.buffer = buffer;
1909         r.in.total_entries = total_entries;
1910 
1911         /* Out parameters */
1912 
1913         if (DEBUGLEVEL >= 10) {
1914                 NDR_PRINT_IN_DEBUG(NetLocalGroupSetMembers, &r);
1915         }
1916 
1917         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1918                 werr = NetLocalGroupSetMembers_l(ctx, &r);
1919         } else {
1920                 werr = NetLocalGroupSetMembers_r(ctx, &r);
1921         }
1922 
1923         r.out.result = W_ERROR_V(werr);
1924 
1925         if (DEBUGLEVEL >= 10) {
1926                 NDR_PRINT_OUT_DEBUG(NetLocalGroupSetMembers, &r);
1927         }
1928 
1929         return r.out.result;
1930 }
1931 
1932 /****************************************************************
1933  NetRemoteTOD
1934 ****************************************************************/
1935 
1936 NET_API_STATUS NetRemoteTOD(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
1937                             uint8_t **buffer /* [out] [ref] */)
1938 {
1939         struct NetRemoteTOD r;
1940         struct libnetapi_ctx *ctx = NULL;
1941         NET_API_STATUS status;
1942         WERROR werr;
1943 
1944         status = libnetapi_getctx(&ctx);
1945         if (status != 0) {
1946                 return status;
1947         }
1948 
1949         /* In parameters */
1950         r.in.server_name = server_name;
1951 
1952         /* Out parameters */
1953         r.out.buffer = buffer;
1954 
1955         if (DEBUGLEVEL >= 10) {
1956                 NDR_PRINT_IN_DEBUG(NetRemoteTOD, &r);
1957         }
1958 
1959         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1960                 werr = NetRemoteTOD_l(ctx, &r);
1961         } else {
1962                 werr = NetRemoteTOD_r(ctx, &r);
1963         }
1964 
1965         r.out.result = W_ERROR_V(werr);
1966 
1967         if (DEBUGLEVEL >= 10) {
1968                 NDR_PRINT_OUT_DEBUG(NetRemoteTOD, &r);
1969         }
1970 
1971         return r.out.result;
1972 }
1973 
1974 /****************************************************************
1975  NetShareAdd
1976 ****************************************************************/
1977 
1978 NET_API_STATUS NetShareAdd(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
1979                            uint32_t level /* [in] */,
1980                            uint8_t *buffer /* [in] [ref] */,
1981                            uint32_t *parm_err /* [out] [ref] */)
1982 {
1983         struct NetShareAdd r;
1984         struct libnetapi_ctx *ctx = NULL;
1985         NET_API_STATUS status;
1986         WERROR werr;
1987 
1988         status = libnetapi_getctx(&ctx);
1989         if (status != 0) {
1990                 return status;
1991         }
1992 
1993         /* In parameters */
1994         r.in.server_name = server_name;
1995         r.in.level = level;
1996         r.in.buffer = buffer;
1997 
1998         /* Out parameters */
1999         r.out.parm_err = parm_err;
2000 
2001         if (DEBUGLEVEL >= 10) {
2002                 NDR_PRINT_IN_DEBUG(NetShareAdd, &r);
2003         }
2004 
2005         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2006                 werr = NetShareAdd_l(ctx, &r);
2007         } else {
2008                 werr = NetShareAdd_r(ctx, &r);
2009         }
2010 
2011         r.out.result = W_ERROR_V(werr);
2012 
2013         if (DEBUGLEVEL >= 10) {
2014                 NDR_PRINT_OUT_DEBUG(NetShareAdd, &r);
2015         }
2016 
2017         return r.out.result;
2018 }
2019 
2020 /****************************************************************
2021  NetShareDel
2022 ****************************************************************/
2023 
2024 NET_API_STATUS NetShareDel(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
2025                            const char * net_name /* [in] */,
2026                            uint32_t reserved /* [in] */)
2027 {
2028         struct NetShareDel r;
2029         struct libnetapi_ctx *ctx = NULL;
2030         NET_API_STATUS status;
2031         WERROR werr;
2032 
2033         status = libnetapi_getctx(&ctx);
2034         if (status != 0) {
2035                 return status;
2036         }
2037 
2038         /* In parameters */
2039         r.in.server_name = server_name;
2040         r.in.net_name = net_name;
2041         r.in.reserved = reserved;
2042 
2043         /* Out parameters */
2044 
2045         if (DEBUGLEVEL >= 10) {
2046                 NDR_PRINT_IN_DEBUG(NetShareDel, &r);
2047         }
2048 
2049         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2050                 werr = NetShareDel_l(ctx, &r);
2051         } else {
2052                 werr = NetShareDel_r(ctx, &r);
2053         }
2054 
2055         r.out.result = W_ERROR_V(werr);
2056 
2057         if (DEBUGLEVEL >= 10) {
2058                 NDR_PRINT_OUT_DEBUG(NetShareDel, &r);
2059         }
2060 
2061         return r.out.result;
2062 }
2063 
2064 /****************************************************************
2065  NetShareEnum
2066 ****************************************************************/
2067 
2068 NET_API_STATUS NetShareEnum(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
2069                             uint32_t level /* [in] */,
2070                             uint8_t **buffer /* [out] [ref] */,
2071                             uint32_t prefmaxlen /* [in] */,
2072                             uint32_t *entries_read /* [out] [ref] */,
2073                             uint32_t *total_entries /* [out] [ref] */,
2074                             uint32_t *resume_handle /* [in,out] [ref] */)
2075 {
2076         struct NetShareEnum r;
2077         struct libnetapi_ctx *ctx = NULL;
2078         NET_API_STATUS status;
2079         WERROR werr;
2080 
2081         status = libnetapi_getctx(&ctx);
2082         if (status != 0) {
2083                 return status;
2084         }
2085 
2086         /* In parameters */
2087         r.in.server_name = server_name;
2088         r.in.level = level;
2089         r.in.prefmaxlen = prefmaxlen;
2090         r.in.resume_handle = resume_handle;
2091 
2092         /* Out parameters */
2093         r.out.buffer = buffer;
2094         r.out.entries_read = entries_read;
2095         r.out.total_entries = total_entries;
2096         r.out.resume_handle = resume_handle;
2097 
2098         if (DEBUGLEVEL >= 10) {
2099                 NDR_PRINT_IN_DEBUG(NetShareEnum, &r);
2100         }
2101 
2102         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2103                 werr = NetShareEnum_l(ctx, &r);
2104         } else {
2105                 werr = NetShareEnum_r(ctx, &r);
2106         }
2107 
2108         r.out.result = W_ERROR_V(werr);
2109 
2110         if (DEBUGLEVEL >= 10) {
2111                 NDR_PRINT_OUT_DEBUG(NetShareEnum, &r);
2112         }
2113 
2114         return r.out.result;
2115 }
2116 
2117 /****************************************************************
2118  NetShareGetInfo
2119 ****************************************************************/
2120 
2121 NET_API_STATUS NetShareGetInfo(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
2122                                const char * net_name /* [in] */,
2123                                uint32_t level /* [in] */,
2124                                uint8_t **buffer /* [out] [ref] */)
2125 {
2126         struct NetShareGetInfo r;
2127         struct libnetapi_ctx *ctx = NULL;
2128         NET_API_STATUS status;
2129         WERROR werr;
2130 
2131         status = libnetapi_getctx(&ctx);
2132         if (status != 0) {
2133                 return status;
2134         }
2135 
2136         /* In parameters */
2137         r.in.server_name = server_name;
2138         r.in.net_name = net_name;
2139         r.in.level = level;
2140 
2141         /* Out parameters */
2142         r.out.buffer = buffer;
2143 
2144         if (DEBUGLEVEL >= 10) {
2145                 NDR_PRINT_IN_DEBUG(NetShareGetInfo, &r);
2146         }
2147 
2148         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2149                 werr = NetShareGetInfo_l(ctx, &r);
2150         } else {
2151                 werr = NetShareGetInfo_r(ctx, &r);
2152         }
2153 
2154         r.out.result = W_ERROR_V(werr);
2155 
2156         if (DEBUGLEVEL >= 10) {
2157                 NDR_PRINT_OUT_DEBUG(NetShareGetInfo, &r);
2158         }
2159 
2160         return r.out.result;
2161 }
2162 
2163 /****************************************************************
2164  NetShareSetInfo
2165 ****************************************************************/
2166 
2167 NET_API_STATUS NetShareSetInfo(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
2168                                const char * net_name /* [in] */,
2169                                uint32_t level /* [in] */,
2170                                uint8_t *buffer /* [in] [ref] */,
2171                                uint32_t *parm_err /* [out] [ref] */)
2172 {
2173         struct NetShareSetInfo r;
2174         struct libnetapi_ctx *ctx = NULL;
2175         NET_API_STATUS status;
2176         WERROR werr;
2177 
2178         status = libnetapi_getctx(&ctx);
2179         if (status != 0) {
2180                 return status;
2181         }
2182 
2183         /* In parameters */
2184         r.in.server_name = server_name;
2185         r.in.net_name = net_name;
2186         r.in.level = level;
2187         r.in.buffer = buffer;
2188 
2189         /* Out parameters */
2190         r.out.parm_err = parm_err;
2191 
2192         if (DEBUGLEVEL >= 10) {
2193                 NDR_PRINT_IN_DEBUG(NetShareSetInfo, &r);
2194         }
2195 
2196         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2197                 werr = NetShareSetInfo_l(ctx, &r);
2198         } else {
2199                 werr = NetShareSetInfo_r(ctx, &r);
2200         }
2201 
2202         r.out.result = W_ERROR_V(werr);
2203 
2204         if (DEBUGLEVEL >= 10) {
2205                 NDR_PRINT_OUT_DEBUG(NetShareSetInfo, &r);
2206         }
2207 
2208         return r.out.result;
2209 }
2210 
2211 /****************************************************************
2212  NetFileClose
2213 ****************************************************************/
2214 
2215 NET_API_STATUS NetFileClose(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
2216                             uint32_t fileid /* [in] */)
2217 {
2218         struct NetFileClose r;
2219         struct libnetapi_ctx *ctx = NULL;
2220         NET_API_STATUS status;
2221         WERROR werr;
2222 
2223         status = libnetapi_getctx(&ctx);
2224         if (status != 0) {
2225                 return status;
2226         }
2227 
2228         /* In parameters */
2229         r.in.server_name = server_name;
2230         r.in.fileid = fileid;
2231 
2232         /* Out parameters */
2233 
2234         if (DEBUGLEVEL >= 10) {
2235                 NDR_PRINT_IN_DEBUG(NetFileClose, &r);
2236         }
2237 
2238         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2239                 werr = NetFileClose_l(ctx, &r);
2240         } else {
2241                 werr = NetFileClose_r(ctx, &r);
2242         }
2243 
2244         r.out.result = W_ERROR_V(werr);
2245 
2246         if (DEBUGLEVEL >= 10) {
2247                 NDR_PRINT_OUT_DEBUG(NetFileClose, &r);
2248         }
2249 
2250         return r.out.result;
2251 }
2252 
2253 /****************************************************************
2254  NetFileGetInfo
2255 ****************************************************************/
2256 
2257 NET_API_STATUS NetFileGetInfo(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
2258                               uint32_t fileid /* [in] */,
2259                               uint32_t level /* [in] */,
2260                               uint8_t **buffer /* [out] [ref] */)
2261 {
2262         struct NetFileGetInfo r;
2263         struct libnetapi_ctx *ctx = NULL;
2264         NET_API_STATUS status;
2265         WERROR werr;
2266 
2267         status = libnetapi_getctx(&ctx);
2268         if (status != 0) {
2269                 return status;
2270         }
2271 
2272         /* In parameters */
2273         r.in.server_name = server_name;
2274         r.in.fileid = fileid;
2275         r.in.level = level;
2276 
2277         /* Out parameters */
2278         r.out.buffer = buffer;
2279 
2280         if (DEBUGLEVEL >= 10) {
2281                 NDR_PRINT_IN_DEBUG(NetFileGetInfo, &r);
2282         }
2283 
2284         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2285                 werr = NetFileGetInfo_l(ctx, &r);
2286         } else {
2287                 werr = NetFileGetInfo_r(ctx, &r);
2288         }
2289 
2290         r.out.result = W_ERROR_V(werr);
2291 
2292         if (DEBUGLEVEL >= 10) {
2293                 NDR_PRINT_OUT_DEBUG(NetFileGetInfo, &r);
2294         }
2295 
2296         return r.out.result;
2297 }
2298 
2299 /****************************************************************
2300  NetFileEnum
2301 ****************************************************************/
2302 
2303 NET_API_STATUS NetFileEnum(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
2304                            const char * base_path /* [in] */,
2305                            const char * user_name /* [in] */,
2306                            uint32_t level /* [in] */,
2307                            uint8_t **buffer /* [out] [ref] */,
2308                            uint32_t prefmaxlen /* [in] */,
2309                            uint32_t *entries_read /* [out] [ref] */,
2310                            uint32_t *total_entries /* [out] [ref] */,
2311                            uint32_t *resume_handle /* [in,out] [ref] */)
2312 {
2313         struct NetFileEnum r;
2314         struct libnetapi_ctx *ctx = NULL;
2315         NET_API_STATUS status;
2316         WERROR werr;
2317 
2318         status = libnetapi_getctx(&ctx);
2319         if (status != 0) {
2320                 return status;
2321         }
2322 
2323         /* In parameters */
2324         r.in.server_name = server_name;
2325         r.in.base_path = base_path;
2326         r.in.user_name = user_name;
2327         r.in.level = level;
2328         r.in.prefmaxlen = prefmaxlen;
2329         r.in.resume_handle = resume_handle;
2330 
2331         /* Out parameters */
2332         r.out.buffer = buffer;
2333         r.out.entries_read = entries_read;
2334         r.out.total_entries = total_entries;
2335         r.out.resume_handle = resume_handle;
2336 
2337         if (DEBUGLEVEL >= 10) {
2338                 NDR_PRINT_IN_DEBUG(NetFileEnum, &r);
2339         }
2340 
2341         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2342                 werr = NetFileEnum_l(ctx, &r);
2343         } else {
2344                 werr = NetFileEnum_r(ctx, &r);
2345         }
2346 
2347         r.out.result = W_ERROR_V(werr);
2348 
2349         if (DEBUGLEVEL >= 10) {
2350                 NDR_PRINT_OUT_DEBUG(NetFileEnum, &r);
2351         }
2352 
2353         return r.out.result;
2354 }
2355 
2356 /****************************************************************
2357  NetShutdownInit
2358 ****************************************************************/
2359 
2360 NET_API_STATUS NetShutdownInit(const char * server_name /* [in] */,
     /* [<][>][^][v][top][bottom][index][help] */
2361                                const char * message /* [in] */,
2362                                uint32_t timeout /* [in] */,
2363                                uint8_t force_apps /* [in] */,
2364                                uint8_t do_reboot /* [in] */)
2365 {
2366         struct NetShutdownInit r;
2367         struct libnetapi_ctx *ctx = NULL;
2368         NET_API_STATUS status;
2369         WERROR werr;
2370 
2371         status = libnetapi_getctx(&ctx);
2372         if (status != 0) {
2373                 return status;
2374         }
2375 
2376         /* In parameters */
2377         r.in.server_name = server_name;
2378         r.in.message = message;
2379         r.in.timeout = timeout;
2380         r.in.force_apps = force_apps;
2381         r.in.do_reboot = do_reboot;
2382 
2383         /* Out parameters */
2384 
2385         if (DEBUGLEVEL >= 10) {
2386                 NDR_PRINT_IN_DEBUG(NetShutdownInit, &r);
2387         }
2388 
2389         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2390                 werr = NetShutdownInit_l(ctx, &r);
2391         } else {
2392                 werr = NetShutdownInit_r(ctx, &r);
2393         }
2394 
2395         r.out.result = W_ERROR_V(werr);
2396 
2397         if (DEBUGLEVEL >= 10) {
2398                 NDR_PRINT_OUT_DEBUG(NetShutdownInit, &r);
2399         }
2400 
2401         return r.out.result;
2402 }
2403 
2404 /****************************************************************
2405  NetShutdownAbort
2406 ****************************************************************/
2407 
2408 NET_API_STATUS NetShutdownAbort(const char * server_name /* [in] */)
     /* [<][>][^][v][top][bottom][index][help] */
2409 {
2410         struct NetShutdownAbort r;
2411         struct libnetapi_ctx *ctx = NULL;
2412         NET_API_STATUS status;
2413         WERROR werr;
2414 
2415         status = libnetapi_getctx(&ctx);
2416         if (status != 0) {
2417                 return status;
2418         }
2419 
2420         /* In parameters */
2421         r.in.server_name = server_name;
2422 
2423         /* Out parameters */
2424 
2425         if (DEBUGLEVEL >= 10) {
2426                 NDR_PRINT_IN_DEBUG(NetShutdownAbort, &r);
2427         }
2428 
2429         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2430                 werr = NetShutdownAbort_l(ctx, &r);
2431         } else {
2432                 werr = NetShutdownAbort_r(ctx, &r);
2433         }
2434 
2435         r.out.result = W_ERROR_V(werr);
2436 
2437         if (DEBUGLEVEL >= 10) {
2438                 NDR_PRINT_OUT_DEBUG(NetShutdownAbort, &r);
2439         }
2440 
2441         return r.out.result;
2442 }
2443 

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