849eec3a67b91deb53f8ffe078e5cba3bfc9124b
[kai/samba.git] / source3 / utils / net_rpc.c
1 /*
2    Samba Unix/Linux SMB client library
3    Distributed SMB/CIFS Server Management Utility
4    Copyright (C) 2001 Andrew Bartlett (abartlet@samba.org)
5    Copyright (C) 2002 Jim McDonough (jmcd@us.ibm.com)
6    Copyright (C) 2004,2008 Guenther Deschner (gd@samba.org)
7    Copyright (C) 2005 Jeremy Allison (jra@samba.org)
8    Copyright (C) 2006 Jelmer Vernooij (jelmer@samba.org)
9
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 3 of the License, or
13    (at your option) any later version.
14
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19
20    You should have received a copy of the GNU General Public License
21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
22
23 #include "includes.h"
24 #include "utils/net.h"
25 #include "rpc_client/cli_pipe.h"
26 #include "../libcli/auth/libcli_auth.h"
27 #include "../librpc/gen_ndr/ndr_samr_c.h"
28 #include "rpc_client/cli_samr.h"
29 #include "rpc_client/init_samr.h"
30 #include "../librpc/gen_ndr/ndr_lsa_c.h"
31 #include "rpc_client/cli_lsarpc.h"
32 #include "../librpc/gen_ndr/ndr_netlogon_c.h"
33 #include "../librpc/gen_ndr/ndr_srvsvc_c.h"
34 #include "../librpc/gen_ndr/ndr_spoolss.h"
35 #include "../librpc/gen_ndr/ndr_initshutdown_c.h"
36 #include "../librpc/gen_ndr/ndr_winreg_c.h"
37 #include "secrets.h"
38 #include "lib/netapi/netapi.h"
39 #include "lib/netapi/netapi_net.h"
40 #include "rpc_client/init_lsa.h"
41 #include "../libcli/security/security.h"
42 #include "libsmb/libsmb.h"
43 #include "libsmb/clirap.h"
44 #include "nsswitch/libwbclient/wbclient.h"
45 #include "passdb.h"
46
47 static int net_mode_share;
48 static NTSTATUS sync_files(struct copy_clistate *cp_clistate, const char *mask);
49
50 /**
51  * @file net_rpc.c
52  *
53  * @brief RPC based subcommands for the 'net' utility.
54  *
55  * This file should contain much of the functionality that used to
56  * be found in rpcclient, execpt that the commands should change
57  * less often, and the fucntionality should be sane (the user is not
58  * expected to know a rid/sid before they conduct an operation etc.)
59  *
60  * @todo Perhaps eventually these should be split out into a number
61  * of files, as this could get quite big.
62  **/
63
64
65 /**
66  * Many of the RPC functions need the domain sid.  This function gets
67  *  it at the start of every run
68  *
69  * @param cli A cli_state already connected to the remote machine
70  *
71  * @return The Domain SID of the remote machine.
72  **/
73
74 NTSTATUS net_get_remote_domain_sid(struct cli_state *cli, TALLOC_CTX *mem_ctx,
75                                    struct dom_sid **domain_sid,
76                                    const char **domain_name)
77 {
78         struct rpc_pipe_client *lsa_pipe = NULL;
79         struct policy_handle pol;
80         NTSTATUS status, result;
81         union lsa_PolicyInformation *info = NULL;
82         struct dcerpc_binding_handle *b;
83
84         status = cli_rpc_pipe_open_noauth(cli, &ndr_table_lsarpc.syntax_id,
85                                           &lsa_pipe);
86         if (!NT_STATUS_IS_OK(status)) {
87                 d_fprintf(stderr, _("Could not initialise lsa pipe\n"));
88                 return status;
89         }
90
91         b = lsa_pipe->binding_handle;
92
93         status = rpccli_lsa_open_policy(lsa_pipe, mem_ctx, false,
94                                      SEC_FLAG_MAXIMUM_ALLOWED,
95                                      &pol);
96         if (!NT_STATUS_IS_OK(status)) {
97                 d_fprintf(stderr, "open_policy %s: %s\n",
98                           _("failed"),
99                           nt_errstr(status));
100                 return status;
101         }
102
103         status = dcerpc_lsa_QueryInfoPolicy(b, mem_ctx,
104                                             &pol,
105                                             LSA_POLICY_INFO_ACCOUNT_DOMAIN,
106                                             &info,
107                                             &result);
108         if (!NT_STATUS_IS_OK(status)) {
109                 d_fprintf(stderr, "lsaquery %s: %s\n",
110                           _("failed"),
111                           nt_errstr(status));
112                 return status;
113         }
114         if (!NT_STATUS_IS_OK(result)) {
115                 d_fprintf(stderr, "lsaquery %s: %s\n",
116                           _("failed"),
117                           nt_errstr(result));
118                 return result;
119         }
120
121         *domain_name = info->account_domain.name.string;
122         *domain_sid = info->account_domain.sid;
123
124         dcerpc_lsa_Close(b, mem_ctx, &pol, &result);
125         TALLOC_FREE(lsa_pipe);
126
127         return NT_STATUS_OK;
128 }
129
130 /**
131  * Run a single RPC command, from start to finish.
132  *
133  * @param pipe_name the pipe to connect to (usually a PIPE_ constant)
134  * @param conn_flag a NET_FLAG_ combination.  Passed to
135  *                   net_make_ipc_connection.
136  * @param argc  Standard main() style argc.
137  * @param argv  Standard main() style argv. Initial components are already
138  *              stripped.
139  * @return A shell status integer (0 for success).
140  */
141
142 int run_rpc_command(struct net_context *c,
143                         struct cli_state *cli_arg,
144                         const struct ndr_syntax_id *interface,
145                         int conn_flags,
146                         rpc_command_fn fn,
147                         int argc,
148                         const char **argv)
149 {
150         struct cli_state *cli = NULL;
151         struct rpc_pipe_client *pipe_hnd = NULL;
152         TALLOC_CTX *mem_ctx;
153         NTSTATUS nt_status;
154         struct dom_sid *domain_sid;
155         const char *domain_name;
156         int ret = -1;
157
158         /* make use of cli_state handed over as an argument, if possible */
159         if (!cli_arg) {
160                 nt_status = net_make_ipc_connection(c, conn_flags, &cli);
161                 if (!NT_STATUS_IS_OK(nt_status)) {
162                         DEBUG(1, ("failed to make ipc connection: %s\n",
163                                   nt_errstr(nt_status)));
164                         return -1;
165                 }
166         } else {
167                 cli = cli_arg;
168         }
169
170         if (!cli) {
171                 return -1;
172         }
173
174         /* Create mem_ctx */
175
176         if (!(mem_ctx = talloc_init("run_rpc_command"))) {
177                 DEBUG(0, ("talloc_init() failed\n"));
178                 goto fail;
179         }
180
181         nt_status = net_get_remote_domain_sid(cli, mem_ctx, &domain_sid,
182                                               &domain_name);
183         if (!NT_STATUS_IS_OK(nt_status)) {
184                 goto fail;
185         }
186
187         if (!(conn_flags & NET_FLAGS_NO_PIPE)) {
188                 if (lp_client_schannel()
189                     && (ndr_syntax_id_equal(interface,
190                                             &ndr_table_netlogon.syntax_id))) {
191                         /* Always try and create an schannel netlogon pipe. */
192                         nt_status = cli_rpc_pipe_open_schannel(
193                                 cli, interface, NCACN_NP,
194                                 DCERPC_AUTH_LEVEL_PRIVACY, domain_name,
195                                 &pipe_hnd);
196                         if (!NT_STATUS_IS_OK(nt_status)) {
197                                 DEBUG(0, ("Could not initialise schannel netlogon pipe. Error was %s\n",
198                                         nt_errstr(nt_status) ));
199                                 goto fail;
200                         }
201                 } else {
202                         if (conn_flags & NET_FLAGS_SEAL) {
203                                 nt_status = cli_rpc_pipe_open_ntlmssp(
204                                         cli, interface,
205                                         (conn_flags & NET_FLAGS_TCP) ?
206                                         NCACN_IP_TCP : NCACN_NP,
207                                         DCERPC_AUTH_LEVEL_PRIVACY,
208                                         lp_workgroup(), c->opt_user_name,
209                                         c->opt_password, &pipe_hnd);
210                         } else {
211                                 nt_status = cli_rpc_pipe_open_noauth(
212                                         cli, interface,
213                                         &pipe_hnd);
214                         }
215                         if (!NT_STATUS_IS_OK(nt_status)) {
216                                 DEBUG(0, ("Could not initialise pipe %s. Error was %s\n",
217                                           get_pipe_name_from_syntax(
218                                                   talloc_tos(), interface),
219                                         nt_errstr(nt_status) ));
220                                 goto fail;
221                         }
222                 }
223         }
224
225         nt_status = fn(c, domain_sid, domain_name, cli, pipe_hnd, mem_ctx, argc, argv);
226
227         if (!NT_STATUS_IS_OK(nt_status)) {
228                 DEBUG(1, ("rpc command function failed! (%s)\n", nt_errstr(nt_status)));
229         } else {
230                 ret = 0;
231                 DEBUG(5, ("rpc command function succedded\n"));
232         }
233
234         if (!(conn_flags & NET_FLAGS_NO_PIPE)) {
235                 if (pipe_hnd) {
236                         TALLOC_FREE(pipe_hnd);
237                 }
238         }
239
240 fail:
241         /* close the connection only if it was opened here */
242         if (!cli_arg) {
243                 cli_shutdown(cli);
244         }
245
246         talloc_destroy(mem_ctx);
247         return ret;
248 }
249
250 /**
251  * Force a change of the trust acccount password.
252  *
253  * All parameters are provided by the run_rpc_command function, except for
254  * argc, argv which are passed through.
255  *
256  * @param domain_sid The domain sid acquired from the remote server.
257  * @param cli A cli_state connected to the server.
258  * @param mem_ctx Talloc context, destroyed on completion of the function.
259  * @param argc  Standard main() style argc.
260  * @param argv  Standard main() style argv. Initial components are already
261  *              stripped.
262  *
263  * @return Normal NTSTATUS return.
264  **/
265
266 static NTSTATUS rpc_changetrustpw_internals(struct net_context *c,
267                                         const struct dom_sid *domain_sid,
268                                         const char *domain_name,
269                                         struct cli_state *cli,
270                                         struct rpc_pipe_client *pipe_hnd,
271                                         TALLOC_CTX *mem_ctx,
272                                         int argc,
273                                         const char **argv)
274 {
275         NTSTATUS status;
276
277         status = trust_pw_find_change_and_store_it(pipe_hnd, mem_ctx, c->opt_target_workgroup);
278         if (!NT_STATUS_IS_OK(status)) {
279                 d_fprintf(stderr, _("Failed to change machine account password: %s\n"),
280                         nt_errstr(status));
281                 return status;
282         }
283
284         return NT_STATUS_OK;
285 }
286
287 /**
288  * Force a change of the trust acccount password.
289  *
290  * @param argc  Standard main() style argc.
291  * @param argv  Standard main() style argv. Initial components are already
292  *              stripped.
293  *
294  * @return A shell status integer (0 for success).
295  **/
296
297 int net_rpc_changetrustpw(struct net_context *c, int argc, const char **argv)
298 {
299         if (c->display_usage) {
300                 d_printf(  "%s\n"
301                            "net rpc changetrustpw\n"
302                            "    %s\n",
303                          _("Usage:"),
304                          _("Change the machine trust password"));
305                 return 0;
306         }
307
308         return run_rpc_command(c, NULL, &ndr_table_netlogon.syntax_id,
309                                NET_FLAGS_ANONYMOUS | NET_FLAGS_PDC,
310                                rpc_changetrustpw_internals,
311                                argc, argv);
312 }
313
314 /**
315  * Join a domain, the old way.
316  *
317  * This uses 'machinename' as the inital password, and changes it.
318  *
319  * The password should be created with 'server manager' or equiv first.
320  *
321  * All parameters are provided by the run_rpc_command function, except for
322  * argc, argv which are passed through.
323  *
324  * @param domain_sid The domain sid acquired from the remote server.
325  * @param cli A cli_state connected to the server.
326  * @param mem_ctx Talloc context, destroyed on completion of the function.
327  * @param argc  Standard main() style argc.
328  * @param argv  Standard main() style argv. Initial components are already
329  *              stripped.
330  *
331  * @return Normal NTSTATUS return.
332  **/
333
334 static NTSTATUS rpc_oldjoin_internals(struct net_context *c,
335                                         const struct dom_sid *domain_sid,
336                                         const char *domain_name,
337                                         struct cli_state *cli,
338                                         struct rpc_pipe_client *pipe_hnd,
339                                         TALLOC_CTX *mem_ctx,
340                                         int argc,
341                                         const char **argv)
342 {
343
344         fstring trust_passwd;
345         unsigned char orig_trust_passwd_hash[16];
346         NTSTATUS result;
347         enum netr_SchannelType sec_channel_type;
348
349         result = cli_rpc_pipe_open_noauth(cli, &ndr_table_netlogon.syntax_id,
350                                           &pipe_hnd);
351         if (!NT_STATUS_IS_OK(result)) {
352                 DEBUG(0,("rpc_oldjoin_internals: netlogon pipe open to machine %s failed. "
353                         "error was %s\n",
354                         cli->desthost,
355                         nt_errstr(result) ));
356                 return result;
357         }
358
359         /*
360            check what type of join - if the user want's to join as
361            a BDC, the server must agree that we are a BDC.
362         */
363         if (argc >= 0) {
364                 sec_channel_type = get_sec_channel_type(argv[0]);
365         } else {
366                 sec_channel_type = get_sec_channel_type(NULL);
367         }
368
369         fstrcpy(trust_passwd, global_myname());
370         strlower_m(trust_passwd);
371
372         /*
373          * Machine names can be 15 characters, but the max length on
374          * a password is 14.  --jerry
375          */
376
377         trust_passwd[14] = '\0';
378
379         E_md4hash(trust_passwd, orig_trust_passwd_hash);
380
381         result = trust_pw_change_and_store_it(pipe_hnd, mem_ctx, c->opt_target_workgroup,
382                                               global_myname(),
383                                               orig_trust_passwd_hash,
384                                               sec_channel_type);
385
386         if (NT_STATUS_IS_OK(result))
387                 printf(_("Joined domain %s.\n"), c->opt_target_workgroup);
388
389
390         if (!secrets_store_domain_sid(c->opt_target_workgroup, domain_sid)) {
391                 DEBUG(0, ("error storing domain sid for %s\n", c->opt_target_workgroup));
392                 result = NT_STATUS_UNSUCCESSFUL;
393         }
394
395         return result;
396 }
397
398 /**
399  * Join a domain, the old way.
400  *
401  * @param argc  Standard main() style argc.
402  * @param argv  Standard main() style argv. Initial components are already
403  *              stripped.
404  *
405  * @return A shell status integer (0 for success).
406  **/
407
408 static int net_rpc_perform_oldjoin(struct net_context *c, int argc, const char **argv)
409 {
410         return run_rpc_command(c, NULL, &ndr_table_netlogon.syntax_id,
411                                NET_FLAGS_NO_PIPE | NET_FLAGS_ANONYMOUS | NET_FLAGS_PDC,
412                                rpc_oldjoin_internals,
413                                argc, argv);
414 }
415
416 /**
417  * Join a domain, the old way.  This function exists to allow
418  * the message to be displayed when oldjoin was explicitly
419  * requested, but not when it was implied by "net rpc join".
420  *
421  * @param argc  Standard main() style argc.
422  * @param argv  Standard main() style argv. Initial components are already
423  *              stripped.
424  *
425  * @return A shell status integer (0 for success).
426  **/
427
428 static int net_rpc_oldjoin(struct net_context *c, int argc, const char **argv)
429 {
430         int rc = -1;
431
432         if (c->display_usage) {
433                 d_printf(  "%s\n"
434                            "net rpc oldjoin\n"
435                            "    %s\n",
436                          _("Usage:"),
437                          _("Join a domain the old way"));
438                 return 0;
439         }
440
441         rc = net_rpc_perform_oldjoin(c, argc, argv);
442
443         if (rc) {
444                 d_fprintf(stderr, _("Failed to join domain\n"));
445         }
446
447         return rc;
448 }
449
450 /**
451  * 'net rpc join' entrypoint.
452  * @param argc  Standard main() style argc.
453  * @param argv  Standard main() style argv. Initial components are already
454  *              stripped
455  *
456  * Main 'net_rpc_join()' (where the admin username/password is used) is
457  * in net_rpc_join.c.
458  * Try to just change the password, but if that doesn't work, use/prompt
459  * for a username/password.
460  **/
461
462 int net_rpc_join(struct net_context *c, int argc, const char **argv)
463 {
464         if (c->display_usage) {
465                 d_printf("%s\n%s",
466                          _("Usage:"),
467                          _("net rpc join -U <username>[%%password] <type>\n"
468                            "  Join a domain\n"
469                            "    username\tName of the admin user"
470                            "    password\tPassword of the admin user, will "
471                            "prompt if not specified\n"
472                            "    type\tCan be one of the following:\n"
473                            "\t\tMEMBER\tJoin as member server (default)\n"
474                            "\t\tBDC\tJoin as BDC\n"
475                            "\t\tPDC\tJoin as PDC\n"));
476                 return 0;
477         }
478
479         if (lp_server_role() == ROLE_STANDALONE) {
480                 d_printf(_("cannot join as standalone machine\n"));
481                 return -1;
482         }
483
484         if (strlen(global_myname()) > 15) {
485                 d_printf(_("Our netbios name can be at most 15 chars long, "
486                            "\"%s\" is %u chars long\n"),
487                          global_myname(), (unsigned int)strlen(global_myname()));
488                 return -1;
489         }
490
491         if ((net_rpc_perform_oldjoin(c, argc, argv) == 0))
492                 return 0;
493
494         return net_rpc_join_newstyle(c, argc, argv);
495 }
496
497 /**
498  * display info about a rpc domain
499  *
500  * All parameters are provided by the run_rpc_command function, except for
501  * argc, argv which are passed through.
502  *
503  * @param domain_sid The domain sid acquired from the remote server
504  * @param cli A cli_state connected to the server.
505  * @param mem_ctx Talloc context, destroyed on completion of the function.
506  * @param argc  Standard main() style argc.
507  * @param argv  Standard main() style argv. Initial components are already
508  *              stripped.
509  *
510  * @return Normal NTSTATUS return.
511  **/
512
513 NTSTATUS rpc_info_internals(struct net_context *c,
514                         const struct dom_sid *domain_sid,
515                         const char *domain_name,
516                         struct cli_state *cli,
517                         struct rpc_pipe_client *pipe_hnd,
518                         TALLOC_CTX *mem_ctx,
519                         int argc,
520                         const char **argv)
521 {
522         struct policy_handle connect_pol, domain_pol;
523         NTSTATUS status, result;
524         union samr_DomainInfo *info = NULL;
525         fstring sid_str;
526         struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
527
528         sid_to_fstring(sid_str, domain_sid);
529
530         /* Get sam policy handle */
531         status = dcerpc_samr_Connect2(b, mem_ctx,
532                                       pipe_hnd->desthost,
533                                       MAXIMUM_ALLOWED_ACCESS,
534                                       &connect_pol,
535                                       &result);
536         if (!NT_STATUS_IS_OK(status)) {
537                 d_fprintf(stderr, _("Could not connect to SAM: %s\n"),
538                           nt_errstr(status));
539                 goto done;
540         }
541
542         if (!NT_STATUS_IS_OK(result)) {
543                 status = result;
544                 d_fprintf(stderr, _("Could not connect to SAM: %s\n"),
545                           nt_errstr(result));
546                 goto done;
547         }
548
549         /* Get domain policy handle */
550         status = dcerpc_samr_OpenDomain(b, mem_ctx,
551                                         &connect_pol,
552                                         MAXIMUM_ALLOWED_ACCESS,
553                                         discard_const_p(struct dom_sid2, domain_sid),
554                                         &domain_pol,
555                                         &result);
556         if (!NT_STATUS_IS_OK(status)) {
557                 d_fprintf(stderr, _("Could not open domain: %s\n"),
558                           nt_errstr(status));
559                 goto done;
560         }
561         if (!NT_STATUS_IS_OK(result)) {
562                 status = result;
563                 d_fprintf(stderr, _("Could not open domain: %s\n"),
564                           nt_errstr(result));
565                 goto done;
566         }
567
568         status = dcerpc_samr_QueryDomainInfo(b, mem_ctx,
569                                              &domain_pol,
570                                              2,
571                                              &info,
572                                              &result);
573         if (!NT_STATUS_IS_OK(status)) {
574                 goto done;
575         }
576         status = result;
577         if (NT_STATUS_IS_OK(result)) {
578                 d_printf(_("Domain Name: %s\n"),
579                          info->general.domain_name.string);
580                 d_printf(_("Domain SID: %s\n"), sid_str);
581                 d_printf(_("Sequence number: %llu\n"),
582                         (unsigned long long)info->general.sequence_num);
583                 d_printf(_("Num users: %u\n"), info->general.num_users);
584                 d_printf(_("Num domain groups: %u\n"),info->general.num_groups);
585                 d_printf(_("Num local groups: %u\n"),info->general.num_aliases);
586         }
587
588  done:
589         return status;
590 }
591
592 /**
593  * 'net rpc info' entrypoint.
594  * @param argc  Standard main() style argc.
595  * @param argv  Standard main() style argv. Initial components are already
596  *              stripped.
597  **/
598
599 int net_rpc_info(struct net_context *c, int argc, const char **argv)
600 {
601         if (c->display_usage) {
602                 d_printf(  "%s\n"
603                            "net rpc info\n"
604                            "  %s\n",
605                          _("Usage:"),
606                          _("Display information about the domain"));
607                 return 0;
608         }
609
610         return run_rpc_command(c, NULL, &ndr_table_samr.syntax_id,
611                                NET_FLAGS_PDC, rpc_info_internals,
612                                argc, argv);
613 }
614
615 /**
616  * Fetch domain SID into the local secrets.tdb.
617  *
618  * All parameters are provided by the run_rpc_command function, except for
619  * argc, argv which are passed through.
620  *
621  * @param domain_sid The domain sid acquired from the remote server.
622  * @param cli A cli_state connected to the server.
623  * @param mem_ctx Talloc context, destroyed on completion of the function.
624  * @param argc  Standard main() style argc.
625  * @param argv  Standard main() style argv. Initial components are already
626  *              stripped.
627  *
628  * @return Normal NTSTATUS return.
629  **/
630
631 static NTSTATUS rpc_getsid_internals(struct net_context *c,
632                         const struct dom_sid *domain_sid,
633                         const char *domain_name,
634                         struct cli_state *cli,
635                         struct rpc_pipe_client *pipe_hnd,
636                         TALLOC_CTX *mem_ctx,
637                         int argc,
638                         const char **argv)
639 {
640         fstring sid_str;
641
642         sid_to_fstring(sid_str, domain_sid);
643         d_printf(_("Storing SID %s for Domain %s in secrets.tdb\n"),
644                  sid_str, domain_name);
645
646         if (!secrets_store_domain_sid(domain_name, domain_sid)) {
647                 DEBUG(0,("Can't store domain SID\n"));
648                 return NT_STATUS_UNSUCCESSFUL;
649         }
650
651         return NT_STATUS_OK;
652 }
653
654 /**
655  * 'net rpc getsid' entrypoint.
656  * @param argc  Standard main() style argc.
657  * @param argv  Standard main() style argv. Initial components are already
658  *              stripped.
659  **/
660
661 int net_rpc_getsid(struct net_context *c, int argc, const char **argv)
662 {
663         int conn_flags = NET_FLAGS_PDC;
664
665         if (!c->opt_user_specified) {
666                 conn_flags |= NET_FLAGS_ANONYMOUS;
667         }
668
669         if (c->display_usage) {
670                 d_printf(  "%s\n"
671                            "net rpc getsid\n"
672                            "    %s\n",
673                          _("Usage:"),
674                          _("Fetch domain SID into local secrets.tdb"));
675                 return 0;
676         }
677
678         return run_rpc_command(c, NULL, &ndr_table_samr.syntax_id,
679                                conn_flags,
680                                rpc_getsid_internals,
681                                argc, argv);
682 }
683
684 /****************************************************************************/
685
686 /**
687  * Basic usage function for 'net rpc user'.
688  * @param argc  Standard main() style argc.
689  * @param argv  Standard main() style argv. Initial components are already
690  *              stripped.
691  **/
692
693 static int rpc_user_usage(struct net_context *c, int argc, const char **argv)
694 {
695         return net_user_usage(c, argc, argv);
696 }
697
698 /**
699  * Add a new user to a remote RPC server.
700  *
701  * @param argc  Standard main() style argc.
702  * @param argv  Standard main() style argv. Initial components are already
703  *              stripped.
704  *
705  * @return A shell status integer (0 for success).
706  **/
707
708 static int rpc_user_add(struct net_context *c, int argc, const char **argv)
709 {
710         NET_API_STATUS status;
711         struct USER_INFO_1 info1;
712         uint32_t parm_error = 0;
713
714         if (argc < 1 || c->display_usage) {
715                 rpc_user_usage(c, argc, argv);
716                 return 0;
717         }
718
719         ZERO_STRUCT(info1);
720
721         info1.usri1_name = argv[0];
722         if (argc == 2) {
723                 info1.usri1_password = argv[1];
724         }
725
726         status = NetUserAdd(c->opt_host, 1, (uint8_t *)&info1, &parm_error);
727
728         if (status != 0) {
729                 d_fprintf(stderr,_("Failed to add user '%s' with error: %s.\n"),
730                         argv[0], libnetapi_get_error_string(c->netapi_ctx,
731                                                             status));
732                 return -1;
733         } else {
734                 d_printf(_("Added user '%s'.\n"), argv[0]);
735         }
736
737         return 0;
738 }
739
740 /**
741  * Rename a user on a remote RPC server.
742  *
743  * @param argc  Standard main() style argc.
744  * @param argv  Standard main() style argv. Initial components are already
745  *              stripped.
746  *
747  * @return A shell status integer (0 for success).
748  **/
749
750 static int rpc_user_rename(struct net_context *c, int argc, const char **argv)
751 {
752         NET_API_STATUS status;
753         struct USER_INFO_0 u0;
754         uint32_t parm_err = 0;
755
756         if (argc != 2 || c->display_usage) {
757                 rpc_user_usage(c, argc, argv);
758                 return 0;
759         }
760
761         u0.usri0_name = argv[1];
762
763         status = NetUserSetInfo(c->opt_host, argv[0],
764                                 0, (uint8_t *)&u0, &parm_err);
765         if (status) {
766                 d_fprintf(stderr,
767                           _("Failed to rename user from %s to %s - %s\n"),
768                           argv[0], argv[1],
769                           libnetapi_get_error_string(c->netapi_ctx, status));
770         } else {
771                 d_printf(_("Renamed user from %s to %s\n"), argv[0], argv[1]);
772         }
773
774         return status;
775 }
776
777 /**
778  * Set a user's primary group
779  *
780  * @param argc  Standard main() style argc.
781  * @param argv  Standard main() style argv. Initial components are already
782  *              stripped.
783  *
784  * @return A shell status integer (0 for success).
785  **/
786
787 static int rpc_user_setprimarygroup(struct net_context *c, int argc,
788                                     const char **argv)
789 {
790         NET_API_STATUS status;
791         uint8_t *buffer;
792         struct GROUP_INFO_2 *g2;
793         struct USER_INFO_1051 u1051;
794         uint32_t parm_err = 0;
795
796         if (argc != 2 || c->display_usage) {
797                 rpc_user_usage(c, argc, argv);
798                 return 0;
799         }
800
801         status = NetGroupGetInfo(c->opt_host, argv[1], 2, &buffer);
802         if (status) {
803                 d_fprintf(stderr, _("Failed to find group name %s -- %s\n"),
804                           argv[1],
805                           libnetapi_get_error_string(c->netapi_ctx, status));
806                 return status;
807         }
808         g2 = (struct GROUP_INFO_2 *)buffer;
809
810         u1051.usri1051_primary_group_id = g2->grpi2_group_id;
811
812         NetApiBufferFree(buffer);
813
814         status = NetUserSetInfo(c->opt_host, argv[0], 1051,
815                                 (uint8_t *)&u1051, &parm_err);
816         if (status) {
817                 d_fprintf(stderr,
818                           _("Failed to set user's primary group %s to %s - "
819                             "%s\n"), argv[0], argv[1],
820                           libnetapi_get_error_string(c->netapi_ctx, status));
821         } else {
822                 d_printf(_("Set primary group of user %s to %s\n"), argv[0],
823                          argv[1]);
824         }
825         return status;
826 }
827
828 /**
829  * Delete a user from a remote RPC server.
830  *
831  * @param argc  Standard main() style argc.
832  * @param argv  Standard main() style argv. Initial components are already
833  *              stripped.
834  *
835  * @return A shell status integer (0 for success).
836  **/
837
838 static int rpc_user_delete(struct net_context *c, int argc, const char **argv)
839 {
840         NET_API_STATUS status;
841
842         if (argc < 1 || c->display_usage) {
843                 rpc_user_usage(c, argc, argv);
844                 return 0;
845         }
846
847         status = NetUserDel(c->opt_host, argv[0]);
848
849         if (status != 0) {
850                 d_fprintf(stderr, _("Failed to delete user '%s' with: %s.\n"),
851                           argv[0],
852                           libnetapi_get_error_string(c->netapi_ctx, status));
853                 return -1;
854         } else {
855                 d_printf(_("Deleted user '%s'.\n"), argv[0]);
856         }
857
858         return 0;
859 }
860
861 /**
862  * Set a user's password on a remote RPC server.
863  *
864  * @param argc  Standard main() style argc.
865  * @param argv  Standard main() style argv. Initial components are already
866  *              stripped.
867  *
868  * @return A shell status integer (0 for success).
869  **/
870
871 static int rpc_user_password(struct net_context *c, int argc, const char **argv)
872 {
873         NET_API_STATUS status;
874         char *prompt = NULL;
875         struct USER_INFO_1003 u1003;
876         uint32_t parm_err = 0;
877         int ret;
878
879         if (argc < 1 || c->display_usage) {
880                 rpc_user_usage(c, argc, argv);
881                 return 0;
882         }
883
884         if (argv[1]) {
885                 u1003.usri1003_password = argv[1];
886         } else {
887                 ret = asprintf(&prompt, _("Enter new password for %s:"),
888                                argv[0]);
889                 if (ret == -1) {
890                         return -1;
891                 }
892                 u1003.usri1003_password = talloc_strdup(c, getpass(prompt));
893                 SAFE_FREE(prompt);
894                 if (u1003.usri1003_password == NULL) {
895                         return -1;
896                 }
897         }
898
899         status = NetUserSetInfo(c->opt_host, argv[0], 1003, (uint8_t *)&u1003, &parm_err);
900
901         /* Display results */
902         if (status != 0) {
903                 d_fprintf(stderr,
904                         _("Failed to set password for '%s' with error: %s.\n"),
905                         argv[0], libnetapi_get_error_string(c->netapi_ctx,
906                                                             status));
907                 return -1;
908         }
909
910         return 0;
911 }
912
913 /**
914  * List a user's groups from a remote RPC server.
915  *
916  * @param argc  Standard main() style argc.
917  * @param argv  Standard main() style argv. Initial components are already
918  *              stripped.
919  *
920  * @return A shell status integer (0 for success)
921  **/
922
923 static int rpc_user_info(struct net_context *c, int argc, const char **argv)
924
925 {
926         NET_API_STATUS status;
927         struct GROUP_USERS_INFO_0 *u0 = NULL;
928         uint32_t entries_read = 0;
929         uint32_t total_entries = 0;
930         int i;
931
932
933         if (argc < 1 || c->display_usage) {
934                 rpc_user_usage(c, argc, argv);
935                 return 0;
936         }
937
938         status = NetUserGetGroups(c->opt_host,
939                                   argv[0],
940                                   0,
941                                   (uint8_t **)(void *)&u0,
942                                   (uint32_t)-1,
943                                   &entries_read,
944                                   &total_entries);
945         if (status != 0) {
946                 d_fprintf(stderr,
947                         _("Failed to get groups for '%s' with error: %s.\n"),
948                         argv[0], libnetapi_get_error_string(c->netapi_ctx,
949                                                             status));
950                 return -1;
951         }
952
953         for (i=0; i < entries_read; i++) {
954                 printf("%s\n", u0->grui0_name);
955                 u0++;
956         }
957
958         return 0;
959 }
960
961 /**
962  * List users on a remote RPC server.
963  *
964  * All parameters are provided by the run_rpc_command function, except for
965  * argc, argv which are passed through.
966  *
967  * @param domain_sid The domain sid acquired from the remote server.
968  * @param cli A cli_state connected to the server.
969  * @param mem_ctx Talloc context, destroyed on completion of the function.
970  * @param argc  Standard main() style argc.
971  * @param argv  Standard main() style argv. Initial components are already
972  *              stripped.
973  *
974  * @return Normal NTSTATUS return.
975  **/
976
977 static int rpc_user_list(struct net_context *c, int argc, const char **argv)
978 {
979         NET_API_STATUS status;
980         uint32_t start_idx=0, num_entries, i, loop_count = 0;
981         struct NET_DISPLAY_USER *info = NULL;
982         void *buffer = NULL;
983
984         /* Query domain users */
985         if (c->opt_long_list_entries)
986                 d_printf(_("\nUser name             Comment"
987                            "\n-----------------------------\n"));
988         do {
989                 uint32_t max_entries, max_size;
990
991                 dcerpc_get_query_dispinfo_params(
992                         loop_count, &max_entries, &max_size);
993
994                 status = NetQueryDisplayInformation(c->opt_host,
995                                                     1,
996                                                     start_idx,
997                                                     max_entries,
998                                                     max_size,
999                                                     &num_entries,
1000                                                     &buffer);
1001                 if (status != 0 && status != ERROR_MORE_DATA) {
1002                         return status;
1003                 }
1004
1005                 info = (struct NET_DISPLAY_USER *)buffer;
1006
1007                 for (i = 0; i < num_entries; i++) {
1008
1009                         if (c->opt_long_list_entries)
1010                                 printf("%-21.21s %s\n", info->usri1_name,
1011                                         info->usri1_comment);
1012                         else
1013                                 printf("%s\n", info->usri1_name);
1014                         info++;
1015                 }
1016
1017                 NetApiBufferFree(buffer);
1018
1019                 loop_count++;
1020                 start_idx += num_entries;
1021
1022         } while (status == ERROR_MORE_DATA);
1023
1024         return status;
1025 }
1026
1027 /**
1028  * 'net rpc user' entrypoint.
1029  * @param argc  Standard main() style argc.
1030  * @param argv  Standard main() style argv. Initial components are already
1031  *              stripped.
1032  **/
1033
1034 int net_rpc_user(struct net_context *c, int argc, const char **argv)
1035 {
1036         NET_API_STATUS status;
1037
1038         struct functable func[] = {
1039                 {
1040                         "add",
1041                         rpc_user_add,
1042                         NET_TRANSPORT_RPC,
1043                         N_("Add specified user"),
1044                         N_("net rpc user add\n"
1045                            "    Add specified user")
1046                 },
1047                 {
1048                         "info",
1049                         rpc_user_info,
1050                         NET_TRANSPORT_RPC,
1051                         N_("List domain groups of user"),
1052                         N_("net rpc user info\n"
1053                            "    List domain groups of user")
1054                 },
1055                 {
1056                         "delete",
1057                         rpc_user_delete,
1058                         NET_TRANSPORT_RPC,
1059                         N_("Remove specified user"),
1060                         N_("net rpc user delete\n"
1061                            "    Remove specified user")
1062                 },
1063                 {
1064                         "password",
1065                         rpc_user_password,
1066                         NET_TRANSPORT_RPC,
1067                         N_("Change user password"),
1068                         N_("net rpc user password\n"
1069                            "    Change user password")
1070                 },
1071                 {
1072                         "rename",
1073                         rpc_user_rename,
1074                         NET_TRANSPORT_RPC,
1075                         N_("Rename specified user"),
1076                         N_("net rpc user rename\n"
1077                            "    Rename specified user")
1078                 },
1079                 {
1080                         "setprimarygroup",
1081                         rpc_user_setprimarygroup,
1082                         NET_TRANSPORT_RPC,
1083                         "Set a user's primary group",
1084                         "net rpc user setprimarygroup\n"
1085                         "    Set a user's primary group"
1086                 },
1087                 {NULL, NULL, 0, NULL, NULL}
1088         };
1089
1090         status = libnetapi_net_init(&c->netapi_ctx);
1091         if (status != 0) {
1092                 return -1;
1093         }
1094         libnetapi_set_username(c->netapi_ctx, c->opt_user_name);
1095         libnetapi_set_password(c->netapi_ctx, c->opt_password);
1096         if (c->opt_kerberos) {
1097                 libnetapi_set_use_kerberos(c->netapi_ctx);
1098         }
1099
1100         if (argc == 0) {
1101                 if (c->display_usage) {
1102                         d_printf(  "%s\n"
1103                                    "net rpc user\n"
1104                                    "    %s\n",
1105                                  _("Usage:"),
1106                                  _("List all users"));
1107                         net_display_usage_from_functable(func);
1108                         return 0;
1109                 }
1110
1111                 return rpc_user_list(c, argc, argv);
1112         }
1113
1114         return net_run_function(c, argc, argv, "net rpc user", func);
1115 }
1116
1117 static NTSTATUS rpc_sh_user_list(struct net_context *c,
1118                                  TALLOC_CTX *mem_ctx,
1119                                  struct rpc_sh_ctx *ctx,
1120                                  struct rpc_pipe_client *pipe_hnd,
1121                                  int argc, const char **argv)
1122 {
1123         return werror_to_ntstatus(W_ERROR(rpc_user_list(c, argc, argv)));
1124 }
1125
1126 static NTSTATUS rpc_sh_user_info(struct net_context *c,
1127                                  TALLOC_CTX *mem_ctx,
1128                                  struct rpc_sh_ctx *ctx,
1129                                  struct rpc_pipe_client *pipe_hnd,
1130                                  int argc, const char **argv)
1131 {
1132         return werror_to_ntstatus(W_ERROR(rpc_user_info(c, argc, argv)));
1133 }
1134
1135 static NTSTATUS rpc_sh_handle_user(struct net_context *c,
1136                                    TALLOC_CTX *mem_ctx,
1137                                    struct rpc_sh_ctx *ctx,
1138                                    struct rpc_pipe_client *pipe_hnd,
1139                                    int argc, const char **argv,
1140                                    NTSTATUS (*fn)(
1141                                            struct net_context *c,
1142                                            TALLOC_CTX *mem_ctx,
1143                                            struct rpc_sh_ctx *ctx,
1144                                            struct rpc_pipe_client *pipe_hnd,
1145                                            struct policy_handle *user_hnd,
1146                                            int argc, const char **argv))
1147 {
1148         struct policy_handle connect_pol, domain_pol, user_pol;
1149         NTSTATUS status, result;
1150         struct dom_sid sid;
1151         uint32 rid;
1152         enum lsa_SidType type;
1153         struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
1154
1155         if (argc == 0) {
1156                 d_fprintf(stderr, "%s %s <username>\n", _("Usage:"),
1157                           ctx->whoami);
1158                 return NT_STATUS_INVALID_PARAMETER;
1159         }
1160
1161         ZERO_STRUCT(connect_pol);
1162         ZERO_STRUCT(domain_pol);
1163         ZERO_STRUCT(user_pol);
1164
1165         status = net_rpc_lookup_name(c, mem_ctx, rpc_pipe_np_smb_conn(pipe_hnd),
1166                                      argv[0], NULL, NULL, &sid, &type);
1167         if (!NT_STATUS_IS_OK(status)) {
1168                 d_fprintf(stderr, _("Could not lookup %s: %s\n"), argv[0],
1169                           nt_errstr(status));
1170                 goto done;
1171         }
1172
1173         if (type != SID_NAME_USER) {
1174                 d_fprintf(stderr, _("%s is a %s, not a user\n"), argv[0],
1175                           sid_type_lookup(type));
1176                 status = NT_STATUS_NO_SUCH_USER;
1177                 goto done;
1178         }
1179
1180         if (!sid_peek_check_rid(ctx->domain_sid, &sid, &rid)) {
1181                 d_fprintf(stderr, _("%s is not in our domain\n"), argv[0]);
1182                 status = NT_STATUS_NO_SUCH_USER;
1183                 goto done;
1184         }
1185
1186         status = dcerpc_samr_Connect2(b, mem_ctx,
1187                                       pipe_hnd->desthost,
1188                                       MAXIMUM_ALLOWED_ACCESS,
1189                                       &connect_pol,
1190                                       &result);
1191         if (!NT_STATUS_IS_OK(status)) {
1192                 goto done;
1193         }
1194         if (!NT_STATUS_IS_OK(result)) {
1195                 status = result;
1196                 goto done;
1197         }
1198
1199         status = dcerpc_samr_OpenDomain(b, mem_ctx,
1200                                         &connect_pol,
1201                                         MAXIMUM_ALLOWED_ACCESS,
1202                                         ctx->domain_sid,
1203                                         &domain_pol,
1204                                         &result);
1205         if (!NT_STATUS_IS_OK(status)) {
1206                 goto done;
1207         }
1208         if (!NT_STATUS_IS_OK(result)) {
1209                 status = result;
1210                 goto done;
1211         }
1212
1213         status = dcerpc_samr_OpenUser(b, mem_ctx,
1214                                       &domain_pol,
1215                                       MAXIMUM_ALLOWED_ACCESS,
1216                                       rid,
1217                                       &user_pol,
1218                                       &result);
1219         if (!NT_STATUS_IS_OK(status)) {
1220                 goto done;
1221         }
1222         if (!NT_STATUS_IS_OK(result)) {
1223                 status = result;
1224                 goto done;
1225         }
1226
1227         status = fn(c, mem_ctx, ctx, pipe_hnd, &user_pol, argc-1, argv+1);
1228
1229  done:
1230         if (is_valid_policy_hnd(&user_pol)) {
1231                 dcerpc_samr_Close(b, mem_ctx, &user_pol, &result);
1232         }
1233         if (is_valid_policy_hnd(&domain_pol)) {
1234                 dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
1235         }
1236         if (is_valid_policy_hnd(&connect_pol)) {
1237                 dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
1238         }
1239         return status;
1240 }
1241
1242 static NTSTATUS rpc_sh_user_show_internals(struct net_context *c,
1243                                            TALLOC_CTX *mem_ctx,
1244                                            struct rpc_sh_ctx *ctx,
1245                                            struct rpc_pipe_client *pipe_hnd,
1246                                            struct policy_handle *user_hnd,
1247                                            int argc, const char **argv)
1248 {
1249         NTSTATUS status, result;
1250         union samr_UserInfo *info = NULL;
1251         struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
1252
1253         if (argc != 0) {
1254                 d_fprintf(stderr, "%s %s show <username>\n", _("Usage:"),
1255                           ctx->whoami);
1256                 return NT_STATUS_INVALID_PARAMETER;
1257         }
1258
1259         status = dcerpc_samr_QueryUserInfo(b, mem_ctx,
1260                                            user_hnd,
1261                                            21,
1262                                            &info,
1263                                            &result);
1264         if (!NT_STATUS_IS_OK(status)) {
1265                 return status;
1266         }
1267         if (!NT_STATUS_IS_OK(result)) {
1268                 return result;
1269         }
1270
1271         d_printf(_("user rid: %d, group rid: %d\n"),
1272                 info->info21.rid,
1273                 info->info21.primary_gid);
1274
1275         return result;
1276 }
1277
1278 static NTSTATUS rpc_sh_user_show(struct net_context *c,
1279                                  TALLOC_CTX *mem_ctx,
1280                                  struct rpc_sh_ctx *ctx,
1281                                  struct rpc_pipe_client *pipe_hnd,
1282                                  int argc, const char **argv)
1283 {
1284         return rpc_sh_handle_user(c, mem_ctx, ctx, pipe_hnd, argc, argv,
1285                                   rpc_sh_user_show_internals);
1286 }
1287
1288 #define FETCHSTR(name, rec) \
1289 do { if (strequal(ctx->thiscmd, name)) { \
1290         oldval = talloc_strdup(mem_ctx, info->info21.rec.string); } \
1291 } while (0);
1292
1293 #define SETSTR(name, rec, flag) \
1294 do { if (strequal(ctx->thiscmd, name)) { \
1295         init_lsa_String(&(info->info21.rec), argv[0]); \
1296         info->info21.fields_present |= SAMR_FIELD_##flag; } \
1297 } while (0);
1298
1299 static NTSTATUS rpc_sh_user_str_edit_internals(struct net_context *c,
1300                                                TALLOC_CTX *mem_ctx,
1301                                                struct rpc_sh_ctx *ctx,
1302                                                struct rpc_pipe_client *pipe_hnd,
1303                                                struct policy_handle *user_hnd,
1304                                                int argc, const char **argv)
1305 {
1306         NTSTATUS status, result;
1307         const char *username;
1308         const char *oldval = "";
1309         union samr_UserInfo *info = NULL;
1310         struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
1311
1312         if (argc > 1) {
1313                 d_fprintf(stderr, "%s %s <username> [new value|NULL]\n",
1314                           _("Usage:"), ctx->whoami);
1315                 return NT_STATUS_INVALID_PARAMETER;
1316         }
1317
1318         status = dcerpc_samr_QueryUserInfo(b, mem_ctx,
1319                                            user_hnd,
1320                                            21,
1321                                            &info,
1322                                            &result);
1323         if (!NT_STATUS_IS_OK(status)) {
1324                 return status;
1325         }
1326         if (!NT_STATUS_IS_OK(result)) {
1327                 return result;
1328         }
1329
1330         username = talloc_strdup(mem_ctx, info->info21.account_name.string);
1331
1332         FETCHSTR("fullname", full_name);
1333         FETCHSTR("homedir", home_directory);
1334         FETCHSTR("homedrive", home_drive);
1335         FETCHSTR("logonscript", logon_script);
1336         FETCHSTR("profilepath", profile_path);
1337         FETCHSTR("description", description);
1338
1339         if (argc == 0) {
1340                 d_printf(_("%s's %s: [%s]\n"), username, ctx->thiscmd, oldval);
1341                 goto done;
1342         }
1343
1344         if (strcmp(argv[0], "NULL") == 0) {
1345                 argv[0] = "";
1346         }
1347
1348         ZERO_STRUCT(info->info21);
1349
1350         SETSTR("fullname", full_name, FULL_NAME);
1351         SETSTR("homedir", home_directory, HOME_DIRECTORY);
1352         SETSTR("homedrive", home_drive, HOME_DRIVE);
1353         SETSTR("logonscript", logon_script, LOGON_SCRIPT);
1354         SETSTR("profilepath", profile_path, PROFILE_PATH);
1355         SETSTR("description", description, DESCRIPTION);
1356
1357         status = dcerpc_samr_SetUserInfo(b, mem_ctx,
1358                                          user_hnd,
1359                                          21,
1360                                          info,
1361                                          &result);
1362         if (!NT_STATUS_IS_OK(status)) {
1363                 return status;
1364         }
1365
1366         status = result;
1367
1368         d_printf(_("Set %s's %s from [%s] to [%s]\n"), username,
1369                  ctx->thiscmd, oldval, argv[0]);
1370
1371  done:
1372
1373         return status;
1374 }
1375
1376 #define HANDLEFLG(name, rec) \
1377 do { if (strequal(ctx->thiscmd, name)) { \
1378         oldval = (oldflags & ACB_##rec) ? "yes" : "no"; \
1379         if (newval) { \
1380                 newflags = oldflags | ACB_##rec; \
1381         } else { \
1382                 newflags = oldflags & ~ACB_##rec; \
1383         } } } while (0);
1384
1385 static NTSTATUS rpc_sh_user_str_edit(struct net_context *c,
1386                                      TALLOC_CTX *mem_ctx,
1387                                      struct rpc_sh_ctx *ctx,
1388                                      struct rpc_pipe_client *pipe_hnd,
1389                                      int argc, const char **argv)
1390 {
1391         return rpc_sh_handle_user(c, mem_ctx, ctx, pipe_hnd, argc, argv,
1392                                   rpc_sh_user_str_edit_internals);
1393 }
1394
1395 static NTSTATUS rpc_sh_user_flag_edit_internals(struct net_context *c,
1396                                                 TALLOC_CTX *mem_ctx,
1397                                                 struct rpc_sh_ctx *ctx,
1398                                                 struct rpc_pipe_client *pipe_hnd,
1399                                                 struct policy_handle *user_hnd,
1400                                                 int argc, const char **argv)
1401 {
1402         NTSTATUS status, result;
1403         const char *username;
1404         const char *oldval = "unknown";
1405         uint32 oldflags, newflags;
1406         bool newval;
1407         union samr_UserInfo *info = NULL;
1408         struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
1409
1410         if ((argc > 1) ||
1411             ((argc == 1) && !strequal(argv[0], "yes") &&
1412              !strequal(argv[0], "no"))) {
1413                 /* TRANSATORS: The yes|no here are program keywords. Please do
1414                    not translate. */
1415                 d_fprintf(stderr, _("Usage: %s <username> [yes|no]\n"),
1416                           ctx->whoami);
1417                 return NT_STATUS_INVALID_PARAMETER;
1418         }
1419
1420         newval = strequal(argv[0], "yes");
1421
1422         status = dcerpc_samr_QueryUserInfo(b, mem_ctx,
1423                                            user_hnd,
1424                                            21,
1425                                            &info,
1426                                            &result);
1427         if (!NT_STATUS_IS_OK(status)) {
1428                 return status;
1429         }
1430         if (!NT_STATUS_IS_OK(result)) {
1431                 return result;
1432         }
1433
1434         username = talloc_strdup(mem_ctx, info->info21.account_name.string);
1435         oldflags = info->info21.acct_flags;
1436         newflags = info->info21.acct_flags;
1437
1438         HANDLEFLG("disabled", DISABLED);
1439         HANDLEFLG("pwnotreq", PWNOTREQ);
1440         HANDLEFLG("autolock", AUTOLOCK);
1441         HANDLEFLG("pwnoexp", PWNOEXP);
1442
1443         if (argc == 0) {
1444                 d_printf(_("%s's %s flag: %s\n"), username, ctx->thiscmd,
1445                          oldval);
1446                 goto done;
1447         }
1448
1449         ZERO_STRUCT(info->info21);
1450
1451         info->info21.acct_flags = newflags;
1452         info->info21.fields_present = SAMR_FIELD_ACCT_FLAGS;
1453
1454         status = dcerpc_samr_SetUserInfo(b, mem_ctx,
1455                                          user_hnd,
1456                                          21,
1457                                          info,
1458                                          &result);
1459         if (!NT_STATUS_IS_OK(status)) {
1460                 goto done;
1461         }
1462         status = result;
1463         if (NT_STATUS_IS_OK(result)) {
1464                 d_printf(_("Set %s's %s flag from [%s] to [%s]\n"), username,
1465                          ctx->thiscmd, oldval, argv[0]);
1466         }
1467
1468  done:
1469
1470         return status;
1471 }
1472
1473 static NTSTATUS rpc_sh_user_flag_edit(struct net_context *c,
1474                                       TALLOC_CTX *mem_ctx,
1475                                       struct rpc_sh_ctx *ctx,
1476                                       struct rpc_pipe_client *pipe_hnd,
1477                                       int argc, const char **argv)
1478 {
1479         return rpc_sh_handle_user(c, mem_ctx, ctx, pipe_hnd, argc, argv,
1480                                   rpc_sh_user_flag_edit_internals);
1481 }
1482
1483 struct rpc_sh_cmd *net_rpc_user_edit_cmds(struct net_context *c,
1484                                           TALLOC_CTX *mem_ctx,
1485                                           struct rpc_sh_ctx *ctx)
1486 {
1487         static struct rpc_sh_cmd cmds[] = {
1488
1489                 { "fullname", NULL, &ndr_table_samr.syntax_id, rpc_sh_user_str_edit,
1490                   N_("Show/Set a user's full name") },
1491
1492                 { "homedir", NULL, &ndr_table_samr.syntax_id, rpc_sh_user_str_edit,
1493                   N_("Show/Set a user's home directory") },
1494
1495                 { "homedrive", NULL, &ndr_table_samr.syntax_id, rpc_sh_user_str_edit,
1496                   N_("Show/Set a user's home drive") },
1497
1498                 { "logonscript", NULL, &ndr_table_samr.syntax_id, rpc_sh_user_str_edit,
1499                   N_("Show/Set a user's logon script") },
1500
1501                 { "profilepath", NULL, &ndr_table_samr.syntax_id, rpc_sh_user_str_edit,
1502                   N_("Show/Set a user's profile path") },
1503
1504                 { "description", NULL, &ndr_table_samr.syntax_id, rpc_sh_user_str_edit,
1505                   N_("Show/Set a user's description") },
1506
1507                 { "disabled", NULL, &ndr_table_samr.syntax_id, rpc_sh_user_flag_edit,
1508                   N_("Show/Set whether a user is disabled") },
1509
1510                 { "autolock", NULL, &ndr_table_samr.syntax_id, rpc_sh_user_flag_edit,
1511                   N_("Show/Set whether a user locked out") },
1512
1513                 { "pwnotreq", NULL, &ndr_table_samr.syntax_id, rpc_sh_user_flag_edit,
1514                   N_("Show/Set whether a user does not need a password") },
1515
1516                 { "pwnoexp", NULL, &ndr_table_samr.syntax_id, rpc_sh_user_flag_edit,
1517                   N_("Show/Set whether a user's password does not expire") },
1518
1519                 { NULL, NULL, 0, NULL, NULL }
1520         };
1521
1522         return cmds;
1523 }
1524
1525 struct rpc_sh_cmd *net_rpc_user_cmds(struct net_context *c,
1526                                      TALLOC_CTX *mem_ctx,
1527                                      struct rpc_sh_ctx *ctx)
1528 {
1529         static struct rpc_sh_cmd cmds[] = {
1530
1531                 { "list", NULL, &ndr_table_samr.syntax_id, rpc_sh_user_list,
1532                   N_("List available users") },
1533
1534                 { "info", NULL, &ndr_table_samr.syntax_id, rpc_sh_user_info,
1535                   N_("List the domain groups a user is member of") },
1536
1537                 { "show", NULL, &ndr_table_samr.syntax_id, rpc_sh_user_show,
1538                   N_("Show info about a user") },
1539
1540                 { "edit", net_rpc_user_edit_cmds, 0, NULL,
1541                   N_("Show/Modify a user's fields") },
1542
1543                 { NULL, NULL, 0, NULL, NULL }
1544         };
1545
1546         return cmds;
1547 }
1548
1549 /****************************************************************************/
1550
1551 /**
1552  * Basic usage function for 'net rpc group'.
1553  * @param argc  Standard main() style argc.
1554  * @param argv  Standard main() style argv. Initial components are already
1555  *              stripped.
1556  **/
1557
1558 static int rpc_group_usage(struct net_context *c, int argc, const char **argv)
1559 {
1560         return net_group_usage(c, argc, argv);
1561 }
1562
1563 /**
1564  * Delete group on a remote RPC server.
1565  *
1566  * All parameters are provided by the run_rpc_command function, except for
1567  * argc, argv which are passed through.
1568  *
1569  * @param domain_sid The domain sid acquired from the remote server.
1570  * @param cli A cli_state connected to the server.
1571  * @param mem_ctx Talloc context, destroyed on completion of the function.
1572  * @param argc  Standard main() style argc.
1573  * @param argv  Standard main() style argv. Initial components are already
1574  *              stripped.
1575  *
1576  * @return Normal NTSTATUS return.
1577  **/
1578
1579 static NTSTATUS rpc_group_delete_internals(struct net_context *c,
1580                                         const struct dom_sid *domain_sid,
1581                                         const char *domain_name,
1582                                         struct cli_state *cli,
1583                                         struct rpc_pipe_client *pipe_hnd,
1584                                         TALLOC_CTX *mem_ctx,
1585                                         int argc,
1586                                         const char **argv)
1587 {
1588         struct policy_handle connect_pol, domain_pol, group_pol, user_pol;
1589         bool group_is_primary = false;
1590         NTSTATUS status, result;
1591         uint32_t group_rid;
1592         struct samr_RidAttrArray *rids = NULL;
1593         /* char **names; */
1594         int i;
1595         /* struct samr_RidWithAttribute *user_gids; */
1596         struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
1597
1598         struct samr_Ids group_rids, name_types;
1599         struct lsa_String lsa_acct_name;
1600         union samr_UserInfo *info = NULL;
1601
1602         if (argc < 1 || c->display_usage) {
1603                 rpc_group_usage(c, argc,argv);
1604                 return NT_STATUS_OK; /* ok? */
1605         }
1606
1607         status = dcerpc_samr_Connect2(b, mem_ctx,
1608                                       pipe_hnd->desthost,
1609                                       MAXIMUM_ALLOWED_ACCESS,
1610                                       &connect_pol,
1611                                       &result);
1612         if (!NT_STATUS_IS_OK(status)) {
1613                 d_fprintf(stderr, _("Request samr_Connect2 failed\n"));
1614                 goto done;
1615         }
1616
1617         if (!NT_STATUS_IS_OK(result)) {
1618                 status = result;
1619                 d_fprintf(stderr, _("Request samr_Connect2 failed\n"));
1620                 goto done;
1621         }
1622
1623         status = dcerpc_samr_OpenDomain(b, mem_ctx,
1624                                         &connect_pol,
1625                                         MAXIMUM_ALLOWED_ACCESS,
1626                                         discard_const_p(struct dom_sid2, domain_sid),
1627                                         &domain_pol,
1628                                         &result);
1629         if (!NT_STATUS_IS_OK(status)) {
1630                 d_fprintf(stderr, _("Request open_domain failed\n"));
1631                 goto done;
1632         }
1633
1634         if (!NT_STATUS_IS_OK(result)) {
1635                 status = result;
1636                 d_fprintf(stderr, _("Request open_domain failed\n"));
1637                 goto done;
1638         }
1639
1640         init_lsa_String(&lsa_acct_name, argv[0]);
1641
1642         status = dcerpc_samr_LookupNames(b, mem_ctx,
1643                                          &domain_pol,
1644                                          1,
1645                                          &lsa_acct_name,
1646                                          &group_rids,
1647                                          &name_types,
1648                                          &result);
1649         if (!NT_STATUS_IS_OK(status)) {
1650                 d_fprintf(stderr, _("Lookup of '%s' failed\n"),argv[0]);
1651                 goto done;
1652         }
1653
1654         if (!NT_STATUS_IS_OK(result)) {
1655                 status = result;
1656                 d_fprintf(stderr, _("Lookup of '%s' failed\n"),argv[0]);
1657                 goto done;
1658         }
1659
1660         switch (name_types.ids[0])
1661         {
1662         case SID_NAME_DOM_GRP:
1663                 status = dcerpc_samr_OpenGroup(b, mem_ctx,
1664                                                &domain_pol,
1665                                                MAXIMUM_ALLOWED_ACCESS,
1666                                                group_rids.ids[0],
1667                                                &group_pol,
1668                                                &result);
1669                 if (!NT_STATUS_IS_OK(status)) {
1670                         d_fprintf(stderr, _("Request open_group failed"));
1671                         goto done;
1672                 }
1673
1674                 if (!NT_STATUS_IS_OK(result)) {
1675                         status = result;
1676                         d_fprintf(stderr, _("Request open_group failed"));
1677                         goto done;
1678                 }
1679
1680                 group_rid = group_rids.ids[0];
1681
1682                 status = dcerpc_samr_QueryGroupMember(b, mem_ctx,
1683                                                       &group_pol,
1684                                                       &rids,
1685                                                       &result);
1686                 if (!NT_STATUS_IS_OK(status)) {
1687                         d_fprintf(stderr,
1688                                   _("Unable to query group members of %s"),
1689                                   argv[0]);
1690                         goto done;
1691                 }
1692
1693                 if (!NT_STATUS_IS_OK(result)) {
1694                         status = result;
1695                         d_fprintf(stderr,
1696                                   _("Unable to query group members of %s"),
1697                                   argv[0]);
1698                         goto done;
1699                 }
1700
1701                 if (c->opt_verbose) {
1702                         d_printf(
1703                                 _("Domain Group %s (rid: %d) has %d members\n"),
1704                                 argv[0],group_rid, rids->count);
1705                 }
1706
1707                 /* Check if group is anyone's primary group */
1708                 for (i = 0; i < rids->count; i++)
1709                 {
1710                         status = dcerpc_samr_OpenUser(b, mem_ctx,
1711                                                       &domain_pol,
1712                                                       MAXIMUM_ALLOWED_ACCESS,
1713                                                       rids->rids[i],
1714                                                       &user_pol,
1715                                                       &result);
1716                         if (!NT_STATUS_IS_OK(status)) {
1717                                 d_fprintf(stderr,
1718                                         _("Unable to open group member %d\n"),
1719                                         rids->rids[i]);
1720                                 goto done;
1721                         }
1722
1723                         if (!NT_STATUS_IS_OK(result)) {
1724                                 status = result;
1725                                 d_fprintf(stderr,
1726                                         _("Unable to open group member %d\n"),
1727                                         rids->rids[i]);
1728                                 goto done;
1729                         }
1730
1731                         status = dcerpc_samr_QueryUserInfo(b, mem_ctx,
1732                                                            &user_pol,
1733                                                            21,
1734                                                            &info,
1735                                                            &result);
1736                         if (!NT_STATUS_IS_OK(status)) {
1737                                 d_fprintf(stderr,
1738                                         _("Unable to lookup userinfo for group "
1739                                           "member %d\n"),
1740                                         rids->rids[i]);
1741                                 goto done;
1742                         }
1743
1744                         if (!NT_STATUS_IS_OK(result)) {
1745                                 status = result;
1746                                 d_fprintf(stderr,
1747                                         _("Unable to lookup userinfo for group "
1748                                           "member %d\n"),
1749                                         rids->rids[i]);
1750                                 goto done;
1751                         }
1752
1753                         if (info->info21.primary_gid == group_rid) {
1754                                 if (c->opt_verbose) {
1755                                         d_printf(_("Group is primary group "
1756                                                    "of %s\n"),
1757                                                 info->info21.account_name.string);
1758                                 }
1759                                 group_is_primary = true;
1760                         }
1761
1762                         dcerpc_samr_Close(b, mem_ctx, &user_pol, &result);
1763                 }
1764
1765                 if (group_is_primary) {
1766                         d_fprintf(stderr, _("Unable to delete group because "
1767                                  "some of it's members have it as primary "
1768                                  "group\n"));
1769                         status = NT_STATUS_MEMBERS_PRIMARY_GROUP;
1770                         goto done;
1771                 }
1772
1773                 /* remove all group members */
1774                 for (i = 0; i < rids->count; i++)
1775                 {
1776                         if (c->opt_verbose)
1777                                 d_printf(_("Remove group member %d..."),
1778                                         rids->rids[i]);
1779                         status = dcerpc_samr_DeleteGroupMember(b, mem_ctx,
1780                                                                &group_pol,
1781                                                                rids->rids[i],
1782                                                                &result);
1783                         if (!NT_STATUS_IS_OK(status)) {
1784                                 goto done;
1785                         }
1786                         status = result;
1787                         if (NT_STATUS_IS_OK(result)) {
1788                                 if (c->opt_verbose)
1789                                         d_printf(_("ok\n"));
1790                         } else {
1791                                 if (c->opt_verbose)
1792                                         d_printf("%s\n", _("failed"));
1793                                 goto done;
1794                         }
1795                 }
1796
1797                 status = dcerpc_samr_DeleteDomainGroup(b, mem_ctx,
1798                                                        &group_pol,
1799                                                        &result);
1800                 if (!NT_STATUS_IS_OK(status)) {
1801                         break;
1802                 }
1803
1804                 status = result;
1805
1806                 break;
1807         /* removing a local group is easier... */
1808         case SID_NAME_ALIAS:
1809                 status = dcerpc_samr_OpenAlias(b, mem_ctx,
1810                                                &domain_pol,
1811                                                MAXIMUM_ALLOWED_ACCESS,
1812                                                group_rids.ids[0],
1813                                                &group_pol,
1814                                                &result);
1815                 if (!NT_STATUS_IS_OK(status)) {
1816                         d_fprintf(stderr, _("Request open_alias failed\n"));
1817                         goto done;
1818                 }
1819                 if (!NT_STATUS_IS_OK(result)) {
1820                         status = result;
1821                         d_fprintf(stderr, _("Request open_alias failed\n"));
1822                         goto done;
1823                 }
1824
1825                 status = dcerpc_samr_DeleteDomAlias(b, mem_ctx,
1826                                                     &group_pol,
1827                                                     &result);
1828                 if (!NT_STATUS_IS_OK(status)) {
1829                         break;
1830                 }
1831
1832                 status = result;
1833
1834                 break;
1835         default:
1836                 d_fprintf(stderr, _("%s is of type %s. This command is only "
1837                                     "for deleting local or global groups\n"),
1838                         argv[0],sid_type_lookup(name_types.ids[0]));
1839                 status = NT_STATUS_UNSUCCESSFUL;
1840                 goto done;
1841         }
1842
1843         if (NT_STATUS_IS_OK(status)) {
1844                 if (c->opt_verbose)
1845                         d_printf(_("Deleted %s '%s'\n"),
1846                                  sid_type_lookup(name_types.ids[0]), argv[0]);
1847         } else {
1848                 d_fprintf(stderr, _("Deleting of %s failed: %s\n"), argv[0],
1849                         get_friendly_nt_error_msg(status));
1850         }
1851
1852  done:
1853         return status;
1854
1855 }
1856
1857 static int rpc_group_delete(struct net_context *c, int argc, const char **argv)
1858 {
1859         return run_rpc_command(c, NULL, &ndr_table_samr.syntax_id, 0,
1860                                rpc_group_delete_internals, argc,argv);
1861 }
1862
1863 static int rpc_group_add_internals(struct net_context *c, int argc, const char **argv)
1864 {
1865         NET_API_STATUS status;
1866         struct GROUP_INFO_1 info1;
1867         uint32_t parm_error = 0;
1868
1869         if (argc != 1 || c->display_usage) {
1870                 rpc_group_usage(c, argc, argv);
1871                 return 0;
1872         }
1873
1874         ZERO_STRUCT(info1);
1875
1876         info1.grpi1_name = argv[0];
1877         if (c->opt_comment && strlen(c->opt_comment) > 0) {
1878                 info1.grpi1_comment = c->opt_comment;
1879         }
1880
1881         status = NetGroupAdd(c->opt_host, 1, (uint8_t *)&info1, &parm_error);
1882
1883         if (status != 0) {
1884                 d_fprintf(stderr,
1885                         _("Failed to add group '%s' with error: %s.\n"),
1886                         argv[0], libnetapi_get_error_string(c->netapi_ctx,
1887                                                             status));
1888                 return -1;
1889         } else {
1890                 d_printf(_("Added group '%s'.\n"), argv[0]);
1891         }
1892
1893         return 0;
1894 }
1895
1896 static int rpc_alias_add_internals(struct net_context *c, int argc, const char **argv)
1897 {
1898         NET_API_STATUS status;
1899         struct LOCALGROUP_INFO_1 info1;
1900         uint32_t parm_error = 0;
1901
1902         if (argc != 1 || c->display_usage) {
1903                 rpc_group_usage(c, argc, argv);
1904                 return 0;
1905         }
1906
1907         ZERO_STRUCT(info1);
1908
1909         info1.lgrpi1_name = argv[0];
1910         if (c->opt_comment && strlen(c->opt_comment) > 0) {
1911                 info1.lgrpi1_comment = c->opt_comment;
1912         }
1913
1914         status = NetLocalGroupAdd(c->opt_host, 1, (uint8_t *)&info1, &parm_error);
1915
1916         if (status != 0) {
1917                 d_fprintf(stderr,
1918                         _("Failed to add alias '%s' with error: %s.\n"),
1919                         argv[0], libnetapi_get_error_string(c->netapi_ctx,
1920                                                             status));
1921                 return -1;
1922         } else {
1923                 d_printf(_("Added alias '%s'.\n"), argv[0]);
1924         }
1925
1926         return 0;
1927 }
1928
1929 static int rpc_group_add(struct net_context *c, int argc, const char **argv)
1930 {
1931         if (c->opt_localgroup)
1932                 return rpc_alias_add_internals(c, argc, argv);
1933
1934         return rpc_group_add_internals(c, argc, argv);
1935 }
1936
1937 static NTSTATUS get_sid_from_name(struct cli_state *cli,
1938                                 TALLOC_CTX *mem_ctx,
1939                                 const char *name,
1940                                 struct dom_sid *sid,
1941                                 enum lsa_SidType *type)
1942 {
1943         struct dom_sid *sids = NULL;
1944         enum lsa_SidType *types = NULL;
1945         struct rpc_pipe_client *pipe_hnd = NULL;
1946         struct policy_handle lsa_pol;
1947         NTSTATUS status, result;
1948         struct dcerpc_binding_handle *b;
1949
1950         status = cli_rpc_pipe_open_noauth(cli, &ndr_table_lsarpc.syntax_id,
1951                                           &pipe_hnd);
1952         if (!NT_STATUS_IS_OK(status)) {
1953                 goto done;
1954         }
1955
1956         b = pipe_hnd->binding_handle;
1957
1958         status = rpccli_lsa_open_policy(pipe_hnd, mem_ctx, false,
1959                                      SEC_FLAG_MAXIMUM_ALLOWED, &lsa_pol);
1960
1961         if (!NT_STATUS_IS_OK(status)) {
1962                 goto done;
1963         }
1964
1965         status = rpccli_lsa_lookup_names(pipe_hnd, mem_ctx, &lsa_pol, 1,
1966                                       &name, NULL, 1, &sids, &types);
1967
1968         if (NT_STATUS_IS_OK(status)) {
1969                 sid_copy(sid, &sids[0]);
1970                 *type = types[0];
1971         }
1972
1973         dcerpc_lsa_Close(b, mem_ctx, &lsa_pol, &result);
1974
1975  done:
1976         if (pipe_hnd) {
1977                 TALLOC_FREE(pipe_hnd);
1978         }
1979
1980         if (!NT_STATUS_IS_OK(status) && (strncasecmp_m(name, "S-", 2) == 0)) {
1981
1982                 /* Try as S-1-5-whatever */
1983
1984                 struct dom_sid tmp_sid;
1985
1986                 if (string_to_sid(&tmp_sid, name)) {
1987                         sid_copy(sid, &tmp_sid);
1988                         *type = SID_NAME_UNKNOWN;
1989                         status = NT_STATUS_OK;
1990                 }
1991         }
1992
1993         return status;
1994 }
1995
1996 static NTSTATUS rpc_add_groupmem(struct rpc_pipe_client *pipe_hnd,
1997                                 TALLOC_CTX *mem_ctx,
1998                                 const struct dom_sid *group_sid,
1999                                 const char *member)
2000 {
2001         struct policy_handle connect_pol, domain_pol;
2002         NTSTATUS status, result;
2003         uint32 group_rid;
2004         struct policy_handle group_pol;
2005         struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
2006
2007         struct samr_Ids rids, rid_types;
2008         struct lsa_String lsa_acct_name;
2009
2010         struct dom_sid sid;
2011
2012         sid_copy(&sid, group_sid);
2013
2014         if (!sid_split_rid(&sid, &group_rid)) {
2015                 return NT_STATUS_UNSUCCESSFUL;
2016         }
2017
2018         /* Get sam policy handle */
2019         status = dcerpc_samr_Connect2(b, mem_ctx,
2020                                       pipe_hnd->desthost,
2021                                       MAXIMUM_ALLOWED_ACCESS,
2022                                       &connect_pol,
2023                                       &result);
2024         if (!NT_STATUS_IS_OK(status)) {
2025                 return status;
2026         }
2027         if (!NT_STATUS_IS_OK(result)) {
2028                 return result;
2029         }
2030
2031         /* Get domain policy handle */
2032         status = dcerpc_samr_OpenDomain(b, mem_ctx,
2033                                         &connect_pol,
2034                                         MAXIMUM_ALLOWED_ACCESS,
2035                                         &sid,
2036                                         &domain_pol,
2037                                         &result);
2038         if (!NT_STATUS_IS_OK(status)) {
2039                 return status;
2040         }
2041         if (!NT_STATUS_IS_OK(result)) {
2042                 return result;
2043         }
2044
2045         init_lsa_String(&lsa_acct_name, member);
2046
2047         status = dcerpc_samr_LookupNames(b, mem_ctx,
2048                                          &domain_pol,
2049                                          1,
2050                                          &lsa_acct_name,
2051                                          &rids,
2052                                          &rid_types,
2053                                          &result);
2054         if (!NT_STATUS_IS_OK(status)) {
2055                 d_fprintf(stderr, _("Could not lookup up group member %s\n"),
2056                           member);
2057                 goto done;
2058         }
2059
2060         if (!NT_STATUS_IS_OK(result)) {
2061                 status = result;
2062                 d_fprintf(stderr, _("Could not lookup up group member %s\n"),
2063                           member);
2064                 goto done;
2065         }
2066
2067         status = dcerpc_samr_OpenGroup(b, mem_ctx,
2068                                        &domain_pol,
2069                                        MAXIMUM_ALLOWED_ACCESS,
2070                                        group_rid,
2071                                        &group_pol,
2072                                        &result);
2073         if (!NT_STATUS_IS_OK(status)) {
2074                 goto done;
2075         }
2076
2077         if (!NT_STATUS_IS_OK(result)) {
2078                 status = result;
2079                 goto done;
2080         }
2081
2082         status = dcerpc_samr_AddGroupMember(b, mem_ctx,
2083                                             &group_pol,
2084                                             rids.ids[0],
2085                                             0x0005, /* unknown flags */
2086                                             &result);
2087         if (!NT_STATUS_IS_OK(status)) {
2088                 goto done;
2089         }
2090
2091         status = result;
2092
2093  done:
2094         dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
2095         return status;
2096 }
2097
2098 static NTSTATUS rpc_add_aliasmem(struct rpc_pipe_client *pipe_hnd,
2099                                 TALLOC_CTX *mem_ctx,
2100                                 const struct dom_sid *alias_sid,
2101                                 const char *member)
2102 {
2103         struct policy_handle connect_pol, domain_pol;
2104         NTSTATUS status, result;
2105         uint32 alias_rid;
2106         struct policy_handle alias_pol;
2107         struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
2108
2109         struct dom_sid member_sid;
2110         enum lsa_SidType member_type;
2111
2112         struct dom_sid sid;
2113
2114         sid_copy(&sid, alias_sid);
2115
2116         if (!sid_split_rid(&sid, &alias_rid)) {
2117                 return NT_STATUS_UNSUCCESSFUL;
2118         }
2119
2120         result = get_sid_from_name(rpc_pipe_np_smb_conn(pipe_hnd), mem_ctx,
2121                                    member, &member_sid, &member_type);
2122
2123         if (!NT_STATUS_IS_OK(result)) {
2124                 d_fprintf(stderr, _("Could not lookup up group member %s\n"),
2125                           member);
2126                 return result;
2127         }
2128
2129         /* Get sam policy handle */
2130         status = dcerpc_samr_Connect2(b, mem_ctx,
2131                                       pipe_hnd->desthost,
2132                                       MAXIMUM_ALLOWED_ACCESS,
2133                                       &connect_pol,
2134                                       &result);
2135         if (!NT_STATUS_IS_OK(status)) {
2136                 goto done;
2137         }
2138         if (!NT_STATUS_IS_OK(result)) {
2139                 status = result;
2140                 goto done;
2141         }
2142
2143         /* Get domain policy handle */
2144         status = dcerpc_samr_OpenDomain(b, mem_ctx,
2145                                         &connect_pol,
2146                                         MAXIMUM_ALLOWED_ACCESS,
2147                                         &sid,
2148                                         &domain_pol,
2149                                         &result);
2150         if (!NT_STATUS_IS_OK(status)) {
2151                 goto done;
2152         }
2153         if (!NT_STATUS_IS_OK(result)) {
2154                 status = result;
2155                 goto done;
2156         }
2157
2158         status = dcerpc_samr_OpenAlias(b, mem_ctx,
2159                                        &domain_pol,
2160                                        MAXIMUM_ALLOWED_ACCESS,
2161                                        alias_rid,
2162                                        &alias_pol,
2163                                        &result);
2164         if (!NT_STATUS_IS_OK(status)) {
2165                 return status;
2166         }
2167         if (!NT_STATUS_IS_OK(result)) {
2168                 return result;
2169         }
2170
2171         status = dcerpc_samr_AddAliasMember(b, mem_ctx,
2172                                             &alias_pol,
2173                                             &member_sid,
2174                                             &result);
2175         if (!NT_STATUS_IS_OK(status)) {
2176                 return status;
2177         }
2178
2179         status = result;
2180
2181  done:
2182         dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
2183         return status;
2184 }
2185
2186 static NTSTATUS rpc_group_addmem_internals(struct net_context *c,
2187                                         const struct dom_sid *domain_sid,
2188                                         const char *domain_name,
2189                                         struct cli_state *cli,
2190                                         struct rpc_pipe_client *pipe_hnd,
2191                                         TALLOC_CTX *mem_ctx,
2192                                         int argc,
2193                                         const char **argv)
2194 {
2195         struct dom_sid group_sid;
2196         enum lsa_SidType group_type;
2197
2198         if (argc != 2 || c->display_usage) {
2199                 d_printf("%s\n%s",
2200                          _("Usage:"),
2201                          _("net rpc group addmem <group> <member>\n"
2202                            "  Add a member to a group\n"
2203                            "    group\tGroup to add member to\n"
2204                            "    member\tMember to add to group\n"));
2205                 return NT_STATUS_UNSUCCESSFUL;
2206         }
2207
2208         if (!NT_STATUS_IS_OK(get_sid_from_name(cli, mem_ctx, argv[0],
2209                                                &group_sid, &group_type))) {
2210                 d_fprintf(stderr, _("Could not lookup group name %s\n"),
2211                           argv[0]);
2212                 return NT_STATUS_UNSUCCESSFUL;
2213         }
2214
2215         if (group_type == SID_NAME_DOM_GRP) {
2216                 NTSTATUS result = rpc_add_groupmem(pipe_hnd, mem_ctx,
2217                                                    &group_sid, argv[1]);
2218
2219                 if (!NT_STATUS_IS_OK(result)) {
2220                         d_fprintf(stderr, _("Could not add %s to %s: %s\n"),
2221                                  argv[1], argv[0], nt_errstr(result));
2222                 }
2223                 return result;
2224         }
2225
2226         if (group_type == SID_NAME_ALIAS) {
2227                 NTSTATUS result = rpc_add_aliasmem(pipe_hnd, mem_ctx,
2228                                                    &group_sid, argv[1]);
2229
2230                 if (!NT_STATUS_IS_OK(result)) {
2231                         d_fprintf(stderr, _("Could not add %s to %s: %s\n"),
2232                                  argv[1], argv[0], nt_errstr(result));
2233                 }
2234                 return result;
2235         }
2236
2237         d_fprintf(stderr, _("Can only add members to global or local groups "
2238                  "which %s is not\n"), argv[0]);
2239
2240         return NT_STATUS_UNSUCCESSFUL;
2241 }
2242
2243 static int rpc_group_addmem(struct net_context *c, int argc, const char **argv)
2244 {
2245         return run_rpc_command(c, NULL, &ndr_table_samr.syntax_id, 0,
2246                                rpc_group_addmem_internals,
2247                                argc, argv);
2248 }
2249
2250 static NTSTATUS rpc_del_groupmem(struct net_context *c,
2251                                 struct rpc_pipe_client *pipe_hnd,
2252                                 TALLOC_CTX *mem_ctx,
2253                                 const struct dom_sid *group_sid,
2254                                 const char *member)
2255 {
2256         struct policy_handle connect_pol, domain_pol;
2257         NTSTATUS status, result;
2258         uint32 group_rid;
2259         struct policy_handle group_pol;
2260         struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
2261
2262         struct samr_Ids rids, rid_types;
2263         struct lsa_String lsa_acct_name;
2264
2265         struct dom_sid sid;
2266
2267         sid_copy(&sid, group_sid);
2268
2269         if (!sid_split_rid(&sid, &group_rid))
2270                 return NT_STATUS_UNSUCCESSFUL;
2271
2272         /* Get sam policy handle */
2273         status = dcerpc_samr_Connect2(b, mem_ctx,
2274                                       pipe_hnd->desthost,
2275                                       MAXIMUM_ALLOWED_ACCESS,
2276                                       &connect_pol,
2277                                       &result);
2278         if (!NT_STATUS_IS_OK(status)) {
2279                 return status;
2280         }
2281         if (!NT_STATUS_IS_OK(result)) {
2282                 return result;
2283         }
2284
2285
2286         /* Get domain policy handle */
2287         status = dcerpc_samr_OpenDomain(b, mem_ctx,
2288                                         &connect_pol,
2289                                         MAXIMUM_ALLOWED_ACCESS,
2290                                         &sid,
2291                                         &domain_pol,
2292                                         &result);
2293         if (!NT_STATUS_IS_OK(status)) {
2294                 return status;
2295         }
2296         if (!NT_STATUS_IS_OK(result)) {
2297                 return result;
2298         }
2299
2300         init_lsa_String(&lsa_acct_name, member);
2301
2302         status = dcerpc_samr_LookupNames(b, mem_ctx,
2303                                          &domain_pol,
2304                                          1,
2305                                          &lsa_acct_name,
2306                                          &rids,
2307                                          &rid_types,
2308                                          &result);
2309         if (!NT_STATUS_IS_OK(status)) {
2310                 d_fprintf(stderr, _("Could not lookup up group member %s\n"),
2311                           member);
2312                 goto done;
2313         }
2314
2315         if (!NT_STATUS_IS_OK(result)) {
2316                 status = result;
2317                 d_fprintf(stderr, _("Could not lookup up group member %s\n"),
2318                           member);
2319                 goto done;
2320         }
2321
2322         status = dcerpc_samr_OpenGroup(b, mem_ctx,
2323                                        &domain_pol,
2324                                        MAXIMUM_ALLOWED_ACCESS,
2325                                        group_rid,
2326                                        &group_pol,
2327                                        &result);
2328         if (!NT_STATUS_IS_OK(status)) {
2329                 goto done;
2330         }
2331         if (!NT_STATUS_IS_OK(result)) {
2332                 status = result;
2333                 goto done;
2334         }
2335
2336         status = dcerpc_samr_DeleteGroupMember(b, mem_ctx,
2337                                                &group_pol,
2338                                                rids.ids[0],
2339                                                &result);
2340         if (!NT_STATUS_IS_OK(status)) {
2341                 goto done;
2342         }
2343
2344         status = result;
2345  done:
2346         dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
2347         return status;
2348 }
2349
2350 static NTSTATUS rpc_del_aliasmem(struct rpc_pipe_client *pipe_hnd,
2351                                 TALLOC_CTX *mem_ctx,
2352                                 const struct dom_sid *alias_sid,
2353                                 const char *member)
2354 {
2355         struct policy_handle connect_pol, domain_pol;
2356         NTSTATUS status, result;
2357         uint32 alias_rid;
2358         struct policy_handle alias_pol;
2359         struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
2360
2361         struct dom_sid member_sid;
2362         enum lsa_SidType member_type;
2363
2364         struct dom_sid sid;
2365
2366         sid_copy(&sid, alias_sid);
2367
2368         if (!sid_split_rid(&sid, &alias_rid))
2369                 return NT_STATUS_UNSUCCESSFUL;
2370
2371         result = get_sid_from_name(rpc_pipe_np_smb_conn(pipe_hnd), mem_ctx,
2372                                    member, &member_sid, &member_type);
2373
2374         if (!NT_STATUS_IS_OK(result)) {
2375                 d_fprintf(stderr, _("Could not lookup up group member %s\n"),
2376                           member);
2377                 return result;
2378         }
2379
2380         /* Get sam policy handle */
2381         status = dcerpc_samr_Connect2(b, mem_ctx,
2382                                       pipe_hnd->desthost,
2383                                       MAXIMUM_ALLOWED_ACCESS,
2384                                       &connect_pol,
2385                                       &result);
2386         if (!NT_STATUS_IS_OK(status)) {
2387                 goto done;
2388         }
2389         if (!NT_STATUS_IS_OK(result)) {
2390                 status = result;
2391                 goto done;
2392         }
2393
2394         /* Get domain policy handle */
2395         status = dcerpc_samr_OpenDomain(b, mem_ctx,
2396                                         &connect_pol,
2397                                         MAXIMUM_ALLOWED_ACCESS,
2398                                         &sid,
2399                                         &domain_pol,
2400                                         &result);
2401         if (!NT_STATUS_IS_OK(status)) {
2402                 goto done;
2403         }
2404         if (!NT_STATUS_IS_OK(result)) {
2405                 status = result;
2406                 goto done;
2407         }
2408
2409         status = dcerpc_samr_OpenAlias(b, mem_ctx,
2410                                        &domain_pol,
2411                                        MAXIMUM_ALLOWED_ACCESS,
2412                                        alias_rid,
2413                                        &alias_pol,
2414                                        &result);
2415         if (!NT_STATUS_IS_OK(status)) {
2416                 return status;
2417         }
2418
2419         if (!NT_STATUS_IS_OK(result)) {
2420                 return result;
2421         }
2422
2423         status = dcerpc_samr_DeleteAliasMember(b, mem_ctx,
2424                                                &alias_pol,
2425                                                &member_sid,
2426                                                &result);
2427
2428         if (!NT_STATUS_IS_OK(status)) {
2429                 return status;
2430         }
2431
2432         status = result;
2433
2434  done:
2435         dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
2436         return status;
2437 }
2438
2439 static NTSTATUS rpc_group_delmem_internals(struct net_context *c,
2440                                         const struct dom_sid *domain_sid,
2441                                         const char *domain_name,
2442                                         struct cli_state *cli,
2443                                         struct rpc_pipe_client *pipe_hnd,
2444                                         TALLOC_CTX *mem_ctx,
2445                                         int argc,
2446                                         const char **argv)
2447 {
2448         struct dom_sid group_sid;
2449         enum lsa_SidType group_type;
2450
2451         if (argc != 2 || c->display_usage) {
2452                 d_printf("%s\n%s",
2453                          _("Usage:"),
2454                          _("net rpc group delmem <group> <member>\n"
2455                            "  Delete a member from a group\n"
2456                            "    group\tGroup to delete member from\n"
2457                            "    member\tMember to delete from group\n"));
2458                 return NT_STATUS_UNSUCCESSFUL;
2459         }
2460
2461         if (!NT_STATUS_IS_OK(get_sid_from_name(cli, mem_ctx, argv[0],
2462                                                &group_sid, &group_type))) {
2463                 d_fprintf(stderr, _("Could not lookup group name %s\n"),
2464                           argv[0]);
2465                 return NT_STATUS_UNSUCCESSFUL;
2466         }
2467
2468         if (group_type == SID_NAME_DOM_GRP) {
2469                 NTSTATUS result = rpc_del_groupmem(c, pipe_hnd, mem_ctx,
2470                                                    &group_sid, argv[1]);
2471
2472                 if (!NT_STATUS_IS_OK(result)) {
2473                         d_fprintf(stderr, _("Could not del %s from %s: %s\n"),
2474                                  argv[1], argv[0], nt_errstr(result));
2475                 }
2476                 return result;
2477         }
2478
2479         if (group_type == SID_NAME_ALIAS) {
2480                 NTSTATUS result = rpc_del_aliasmem(pipe_hnd, mem_ctx,
2481                                                    &group_sid, argv[1]);
2482
2483                 if (!NT_STATUS_IS_OK(result)) {
2484                         d_fprintf(stderr, _("Could not del %s from %s: %s\n"),
2485                                  argv[1], argv[0], nt_errstr(result));
2486                 }
2487                 return result;
2488         }
2489
2490         d_fprintf(stderr, _("Can only delete members from global or local "
2491                  "groups which %s is not\n"), argv[0]);
2492
2493         return NT_STATUS_UNSUCCESSFUL;
2494 }
2495
2496 static int rpc_group_delmem(struct net_context *c, int argc, const char **argv)
2497 {
2498         return run_rpc_command(c, NULL, &ndr_table_samr.syntax_id, 0,
2499                                rpc_group_delmem_internals,
2500                                argc, argv);
2501 }
2502
2503 /**
2504  * List groups on a remote RPC server.
2505  *
2506  * All parameters are provided by the run_rpc_command function, except for
2507  * argc, argv which are passes through.
2508  *
2509  * @param domain_sid The domain sid acquired from the remote server.
2510  * @param cli A cli_state connected to the server.
2511  * @param mem_ctx Talloc context, destroyed on completion of the function.
2512  * @param argc  Standard main() style argc.
2513  * @param argv  Standard main() style argv. Initial components are already
2514  *              stripped.
2515  *
2516  * @return Normal NTSTATUS return.
2517  **/
2518
2519 static NTSTATUS rpc_group_list_internals(struct net_context *c,
2520                                         const struct dom_sid *domain_sid,
2521                                         const char *domain_name,
2522                                         struct cli_state *cli,
2523                                         struct rpc_pipe_client *pipe_hnd,
2524                                         TALLOC_CTX *mem_ctx,
2525                                         int argc,
2526                                         const char **argv)
2527 {
2528         struct policy_handle connect_pol, domain_pol;
2529         NTSTATUS status, result;
2530         uint32 start_idx=0, max_entries=250, num_entries, i, loop_count = 0;
2531         struct samr_SamArray *groups = NULL;
2532         bool global = false;
2533         bool local = false;
2534         bool builtin = false;
2535         struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
2536
2537         if (c->display_usage) {
2538                 d_printf("%s\n%s",
2539                          _("Usage:"),
2540                          _("net rpc group list [global] [local] [builtin]\n"
2541                            "  List groups on RPC server\n"
2542                            "    global\tList global groups\n"
2543                            "    local\tList local groups\n"
2544                            "    builtin\tList builtin groups\n"
2545                            "    If none of global, local or builtin is "
2546                            "specified, all three options are considered "
2547                            "set\n"));
2548                 return NT_STATUS_OK;
2549         }
2550
2551         if (argc == 0) {
2552                 global = true;
2553                 local = true;
2554                 builtin = true;
2555         }
2556
2557         for (i=0; i<argc; i++) {
2558                 if (strequal(argv[i], "global"))
2559                         global = true;
2560
2561                 if (strequal(argv[i], "local"))
2562                         local = true;
2563
2564                 if (strequal(argv[i], "builtin"))
2565                         builtin = true;
2566         }
2567
2568         /* Get sam policy handle */
2569
2570         status = dcerpc_samr_Connect2(b, mem_ctx,
2571                                       pipe_hnd->desthost,
2572                                       MAXIMUM_ALLOWED_ACCESS,
2573                                       &connect_pol,
2574                                       &result);
2575         if (!NT_STATUS_IS_OK(status)) {
2576                 goto done;
2577         }
2578         if (!NT_STATUS_IS_OK(result)) {
2579                 status = result;
2580                 goto done;
2581         }
2582
2583         /* Get domain policy handle */
2584
2585         status = dcerpc_samr_OpenDomain(b, mem_ctx,
2586                                         &connect_pol,
2587                                         MAXIMUM_ALLOWED_ACCESS,
2588                                         discard_const_p(struct dom_sid2, domain_sid),
2589                                         &domain_pol,
2590                                         &result);
2591         if (!NT_STATUS_IS_OK(status)) {
2592                 goto done;
2593         }
2594         if (!NT_STATUS_IS_OK(result)) {
2595                 status = result;
2596                 goto done;
2597         }
2598
2599         /* Query domain groups */
2600         if (c->opt_long_list_entries)
2601                 d_printf(_("\nGroup name            Comment"
2602                            "\n-----------------------------\n"));
2603         do {
2604                 uint32_t max_size, total_size, returned_size;
2605                 union samr_DispInfo info;
2606
2607                 if (!global) break;
2608
2609                 dcerpc_get_query_dispinfo_params(
2610                         loop_count, &max_entries, &max_size);
2611
2612                 status = dcerpc_samr_QueryDisplayInfo(b, mem_ctx,
2613                                                       &domain_pol,
2614                                                       3,
2615                                                       start_idx,
2616                                                       max_entries,
2617                                                       max_size,
2618                                                       &total_size,
2619                                                       &returned_size,
2620                                                       &info,
2621                                                       &result);
2622                 if (!NT_STATUS_IS_OK(status)) {
2623                         goto done;
2624                 }
2625                 num_entries = info.info3.count;
2626                 start_idx += info.info3.count;
2627
2628                 if (!NT_STATUS_IS_OK(result) &&
2629                     !NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES))
2630                         break;
2631
2632                 for (i = 0; i < num_entries; i++) {
2633
2634                         const char *group = NULL;
2635                         const char *desc = NULL;
2636
2637                         group = info.info3.entries[i].account_name.string;
2638                         desc = info.info3.entries[i].description.string;
2639
2640                         if (c->opt_long_list_entries)
2641                                 printf("%-21.21s %-50.50s\n",
2642                                        group, desc);
2643                         else
2644                                 printf("%s\n", group);
2645                 }
2646         } while (NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES));
2647         /* query domain aliases */
2648         start_idx = 0;
2649         do {
2650                 if (!local) break;
2651
2652                 status = dcerpc_samr_EnumDomainAliases(b, mem_ctx,
2653                                                        &domain_pol,
2654                                                        &start_idx,
2655                                                        &groups,
2656                                                        0xffff,
2657                                                        &num_entries,
2658                                                        &result);
2659                 if (!NT_STATUS_IS_OK(status)) {
2660                         goto done;
2661                 }
2662                 if (!NT_STATUS_IS_OK(result) &&
2663                     !NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES))
2664                         break;
2665
2666                 for (i = 0; i < num_entries; i++) {
2667
2668                         const char *description = NULL;
2669
2670                         if (c->opt_long_list_entries) {
2671
2672                                 struct policy_handle alias_pol;
2673                                 union samr_AliasInfo *info = NULL;
2674                                 NTSTATUS _result;
2675
2676                                 status = dcerpc_samr_OpenAlias(b, mem_ctx,
2677                                                                &domain_pol,
2678                                                                0x8,
2679                                                                groups->entries[i].idx,
2680                                                                &alias_pol,
2681                                                                &_result);
2682                                 if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(_result)) {
2683                                         status = dcerpc_samr_QueryAliasInfo(b, mem_ctx,
2684                                                                             &alias_pol,
2685                                                                             3,
2686                                                                             &info,
2687                                                                             &_result);
2688                                         if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(_result)) {
2689                                                 status = dcerpc_samr_Close(b, mem_ctx,
2690                                                                            &alias_pol,
2691                                                                            &_result);
2692                                                 if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(_result)) {
2693                                                         description = info->description.string;
2694                                                 }
2695                                         }
2696                                 }
2697                         }
2698
2699                         if (description != NULL) {
2700                                 printf("%-21.21s %-50.50s\n",
2701                                        groups->entries[i].name.string,
2702                                        description);
2703                         } else {
2704                                 printf("%s\n", groups->entries[i].name.string);
2705                         }
2706                 }
2707         } while (NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES));
2708         dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
2709         /* Get builtin policy handle */
2710
2711         status = dcerpc_samr_OpenDomain(b, mem_ctx,
2712                                         &connect_pol,
2713                                         MAXIMUM_ALLOWED_ACCESS,
2714                                         discard_const_p(struct dom_sid2, &global_sid_Builtin),
2715                                         &domain_pol,
2716                                         &result);
2717         if (!NT_STATUS_IS_OK(status)) {
2718                 goto done;
2719         }
2720         if (!NT_STATUS_IS_OK(result)) {
2721                 status = result;
2722                 goto done;
2723         }
2724
2725         /* query builtin aliases */
2726         start_idx = 0;
2727         do {
2728                 if (!builtin) break;
2729
2730                 status = dcerpc_samr_EnumDomainAliases(b, mem_ctx,
2731                                                        &domain_pol,
2732                                                        &start_idx,
2733                                                        &groups,
2734                                                        max_entries,
2735                                                        &num_entries,
2736                                                        &result);
2737                 if (!NT_STATUS_IS_OK(status)) {
2738                         break;
2739                 }
2740                 if (!NT_STATUS_IS_OK(result) &&
2741                     !NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES)) {
2742                         status = result;
2743                         break;
2744                 }
2745
2746                 for (i = 0; i < num_entries; i++) {
2747
2748                         const char *description = NULL;
2749
2750                         if (c->opt_long_list_entries) {
2751
2752                                 struct policy_handle alias_pol;
2753                                 union samr_AliasInfo *info = NULL;
2754                                 NTSTATUS _result;
2755
2756                                 status = dcerpc_samr_OpenAlias(b, mem_ctx,
2757                                                                &domain_pol,
2758                                                                0x8,
2759                                                                groups->entries[i].idx,
2760                                                                &alias_pol,
2761                                                                &_result);
2762                                 if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(_result)) {
2763                                         status = dcerpc_samr_QueryAliasInfo(b, mem_ctx,
2764                                                                             &alias_pol,
2765                                                                             3,
2766                                                                             &info,
2767                                                                             &_result);
2768                                         if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(_result)) {
2769                                                 status = dcerpc_samr_Close(b, mem_ctx,
2770                                                                            &alias_pol,
2771                                                                            &_result);
2772                                                 if (NT_STATUS_IS_OK(status) && NT_STATUS_IS_OK(_result)) {
2773                                                         description = info->description.string;
2774                                                 }
2775                                         }
2776                                 }
2777                         }
2778
2779                         if (description != NULL) {
2780                                 printf("%-21.21s %-50.50s\n",
2781                                        groups->entries[i].name.string,
2782                                        description);
2783                         } else {
2784                                 printf("%s\n", groups->entries[i].name.string);
2785                         }
2786                 }
2787         } while (NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES));
2788
2789         status = result;
2790
2791  done:
2792         return status;
2793 }
2794
2795 static int rpc_group_list(struct net_context *c, int argc, const char **argv)
2796 {
2797         return run_rpc_command(c, NULL, &ndr_table_samr.syntax_id, 0,
2798                                rpc_group_list_internals,
2799                                argc, argv);
2800 }
2801
2802 static NTSTATUS rpc_list_group_members(struct net_context *c,
2803                                         struct rpc_pipe_client *pipe_hnd,
2804                                         TALLOC_CTX *mem_ctx,
2805                                         const char *domain_name,
2806                                         const struct dom_sid *domain_sid,
2807                                         struct policy_handle *domain_pol,
2808                                         uint32 rid)
2809 {
2810         NTSTATUS result, status;
2811         struct policy_handle group_pol;
2812         uint32 num_members, *group_rids;
2813         int i;
2814         struct samr_RidAttrArray *rids = NULL;
2815         struct lsa_Strings names;
2816         struct samr_Ids types;
2817         struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
2818
2819         fstring sid_str;
2820         sid_to_fstring(sid_str, domain_sid);
2821
2822         status = dcerpc_samr_OpenGroup(b, mem_ctx,
2823                                        domain_pol,
2824                                        MAXIMUM_ALLOWED_ACCESS,
2825                                        rid,
2826                                        &group_pol,
2827                                        &result);
2828         if (!NT_STATUS_IS_OK(status)) {
2829                 return status;
2830         }
2831         if (!NT_STATUS_IS_OK(result)) {
2832                 return result;
2833         }
2834
2835         status = dcerpc_samr_QueryGroupMember(b, mem_ctx,
2836                                               &group_pol,
2837                                               &rids,
2838                                               &result);
2839         if (!NT_STATUS_IS_OK(status)) {
2840                 return status;
2841         }
2842         if (!NT_STATUS_IS_OK(result)) {
2843                 return result;
2844         }
2845
2846         num_members = rids->count;
2847         group_rids = rids->rids;
2848
2849         while (num_members > 0) {
2850                 int this_time = 512;
2851
2852                 if (num_members < this_time)
2853                         this_time = num_members;
2854
2855                 status = dcerpc_samr_LookupRids(b, mem_ctx,
2856                                                 domain_pol,
2857                                                 this_time,
2858                                                 group_rids,
2859                                                 &names,
2860                                                 &types,
2861                                                 &result);
2862                 if (!NT_STATUS_IS_OK(status)) {
2863                         return status;
2864                 }
2865                 if (!NT_STATUS_IS_OK(result)) {
2866                         return result;
2867                 }
2868
2869                 /* We only have users as members, but make the output
2870                    the same as the output of alias members */
2871
2872                 for (i = 0; i < this_time; i++) {
2873
2874                         if (c->opt_long_list_entries) {
2875                                 printf("%s-%d %s\\%s %d\n", sid_str,
2876                                        group_rids[i], domain_name,
2877                                        names.names[i].string,
2878                                        SID_NAME_USER);
2879                         } else {
2880                                 printf("%s\\%s\n", domain_name,
2881                                         names.names[i].string);
2882                         }
2883                 }
2884
2885                 num_members -= this_time;
2886                 group_rids += 512;
2887         }
2888
2889         return NT_STATUS_OK;
2890 }
2891
2892 static NTSTATUS rpc_list_alias_members(struct net_context *c,
2893                                         struct rpc_pipe_client *pipe_hnd,
2894                                         TALLOC_CTX *mem_ctx,
2895                                         struct policy_handle *domain_pol,
2896                                         uint32 rid)
2897 {
2898         NTSTATUS result, status;
2899         struct rpc_pipe_client *lsa_pipe;
2900         struct policy_handle alias_pol, lsa_pol;
2901         uint32 num_members;
2902         struct dom_sid *alias_sids;
2903         char **domains;
2904         char **names;
2905         enum lsa_SidType *types;
2906         int i;
2907         struct lsa_SidArray sid_array;
2908         struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
2909
2910         status = dcerpc_samr_OpenAlias(b, mem_ctx,
2911                                        domain_pol,
2912                                        MAXIMUM_ALLOWED_ACCESS,
2913                                        rid,
2914                                        &alias_pol,
2915                                        &result);
2916         if (!NT_STATUS_IS_OK(status)) {
2917                 return status;
2918         }
2919         if (!NT_STATUS_IS_OK(result)) {
2920                 return result;
2921         }
2922
2923         status = dcerpc_samr_GetMembersInAlias(b, mem_ctx,
2924                                                &alias_pol,
2925                                                &sid_array,
2926                                                &result);
2927         if (!NT_STATUS_IS_OK(status)) {
2928                 d_fprintf(stderr, _("Couldn't list alias members\n"));
2929                 return status;
2930         }
2931         if (!NT_STATUS_IS_OK(result)) {
2932                 d_fprintf(stderr, _("Couldn't list alias members\n"));
2933                 return result;
2934         }
2935
2936         num_members = sid_array.num_sids;
2937
2938         if (num_members == 0) {
2939                 return NT_STATUS_OK;
2940         }
2941
2942         result = cli_rpc_pipe_open_noauth(rpc_pipe_np_smb_conn(pipe_hnd),
2943                                           &ndr_table_lsarpc.syntax_id,
2944                                           &lsa_pipe);
2945         if (!NT_STATUS_IS_OK(result)) {
2946                 d_fprintf(stderr, _("Couldn't open LSA pipe. Error was %s\n"),
2947                         nt_errstr(result) );
2948                 return result;
2949         }
2950
2951         result = rpccli_lsa_open_policy(lsa_pipe, mem_ctx, true,
2952                                      SEC_FLAG_MAXIMUM_ALLOWED, &lsa_pol);
2953
2954         if (!NT_STATUS_IS_OK(result)) {
2955                 d_fprintf(stderr, _("Couldn't open LSA policy handle\n"));
2956                 TALLOC_FREE(lsa_pipe);
2957                 return result;
2958         }
2959
2960         alias_sids = TALLOC_ZERO_ARRAY(mem_ctx, struct dom_sid, num_members);
2961         if (!alias_sids) {
2962                 d_fprintf(stderr, _("Out of memory\n"));
2963                 TALLOC_FREE(lsa_pipe);
2964                 return NT_STATUS_NO_MEMORY;
2965         }
2966
2967         for (i=0; i<num_members; i++) {
2968                 sid_copy(&alias_sids[i], sid_array.sids[i].sid);
2969         }
2970
2971         result = rpccli_lsa_lookup_sids(lsa_pipe, mem_ctx, &lsa_pol,
2972                                      num_members,  alias_sids,
2973                                      &domains, &names, &types);
2974
2975         if (!NT_STATUS_IS_OK(result) &&
2976             !NT_STATUS_EQUAL(result, STATUS_SOME_UNMAPPED)) {
2977                 d_fprintf(stderr, _("Couldn't lookup SIDs\n"));
2978                 TALLOC_FREE(lsa_pipe);
2979                 return result;
2980         }
2981
2982         for (i = 0; i < num_members; i++) {
2983                 fstring sid_str;
2984                 sid_to_fstring(sid_str, &alias_sids[i]);
2985
2986                 if (c->opt_long_list_entries) {
2987                         printf("%s %s\\%s %d\n", sid_str,
2988                                domains[i] ? domains[i] : _("*unknown*"),
2989                                names[i] ? names[i] : _("*unknown*"), types[i]);
2990                 } else {
2991                         if (domains[i])
2992                                 printf("%s\\%s\n", domains[i], names[i]);
2993                         else
2994                                 printf("%s\n", sid_str);
2995                 }
2996         }
2997
2998         TALLOC_FREE(lsa_pipe);
2999         return NT_STATUS_OK;
3000 }
3001
3002 static NTSTATUS rpc_group_members_internals(struct net_context *c,
3003                                         const struct dom_sid *domain_sid,
3004                                         const char *domain_name,
3005                                         struct cli_state *cli,
3006                                         struct rpc_pipe_client *pipe_hnd,
3007                                         TALLOC_CTX *mem_ctx,
3008                                         int argc,
3009                                         const char **argv)
3010 {
3011         NTSTATUS result, status;
3012         struct policy_handle connect_pol, domain_pol;
3013         struct samr_Ids rids, rid_types;
3014         struct lsa_String lsa_acct_name;
3015         struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
3016
3017         /* Get sam policy handle */
3018
3019         status = dcerpc_samr_Connect2(b, mem_ctx,
3020                                       pipe_hnd->desthost,
3021                                       MAXIMUM_ALLOWED_ACCESS,
3022                                       &connect_pol,
3023                                       &result);
3024         if (!NT_STATUS_IS_OK(status)) {
3025                 return status;
3026         }
3027         if (!NT_STATUS_IS_OK(result)) {
3028                 return result;
3029         }
3030
3031         /* Get domain policy handle */
3032
3033         status = dcerpc_samr_OpenDomain(b, mem_ctx,
3034                                         &connect_pol,
3035                                         MAXIMUM_ALLOWED_ACCESS,
3036                                         discard_const_p(struct dom_sid2, domain_sid),
3037                                         &domain_pol,
3038                                         &result);
3039         if (!NT_STATUS_IS_OK(status)) {
3040                 return status;
3041         }
3042         if (!NT_STATUS_IS_OK(result)) {
3043                 return result;
3044         }
3045
3046         init_lsa_String(&lsa_acct_name, argv[0]); /* sure? */
3047
3048         status = dcerpc_samr_LookupNames(b, mem_ctx,
3049                                          &domain_pol,
3050                                          1,
3051                                          &lsa_acct_name,
3052                                          &rids,
3053                                          &rid_types,
3054                                          &result);
3055         if (!NT_STATUS_IS_OK(status)) {
3056                 return status;
3057         }
3058
3059         if (!NT_STATUS_IS_OK(result)) {
3060
3061                 /* Ok, did not find it in the global sam, try with builtin */
3062
3063                 struct dom_sid sid_Builtin;
3064
3065                 dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
3066
3067                 sid_copy(&sid_Builtin, &global_sid_Builtin);
3068
3069                 status = dcerpc_samr_OpenDomain(b, mem_ctx,
3070                                                 &connect_pol,
3071                                                 MAXIMUM_ALLOWED_ACCESS,
3072                                                 &sid_Builtin,
3073                                                 &domain_pol,
3074                                                 &result);
3075                 if (!NT_STATUS_IS_OK(status)) {
3076                         return status;
3077                 }
3078                 if (!NT_STATUS_IS_OK(result)) {
3079                         d_fprintf(stderr, _("Couldn't find group %s\n"),
3080                                   argv[0]);
3081                         return result;
3082                 }
3083
3084                 status = dcerpc_samr_LookupNames(b, mem_ctx,
3085                                                  &domain_pol,
3086                                                  1,
3087                                                  &lsa_acct_name,
3088                                                  &rids,
3089                                                  &rid_types,
3090                                                  &result);
3091                 if (!NT_STATUS_IS_OK(status)) {
3092                         return status;
3093                 }
3094                 if (!NT_STATUS_IS_OK(result)) {
3095                         d_fprintf(stderr, _("Couldn't find group %s\n"),
3096                                   argv[0]);
3097                         return result;
3098                 }
3099         }
3100
3101         if (rids.count != 1) {
3102                 d_fprintf(stderr, _("Couldn't find group %s\n"),
3103                           argv[0]);
3104                 return result;
3105         }
3106
3107         if (rid_types.ids[0] == SID_NAME_DOM_GRP) {
3108                 return rpc_list_group_members(c, pipe_hnd, mem_ctx, domain_name,
3109                                               domain_sid, &domain_pol,
3110                                               rids.ids[0]);
3111         }
3112
3113         if (rid_types.ids[0] == SID_NAME_ALIAS) {
3114                 return rpc_list_alias_members(c, pipe_hnd, mem_ctx, &domain_pol,
3115                                               rids.ids[0]);
3116         }
3117
3118         return NT_STATUS_NO_SUCH_GROUP;
3119 }
3120
3121 static int rpc_group_members(struct net_context *c, int argc, const char **argv)
3122 {
3123         if (argc != 1 || c->display_usage) {
3124                 return rpc_group_usage(c, argc, argv);
3125         }
3126
3127         return run_rpc_command(c, NULL, &ndr_table_samr.syntax_id, 0,
3128                                rpc_group_members_internals,
3129                                argc, argv);
3130 }
3131
3132 static int rpc_group_rename_internals(struct net_context *c, int argc, const char **argv)
3133 {
3134         NET_API_STATUS status;
3135         struct GROUP_INFO_0 g0;
3136         uint32_t parm_err;
3137
3138         if (argc != 2) {
3139                 d_printf(_("Usage:\n"));
3140                 d_printf("net rpc group rename group newname\n");
3141                 return -1;
3142         }
3143
3144         g0.grpi0_name = argv[1];
3145
3146         status = NetGroupSetInfo(c->opt_host,
3147                                  argv[0],
3148                                  0,
3149                                  (uint8_t *)&g0,
3150                                  &parm_err);
3151
3152         if (status != 0) {
3153                 d_fprintf(stderr, _("Renaming group %s failed with: %s\n"),
3154                         argv[0], libnetapi_get_error_string(c->netapi_ctx,
3155                         status));
3156                 return -1;
3157         }
3158
3159         return 0;
3160 }
3161
3162 static int rpc_group_rename(struct net_context *c, int argc, const char **argv)
3163 {
3164         if (argc != 2 || c->display_usage) {
3165                 return rpc_group_usage(c, argc, argv);
3166         }
3167
3168         return rpc_group_rename_internals(c, argc, argv);
3169 }
3170
3171 /**
3172  * 'net rpc group' entrypoint.
3173  * @param argc  Standard main() style argc.
3174  * @param argv  Standard main() style argv. Initial components are already
3175  *              stripped.
3176  **/
3177
3178 int net_rpc_group(struct net_context *c, int argc, const char **argv)
3179 {
3180         NET_API_STATUS status;
3181
3182         struct functable func[] = {
3183                 {
3184                         "add",
3185                         rpc_group_add,
3186                         NET_TRANSPORT_RPC,
3187                         N_("Create specified group"),
3188                         N_("net rpc group add\n"
3189                            "    Create specified group")
3190                 },
3191                 {
3192                         "delete",
3193                         rpc_group_delete,
3194                         NET_TRANSPORT_RPC,
3195                         N_("Delete specified group"),
3196                         N_("net rpc group delete\n"
3197                            "    Delete specified group")
3198                 },
3199                 {
3200                         "addmem",
3201                         rpc_group_addmem,
3202                         NET_TRANSPORT_RPC,
3203                         N_("Add member to group"),
3204                         N_("net rpc group addmem\n"
3205                            "    Add member to group")
3206                 },
3207                 {
3208                         "delmem",
3209                         rpc_group_delmem,
3210                         NET_TRANSPORT_RPC,
3211                         N_("Remove member from group"),
3212                         N_("net rpc group delmem\n"
3213                            "    Remove member from group")
3214                 },
3215                 {
3216                         "list",
3217                         rpc_group_list,
3218                         NET_TRANSPORT_RPC,
3219                         N_("List groups"),
3220                         N_("net rpc group list\n"
3221                            "    List groups")
3222                 },
3223                 {
3224                         "members",
3225                         rpc_group_members,
3226                         NET_TRANSPORT_RPC,
3227                         N_("List group members"),
3228                         N_("net rpc group members\n"
3229                            "    List group members")
3230                 },
3231                 {
3232                         "rename",
3233                         rpc_group_rename,
3234                         NET_TRANSPORT_RPC,
3235                         N_("Rename group"),
3236                         N_("net rpc group rename\n"
3237                            "    Rename group")
3238                 },
3239                 {NULL, NULL, 0, NULL, NULL}
3240         };
3241
3242         status = libnetapi_net_init(&c->netapi_ctx);
3243         if (status != 0) {
3244                 return -1;
3245         }
3246         libnetapi_set_username(c->netapi_ctx, c->opt_user_name);
3247         libnetapi_set_password(c->netapi_ctx, c->opt_password);
3248         if (c->opt_kerberos) {
3249                 libnetapi_set_use_kerberos(c->netapi_ctx);
3250         }
3251
3252         if (argc == 0) {
3253                 if (c->display_usage) {
3254                         d_printf(_("Usage:\n"));
3255                         d_printf(_("net rpc group\n"
3256                                    "    Alias for net rpc group list global "
3257                                    "local builtin\n"));
3258                         net_display_usage_from_functable(func);
3259                         return 0;
3260                 }
3261
3262                 return run_rpc_command(c, NULL, &ndr_table_samr.syntax_id, 0,
3263                                        rpc_group_list_internals,
3264                                        argc, argv);
3265         }
3266
3267         return net_run_function(c, argc, argv, "net rpc group", func);
3268 }
3269
3270 /****************************************************************************/
3271
3272 static int rpc_share_usage(struct net_context *c, int argc, const char **argv)
3273 {
3274         return net_share_usage(c, argc, argv);
3275 }
3276
3277 /**
3278  * Add a share on a remote RPC server.
3279  *
3280  * @param argc  Standard main() style argc.
3281  * @param argv  Standard main() style argv. Initial components are already
3282  *              stripped.
3283  *
3284  * @return A shell status integer (0 for success).
3285  **/
3286
3287 static int rpc_share_add(struct net_context *c, int argc, const char **argv)
3288 {
3289         NET_API_STATUS status;
3290         char *sharename;
3291         char *path;
3292         uint32 type = STYPE_DISKTREE; /* only allow disk shares to be added */
3293         uint32 num_users=0, perms=0;
3294         char *password=NULL; /* don't allow a share password */
3295         struct SHARE_INFO_2 i2;
3296         uint32_t parm_error = 0;
3297
3298         if ((argc < 1) || !strchr(argv[0], '=') || c->display_usage) {
3299                 return rpc_share_usage(c, argc, argv);
3300         }
3301
3302         if ((sharename = talloc_strdup(c, argv[0])) == NULL) {
3303                 return -1;
3304         }
3305
3306         path = strchr(sharename, '=');
3307         if (!path) {
3308                 return -1;
3309         }
3310
3311         *path++ = '\0';
3312
3313         i2.shi2_netname         = sharename;
3314         i2.shi2_type            = type;
3315         i2.shi2_remark          = c->opt_comment;
3316         i2.shi2_permissions     = perms;
3317         i2.shi2_max_uses        = c->opt_maxusers;
3318         i2.shi2_current_uses    = num_users;
3319         i2.shi2_path            = path;
3320         i2.shi2_passwd          = password;
3321
3322         status = NetShareAdd(c->opt_host,
3323                              2,
3324                              (uint8_t *)&i2,
3325                              &parm_error);
3326         if (status != 0) {
3327                 printf(_("NetShareAdd failed with: %s\n"),
3328                         libnetapi_get_error_string(c->netapi_ctx, status));
3329         }
3330
3331         return status;
3332 }
3333
3334 /**
3335  * Delete a share on a remote RPC server.
3336  *
3337  * @param domain_sid The domain sid acquired from the remote server.
3338  * @param argc  Standard main() style argc.
3339  * @param argv  Standard main() style argv. Initial components are already
3340  *              stripped.
3341  *
3342  * @return A shell status integer (0 for success).
3343  **/
3344 static int rpc_share_delete(struct net_context *c, int argc, const char **argv)
3345 {
3346         if (argc < 1 || c->display_usage) {
3347                 return rpc_share_usage(c, argc, argv);
3348         }
3349
3350         return NetShareDel(c->opt_host, argv[0], 0);
3351 }
3352
3353 /**
3354  * Formatted print of share info
3355  *
3356  * @param r  pointer to SHARE_INFO_1 to format
3357  **/
3358
3359 static void display_share_info_1(struct net_context *c,
3360                                  struct SHARE_INFO_1 *r)
3361 {
3362         if (c->opt_long_list_entries) {
3363                 d_printf("%-12s %-8.8s %-50s\n",
3364                          r->shi1_netname,
3365                          net_share_type_str(r->shi1_type & ~(STYPE_TEMPORARY|STYPE_HIDDEN)),
3366                          r->shi1_remark);
3367         } else {
3368                 d_printf("%s\n", r->shi1_netname);
3369         }
3370 }
3371
3372 static WERROR get_share_info(struct net_context *c,
3373                              struct rpc_pipe_client *pipe_hnd,
3374                              TALLOC_CTX *mem_ctx,
3375                              uint32 level,
3376                              int argc,
3377                              const char **argv,
3378                              struct srvsvc_NetShareInfoCtr *info_ctr)
3379 {
3380         WERROR result;
3381         NTSTATUS status;
3382         union srvsvc_NetShareInfo info;
3383         struct dcerpc_binding_handle *b = pipe_hnd->binding_handle;
3384
3385         /* no specific share requested, enumerate all */
3386         if (argc == 0) {
3387
3388                 uint32_t preferred_len = 0xffffffff;
3389                 uint32_t total_entries = 0;
3390                 uint32_t resume_handle = 0;
3391
3392                 info_ctr->level = level;
3393
3394                 status = dcerpc_srvsvc_NetShareEnumAll(b, mem_ctx,
3395                                                        pipe_hnd->desthost,
3396                                                        info_ctr,
3397                                                        preferred_len,
3398                                                        &total_entries,
3399                                                        &resume_handle,
3400                                                        &result);
3401                 if (!NT_STATUS_IS_OK(status)) {
3402                         return ntstatus_to_werror(status);
3403                 }
3404                 return result;
3405         }
3406
3407         /* request just one share */
3408         status = dcerpc_srvsvc_NetShareGetInfo(b, mem_ctx,
3409                                                pipe_hnd->desthost,
3410                                                argv[0],
3411                                                level,
3412                                                &info,
3413                                                &result);
3414
3415         if (!NT_STATUS_IS_OK(status)) {
3416                 result = ntstatus_to_werror(status);
3417                 goto done;
3418         }
3419
3420         if (!W_ERROR_IS_OK(result)) {
3421                 goto done;
3422         }
3423
3424         /* construct ctr */
3425         ZERO_STRUCTP(info_ctr);
3426
3427         info_ctr->level = level;
3428
3429         switch (level) {
3430         case 1:
3431         {
3432                 struct srvsvc_NetShareCtr1 *ctr1;
3433
3434                 ctr1 = TALLOC_ZERO_P(mem_ctx, struct srvsvc_NetShareCtr1);
3435                 W_ERROR_HAVE_NO_MEMORY(ctr1);
3436
3437                 ctr1->count = 1;
3438                 ctr1->array = info.info1;
3439
3440                 info_ctr->ctr.ctr1 = ctr1;
3441
3442                 break;
3443         }
3444         case 2:
3445         {
3446                 struct srvsvc_NetShareCtr2 *ctr2;
3447
3448                 ctr2 = TALLOC_ZERO_P(mem_ctx, struct srvsvc_NetShareCtr2);
3449                 W_ERROR_HAVE_NO_MEMORY(ctr2);
3450
3451                 ctr2->count = 1;
3452                 ctr2->array = info.info2;
3453
3454                 info_ctr->ctr.ctr2 = ctr2;
3455
3456                 break;
3457         }
3458         case 502:
3459         {
3460                 struct srvsvc_NetShareCtr502 *ctr502;
3461
3462                 ctr502 = TALLOC_ZERO_P(mem_ctx, struct srvsvc_NetShareCtr502);
3463                 W_ERROR_HAVE_NO_MEMORY(ctr502);
3464
3465                 ctr502->count = 1;
3466                 ctr502->array = info.info502;
3467
3468                 info_ctr->ctr.ctr502 = ctr502;
3469
3470                 break;
3471         }
3472         } /* switch */
3473 done:
3474         return result;
3475 }
3476
3477 /***
3478  * 'net rpc share list' entrypoint.
3479  * @param argc  Standard main() style argc.
3480  * @param argv  Standard main() style argv. Initial components are already
3481  *              stripped.
3482  **/
3483 static int rpc_share_list(struct net_context *c, int argc, const char **argv)
3484 {
3485         NET_API_STATUS status;
3486         struct SHARE_INFO_1 *i1 = NULL;
3487         uint32_t entries_read = 0;
3488         uint32_t total_entries = 0;
3489         uint32_t resume_handle = 0;
3490         uint32_t i, level = 1;
3491
3492         if (c->display_usage) {
3493                 d_printf(  "%s\n"
3494                            "net rpc share list\n"
3495                            "    %s\n",
3496                          _("Usage:"),
3497                          _("List shares on remote server"));