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 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, write to the Free Software
  22    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  23
  24 #include "includes.h"
  25 #include "utils/net.h"
  26
  27 static int net_mode_share;
  28
  29 /**
  30  * @file net_rpc.c
  31  *
  32  * @brief RPC based subcommands for the 'net' utility.
  33  *
  34  * This file should contain much of the functionality that used to
  35  * be found in rpcclient, execpt that the commands should change
  36  * less often, and the fucntionality should be sane (the user is not
  37  * expected to know a rid/sid before they conduct an operation etc.)
  38  *
  39  * @todo Perhaps eventually these should be split out into a number
  40  * of files, as this could get quite big.
  41  **/
  42
  43
  44 /**
  45  * Many of the RPC functions need the domain sid.  This function gets
  46  *  it at the start of every run
  47  *
  48  * @param cli A cli_state already connected to the remote machine
  49  *
  50  * @return The Domain SID of the remote machine.
  51  **/
  52
  53 NTSTATUS net_get_remote_domain_sid(struct cli_state *cli, TALLOC_CTX *mem_ctx,
  54                                    DOM_SID **domain_sid, char **domain_name)
  55 {
  56         struct rpc_pipe_client *lsa_pipe;
  57         POLICY_HND pol;
  58         NTSTATUS result = NT_STATUS_OK;
  59         uint32 info_class = 5;
  60
  61         lsa_pipe = cli_rpc_pipe_open_noauth(cli, PI_LSARPC, &result);
  62         if (!lsa_pipe) {
  63                 d_fprintf(stderr, "Could not initialise lsa pipe\n");
  64                 return result;
  65         }
  66
  67         result = rpccli_lsa_open_policy(lsa_pipe, mem_ctx, False,
  68                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
  69                                      &pol);
  70         if (!NT_STATUS_IS_OK(result)) {
  71                 d_fprintf(stderr, "open_policy failed: %s\n",
  72                           nt_errstr(result));
  73                 return result;
  74         }
  75
  76         result = rpccli_lsa_query_info_policy(lsa_pipe, mem_ctx, &pol,
  77                                               info_class, domain_name,
  78                                               domain_sid);
  79         if (!NT_STATUS_IS_OK(result)) {
  80                 d_fprintf(stderr, "lsaquery failed: %s\n",
  81                           nt_errstr(result));
  82                 return result;
  83         }
  84
  85         rpccli_lsa_Close(lsa_pipe, mem_ctx, &pol);
  86         cli_rpc_pipe_close(lsa_pipe);
  87
  88         return NT_STATUS_OK;
  89 }
  90
  91 /**
  92  * Run a single RPC command, from start to finish.
  93  *
  94  * @param pipe_name the pipe to connect to (usually a PIPE_ constant)
  95  * @param conn_flag a NET_FLAG_ combination.  Passed to
  96  *                   net_make_ipc_connection.
  97  * @param argc  Standard main() style argc
  98  * @param argc  Standard main() style argv.  Initial components are already
  99  *              stripped
 100  * @return A shell status integer (0 for success)
 101  */
 102
 103 int run_rpc_command(struct cli_state *cli_arg,
 104                         const int pipe_idx,
 105                         int conn_flags,
 106                         rpc_command_fn fn,
 107                         int argc,
 108                         const char **argv)
 109 {
 110         struct cli_state *cli = NULL;
 111         struct rpc_pipe_client *pipe_hnd = NULL;
 112         TALLOC_CTX *mem_ctx;
 113         NTSTATUS nt_status;
 114         DOM_SID *domain_sid;
 115         char *domain_name;
 116
 117         /* make use of cli_state handed over as an argument, if possible */
 118         if (!cli_arg) {
 119                 cli = net_make_ipc_connection(conn_flags);
 120         } else {
 121                 cli = cli_arg;
 122         }
 123
 124         if (!cli) {
 125                 return -1;
 126         }
 127
 128         /* Create mem_ctx */
 129
 130         if (!(mem_ctx = talloc_init("run_rpc_command"))) {
 131                 DEBUG(0, ("talloc_init() failed\n"));
 132                 cli_shutdown(cli);
 133                 return -1;
 134         }
 135
 136         nt_status = net_get_remote_domain_sid(cli, mem_ctx, &domain_sid,
 137                                               &domain_name);
 138         if (!NT_STATUS_IS_OK(nt_status)) {
 139                 cli_shutdown(cli);
 140                 return -1;
 141         }
 142
 143         if (!(conn_flags & NET_FLAGS_NO_PIPE)) {
 144                 if (lp_client_schannel() && (pipe_idx == PI_NETLOGON)) {
 145                         /* Always try and create an schannel netlogon pipe. */
 146                         pipe_hnd = cli_rpc_pipe_open_schannel(cli, pipe_idx,
 147                                                         PIPE_AUTH_LEVEL_PRIVACY,
 148                                                         domain_name,
 149                                                         &nt_status);
 150                         if (!pipe_hnd) {
 151                                 DEBUG(0, ("Could not initialise schannel netlogon pipe. Error was %s\n",
 152                                         nt_errstr(nt_status) ));
 153                                 cli_shutdown(cli);
 154                                 return -1;
 155                         }
 156                 } else {
 157                         pipe_hnd = cli_rpc_pipe_open_noauth(cli, pipe_idx, &nt_status);
 158                         if (!pipe_hnd) {
 159                                 DEBUG(0, ("Could not initialise pipe %s. Error was %s\n",
 160                                         cli_get_pipe_name(pipe_idx),
 161                                         nt_errstr(nt_status) ));
 162                                 cli_shutdown(cli);
 163                                 return -1;
 164                         }
 165                 }
 166         }
 167
 168         nt_status = fn(domain_sid, domain_name, cli, pipe_hnd, mem_ctx, argc, argv);
 169
 170         if (!NT_STATUS_IS_OK(nt_status)) {
 171                 DEBUG(1, ("rpc command function failed! (%s)\n", nt_errstr(nt_status)));
 172         } else {
 173                 DEBUG(5, ("rpc command function succedded\n"));
 174         }
 175
 176         if (!(conn_flags & NET_FLAGS_NO_PIPE)) {
 177                 if (pipe_hnd) {
 178                         cli_rpc_pipe_close(pipe_hnd);
 179                 }
 180         }
 181
 182         /* close the connection only if it was opened here */
 183         if (!cli_arg) {
 184                 cli_shutdown(cli);
 185         }
 186
 187         talloc_destroy(mem_ctx);
 188         return (!NT_STATUS_IS_OK(nt_status));
 189 }
 190
 191 /**
 192  * Force a change of the trust acccount password.
 193  *
 194  * All parameters are provided by the run_rpc_command function, except for
 195  * argc, argv which are passes through.
 196  *
 197  * @param domain_sid The domain sid aquired from the remote server
 198  * @param cli A cli_state connected to the server.
 199  * @param mem_ctx Talloc context, destoyed on compleation of the function.
 200  * @param argc  Standard main() style argc
 201  * @param argc  Standard main() style argv.  Initial components are already
 202  *              stripped
 203  *
 204  * @return Normal NTSTATUS return.
 205  **/
 206
 207 static NTSTATUS rpc_changetrustpw_internals(const DOM_SID *domain_sid,
 208                                         const char *domain_name,
 209                                         struct cli_state *cli,
 210                                         struct rpc_pipe_client *pipe_hnd,
 211                                         TALLOC_CTX *mem_ctx,
 212                                         int argc,
 213                                         const char **argv)
 214 {
 215
 216         return trust_pw_find_change_and_store_it(pipe_hnd, mem_ctx, opt_target_workgroup);
 217 }
 218
 219 /**
 220  * Force a change of the trust acccount password.
 221  *
 222  * @param argc  Standard main() style argc
 223  * @param argc  Standard main() style argv.  Initial components are already
 224  *              stripped
 225  *
 226  * @return A shell status integer (0 for success)
 227  **/
 228
 229 int net_rpc_changetrustpw(int argc, const char **argv)
 230 {
 231         return run_rpc_command(NULL, PI_NETLOGON, NET_FLAGS_ANONYMOUS | NET_FLAGS_PDC,
 232                                rpc_changetrustpw_internals,
 233                                argc, argv);
 234 }
 235
 236 /**
 237  * Join a domain, the old way.
 238  *
 239  * This uses 'machinename' as the inital password, and changes it.
 240  *
 241  * The password should be created with 'server manager' or equiv first.
 242  *
 243  * All parameters are provided by the run_rpc_command function, except for
 244  * argc, argv which are passes through.
 245  *
 246  * @param domain_sid The domain sid aquired from the remote server
 247  * @param cli A cli_state connected to the server.
 248  * @param mem_ctx Talloc context, destoyed on compleation of the function.
 249  * @param argc  Standard main() style argc
 250  * @param argc  Standard main() style argv.  Initial components are already
 251  *              stripped
 252  *
 253  * @return Normal NTSTATUS return.
 254  **/
 255
 256 static NTSTATUS rpc_oldjoin_internals(const DOM_SID *domain_sid,
 257                                         const char *domain_name,
 258                                         struct cli_state *cli,
 259                                         struct rpc_pipe_client *pipe_hnd,
 260                                         TALLOC_CTX *mem_ctx,
 261                                         int argc,
 262                                         const char **argv)
 263 {
 264
 265         fstring trust_passwd;
 266         unsigned char orig_trust_passwd_hash[16];
 267         NTSTATUS result;
 268         uint32 sec_channel_type;
 269
 270         pipe_hnd = cli_rpc_pipe_open_noauth(cli, PI_NETLOGON, &result);
 271         if (!pipe_hnd) {
 272                 DEBUG(0,("rpc_oldjoin_internals: netlogon pipe open to machine %s failed. "
 273                         "error was %s\n",
 274                         cli->desthost,
 275                         nt_errstr(result) ));
 276                 return result;
 277         }
 278
 279         /*
 280            check what type of join - if the user want's to join as
 281            a BDC, the server must agree that we are a BDC.
 282         */
 283         if (argc >= 0) {
 284                 sec_channel_type = get_sec_channel_type(argv[0]);
 285         } else {
 286                 sec_channel_type = get_sec_channel_type(NULL);
 287         }
 288
 289         fstrcpy(trust_passwd, global_myname());
 290         strlower_m(trust_passwd);
 291
 292         /*
 293          * Machine names can be 15 characters, but the max length on
 294          * a password is 14.  --jerry
 295          */
 296
 297         trust_passwd[14] = '\0';
 298
 299         E_md4hash(trust_passwd, orig_trust_passwd_hash);
 300
 301         result = trust_pw_change_and_store_it(pipe_hnd, mem_ctx, opt_target_workgroup,
 302                                               orig_trust_passwd_hash,
 303                                               sec_channel_type);
 304
 305         if (NT_STATUS_IS_OK(result))
 306                 printf("Joined domain %s.\n",opt_target_workgroup);
 307
 308
 309         if (!secrets_store_domain_sid(opt_target_workgroup, domain_sid)) {
 310                 DEBUG(0, ("error storing domain sid for %s\n", opt_target_workgroup));
 311                 result = NT_STATUS_UNSUCCESSFUL;
 312         }
 313
 314         return result;
 315 }
 316
 317 /**
 318  * Join a domain, the old way.
 319  *
 320  * @param argc  Standard main() style argc
 321  * @param argc  Standard main() style argv.  Initial components are already
 322  *              stripped
 323  *
 324  * @return A shell status integer (0 for success)
 325  **/
 326
 327 static int net_rpc_perform_oldjoin(int argc, const char **argv)
 328 {
 329         return run_rpc_command(NULL, PI_NETLOGON,
 330                                NET_FLAGS_NO_PIPE | NET_FLAGS_ANONYMOUS | NET_FLAGS_PDC,
 331                                rpc_oldjoin_internals,
 332                                argc, argv);
 333 }
 334
 335 /**
 336  * Join a domain, the old way.  This function exists to allow
 337  * the message to be displayed when oldjoin was explicitly
 338  * requested, but not when it was implied by "net rpc join"
 339  *
 340  * @param argc  Standard main() style argc
 341  * @param argc  Standard main() style argv.  Initial components are already
 342  *              stripped
 343  *
 344  * @return A shell status integer (0 for success)
 345  **/
 346
 347 static int net_rpc_oldjoin(int argc, const char **argv)
 348 {
 349         int rc = net_rpc_perform_oldjoin(argc, argv);
 350
 351         if (rc) {
 352                 d_fprintf(stderr, "Failed to join domain\n");
 353         }
 354
 355         return rc;
 356 }
 357
 358 /**
 359  * Basic usage function for 'net rpc join'
 360  * @param argc  Standard main() style argc
 361  * @param argc  Standard main() style argv.  Initial components are already
 362  *              stripped
 363  **/
 364
 365 static int rpc_join_usage(int argc, const char **argv)
 366 {
 367         d_printf("net rpc join -U <username>[%%password] <type>[options]\n"\
 368                  "\t to join a domain with admin username & password\n"\
 369                  "\t\t password will be prompted if needed and none is specified\n"\
 370                  "\t <type> can be (default MEMBER)\n"\
 371                  "\t\t BDC - Join as a BDC\n"\
 372                  "\t\t PDC - Join as a PDC\n"\
 373                  "\t\t MEMBER - Join as a MEMBER server\n");
 374
 375         net_common_flags_usage(argc, argv);
 376         return -1;
 377 }
 378
 379 /**
 380  * 'net rpc join' entrypoint.
 381  * @param argc  Standard main() style argc
 382  * @param argc  Standard main() style argv.  Initial components are already
 383  *              stripped
 384  *
 385  * Main 'net_rpc_join()' (where the admain username/password is used) is
 386  * in net_rpc_join.c
 387  * Try to just change the password, but if that doesn't work, use/prompt
 388  * for a username/password.
 389  **/
 390
 391 int net_rpc_join(int argc, const char **argv)
 392 {
 393         if (lp_server_role() == ROLE_STANDALONE) {
 394                 d_printf("cannot join as standalone machine\n");
 395                 return -1;
 396         }
 397
 398         if (strlen(global_myname()) > 15) {
 399                 d_printf("Our netbios name can be at most 15 chars long, "
 400                          "\"%s\" is %u chars long\n",
 401                          global_myname(), (unsigned int)strlen(global_myname()));
 402                 return -1;
 403         }
 404
 405         if ((net_rpc_perform_oldjoin(argc, argv) == 0))
 406                 return 0;
 407
 408         return net_rpc_join_newstyle(argc, argv);
 409 }
 410
 411 /**
 412  * display info about a rpc domain
 413  *
 414  * All parameters are provided by the run_rpc_command function, except for
 415  * argc, argv which are passed through.
 416  *
 417  * @param domain_sid The domain sid acquired from the remote server
 418  * @param cli A cli_state connected to the server.
 419  * @param mem_ctx Talloc context, destoyed on completion of the function.
 420  * @param argc  Standard main() style argc
 421  * @param argv  Standard main() style argv.  Initial components are already
 422  *              stripped
 423  *
 424  * @return Normal NTSTATUS return.
 425  **/
 426
 427 NTSTATUS rpc_info_internals(const DOM_SID *domain_sid,
 428                         const char *domain_name,
 429                         struct cli_state *cli,
 430                         struct rpc_pipe_client *pipe_hnd,
 431                         TALLOC_CTX *mem_ctx,
 432                         int argc,
 433                         const char **argv)
 434 {
 435         POLICY_HND connect_pol, domain_pol;
 436         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 437         SAM_UNK_CTR ctr;
 438         fstring sid_str;
 439
 440         sid_to_string(sid_str, domain_sid);
 441
 442         /* Get sam policy handle */
 443         result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
 444                                   &connect_pol);
 445         if (!NT_STATUS_IS_OK(result)) {
 446                 d_fprintf(stderr, "Could not connect to SAM: %s\n", nt_errstr(result));
 447                 goto done;
 448         }
 449
 450         /* Get domain policy handle */
 451         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
 452                                       MAXIMUM_ALLOWED_ACCESS,
 453                                       domain_sid, &domain_pol);
 454         if (!NT_STATUS_IS_OK(result)) {
 455                 d_fprintf(stderr, "Could not open domain: %s\n", nt_errstr(result));
 456                 goto done;
 457         }
 458
 459         ZERO_STRUCT(ctr);
 460         result = rpccli_samr_query_dom_info(pipe_hnd, mem_ctx, &domain_pol,
 461                                          2, &ctr);
 462         if (NT_STATUS_IS_OK(result)) {
 463                 TALLOC_CTX *ctx = talloc_init("rpc_info_internals");
 464                 d_printf("Domain Name: %s\n", unistr2_tdup(ctx, &ctr.info.inf2.uni_domain));
 465                 d_printf("Domain SID: %s\n", sid_str);
 466                 d_printf("Sequence number: %llu\n", (unsigned long long)ctr.info.inf2.seq_num);
 467                 d_printf("Num users: %u\n", ctr.info.inf2.num_domain_usrs);
 468                 d_printf("Num domain groups: %u\n", ctr.info.inf2.num_domain_grps);
 469                 d_printf("Num local groups: %u\n", ctr.info.inf2.num_local_grps);
 470                 talloc_destroy(ctx);
 471         }
 472
 473  done:
 474         return result;
 475 }
 476
 477 /**
 478  * 'net rpc info' entrypoint.
 479  * @param argc  Standard main() style argc
 480  * @param argc  Standard main() style argv.  Initial components are already
 481  *              stripped
 482  **/
 483
 484 int net_rpc_info(int argc, const char **argv)
 485 {
 486         return run_rpc_command(NULL, PI_SAMR, NET_FLAGS_PDC,
 487                                rpc_info_internals,
 488                                argc, argv);
 489 }
 490
 491 /**
 492  * Fetch domain SID into the local secrets.tdb
 493  *
 494  * All parameters are provided by the run_rpc_command function, except for
 495  * argc, argv which are passes through.
 496  *
 497  * @param domain_sid The domain sid acquired from the remote server
 498  * @param cli A cli_state connected to the server.
 499  * @param mem_ctx Talloc context, destoyed on completion of the function.
 500  * @param argc  Standard main() style argc
 501  * @param argv  Standard main() style argv.  Initial components are already
 502  *              stripped
 503  *
 504  * @return Normal NTSTATUS return.
 505  **/
 506
 507 static NTSTATUS rpc_getsid_internals(const DOM_SID *domain_sid,
 508                         const char *domain_name,
 509                         struct cli_state *cli,
 510                         struct rpc_pipe_client *pipe_hnd,
 511                         TALLOC_CTX *mem_ctx,
 512                         int argc,
 513                         const char **argv)
 514 {
 515         fstring sid_str;
 516
 517         sid_to_string(sid_str, domain_sid);
 518         d_printf("Storing SID %s for Domain %s in secrets.tdb\n",
 519                  sid_str, domain_name);
 520
 521         if (!secrets_store_domain_sid(domain_name, domain_sid)) {
 522                 DEBUG(0,("Can't store domain SID\n"));
 523                 return NT_STATUS_UNSUCCESSFUL;
 524         }
 525
 526         return NT_STATUS_OK;
 527 }
 528
 529 /**
 530  * 'net rpc getsid' entrypoint.
 531  * @param argc  Standard main() style argc
 532  * @param argc  Standard main() style argv.  Initial components are already
 533  *              stripped
 534  **/
 535
 536 int net_rpc_getsid(int argc, const char **argv)
 537 {
 538         return run_rpc_command(NULL, PI_SAMR, NET_FLAGS_ANONYMOUS | NET_FLAGS_PDC,
 539                                rpc_getsid_internals,
 540                                argc, argv);
 541 }
 542
 543 /****************************************************************************/
 544
 545 /**
 546  * Basic usage function for 'net rpc user'
 547  * @param argc  Standard main() style argc.
 548  * @param argv  Standard main() style argv.  Initial components are already
 549  *              stripped.
 550  **/
 551
 552 static int rpc_user_usage(int argc, const char **argv)
 553 {
 554         return net_help_user(argc, argv);
 555 }
 556
 557 /**
 558  * Add a new user to a remote RPC server
 559  *
 560  * All parameters are provided by the run_rpc_command function, except for
 561  * argc, argv which are passes through.
 562  *
 563  * @param domain_sid The domain sid acquired from the remote server
 564  * @param cli A cli_state connected to the server.
 565  * @param mem_ctx Talloc context, destoyed on completion of the function.
 566  * @param argc  Standard main() style argc
 567  * @param argv  Standard main() style argv.  Initial components are already
 568  *              stripped
 569  *
 570  * @return Normal NTSTATUS return.
 571  **/
 572
 573 static NTSTATUS rpc_user_add_internals(const DOM_SID *domain_sid,
 574                                 const char *domain_name,
 575                                 struct cli_state *cli,
 576                                 struct rpc_pipe_client *pipe_hnd,
 577                                 TALLOC_CTX *mem_ctx,
 578                                 int argc, const char **argv)
 579 {
 580
 581         POLICY_HND connect_pol, domain_pol, user_pol;
 582         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 583         const char *acct_name;
 584         uint32 acb_info;
 585         uint32 unknown, user_rid;
 586
 587         if (argc < 1) {
 588                 d_printf("User must be specified\n");
 589                 rpc_user_usage(argc, argv);
 590                 return NT_STATUS_OK;
 591         }
 592
 593         acct_name = argv[0];
 594
 595         /* Get sam policy handle */
 596
 597         result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
 598                                   &connect_pol);
 599         if (!NT_STATUS_IS_OK(result)) {
 600                 goto done;
 601         }
 602
 603         /* Get domain policy handle */
 604
 605         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
 606                                       MAXIMUM_ALLOWED_ACCESS,
 607                                       domain_sid, &domain_pol);
 608         if (!NT_STATUS_IS_OK(result)) {
 609                 goto done;
 610         }
 611
 612         /* Create domain user */
 613
 614         acb_info = ACB_NORMAL;
 615         unknown = 0xe005000b; /* No idea what this is - a permission mask? */
 616
 617         result = rpccli_samr_create_dom_user(pipe_hnd, mem_ctx, &domain_pol,
 618                                           acct_name, acb_info, unknown,
 619                                           &user_pol, &user_rid);
 620         if (!NT_STATUS_IS_OK(result)) {
 621                 goto done;
 622         }
 623
 624         if (argc == 2) {
 625
 626                 uint32 *user_rids, num_rids, *name_types;
 627                 uint32 flags = 0x000003e8; /* Unknown */
 628                 SAM_USERINFO_CTR ctr;
 629                 SAM_USER_INFO_24 p24;
 630                 uchar pwbuf[516];
 631
 632                 result = rpccli_samr_lookup_names(pipe_hnd, mem_ctx, &domain_pol,
 633                                                   flags, 1, &acct_name,
 634                                                   &num_rids, &user_rids,
 635                                                   &name_types);
 636
 637                 if (!NT_STATUS_IS_OK(result)) {
 638                         goto done;
 639                 }
 640
 641                 result = rpccli_samr_open_user(pipe_hnd, mem_ctx, &domain_pol,
 642                                                MAXIMUM_ALLOWED_ACCESS,
 643                                                user_rids[0], &user_pol);
 644
 645                 if (!NT_STATUS_IS_OK(result)) {
 646                         goto done;
 647                 }
 648
 649                 /* Set password on account */
 650
 651                 ZERO_STRUCT(ctr);
 652                 ZERO_STRUCT(p24);
 653
 654                 encode_pw_buffer(pwbuf, argv[1], STR_UNICODE);
 655
 656                 init_sam_user_info24(&p24, (char *)pwbuf,24);
 657
 658                 ctr.switch_value = 24;
 659                 ctr.info.id24 = &p24;
 660
 661                 result = rpccli_samr_set_userinfo(pipe_hnd, mem_ctx, &user_pol, 24,
 662                                                &cli->user_session_key, &ctr);
 663
 664                 if (!NT_STATUS_IS_OK(result)) {
 665                         d_fprintf(stderr, "Failed to set password for user %s - %s\n",
 666                                  acct_name, nt_errstr(result));
 667
 668                         result = rpccli_samr_delete_dom_user(pipe_hnd, mem_ctx, &user_pol);
 669
 670                         if (!NT_STATUS_IS_OK(result)) {
 671                                 d_fprintf(stderr, "Failed to delete user %s - %s\n",
 672                                          acct_name, nt_errstr(result));
 673                                  return result;
 674                         }
 675                 }
 676
 677         }
 678  done:
 679         if (!NT_STATUS_IS_OK(result)) {
 680                 d_fprintf(stderr, "Failed to add user %s - %s\n", acct_name,
 681                          nt_errstr(result));
 682         } else {
 683                 d_printf("Added user %s\n", acct_name);
 684         }
 685         return result;
 686 }
 687
 688 /**
 689  * Add a new user to a remote RPC server
 690  *
 691  * @param argc  Standard main() style argc
 692  * @param argv  Standard main() style argv.  Initial components are already
 693  *              stripped
 694  *
 695  * @return A shell status integer (0 for success)
 696  **/
 697
 698 static int rpc_user_add(int argc, const char **argv)
 699 {
 700         return run_rpc_command(NULL, PI_SAMR, 0, rpc_user_add_internals,
 701                                argc, argv);
 702 }
 703
 704 /**
 705  * Delete a user from a remote RPC server
 706  *
 707  * All parameters are provided by the run_rpc_command function, except for
 708  * argc, argv which are passes through.
 709  *
 710  * @param domain_sid The domain sid acquired from the remote server
 711  * @param cli A cli_state connected to the server.
 712  * @param mem_ctx Talloc context, destoyed on completion of the function.
 713  * @param argc  Standard main() style argc
 714  * @param argv  Standard main() style argv.  Initial components are already
 715  *              stripped
 716  *
 717  * @return Normal NTSTATUS return.
 718  **/
 719
 720 static NTSTATUS rpc_user_del_internals(const DOM_SID *domain_sid,
 721                                         const char *domain_name,
 722                                         struct cli_state *cli,
 723                                         struct rpc_pipe_client *pipe_hnd,
 724                                         TALLOC_CTX *mem_ctx,
 725                                         int argc,
 726                                         const char **argv)
 727 {
 728         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 729         POLICY_HND connect_pol, domain_pol, user_pol;
 730
 731         if (argc < 1) {
 732                 d_printf("User must be specified\n");
 733                 rpc_user_usage(argc, argv);
 734                 return NT_STATUS_OK;
 735         }
 736         /* Get sam policy and domain handles */
 737
 738         result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
 739                                   &connect_pol);
 740
 741         if (!NT_STATUS_IS_OK(result)) {
 742                 goto done;
 743         }
 744
 745         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
 746                                       MAXIMUM_ALLOWED_ACCESS,
 747                                       domain_sid, &domain_pol);
 748
 749         if (!NT_STATUS_IS_OK(result)) {
 750                 goto done;
 751         }
 752
 753         /* Get handle on user */
 754
 755         {
 756                 uint32 *user_rids, num_rids, *name_types;
 757                 uint32 flags = 0x000003e8; /* Unknown */
 758
 759                 result = rpccli_samr_lookup_names(pipe_hnd, mem_ctx, &domain_pol,
 760                                                flags, 1, &argv[0],
 761                                                &num_rids, &user_rids,
 762                                                &name_types);
 763
 764                 if (!NT_STATUS_IS_OK(result)) {
 765                         goto done;
 766                 }
 767
 768                 result = rpccli_samr_open_user(pipe_hnd, mem_ctx, &domain_pol,
 769                                             MAXIMUM_ALLOWED_ACCESS,
 770                                             user_rids[0], &user_pol);
 771
 772                 if (!NT_STATUS_IS_OK(result)) {
 773                         goto done;
 774                 }
 775         }
 776
 777         /* Delete user */
 778
 779         result = rpccli_samr_delete_dom_user(pipe_hnd, mem_ctx, &user_pol);
 780
 781         if (!NT_STATUS_IS_OK(result)) {
 782                 goto done;
 783         }
 784
 785         /* Display results */
 786         if (!NT_STATUS_IS_OK(result)) {
 787                 d_fprintf(stderr, "Failed to delete user account - %s\n", nt_errstr(result));
 788         } else {
 789                 d_printf("Deleted user account\n");
 790         }
 791
 792  done:
 793         return result;
 794 }
 795
 796 /**
 797  * Rename a user on a remote RPC server
 798  *
 799  * All parameters are provided by the run_rpc_command function, except for
 800  * argc, argv which are passes through.
 801  *
 802  * @param domain_sid The domain sid acquired from the remote server
 803  * @param cli A cli_state connected to the server.
 804  * @param mem_ctx Talloc context, destoyed on completion of the function.
 805  * @param argc  Standard main() style argc
 806  * @param argv  Standard main() style argv.  Initial components are already
 807  *              stripped
 808  *
 809  * @return Normal NTSTATUS return.
 810  **/
 811
 812 static NTSTATUS rpc_user_rename_internals(const DOM_SID *domain_sid,
 813                                         const char *domain_name,
 814                                         struct cli_state *cli,
 815                                         struct rpc_pipe_client *pipe_hnd,
 816                                         TALLOC_CTX *mem_ctx,
 817                                         int argc,
 818                                         const char **argv)
 819 {
 820         POLICY_HND connect_pol, domain_pol, user_pol;
 821         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 822         uint32 info_level = 7;
 823         const char *old_name, *new_name;
 824         uint32 *user_rid;
 825         uint32 flags = 0x000003e8; /* Unknown */
 826         uint32 num_rids, *name_types;
 827         uint32 num_names = 1;
 828         const char **names;
 829         SAM_USERINFO_CTR *user_ctr;
 830         SAM_USERINFO_CTR ctr;
 831         SAM_USER_INFO_7 info7;
 832
 833         if (argc != 2) {
 834                 d_printf("Old and new username must be specified\n");
 835                 rpc_user_usage(argc, argv);
 836                 return NT_STATUS_OK;
 837         }
 838
 839         old_name = argv[0];
 840         new_name = argv[1];
 841
 842         ZERO_STRUCT(ctr);
 843         ZERO_STRUCT(user_ctr);
 844
 845         /* Get sam policy handle */
 846
 847         result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
 848                                   &connect_pol);
 849         if (!NT_STATUS_IS_OK(result)) {
 850                 goto done;
 851         }
 852
 853         /* Get domain policy handle */
 854
 855         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
 856                                       MAXIMUM_ALLOWED_ACCESS,
 857                                       domain_sid, &domain_pol);
 858         if (!NT_STATUS_IS_OK(result)) {
 859                 goto done;
 860         }
 861
 862         if ((names = TALLOC_ARRAY(mem_ctx, const char *, num_names)) == NULL) {
 863                 result = NT_STATUS_NO_MEMORY;
 864                 goto done;
 865         }
 866         names[0] = old_name;
 867         result = rpccli_samr_lookup_names(pipe_hnd, mem_ctx, &domain_pol,
 868                                        flags, num_names, names,
 869                                        &num_rids, &user_rid, &name_types);
 870         if (!NT_STATUS_IS_OK(result)) {
 871                 goto done;
 872         }
 873
 874         /* Open domain user */
 875         result = rpccli_samr_open_user(pipe_hnd, mem_ctx, &domain_pol,
 876                                     MAXIMUM_ALLOWED_ACCESS, user_rid[0], &user_pol);
 877
 878         if (!NT_STATUS_IS_OK(result)) {
 879                 goto done;
 880         }
 881
 882         /* Query user info */
 883         result = rpccli_samr_query_userinfo(pipe_hnd, mem_ctx, &user_pol,
 884                                          info_level, &user_ctr);
 885
 886         if (!NT_STATUS_IS_OK(result)) {
 887                 goto done;
 888         }
 889
 890         ctr.switch_value = info_level;
 891         ctr.info.id7 = &info7;
 892
 893         init_sam_user_info7(&info7, new_name);
 894
 895         /* Set new name */
 896         result = rpccli_samr_set_userinfo(pipe_hnd, mem_ctx, &user_pol,
 897                                        info_level, &cli->user_session_key, &ctr);
 898
 899         if (!NT_STATUS_IS_OK(result)) {
 900                 goto done;
 901         }
 902
 903  done:
 904         if (!NT_STATUS_IS_OK(result)) {
 905                 d_fprintf(stderr, "Failed to rename user from %s to %s - %s\n", old_name, new_name,
 906                          nt_errstr(result));
 907         } else {
 908                 d_printf("Renamed user from %s to %s\n", old_name, new_name);
 909         }
 910         return result;
 911 }
 912
 913 /**
 914  * Rename a user on 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_rename(int argc, const char **argv)
 924 {
 925         return run_rpc_command(NULL, PI_SAMR, 0, rpc_user_rename_internals,
 926                                argc, argv);
 927 }
 928
 929 /**
 930  * Delete a user from a remote RPC server
 931  *
 932  * @param argc  Standard main() style argc
 933  * @param argv  Standard main() style argv.  Initial components are already
 934  *              stripped
 935  *
 936  * @return A shell status integer (0 for success)
 937  **/
 938
 939 static int rpc_user_delete(int argc, const char **argv)
 940 {
 941         return run_rpc_command(NULL, PI_SAMR, 0, rpc_user_del_internals,
 942                                argc, argv);
 943 }
 944
 945 /**
 946  * Set a password for a user on a remote RPC server
 947  *
 948  * All parameters are provided by the run_rpc_command function, except for
 949  * argc, argv which are passes through.
 950  *
 951  * @param domain_sid The domain sid acquired from the remote server
 952  * @param cli A cli_state connected to the server.
 953  * @param mem_ctx Talloc context, destoyed on completion of the function.
 954  * @param argc  Standard main() style argc
 955  * @param argv  Standard main() style argv.  Initial components are already
 956  *              stripped
 957  *
 958  * @return Normal NTSTATUS return.
 959  **/
 960
 961 static NTSTATUS rpc_user_password_internals(const DOM_SID *domain_sid,
 962                                         const char *domain_name,
 963                                         struct cli_state *cli,
 964                                         struct rpc_pipe_client *pipe_hnd,
 965                                         TALLOC_CTX *mem_ctx,
 966                                         int argc,
 967                                         const char **argv)
 968 {
 969         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 970         POLICY_HND connect_pol, domain_pol, user_pol;
 971         SAM_USERINFO_CTR ctr;
 972         SAM_USER_INFO_24 p24;
 973         uchar pwbuf[516];
 974         const char *user;
 975         const char *new_password;
 976         char *prompt = NULL;
 977
 978         if (argc < 1) {
 979                 d_printf("User must be specified\n");
 980                 rpc_user_usage(argc, argv);
 981                 return NT_STATUS_OK;
 982         }
 983
 984         user = argv[0];
 985
 986         if (argv[1]) {
 987                 new_password = argv[1];
 988         } else {
 989                 asprintf(&prompt, "Enter new password for %s:", user);
 990                 new_password = getpass(prompt);
 991                 SAFE_FREE(prompt);
 992         }
 993
 994         /* Get sam policy and domain handles */
 995
 996         result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
 997                                   &connect_pol);
 998
 999         if (!NT_STATUS_IS_OK(result)) {
1000                 goto done;
1001         }
1002
1003         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
1004                                       MAXIMUM_ALLOWED_ACCESS,
1005                                       domain_sid, &domain_pol);
1006
1007         if (!NT_STATUS_IS_OK(result)) {
1008                 goto done;
1009         }
1010
1011         /* Get handle on user */
1012
1013         {
1014                 uint32 *user_rids, num_rids, *name_types;
1015                 uint32 flags = 0x000003e8; /* Unknown */
1016
1017                 result = rpccli_samr_lookup_names(pipe_hnd, mem_ctx, &domain_pol,
1018                                                flags, 1, &user,
1019                                                &num_rids, &user_rids,
1020                                                &name_types);
1021
1022                 if (!NT_STATUS_IS_OK(result)) {
1023                         goto done;
1024                 }
1025
1026                 result = rpccli_samr_open_user(pipe_hnd, mem_ctx, &domain_pol,
1027                                             MAXIMUM_ALLOWED_ACCESS,
1028                                             user_rids[0], &user_pol);
1029
1030                 if (!NT_STATUS_IS_OK(result)) {
1031                         goto done;
1032                 }
1033         }
1034
1035         /* Set password on account */
1036
1037         ZERO_STRUCT(ctr);
1038         ZERO_STRUCT(p24);
1039
1040         encode_pw_buffer(pwbuf, new_password, STR_UNICODE);
1041
1042         init_sam_user_info24(&p24, (char *)pwbuf,24);
1043
1044         ctr.switch_value = 24;
1045         ctr.info.id24 = &p24;
1046
1047         result = rpccli_samr_set_userinfo(pipe_hnd, mem_ctx, &user_pol, 24,
1048                                        &cli->user_session_key, &ctr);
1049
1050         if (!NT_STATUS_IS_OK(result)) {
1051                 goto done;
1052         }
1053
1054         /* Display results */
1055
1056  done:
1057         return result;
1058
1059 }
1060
1061 /**
1062  * Set a user's password on a remote RPC server
1063  *
1064  * @param argc  Standard main() style argc
1065  * @param argv  Standard main() style argv.  Initial components are already
1066  *              stripped
1067  *
1068  * @return A shell status integer (0 for success)
1069  **/
1070
1071 static int rpc_user_password(int argc, const char **argv)
1072 {
1073         return run_rpc_command(NULL, PI_SAMR, 0, rpc_user_password_internals,
1074                                argc, argv);
1075 }
1076
1077 /**
1078  * List user's groups on a remote RPC server
1079  *
1080  * All parameters are provided by the run_rpc_command function, except for
1081  * argc, argv which are passes through.
1082  *
1083  * @param domain_sid The domain sid acquired from the remote server
1084  * @param cli A cli_state connected to the server.
1085  * @param mem_ctx Talloc context, destoyed on completion of the function.
1086  * @param argc  Standard main() style argc
1087  * @param argv  Standard main() style argv.  Initial components are already
1088  *              stripped
1089  *
1090  * @return Normal NTSTATUS return.
1091  **/
1092
1093 static NTSTATUS rpc_user_info_internals(const DOM_SID *domain_sid,
1094                         const char *domain_name,
1095                         struct cli_state *cli,
1096                         struct rpc_pipe_client *pipe_hnd,
1097                         TALLOC_CTX *mem_ctx,
1098                         int argc,
1099                         const char **argv)
1100 {
1101         POLICY_HND connect_pol, domain_pol, user_pol;
1102         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1103         uint32 *rids, num_rids, *name_types, num_names;
1104         uint32 flags = 0x000003e8; /* Unknown */
1105         int i;
1106         char **names;
1107         DOM_GID *user_gids;
1108
1109         if (argc < 1) {
1110                 d_printf("User must be specified\n");
1111                 rpc_user_usage(argc, argv);
1112                 return NT_STATUS_OK;
1113         }
1114         /* Get sam policy handle */
1115
1116         result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1117                                   &connect_pol);
1118         if (!NT_STATUS_IS_OK(result)) goto done;
1119
1120         /* Get domain policy handle */
1121
1122         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
1123                                       MAXIMUM_ALLOWED_ACCESS,
1124                                       domain_sid, &domain_pol);
1125         if (!NT_STATUS_IS_OK(result)) goto done;
1126
1127         /* Get handle on user */
1128
1129         result = rpccli_samr_lookup_names(pipe_hnd, mem_ctx, &domain_pol,
1130                                        flags, 1, &argv[0],
1131                                        &num_rids, &rids, &name_types);
1132
1133         if (!NT_STATUS_IS_OK(result)) goto done;
1134
1135         result = rpccli_samr_open_user(pipe_hnd, mem_ctx, &domain_pol,
1136                                     MAXIMUM_ALLOWED_ACCESS,
1137                                     rids[0], &user_pol);
1138         if (!NT_STATUS_IS_OK(result)) goto done;
1139
1140         result = rpccli_samr_query_usergroups(pipe_hnd, mem_ctx, &user_pol,
1141                                            &num_rids, &user_gids);
1142
1143         if (!NT_STATUS_IS_OK(result)) goto done;
1144
1145         /* Look up rids */
1146
1147         if (num_rids) {
1148                 if ((rids = TALLOC_ARRAY(mem_ctx, uint32, num_rids)) == NULL) {
1149                         result = NT_STATUS_NO_MEMORY;
1150                         goto done;
1151                 }
1152
1153                 for (i = 0; i < num_rids; i++)
1154                         rids[i] = user_gids[i].g_rid;
1155
1156                 result = rpccli_samr_lookup_rids(pipe_hnd, mem_ctx, &domain_pol,
1157                                               num_rids, rids,
1158                                               &num_names, &names, &name_types);
1159
1160                 if (!NT_STATUS_IS_OK(result)) {
1161                         goto done;
1162                 }
1163
1164                 /* Display results */
1165
1166                 for (i = 0; i < num_names; i++)
1167                         printf("%s\n", names[i]);
1168         }
1169  done:
1170         return result;
1171 }
1172
1173 /**
1174  * List a user's groups from a remote RPC server
1175  *
1176  * @param argc  Standard main() style argc
1177  * @param argv  Standard main() style argv.  Initial components are already
1178  *              stripped
1179  *
1180  * @return A shell status integer (0 for success)
1181  **/
1182
1183 static int rpc_user_info(int argc, const char **argv)
1184 {
1185         return run_rpc_command(NULL, PI_SAMR, 0, rpc_user_info_internals,
1186                                argc, argv);
1187 }
1188
1189 /**
1190  * List users on a remote RPC server
1191  *
1192  * All parameters are provided by the run_rpc_command function, except for
1193  * argc, argv which are passes through.
1194  *
1195  * @param domain_sid The domain sid acquired from the remote server
1196  * @param cli A cli_state connected to the server.
1197  * @param mem_ctx Talloc context, destoyed on completion of the function.
1198  * @param argc  Standard main() style argc
1199  * @param argv  Standard main() style argv.  Initial components are already
1200  *              stripped
1201  *
1202  * @return Normal NTSTATUS return.
1203  **/
1204
1205 static NTSTATUS rpc_user_list_internals(const DOM_SID *domain_sid,
1206                                         const char *domain_name,
1207                                         struct cli_state *cli,
1208                                         struct rpc_pipe_client *pipe_hnd,
1209                                         TALLOC_CTX *mem_ctx,
1210                                         int argc,
1211                                         const char **argv)
1212 {
1213         POLICY_HND connect_pol, domain_pol;
1214         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1215         uint32 start_idx=0, num_entries, i, loop_count = 0;
1216         SAM_DISPINFO_CTR ctr;
1217         SAM_DISPINFO_1 info1;
1218
1219         /* Get sam policy handle */
1220
1221         result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1222                                   &connect_pol);
1223         if (!NT_STATUS_IS_OK(result)) {
1224                 goto done;
1225         }
1226
1227         /* Get domain policy handle */
1228
1229         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
1230                                       MAXIMUM_ALLOWED_ACCESS,
1231                                       domain_sid, &domain_pol);
1232         if (!NT_STATUS_IS_OK(result)) {
1233                 goto done;
1234         }
1235
1236         /* Query domain users */
1237         ZERO_STRUCT(ctr);
1238         ZERO_STRUCT(info1);
1239         ctr.sam.info1 = &info1;
1240         if (opt_long_list_entries)
1241                 d_printf("\nUser name             Comment"\
1242                          "\n-----------------------------\n");
1243         do {
1244                 fstring user, desc;
1245                 uint32 max_entries, max_size;
1246
1247                 get_query_dispinfo_params(
1248                         loop_count, &max_entries, &max_size);
1249
1250                 result = rpccli_samr_query_dispinfo(pipe_hnd, mem_ctx, &domain_pol,
1251                                                  &start_idx, 1, &num_entries,
1252                                                  max_entries, max_size, &ctr);
1253                 loop_count++;
1254
1255                 for (i = 0; i < num_entries; i++) {
1256                         unistr2_to_ascii(user, &(&ctr.sam.info1->str[i])->uni_acct_name, sizeof(user)-1);
1257                         if (opt_long_list_entries)
1258                                 unistr2_to_ascii(desc, &(&ctr.sam.info1->str[i])->uni_acct_desc, sizeof(desc)-1);
1259
1260                         if (opt_long_list_entries)
1261                                 printf("%-21.21s %s\n", user, desc);
1262                         else
1263                                 printf("%s\n", user);
1264                 }
1265         } while (NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES));
1266
1267  done:
1268         return result;
1269 }
1270
1271 /**
1272  * 'net rpc user' entrypoint.
1273  * @param argc  Standard main() style argc
1274  * @param argc  Standard main() style argv.  Initial components are already
1275  *              stripped
1276  **/
1277
1278 int net_rpc_user(int argc, const char **argv)
1279 {
1280         struct functable func[] = {
1281                 {"add", rpc_user_add},
1282                 {"info", rpc_user_info},
1283                 {"delete", rpc_user_delete},
1284                 {"password", rpc_user_password},
1285                 {"rename", rpc_user_rename},
1286                 {NULL, NULL}
1287         };
1288
1289         if (argc == 0) {
1290                 return run_rpc_command(NULL,PI_SAMR, 0,
1291                                        rpc_user_list_internals,
1292                                        argc, argv);
1293         }
1294
1295         return net_run_function(argc, argv, func, rpc_user_usage);
1296 }
1297
1298 static NTSTATUS rpc_sh_user_list(TALLOC_CTX *mem_ctx,
1299                                  struct rpc_sh_ctx *ctx,
1300                                  struct rpc_pipe_client *pipe_hnd,
1301                                  int argc, const char **argv)
1302 {
1303         return rpc_user_list_internals(ctx->domain_sid, ctx->domain_name,
1304                                        ctx->cli, pipe_hnd, mem_ctx,
1305                                        argc, argv);
1306 }
1307
1308 static NTSTATUS rpc_sh_user_info(TALLOC_CTX *mem_ctx,
1309                                  struct rpc_sh_ctx *ctx,
1310                                  struct rpc_pipe_client *pipe_hnd,
1311                                  int argc, const char **argv)
1312 {
1313         return rpc_user_info_internals(ctx->domain_sid, ctx->domain_name,
1314                                        ctx->cli, pipe_hnd, mem_ctx,
1315                                        argc, argv);
1316 }
1317
1318 static NTSTATUS rpc_sh_handle_user(TALLOC_CTX *mem_ctx,
1319                                    struct rpc_sh_ctx *ctx,
1320                                    struct rpc_pipe_client *pipe_hnd,
1321                                    int argc, const char **argv,
1322                                    NTSTATUS (*fn)(
1323                                            TALLOC_CTX *mem_ctx,
1324                                            struct rpc_sh_ctx *ctx,
1325                                            struct rpc_pipe_client *pipe_hnd,
1326                                            const POLICY_HND *user_hnd,
1327                                            int argc, const char **argv))
1328
1329 {
1330         POLICY_HND connect_pol, domain_pol, user_pol;
1331         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1332         DOM_SID sid;
1333         uint32 rid;
1334         enum lsa_SidType type;
1335
1336         if (argc == 0) {
1337                 d_fprintf(stderr, "usage: %s <username>\n", ctx->whoami);
1338                 return NT_STATUS_INVALID_PARAMETER;
1339         }
1340
1341         ZERO_STRUCT(connect_pol);
1342         ZERO_STRUCT(domain_pol);
1343         ZERO_STRUCT(user_pol);
1344
1345         result = net_rpc_lookup_name(mem_ctx, pipe_hnd->cli, argv[0],
1346                                      NULL, NULL, &sid, &type);
1347         if (!NT_STATUS_IS_OK(result)) {
1348                 d_fprintf(stderr, "Could not lookup %s: %s\n", argv[0],
1349                           nt_errstr(result));
1350                 goto done;
1351         }
1352
1353         if (type != SID_NAME_USER) {
1354                 d_fprintf(stderr, "%s is a %s, not a user\n", argv[0],
1355                           sid_type_lookup(type));
1356                 result = NT_STATUS_NO_SUCH_USER;
1357                 goto done;
1358         }
1359
1360         if (!sid_peek_check_rid(ctx->domain_sid, &sid, &rid)) {
1361                 d_fprintf(stderr, "%s is not in our domain\n", argv[0]);
1362                 result = NT_STATUS_NO_SUCH_USER;
1363                 goto done;
1364         }
1365
1366         result = rpccli_samr_connect(pipe_hnd, mem_ctx,
1367                                      MAXIMUM_ALLOWED_ACCESS, &connect_pol);
1368         if (!NT_STATUS_IS_OK(result)) {
1369                 goto done;
1370         }
1371
1372         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
1373                                          MAXIMUM_ALLOWED_ACCESS,
1374                                          ctx->domain_sid, &domain_pol);
1375         if (!NT_STATUS_IS_OK(result)) {
1376                 goto done;
1377         }
1378
1379         result = rpccli_samr_open_user(pipe_hnd, mem_ctx, &domain_pol,
1380                                        MAXIMUM_ALLOWED_ACCESS,
1381                                        rid, &user_pol);
1382         if (!NT_STATUS_IS_OK(result)) {
1383                 goto done;
1384         }
1385
1386         result = fn(mem_ctx, ctx, pipe_hnd, &user_pol, argc-1, argv+1);
1387
1388  done:
1389         if (is_valid_policy_hnd(&user_pol)) {
1390                 rpccli_samr_close(pipe_hnd, mem_ctx, &user_pol);
1391         }
1392         if (is_valid_policy_hnd(&domain_pol)) {
1393                 rpccli_samr_close(pipe_hnd, mem_ctx, &domain_pol);
1394         }
1395         if (is_valid_policy_hnd(&connect_pol)) {
1396                 rpccli_samr_close(pipe_hnd, mem_ctx, &connect_pol);
1397         }
1398         return result;
1399 }
1400
1401 static NTSTATUS rpc_sh_user_show_internals(TALLOC_CTX *mem_ctx,
1402                                            struct rpc_sh_ctx *ctx,
1403                                            struct rpc_pipe_client *pipe_hnd,
1404                                            const POLICY_HND *user_hnd,
1405                                            int argc, const char **argv)
1406 {
1407         NTSTATUS result;
1408         SAM_USERINFO_CTR *ctr;
1409         SAM_USER_INFO_21 *info;
1410
1411         if (argc != 0) {
1412                 d_fprintf(stderr, "usage: %s show <username>\n", ctx->whoami);
1413                 return NT_STATUS_INVALID_PARAMETER;
1414         }
1415
1416         result = rpccli_samr_query_userinfo(pipe_hnd, mem_ctx, user_hnd,
1417                                             21, &ctr);
1418         if (!NT_STATUS_IS_OK(result)) {
1419                 return result;
1420         }
1421
1422         info = ctr->info.id21;
1423
1424         d_printf("user rid: %d, group rid: %d\n", info->user_rid,
1425                  info->group_rid);
1426
1427         return result;
1428 }
1429
1430 static NTSTATUS rpc_sh_user_show(TALLOC_CTX *mem_ctx,
1431                                  struct rpc_sh_ctx *ctx,
1432                                  struct rpc_pipe_client *pipe_hnd,
1433                                  int argc, const char **argv)
1434 {
1435         return rpc_sh_handle_user(mem_ctx, ctx, pipe_hnd, argc, argv,
1436                                   rpc_sh_user_show_internals);
1437 }
1438
1439 #define FETCHSTR(name, rec) \
1440 do { if (strequal(ctx->thiscmd, name)) { \
1441         oldval = rpcstr_pull_unistr2_talloc(mem_ctx, &usr->uni_##rec); } \
1442 } while (0);
1443
1444 #define SETSTR(name, rec, flag) \
1445 do { if (strequal(ctx->thiscmd, name)) { \
1446         init_unistr2(&usr->uni_##rec, argv[0], UNI_STR_TERMINATE); \
1447         init_uni_hdr(&usr->hdr_##rec, &usr->uni_##rec); \
1448         usr->fields_present |= ACCT_##flag; } \
1449 } while (0);
1450
1451 static NTSTATUS rpc_sh_user_str_edit_internals(TALLOC_CTX *mem_ctx,
1452                                                struct rpc_sh_ctx *ctx,
1453                                                struct rpc_pipe_client *pipe_hnd,
1454                                                const POLICY_HND *user_hnd,
1455                                                int argc, const char **argv)
1456 {
1457         NTSTATUS result;
1458         SAM_USERINFO_CTR *ctr;
1459         SAM_USER_INFO_21 *usr;
1460         const char *username;
1461         const char *oldval = "";
1462
1463         if (argc > 1) {
1464                 d_fprintf(stderr, "usage: %s <username> [new value|NULL]\n",
1465                           ctx->whoami);
1466                 return NT_STATUS_INVALID_PARAMETER;
1467         }
1468
1469         result = rpccli_samr_query_userinfo(pipe_hnd, mem_ctx, user_hnd,
1470                                             21, &ctr);
1471         if (!NT_STATUS_IS_OK(result)) {
1472                 return result;
1473         }
1474
1475         usr = ctr->info.id21;
1476
1477         username = rpcstr_pull_unistr2_talloc(mem_ctx, &usr->uni_user_name);
1478
1479         FETCHSTR("fullname", full_name);
1480         FETCHSTR("homedir", home_dir);
1481         FETCHSTR("homedrive", dir_drive);
1482         FETCHSTR("logonscript", logon_script);
1483         FETCHSTR("profilepath", profile_path);
1484         FETCHSTR("description", acct_desc);
1485
1486         if (argc == 0) {
1487                 d_printf("%s's %s: [%s]\n", username, ctx->thiscmd, oldval);
1488                 goto done;
1489         }
1490
1491         ZERO_STRUCTP(usr);
1492
1493         if (strcmp(argv[0], "NULL") == 0) {
1494                 argv[0] = "";
1495         }
1496
1497         SETSTR("fullname", full_name, FULL_NAME);
1498         SETSTR("homedir", home_dir, HOME_DIR);
1499         SETSTR("homedrive", dir_drive, HOME_DRIVE);
1500         SETSTR("logonscript", logon_script, LOGON_SCRIPT);
1501         SETSTR("profilepath", profile_path, PROFILE);
1502         SETSTR("description", acct_desc, DESCRIPTION);
1503
1504         result = rpccli_samr_set_userinfo2(
1505                 pipe_hnd, mem_ctx, user_hnd, 21,
1506                 &pipe_hnd->cli->user_session_key, ctr);
1507
1508         d_printf("Set %s's %s from [%s] to [%s]\n", username,
1509                  ctx->thiscmd, oldval, argv[0]);
1510
1511  done:
1512
1513         return result;
1514 }
1515
1516 #define HANDLEFLG(name, rec) \
1517 do { if (strequal(ctx->thiscmd, name)) { \
1518         oldval = (oldflags & ACB_##rec) ? "yes" : "no"; \
1519         if (newval) { \
1520                 newflags = oldflags | ACB_##rec; \
1521         } else { \
1522                 newflags = oldflags & ~ACB_##rec; \
1523         } } } while (0);
1524
1525 static NTSTATUS rpc_sh_user_str_edit(TALLOC_CTX *mem_ctx,
1526                                      struct rpc_sh_ctx *ctx,
1527                                      struct rpc_pipe_client *pipe_hnd,
1528                                      int argc, const char **argv)
1529 {
1530         return rpc_sh_handle_user(mem_ctx, ctx, pipe_hnd, argc, argv,
1531                                   rpc_sh_user_str_edit_internals);
1532 }
1533
1534 static NTSTATUS rpc_sh_user_flag_edit_internals(TALLOC_CTX *mem_ctx,
1535                                                 struct rpc_sh_ctx *ctx,
1536                                                 struct rpc_pipe_client *pipe_hnd,
1537                                                 const POLICY_HND *user_hnd,
1538                                                 int argc, const char **argv)
1539 {
1540         NTSTATUS result;
1541         SAM_USERINFO_CTR *ctr;
1542         SAM_USER_INFO_21 *usr;
1543         const char *username;
1544         const char *oldval = "unknown";
1545         uint32 oldflags, newflags;
1546         BOOL newval;
1547
1548         if ((argc > 1) ||
1549             ((argc == 1) && !strequal(argv[0], "yes") &&
1550              !strequal(argv[0], "no"))) {
1551                 d_fprintf(stderr, "usage: %s <username> [yes|no]\n",
1552                           ctx->whoami);
1553                 return NT_STATUS_INVALID_PARAMETER;
1554         }
1555
1556         newval = strequal(argv[0], "yes");
1557
1558         result = rpccli_samr_query_userinfo(pipe_hnd, mem_ctx, user_hnd,
1559                                             21, &ctr);
1560         if (!NT_STATUS_IS_OK(result)) {
1561                 return result;
1562         }
1563
1564         usr = ctr->info.id21;
1565
1566         username = rpcstr_pull_unistr2_talloc(mem_ctx, &usr->uni_user_name);
1567         oldflags = usr->acb_info;
1568         newflags = usr->acb_info;
1569
1570         HANDLEFLG("disabled", DISABLED);
1571         HANDLEFLG("pwnotreq", PWNOTREQ);
1572         HANDLEFLG("autolock", AUTOLOCK);
1573         HANDLEFLG("pwnoexp", PWNOEXP);
1574
1575         if (argc == 0) {
1576                 d_printf("%s's %s flag: %s\n", username, ctx->thiscmd, oldval);
1577                 goto done;
1578         }
1579
1580         ZERO_STRUCTP(usr);
1581
1582         usr->acb_info = newflags;
1583         usr->fields_present = ACCT_FLAGS;
1584
1585         result = rpccli_samr_set_userinfo2(
1586                 pipe_hnd, mem_ctx, user_hnd, 21,
1587                 &pipe_hnd->cli->user_session_key, ctr);
1588
1589         if (NT_STATUS_IS_OK(result)) {
1590                 d_printf("Set %s's %s flag from [%s] to [%s]\n", username,
1591                          ctx->thiscmd, oldval, argv[0]);
1592         }
1593
1594  done:
1595
1596         return result;
1597 }
1598
1599 static NTSTATUS rpc_sh_user_flag_edit(TALLOC_CTX *mem_ctx,
1600                                       struct rpc_sh_ctx *ctx,
1601                                       struct rpc_pipe_client *pipe_hnd,
1602                                       int argc, const char **argv)
1603 {
1604         return rpc_sh_handle_user(mem_ctx, ctx, pipe_hnd, argc, argv,
1605                                   rpc_sh_user_flag_edit_internals);
1606 }
1607
1608 struct rpc_sh_cmd *net_rpc_user_edit_cmds(TALLOC_CTX *mem_ctx,
1609                                           struct rpc_sh_ctx *ctx)
1610 {
1611         static struct rpc_sh_cmd cmds[] = {
1612
1613                 { "fullname", NULL, PI_SAMR, rpc_sh_user_str_edit,
1614                   "Show/Set a user's full name" },
1615
1616                 { "homedir", NULL, PI_SAMR, rpc_sh_user_str_edit,
1617                   "Show/Set a user's home directory" },
1618
1619                 { "homedrive", NULL, PI_SAMR, rpc_sh_user_str_edit,
1620                   "Show/Set a user's home drive" },
1621
1622                 { "logonscript", NULL, PI_SAMR, rpc_sh_user_str_edit,
1623                   "Show/Set a user's logon script" },
1624
1625                 { "profilepath", NULL, PI_SAMR, rpc_sh_user_str_edit,
1626                   "Show/Set a user's profile path" },
1627
1628                 { "description", NULL, PI_SAMR, rpc_sh_user_str_edit,
1629                   "Show/Set a user's description" },
1630
1631                 { "disabled", NULL, PI_SAMR, rpc_sh_user_flag_edit,
1632                   "Show/Set whether a user is disabled" },
1633
1634                 { "autolock", NULL, PI_SAMR, rpc_sh_user_flag_edit,
1635                   "Show/Set whether a user locked out" },
1636
1637                 { "pwnotreq", NULL, PI_SAMR, rpc_sh_user_flag_edit,
1638                   "Show/Set whether a user does not need a password" },
1639
1640                 { "pwnoexp", NULL, PI_SAMR, rpc_sh_user_flag_edit,
1641                   "Show/Set whether a user's password does not expire" },
1642
1643                 { NULL, NULL, 0, NULL, NULL }
1644         };
1645
1646         return cmds;
1647 }
1648
1649 struct rpc_sh_cmd *net_rpc_user_cmds(TALLOC_CTX *mem_ctx,
1650                                      struct rpc_sh_ctx *ctx)
1651 {
1652         static struct rpc_sh_cmd cmds[] = {
1653
1654                 { "list", NULL, PI_SAMR, rpc_sh_user_list,
1655                   "List available users" },
1656
1657                 { "info", NULL, PI_SAMR, rpc_sh_user_info,
1658                   "List the domain groups a user is member of" },
1659
1660                 { "show", NULL, PI_SAMR, rpc_sh_user_show,
1661                   "Show info about a user" },
1662
1663                 { "edit", net_rpc_user_edit_cmds, 0, NULL,
1664                   "Show/Modify a user's fields" },
1665
1666                 { NULL, NULL, 0, NULL, NULL }
1667         };
1668
1669         return cmds;
1670 }
1671
1672 /****************************************************************************/
1673
1674 /**
1675  * Basic usage function for 'net rpc group'
1676  * @param argc  Standard main() style argc.
1677  * @param argv  Standard main() style argv.  Initial components are already
1678  *              stripped.
1679  **/
1680
1681 static int rpc_group_usage(int argc, const char **argv)
1682 {
1683         return net_help_group(argc, argv);
1684 }
1685
1686 /**
1687  * Delete group on a remote RPC server
1688  *
1689  * All parameters are provided by the run_rpc_command function, except for
1690  * argc, argv which are passes through.
1691  *
1692  * @param domain_sid The domain sid acquired from the remote server
1693  * @param cli A cli_state connected to the server.
1694  * @param mem_ctx Talloc context, destoyed on completion of the function.
1695  * @param argc  Standard main() style argc
1696  * @param argv  Standard main() style argv.  Initial components are already
1697  *              stripped
1698  *
1699  * @return Normal NTSTATUS return.
1700  **/
1701
1702 static NTSTATUS rpc_group_delete_internals(const DOM_SID *domain_sid,
1703                                         const char *domain_name,
1704                                         struct cli_state *cli,
1705                                         struct rpc_pipe_client *pipe_hnd,
1706                                         TALLOC_CTX *mem_ctx,
1707                                         int argc,
1708                                         const char **argv)
1709 {
1710         POLICY_HND connect_pol, domain_pol, group_pol, user_pol;
1711         BOOL group_is_primary = False;
1712         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1713
1714         uint32 *group_rids, num_rids, *name_types, num_members,
1715                *group_attrs, group_rid;
1716         uint32 flags = 0x000003e8; /* Unknown */
1717         /* char **names; */
1718         int i;
1719         /* DOM_GID *user_gids; */
1720         SAM_USERINFO_CTR *user_ctr;
1721         fstring temp;
1722
1723         if (argc < 1) {
1724                 d_printf("specify group\n");
1725                 rpc_group_usage(argc,argv);
1726                 return NT_STATUS_OK; /* ok? */
1727         }
1728
1729         result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1730                                   &connect_pol);
1731
1732         if (!NT_STATUS_IS_OK(result)) {
1733                 d_fprintf(stderr, "Request samr_connect failed\n");
1734                 goto done;
1735         }
1736
1737         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
1738                                       MAXIMUM_ALLOWED_ACCESS,
1739                                       domain_sid, &domain_pol);
1740
1741         if (!NT_STATUS_IS_OK(result)) {
1742                 d_fprintf(stderr, "Request open_domain failed\n");
1743                 goto done;
1744         }
1745
1746         result = rpccli_samr_lookup_names(pipe_hnd, mem_ctx, &domain_pol,
1747                                        flags, 1, &argv[0],
1748                                        &num_rids, &group_rids,
1749                                        &name_types);
1750
1751         if (!NT_STATUS_IS_OK(result)) {
1752                 d_fprintf(stderr, "Lookup of '%s' failed\n",argv[0]);
1753                 goto done;
1754         }
1755
1756         switch (name_types[0])
1757         {
1758         case SID_NAME_DOM_GRP:
1759                 result = rpccli_samr_open_group(pipe_hnd, mem_ctx, &domain_pol,
1760                                              MAXIMUM_ALLOWED_ACCESS,
1761                                              group_rids[0], &group_pol);
1762                 if (!NT_STATUS_IS_OK(result)) {
1763                         d_fprintf(stderr, "Request open_group failed");
1764                         goto done;
1765                 }
1766
1767                 group_rid = group_rids[0];
1768
1769                 result = rpccli_samr_query_groupmem(pipe_hnd, mem_ctx, &group_pol,
1770                                  &num_members, &group_rids,
1771                                  &group_attrs);
1772
1773                 if (!NT_STATUS_IS_OK(result)) {
1774                         d_fprintf(stderr, "Unable to query group members of %s",argv[0]);
1775                         goto done;
1776                 }
1777
1778                 if (opt_verbose) {
1779                         d_printf("Domain Group %s (rid: %d) has %d members\n",
1780                                 argv[0],group_rid,num_members);
1781                 }
1782
1783                 /* Check if group is anyone's primary group */
1784                 for (i = 0; i < num_members; i++)
1785                 {
1786                         result = rpccli_samr_open_user(pipe_hnd, mem_ctx, &domain_pol,
1787                                                     MAXIMUM_ALLOWED_ACCESS,
1788                                                     group_rids[i], &user_pol);
1789
1790                         if (!NT_STATUS_IS_OK(result)) {
1791                                 d_fprintf(stderr, "Unable to open group member %d\n",group_rids[i]);
1792                                 goto done;
1793                         }
1794
1795                         ZERO_STRUCT(user_ctr);
1796
1797                         result = rpccli_samr_query_userinfo(pipe_hnd, mem_ctx, &user_pol,
1798                                                          21, &user_ctr);
1799
1800                         if (!NT_STATUS_IS_OK(result)) {
1801                                 d_fprintf(stderr, "Unable to lookup userinfo for group member %d\n",group_rids[i]);
1802                                 goto done;
1803                         }
1804
1805                         if (user_ctr->info.id21->group_rid == group_rid) {
1806                                 unistr2_to_ascii(temp, &(user_ctr->info.id21)->uni_user_name,
1807                                                 sizeof(temp)-1);
1808                                 if (opt_verbose)
1809                                         d_printf("Group is primary group of %s\n",temp);
1810                                 group_is_primary = True;
1811                         }
1812
1813                         rpccli_samr_close(pipe_hnd, mem_ctx, &user_pol);
1814                 }
1815
1816                 if (group_is_primary) {
1817                         d_fprintf(stderr, "Unable to delete group because some "
1818                                  "of it's members have it as primary group\n");
1819                         result = NT_STATUS_MEMBERS_PRIMARY_GROUP;
1820                         goto done;
1821                 }
1822
1823                 /* remove all group members */
1824                 for (i = 0; i < num_members; i++)
1825                 {
1826                         if (opt_verbose)
1827                                 d_printf("Remove group member %d...",group_rids[i]);
1828                         result = rpccli_samr_del_groupmem(pipe_hnd, mem_ctx, &group_pol, group_rids[i]);
1829
1830                         if (NT_STATUS_IS_OK(result)) {
1831                                 if (opt_verbose)
1832                                         d_printf("ok\n");
1833                         } else {
1834                                 if (opt_verbose)
1835                                         d_printf("failed\n");
1836                                 goto done;
1837                         }
1838                 }
1839
1840                 result = rpccli_samr_delete_dom_group(pipe_hnd, mem_ctx, &group_pol);
1841
1842                 break;
1843         /* removing a local group is easier... */
1844         case SID_NAME_ALIAS:
1845                 result = rpccli_samr_open_alias(pipe_hnd, mem_ctx, &domain_pol,
1846                                              MAXIMUM_ALLOWED_ACCESS,
1847                                              group_rids[0], &group_pol);
1848
1849                 if (!NT_STATUS_IS_OK(result)) {
1850                         d_fprintf(stderr, "Request open_alias failed\n");
1851                         goto done;
1852                 }
1853
1854                 result = rpccli_samr_delete_dom_alias(pipe_hnd, mem_ctx, &group_pol);
1855                 break;
1856         default:
1857                 d_fprintf(stderr, "%s is of type %s. This command is only for deleting local or global groups\n",
1858                         argv[0],sid_type_lookup(name_types[0]));
1859                 result = NT_STATUS_UNSUCCESSFUL;
1860                 goto done;
1861         }
1862
1863
1864         if (NT_STATUS_IS_OK(result)) {
1865                 if (opt_verbose)
1866                         d_printf("Deleted %s '%s'\n",sid_type_lookup(name_types[0]),argv[0]);
1867         } else {
1868                 d_fprintf(stderr, "Deleting of %s failed: %s\n",argv[0],
1869                         get_friendly_nt_error_msg(result));
1870         }
1871
1872  done:
1873         return result;
1874
1875 }
1876
1877 static int rpc_group_delete(int argc, const char **argv)
1878 {
1879         return run_rpc_command(NULL, PI_SAMR, 0, rpc_group_delete_internals,
1880                                argc,argv);
1881 }
1882
1883 static NTSTATUS rpc_group_add_internals(const DOM_SID *domain_sid,
1884                                         const char *domain_name,
1885                                         struct cli_state *cli,
1886                                         struct rpc_pipe_client *pipe_hnd,
1887                                         TALLOC_CTX *mem_ctx,
1888                                         int argc,
1889                                         const char **argv)
1890 {
1891         POLICY_HND connect_pol, domain_pol, group_pol;
1892         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1893         GROUP_INFO_CTR group_info;
1894
1895         if (argc != 1) {
1896                 d_printf("Group name must be specified\n");
1897                 rpc_group_usage(argc, argv);
1898                 return NT_STATUS_OK;
1899         }
1900
1901         /* Get sam policy handle */
1902
1903         result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1904                                   &connect_pol);
1905         if (!NT_STATUS_IS_OK(result)) goto done;
1906
1907         /* Get domain policy handle */
1908
1909         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
1910                                       MAXIMUM_ALLOWED_ACCESS,
1911                                       domain_sid, &domain_pol);
1912         if (!NT_STATUS_IS_OK(result)) goto done;
1913
1914         /* Create the group */
1915
1916         result = rpccli_samr_create_dom_group(pipe_hnd, mem_ctx, &domain_pol,
1917                                            argv[0], MAXIMUM_ALLOWED_ACCESS,
1918                                            &group_pol);
1919         if (!NT_STATUS_IS_OK(result)) goto done;
1920
1921         if (strlen(opt_comment) == 0) goto done;
1922
1923         /* We've got a comment to set */
1924
1925         group_info.switch_value1 = 4;
1926         init_samr_group_info4(&group_info.group.info4, opt_comment);
1927
1928         result = rpccli_samr_set_groupinfo(pipe_hnd, mem_ctx, &group_pol, &group_info);
1929         if (!NT_STATUS_IS_OK(result)) goto done;
1930
1931  done:
1932         if (NT_STATUS_IS_OK(result))
1933                 DEBUG(5, ("add group succeeded\n"));
1934         else
1935                 d_fprintf(stderr, "add group failed: %s\n", nt_errstr(result));
1936
1937         return result;
1938 }
1939
1940 static NTSTATUS rpc_alias_add_internals(const DOM_SID *domain_sid,
1941                                         const char *domain_name,
1942                                         struct cli_state *cli,
1943                                         struct rpc_pipe_client *pipe_hnd,
1944                                         TALLOC_CTX *mem_ctx,
1945                                         int argc,
1946                                         const char **argv)
1947 {
1948         POLICY_HND connect_pol, domain_pol, alias_pol;
1949         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1950         ALIAS_INFO_CTR alias_info;
1951
1952         if (argc != 1) {
1953                 d_printf("Alias name must be specified\n");
1954                 rpc_group_usage(argc, argv);
1955                 return NT_STATUS_OK;
1956         }
1957
1958         /* Get sam policy handle */
1959
1960         result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
1961                                   &connect_pol);
1962         if (!NT_STATUS_IS_OK(result)) goto done;
1963
1964         /* Get domain policy handle */
1965
1966         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
1967                                       MAXIMUM_ALLOWED_ACCESS,
1968                                       domain_sid, &domain_pol);
1969         if (!NT_STATUS_IS_OK(result)) goto done;
1970
1971         /* Create the group */
1972
1973         result = rpccli_samr_create_dom_alias(pipe_hnd, mem_ctx, &domain_pol,
1974                                            argv[0], &alias_pol);
1975         if (!NT_STATUS_IS_OK(result)) goto done;
1976
1977         if (strlen(opt_comment) == 0) goto done;
1978
1979         /* We've got a comment to set */
1980
1981         alias_info.level = 3;
1982         init_samr_alias_info3(&alias_info.alias.info3, opt_comment);
1983
1984         result = rpccli_samr_set_aliasinfo(pipe_hnd, mem_ctx, &alias_pol, &alias_info);
1985         if (!NT_STATUS_IS_OK(result)) goto done;
1986
1987  done:
1988         if (NT_STATUS_IS_OK(result))
1989                 DEBUG(5, ("add alias succeeded\n"));
1990         else
1991                 d_fprintf(stderr, "add alias failed: %s\n", nt_errstr(result));
1992
1993         return result;
1994 }
1995
1996 static int rpc_group_add(int argc, const char **argv)
1997 {
1998         if (opt_localgroup)
1999                 return run_rpc_command(NULL, PI_SAMR, 0,
2000                                        rpc_alias_add_internals,
2001                                        argc, argv);
2002
2003         return run_rpc_command(NULL, PI_SAMR, 0,
2004                                rpc_group_add_internals,
2005                                argc, argv);
2006 }
2007
2008 static NTSTATUS get_sid_from_name(struct cli_state *cli,
2009                                 TALLOC_CTX *mem_ctx,
2010                                 const char *name,
2011                                 DOM_SID *sid,
2012                                 enum lsa_SidType *type)
2013 {
2014         DOM_SID *sids = NULL;
2015         enum lsa_SidType *types = NULL;
2016         struct rpc_pipe_client *pipe_hnd;
2017         POLICY_HND lsa_pol;
2018         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2019
2020         pipe_hnd = cli_rpc_pipe_open_noauth(cli, PI_LSARPC, &result);
2021         if (!pipe_hnd) {
2022                 goto done;
2023         }
2024
2025         result = rpccli_lsa_open_policy(pipe_hnd, mem_ctx, False,
2026                                      SEC_RIGHTS_MAXIMUM_ALLOWED, &lsa_pol);
2027
2028         if (!NT_STATUS_IS_OK(result)) {
2029                 goto done;
2030         }
2031
2032         result = rpccli_lsa_lookup_names(pipe_hnd, mem_ctx, &lsa_pol, 1,
2033                                       &name, NULL, 1, &sids, &types);
2034
2035         if (NT_STATUS_IS_OK(result)) {
2036                 sid_copy(sid, &sids[0]);
2037                 *type = types[0];
2038         }
2039
2040         rpccli_lsa_Close(pipe_hnd, mem_ctx, &lsa_pol);
2041
2042  done:
2043         if (pipe_hnd) {
2044                 cli_rpc_pipe_close(pipe_hnd);
2045         }
2046
2047         if (!NT_STATUS_IS_OK(result) && (StrnCaseCmp(name, "S-", 2) == 0)) {
2048
2049                 /* Try as S-1-5-whatever */
2050
2051                 DOM_SID tmp_sid;
2052
2053                 if (string_to_sid(&tmp_sid, name)) {
2054                         sid_copy(sid, &tmp_sid);
2055                         *type = SID_NAME_UNKNOWN;
2056                         result = NT_STATUS_OK;
2057                 }
2058         }
2059
2060         return result;
2061 }
2062
2063 static NTSTATUS rpc_add_groupmem(struct rpc_pipe_client *pipe_hnd,
2064                                 TALLOC_CTX *mem_ctx,
2065                                 const DOM_SID *group_sid,
2066                                 const char *member)
2067 {
2068         POLICY_HND connect_pol, domain_pol;
2069         NTSTATUS result;
2070         uint32 group_rid;
2071         POLICY_HND group_pol;
2072
2073         uint32 num_rids;
2074         uint32 *rids = NULL;
2075         uint32 *rid_types = NULL;
2076
2077         DOM_SID sid;
2078
2079         sid_copy(&sid, group_sid);
2080
2081         if (!sid_split_rid(&sid, &group_rid)) {
2082                 return NT_STATUS_UNSUCCESSFUL;
2083         }
2084
2085         /* Get sam policy handle */
2086         result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
2087                                   &connect_pol);
2088         if (!NT_STATUS_IS_OK(result)) {
2089                 return result;
2090         }
2091
2092         /* Get domain policy handle */
2093         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
2094                                       MAXIMUM_ALLOWED_ACCESS,
2095                                       &sid, &domain_pol);
2096         if (!NT_STATUS_IS_OK(result)) {
2097                 return result;
2098         }
2099
2100         result = rpccli_samr_lookup_names(pipe_hnd, mem_ctx, &domain_pol, 1000,
2101                                        1, &member,
2102                                        &num_rids, &rids, &rid_types);
2103
2104         if (!NT_STATUS_IS_OK(result)) {
2105                 d_fprintf(stderr, "Could not lookup up group member %s\n", member);
2106                 goto done;
2107         }
2108
2109         result = rpccli_samr_open_group(pipe_hnd, mem_ctx, &domain_pol,
2110                                      MAXIMUM_ALLOWED_ACCESS,
2111                                      group_rid, &group_pol);
2112
2113         if (!NT_STATUS_IS_OK(result)) {
2114                 goto done;
2115         }
2116
2117         result = rpccli_samr_add_groupmem(pipe_hnd, mem_ctx, &group_pol, rids[0]);
2118
2119  done:
2120         rpccli_samr_close(pipe_hnd, mem_ctx, &connect_pol);
2121         return result;
2122 }
2123
2124 static NTSTATUS rpc_add_aliasmem(struct rpc_pipe_client *pipe_hnd,
2125                                 TALLOC_CTX *mem_ctx,
2126                                 const DOM_SID *alias_sid,
2127                                 const char *member)
2128 {
2129         POLICY_HND connect_pol, domain_pol;
2130         NTSTATUS result;
2131         uint32 alias_rid;
2132         POLICY_HND alias_pol;
2133
2134         DOM_SID member_sid;
2135         enum lsa_SidType member_type;
2136
2137         DOM_SID sid;
2138
2139         sid_copy(&sid, alias_sid);
2140
2141         if (!sid_split_rid(&sid, &alias_rid)) {
2142                 return NT_STATUS_UNSUCCESSFUL;
2143         }
2144
2145         result = get_sid_from_name(pipe_hnd->cli, mem_ctx, member,
2146                                    &member_sid, &member_type);
2147
2148         if (!NT_STATUS_IS_OK(result)) {
2149                 d_fprintf(stderr, "Could not lookup up group member %s\n", member);
2150                 return result;
2151         }
2152
2153         /* Get sam policy handle */
2154         result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
2155                                   &connect_pol);
2156         if (!NT_STATUS_IS_OK(result)) {
2157                 goto done;
2158         }
2159
2160         /* Get domain policy handle */
2161         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
2162                                       MAXIMUM_ALLOWED_ACCESS,
2163                                       &sid, &domain_pol);
2164         if (!NT_STATUS_IS_OK(result)) {
2165                 goto done;
2166         }
2167
2168         result = rpccli_samr_open_alias(pipe_hnd, mem_ctx, &domain_pol,
2169                                      MAXIMUM_ALLOWED_ACCESS,
2170                                      alias_rid, &alias_pol);
2171
2172         if (!NT_STATUS_IS_OK(result)) {
2173                 return result;
2174         }
2175
2176         result = rpccli_samr_add_aliasmem(pipe_hnd, mem_ctx, &alias_pol, &member_sid);
2177
2178         if (!NT_STATUS_IS_OK(result)) {
2179                 return result;
2180         }
2181
2182  done:
2183         rpccli_samr_close(pipe_hnd, mem_ctx, &connect_pol);
2184         return result;
2185 }
2186
2187 static NTSTATUS rpc_group_addmem_internals(const 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         DOM_SID group_sid;
2196         enum lsa_SidType group_type;
2197
2198         if (argc != 2) {
2199                 d_printf("Usage: 'net rpc group addmem <group> <member>\n");
2200                 return NT_STATUS_UNSUCCESSFUL;
2201         }
2202
2203         if (!NT_STATUS_IS_OK(get_sid_from_name(cli, mem_ctx, argv[0],
2204                                                &group_sid, &group_type))) {
2205                 d_fprintf(stderr, "Could not lookup group name %s\n", argv[0]);
2206                 return NT_STATUS_UNSUCCESSFUL;
2207         }
2208
2209         if (group_type == SID_NAME_DOM_GRP) {
2210                 NTSTATUS result = rpc_add_groupmem(pipe_hnd, mem_ctx,
2211                                                    &group_sid, argv[1]);
2212
2213                 if (!NT_STATUS_IS_OK(result)) {
2214                         d_fprintf(stderr, "Could not add %s to %s: %s\n",
2215                                  argv[1], argv[0], nt_errstr(result));
2216                 }
2217                 return result;
2218         }
2219
2220         if (group_type == SID_NAME_ALIAS) {
2221                 NTSTATUS result = rpc_add_aliasmem(pipe_hnd, mem_ctx,
2222                                                    &group_sid, argv[1]);
2223
2224                 if (!NT_STATUS_IS_OK(result)) {
2225                         d_fprintf(stderr, "Could not add %s to %s: %s\n",
2226                                  argv[1], argv[0], nt_errstr(result));
2227                 }
2228                 return result;
2229         }
2230
2231         d_fprintf(stderr, "Can only add members to global or local groups "
2232                  "which %s is not\n", argv[0]);
2233
2234         return NT_STATUS_UNSUCCESSFUL;
2235 }
2236
2237 static int rpc_group_addmem(int argc, const char **argv)
2238 {
2239         return run_rpc_command(NULL, PI_SAMR, 0,
2240                                rpc_group_addmem_internals,
2241                                argc, argv);
2242 }
2243
2244 static NTSTATUS rpc_del_groupmem(struct rpc_pipe_client *pipe_hnd,
2245                                 TALLOC_CTX *mem_ctx,
2246                                 const DOM_SID *group_sid,
2247                                 const char *member)
2248 {
2249         POLICY_HND connect_pol, domain_pol;
2250         NTSTATUS result;
2251         uint32 group_rid;
2252         POLICY_HND group_pol;
2253
2254         uint32 num_rids;
2255         uint32 *rids = NULL;
2256         uint32 *rid_types = NULL;
2257
2258         DOM_SID sid;
2259
2260         sid_copy(&sid, group_sid);
2261
2262         if (!sid_split_rid(&sid, &group_rid))
2263                 return NT_STATUS_UNSUCCESSFUL;
2264
2265         /* Get sam policy handle */
2266         result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
2267                                   &connect_pol);
2268         if (!NT_STATUS_IS_OK(result))
2269                 return result;
2270
2271         /* Get domain policy handle */
2272         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
2273                                       MAXIMUM_ALLOWED_ACCESS,
2274                                       &sid, &domain_pol);
2275         if (!NT_STATUS_IS_OK(result))
2276                 return result;
2277
2278         result = rpccli_samr_lookup_names(pipe_hnd, mem_ctx, &domain_pol, 1000,
2279                                        1, &member,
2280                                        &num_rids, &rids, &rid_types);
2281
2282         if (!NT_STATUS_IS_OK(result)) {
2283                 d_fprintf(stderr, "Could not lookup up group member %s\n", member);
2284                 goto done;
2285         }
2286
2287         result = rpccli_samr_open_group(pipe_hnd, mem_ctx, &domain_pol,
2288                                      MAXIMUM_ALLOWED_ACCESS,
2289                                      group_rid, &group_pol);
2290
2291         if (!NT_STATUS_IS_OK(result))
2292                 goto done;
2293
2294         result = rpccli_samr_del_groupmem(pipe_hnd, mem_ctx, &group_pol, rids[0]);
2295
2296  done:
2297         rpccli_samr_close(pipe_hnd, mem_ctx, &connect_pol);
2298         return result;
2299 }
2300
2301 static NTSTATUS rpc_del_aliasmem(struct rpc_pipe_client *pipe_hnd,
2302                                 TALLOC_CTX *mem_ctx,
2303                                 const DOM_SID *alias_sid,
2304                                 const char *member)
2305 {
2306         POLICY_HND connect_pol, domain_pol;
2307         NTSTATUS result;
2308         uint32 alias_rid;
2309         POLICY_HND alias_pol;
2310
2311         DOM_SID member_sid;
2312         enum lsa_SidType member_type;
2313
2314         DOM_SID sid;
2315
2316         sid_copy(&sid, alias_sid);
2317
2318         if (!sid_split_rid(&sid, &alias_rid))
2319                 return NT_STATUS_UNSUCCESSFUL;
2320
2321         result = get_sid_from_name(pipe_hnd->cli, mem_ctx, member,
2322                                    &member_sid, &member_type);
2323
2324         if (!NT_STATUS_IS_OK(result)) {
2325                 d_fprintf(stderr, "Could not lookup up group member %s\n", member);
2326                 return result;
2327         }
2328
2329         /* Get sam policy handle */
2330         result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
2331                                   &connect_pol);
2332         if (!NT_STATUS_IS_OK(result)) {
2333                 goto done;
2334         }
2335
2336         /* Get domain policy handle */
2337         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
2338                                       MAXIMUM_ALLOWED_ACCESS,
2339                                       &sid, &domain_pol);
2340         if (!NT_STATUS_IS_OK(result)) {
2341                 goto done;
2342         }
2343
2344         result = rpccli_samr_open_alias(pipe_hnd, mem_ctx, &domain_pol,
2345                                      MAXIMUM_ALLOWED_ACCESS,
2346                                      alias_rid, &alias_pol);
2347
2348         if (!NT_STATUS_IS_OK(result))
2349                 return result;
2350
2351         result = rpccli_samr_del_aliasmem(pipe_hnd, mem_ctx, &alias_pol, &member_sid);
2352
2353         if (!NT_STATUS_IS_OK(result))
2354                 return result;
2355
2356  done:
2357         rpccli_samr_close(pipe_hnd, mem_ctx, &connect_pol);
2358         return result;
2359 }
2360
2361 static NTSTATUS rpc_group_delmem_internals(const DOM_SID *domain_sid,
2362                                         const char *domain_name,
2363                                         struct cli_state *cli,
2364                                         struct rpc_pipe_client *pipe_hnd,
2365                                         TALLOC_CTX *mem_ctx,
2366                                         int argc,
2367                                         const char **argv)
2368 {
2369         DOM_SID group_sid;
2370         enum lsa_SidType group_type;
2371
2372         if (argc != 2) {
2373                 d_printf("Usage: 'net rpc group delmem <group> <member>\n");
2374                 return NT_STATUS_UNSUCCESSFUL;
2375         }
2376
2377         if (!NT_STATUS_IS_OK(get_sid_from_name(cli, mem_ctx, argv[0],
2378                                                &group_sid, &group_type))) {
2379                 d_fprintf(stderr, "Could not lookup group name %s\n", argv[0]);
2380                 return NT_STATUS_UNSUCCESSFUL;
2381         }
2382
2383         if (group_type == SID_NAME_DOM_GRP) {
2384                 NTSTATUS result = rpc_del_groupmem(pipe_hnd, mem_ctx,
2385                                                    &group_sid, argv[1]);
2386
2387                 if (!NT_STATUS_IS_OK(result)) {
2388                         d_fprintf(stderr, "Could not del %s from %s: %s\n",
2389                                  argv[1], argv[0], nt_errstr(result));
2390                 }
2391                 return result;
2392         }
2393
2394         if (group_type == SID_NAME_ALIAS) {
2395                 NTSTATUS result = rpc_del_aliasmem(pipe_hnd, mem_ctx,
2396                                                    &group_sid, argv[1]);
2397
2398                 if (!NT_STATUS_IS_OK(result)) {
2399                         d_fprintf(stderr, "Could not del %s from %s: %s\n",
2400                                  argv[1], argv[0], nt_errstr(result));
2401                 }
2402                 return result;
2403         }
2404
2405         d_fprintf(stderr, "Can only delete members from global or local groups "
2406                  "which %s is not\n", argv[0]);
2407
2408         return NT_STATUS_UNSUCCESSFUL;
2409 }
2410
2411 static int rpc_group_delmem(int argc, const char **argv)
2412 {
2413         return run_rpc_command(NULL, PI_SAMR, 0,
2414                                rpc_group_delmem_internals,
2415                                argc, argv);
2416 }
2417
2418 /**
2419  * List groups on a remote RPC server
2420  *
2421  * All parameters are provided by the run_rpc_command function, except for
2422  * argc, argv which are passes through.
2423  *
2424  * @param domain_sid The domain sid acquired from the remote server
2425  * @param cli A cli_state connected to the server.
2426  * @param mem_ctx Talloc context, destoyed on completion of the function.
2427  * @param argc  Standard main() style argc
2428  * @param argv  Standard main() style argv.  Initial components are already
2429  *              stripped
2430  *
2431  * @return Normal NTSTATUS return.
2432  **/
2433
2434 static NTSTATUS rpc_group_list_internals(const DOM_SID *domain_sid,
2435                                         const char *domain_name,
2436                                         struct cli_state *cli,
2437                                         struct rpc_pipe_client *pipe_hnd,
2438                                         TALLOC_CTX *mem_ctx,
2439                                         int argc,
2440                                         const char **argv)
2441 {
2442         POLICY_HND connect_pol, domain_pol;
2443         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
2444         uint32 start_idx=0, max_entries=250, num_entries, i, loop_count = 0;
2445         struct acct_info *groups;
2446         BOOL global = False;
2447         BOOL local = False;
2448         BOOL builtin = False;
2449
2450         if (argc == 0) {
2451                 global = True;
2452                 local = True;
2453                 builtin = True;
2454         }
2455
2456         for (i=0; i<argc; i++) {
2457                 if (strequal(argv[i], "global"))
2458                         global = True;
2459
2460                 if (strequal(argv[i], "local"))
2461                         local = True;
2462
2463                 if (strequal(argv[i], "builtin"))
2464                         builtin = True;
2465         }
2466
2467         /* Get sam policy handle */
2468
2469         result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
2470                                   &connect_pol);
2471         if (!NT_STATUS_IS_OK(result)) {
2472                 goto done;
2473         }
2474
2475         /* Get domain policy handle */
2476
2477         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
2478                                       MAXIMUM_ALLOWED_ACCESS,
2479                                       domain_sid, &domain_pol);
2480         if (!NT_STATUS_IS_OK(result)) {
2481                 goto done;
2482         }
2483
2484         /* Query domain groups */
2485         if (opt_long_list_entries)
2486                 d_printf("\nGroup name            Comment"\
2487                          "\n-----------------------------\n");
2488         do {
2489                 SAM_DISPINFO_CTR ctr;
2490                 SAM_DISPINFO_3 info3;
2491                 uint32 max_size;
2492
2493                 ZERO_STRUCT(ctr);
2494                 ZERO_STRUCT(info3);
2495                 ctr.sam.info3 = &info3;
2496
2497                 if (!global) break;
2498
2499                 get_query_dispinfo_params(
2500                         loop_count, &max_entries, &max_size);
2501
2502                 result = rpccli_samr_query_dispinfo(pipe_hnd, mem_ctx, &domain_pol,
2503                                                  &start_idx, 3, &num_entries,
2504                                                  max_entries, max_size, &ctr);
2505
2506                 if (!NT_STATUS_IS_OK(result) &&
2507                     !NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES))
2508                         break;
2509
2510                 for (i = 0; i < num_entries; i++) {
2511
2512                         fstring group, desc;
2513
2514                         unistr2_to_ascii(group, &(&ctr.sam.info3->str[i])->uni_grp_name, sizeof(group)-1);
2515                         unistr2_to_ascii(desc, &(&ctr.sam.info3->str[i])->uni_grp_desc, sizeof(desc)-1);
2516
2517                         if (opt_long_list_entries)
2518                                 printf("%-21.21s %-50.50s\n",
2519                                        group, desc);
2520                         else
2521                                 printf("%s\n", group);
2522                 }
2523         } while (NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES));
2524         /* query domain aliases */
2525         start_idx = 0;
2526         do {
2527                 if (!local) break;
2528
2529                 /* The max_size field in cli_samr_enum_als_groups is more like
2530                  * an account_control field with indiviual bits what to
2531                  * retrieve. Set this to 0xffff as NT4 usrmgr.exe does to get
2532                  * everything. I'm too lazy (sorry) to get this through to
2533                  * rpc_parse/ etc.  Volker */
2534
2535                 result = rpccli_samr_enum_als_groups(pipe_hnd, mem_ctx, &domain_pol,
2536                                                   &start_idx, 0xffff,
2537                                                   &groups, &num_entries);
2538
2539                 if (!NT_STATUS_IS_OK(result) &&
2540                     !NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES))
2541                         break;
2542
2543                 for (i = 0; i < num_entries; i++) {
2544
2545                         char *description = NULL;
2546
2547                         if (opt_long_list_entries) {
2548
2549                                 POLICY_HND alias_pol;
2550                                 ALIAS_INFO_CTR ctr;
2551
2552                                 if ((NT_STATUS_IS_OK(rpccli_samr_open_alias(pipe_hnd, mem_ctx,
2553                                                                          &domain_pol,
2554                                                                          0x8,
2555                                                                          groups[i].rid,
2556                                                                          &alias_pol))) &&
2557                                     (NT_STATUS_IS_OK(rpccli_samr_query_alias_info(pipe_hnd, mem_ctx,
2558                                                                                &alias_pol, 3,
2559                                                                                &ctr))) &&
2560                                     (NT_STATUS_IS_OK(rpccli_samr_close(pipe_hnd, mem_ctx,
2561                                                                     &alias_pol)))) {
2562                                         description = unistr2_tdup(mem_ctx,
2563                                                                    ctr.alias.info3.description.string);
2564                                 }
2565                         }
2566
2567                         if (description != NULL) {
2568                                 printf("%-21.21s %-50.50s\n",
2569                                        groups[i].acct_name,
2570                                        description);
2571                         } else {
2572                                 printf("%s\n", groups[i].acct_name);
2573                         }
2574                 }
2575         } while (NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES));
2576         rpccli_samr_close(pipe_hnd, mem_ctx, &domain_pol);
2577         /* Get builtin policy handle */
2578
2579         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
2580                                       MAXIMUM_ALLOWED_ACCESS,
2581                                       &global_sid_Builtin, &domain_pol);
2582         if (!NT_STATUS_IS_OK(result)) {
2583                 goto done;
2584         }
2585         /* query builtin aliases */
2586         start_idx = 0;
2587         do {
2588                 if (!builtin) break;
2589
2590                 result = rpccli_samr_enum_als_groups(pipe_hnd, mem_ctx, &domain_pol,
2591                                                   &start_idx, max_entries,
2592                                                   &groups, &num_entries);
2593
2594                 if (!NT_STATUS_IS_OK(result) &&
2595                     !NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES))
2596                         break;
2597
2598                 for (i = 0; i < num_entries; i++) {
2599
2600                         char *description = NULL;
2601
2602                         if (opt_long_list_entries) {
2603
2604                                 POLICY_HND alias_pol;
2605                                 ALIAS_INFO_CTR ctr;
2606
2607                                 if ((NT_STATUS_IS_OK(rpccli_samr_open_alias(pipe_hnd, mem_ctx,
2608                                                                          &domain_pol,
2609                                                                          0x8,
2610                                                                          groups[i].rid,
2611                                                                          &alias_pol))) &&
2612                                     (NT_STATUS_IS_OK(rpccli_samr_query_alias_info(pipe_hnd, mem_ctx,
2613                                                                                &alias_pol, 3,
2614                                                                                &ctr))) &&
2615                                     (NT_STATUS_IS_OK(rpccli_samr_close(pipe_hnd, mem_ctx,
2616                                                                     &alias_pol)))) {
2617                                         description = unistr2_tdup(mem_ctx,
2618                                                                    ctr.alias.info3.description.string);
2619                                 }
2620                         }
2621
2622                         if (description != NULL) {
2623                                 printf("%-21.21s %-50.50s\n",
2624                                        groups[i].acct_name,
2625                                        description);
2626                         } else {
2627                                 printf("%s\n", groups[i].acct_name);
2628                         }
2629                 }
2630         } while (NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES));
2631
2632  done:
2633         return result;
2634 }
2635
2636 static int rpc_group_list(int argc, const char **argv)
2637 {
2638         return run_rpc_command(NULL, PI_SAMR, 0,
2639                                rpc_group_list_internals,
2640                                argc, argv);
2641 }
2642
2643 static NTSTATUS rpc_list_group_members(struct rpc_pipe_client *pipe_hnd,
2644                                         TALLOC_CTX *mem_ctx,
2645                                         const char *domain_name,
2646                                         const DOM_SID *domain_sid,
2647                                         POLICY_HND *domain_pol,
2648                                         uint32 rid)
2649 {
2650         NTSTATUS result;
2651         POLICY_HND group_pol;
2652         uint32 num_members, *group_rids, *group_attrs;
2653         uint32 num_names;
2654         char **names;
2655         uint32 *name_types;
2656         int i;
2657
2658         fstring sid_str;
2659         sid_to_string(sid_str, domain_sid);
2660
2661         result = rpccli_samr_open_group(pipe_hnd, mem_ctx, domain_pol,
2662                                      MAXIMUM_ALLOWED_ACCESS,
2663                                      rid, &group_pol);
2664
2665         if (!NT_STATUS_IS_OK(result))
2666                 return result;
2667
2668         result = rpccli_samr_query_groupmem(pipe_hnd, mem_ctx, &group_pol,
2669                                          &num_members, &group_rids,
2670                                          &group_attrs);
2671
2672         if (!NT_STATUS_IS_OK(result))
2673                 return result;
2674
2675         while (num_members > 0) {
2676                 int this_time = 512;
2677
2678                 if (num_members < this_time)
2679                         this_time = num_members;
2680
2681                 result = rpccli_samr_lookup_rids(pipe_hnd, mem_ctx, domain_pol,
2682                                               this_time, group_rids,
2683                                               &num_names, &names, &name_types);
2684
2685                 if (!NT_STATUS_IS_OK(result))
2686                         return result;
2687
2688                 /* We only have users as members, but make the output
2689                    the same as the output of alias members */
2690
2691                 for (i = 0; i < this_time; i++) {
2692
2693                         if (opt_long_list_entries) {
2694                                 printf("%s-%d %s\\%s %d\n", sid_str,
2695                                        group_rids[i], domain_name, names[i],
2696                                        SID_NAME_USER);
2697                         } else {
2698                                 printf("%s\\%s\n", domain_name, names[i]);
2699                         }
2700                 }
2701
2702                 num_members -= this_time;
2703                 group_rids += 512;
2704         }
2705
2706         return NT_STATUS_OK;
2707 }
2708
2709 static NTSTATUS rpc_list_alias_members(struct rpc_pipe_client *pipe_hnd,
2710                                         TALLOC_CTX *mem_ctx,
2711                                         POLICY_HND *domain_pol,
2712                                         uint32 rid)
2713 {
2714         NTSTATUS result;
2715         struct rpc_pipe_client *lsa_pipe;
2716         POLICY_HND alias_pol, lsa_pol;
2717         uint32 num_members;
2718         DOM_SID *alias_sids;
2719         char **domains;
2720         char **names;
2721         enum lsa_SidType *types;
2722         int i;
2723
2724         result = rpccli_samr_open_alias(pipe_hnd, mem_ctx, domain_pol,
2725                                      MAXIMUM_ALLOWED_ACCESS, rid, &alias_pol);
2726
2727         if (!NT_STATUS_IS_OK(result))
2728                 return result;
2729
2730         result = rpccli_samr_query_aliasmem(pipe_hnd, mem_ctx, &alias_pol,
2731                                          &num_members, &alias_sids);
2732
2733         if (!NT_STATUS_IS_OK(result)) {
2734                 d_fprintf(stderr, "Couldn't list alias members\n");
2735                 return result;
2736         }
2737
2738         if (num_members == 0) {
2739                 return NT_STATUS_OK;
2740         }
2741
2742         lsa_pipe = cli_rpc_pipe_open_noauth(pipe_hnd->cli, PI_LSARPC, &result);
2743         if (!lsa_pipe) {
2744                 d_fprintf(stderr, "Couldn't open LSA pipe. Error was %s\n",
2745                         nt_errstr(result) );
2746                 return result;
2747         }
2748
2749         result = rpccli_lsa_open_policy(lsa_pipe, mem_ctx, True,
2750                                      SEC_RIGHTS_MAXIMUM_ALLOWED, &lsa_pol);
2751
2752         if (!NT_STATUS_IS_OK(result)) {
2753                 d_fprintf(stderr, "Couldn't open LSA policy handle\n");
2754                 cli_rpc_pipe_close(lsa_pipe);
2755                 return result;
2756         }
2757
2758         result = rpccli_lsa_lookup_sids(lsa_pipe, mem_ctx, &lsa_pol, num_members,
2759                                      alias_sids,
2760                                      &domains, &names, &types);
2761
2762         if (!NT_STATUS_IS_OK(result) &&
2763             !NT_STATUS_EQUAL(result, STATUS_SOME_UNMAPPED)) {
2764                 d_fprintf(stderr, "Couldn't lookup SIDs\n");
2765                 cli_rpc_pipe_close(lsa_pipe);
2766                 return result;
2767         }
2768
2769         for (i = 0; i < num_members; i++) {
2770                 fstring sid_str;
2771                 sid_to_string(sid_str, &alias_sids[i]);
2772
2773                 if (opt_long_list_entries) {
2774                         printf("%s %s\\%s %d\n", sid_str,
2775                                domains[i] ? domains[i] : "*unknown*",
2776                                names[i] ? names[i] : "*unknown*", types[i]);
2777                 } else {
2778                         if (domains[i])
2779                                 printf("%s\\%s\n", domains[i], names[i]);
2780                         else
2781                                 printf("%s\n", sid_str);
2782                 }
2783         }
2784
2785         cli_rpc_pipe_close(lsa_pipe);
2786         return NT_STATUS_OK;
2787 }
2788
2789 static NTSTATUS rpc_group_members_internals(const DOM_SID *domain_sid,
2790                                         const char *domain_name,
2791                                         struct cli_state *cli,
2792                                         struct rpc_pipe_client *pipe_hnd,
2793                                         TALLOC_CTX *mem_ctx,
2794                                         int argc,
2795                                         const char **argv)
2796 {
2797         NTSTATUS result;
2798         POLICY_HND connect_pol, domain_pol;
2799         uint32 num_rids, *rids, *rid_types;
2800
2801         /* Get sam policy handle */
2802
2803         result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
2804                                   &connect_pol);
2805
2806         if (!NT_STATUS_IS_OK(result))
2807                 return result;
2808
2809         /* Get domain policy handle */
2810
2811         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
2812                                       MAXIMUM_ALLOWED_ACCESS,
2813                                       domain_sid, &domain_pol);
2814
2815         if (!NT_STATUS_IS_OK(result))
2816                 return result;
2817
2818         result = rpccli_samr_lookup_names(pipe_hnd, mem_ctx, &domain_pol, 1000,
2819                                        1, argv, &num_rids, &rids, &rid_types);
2820
2821         if (!NT_STATUS_IS_OK(result)) {
2822
2823                 /* Ok, did not find it in the global sam, try with builtin */
2824
2825                 DOM_SID sid_Builtin;
2826
2827                 rpccli_samr_close(pipe_hnd, mem_ctx, &domain_pol);
2828
2829                 string_to_sid(&sid_Builtin, "S-1-5-32");
2830
2831                 result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
2832                                               MAXIMUM_ALLOWED_ACCESS,
2833                                               &sid_Builtin, &domain_pol);
2834
2835                 if (!NT_STATUS_IS_OK(result)) {
2836                         d_fprintf(stderr, "Couldn't find group %s\n", argv[0]);
2837                         return result;
2838                 }
2839
2840                 result = rpccli_samr_lookup_names(pipe_hnd, mem_ctx, &domain_pol, 1000,
2841                                                1, argv, &num_rids,
2842                                                &rids, &rid_types);
2843
2844                 if (!NT_STATUS_IS_OK(result)) {
2845                         d_fprintf(stderr, "Couldn't find group %s\n", argv[0]);
2846                         return result;
2847                 }
2848         }
2849
2850         if (num_rids != 1) {
2851                 d_fprintf(stderr, "Couldn't find group %s\n", argv[0]);
2852                 return result;
2853         }
2854
2855         if (rid_types[0] == SID_NAME_DOM_GRP) {
2856                 return rpc_list_group_members(pipe_hnd, mem_ctx, domain_name,
2857                                               domain_sid, &domain_pol,
2858                                               rids[0]);
2859         }
2860
2861         if (rid_types[0] == SID_NAME_ALIAS) {
2862                 return rpc_list_alias_members(pipe_hnd, mem_ctx, &domain_pol,
2863                                               rids[0]);
2864         }
2865
2866         return NT_STATUS_NO_SUCH_GROUP;
2867 }
2868
2869 static int rpc_group_members(int argc, const char **argv)
2870 {
2871         if (argc != 1) {
2872                 return rpc_group_usage(argc, argv);
2873         }
2874
2875         return run_rpc_command(NULL, PI_SAMR, 0,
2876                                rpc_group_members_internals,
2877                                argc, argv);
2878 }
2879
2880 static NTSTATUS rpc_group_rename_internals(const DOM_SID *domain_sid,
2881                                         const char *domain_name,
2882                                         struct cli_state *cli,
2883                                         struct rpc_pipe_client *pipe_hnd,
2884                                         TALLOC_CTX *mem_ctx,
2885                                         int argc,
2886                                         const char **argv)
2887 {
2888         NTSTATUS result;
2889         POLICY_HND connect_pol, domain_pol, group_pol;
2890         uint32 num_rids, *rids, *rid_types;
2891         GROUP_INFO_CTR ctr;
2892
2893         if (argc != 2) {
2894                 d_printf("Usage: 'net rpc group rename group newname'\n");
2895                 return NT_STATUS_UNSUCCESSFUL;
2896         }
2897
2898         /* Get sam policy handle */
2899
2900         result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
2901                                   &connect_pol);
2902
2903         if (!NT_STATUS_IS_OK(result))
2904                 return result;
2905
2906         /* Get domain policy handle */
2907
2908         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
2909                                       MAXIMUM_ALLOWED_ACCESS,
2910                                       domain_sid, &domain_pol);
2911
2912         if (!NT_STATUS_IS_OK(result))
2913                 return result;
2914
2915         result = rpccli_samr_lookup_names(pipe_hnd, mem_ctx, &domain_pol, 1000,
2916                                        1, argv, &num_rids, &rids, &rid_types);
2917
2918         if (num_rids != 1) {
2919                 d_fprintf(stderr, "Couldn't find group %s\n", argv[0]);
2920                 return result;
2921         }
2922
2923         if (rid_types[0] != SID_NAME_DOM_GRP) {
2924                 d_fprintf(stderr, "Can only rename domain groups\n");
2925                 return NT_STATUS_UNSUCCESSFUL;
2926         }
2927
2928         result = rpccli_samr_open_group(pipe_hnd, mem_ctx, &domain_pol,
2929                                      MAXIMUM_ALLOWED_ACCESS,
2930                                      rids[0], &group_pol);
2931
2932         if (!NT_STATUS_IS_OK(result))
2933                 return result;
2934
2935         ZERO_STRUCT(ctr);
2936
2937         ctr.switch_value1 = 2;
2938         init_samr_group_info2(&ctr.group.info2, argv[1]);
2939
2940         result = rpccli_samr_set_groupinfo(pipe_hnd, mem_ctx, &group_pol, &ctr);
2941
2942         if (!NT_STATUS_IS_OK(result))
2943                 return result;
2944
2945         return NT_STATUS_NO_SUCH_GROUP;
2946 }
2947
2948 static int rpc_group_rename(int argc, const char **argv)
2949 {
2950         if (argc != 2) {
2951                 return rpc_group_usage(argc, argv);
2952         }
2953
2954         return run_rpc_command(NULL, PI_SAMR, 0,
2955                                rpc_group_rename_internals,
2956                                argc, argv);
2957 }
2958
2959 /**
2960  * 'net rpc group' entrypoint.
2961  * @param argc  Standard main() style argc
2962  * @param argc  Standard main() style argv.  Initial components are already
2963  *              stripped
2964  **/
2965
2966 int net_rpc_group(int argc, const char **argv)
2967 {
2968         struct functable func[] = {
2969                 {"add", rpc_group_add},
2970                 {"delete", rpc_group_delete},
2971                 {"addmem", rpc_group_addmem},
2972                 {"delmem", rpc_group_delmem},
2973                 {"list", rpc_group_list},
2974                 {"members", rpc_group_members},
2975                 {"rename", rpc_group_rename},
2976                 {NULL, NULL}
2977         };
2978
2979         if (argc == 0) {
2980                 return run_rpc_command(NULL, PI_SAMR, 0,
2981                                        rpc_group_list_internals,
2982                                        argc, argv);
2983         }
2984
2985         return net_run_function(argc, argv, func, rpc_group_usage);
2986 }
2987
2988 /****************************************************************************/
2989
2990 static int rpc_share_usage(int argc, const char **argv)
2991 {
2992         return net_help_share(argc, argv);
2993 }
2994
2995 /**
2996  * Add a share on a remote RPC server
2997  *
2998  * All parameters are provided by the run_rpc_command function, except for
2999  * argc, argv which are passes through.
3000  *
3001  * @param domain_sid The domain sid acquired from the remote server
3002  * @param cli A cli_state connected to the server.
3003  * @param mem_ctx Talloc context, destoyed on completion of the function.
3004  * @param argc  Standard main() style argc
3005  * @param argv  Standard main() style argv.  Initial components are already
3006  *              stripped
3007  *
3008  * @return Normal NTSTATUS return.
3009  **/
3010 static NTSTATUS rpc_share_add_internals(const DOM_SID *domain_sid,
3011                                         const char *domain_name,
3012                                         struct cli_state *cli,
3013                                         struct rpc_pipe_client *pipe_hnd,
3014                                         TALLOC_CTX *mem_ctx,int argc,
3015                                         const char **argv)
3016 {
3017         NTSTATUS result;
3018         char *sharename;
3019         char *path;
3020         uint32 type = STYPE_DISKTREE; /* only allow disk shares to be added */
3021         uint32 num_users=0, perms=0;
3022         char *password=NULL; /* don't allow a share password */
3023         uint32 level = 2;
3024         uint32 parm_error;
3025         union srvsvc_NetShareInfo info;
3026         struct srvsvc_NetShareInfo2 info2;
3027
3028         if ((sharename = talloc_strdup(mem_ctx, argv[0])) == NULL) {
3029                 return NT_STATUS_NO_MEMORY;
3030         }
3031
3032         path = strchr(sharename, '=');
3033         if (!path)
3034                 return NT_STATUS_UNSUCCESSFUL;
3035         *path++ = '\0';
3036
3037         info.info2 = &info2;
3038
3039         info2.type = type;
3040         info2.comment = opt_comment;
3041         info2.permissions = perms;
3042         info2.max_users = opt_maxusers;
3043         info2.current_users = num_users;
3044         info2.path = path;
3045         info2.password = password;
3046         info2.name = sharename;
3047
3048         result = rpccli_srvsvc_NetShareAdd(pipe_hnd, mem_ctx, NULL, level,
3049                                            info, &parm_error);
3050         return result;
3051 }
3052
3053 static int rpc_share_add(int argc, const char **argv)
3054 {
3055         if ((argc < 1) || !strchr(argv[0], '=')) {
3056                 DEBUG(1,("Sharename or path not specified on add\n"));
3057                 return rpc_share_usage(argc, argv);
3058         }
3059         return run_rpc_command(NULL, PI_SRVSVC, 0,
3060                                rpc_share_add_internals,
3061                                argc, argv);
3062 }
3063
3064 /**
3065  * Delete a share on a remote RPC server
3066  *
3067  * All parameters are provided by the run_rpc_command function, except for
3068  * argc, argv which are passes through.
3069  *
3070  * @param domain_sid The domain sid acquired from the remote server
3071  * @param cli A cli_state connected to the server.
3072  * @param mem_ctx Talloc context, destoyed on completion of the function.
3073  * @param argc  Standard main() style argc
3074  * @param argv  Standard main() style argv.  Initial components are already
3075  *              stripped
3076  *
3077  * @return Normal NTSTATUS return.
3078  **/
3079 static NTSTATUS rpc_share_del_internals(const DOM_SID *domain_sid,
3080                                         const char *domain_name,
3081                                         struct cli_state *cli,
3082                                         struct rpc_pipe_client *pipe_hnd,
3083                                         TALLOC_CTX *mem_ctx,
3084                                         int argc,
3085                                         const char **argv)
3086 {
3087         return rpccli_srvsvc_NetShareDel(pipe_hnd, mem_ctx, NULL, argv[0], 0);
3088 }
3089
3090 /**
3091  * Delete a share on a remote RPC server
3092  *
3093  * @param domain_sid The domain sid acquired from the remote server
3094  * @param argc  Standard main() style argc
3095  * @param argv  Standard main() style argv.  Initial components are already
3096  *              stripped
3097  *
3098  * @return A shell status integer (0 for success)
3099  **/
3100 static int rpc_share_delete(int argc, const char **argv)
3101 {
3102         if (argc < 1) {
3103                 DEBUG(1,("Sharename not specified on delete\n"));
3104                 return rpc_share_usage(argc, argv);
3105         }
3106         return run_rpc_command(NULL, PI_SRVSVC, 0,
3107                                rpc_share_del_internals,
3108                                argc, argv);
3109 }
3110
3111 /**
3112  * Formatted print of share info
3113  *
3114  * @param info1  pointer to struct srvsvc_NetShareInfo1 to format
3115  **/
3116
3117 static void display_share_info_1(struct srvsvc_NetShareInfo1 *info1)
3118 {
3119         if (opt_long_list_entries) {
3120                 d_printf("%-12s %-8.8s %-50s\n",
3121                          info1->name, share_type[info1->type & ~(STYPE_TEMPORARY|STYPE_HIDDEN)],
3122                          info1->comment ? info1->comment : "");
3123         } else {
3124                 d_printf("%s\n", info1->name);
3125         }
3126
3127 }
3128
3129 static NTSTATUS get_share_info(struct rpc_pipe_client *pipe_hnd,
3130                                 TALLOC_CTX *mem_ctx,
3131                                 uint32 level,
3132                                 int argc,
3133                                 const char **argv,
3134                                 union srvsvc_NetShareCtr *ctr,
3135                                 uint32 *numentries)
3136 {
3137         union srvsvc_NetShareInfo info;
3138         NTSTATUS status;
3139
3140         switch(level) {
3141         case 1:
3142                 if (!(ctr->ctr1 = TALLOC_ZERO_P(
3143                               mem_ctx, struct srvsvc_NetShareCtr1))) {
3144                         return NT_STATUS_NO_MEMORY;
3145                 }
3146                 break;
3147         case 502:
3148                 if (!(ctr->ctr502 = TALLOC_ZERO_P(
3149                               mem_ctx, struct srvsvc_NetShareCtr502))) {
3150                         return NT_STATUS_NO_MEMORY;
3151                 }
3152                 break;
3153         default:
3154                 return NT_STATUS_INVALID_LEVEL;
3155                 break;
3156         }
3157
3158         /* no specific share requested, enumerate all */
3159         if (argc == 0) {
3160                 uint32 hnd = 0;
3161
3162                 return rpccli_srvsvc_NetShareEnum(pipe_hnd, mem_ctx, NULL,
3163                                                   &level, ctr, 0xffffffff,
3164                                                   numentries, &hnd);
3165         }
3166
3167         /* request just one share */
3168         status = rpccli_srvsvc_NetShareGetInfo(pipe_hnd, mem_ctx, NULL,
3169                                                argv[0], level, &info);
3170         if (!NT_STATUS_IS_OK(status)) {
3171                 return status;
3172         }
3173
3174         *numentries = 1;
3175
3176         switch(level) {
3177         case 1:
3178                 ctr->ctr1->count = 1;
3179                 ctr->ctr1->array = info.info1;
3180                 break;
3181         case 502:
3182                 ctr->ctr501->count = 1;
3183                 ctr->ctr502->array = info.info502;
3184                 break;
3185         default:
3186                 return NT_STATUS_INTERNAL_ERROR;
3187                 break;
3188         }
3189
3190         return NT_STATUS_OK;
3191 }
3192
3193 /**
3194  * List shares on a remote RPC server
3195  *
3196  * All parameters are provided by the run_rpc_command function, except for
3197  * argc, argv which are passes through.
3198  *
3199  * @param domain_sid The domain sid acquired from the remote server
3200  * @param cli A cli_state connected to the server.
3201  * @param mem_ctx Talloc context, destoyed on completion of the function.
3202  * @param argc  Standard main() style argc
3203  * @param argv  Standard main() style argv.  Initial components are already
3204  *              stripped
3205  *
3206  * @return Normal NTSTATUS return.
3207  **/
3208
3209 static NTSTATUS rpc_share_list_internals(const DOM_SID *domain_sid,
3210                                         const char *domain_name,
3211                                         struct cli_state *cli,
3212                                         struct rpc_pipe_client *pipe_hnd,
3213                                         TALLOC_CTX *mem_ctx,
3214                                         int argc,
3215                                         const char **argv)
3216 {
3217         union srvsvc_NetShareCtr ctr;
3218         NTSTATUS result;
3219         uint32 i, level = 1;
3220         uint32 numentries;
3221
3222         result = get_share_info(pipe_hnd, mem_ctx, level, argc, argv, &ctr,
3223                                                         &numentries);
3224         if (!NT_STATUS_IS_OK(result))
3225                 goto done;
3226
3227         /* Display results */
3228
3229         if (opt_long_list_entries) {
3230                 d_printf(
3231         "\nEnumerating shared resources (exports) on remote server:\n\n"\
3232         "\nShare name   Type     Description\n"\
3233         "----------   ----     -----------\n");
3234         }
3235         for (i = 0; i < numentries; i++)
3236                 display_share_info_1(&ctr.ctr1->array[i]);
3237  done:
3238         return NT_STATUS_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
3239 }
3240
3241 /***
3242  * 'net rpc share list' entrypoint.
3243  * @param argc  Standard main() style argc
3244  * @param argv  Standard main() style argv.  Initial components are already
3245  *              stripped
3246  **/
3247 static int rpc_share_list(int argc, const char **argv)
3248 {
3249         return run_rpc_command(NULL, PI_SRVSVC, 0, rpc_share_list_internals, argc, argv);
3250 }
3251
3252 static BOOL check_share_availability(struct cli_state *cli, const char *netname)
3253 {
3254         if (!cli_send_tconX(cli, netname, "A:", "", 0)) {
3255                 d_printf("skipping   [%s]: not a file share.\n", netname);
3256                 return False;
3257         }
3258
3259         if (!cli_tdis(cli))
3260                 return False;
3261
3262         return True;
3263 }
3264
3265 static BOOL check_share_sanity(struct cli_state *cli, const char *netname, uint32 type)
3266 {
3267         /* only support disk shares */
3268         if (! ( type == STYPE_DISKTREE || type == (STYPE_DISKTREE | STYPE_HIDDEN)) ) {
3269                 printf("share [%s] is not a diskshare (type: %x)\n", netname, type);
3270                 return False;
3271         }
3272
3273         /* skip builtin shares */
3274         /* FIXME: should print$ be added too ? */
3275         if (strequal(netname,"IPC$") || strequal(netname,"ADMIN$") ||
3276             strequal(netname,"global"))
3277                 return False;
3278
3279         if (opt_exclude && in_list(netname, opt_exclude, False)) {
3280                 printf("excluding  [%s]\n", netname);
3281                 return False;
3282         }
3283
3284         return check_share_availability(cli, netname);
3285 }
3286
3287 /**
3288  * Migrate shares from a remote RPC server to the local RPC srever
3289  *
3290  * All parameters are provided by the run_rpc_command function, except for
3291  * argc, argv which are passes through.
3292  *
3293  * @param domain_sid The domain sid acquired from the remote server
3294  * @param cli A cli_state connected to the server.
3295  * @param mem_ctx Talloc context, destoyed on completion of the function.
3296  * @param argc  Standard main() style argc
3297  * @param argv  Standard main() style argv.  Initial components are already
3298  *              stripped
3299  *
3300  * @return Normal NTSTATUS return.
3301  **/
3302
3303 static NTSTATUS rpc_share_migrate_shares_internals(const DOM_SID *domain_sid,
3304                                                 const char *domain_name,
3305                                                 struct cli_state *cli,
3306                                                 struct rpc_pipe_client *pipe_hnd,
3307                                                 TALLOC_CTX *mem_ctx,
3308                                                 int argc,
3309                                                 const char **argv)
3310 {
3311         NTSTATUS result;
3312         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
3313         union srvsvc_NetShareCtr ctr_src;
3314         uint32 i;
3315         struct rpc_pipe_client *srvsvc_pipe = NULL;
3316         struct cli_state *cli_dst = NULL;
3317         uint32 level = 502; /* includes secdesc */
3318         uint32 numentries;
3319
3320         result = get_share_info(pipe_hnd, mem_ctx, level, argc, argv, &ctr_src,
3321                                                         &numentries);
3322         if (!NT_STATUS_IS_OK(result))
3323                 goto done;
3324
3325         /* connect destination PI_SRVSVC */
3326         nt_status = connect_dst_pipe(&cli_dst, &srvsvc_pipe, PI_SRVSVC);
3327         if (!NT_STATUS_IS_OK(nt_status))
3328                 return nt_status;
3329
3330
3331         for (i = 0; i < numentries; i++) {
3332                 uint32 parm_error = 0;
3333                 union srvsvc_NetShareInfo info;
3334
3335                 /* reset error-code */
3336                 nt_status = NT_STATUS_UNSUCCESSFUL;
3337
3338                 if (!check_share_sanity(cli, ctr_src.ctr502->array[i].name,
3339                                                                 ctr_src.ctr502->array[i].type))
3340
3341                         continue;
3342
3343                 /* finally add the share on the dst server */
3344
3345                 printf("migrating: [%s], path: %s, comment: %s, without share-ACLs\n",
3346                         ctr_src.ctr502->array[i].name,
3347                         ctr_src.ctr502->array[i].path,
3348                         ctr_src.ctr502->array[i].comment);
3349
3350                 info.info502 = &ctr_src.ctr502->array[i];
3351
3352                 result = rpccli_srvsvc_NetShareAdd(srvsvc_pipe, mem_ctx, NULL,
3353                                                    502, info, &parm_error);
3354
3355                 if (NT_STATUS_EQUAL(result, NT_STATUS_OBJECT_NAME_COLLISION)) {
3356                         printf("           [%s] does already exist\n", ctr_src.ctr502->array[i].name);
3357                         continue;
3358                 }
3359
3360                 if (!NT_STATUS_IS_OK(result)) {
3361                         printf("cannot add share: %s\n", nt_errstr(result));
3362                         goto done;
3363                 }
3364
3365         }
3366
3367         nt_status = NT_STATUS_OK;
3368
3369 done:
3370         if (cli_dst) {
3371                 cli_shutdown(cli_dst);
3372         }
3373
3374         return nt_status;
3375
3376 }
3377
3378 /**
3379  * Migrate shares from a rpc-server to another
3380  *
3381  * @param argc  Standard main() style argc
3382  * @param argv  Standard main() style argv.  Initial components are already
3383  *              stripped
3384  *
3385  * @return A shell status integer (0 for success)
3386  **/
3387 static int rpc_share_migrate_shares(int argc, const char **argv)
3388 {
3389
3390         if (!opt_host) {
3391                 printf("no server to migrate\n");
3392                 return -1;
3393         }
3394
3395         return run_rpc_command(NULL, PI_SRVSVC, 0,
3396                                rpc_share_migrate_shares_internals,
3397                                argc, argv);
3398 }
3399
3400 /**
3401  * Copy a file/dir
3402  *
3403  * @param f     file_info
3404  * @param mask  current search mask
3405  * @param state arg-pointer
3406  *
3407  **/
3408 static void copy_fn(const char *mnt, file_info *f, const char *mask, void *state)
3409 {
3410         static NTSTATUS nt_status;
3411         static struct copy_clistate *local_state;
3412         static fstring filename, new_mask;
3413         fstring dir;
3414         char *old_dir;
3415
3416         local_state = (struct copy_clistate *)state;
3417         nt_status = NT_STATUS_UNSUCCESSFUL;
3418
3419         if (strequal(f->name, ".") || strequal(f->name, ".."))
3420                 return;
3421
3422         DEBUG(3,("got mask: %s, name: %s\n", mask, f->name));
3423
3424         /* DIRECTORY */
3425         if (f->mode & aDIR) {
3426
3427                 DEBUG(3,("got dir: %s\n", f->name));
3428
3429                 fstrcpy(dir, local_state->cwd);
3430                 fstrcat(dir, "\\");
3431                 fstrcat(dir, f->name);
3432
3433                 switch (net_mode_share)
3434                 {
3435                 case NET_MODE_SHARE_MIGRATE:
3436                         /* create that directory */
3437                         nt_status = net_copy_file(local_state->mem_ctx,
3438                                                   local_state->cli_share_src,
3439                                                   local_state->cli_share_dst,
3440                                                   dir, dir,
3441                                                   opt_acls? True : False,
3442                                                   opt_attrs? True : False,
3443                                                   opt_timestamps? True : False,
3444                                                   False);
3445                         break;
3446                 default:
3447                         d_fprintf(stderr, "Unsupported mode %d\n", net_mode_share);
3448                         return;
3449                 }
3450
3451                 if (!NT_STATUS_IS_OK(nt_status))
3452                         printf("could not handle dir %s: %s\n",
3453                                 dir, nt_errstr(nt_status));
3454
3455                 /* search below that directory */
3456                 fstrcpy(new_mask, dir);
3457                 fstrcat(new_mask, "\\*");
3458
3459                 old_dir = local_state->cwd;
3460                 local_state->cwd = dir;
3461                 if (!sync_files(local_state, new_mask))
3462                         printf("could not handle files\n");
3463                 local_state->cwd = old_dir;
3464
3465                 return;
3466         }
3467
3468
3469         /* FILE */
3470         fstrcpy(filename, local_state->cwd);
3471         fstrcat(filename, "\\");
3472         fstrcat(filename, f->name);
3473
3474         DEBUG(3,("got file: %s\n", filename));
3475
3476         switch (net_mode_share)
3477         {
3478         case NET_MODE_SHARE_MIGRATE:
3479                 nt_status = net_copy_file(local_state->mem_ctx,
3480                                           local_state->cli_share_src,
3481                                           local_state->cli_share_dst,
3482                                           filename, filename,
3483                                           opt_acls? True : False,
3484                                           opt_attrs? True : False,
3485                                           opt_timestamps? True: False,
3486                                           True);
3487                 break;
3488         default:
3489                 d_fprintf(stderr, "Unsupported file mode %d\n", net_mode_share);
3490                 return;
3491         }
3492
3493         if (!NT_STATUS_IS_OK(nt_status))
3494                 printf("could not handle file %s: %s\n",
3495                         filename, nt_errstr(nt_status));
3496
3497 }
3498
3499 /**
3500  * sync files, can be called recursivly to list files
3501  * and then call copy_fn for each file
3502  *
3503  * @param cp_clistate   pointer to the copy_clistate we work with
3504  * @param mask          the current search mask
3505  *
3506  * @return              Boolean result
3507  **/
3508 BOOL sync_files(struct copy_clistate *cp_clistate, pstring mask)
3509 {
3510         struct cli_state *targetcli;
3511         pstring targetpath;
3512
3513         DEBUG(3,("calling cli_list with mask: %s\n", mask));
3514
3515         if ( !cli_resolve_path( "", cp_clistate->cli_share_src, mask, &targetcli, targetpath ) ) {
3516                 d_fprintf(stderr, "cli_resolve_path %s failed with error: %s\n",
3517                         mask, cli_errstr(cp_clistate->cli_share_src));
3518                 return False;
3519         }
3520
3521         if (cli_list(targetcli, targetpath, cp_clistate->attribute, copy_fn, cp_clistate) == -1) {
3522                 d_fprintf(stderr, "listing %s failed with error: %s\n",
3523                         mask, cli_errstr(targetcli));
3524                 return False;
3525         }
3526
3527         return True;
3528 }
3529
3530
3531 /**
3532  * Set the top level directory permissions before we do any further copies.
3533  * Should set up ACL inheritance.
3534  **/
3535
3536 BOOL copy_top_level_perms(struct copy_clistate *cp_clistate,
3537                                 const char *sharename)
3538 {
3539         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
3540
3541         switch (net_mode_share) {
3542         case NET_MODE_SHARE_MIGRATE:
3543                 DEBUG(3,("calling net_copy_fileattr for '.' directory in share %s\n", sharename));
3544                 nt_status = net_copy_fileattr(cp_clistate->mem_ctx,
3545                                                 cp_clistate->cli_share_src,
3546                                                 cp_clistate->cli_share_dst,
3547                                                 "\\", "\\",
3548                                                 opt_acls? True : False,
3549                                                 opt_attrs? True : False,
3550                                                 opt_timestamps? True: False,
3551                                                 False);
3552                 break;
3553         default:
3554                 d_fprintf(stderr, "Unsupported mode %d\n", net_mode_share);
3555                 break;
3556         }
3557
3558         if (!NT_STATUS_IS_OK(nt_status))  {
3559                 printf("Could handle directory attributes for top level directory of share %s. Error %s\n",
3560                         sharename, nt_errstr(nt_status));
3561                 return False;
3562         }
3563
3564         return True;
3565 }
3566
3567 /**
3568  * Sync all files inside a remote share to another share (over smb)
3569  *
3570  * All parameters are provided by the run_rpc_command function, except for
3571  * argc, argv which are passes through.
3572  *
3573  * @param domain_sid The domain sid acquired from the remote server
3574  * @param cli A cli_state connected to the server.
3575  * @param mem_ctx Talloc context, destoyed on completion of the function.
3576  * @param argc  Standard main() style argc
3577  * @param argv  Standard main() style argv.  Initial components are already
3578  *              stripped
3579  *
3580  * @return Normal NTSTATUS return.
3581  **/
3582
3583 static NTSTATUS rpc_share_migrate_files_internals(const DOM_SID *domain_sid,
3584                                                 const char *domain_name,
3585                                                 struct cli_state *cli,
3586                                                 struct rpc_pipe_client *pipe_hnd,
3587                                                 TALLOC_CTX *mem_ctx,
3588                                                 int argc,
3589                                                 const char **argv)
3590 {
3591         NTSTATUS result;
3592         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
3593         union srvsvc_NetShareCtr ctr_src;
3594         uint32 i;
3595         uint32 level = 502;
3596         struct copy_clistate cp_clistate;
3597         BOOL got_src_share = False;
3598         BOOL got_dst_share = False;
3599         pstring mask = "\\*";
3600         char *dst = NULL;
3601         uint32 numentries;
3602
3603         dst = SMB_STRDUP(opt_destination?opt_destination:"127.0.0.1");
3604
3605         result = get_share_info(pipe_hnd, mem_ctx, level, argc, argv, &ctr_src,
3606                                                         &numentries);
3607
3608         if (!NT_STATUS_IS_OK(result))
3609                 goto done;
3610
3611         for (i = 0; i < numentries; i++) {
3612                 if (!check_share_sanity(cli, ctr_src.ctr502->array[i].name,
3613                                                         ctr_src.ctr502->array[i].type))
3614                         continue;
3615
3616                 /* one might not want to mirror whole discs :) */
3617                 if (strequal(ctr_src.ctr502->array[i].name, "print$") || ctr_src.ctr502->array[i].name[1] == '$') {
3618                         d_printf("skipping   [%s]: builtin/hidden share\n", ctr_src.ctr502->array[i].name);
3619                         continue;
3620                 }
3621
3622                 switch (net_mode_share)
3623                 {
3624                 case NET_MODE_SHARE_MIGRATE:
3625                         printf("syncing");
3626                         break;
3627                 default:
3628                         d_fprintf(stderr, "Unsupported mode %d\n", net_mode_share);
3629                         break;
3630                 }
3631                 printf("    [%s] files and directories %s ACLs, %s DOS Attributes %s\n",
3632                         ctr_src.ctr502->array[i].name,
3633                         opt_acls ? "including" : "without",
3634                         opt_attrs ? "including" : "without",
3635                         opt_timestamps ? "(preserving timestamps)" : "");
3636
3637                 cp_clistate.mem_ctx = mem_ctx;
3638                 cp_clistate.cli_share_src = NULL;
3639                 cp_clistate.cli_share_dst = NULL;
3640                 cp_clistate.cwd = NULL;
3641                 cp_clistate.attribute = aSYSTEM | aHIDDEN | aDIR;
3642
3643                 /* open share source */
3644                 nt_status = connect_to_service(&cp_clistate.cli_share_src,
3645                                                &cli->dest_ip, cli->desthost,
3646                                                    ctr_src.ctr502->array[i].name, "A:");
3647                 if (!NT_STATUS_IS_OK(nt_status))
3648                         goto done;
3649
3650                 got_src_share = True;
3651
3652                 if (net_mode_share == NET_MODE_SHARE_MIGRATE) {
3653                         /* open share destination */
3654                         nt_status = connect_to_service(&cp_clistate.cli_share_dst,
3655                                                        NULL, dst, ctr_src.ctr502->array[i].name, "A:");
3656                         if (!NT_STATUS_IS_OK(nt_status))
3657                                 goto done;
3658
3659                         got_dst_share = True;
3660                 }
3661
3662                 if (!copy_top_level_perms(&cp_clistate, ctr_src.ctr502->array[i].name)) {
3663                         d_fprintf(stderr, "Could not handle the top level directory permissions for the share: %s\n", ctr_src.ctr502->array[i].name);
3664                         nt_status = NT_STATUS_UNSUCCESSFUL;
3665                         goto done;
3666                 }
3667
3668                 if (!sync_files(&cp_clistate, mask)) {
3669                         d_fprintf(stderr, "could not handle files for share: %s\n",
3670                                           ctr_src.ctr502->array[i].name);
3671                         nt_status = NT_STATUS_UNSUCCESSFUL;
3672                         goto done;
3673                 }
3674         }
3675
3676         nt_status = NT_STATUS_OK;
3677
3678 done:
3679
3680         if (got_src_share)
3681                 cli_shutdown(cp_clistate.cli_share_src);
3682
3683         if (got_dst_share)
3684                 cli_shutdown(cp_clistate.cli_share_dst);
3685
3686         return nt_status;
3687
3688 }
3689
3690 static int rpc_share_migrate_files(int argc, const char **argv)
3691 {
3692
3693         if (!opt_host) {
3694                 printf("no server to migrate\n");
3695                 return -1;
3696         }
3697
3698         return run_rpc_command(NULL, PI_SRVSVC, 0,
3699                                rpc_share_migrate_files_internals,
3700                                argc, argv);
3701 }
3702
3703 /**
3704  * Migrate share-ACLs from a remote RPC server to the local RPC srever
3705  *
3706  * All parameters are provided by the run_rpc_command function, except for
3707  * argc, argv which are passes through.
3708  *
3709  * @param domain_sid The domain sid acquired from the remote server
3710  * @param cli A cli_state connected to the server.
3711  * @param mem_ctx Talloc context, destoyed on completion of the function.
3712  * @param argc  Standard main() style argc
3713  * @param argv  Standard main() style argv.  Initial components are already
3714  *              stripped
3715  *
3716  * @return Normal NTSTATUS return.
3717  **/
3718
3719 static NTSTATUS rpc_share_migrate_security_internals(const DOM_SID *domain_sid,
3720                                                 const char *domain_name,
3721                                                 struct cli_state *cli,
3722                                                 struct rpc_pipe_client *pipe_hnd,
3723                                                 TALLOC_CTX *mem_ctx,
3724                                                 int argc,
3725                                                 const char **argv)
3726 {
3727         NTSTATUS result;
3728         NTSTATUS nt_status = NT_STATUS_UNSUCCESSFUL;
3729         union srvsvc_NetShareCtr ctr_src;
3730         union srvsvc_NetShareInfo info;
3731         uint32 i;
3732         struct rpc_pipe_client *srvsvc_pipe = NULL;
3733         struct cli_state *cli_dst = NULL;
3734         uint32 level = 502; /* includes secdesc */
3735         uint32 numentries;
3736         uint32 parm_error = 0;
3737
3738         result = get_share_info(pipe_hnd, mem_ctx, level, argc, argv, &ctr_src,
3739                                                         &numentries);
3740
3741         if (!NT_STATUS_IS_OK(result))
3742                 goto done;
3743
3744         /* connect destination PI_SRVSVC */
3745         nt_status = connect_dst_pipe(&cli_dst, &srvsvc_pipe, PI_SRVSVC);
3746         if (!NT_STATUS_IS_OK(nt_status))
3747                 return nt_status;
3748
3749
3750         for (i = 0; i < numentries; i++) {
3751                 /* reset error-code */
3752                 nt_status = NT_STATUS_UNSUCCESSFUL;
3753
3754                 if (!check_share_sanity(cli, ctr_src.ctr502->array[i].name, ctr_src.ctr502->array[i].type))
3755                         continue;
3756
3757                 printf("migrating: [%s], path: %s, comment: %s, including share-ACLs\n",
3758                         ctr_src.ctr502->array[i].name,
3759                         ctr_src.ctr502->array[i].path,
3760                         ctr_src.ctr502->array[i].comment);
3761
3762                 if (opt_verbose)
3763                         display_sec_desc(ctr_src.ctr502->array[i].sd);
3764
3765                 /* init info */
3766                 ZERO_STRUCT(info);
3767
3768                 /* finally modify the share on the dst server */
3769                 result = rpccli_srvsvc_NetShareSetInfo(
3770                         srvsvc_pipe, mem_ctx, NULL, argv[0], level, info,
3771                         &parm_error);
3772
3773                 if (!NT_STATUS_IS_OK(result)) {
3774                         printf("cannot set share-acl: %s\n", nt_errstr(result));
3775                         goto done;
3776                 }
3777
3778         }
3779
3780         nt_status = NT_STATUS_OK;
3781
3782 done:
3783         if (cli_dst) {
3784                 cli_shutdown(cli_dst);
3785         }
3786
3787         return nt_status;
3788
3789 }
3790
3791 /**
3792  * Migrate share-acls from a rpc-server to another
3793  *
3794  * @param argc  Standard main() style argc
3795  * @param argv  Standard main() style argv.  Initial components are already
3796  *              stripped
3797  *
3798  * @return A shell status integer (0 for success)
3799  **/
3800 static int rpc_share_migrate_security(int argc, const char **argv)
3801 {
3802
3803         if (!opt_host) {
3804                 printf("no server to migrate\n");
3805                 return -1;
3806         }
3807
3808         return run_rpc_command(NULL, PI_SRVSVC, 0,
3809                                rpc_share_migrate_security_internals,
3810                                argc, argv);
3811 }
3812
3813 /**
3814  * Migrate shares (including share-definitions, share-acls and files with acls/attrs)
3815  * from one server to another
3816  *
3817  * @param argc  Standard main() style argc
3818  * @param argv  Standard main() style argv.  Initial components are already
3819  *              stripped
3820  *
3821  * @return A shell status integer (0 for success)
3822  *
3823  **/
3824 static int rpc_share_migrate_all(int argc, const char **argv)
3825 {
3826         int ret;
3827
3828         if (!opt_host) {
3829                 printf("no server to migrate\n");
3830                 return -1;
3831         }
3832
3833         /* order is important. we don't want to be locked out by the share-acl
3834          * before copying files - gd */
3835
3836         ret = run_rpc_command(NULL, PI_SRVSVC, 0, rpc_share_migrate_shares_internals, argc, argv);
3837         if (ret)
3838                 return ret;
3839
3840         ret = run_rpc_command(NULL, PI_SRVSVC, 0, rpc_share_migrate_files_internals, argc, argv);
3841         if (ret)
3842                 return ret;
3843
3844         return run_rpc_command(NULL, PI_SRVSVC, 0, rpc_share_migrate_security_internals, argc, argv);
3845 }
3846
3847
3848 /**
3849  * 'net rpc share migrate' entrypoint.
3850  * @param argc  Standard main() style argc
3851  * @param argv  Standard main() style argv.  Initial components are already
3852  *              stripped
3853  **/
3854 static int rpc_share_migrate(int argc, const char **argv)
3855 {
3856
3857         struct functable func[] = {
3858                 {"all",         rpc_share_migrate_all},
3859                 {"files",       rpc_share_migrate_files},
3860                 {"help",        rpc_share_usage},
3861                 {"security",    rpc_share_migrate_security},
3862                 {"shares",      rpc_share_migrate_shares},
3863                 {NULL, NULL}
3864         };
3865
3866         net_mode_share = NET_MODE_SHARE_MIGRATE;
3867
3868         return net_run_function(argc, argv, func, rpc_share_usage);
3869 }
3870
3871 struct full_alias {
3872         DOM_SID sid;
3873         uint32 num_members;
3874         DOM_SID *members;
3875 };
3876
3877 static int num_server_aliases;
3878 static struct full_alias *server_aliases;
3879
3880 /*
3881  * Add an alias to the static list.
3882  */
3883 static void push_alias(TALLOC_CTX *mem_ctx, struct full_alias *alias)
3884 {
3885         if (server_aliases == NULL)
3886                 server_aliases = SMB_MALLOC_ARRAY(struct full_alias, 100);
3887
3888         server_aliases[num_server_aliases] = *alias;
3889         num_server_aliases += 1;
3890 }
3891
3892 /*
3893  * For a specific domain on the server, fetch all the aliases
3894  * and their members. Add all of them to the server_aliases.
3895  */
3896
3897 static NTSTATUS rpc_fetch_domain_aliases(struct rpc_pipe_client *pipe_hnd,
3898                                         TALLOC_CTX *mem_ctx,
3899                                         POLICY_HND *connect_pol,
3900                                         const DOM_SID *domain_sid)
3901 {
3902         uint32 start_idx, max_entries, num_entries, i;
3903         struct acct_info *groups;
3904         NTSTATUS result;
3905         POLICY_HND domain_pol;
3906
3907         /* Get domain policy handle */
3908
3909         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, connect_pol,
3910                                       MAXIMUM_ALLOWED_ACCESS,
3911                                       domain_sid, &domain_pol);
3912         if (!NT_STATUS_IS_OK(result))
3913                 return result;
3914
3915         start_idx = 0;
3916         max_entries = 250;
3917
3918         do {
3919                 result = rpccli_samr_enum_als_groups(pipe_hnd, mem_ctx, &domain_pol,
3920                                                   &start_idx, max_entries,
3921                                                   &groups, &num_entries);
3922
3923                 for (i = 0; i < num_entries; i++) {
3924
3925                         POLICY_HND alias_pol;
3926                         struct full_alias alias;
3927                         DOM_SID *members;
3928                         int j;
3929
3930                         result = rpccli_samr_open_alias(pipe_hnd, mem_ctx, &domain_pol,
3931                                                      MAXIMUM_ALLOWED_ACCESS,
3932                                                      groups[i].rid,
3933                                                      &alias_pol);
3934                         if (!NT_STATUS_IS_OK(result))
3935                                 goto done;
3936
3937                         result = rpccli_samr_query_aliasmem(pipe_hnd, mem_ctx,
3938                                                          &alias_pol,
3939                                                          &alias.num_members,
3940                                                          &members);
3941                         if (!NT_STATUS_IS_OK(result))
3942                                 goto done;
3943
3944                         result = rpccli_samr_close(pipe_hnd, mem_ctx, &alias_pol);
3945                         if (!NT_STATUS_IS_OK(result))
3946                                 goto done;
3947
3948                         alias.members = NULL;
3949
3950                         if (alias.num_members > 0) {
3951                                 alias.members = SMB_MALLOC_ARRAY(DOM_SID, alias.num_members);
3952
3953                                 for (j = 0; j < alias.num_members; j++)
3954                                         sid_copy(&alias.members[j],
3955                                                  &members[j]);
3956                         }
3957
3958                         sid_copy(&alias.sid, domain_sid);
3959                         sid_append_rid(&alias.sid, groups[i].rid);
3960
3961                         push_alias(mem_ctx, &alias);
3962                 }
3963         } while (NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES));
3964
3965         result = NT_STATUS_OK;
3966
3967  done:
3968         rpccli_samr_close(pipe_hnd, mem_ctx, &domain_pol);
3969
3970         return result;
3971 }
3972
3973 /*
3974  * Dump server_aliases as names for debugging purposes.
3975  */
3976
3977 static NTSTATUS rpc_aliaslist_dump(const DOM_SID *domain_sid,
3978                                 const char *domain_name,
3979                                 struct cli_state *cli,
3980                                 struct rpc_pipe_client *pipe_hnd,
3981                                 TALLOC_CTX *mem_ctx,
3982                                 int argc,
3983                                 const char **argv)
3984 {
3985         int i;
3986         NTSTATUS result;
3987         POLICY_HND lsa_pol;
3988
3989         result = rpccli_lsa_open_policy(pipe_hnd, mem_ctx, True,
3990                                      SEC_RIGHTS_MAXIMUM_ALLOWED,
3991                                      &lsa_pol);
3992         if (!NT_STATUS_IS_OK(result))
3993                 return result;
3994
3995         for (i=0; i<num_server_aliases; i++) {
3996                 char **names;
3997                 char **domains;
3998                 enum lsa_SidType *types;
3999                 int j;
4000
4001                 struct full_alias *alias = &server_aliases[i];
4002
4003                 result = rpccli_lsa_lookup_sids(pipe_hnd, mem_ctx, &lsa_pol, 1,
4004                                              &alias->sid,
4005                                              &domains, &names, &types);
4006                 if (!NT_STATUS_IS_OK(result))
4007                         continue;
4008
4009                 DEBUG(1, ("%s\\%s %d: ", domains[0], names[0], types[0]));
4010
4011                 if (alias->num_members == 0) {
4012                         DEBUG(1, ("\n"));
4013                         continue;
4014                 }
4015
4016                 result = rpccli_lsa_lookup_sids(pipe_hnd, mem_ctx, &lsa_pol,
4017                                              alias->num_members,
4018                                              alias->members,
4019                                              &domains, &names, &types);
4020
4021                 if (!NT_STATUS_IS_OK(result) &&
4022                     !NT_STATUS_EQUAL(result, STATUS_SOME_UNMAPPED))
4023                         continue;
4024
4025                 for (j=0; j<alias->num_members; j++)
4026                         DEBUG(1, ("%s\\%s (%d); ",
4027                                   domains[j] ? domains[j] : "*unknown*",
4028                                   names[j] ? names[j] : "*unknown*",types[j]));
4029                 DEBUG(1, ("\n"));
4030         }
4031
4032         rpccli_lsa_Close(pipe_hnd, mem_ctx, &lsa_pol);
4033
4034         return NT_STATUS_OK;
4035 }
4036
4037 /*
4038  * Fetch a list of all server aliases and their members into
4039  * server_aliases.
4040  */
4041
4042 static NTSTATUS rpc_aliaslist_internals(const DOM_SID *domain_sid,
4043                                         const char *domain_name,
4044                                         struct cli_state *cli,
4045                                         struct rpc_pipe_client *pipe_hnd,
4046                                         TALLOC_CTX *mem_ctx,
4047                                         int argc,
4048                                         const char **argv)
4049 {
4050         NTSTATUS result;
4051         POLICY_HND connect_pol;
4052
4053         result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
4054                                   &connect_pol);
4055
4056         if (!NT_STATUS_IS_OK(result))
4057                 goto done;
4058
4059         result = rpc_fetch_domain_aliases(pipe_hnd, mem_ctx, &connect_pol,
4060                                           &global_sid_Builtin);
4061
4062         if (!NT_STATUS_IS_OK(result))
4063                 goto done;
4064
4065         result = rpc_fetch_domain_aliases(pipe_hnd, mem_ctx, &connect_pol,
4066                                           domain_sid);
4067
4068         rpccli_samr_close(pipe_hnd, mem_ctx, &connect_pol);
4069  done:
4070         return result;
4071 }
4072
4073 static void init_user_token(NT_USER_TOKEN *token, DOM_SID *user_sid)
4074 {
4075         token->num_sids = 4;
4076
4077         if (!(token->user_sids = SMB_MALLOC_ARRAY(DOM_SID, 4))) {
4078                 d_fprintf(stderr, "malloc failed\n");
4079                 token->num_sids = 0;
4080                 return;
4081         }
4082
4083         token->user_sids[0] = *user_sid;
4084         sid_copy(&token->user_sids[1], &global_sid_World);
4085         sid_copy(&token->user_sids[2], &global_sid_Network);
4086         sid_copy(&token->user_sids[3], &global_sid_Authenticated_Users);
4087 }
4088
4089 static void free_user_token(NT_USER_TOKEN *token)
4090 {
4091         SAFE_FREE(token->user_sids);
4092 }
4093
4094 static BOOL is_sid_in_token(NT_USER_TOKEN *token, DOM_SID *sid)
4095 {
4096         int i;
4097
4098         for (i=0; i<token->num_sids; i++) {
4099                 if (sid_compare(sid, &token->user_sids[i]) == 0)
4100                         return True;
4101         }
4102         return False;
4103 }
4104
4105 static void add_sid_to_token(NT_USER_TOKEN *token, DOM_SID *sid)
4106 {
4107         if (is_sid_in_token(token, sid))
4108                 return;
4109
4110         token->user_sids = SMB_REALLOC_ARRAY(token->user_sids, DOM_SID, token->num_sids+1);
4111         if (!token->user_sids) {
4112                 return;
4113         }
4114
4115         sid_copy(&token->user_sids[token->num_sids], sid);
4116
4117         token->num_sids += 1;
4118 }
4119
4120 struct user_token {
4121         fstring name;
4122         NT_USER_TOKEN token;
4123 };
4124
4125 static void dump_user_token(struct user_token *token)
4126 {
4127         int i;
4128
4129         d_printf("%s\n", token->name);
4130
4131         for (i=0; i<token->token.num_sids; i++) {
4132                 d_printf(" %s\n", sid_string_static(&token->token.user_sids[i]));
4133         }
4134 }
4135
4136 static BOOL is_alias_member(DOM_SID *sid, struct full_alias *alias)
4137 {
4138         int i;
4139
4140         for (i=0; i<alias->num_members; i++) {
4141                 if (sid_compare(sid, &alias->members[i]) == 0)
4142                         return True;
4143         }
4144
4145         return False;
4146 }
4147
4148 static void collect_sid_memberships(NT_USER_TOKEN *token, DOM_SID sid)
4149 {
4150         int i;
4151
4152         for (i=0; i<num_server_aliases; i++) {
4153                 if (is_alias_member(&sid, &server_aliases[i]))
4154                         add_sid_to_token(token, &server_aliases[i].sid);
4155         }
4156 }
4157
4158 /*
4159  * We got a user token with all the SIDs we can know about without asking the
4160  * server directly. These are the user and domain group sids. All of these can
4161  * be members of aliases. So scan the list of aliases for each of the SIDs and
4162  * add them to the token.
4163  */
4164
4165 static void collect_alias_memberships(NT_USER_TOKEN *token)
4166 {
4167         int num_global_sids = token->num_sids;
4168         int i;
4169
4170         for (i=0; i<num_global_sids; i++) {
4171                 collect_sid_memberships(token, token->user_sids[i]);
4172         }
4173 }
4174
4175 static BOOL get_user_sids(const char *domain, const char *user, NT_USER_TOKEN *token)
4176 {
4177         struct winbindd_request request;
4178         struct winbindd_response response;
4179         fstring full_name;
4180         NSS_STATUS result;
4181
4182         DOM_SID user_sid;
4183
4184         int i;
4185
4186         fstr_sprintf(full_name, "%s%c%s",
4187                      domain, *lp_winbind_separator(), user);
4188
4189         /* First let's find out the user sid */
4190
4191         ZERO_STRUCT(request);
4192         ZERO_STRUCT(response);
4193
4194         fstrcpy(request.data.name.dom_name, domain);
4195         fstrcpy(request.data.name.name, user);
4196
4197         result = winbindd_request_response(WINBINDD_LOOKUPNAME, &request, &response);
4198
4199         if (result != NSS_STATUS_SUCCESS) {
4200                 DEBUG(1, ("winbind could not find %s\n", full_name));
4201                 return False;
4202         }
4203
4204         if (response.data.sid.type != SID_NAME_USER) {
4205                 DEBUG(1, ("%s is not a user\n", full_name));
4206                 return False;
4207         }
4208
4209         string_to_sid(&user_sid, response.data.sid.sid);
4210
4211         init_user_token(token, &user_sid);
4212
4213         /* And now the groups winbind knows about */
4214
4215         ZERO_STRUCT(response);
4216
4217         fstrcpy(request.data.username, full_name);
4218
4219         result = winbindd_request_response(WINBINDD_GETGROUPS, &request, &response);
4220
4221         if (result != NSS_STATUS_SUCCESS) {
4222                 DEBUG(1, ("winbind could not get groups of %s\n", full_name));
4223                 return False;
4224         }
4225
4226         for (i = 0; i < response.data.num_entries; i++) {
4227                 gid_t gid = ((gid_t *)response.extra_data.data)[i];
4228                 DOM_SID sid;
4229
4230                 struct winbindd_request sidrequest;
4231                 struct winbindd_response sidresponse;
4232
4233                 ZERO_STRUCT(sidrequest);
4234                 ZERO_STRUCT(sidresponse);
4235
4236                 sidrequest.data.gid = gid;
4237
4238                 result = winbindd_request_response(WINBINDD_GID_TO_SID,
4239                                           &sidrequest, &sidresponse);
4240
4241                 if (result != NSS_STATUS_SUCCESS) {
4242                         DEBUG(1, ("winbind could not find SID of gid %d\n",
4243                                   gid));
4244                         return False;
4245                 }
4246
4247                 DEBUG(3, (" %s\n", sidresponse.data.sid.sid));
4248
4249                 string_to_sid(&sid, sidresponse.data.sid.sid);
4250                 add_sid_to_token(token, &sid);
4251         }
4252
4253         SAFE_FREE(response.extra_data.data);
4254
4255         return True;
4256 }
4257
4258 /**
4259  * Get a list of all user tokens we want to look at
4260  **/
4261
4262 static BOOL get_user_tokens(int *num_tokens, struct user_token **user_tokens)
4263 {
4264         struct winbindd_request request;
4265         struct winbindd_response response;
4266         const char *extra_data;
4267         fstring name;
4268         int i;
4269         struct user_token *result;
4270
4271         if (lp_winbind_use_default_domain() &&
4272             (opt_target_workgroup == NULL)) {
4273                 d_fprintf(stderr, "winbind use default domain = yes set, "
4274                          "please specify a workgroup\n");
4275                 return False;
4276         }
4277
4278         /* Send request to winbind daemon */
4279
4280         ZERO_STRUCT(request);
4281         ZERO_STRUCT(response);
4282
4283         if (winbindd_request_response(WINBINDD_LIST_USERS, &request, &response) !=
4284             NSS_STATUS_SUCCESS)
4285                 return False;
4286
4287         /* Look through extra data */
4288
4289         if (!response.extra_data.data)
4290                 return False;
4291
4292         extra_data = (const char *)response.extra_data.data;
4293         *num_tokens = 0;
4294
4295         while(next_token(&extra_data, name, ",", sizeof(fstring))) {
4296                 *num_tokens += 1;
4297         }
4298
4299         result = SMB_MALLOC_ARRAY(struct user_token, *num_tokens);
4300
4301         if (result == NULL) {
4302                 DEBUG(1, ("Could not malloc sid array\n"));
4303                 return False;
4304         }
4305
4306         extra_data = (const char *)response.extra_data.data;
4307         i=0;
4308
4309         while(next_token(&extra_data, name, ",", sizeof(fstring))) {
4310
4311                 fstring domain, user;
4312                 char *p;
4313
4314                 fstrcpy(result[i].name, name);
4315
4316                 p = strchr(name, *lp_winbind_separator());
4317
4318                 DEBUG(3, ("%s\n", name));
4319
4320                 if (p == NULL) {
4321                         fstrcpy(domain, opt_target_workgroup);
4322                         fstrcpy(user, name);
4323                 } else {
4324                         *p++ = '\0';
4325                         fstrcpy(domain, name);
4326                         strupper_m(domain);
4327                         fstrcpy(user, p);
4328                 }
4329
4330                 get_user_sids(domain, user, &(result[i].token));
4331                 i+=1;
4332         }
4333
4334         SAFE_FREE(response.extra_data.data);
4335
4336         *user_tokens = result;
4337
4338         return True;
4339 }
4340
4341 static BOOL get_user_tokens_from_file(FILE *f,
4342                                       int *num_tokens,
4343                                       struct user_token **tokens)
4344 {
4345         struct user_token *token = NULL;
4346
4347         while (!feof(f)) {
4348                 fstring line;
4349
4350                 if (fgets(line, sizeof(line)-1, f) == NULL) {
4351                         return True;
4352                 }
4353
4354                 if (line[strlen(line)-1] == '\n')
4355                         line[strlen(line)-1] = '\0';
4356
4357                 if (line[0] == ' ') {
4358                         /* We have a SID */
4359
4360                         DOM_SID sid;
4361                         string_to_sid(&sid, &line[1]);
4362
4363                         if (token == NULL) {
4364                                 DEBUG(0, ("File does not begin with username"));
4365                                 return False;
4366                         }
4367
4368                         add_sid_to_token(&token->token, &sid);
4369                         continue;
4370                 }
4371
4372                 /* And a new user... */
4373
4374                 *num_tokens += 1;
4375                 *tokens = SMB_REALLOC_ARRAY(*tokens, struct user_token, *num_tokens);
4376                 if (*tokens == NULL) {
4377                         DEBUG(0, ("Could not realloc tokens\n"));
4378                         return False;
4379                 }
4380
4381                 token = &((*tokens)[*num_tokens-1]);
4382
4383                 fstrcpy(token->name, line);
4384                 token->token.num_sids = 0;
4385                 token->token.user_sids = NULL;
4386                 continue;
4387         }
4388
4389         return False;
4390 }
4391
4392
4393 /*
4394  * Show the list of all users that have access to a share
4395  */
4396
4397 static void show_userlist(struct rpc_pipe_client *pipe_hnd,
4398                         TALLOC_CTX *mem_ctx,
4399                         const char *netname,
4400                         int num_tokens,
4401                         struct user_token *tokens)
4402 {
4403         int fnum;
4404         SEC_DESC *share_sd = NULL;
4405         SEC_DESC *root_sd = NULL;
4406         struct cli_state *cli = pipe_hnd->cli;
4407         int i;
4408         union srvsvc_NetShareInfo info;
4409         NTSTATUS result;
4410         uint16 cnum;
4411
4412         result = rpccli_srvsvc_NetShareGetInfo(pipe_hnd, mem_ctx, NULL, netname,
4413                                                502, &info);
4414
4415         if (!NT_STATUS_IS_OK(result)) {
4416                 DEBUG(1, ("Coult not query secdesc for share %s\n",
4417                           netname));
4418                 return;
4419         }
4420
4421         share_sd = info.info502->sd;
4422         if (share_sd == NULL) {
4423                 DEBUG(1, ("Got no secdesc for share %s\n",
4424                           netname));
4425         }
4426
4427         cnum = cli->cnum;
4428
4429         if (!cli_send_tconX(cli, netname, "A:", "", 0)) {
4430                 return;
4431         }
4432
4433         fnum = cli_nt_create(cli, "\\", READ_CONTROL_ACCESS);
4434
4435         if (fnum != -1) {
4436                 root_sd = cli_query_secdesc(cli, fnum, mem_ctx);
4437         }
4438
4439         for (i=0; i<num_tokens; i++) {
4440                 uint32 acc_granted;
4441                 NTSTATUS status;
4442
4443                 if (share_sd != NULL) {
4444                         if (!se_access_check(share_sd, &tokens[i].token,
4445                                              1, &acc_granted, &status)) {
4446                                 DEBUG(1, ("Could not check share_sd for "
4447                                           "user %s\n",
4448                                           tokens[i].name));
4449                                 continue;
4450                         }
4451
4452                         if (!NT_STATUS_IS_OK(status))
4453                                 continue;
4454                 }
4455
4456                 if (root_sd == NULL) {
4457                         d_printf(" %s\n", tokens[i].name);
4458                         continue;
4459                 }
4460
4461                 if (!se_access_check(root_sd, &tokens[i].token,
4462                                      1, &acc_granted, &status)) {
4463                         DEBUG(1, ("Could not check root_sd for user %s\n",
4464                                   tokens[i].name));
4465                         continue;
4466                 }
4467
4468                 if (!NT_STATUS_IS_OK(status))
4469                         continue;
4470
4471                 d_printf(" %s\n", tokens[i].name);
4472         }
4473
4474         if (fnum != -1)
4475                 cli_close(cli, fnum);
4476         cli_tdis(cli);
4477         cli->cnum = cnum;
4478
4479         return;
4480 }
4481
4482 struct share_list {
4483         int num_shares;
4484         char **shares;
4485 };
4486
4487 static void collect_share(const char *name, uint32 m,
4488                           const char *comment, void *state)
4489 {
4490         struct share_list *share_list = (struct share_list *)state;
4491
4492         if (m != STYPE_DISKTREE)
4493                 return;
4494
4495         share_list->num_shares += 1;
4496         share_list->shares = SMB_REALLOC_ARRAY(share_list->shares, char *, share_list->num_shares);
4497         if (!share_list->shares) {
4498                 share_list->num_shares = 0;
4499                 return;
4500         }
4501         share_list->shares[share_list->num_shares-1] = SMB_STRDUP(name);
4502 }
4503
4504 static void rpc_share_userlist_usage(void)
4505 {
4506         return;
4507 }
4508
4509 /**
4510  * List shares on a remote RPC server, including the security descriptors
4511  *
4512  * All parameters are provided by the run_rpc_command function, except for
4513  * argc, argv which are passes through.
4514  *
4515  * @param domain_sid The domain sid acquired from the remote server
4516  * @param cli A cli_state connected to the server.
4517  * @param mem_ctx Talloc context, destoyed on completion of the function.
4518  * @param argc  Standard main() style argc
4519  * @param argv  Standard main() style argv.  Initial components are already
4520  *              stripped
4521  *
4522  * @return Normal NTSTATUS return.
4523  **/
4524
4525 static NTSTATUS rpc_share_allowedusers_internals(const DOM_SID *domain_sid,
4526                                                 const char *domain_name,
4527                                                 struct cli_state *cli,
4528                                                 struct rpc_pipe_client *pipe_hnd,
4529                                                 TALLOC_CTX *mem_ctx,
4530                                                 int argc,
4531                                                 const char **argv)
4532 {
4533         int ret;
4534         BOOL r;
4535         uint32 hnd;
4536         uint32 i;
4537         FILE *f;
4538
4539         struct user_token *tokens = NULL;
4540         int num_tokens = 0;
4541
4542         struct share_list share_list;
4543
4544         if (argc > 1) {
4545                 rpc_share_userlist_usage();
4546                 return NT_STATUS_UNSUCCESSFUL;
4547         }
4548
4549         if (argc == 0) {
4550                 f = stdin;
4551         } else {
4552                 f = fopen(argv[0], "r");
4553         }
4554
4555         if (f == NULL) {
4556                 DEBUG(0, ("Could not open userlist: %s\n", strerror(errno)));
4557                 return NT_STATUS_UNSUCCESSFUL;
4558         }
4559
4560         r = get_user_tokens_from_file(f, &num_tokens, &tokens);
4561
4562         if (f != stdin)
4563                 fclose(f);
4564
4565         if (!r) {
4566                 DEBUG(0, ("Could not read users from file\n"));
4567                 return NT_STATUS_UNSUCCESSFUL;
4568         }
4569
4570         for (i=0; i<num_tokens; i++)
4571                 collect_alias_memberships(&tokens[i].token);
4572
4573         hnd = 0;
4574         share_list.num_shares = 0;
4575         share_list.shares = NULL;
4576
4577         ret = cli_RNetShareEnum(cli, collect_share, &share_list);
4578
4579         if (ret == -1) {
4580                 DEBUG(0, ("Error returning browse list: %s\n",
4581                           cli_errstr(cli)));
4582                 goto done;
4583         }
4584
4585         for (i = 0; i < share_list.num_shares; i++) {
4586                 char *netname = share_list.shares[i];
4587
4588                 if (netname[strlen(netname)-1] == '$')
4589                         continue;
4590
4591                 d_printf("%s\n", netname);
4592
4593                 show_userlist(pipe_hnd, mem_ctx, netname,
4594                               num_tokens, tokens);
4595         }
4596  done:
4597         for (i=0; i<num_tokens; i++) {
4598                 free_user_token(&tokens[i].token);
4599         }
4600         SAFE_FREE(tokens);
4601         SAFE_FREE(share_list.shares);
4602
4603         return NT_STATUS_OK;
4604 }
4605
4606 static int rpc_share_allowedusers(int argc, const char **argv)
4607 {
4608         int result;
4609
4610         result = run_rpc_command(NULL, PI_SAMR, 0,
4611                                  rpc_aliaslist_internals,
4612                                  argc, argv);
4613         if (result != 0)
4614                 return result;
4615
4616         result = run_rpc_command(NULL, PI_LSARPC, 0,
4617                                  rpc_aliaslist_dump,
4618                                  argc, argv);
4619         if (result != 0)
4620                 return result;
4621
4622         return run_rpc_command(NULL, PI_SRVSVC, 0,
4623                                rpc_share_allowedusers_internals,
4624                                argc, argv);
4625 }
4626
4627 int net_usersidlist(int argc, const char **argv)
4628 {
4629         int num_tokens = 0;
4630         struct user_token *tokens = NULL;
4631         int i;
4632
4633         if (argc != 0) {
4634                 net_usersidlist_usage(argc, argv);
4635                 return 0;
4636         }
4637
4638         if (!get_user_tokens(&num_tokens, &tokens)) {
4639                 DEBUG(0, ("Could not get the user/sid list\n"));
4640                 return 0;
4641         }
4642
4643         for (i=0; i<num_tokens; i++) {
4644                 dump_user_token(&tokens[i]);
4645                 free_user_token(&tokens[i].token);
4646         }
4647
4648         SAFE_FREE(tokens);
4649         return 1;
4650 }
4651
4652 int net_usersidlist_usage(int argc, const char **argv)
4653 {
4654         d_printf("net usersidlist\n"
4655                  "\tprints out a list of all users the running winbind knows\n"
4656                  "\tabout, together with all their SIDs. This is used as\n"
4657                  "\tinput to the 'net rpc share allowedusers' command.\n\n");
4658
4659         net_common_flags_usage(argc, argv);
4660         return -1;
4661 }
4662
4663 /**
4664  * 'net rpc share' entrypoint.
4665  * @param argc  Standard main() style argc
4666  * @param argv  Standard main() style argv.  Initial components are already
4667  *              stripped
4668  **/
4669
4670 int net_rpc_share(int argc, const char **argv)
4671 {
4672         struct functable func[] = {
4673                 {"add", rpc_share_add},
4674                 {"delete", rpc_share_delete},
4675                 {"allowedusers", rpc_share_allowedusers},
4676                 {"migrate", rpc_share_migrate},
4677                 {"list", rpc_share_list},
4678                 {NULL, NULL}
4679         };
4680
4681         if (argc == 0)
4682                 return run_rpc_command(NULL, PI_SRVSVC, 0,
4683                                        rpc_share_list_internals,
4684                                        argc, argv);
4685
4686         return net_run_function(argc, argv, func, rpc_share_usage);
4687 }
4688
4689 static NTSTATUS rpc_sh_share_list(TALLOC_CTX *mem_ctx,
4690                                   struct rpc_sh_ctx *ctx,
4691                                   struct rpc_pipe_client *pipe_hnd,
4692                                   int argc, const char **argv)
4693 {
4694         return rpc_share_list_internals(ctx->domain_sid, ctx->domain_name,
4695                                         ctx->cli, pipe_hnd, mem_ctx,
4696                                         argc, argv);
4697 }
4698
4699 static NTSTATUS rpc_sh_share_add(TALLOC_CTX *mem_ctx,
4700                                  struct rpc_sh_ctx *ctx,
4701                                  struct rpc_pipe_client *pipe_hnd,
4702                                  int argc, const char **argv)
4703 {
4704         union srvsvc_NetShareInfo info;
4705         struct srvsvc_NetShareInfo2 info2;
4706         NTSTATUS result;
4707         uint32 parm_error = 0;
4708
4709         if ((argc < 2) || (argc > 3)) {
4710                 d_fprintf(stderr, "usage: %s <share> <path> [comment]\n",
4711                           ctx->whoami);
4712                 return NT_STATUS_INVALID_PARAMETER;
4713         }
4714
4715         info.info2 = &info2;
4716         info2.name = argv[0];
4717         info2.type = STYPE_DISKTREE;
4718         info2.comment = (argc == 3) ? argv[2] : "";
4719
4720         result = rpccli_srvsvc_NetShareAdd(
4721                 pipe_hnd, mem_ctx, NULL, 2, info, &parm_error);
4722
4723         return result;
4724 }
4725
4726 static NTSTATUS rpc_sh_share_delete(TALLOC_CTX *mem_ctx,
4727                                     struct rpc_sh_ctx *ctx,
4728                                     struct rpc_pipe_client *pipe_hnd,
4729                                     int argc, const char **argv)
4730 {
4731         NTSTATUS result;
4732
4733         if (argc != 1) {
4734                 d_fprintf(stderr, "usage: %s <share>\n", ctx->whoami);
4735                 return NT_STATUS_INVALID_PARAMETER;
4736         }
4737
4738         result = rpccli_srvsvc_NetShareDel(pipe_hnd, mem_ctx, NULL, argv[0], 0);
4739         return result;
4740 }
4741
4742 static NTSTATUS rpc_sh_share_info(TALLOC_CTX *mem_ctx,
4743                                   struct rpc_sh_ctx *ctx,
4744                                   struct rpc_pipe_client *pipe_hnd,
4745                                   int argc, const char **argv)
4746 {
4747         union srvsvc_NetShareInfo info;
4748         NTSTATUS result;
4749
4750         if (argc != 1) {
4751                 d_fprintf(stderr, "usage: %s <share>\n", ctx->whoami);
4752                 return NT_STATUS_INVALID_PARAMETER;
4753         }
4754
4755         result = rpccli_srvsvc_NetShareGetInfo(
4756                 pipe_hnd, mem_ctx, NULL, argv[0], 2, &info);
4757         if (!NT_STATUS_IS_OK(result)) {
4758                 goto done;
4759         }
4760
4761         d_printf("Name:     %s\n", info.info2->name);
4762         d_printf("Comment:  %s\n", info.info2->comment);
4763         d_printf("Path:     %s\n", info.info2->path);
4764         d_printf("Password: %s\n", info.info2->password);
4765
4766  done:
4767         return result;
4768 }
4769
4770 struct rpc_sh_cmd *net_rpc_share_cmds(TALLOC_CTX *mem_ctx,
4771                                       struct rpc_sh_ctx *ctx)
4772 {
4773         static struct rpc_sh_cmd cmds[] = {
4774
4775         { "list", NULL, PI_SRVSVC, rpc_sh_share_list,
4776           "List available shares" },
4777
4778         { "add", NULL, PI_SRVSVC, rpc_sh_share_add,
4779           "Add a share" },
4780
4781         { "delete", NULL, PI_SRVSVC, rpc_sh_share_delete,
4782           "Delete a share" },
4783
4784         { "info", NULL, PI_SRVSVC, rpc_sh_share_info,
4785           "Get information about a share" },
4786
4787         { NULL, NULL, 0, NULL, NULL }
4788         };
4789
4790         return cmds;
4791 }
4792
4793 /****************************************************************************/
4794
4795 static int rpc_file_usage(int argc, const char **argv)
4796 {
4797         return net_help_file(argc, argv);
4798 }
4799
4800 /**
4801  * Close a file on a remote RPC server
4802  *
4803  * All parameters are provided by the run_rpc_command function, except for
4804  * argc, argv which are passes through.
4805  *
4806  * @param domain_sid The domain sid acquired from the remote server
4807  * @param cli A cli_state connected to the server.
4808  * @param mem_ctx Talloc context, destoyed on completion of the function.
4809  * @param argc  Standard main() style argc
4810  * @param argv  Standard main() style argv.  Initial components are already
4811  *              stripped
4812  *
4813  * @return Normal NTSTATUS return.
4814  **/
4815 static NTSTATUS rpc_file_close_internals(const DOM_SID *domain_sid,
4816                                         const char *domain_name,
4817                                         struct cli_state *cli,
4818                                         struct rpc_pipe_client *pipe_hnd,
4819                                         TALLOC_CTX *mem_ctx,
4820                                         int argc,
4821                                         const char **argv)
4822 {
4823         NTSTATUS result;
4824         result = rpccli_srvsvc_NetFileClose(pipe_hnd, mem_ctx, NULL, atoi(argv[0]));
4825         return NT_STATUS_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
4826 }
4827
4828 /**
4829  * Close a file on a remote RPC server
4830  *
4831  * @param argc  Standard main() style argc
4832  * @param argv  Standard main() style argv.  Initial components are already
4833  *              stripped
4834  *
4835  * @return A shell status integer (0 for success)
4836  **/
4837 static int rpc_file_close(int argc, const char **argv)
4838 {
4839         if (argc < 1) {
4840                 DEBUG(1, ("No fileid given on close\n"));
4841                 return(rpc_file_usage(argc, argv));
4842         }
4843
4844         return run_rpc_command(NULL, PI_SRVSVC, 0,
4845                                rpc_file_close_internals,
4846                                argc, argv);
4847 }
4848
4849 /**
4850  * Formatted print of open file info
4851  *
4852  * @param info3  FILE_INFO_3 contents
4853  * @param str3   strings for FILE_INFO_3
4854  **/
4855
4856 static void display_file_info_3( struct srvsvc_NetFileInfo3 *info3 )
4857 {
4858         d_printf("%-7.1d %-20.20s 0x%-4.2x %-6.1d %s\n",
4859                  info3->fid, info3->user, info3->permissions, info3->num_locks, info3->path);
4860 }
4861
4862 /**
4863  * List open files on a remote RPC server
4864  *
4865  * All parameters are provided by the run_rpc_command function, except for
4866  * argc, argv which are passes through.
4867  *
4868  * @param domain_sid The domain sid acquired from the remote server
4869  * @param cli A cli_state connected to the server.
4870  * @param mem_ctx Talloc context, destoyed on completion of the function.
4871  * @param argc  Standard main() style argc
4872  * @param argv  Standard main() style argv.  Initial components are already
4873  *              stripped
4874  *
4875  * @return Normal NTSTATUS return.
4876  **/
4877
4878 static NTSTATUS rpc_file_list_internals(const DOM_SID *domain_sid,
4879                                         const char *domain_name,
4880                                         struct cli_state *cli,
4881                                         struct rpc_pipe_client *pipe_hnd,
4882                                         TALLOC_CTX *mem_ctx,
4883                                         int argc,
4884                                         const char **argv)
4885 {
4886         union srvsvc_NetFileCtr ctr;
4887         NTSTATUS result;
4888         uint32 hnd;
4889         uint32 preferred_len = 0xffffffff, i;
4890         const char *username=NULL;
4891         uint32 level = 3;
4892         uint32 numentries;
4893
4894         hnd = 0;
4895
4896         /* if argc > 0, must be user command */
4897         if (argc > 0)
4898                 username = smb_xstrdup(argv[0]);
4899
4900         result = rpccli_srvsvc_NetFileEnum(pipe_hnd, mem_ctx, NULL, NULL,
4901                                            username, &level, &ctr,
4902                                            preferred_len, &numentries, &hnd);
4903
4904         if (!NT_STATUS_IS_OK(result))
4905                 goto done;
4906
4907         /* Display results */
4908
4909         d_printf(
4910                  "\nEnumerating open files on remote server:\n\n"\
4911                  "\nFileId  Opened by            Perms  Locks  Path"\
4912                  "\n------  ---------            -----  -----  ---- \n");
4913         for (i = 0; i < numentries; i++)
4914                 display_file_info_3(&ctr.ctr3->array[i]);
4915  done:
4916         return NT_STATUS_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
4917 }
4918
4919 /**
4920  * List files for a user on a remote RPC server
4921  *
4922  * @param argc  Standard main() style argc
4923  * @param argv  Standard main() style argv.  Initial components are already
4924  *              stripped
4925  *
4926  * @return A shell status integer (0 for success)
4927  **/
4928
4929 static int rpc_file_user(int argc, const char **argv)
4930 {
4931         if (argc < 1) {
4932                 DEBUG(1, ("No username given\n"));
4933                 return(rpc_file_usage(argc, argv));
4934         }
4935
4936         return run_rpc_command(NULL, PI_SRVSVC, 0,
4937                                rpc_file_list_internals,
4938                                argc, argv);
4939 }
4940
4941 /**
4942  * 'net rpc file' entrypoint.
4943  * @param argc  Standard main() style argc
4944  * @param argv  Standard main() style argv.  Initial components are already
4945  *              stripped
4946  **/
4947
4948 int net_rpc_file(int argc, const char **argv)
4949 {
4950         struct functable func[] = {
4951                 {"close", rpc_file_close},
4952                 {"user", rpc_file_user},
4953 #if 0
4954                 {"info", rpc_file_info},
4955 #endif
4956                 {NULL, NULL}
4957         };
4958
4959         if (argc == 0)
4960                 return run_rpc_command(NULL, PI_SRVSVC, 0,
4961                                        rpc_file_list_internals,
4962                                        argc, argv);
4963
4964         return net_run_function(argc, argv, func, rpc_file_usage);
4965 }
4966
4967 /**
4968  * ABORT the shutdown of a remote RPC Server over, initshutdown pipe
4969  *
4970  * All parameters are provided by the run_rpc_command function, except for
4971  * argc, argv which are passed through.
4972  *
4973  * @param domain_sid The domain sid aquired from the remote server
4974  * @param cli A cli_state connected to the server.
4975  * @param mem_ctx Talloc context, destoyed on compleation of the function.
4976  * @param argc  Standard main() style argc
4977  * @param argv  Standard main() style argv.  Initial components are already
4978  *              stripped
4979  *
4980  * @return Normal NTSTATUS return.
4981  **/
4982
4983 static NTSTATUS rpc_shutdown_abort_internals(const DOM_SID *domain_sid,
4984                                         const char *domain_name,
4985                                         struct cli_state *cli,
4986                                         struct rpc_pipe_client *pipe_hnd,
4987                                         TALLOC_CTX *mem_ctx,
4988                                         int argc,
4989                                         const char **argv)
4990 {
4991         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
4992
4993         result = rpccli_initshutdown_Abort(pipe_hnd, mem_ctx, NULL);
4994
4995         if (NT_STATUS_IS_OK(result)) {
4996                 d_printf("\nShutdown successfully aborted\n");
4997                 DEBUG(5,("cmd_shutdown_abort: query succeeded\n"));
4998         } else
4999                 DEBUG(5,("cmd_shutdown_abort: query failed\n"));
5000
5001         return result;
5002 }
5003
5004 /**
5005  * ABORT the shutdown of a remote RPC Server,  over winreg pipe
5006  *
5007  * All parameters are provided by the run_rpc_command function, except for
5008  * argc, argv which are passed through.
5009  *
5010  * @param domain_sid The domain sid aquired from the remote server
5011  * @param cli A cli_state connected to the server.
5012  * @param mem_ctx Talloc context, destoyed on compleation of the function.
5013  * @param argc  Standard main() style argc
5014  * @param argv  Standard main() style argv.  Initial components are already
5015  *              stripped
5016  *
5017  * @return Normal NTSTATUS return.
5018  **/
5019
5020 static NTSTATUS rpc_reg_shutdown_abort_internals(const DOM_SID *domain_sid,
5021                                                 const char *domain_name,
5022                                                 struct cli_state *cli,
5023                                                 struct rpc_pipe_client *pipe_hnd,
5024                                                 TALLOC_CTX *mem_ctx,
5025                                                 int argc,
5026                                                 const char **argv)
5027 {
5028         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
5029
5030         result = rpccli_winreg_AbortSystemShutdown(pipe_hnd, mem_ctx, NULL);
5031
5032         if (NT_STATUS_IS_OK(result)) {
5033                 d_printf("\nShutdown successfully aborted\n");
5034                 DEBUG(5,("cmd_reg_abort_shutdown: query succeeded\n"));
5035         } else
5036                 DEBUG(5,("cmd_reg_abort_shutdown: query failed\n"));
5037
5038         return result;
5039 }
5040
5041 /**
5042  * ABORT the Shut down of a remote RPC server
5043  *
5044  * @param argc  Standard main() style argc
5045  * @param argv  Standard main() style argv.  Initial components are already
5046  *              stripped
5047  *
5048  * @return A shell status integer (0 for success)
5049  **/
5050
5051 static int rpc_shutdown_abort(int argc, const char **argv)
5052 {
5053         int rc = run_rpc_command(NULL, PI_INITSHUTDOWN, 0,
5054                                  rpc_shutdown_abort_internals,
5055                                  argc, argv);
5056
5057         if (rc == 0)
5058                 return rc;
5059
5060         DEBUG(1, ("initshutdown pipe didn't work, trying winreg pipe\n"));
5061
5062         return run_rpc_command(NULL, PI_WINREG, 0,
5063                                rpc_reg_shutdown_abort_internals,
5064                                argc, argv);
5065 }
5066
5067 /**
5068  * Shut down a remote RPC Server via initshutdown pipe
5069  *
5070  * All parameters are provided by the run_rpc_command function, except for
5071  * argc, argv which are passes through.
5072  *
5073  * @param domain_sid The domain sid aquired from the remote server
5074  * @param cli A cli_state connected to the server.
5075  * @param mem_ctx Talloc context, destoyed on compleation of the function.
5076  * @param argc  Standard main() style argc
5077  * @param argc  Standard main() style argv.  Initial components are already
5078  *              stripped
5079  *
5080  * @return Normal NTSTATUS return.
5081  **/
5082
5083 static NTSTATUS rpc_init_shutdown_internals(const DOM_SID *domain_sid,
5084                                                 const char *domain_name,
5085                                                 struct cli_state *cli,
5086                                                 struct rpc_pipe_client *pipe_hnd,
5087                                                 TALLOC_CTX *mem_ctx,
5088                                                 int argc,
5089                                                 const char **argv)
5090 {
5091         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
5092         const char *msg = "This machine will be shutdown shortly";
5093         uint32 timeout = 20;
5094         struct initshutdown_String msg_string;
5095         struct initshutdown_String_sub s;
5096
5097         if (opt_comment) {
5098                 msg = opt_comment;
5099         }
5100         if (opt_timeout) {
5101                 timeout = opt_timeout;
5102         }
5103
5104         s.name = msg;
5105         msg_string.name = &s;
5106
5107         /* create an entry */
5108         result = rpccli_initshutdown_Init(pipe_hnd, mem_ctx, NULL,
5109                         &msg_string, timeout, opt_force, opt_reboot);
5110
5111         if (NT_STATUS_IS_OK(result)) {
5112                 d_printf("\nShutdown of remote machine succeeded\n");
5113                 DEBUG(5,("Shutdown of remote machine succeeded\n"));
5114         } else {
5115                 DEBUG(1,("Shutdown of remote machine failed!\n"));
5116         }
5117         return result;
5118 }
5119
5120 /**
5121  * Shut down a remote RPC Server via winreg pipe
5122  *
5123  * All parameters are provided by the run_rpc_command function, except for
5124  * argc, argv which are passes through.
5125  *
5126  * @param domain_sid The domain sid aquired from the remote server
5127  * @param cli A cli_state connected to the server.
5128  * @param mem_ctx Talloc context, destoyed on compleation of the function.
5129  * @param argc  Standard main() style argc
5130  * @param argc  Standard main() style argv.  Initial components are already
5131  *              stripped
5132  *
5133  * @return Normal NTSTATUS return.
5134  **/
5135
5136 static NTSTATUS rpc_reg_shutdown_internals(const DOM_SID *domain_sid,
5137                                                 const char *domain_name,
5138                                                 struct cli_state *cli,
5139                                                 struct rpc_pipe_client *pipe_hnd,
5140                                                 TALLOC_CTX *mem_ctx,
5141                                                 int argc,
5142                                                 const char **argv)
5143 {
5144         const char *msg = "This machine will be shutdown shortly";
5145         uint32 timeout = 20;
5146         struct initshutdown_String msg_string;
5147         struct initshutdown_String_sub s;
5148         NTSTATUS result;
5149
5150         if (opt_comment) {
5151                 msg = opt_comment;
5152         }
5153         s.name = msg;
5154         msg_string.name = &s;
5155
5156         if (opt_timeout) {
5157                 timeout = opt_timeout;
5158         }
5159
5160         /* create an entry */
5161         result = rpccli_winreg_InitiateSystemShutdown(pipe_hnd, mem_ctx, NULL,
5162                         &msg_string, timeout, opt_force, opt_reboot);
5163
5164         if (NT_STATUS_IS_OK(result)) {
5165                 d_printf("\nShutdown of remote machine succeeded\n");
5166         } else {
5167                 d_fprintf(stderr, "\nShutdown of remote machine failed\n");
5168                 if ( W_ERROR_EQUAL(ntstatus_to_werror(result),WERR_MACHINE_LOCKED) )
5169                         d_fprintf(stderr, "\nMachine locked, use -f switch to force\n");
5170                 else
5171                         d_fprintf(stderr, "\nresult was: %s\n", nt_errstr(result));
5172         }
5173
5174         return result;
5175 }
5176
5177 /**
5178  * Shut down a remote RPC server
5179  *
5180  * @param argc  Standard main() style argc
5181  * @param argc  Standard main() style argv.  Initial components are already
5182  *              stripped
5183  *
5184  * @return A shell status integer (0 for success)
5185  **/
5186
5187 static int rpc_shutdown(int argc, const char **argv)
5188 {
5189         int rc = run_rpc_command(NULL, PI_INITSHUTDOWN, 0,
5190                                  rpc_init_shutdown_internals,
5191                                  argc, argv);
5192
5193         if (rc) {
5194                 DEBUG(1, ("initshutdown pipe failed, trying winreg pipe\n"));
5195                 rc = run_rpc_command(NULL, PI_WINREG, 0,
5196                                      rpc_reg_shutdown_internals, argc, argv);
5197         }
5198
5199         return rc;
5200 }
5201
5202 /***************************************************************************
5203   NT Domain trusts code (i.e. 'net rpc trustdom' functionality)
5204
5205  ***************************************************************************/
5206
5207 /**
5208  * Add interdomain trust account to the RPC server.
5209  * All parameters (except for argc and argv) are passed by run_rpc_command
5210  * function.
5211  *
5212  * @param domain_sid The domain sid acquired from the server
5213  * @param cli A cli_state connected to the server.
5214  * @param mem_ctx Talloc context, destoyed on completion of the function.
5215  * @param argc  Standard main() style argc
5216  * @param argc  Standard main() style argv.  Initial components are already
5217  *              stripped
5218  *
5219  * @return normal NTSTATUS return code
5220  */
5221
5222 static NTSTATUS rpc_trustdom_add_internals(const DOM_SID *domain_sid,
5223                                                 const char *domain_name,
5224                                                 struct cli_state *cli,
5225                                                 struct rpc_pipe_client *pipe_hnd,
5226                                                 TALLOC_CTX *mem_ctx,
5227                                                 int argc,
5228                                                 const char **argv)
5229 {
5230         POLICY_HND connect_pol, domain_pol, user_pol;
5231         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
5232         char *acct_name;
5233         uint32 acb_info;
5234         uint32 unknown, user_rid;
5235
5236         if (argc != 2) {
5237                 d_printf("Usage: net rpc trustdom add <domain_name> <pw>\n");
5238                 return NT_STATUS_INVALID_PARAMETER;
5239         }
5240
5241         /*
5242          * Make valid trusting domain account (ie. uppercased and with '$' appended)
5243          */
5244
5245         if (asprintf(&acct_name, "%s$", argv[0]) < 0) {
5246                 return NT_STATUS_NO_MEMORY;
5247         }
5248
5249         strupper_m(acct_name);
5250
5251         /* Get samr policy handle */
5252         result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
5253                                   &connect_pol);
5254         if (!NT_STATUS_IS_OK(result)) {
5255                 goto done;
5256         }
5257
5258         /* Get domain policy handle */
5259         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
5260                                       MAXIMUM_ALLOWED_ACCESS,
5261                                       domain_sid, &domain_pol);
5262         if (!NT_STATUS_IS_OK(result)) {
5263                 goto done;
5264         }
5265
5266         /* Create trusting domain's account */
5267         acb_info = ACB_NORMAL;
5268         unknown = 0xe00500b0; /* No idea what this is - a permission mask?
5269                                  mimir: yes, most probably it is */
5270
5271         result = rpccli_samr_create_dom_user(pipe_hnd, mem_ctx, &domain_pol,
5272                                           acct_name, acb_info, unknown,
5273                                           &user_pol, &user_rid);
5274         if (!NT_STATUS_IS_OK(result)) {
5275                 goto done;
5276         }
5277
5278         {
5279                 SAM_USERINFO_CTR ctr;
5280                 SAM_USER_INFO_23 p23;
5281                 NTTIME notime;
5282                 char nostr[] = "";
5283                 LOGON_HRS hrs;
5284                 uchar pwbuf[516];
5285
5286                 encode_pw_buffer(pwbuf, argv[1], STR_UNICODE);
5287
5288                 ZERO_STRUCT(ctr);
5289                 ZERO_STRUCT(p23);
5290                 ZERO_STRUCT(notime);
5291                 hrs.max_len = 1260;
5292                 hrs.offset = 0;
5293                 hrs.len = 21;
5294                 memset(hrs.hours, 0xFF, sizeof(hrs.hours));
5295                 acb_info = ACB_DOMTRUST;
5296
5297                 init_sam_user_info23A(&p23, &notime, &notime, &notime,
5298                                       &notime, &notime, &notime,
5299                                       nostr, nostr, nostr, nostr, nostr,
5300                                       nostr, nostr, nostr, nostr, nostr,
5301                                       0, 0, acb_info, ACCT_FLAGS, 168, &hrs,
5302                                       0, 0, (char *)pwbuf);
5303                 ctr.switch_value = 23;
5304                 ctr.info.id23 = &p23;
5305                 p23.passmustchange = 0;
5306
5307                 result = rpccli_samr_set_userinfo(pipe_hnd, mem_ctx, &user_pol, 23,
5308                                                &cli->user_session_key, &ctr);
5309
5310                 if (!NT_STATUS_IS_OK(result)) {
5311                         DEBUG(0,("Could not set trust account password: %s\n",
5312                                  nt_errstr(result)));
5313                         goto done;
5314                 }
5315         }
5316
5317  done:
5318         SAFE_FREE(acct_name);
5319         return result;
5320 }
5321
5322 /**
5323  * Create interdomain trust account for a remote domain.
5324  *
5325  * @param argc standard argc
5326  * @param argv standard argv without initial components
5327  *
5328  * @return Integer status (0 means success)
5329  **/
5330
5331 static int rpc_trustdom_add(int argc, const char **argv)
5332 {
5333         if (argc > 0) {
5334                 return run_rpc_command(NULL, PI_SAMR, 0, rpc_trustdom_add_internals,
5335                                        argc, argv);
5336         } else {
5337                 d_printf("Usage: net rpc trustdom add <domain>\n");
5338                 return -1;
5339         }
5340 }
5341
5342
5343 /**
5344  * Remove interdomain trust account from the RPC server.
5345  * All parameters (except for argc and argv) are passed by run_rpc_command
5346  * function.
5347  *
5348  * @param domain_sid The domain sid acquired from the server
5349  * @param cli A cli_state connected to the server.
5350  * @param mem_ctx Talloc context, destoyed on completion of the function.
5351  * @param argc  Standard main() style argc
5352  * @param argc  Standard main() style argv.  Initial components are already
5353  *              stripped
5354  *
5355  * @return normal NTSTATUS return code
5356  */
5357
5358 static NTSTATUS rpc_trustdom_del_internals(const DOM_SID *domain_sid,
5359                                         const char *domain_name,
5360                                         struct cli_state *cli,
5361                                         struct rpc_pipe_client *pipe_hnd,
5362                                         TALLOC_CTX *mem_ctx,
5363                                         int argc,
5364                                         const char **argv)
5365 {
5366         POLICY_HND connect_pol, domain_pol, user_pol;
5367         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
5368         char *acct_name;
5369         const char **names;
5370         DOM_SID trust_acct_sid;
5371         uint32 *user_rids, num_rids, *name_types;
5372         uint32 flags = 0x000003e8; /* Unknown */
5373
5374         if (argc != 1) {
5375                 d_printf("Usage: net rpc trustdom del <domain_name>\n");
5376                 return NT_STATUS_INVALID_PARAMETER;
5377         }
5378
5379         /*
5380          * Make valid trusting domain account (ie. uppercased and with '$' appended)
5381          */
5382         acct_name = talloc_asprintf(mem_ctx, "%s$", argv[0]);
5383
5384         if (acct_name == NULL)
5385                 return NT_STATUS_NO_MEMORY;
5386
5387         strupper_m(acct_name);
5388
5389         if ((names = TALLOC_ARRAY(mem_ctx, const char *, 1)) == NULL) {
5390                 return NT_STATUS_NO_MEMORY;
5391         }
5392         names[0] = acct_name;
5393
5394
5395         /* Get samr policy handle */
5396         result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
5397                                   &connect_pol);
5398         if (!NT_STATUS_IS_OK(result)) {
5399                 goto done;
5400         }
5401
5402         /* Get domain policy handle */
5403         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
5404                                       MAXIMUM_ALLOWED_ACCESS,
5405                                       domain_sid, &domain_pol);
5406         if (!NT_STATUS_IS_OK(result)) {
5407                 goto done;
5408         }
5409
5410         result = rpccli_samr_lookup_names(pipe_hnd, mem_ctx, &domain_pol, flags, 1,
5411                                        names, &num_rids,
5412                                        &user_rids, &name_types);
5413
5414         if (!NT_STATUS_IS_OK(result)) {
5415                 goto done;
5416         }
5417
5418         result = rpccli_samr_open_user(pipe_hnd, mem_ctx, &domain_pol,
5419                                     MAXIMUM_ALLOWED_ACCESS,
5420                                     user_rids[0], &user_pol);
5421
5422         if (!NT_STATUS_IS_OK(result)) {
5423                 goto done;
5424         }
5425
5426         /* append the rid to the domain sid */
5427         sid_copy(&trust_acct_sid, domain_sid);
5428         if (!sid_append_rid(&trust_acct_sid, user_rids[0])) {
5429                 goto done;
5430         }
5431
5432         /* remove the sid */
5433
5434         result = rpccli_samr_remove_sid_foreign_domain(pipe_hnd, mem_ctx, &user_pol,
5435                                                     &trust_acct_sid);
5436
5437         if (!NT_STATUS_IS_OK(result)) {
5438                 goto done;
5439         }
5440
5441         /* Delete user */
5442
5443         result = rpccli_samr_delete_dom_user(pipe_hnd, mem_ctx, &user_pol);
5444
5445         if (!NT_STATUS_IS_OK(result)) {
5446                 goto done;
5447         }
5448
5449         if (!NT_STATUS_IS_OK(result)) {
5450           DEBUG(0,("Could not set trust account password: %s\n",
5451                    nt_errstr(result)));
5452           goto done;
5453         }
5454
5455  done:
5456         return result;
5457 }
5458
5459 /**
5460  * Delete interdomain trust account for a remote domain.
5461  *
5462  * @param argc standard argc
5463  * @param argv standard argv without initial components
5464  *
5465  * @return Integer status (0 means success)
5466  **/
5467
5468 static int rpc_trustdom_del(int argc, const char **argv)
5469 {
5470         if (argc > 0) {
5471                 return run_rpc_command(NULL, PI_SAMR, 0, rpc_trustdom_del_internals,
5472                                        argc, argv);
5473         } else {
5474                 d_printf("Usage: net rpc trustdom del <domain>\n");
5475                 return -1;
5476         }
5477 }
5478
5479
5480 /**
5481  * Establish trust relationship to a trusting domain.
5482  * Interdomain account must already be created on remote PDC.
5483  *
5484  * @param argc standard argc
5485  * @param argv standard argv without initial components
5486  *
5487  * @return Integer status (0 means success)
5488  **/
5489
5490 static int rpc_trustdom_establish(int argc, const char **argv)
5491 {
5492         struct cli_state *cli = NULL;
5493         struct in_addr server_ip;
5494         struct rpc_pipe_client *pipe_hnd = NULL;
5495         POLICY_HND connect_hnd;
5496         TALLOC_CTX *mem_ctx;
5497         NTSTATUS nt_status;
5498         DOM_SID *domain_sid;
5499
5500         char* domain_name;
5501         char* domain_name_pol;
5502         char* acct_name;
5503         fstring pdc_name;
5504
5505         /*
5506          * Connect to \\server\ipc$ as 'our domain' account with password
5507          */
5508
5509         if (argc != 1) {
5510                 d_printf("Usage: net rpc trustdom establish <domain_name>\n");
5511                 return -1;
5512         }
5513
5514         domain_name = smb_xstrdup(argv[0]);
5515         strupper_m(domain_name);
5516
5517         /* account name used at first is our domain's name with '$' */
5518         asprintf(&acct_name, "%s$", lp_workgroup());
5519         strupper_m(acct_name);
5520
5521         /*
5522          * opt_workgroup will be used by connection functions further,
5523          * hence it should be set to remote domain name instead of ours
5524          */
5525         if (opt_workgroup) {
5526                 opt_workgroup = smb_xstrdup(domain_name);
5527         };
5528
5529         opt_user_name = acct_name;
5530
5531         /* find the domain controller */
5532         if (!net_find_pdc(&server_ip, pdc_name, domain_name)) {
5533                 DEBUG(0, ("Couldn't find domain controller for domain %s\n", domain_name));
5534                 return -1;
5535         }
5536
5537         /* connect to ipc$ as username/password */
5538         nt_status = connect_to_ipc(&cli, &server_ip, pdc_name);
5539         if (!NT_STATUS_EQUAL(nt_status, NT_STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT)) {
5540
5541                 /* Is it trusting domain account for sure ? */
5542                 DEBUG(0, ("Couldn't verify trusting domain account. Error was %s\n",
5543                         nt_errstr(nt_status)));
5544                 return -1;
5545         }
5546
5547         /* store who we connected to */
5548
5549         saf_store( domain_name, pdc_name );
5550
5551         /*
5552          * Connect to \\server\ipc$ again (this time anonymously)
5553          */
5554
5555         nt_status = connect_to_ipc_anonymous(&cli, &server_ip, (char*)pdc_name);
5556
5557         if (NT_STATUS_IS_ERR(nt_status)) {
5558                 DEBUG(0, ("Couldn't connect to domain %s controller. Error was %s.\n",
5559                         domain_name, nt_errstr(nt_status)));
5560                 return -1;
5561         }
5562
5563         /*
5564          * Use NetServerEnum2 to make sure we're talking to a proper server
5565          */
5566
5567         if (!cli_get_pdc_name(cli, domain_name, (char*)pdc_name)) {
5568                 DEBUG(0, ("NetServerEnum2 error: Couldn't find primary domain controller\
5569                          for domain %s\n", domain_name));
5570                 cli_shutdown(cli);
5571                 return -1;
5572         }
5573
5574         if (!(mem_ctx = talloc_init("establishing trust relationship to "
5575                                     "domain %s", domain_name))) {
5576                 DEBUG(0, ("talloc_init() failed\n"));
5577                 cli_shutdown(cli);
5578                 return -1;
5579         }
5580
5581         /*
5582          * Call LsaOpenPolicy and LsaQueryInfo
5583          */
5584
5585         pipe_hnd = cli_rpc_pipe_open_noauth(cli, PI_LSARPC, &nt_status);
5586         if (!pipe_hnd) {
5587                 DEBUG(0, ("Could not initialise lsa pipe. Error was %s\n", nt_errstr(nt_status) ));
5588                 cli_shutdown(cli);
5589                 talloc_destroy(mem_ctx);
5590                 return -1;
5591         }
5592
5593         nt_status = rpccli_lsa_open_policy2(pipe_hnd, mem_ctx, True, SEC_RIGHTS_QUERY_VALUE,
5594                                          &connect_hnd);
5595         if (NT_STATUS_IS_ERR(nt_status)) {
5596                 DEBUG(0, ("Couldn't open policy handle. Error was %s\n",
5597                         nt_errstr(nt_status)));
5598                 cli_shutdown(cli);
5599                 talloc_destroy(mem_ctx);
5600                 return -1;
5601         }
5602
5603         /* Querying info level 5 */
5604
5605         nt_status = rpccli_lsa_query_info_policy(pipe_hnd, mem_ctx, &connect_hnd,
5606                                               5 /* info level */,
5607                                               &domain_name_pol, &domain_sid);
5608         if (NT_STATUS_IS_ERR(nt_status)) {
5609                 DEBUG(0, ("LSA Query Info failed. Returned error was %s\n",
5610                         nt_errstr(nt_status)));
5611                 cli_shutdown(cli);
5612                 talloc_destroy(mem_ctx);
5613                 return -1;
5614         }
5615
5616         /* There should be actually query info level 3 (following nt serv behaviour),
5617            but I still don't know if it's _really_ necessary */
5618
5619         /*
5620          * Store the password in secrets db
5621          */
5622
5623         if (!pdb_set_trusteddom_pw(domain_name, opt_password, domain_sid)) {
5624                 DEBUG(0, ("Storing password for trusted domain failed.\n"));
5625                 cli_shutdown(cli);
5626                 talloc_destroy(mem_ctx);
5627                 return -1;
5628         }
5629
5630         /*
5631          * Close the pipes and clean up
5632          */
5633
5634         nt_status = rpccli_lsa_Close(pipe_hnd, mem_ctx, &connect_hnd);
5635         if (NT_STATUS_IS_ERR(nt_status)) {
5636                 DEBUG(0, ("Couldn't close LSA pipe. Error was %s\n",
5637                         nt_errstr(nt_status)));
5638                 cli_shutdown(cli);
5639                 talloc_destroy(mem_ctx);
5640                 return -1;
5641         }
5642
5643         cli_shutdown(cli);
5644
5645         talloc_destroy(mem_ctx);
5646
5647         d_printf("Trust to domain %s established\n", domain_name);
5648         return 0;
5649 }
5650
5651 /**
5652  * Revoke trust relationship to the remote domain
5653  *
5654  * @param argc standard argc
5655  * @param argv standard argv without initial components
5656  *
5657  * @return Integer status (0 means success)
5658  **/
5659
5660 static int rpc_trustdom_revoke(int argc, const char **argv)
5661 {
5662         char* domain_name;
5663         int rc = -1;
5664
5665         if (argc < 1) return -1;
5666
5667         /* generate upper cased domain name */
5668         domain_name = smb_xstrdup(argv[0]);
5669         strupper_m(domain_name);
5670
5671         /* delete password of the trust */
5672         if (!pdb_del_trusteddom_pw(domain_name)) {
5673                 DEBUG(0, ("Failed to revoke relationship to the trusted domain %s\n",
5674                           domain_name));
5675                 goto done;
5676         };
5677
5678         rc = 0;
5679 done:
5680         SAFE_FREE(domain_name);
5681         return rc;
5682 }
5683
5684 /**
5685  * Usage for 'net rpc trustdom' command
5686  *
5687  * @param argc standard argc
5688  * @param argv standard argv without inital components
5689  *
5690  * @return Integer status returned to shell
5691  **/
5692
5693 static int rpc_trustdom_usage(int argc, const char **argv)
5694 {
5695         d_printf("  net rpc trustdom add \t\t add trusting domain's account\n");
5696         d_printf("  net rpc trustdom del \t\t delete trusting domain's account\n");
5697         d_printf("  net rpc trustdom establish \t establish relationship to trusted domain\n");
5698         d_printf("  net rpc trustdom revoke \t abandon relationship to trusted domain\n");
5699         d_printf("  net rpc trustdom list \t show current interdomain trust relationships\n");
5700         d_printf("  net rpc trustdom vampire \t vampire interdomain trust relationships from remote server\n");
5701         return -1;
5702 }
5703
5704
5705 static NTSTATUS rpc_query_domain_sid(const DOM_SID *domain_sid,
5706                                         const char *domain_name,
5707                                         struct cli_state *cli,
5708                                         struct rpc_pipe_client *pipe_hnd,
5709                                         TALLOC_CTX *mem_ctx,
5710                                         int argc,
5711                                         const char **argv)
5712 {
5713         fstring str_sid;
5714         sid_to_string(str_sid, domain_sid);
5715         d_printf("%s\n", str_sid);
5716         return NT_STATUS_OK;
5717 }
5718
5719 static void print_trusted_domain(DOM_SID *dom_sid, const char *trusted_dom_name)
5720 {
5721         fstring ascii_sid, padding;
5722         int pad_len, col_len = 20;
5723
5724         /* convert sid into ascii string */
5725         sid_to_string(ascii_sid, dom_sid);
5726
5727         /* calculate padding space for d_printf to look nicer */
5728         pad_len = col_len - strlen(trusted_dom_name);
5729         padding[pad_len] = 0;
5730         do padding[--pad_len] = ' '; while (pad_len);
5731
5732         d_printf("%s%s%s\n", trusted_dom_name, padding, ascii_sid);
5733 }
5734
5735 static NTSTATUS vampire_trusted_domain(struct rpc_pipe_client *pipe_hnd,
5736                                       TALLOC_CTX *mem_ctx,
5737                                       POLICY_HND *pol,
5738                                       DOM_SID dom_sid,
5739                                       const char *trusted_dom_name)
5740 {
5741         NTSTATUS nt_status;
5742         LSA_TRUSTED_DOMAIN_INFO *info;
5743         char *cleartextpwd = NULL;
5744         DATA_BLOB data;
5745
5746         nt_status = rpccli_lsa_query_trusted_domain_info_by_sid(pipe_hnd, mem_ctx, pol, 4, &dom_sid, &info);
5747
5748         if (NT_STATUS_IS_ERR(nt_status)) {
5749                 DEBUG(0,("Could not query trusted domain info. Error was %s\n",
5750                 nt_errstr(nt_status)));
5751                 goto done;
5752         }
5753
5754         data = data_blob(NULL, info->password.password.length);
5755
5756         memcpy(data.data, info->password.password.data, info->password.password.length);
5757         data.length     = info->password.password.length;
5758
5759         cleartextpwd = decrypt_trustdom_secret(pipe_hnd->cli->pwd.password, &data);
5760
5761         if (cleartextpwd == NULL) {
5762                 DEBUG(0,("retrieved NULL password\n"));
5763                 nt_status = NT_STATUS_UNSUCCESSFUL;
5764                 goto done;
5765         }
5766
5767         if (!pdb_set_trusteddom_pw(trusted_dom_name, cleartextpwd, &dom_sid)) {
5768                 DEBUG(0, ("Storing password for trusted domain failed.\n"));
5769                 nt_status = NT_STATUS_UNSUCCESSFUL;
5770                 goto done;
5771         }
5772
5773 #ifdef DEBUG_PASSWORD
5774         DEBUG(100,("sucessfully vampired trusted domain [%s], sid: [%s], password: [%s]\n",
5775                 trusted_dom_name, sid_string_static(&dom_sid), cleartextpwd));
5776 #endif
5777
5778 done:
5779         SAFE_FREE(cleartextpwd);
5780         data_blob_free(&data);
5781
5782         return nt_status;
5783 }
5784
5785 static int rpc_trustdom_vampire(int argc, const char **argv)
5786 {
5787         /* common variables */
5788         TALLOC_CTX* mem_ctx;
5789         struct cli_state *cli = NULL;
5790         struct rpc_pipe_client *pipe_hnd = NULL;
5791         NTSTATUS nt_status;
5792         const char *domain_name = NULL;
5793         DOM_SID *queried_dom_sid;
5794         POLICY_HND connect_hnd;
5795
5796         /* trusted domains listing variables */
5797         unsigned int num_domains, enum_ctx = 0;
5798         int i;
5799         DOM_SID *domain_sids;
5800         char **trusted_dom_names;
5801         fstring pdc_name;
5802         char *dummy;
5803
5804         /*
5805          * Listing trusted domains (stored in secrets.tdb, if local)
5806          */
5807
5808         mem_ctx = talloc_init("trust relationships vampire");
5809
5810         /*
5811          * set domain and pdc name to local samba server (default)
5812          * or to remote one given in command line
5813          */
5814
5815         if (StrCaseCmp(opt_workgroup, lp_workgroup())) {
5816                 domain_name = opt_workgroup;
5817                 opt_target_workgroup = opt_workgroup;
5818         } else {
5819                 fstrcpy(pdc_name, global_myname());
5820                 domain_name = talloc_strdup(mem_ctx, lp_workgroup());
5821                 opt_target_workgroup = domain_name;
5822         };
5823
5824         /* open \PIPE\lsarpc and open policy handle */
5825         if (!(cli = net_make_ipc_connection(NET_FLAGS_PDC))) {
5826                 DEBUG(0, ("Couldn't connect to domain controller\n"));
5827                 talloc_destroy(mem_ctx);
5828                 return -1;
5829         };
5830
5831         pipe_hnd = cli_rpc_pipe_open_noauth(cli, PI_LSARPC, &nt_status);
5832         if (!pipe_hnd) {
5833                 DEBUG(0, ("Could not initialise lsa pipe. Error was %s\n",
5834                         nt_errstr(nt_status) ));
5835                 cli_shutdown(cli);
5836                 talloc_destroy(mem_ctx);
5837                 return -1;
5838         };
5839
5840         nt_status = rpccli_lsa_open_policy2(pipe_hnd, mem_ctx, False, SEC_RIGHTS_QUERY_VALUE,
5841                                         &connect_hnd);
5842         if (NT_STATUS_IS_ERR(nt_status)) {
5843                 DEBUG(0, ("Couldn't open policy handle. Error was %s\n",
5844                         nt_errstr(nt_status)));
5845                 cli_shutdown(cli);
5846                 talloc_destroy(mem_ctx);
5847                 return -1;
5848         };
5849
5850         /* query info level 5 to obtain sid of a domain being queried */
5851         nt_status = rpccli_lsa_query_info_policy(
5852                 pipe_hnd, mem_ctx, &connect_hnd, 5 /* info level */,
5853                 &dummy, &queried_dom_sid);
5854
5855         if (NT_STATUS_IS_ERR(nt_status)) {
5856                 DEBUG(0, ("LSA Query Info failed. Returned error was %s\n",
5857                         nt_errstr(nt_status)));
5858                 cli_shutdown(cli);
5859                 talloc_destroy(mem_ctx);
5860                 return -1;
5861         }
5862
5863         /*
5864          * Keep calling LsaEnumTrustdom over opened pipe until
5865          * the end of enumeration is reached
5866          */
5867
5868         d_printf("Vampire trusted domains:\n\n");
5869
5870         do {
5871                 nt_status = rpccli_lsa_enum_trust_dom(pipe_hnd, mem_ctx, &connect_hnd, &enum_ctx,
5872                                                    &num_domains,
5873                                                    &trusted_dom_names, &domain_sids);
5874
5875                 if (NT_STATUS_IS_ERR(nt_status)) {
5876                         DEBUG(0, ("Couldn't enumerate trusted domains. Error was %s\n",
5877                                 nt_errstr(nt_status)));
5878                         cli_shutdown(cli);
5879                         talloc_destroy(mem_ctx);
5880                         return -1;
5881                 };
5882
5883                 for (i = 0; i < num_domains; i++) {
5884
5885                         print_trusted_domain(&(domain_sids[i]), trusted_dom_names[i]);
5886
5887                         nt_status = vampire_trusted_domain(pipe_hnd, mem_ctx, &connect_hnd,
5888                                                            domain_sids[i], trusted_dom_names[i]);
5889                         if (!NT_STATUS_IS_OK(nt_status)) {
5890                                 cli_shutdown(cli);
5891                                 talloc_destroy(mem_ctx);
5892                                 return -1;
5893                         }
5894                 };
5895
5896                 /*
5897                  * in case of no trusted domains say something rather
5898                  * than just display blank line
5899                  */
5900                 if (!num_domains) d_printf("none\n");
5901
5902         } while (NT_STATUS_EQUAL(nt_status, STATUS_MORE_ENTRIES));
5903
5904         /* close this connection before doing next one */
5905         nt_status = rpccli_lsa_Close(pipe_hnd, mem_ctx, &connect_hnd);
5906         if (NT_STATUS_IS_ERR(nt_status)) {
5907                 DEBUG(0, ("Couldn't properly close lsa policy handle. Error was %s\n",
5908                         nt_errstr(nt_status)));
5909                 cli_shutdown(cli);
5910                 talloc_destroy(mem_ctx);
5911                 return -1;
5912         };
5913
5914         /* close lsarpc pipe and connection to IPC$ */
5915         cli_shutdown(cli);
5916
5917         talloc_destroy(mem_ctx);
5918         return 0;
5919 }
5920
5921 static int rpc_trustdom_list(int argc, const char **argv)
5922 {
5923         /* common variables */
5924         TALLOC_CTX* mem_ctx;
5925         struct cli_state *cli = NULL, *remote_cli = NULL;
5926         struct rpc_pipe_client *pipe_hnd = NULL;
5927         NTSTATUS nt_status;
5928         const char *domain_name = NULL;
5929         DOM_SID *queried_dom_sid;
5930         fstring padding;
5931         int ascii_dom_name_len;
5932         POLICY_HND connect_hnd;
5933
5934         /* trusted domains listing variables */
5935         unsigned int num_domains, enum_ctx = 0;
5936         int i, pad_len, col_len = 20;
5937         DOM_SID *domain_sids;
5938         char **trusted_dom_names;
5939         fstring pdc_name;
5940         char *dummy;
5941
5942         /* trusting domains listing variables */
5943         POLICY_HND domain_hnd;
5944         char **trusting_dom_names;
5945         uint32 *trusting_dom_rids;
5946
5947         /*
5948          * Listing trusted domains (stored in secrets.tdb, if local)
5949          */
5950
5951         mem_ctx = talloc_init("trust relationships listing");
5952
5953         /*
5954          * set domain and pdc name to local samba server (default)
5955          * or to remote one given in command line
5956          */
5957
5958         if (StrCaseCmp(opt_workgroup, lp_workgroup())) {
5959                 domain_name = opt_workgroup;
5960                 opt_target_workgroup = opt_workgroup;
5961         } else {
5962                 fstrcpy(pdc_name, global_myname());
5963                 domain_name = talloc_strdup(mem_ctx, lp_workgroup());
5964                 opt_target_workgroup = domain_name;
5965         };
5966
5967         /* open \PIPE\lsarpc and open policy handle */
5968         if (!(cli = net_make_ipc_connection(NET_FLAGS_PDC))) {
5969                 DEBUG(0, ("Couldn't connect to domain controller\n"));
5970                 talloc_destroy(mem_ctx);
5971                 return -1;
5972         };
5973
5974         pipe_hnd = cli_rpc_pipe_open_noauth(cli, PI_LSARPC, &nt_status);
5975         if (!pipe_hnd) {
5976                 DEBUG(0, ("Could not initialise lsa pipe. Error was %s\n",
5977                         nt_errstr(nt_status) ));
5978                 cli_shutdown(cli);
5979                 talloc_destroy(mem_ctx);
5980                 return -1;
5981         };
5982
5983         nt_status = rpccli_lsa_open_policy2(pipe_hnd, mem_ctx, False, SEC_RIGHTS_QUERY_VALUE,
5984                                         &connect_hnd);
5985         if (NT_STATUS_IS_ERR(nt_status)) {
5986                 DEBUG(0, ("Couldn't open policy handle. Error was %s\n",
5987                         nt_errstr(nt_status)));
5988                 cli_shutdown(cli);
5989                 talloc_destroy(mem_ctx);
5990                 return -1;
5991         };
5992
5993         /* query info level 5 to obtain sid of a domain being queried */
5994         nt_status = rpccli_lsa_query_info_policy(
5995                 pipe_hnd, mem_ctx, &connect_hnd, 5 /* info level */,
5996                 &dummy, &queried_dom_sid);
5997
5998         if (NT_STATUS_IS_ERR(nt_status)) {
5999                 DEBUG(0, ("LSA Query Info failed. Returned error was %s\n",
6000                         nt_errstr(nt_status)));
6001                 cli_shutdown(cli);
6002                 talloc_destroy(mem_ctx);
6003                 return -1;
6004         }
6005
6006         /*
6007          * Keep calling LsaEnumTrustdom over opened pipe until
6008          * the end of enumeration is reached
6009          */
6010
6011         d_printf("Trusted domains list:\n\n");
6012
6013         do {
6014                 nt_status = rpccli_lsa_enum_trust_dom(pipe_hnd, mem_ctx, &connect_hnd, &enum_ctx,
6015                                                    &num_domains,
6016                                                    &trusted_dom_names, &domain_sids);
6017
6018                 if (NT_STATUS_IS_ERR(nt_status)) {
6019                         DEBUG(0, ("Couldn't enumerate trusted domains. Error was %s\n",
6020                                 nt_errstr(nt_status)));
6021                         cli_shutdown(cli);
6022                         talloc_destroy(mem_ctx);
6023                         return -1;
6024                 };
6025
6026                 for (i = 0; i < num_domains; i++) {
6027                         print_trusted_domain(&(domain_sids[i]), trusted_dom_names[i]);
6028                 };
6029
6030                 /*
6031                  * in case of no trusted domains say something rather
6032                  * than just display blank line
6033                  */
6034                 if (!num_domains) d_printf("none\n");
6035
6036         } while (NT_STATUS_EQUAL(nt_status, STATUS_MORE_ENTRIES));
6037
6038         /* close this connection before doing next one */
6039         nt_status = rpccli_lsa_Close(pipe_hnd, mem_ctx, &connect_hnd);
6040         if (NT_STATUS_IS_ERR(nt_status)) {
6041                 DEBUG(0, ("Couldn't properly close lsa policy handle. Error was %s\n",
6042                         nt_errstr(nt_status)));
6043                 cli_shutdown(cli);
6044                 talloc_destroy(mem_ctx);
6045                 return -1;
6046         };
6047
6048         cli_rpc_pipe_close(pipe_hnd);
6049
6050         /*
6051          * Listing trusting domains (stored in passdb backend, if local)
6052          */
6053
6054         d_printf("\nTrusting domains list:\n\n");
6055
6056         /*
6057          * Open \PIPE\samr and get needed policy handles
6058          */
6059         pipe_hnd = cli_rpc_pipe_open_noauth(cli, PI_SAMR, &nt_status);
6060         if (!pipe_hnd) {
6061                 DEBUG(0, ("Could not initialise samr pipe. Error was %s\n", nt_errstr(nt_status)));
6062                 cli_shutdown(cli);
6063                 talloc_destroy(mem_ctx);
6064                 return -1;
6065         };
6066
6067         /* SamrConnect */
6068         nt_status = rpccli_samr_connect(pipe_hnd, mem_ctx, SA_RIGHT_SAM_OPEN_DOMAIN,
6069                                                                  &connect_hnd);
6070         if (!NT_STATUS_IS_OK(nt_status)) {
6071                 DEBUG(0, ("Couldn't open SAMR policy handle. Error was %s\n",
6072                         nt_errstr(nt_status)));
6073                 cli_shutdown(cli);
6074                 talloc_destroy(mem_ctx);
6075                 return -1;
6076         };
6077
6078         /* SamrOpenDomain - we have to open domain policy handle in order to be
6079            able to enumerate accounts*/
6080         nt_status = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_hnd,
6081                                          SA_RIGHT_DOMAIN_ENUM_ACCOUNTS,
6082                                          queried_dom_sid, &domain_hnd);
6083         if (!NT_STATUS_IS_OK(nt_status)) {
6084                 DEBUG(0, ("Couldn't open domain object. Error was %s\n",
6085                         nt_errstr(nt_status)));
6086                 cli_shutdown(cli);
6087                 talloc_destroy(mem_ctx);
6088                 return -1;
6089         };
6090
6091         /*
6092          * perform actual enumeration
6093          */
6094
6095         enum_ctx = 0;   /* reset enumeration context from last enumeration */
6096         do {
6097
6098                 nt_status = rpccli_samr_enum_dom_users(pipe_hnd, mem_ctx, &domain_hnd,
6099                                                     &enum_ctx, ACB_DOMTRUST, 0xffff,
6100                                                     &trusting_dom_names, &trusting_dom_rids,
6101                                                     &num_domains);
6102                 if (NT_STATUS_IS_ERR(nt_status)) {
6103                         DEBUG(0, ("Couldn't enumerate accounts. Error was: %s\n",
6104                                 nt_errstr(nt_status)));
6105                         cli_shutdown(cli);
6106                         talloc_destroy(mem_ctx);
6107                         return -1;
6108                 };
6109
6110                 for (i = 0; i < num_domains; i++) {
6111
6112                         /*
6113                          * get each single domain's sid (do we _really_ need this ?):
6114                          *  1) connect to domain's pdc
6115                          *  2) query the pdc for domain's sid
6116                          */
6117
6118                         /* get rid of '$' tail */
6119                         ascii_dom_name_len = strlen(trusting_dom_names[i]);
6120                         if (ascii_dom_name_len && ascii_dom_name_len < FSTRING_LEN)
6121                                 trusting_dom_names[i][ascii_dom_name_len - 1] = '\0';
6122
6123                         /* calculate padding space for d_printf to look nicer */
6124                         pad_len = col_len - strlen(trusting_dom_names[i]);
6125                         padding[pad_len] = 0;
6126                         do padding[--pad_len] = ' '; while (pad_len);
6127
6128                         /* set opt_* variables to remote domain */
6129                         strupper_m(trusting_dom_names[i]);
6130                         opt_workgroup = talloc_strdup(mem_ctx, trusting_dom_names[i]);
6131                         opt_target_workgroup = opt_workgroup;
6132
6133                         d_printf("%s%s", trusting_dom_names[i], padding);
6134
6135                         /* connect to remote domain controller */
6136                         remote_cli = net_make_ipc_connection(NET_FLAGS_PDC | NET_FLAGS_ANONYMOUS);
6137                         if (remote_cli) {
6138                                 /* query for domain's sid */
6139                                 if (run_rpc_command(remote_cli, PI_LSARPC, 0, rpc_query_domain_sid, argc, argv))
6140                                         d_fprintf(stderr, "couldn't get domain's sid\n");
6141
6142                                 cli_shutdown(remote_cli);
6143
6144                         } else {
6145                                 d_fprintf(stderr, "domain controller is not responding\n");
6146                         };
6147                 };
6148
6149                 if (!num_domains) d_printf("none\n");
6150
6151         } while (NT_STATUS_EQUAL(nt_status, STATUS_MORE_ENTRIES));
6152
6153         /* close opened samr and domain policy handles */
6154         nt_status = rpccli_samr_close(pipe_hnd, mem_ctx, &domain_hnd);
6155         if (!NT_STATUS_IS_OK(nt_status)) {
6156                 DEBUG(0, ("Couldn't properly close domain policy handle for domain %s\n", domain_name));
6157         };
6158
6159         nt_status = rpccli_samr_close(pipe_hnd, mem_ctx, &connect_hnd);
6160         if (!NT_STATUS_IS_OK(nt_status)) {
6161                 DEBUG(0, ("Couldn't properly close samr policy handle for domain %s\n", domain_name));
6162         };
6163
6164         /* close samr pipe and connection to IPC$ */
6165         cli_shutdown(cli);
6166
6167         talloc_destroy(mem_ctx);
6168         return 0;
6169 }
6170
6171 /**
6172  * Entrypoint for 'net rpc trustdom' code
6173  *
6174  * @param argc standard argc
6175  * @param argv standard argv without initial components
6176  *
6177  * @return Integer status (0 means success)
6178  */
6179
6180 static int rpc_trustdom(int argc, const char **argv)
6181 {
6182         struct functable func[] = {
6183                 {"add", rpc_trustdom_add},
6184                 {"del", rpc_trustdom_del},
6185                 {"establish", rpc_trustdom_establish},
6186                 {"revoke", rpc_trustdom_revoke},
6187                 {"help", rpc_trustdom_usage},
6188                 {"list", rpc_trustdom_list},
6189                 {"vampire", rpc_trustdom_vampire},
6190                 {NULL, NULL}
6191         };
6192
6193         if (argc == 0) {
6194                 rpc_trustdom_usage(argc, argv);
6195                 return -1;
6196         }
6197
6198         return (net_run_function(argc, argv, func, rpc_user_usage));
6199 }
6200
6201 /**
6202  * Check if a server will take rpc commands
6203  * @param flags Type of server to connect to (PDC, DMB, localhost)
6204  *              if the host is not explicitly specified
6205  * @return  BOOL (true means rpc supported)
6206  */
6207 BOOL net_rpc_check(unsigned flags)
6208 {
6209         struct cli_state *cli;
6210         BOOL ret = False;
6211         struct in_addr server_ip;
6212         char *server_name = NULL;
6213         NTSTATUS status;
6214
6215         /* flags (i.e. server type) may depend on command */
6216         if (!net_find_server(NULL, flags, &server_ip, &server_name))
6217                 return False;
6218
6219         if ((cli = cli_initialise()) == NULL) {
6220                 return False;
6221         }
6222
6223         status = cli_connect(cli, server_name, &server_ip);
6224         if (!NT_STATUS_IS_OK(status))
6225                 goto done;
6226         if (!attempt_netbios_session_request(&cli, global_myname(),
6227                                              server_name, &server_ip))
6228                 goto done;
6229         if (!cli_negprot(cli))
6230                 goto done;
6231         if (cli->protocol < PROTOCOL_NT1)
6232                 goto done;
6233
6234         ret = True;
6235  done:
6236         cli_shutdown(cli);
6237         return ret;
6238 }
6239
6240 /* dump sam database via samsync rpc calls */
6241 static int rpc_samdump(int argc, const char **argv) {
6242                 return run_rpc_command(NULL, PI_NETLOGON, NET_FLAGS_ANONYMOUS, rpc_samdump_internals,
6243                                argc, argv);
6244 }
6245
6246 /* syncronise sam database via samsync rpc calls */
6247 static int rpc_vampire(int argc, const char **argv) {
6248         return run_rpc_command(NULL, PI_NETLOGON, NET_FLAGS_ANONYMOUS, rpc_vampire_internals,
6249                                argc, argv);
6250 }
6251
6252 /**
6253  * Migrate everything from a print-server
6254  *
6255  * @param argc  Standard main() style argc
6256  * @param argv  Standard main() style argv.  Initial components are already
6257  *              stripped
6258  *
6259  * @return A shell status integer (0 for success)
6260  *
6261  * The order is important !
6262  * To successfully add drivers the print-queues have to exist !
6263  * Applying ACLs should be the last step, because you're easily locked out
6264  *
6265  **/
6266 static int rpc_printer_migrate_all(int argc, const char **argv)
6267 {
6268         int ret;
6269
6270         if (!opt_host) {
6271                 printf("no server to migrate\n");
6272                 return -1;
6273         }
6274
6275         ret = run_rpc_command(NULL, PI_SPOOLSS, 0, rpc_printer_migrate_printers_internals, argc, argv);
6276         if (ret)
6277                 return ret;
6278
6279         ret = run_rpc_command(NULL, PI_SPOOLSS, 0, rpc_printer_migrate_drivers_internals, argc, argv);
6280         if (ret)
6281                 return ret;
6282
6283         ret = run_rpc_command(NULL, PI_SPOOLSS, 0, rpc_printer_migrate_forms_internals, argc, argv);
6284         if (ret)
6285                 return ret;
6286
6287         ret = run_rpc_command(NULL, PI_SPOOLSS, 0, rpc_printer_migrate_settings_internals, argc, argv);
6288         if (ret)
6289                 return ret;
6290
6291         return run_rpc_command(NULL, PI_SPOOLSS, 0, rpc_printer_migrate_security_internals, argc, argv);
6292
6293 }
6294
6295 /**
6296  * Migrate print-drivers from a print-server
6297  *
6298  * @param argc  Standard main() style argc
6299  * @param argv  Standard main() style argv.  Initial components are already
6300  *              stripped
6301  *
6302  * @return A shell status integer (0 for success)
6303  **/
6304 static int rpc_printer_migrate_drivers(int argc, const char **argv)
6305 {
6306         if (!opt_host) {
6307                 printf("no server to migrate\n");
6308                 return -1;
6309         }
6310
6311         return run_rpc_command(NULL, PI_SPOOLSS, 0,
6312                                rpc_printer_migrate_drivers_internals,
6313                                argc, argv);
6314 }
6315
6316 /**
6317  * Migrate print-forms from a print-server
6318  *
6319  * @param argc  Standard main() style argc
6320  * @param argv  Standard main() style argv.  Initial components are already
6321  *              stripped
6322  *
6323  * @return A shell status integer (0 for success)
6324  **/
6325 static int rpc_printer_migrate_forms(int argc, const char **argv)
6326 {
6327         if (!opt_host) {
6328                 printf("no server to migrate\n");
6329                 return -1;
6330         }
6331
6332         return run_rpc_command(NULL, PI_SPOOLSS, 0,
6333                                rpc_printer_migrate_forms_internals,
6334                                argc, argv);
6335 }
6336
6337 /**
6338  * Migrate printers from a print-server
6339  *
6340  * @param argc  Standard main() style argc
6341  * @param argv  Standard main() style argv.  Initial components are already
6342  *              stripped
6343  *
6344  * @return A shell status integer (0 for success)
6345  **/
6346 static int rpc_printer_migrate_printers(int argc, const char **argv)
6347 {
6348         if (!opt_host) {
6349                 printf("no server to migrate\n");
6350                 return -1;
6351         }
6352
6353         return run_rpc_command(NULL, PI_SPOOLSS, 0,
6354                                rpc_printer_migrate_printers_internals,
6355                                argc, argv);
6356 }
6357
6358 /**
6359  * Migrate printer-ACLs from a print-server
6360  *
6361  * @param argc  Standard main() style argc
6362  * @param argv  Standard main() style argv.  Initial components are already
6363  *              stripped
6364  *
6365  * @return A shell status integer (0 for success)
6366  **/
6367 static int rpc_printer_migrate_security(int argc, const char **argv)
6368 {
6369         if (!opt_host) {
6370                 printf("no server to migrate\n");
6371                 return -1;
6372         }
6373
6374         return run_rpc_command(NULL, PI_SPOOLSS, 0,
6375                                rpc_printer_migrate_security_internals,
6376                                argc, argv);
6377 }
6378
6379 /**
6380  * Migrate printer-settings from a print-server
6381  *
6382  * @param argc  Standard main() style argc
6383  * @param argv  Standard main() style argv.  Initial components are already
6384  *              stripped
6385  *
6386  * @return A shell status integer (0 for success)
6387  **/
6388 static int rpc_printer_migrate_settings(int argc, const char **argv)
6389 {
6390         if (!opt_host) {
6391                 printf("no server to migrate\n");
6392                 return -1;
6393         }
6394
6395         return run_rpc_command(NULL, PI_SPOOLSS, 0,
6396                                rpc_printer_migrate_settings_internals,
6397                                argc, argv);
6398 }
6399
6400 /**
6401  * 'net rpc printer' entrypoint.
6402  * @param argc  Standard main() style argc
6403  * @param argv  Standard main() style argv.  Initial components are already
6404  *              stripped
6405  **/
6406
6407 int rpc_printer_migrate(int argc, const char **argv)
6408 {
6409
6410         /* ouch: when addriver and setdriver are called from within
6411            rpc_printer_migrate_drivers_internals, the printer-queue already
6412            *has* to exist */
6413
6414         struct functable func[] = {
6415                 {"all",         rpc_printer_migrate_all},
6416                 {"drivers",     rpc_printer_migrate_drivers},
6417                 {"forms",       rpc_printer_migrate_forms},
6418                 {"help",        rpc_printer_usage},
6419                 {"printers",    rpc_printer_migrate_printers},
6420                 {"security",    rpc_printer_migrate_security},
6421                 {"settings",    rpc_printer_migrate_settings},
6422                 {NULL, NULL}
6423         };
6424
6425         return net_run_function(argc, argv, func, rpc_printer_usage);
6426 }
6427
6428
6429 /**
6430  * List printers on a remote RPC server
6431  *
6432  * @param argc  Standard main() style argc
6433  * @param argv  Standard main() style argv.  Initial components are already
6434  *              stripped
6435  *
6436  * @return A shell status integer (0 for success)
6437  **/
6438 static int rpc_printer_list(int argc, const char **argv)
6439 {
6440
6441         return run_rpc_command(NULL, PI_SPOOLSS, 0,
6442                                rpc_printer_list_internals,
6443                                argc, argv);
6444 }
6445
6446 /**
6447  * List printer-drivers on a remote RPC server
6448  *
6449  * @param argc  Standard main() style argc
6450  * @param argv  Standard main() style argv.  Initial components are already
6451  *              stripped
6452  *
6453  * @return A shell status integer (0 for success)
6454  **/
6455 static int rpc_printer_driver_list(int argc, const char **argv)
6456 {
6457
6458         return run_rpc_command(NULL, PI_SPOOLSS, 0,
6459                                rpc_printer_driver_list_internals,
6460                                argc, argv);
6461 }
6462
6463 /**
6464  * Publish printer in ADS via MSRPC
6465  *
6466  * @param argc  Standard main() style argc
6467  * @param argv  Standard main() style argv.  Initial components are already
6468  *              stripped
6469  *
6470  * @return A shell status integer (0 for success)
6471  **/
6472 static int rpc_printer_publish_publish(int argc, const char **argv)
6473 {
6474
6475         return run_rpc_command(NULL, PI_SPOOLSS, 0,
6476                                rpc_printer_publish_publish_internals,
6477                                argc, argv);
6478 }
6479
6480 /**
6481  * Update printer in ADS via MSRPC
6482  *
6483  * @param argc  Standard main() style argc
6484  * @param argv  Standard main() style argv.  Initial components are already
6485  *              stripped
6486  *
6487  * @return A shell status integer (0 for success)
6488  **/
6489 static int rpc_printer_publish_update(int argc, const char **argv)
6490 {
6491
6492         return run_rpc_command(NULL, PI_SPOOLSS, 0,
6493                                rpc_printer_publish_update_internals,
6494                                argc, argv);
6495 }
6496
6497 /**
6498  * UnPublish printer in ADS via MSRPC
6499  *
6500  * @param argc  Standard main() style argc
6501  * @param argv  Standard main() style argv.  Initial components are already
6502  *              stripped
6503  *
6504  * @return A shell status integer (0 for success)
6505  **/
6506 static int rpc_printer_publish_unpublish(int argc, const char **argv)
6507 {
6508
6509         return run_rpc_command(NULL, PI_SPOOLSS, 0,
6510                                rpc_printer_publish_unpublish_internals,
6511                                argc, argv);
6512 }
6513
6514 /**
6515  * List published printers via MSRPC
6516  *
6517  * @param argc  Standard main() style argc
6518  * @param argv  Standard main() style argv.  Initial components are already
6519  *              stripped
6520  *
6521  * @return A shell status integer (0 for success)
6522  **/
6523 static int rpc_printer_publish_list(int argc, const char **argv)
6524 {
6525
6526         return run_rpc_command(NULL, PI_SPOOLSS, 0,
6527                                rpc_printer_publish_list_internals,
6528                                argc, argv);
6529 }
6530
6531
6532 /**
6533  * Publish printer in ADS
6534  *
6535  * @param argc  Standard main() style argc
6536  * @param argv  Standard main() style argv.  Initial components are already
6537  *              stripped
6538  *
6539  * @return A shell status integer (0 for success)
6540  **/
6541 static int rpc_printer_publish(int argc, const char **argv)
6542 {
6543
6544         struct functable func[] = {
6545                 {"publish",     rpc_printer_publish_publish},
6546                 {"update",      rpc_printer_publish_update},
6547                 {"unpublish",   rpc_printer_publish_unpublish},
6548                 {"list",        rpc_printer_publish_list},
6549                 {"help",        rpc_printer_usage},
6550                 {NULL, NULL}
6551         };
6552
6553         if (argc == 0)
6554                 return run_rpc_command(NULL, PI_SPOOLSS, 0,
6555                                rpc_printer_publish_list_internals,
6556                                argc, argv);
6557
6558         return net_run_function(argc, argv, func, rpc_printer_usage);
6559
6560 }
6561
6562
6563 /**
6564  * Display rpc printer help page.
6565  * @param argc  Standard main() style argc
6566  * @param argv  Standard main() style argv.  Initial components are already
6567  *              stripped
6568  **/
6569 int rpc_printer_usage(int argc, const char **argv)
6570 {
6571         return net_help_printer(argc, argv);
6572 }
6573
6574 /**
6575  * 'net rpc printer' entrypoint.
6576  * @param argc  Standard main() style argc
6577  * @param argv  Standard main() style argv.  Initial components are already
6578  *              stripped
6579  **/
6580 int net_rpc_printer(int argc, const char **argv)
6581 {
6582         struct functable func[] = {
6583                 {"list", rpc_printer_list},
6584                 {"migrate", rpc_printer_migrate},
6585                 {"driver", rpc_printer_driver_list},
6586                 {"publish", rpc_printer_publish},
6587                 {NULL, NULL}
6588         };
6589
6590         if (argc == 0)
6591                 return run_rpc_command(NULL, PI_SPOOLSS, 0,
6592                                rpc_printer_list_internals,
6593                                argc, argv);
6594
6595         return net_run_function(argc, argv, func, rpc_printer_usage);
6596 }
6597
6598 /****************************************************************************/
6599
6600
6601 /**
6602  * Basic usage function for 'net rpc'
6603  * @param argc  Standard main() style argc
6604  * @param argv  Standard main() style argv.  Initial components are already
6605  *              stripped
6606  **/
6607
6608 int net_rpc_usage(int argc, const char **argv)
6609 {
6610         d_printf("  net rpc info \t\t\tshow basic info about a domain \n");
6611         d_printf("  net rpc join \t\t\tto join a domain \n");
6612         d_printf("  net rpc oldjoin \t\t\tto join a domain created in server manager\n");
6613         d_printf("  net rpc testjoin \t\ttests that a join is valid\n");
6614         d_printf("  net rpc user \t\t\tto add, delete and list users\n");
6615         d_printf("  net rpc password <username> [<password>] -Uadmin_username%%admin_pass\n");
6616         d_printf("  net rpc group \t\tto list groups\n");
6617         d_printf("  net rpc share \t\tto add, delete, list and migrate shares\n");
6618         d_printf("  net rpc printer \t\tto list and migrate printers\n");
6619         d_printf("  net rpc file \t\t\tto list open files\n");
6620         d_printf("  net rpc changetrustpw \tto change the trust account password\n");
6621         d_printf("  net rpc getsid \t\tfetch the domain sid into the local secrets.tdb\n");
6622         d_printf("  net rpc vampire \t\tsyncronise an NT PDC's users and groups into the local passdb\n");
6623         d_printf("  net rpc samdump \t\tdiplay an NT PDC's users, groups and other data\n");
6624         d_printf("  net rpc trustdom \t\tto create trusting domain's account or establish trust\n");
6625         d_printf("  net rpc abortshutdown \tto abort the shutdown of a remote server\n");
6626         d_printf("  net rpc shutdown \t\tto shutdown a remote server\n");
6627         d_printf("  net rpc rights\t\tto manage privileges assigned to SIDs\n");
6628         d_printf("  net rpc registry\t\tto manage registry hives\n");
6629         d_printf("  net rpc service\t\tto start, stop and query services\n");
6630         d_printf("  net rpc audit\t\t\tto modify global auditing settings\n");
6631         d_printf("  net rpc shell\t\t\tto open an interactive shell for remote server/account management\n");
6632         d_printf("\n");
6633         d_printf("'net rpc shutdown' also accepts the following miscellaneous options:\n"); /* misc options */
6634         d_printf("\t-r or --reboot\trequest remote server reboot on shutdown\n");
6635         d_printf("\t-f or --force\trequest the remote server force its shutdown\n");
6636         d_printf("\t-t or --timeout=<timeout>\tnumber of seconds before shutdown\n");
6637         d_printf("\t-C or --comment=<message>\ttext message to display on impending shutdown\n");
6638         return -1;
6639 }
6640
6641
6642 /**
6643  * Help function for 'net rpc'.  Calls command specific help if requested
6644  * or displays usage of net rpc
6645  * @param argc  Standard main() style argc
6646  * @param argv  Standard main() style argv.  Initial components are already
6647  *              stripped
6648  **/
6649
6650 int net_rpc_help(int argc, const char **argv)
6651 {
6652         struct functable func[] = {
6653                 {"join", rpc_join_usage},
6654                 {"user", rpc_user_usage},
6655                 {"group", rpc_group_usage},
6656                 {"share", rpc_share_usage},
6657                 /*{"changetrustpw", rpc_changetrustpw_usage}, */
6658                 {"trustdom", rpc_trustdom_usage},
6659                 /*{"abortshutdown", rpc_shutdown_abort_usage},*/
6660                 /*{"shutdown", rpc_shutdown_usage}, */
6661                 {"vampire", rpc_vampire_usage},
6662                 {NULL, NULL}
6663         };
6664
6665         if (argc == 0) {
6666                 net_rpc_usage(argc, argv);
6667                 return -1;
6668         }
6669
6670         return (net_run_function(argc, argv, func, rpc_user_usage));
6671 }
6672
6673 /**
6674  * 'net rpc' entrypoint.
6675  * @param argc  Standard main() style argc
6676  * @param argv  Standard main() style argv.  Initial components are already
6677  *              stripped
6678  **/
6679
6680 int net_rpc(int argc, const char **argv)
6681 {
6682         struct functable func[] = {
6683                 {"audit", net_rpc_audit},
6684                 {"info", net_rpc_info},
6685                 {"join", net_rpc_join},
6686                 {"oldjoin", net_rpc_oldjoin},
6687                 {"testjoin", net_rpc_testjoin},
6688                 {"user", net_rpc_user},
6689                 {"password", rpc_user_password},
6690                 {"group", net_rpc_group},
6691                 {"share", net_rpc_share},
6692                 {"file", net_rpc_file},
6693                 {"printer", net_rpc_printer},
6694                 {"changetrustpw", net_rpc_changetrustpw},
6695                 {"trustdom", rpc_trustdom},
6696                 {"abortshutdown", rpc_shutdown_abort},
6697                 {"shutdown", rpc_shutdown},
6698                 {"samdump", rpc_samdump},
6699                 {"vampire", rpc_vampire},
6700                 {"getsid", net_rpc_getsid},
6701                 {"rights", net_rpc_rights},
6702                 {"service", net_rpc_service},
6703                 {"registry", net_rpc_registry},
6704                 {"shell", net_rpc_shell},
6705                 {"help", net_rpc_help},
6706                 {NULL, NULL}
6707         };
6708         return net_run_function(argc, argv, func, net_rpc_usage);
6709 }