LCOV - code coverage report
Current view: top level - source3/lib/netapi - libnetapi.c (source / functions) Hit Total Coverage
Test: coverage report for master 2b515b7d Lines: 424 1475 28.7 %
Date: 2024-02-28 12:06:22 Functions: 23 57 40.4 %

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

Generated by: LCOV version 1.14