source/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 2 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, &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         token->user_sids = SMB_MALLOC_ARRAY(DOM_SID, 4);
4078
4079         token->user_sids[0] = *user_sid;
4080         sid_copy(&token->user_sids[1], &global_sid_World);
4081         sid_copy(&token->user_sids[2], &global_sid_Network);
4082         sid_copy(&token->user_sids[3], &global_sid_Authenticated_Users);
4083 }
4084
4085 static void free_user_token(NT_USER_TOKEN *token)
4086 {
4087         SAFE_FREE(token->user_sids);
4088 }
4089
4090 static BOOL is_sid_in_token(NT_USER_TOKEN *token, DOM_SID *sid)
4091 {
4092         int i;
4093
4094         for (i=0; i<token->num_sids; i++) {
4095                 if (sid_compare(sid, &token->user_sids[i]) == 0)
4096                         return True;
4097         }
4098         return False;
4099 }
4100
4101 static void add_sid_to_token(NT_USER_TOKEN *token, DOM_SID *sid)
4102 {
4103         if (is_sid_in_token(token, sid))
4104                 return;
4105
4106         token->user_sids = SMB_REALLOC_ARRAY(token->user_sids, DOM_SID, token->num_sids+1);
4107         if (!token->user_sids) {
4108                 return;
4109         }
4110
4111         sid_copy(&token->user_sids[token->num_sids], sid);
4112
4113         token->num_sids += 1;
4114 }
4115
4116 struct user_token {
4117         fstring name;
4118         NT_USER_TOKEN token;
4119 };
4120
4121 static void dump_user_token(struct user_token *token)
4122 {
4123         int i;
4124
4125         d_printf("%s\n", token->name);
4126
4127         for (i=0; i<token->token.num_sids; i++) {
4128                 d_printf(" %s\n", sid_string_static(&token->token.user_sids[i]));
4129         }
4130 }
4131
4132 static BOOL is_alias_member(DOM_SID *sid, struct full_alias *alias)
4133 {
4134         int i;
4135
4136         for (i=0; i<alias->num_members; i++) {
4137                 if (sid_compare(sid, &alias->members[i]) == 0)
4138                         return True;
4139         }
4140
4141         return False;
4142 }
4143
4144 static void collect_sid_memberships(NT_USER_TOKEN *token, DOM_SID sid)
4145 {
4146         int i;
4147
4148         for (i=0; i<num_server_aliases; i++) {
4149                 if (is_alias_member(&sid, &server_aliases[i]))
4150                         add_sid_to_token(token, &server_aliases[i].sid);
4151         }
4152 }
4153
4154 /*
4155  * We got a user token with all the SIDs we can know about without asking the
4156  * server directly. These are the user and domain group sids. All of these can
4157  * be members of aliases. So scan the list of aliases for each of the SIDs and
4158  * add them to the token.
4159  */
4160
4161 static void collect_alias_memberships(NT_USER_TOKEN *token)
4162 {
4163         int num_global_sids = token->num_sids;
4164         int i;
4165
4166         for (i=0; i<num_global_sids; i++) {
4167                 collect_sid_memberships(token, token->user_sids[i]);
4168         }
4169 }
4170
4171 static BOOL get_user_sids(const char *domain, const char *user, NT_USER_TOKEN *token)
4172 {
4173         struct winbindd_request request;
4174         struct winbindd_response response;
4175         fstring full_name;
4176         NSS_STATUS result;
4177
4178         DOM_SID user_sid;
4179
4180         int i;
4181
4182         fstr_sprintf(full_name, "%s%c%s",
4183                      domain, *lp_winbind_separator(), user);
4184
4185         /* First let's find out the user sid */
4186
4187         ZERO_STRUCT(request);
4188         ZERO_STRUCT(response);
4189
4190         fstrcpy(request.data.name.dom_name, domain);
4191         fstrcpy(request.data.name.name, user);
4192
4193         result = winbindd_request_response(WINBINDD_LOOKUPNAME, &request, &response);
4194
4195         if (result != NSS_STATUS_SUCCESS) {
4196                 DEBUG(1, ("winbind could not find %s\n", full_name));
4197                 return False;
4198         }
4199
4200         if (response.data.sid.type != SID_NAME_USER) {
4201                 DEBUG(1, ("%s is not a user\n", full_name));
4202                 return False;
4203         }
4204
4205         string_to_sid(&user_sid, response.data.sid.sid);
4206
4207         init_user_token(token, &user_sid);
4208
4209         /* And now the groups winbind knows about */
4210
4211         ZERO_STRUCT(response);
4212
4213         fstrcpy(request.data.username, full_name);
4214
4215         result = winbindd_request_response(WINBINDD_GETGROUPS, &request, &response);
4216
4217         if (result != NSS_STATUS_SUCCESS) {
4218                 DEBUG(1, ("winbind could not get groups of %s\n", full_name));
4219                 return False;
4220         }
4221
4222         for (i = 0; i < response.data.num_entries; i++) {
4223                 gid_t gid = ((gid_t *)response.extra_data.data)[i];
4224                 DOM_SID sid;
4225
4226                 struct winbindd_request sidrequest;
4227                 struct winbindd_response sidresponse;
4228
4229                 ZERO_STRUCT(sidrequest);
4230                 ZERO_STRUCT(sidresponse);
4231
4232                 sidrequest.data.gid = gid;
4233
4234                 result = winbindd_request_response(WINBINDD_GID_TO_SID,
4235                                           &sidrequest, &sidresponse);
4236
4237                 if (result != NSS_STATUS_SUCCESS) {
4238                         DEBUG(1, ("winbind could not find SID of gid %d\n",
4239                                   gid));
4240                         return False;
4241                 }
4242
4243                 DEBUG(3, (" %s\n", sidresponse.data.sid.sid));
4244
4245                 string_to_sid(&sid, sidresponse.data.sid.sid);
4246                 add_sid_to_token(token, &sid);
4247         }
4248
4249         SAFE_FREE(response.extra_data.data);
4250
4251         return True;
4252 }
4253
4254 /**
4255  * Get a list of all user tokens we want to look at
4256  **/
4257
4258 static BOOL get_user_tokens(int *num_tokens, struct user_token **user_tokens)
4259 {
4260         struct winbindd_request request;
4261         struct winbindd_response response;
4262         const char *extra_data;
4263         fstring name;
4264         int i;
4265         struct user_token *result;
4266
4267         if (lp_winbind_use_default_domain() &&
4268             (opt_target_workgroup == NULL)) {
4269                 d_fprintf(stderr, "winbind use default domain = yes set, "
4270                          "please specify a workgroup\n");
4271                 return False;
4272         }
4273
4274         /* Send request to winbind daemon */
4275
4276         ZERO_STRUCT(request);
4277         ZERO_STRUCT(response);
4278
4279         if (winbindd_request_response(WINBINDD_LIST_USERS, &request, &response) !=
4280             NSS_STATUS_SUCCESS)
4281                 return False;
4282
4283         /* Look through extra data */
4284
4285         if (!response.extra_data.data)
4286                 return False;
4287
4288         extra_data = (const char *)response.extra_data.data;
4289         *num_tokens = 0;
4290
4291         while(next_token(&extra_data, name, ",", sizeof(fstring))) {
4292                 *num_tokens += 1;
4293         }
4294
4295         result = SMB_MALLOC_ARRAY(struct user_token, *num_tokens);
4296
4297         if (result == NULL) {
4298                 DEBUG(1, ("Could not malloc sid array\n"));
4299                 return False;
4300         }
4301
4302         extra_data = (const char *)response.extra_data.data;
4303         i=0;
4304
4305         while(next_token(&extra_data, name, ",", sizeof(fstring))) {
4306
4307                 fstring domain, user;
4308                 char *p;
4309
4310                 fstrcpy(result[i].name, name);
4311
4312                 p = strchr(name, *lp_winbind_separator());
4313
4314                 DEBUG(3, ("%s\n", name));
4315
4316                 if (p == NULL) {
4317                         fstrcpy(domain, opt_target_workgroup);
4318                         fstrcpy(user, name);
4319                 } else {
4320                         *p++ = '\0';
4321                         fstrcpy(domain, name);
4322                         strupper_m(domain);
4323                         fstrcpy(user, p);
4324                 }
4325
4326                 get_user_sids(domain, user, &(result[i].token));
4327                 i+=1;
4328         }
4329
4330         SAFE_FREE(response.extra_data.data);
4331
4332         *user_tokens = result;
4333
4334         return True;
4335 }
4336
4337 static BOOL get_user_tokens_from_file(FILE *f,
4338                                       int *num_tokens,
4339                                       struct user_token **tokens)
4340 {
4341         struct user_token *token = NULL;
4342
4343         while (!feof(f)) {
4344                 fstring line;
4345
4346                 if (fgets(line, sizeof(line)-1, f) == NULL) {
4347                         return True;
4348                 }
4349
4350                 if (line[strlen(line)-1] == '\n')
4351                         line[strlen(line)-1] = '\0';
4352
4353                 if (line[0] == ' ') {
4354                         /* We have a SID */
4355
4356                         DOM_SID sid;
4357                         string_to_sid(&sid, &line[1]);
4358
4359                         if (token == NULL) {
4360                                 DEBUG(0, ("File does not begin with username"));
4361                                 return False;
4362                         }
4363
4364                         add_sid_to_token(&token->token, &sid);
4365                         continue;
4366                 }
4367
4368                 /* And a new user... */
4369
4370                 *num_tokens += 1;
4371                 *tokens = SMB_REALLOC_ARRAY(*tokens, struct user_token, *num_tokens);
4372                 if (*tokens == NULL) {
4373                         DEBUG(0, ("Could not realloc tokens\n"));
4374                         return False;
4375                 }
4376
4377                 token = &((*tokens)[*num_tokens-1]);
4378
4379                 fstrcpy(token->name, line);
4380                 token->token.num_sids = 0;
4381                 token->token.user_sids = NULL;
4382                 continue;
4383         }
4384
4385         return False;
4386 }
4387
4388
4389 /*
4390  * Show the list of all users that have access to a share
4391  */
4392
4393 static void show_userlist(struct rpc_pipe_client *pipe_hnd,
4394                         TALLOC_CTX *mem_ctx,
4395                         const char *netname,
4396                         int num_tokens,
4397                         struct user_token *tokens)
4398 {
4399         int fnum;
4400         SEC_DESC *share_sd = NULL;
4401         SEC_DESC *root_sd = NULL;
4402         struct cli_state *cli = pipe_hnd->cli;
4403         int i;
4404         union srvsvc_NetShareInfo info;
4405         NTSTATUS result;
4406         uint16 cnum;
4407
4408         result = rpccli_srvsvc_NetShareGetInfo(pipe_hnd, mem_ctx, NULL, netname,
4409                                                502, &info);
4410
4411         if (!NT_STATUS_IS_OK(result)) {
4412                 DEBUG(1, ("Coult not query secdesc for share %s\n",
4413                           netname));
4414                 return;
4415         }
4416
4417         share_sd = info.info502->sd;
4418         if (share_sd == NULL) {
4419                 DEBUG(1, ("Got no secdesc for share %s\n",
4420                           netname));
4421         }
4422
4423         cnum = cli->cnum;
4424
4425         if (!cli_send_tconX(cli, netname, "A:", "", 0)) {
4426                 return;
4427         }
4428
4429         fnum = cli_nt_create(cli, "\\", READ_CONTROL_ACCESS);
4430
4431         if (fnum != -1) {
4432                 root_sd = cli_query_secdesc(cli, fnum, mem_ctx);
4433         }
4434
4435         for (i=0; i<num_tokens; i++) {
4436                 uint32 acc_granted;
4437                 NTSTATUS status;
4438
4439                 if (share_sd != NULL) {
4440                         if (!se_access_check(share_sd, &tokens[i].token,
4441                                              1, &acc_granted, &status)) {
4442                                 DEBUG(1, ("Could not check share_sd for "
4443                                           "user %s\n",
4444                                           tokens[i].name));
4445                                 continue;
4446                         }
4447
4448                         if (!NT_STATUS_IS_OK(status))
4449                                 continue;
4450                 }
4451
4452                 if (root_sd == NULL) {
4453                         d_printf(" %s\n", tokens[i].name);
4454                         continue;
4455                 }
4456
4457                 if (!se_access_check(root_sd, &tokens[i].token,
4458                                      1, &acc_granted, &status)) {
4459                         DEBUG(1, ("Could not check root_sd for user %s\n",
4460                                   tokens[i].name));
4461                         continue;
4462                 }
4463
4464                 if (!NT_STATUS_IS_OK(status))
4465                         continue;
4466
4467                 d_printf(" %s\n", tokens[i].name);
4468         }
4469
4470         if (fnum != -1)
4471                 cli_close(cli, fnum);
4472         cli_tdis(cli);
4473         cli->cnum = cnum;
4474
4475         return;
4476 }
4477
4478 struct share_list {
4479         int num_shares;
4480         char **shares;
4481 };
4482
4483 static void collect_share(const char *name, uint32 m,
4484                           const char *comment, void *state)
4485 {
4486         struct share_list *share_list = (struct share_list *)state;
4487
4488         if (m != STYPE_DISKTREE)
4489                 return;
4490
4491         share_list->num_shares += 1;
4492         share_list->shares = SMB_REALLOC_ARRAY(share_list->shares, char *, share_list->num_shares);
4493         if (!share_list->shares) {
4494                 share_list->num_shares = 0;
4495                 return;
4496         }
4497         share_list->shares[share_list->num_shares-1] = SMB_STRDUP(name);
4498 }
4499
4500 static void rpc_share_userlist_usage(void)
4501 {
4502         return;
4503 }
4504
4505 /**
4506  * List shares on a remote RPC server, including the security descriptors
4507  *
4508  * All parameters are provided by the run_rpc_command function, except for
4509  * argc, argv which are passes through.
4510  *
4511  * @param domain_sid The domain sid acquired from the remote server
4512  * @param cli A cli_state connected to the server.
4513  * @param mem_ctx Talloc context, destoyed on completion of the function.
4514  * @param argc  Standard main() style argc
4515  * @param argv  Standard main() style argv.  Initial components are already
4516  *              stripped
4517  *
4518  * @return Normal NTSTATUS return.
4519  **/
4520
4521 static NTSTATUS rpc_share_allowedusers_internals(const DOM_SID *domain_sid,
4522                                                 const char *domain_name,
4523                                                 struct cli_state *cli,
4524                                                 struct rpc_pipe_client *pipe_hnd,
4525                                                 TALLOC_CTX *mem_ctx,
4526                                                 int argc,
4527                                                 const char **argv)
4528 {
4529         int ret;
4530         BOOL r;
4531         uint32 hnd;
4532         uint32 i;
4533         FILE *f;
4534
4535         struct user_token *tokens = NULL;
4536         int num_tokens = 0;
4537
4538         struct share_list share_list;
4539
4540         if (argc > 1) {
4541                 rpc_share_userlist_usage();
4542                 return NT_STATUS_UNSUCCESSFUL;
4543         }
4544
4545         if (argc == 0) {
4546                 f = stdin;
4547         } else {
4548                 f = fopen(argv[0], "r");
4549         }
4550
4551         if (f == NULL) {
4552                 DEBUG(0, ("Could not open userlist: %s\n", strerror(errno)));
4553                 return NT_STATUS_UNSUCCESSFUL;
4554         }
4555
4556         r = get_user_tokens_from_file(f, &num_tokens, &tokens);
4557
4558         if (f != stdin)
4559                 fclose(f);
4560
4561         if (!r) {
4562                 DEBUG(0, ("Could not read users from file\n"));
4563                 return NT_STATUS_UNSUCCESSFUL;
4564         }
4565
4566         for (i=0; i<num_tokens; i++)
4567                 collect_alias_memberships(&tokens[i].token);
4568
4569         hnd = 0;
4570         share_list.num_shares = 0;
4571         share_list.shares = NULL;
4572
4573         ret = cli_RNetShareEnum(cli, collect_share, &share_list);
4574
4575         if (ret == -1) {
4576                 DEBUG(0, ("Error returning browse list: %s\n",
4577                           cli_errstr(cli)));
4578                 goto done;
4579         }
4580
4581         for (i = 0; i < share_list.num_shares; i++) {
4582                 char *netname = share_list.shares[i];
4583
4584                 if (netname[strlen(netname)-1] == '$')
4585                         continue;
4586
4587                 d_printf("%s\n", netname);
4588
4589                 show_userlist(pipe_hnd, mem_ctx, netname,
4590                               num_tokens, tokens);
4591         }
4592  done:
4593         for (i=0; i<num_tokens; i++) {
4594                 free_user_token(&tokens[i].token);
4595         }
4596         SAFE_FREE(tokens);
4597         SAFE_FREE(share_list.shares);
4598
4599         return NT_STATUS_OK;
4600 }
4601
4602 static int rpc_share_allowedusers(int argc, const char **argv)
4603 {
4604         int result;
4605
4606         result = run_rpc_command(NULL, PI_SAMR, 0,
4607                                  rpc_aliaslist_internals,
4608                                  argc, argv);
4609         if (result != 0)
4610                 return result;
4611
4612         result = run_rpc_command(NULL, PI_LSARPC, 0,
4613                                  rpc_aliaslist_dump,
4614                                  argc, argv);
4615         if (result != 0)
4616                 return result;
4617
4618         return run_rpc_command(NULL, PI_SRVSVC, 0,
4619                                rpc_share_allowedusers_internals,
4620                                argc, argv);
4621 }
4622
4623 int net_usersidlist(int argc, const char **argv)
4624 {
4625         int num_tokens = 0;
4626         struct user_token *tokens = NULL;
4627         int i;
4628
4629         if (argc != 0) {
4630                 net_usersidlist_usage(argc, argv);
4631                 return 0;
4632         }
4633
4634         if (!get_user_tokens(&num_tokens, &tokens)) {
4635                 DEBUG(0, ("Could not get the user/sid list\n"));
4636                 return 0;
4637         }
4638
4639         for (i=0; i<num_tokens; i++) {
4640                 dump_user_token(&tokens[i]);
4641                 free_user_token(&tokens[i].token);
4642         }
4643
4644         SAFE_FREE(tokens);
4645         return 1;
4646 }
4647
4648 int net_usersidlist_usage(int argc, const char **argv)
4649 {
4650         d_printf("net usersidlist\n"
4651                  "\tprints out a list of all users the running winbind knows\n"
4652                  "\tabout, together with all their SIDs. This is used as\n"
4653                  "\tinput to the 'net rpc share allowedusers' command.\n\n");
4654
4655         net_common_flags_usage(argc, argv);
4656         return -1;
4657 }
4658
4659 /**
4660  * 'net rpc share' entrypoint.
4661  * @param argc  Standard main() style argc
4662  * @param argv  Standard main() style argv.  Initial components are already
4663  *              stripped
4664  **/
4665
4666 int net_rpc_share(int argc, const char **argv)
4667 {
4668         struct functable func[] = {
4669                 {"add", rpc_share_add},
4670                 {"delete", rpc_share_delete},
4671                 {"allowedusers", rpc_share_allowedusers},
4672                 {"migrate", rpc_share_migrate},
4673                 {"list", rpc_share_list},
4674                 {NULL, NULL}
4675         };
4676
4677         if (argc == 0)
4678                 return run_rpc_command(NULL, PI_SRVSVC, 0,
4679                                        rpc_share_list_internals,
4680                                        argc, argv);
4681
4682         return net_run_function(argc, argv, func, rpc_share_usage);
4683 }
4684
4685 static NTSTATUS rpc_sh_share_list(TALLOC_CTX *mem_ctx,
4686                                   struct rpc_sh_ctx *ctx,
4687                                   struct rpc_pipe_client *pipe_hnd,
4688                                   int argc, const char **argv)
4689 {
4690         return rpc_share_list_internals(ctx->domain_sid, ctx->domain_name,
4691                                         ctx->cli, pipe_hnd, mem_ctx,
4692                                         argc, argv);
4693 }
4694
4695 static NTSTATUS rpc_sh_share_add(TALLOC_CTX *mem_ctx,
4696                                  struct rpc_sh_ctx *ctx,
4697                                  struct rpc_pipe_client *pipe_hnd,
4698                                  int argc, const char **argv)
4699 {
4700         union srvsvc_NetShareInfo info;
4701         struct srvsvc_NetShareInfo2 info2;
4702         NTSTATUS result;
4703         uint32 parm_error = 0;
4704
4705         if ((argc < 2) || (argc > 3)) {
4706                 d_fprintf(stderr, "usage: %s <share> <path> [comment]\n",
4707                           ctx->whoami);
4708                 return NT_STATUS_INVALID_PARAMETER;
4709         }
4710
4711         info.info2 = &info2;
4712         info2.name = argv[0];
4713         info2.type = STYPE_DISKTREE;
4714         info2.comment = (argc == 3) ? argv[2] : "";
4715
4716         result = rpccli_srvsvc_NetShareAdd(
4717                 pipe_hnd, mem_ctx, NULL, 2, info, &parm_error);
4718
4719         return result;
4720 }
4721
4722 static NTSTATUS rpc_sh_share_delete(TALLOC_CTX *mem_ctx,
4723                                     struct rpc_sh_ctx *ctx,
4724                                     struct rpc_pipe_client *pipe_hnd,
4725                                     int argc, const char **argv)
4726 {
4727         NTSTATUS result;
4728
4729         if (argc != 1) {
4730                 d_fprintf(stderr, "usage: %s <share>\n", ctx->whoami);
4731                 return NT_STATUS_INVALID_PARAMETER;
4732         }
4733
4734         result = rpccli_srvsvc_NetShareDel(pipe_hnd, mem_ctx, NULL, argv[0], 0);
4735         return result;
4736 }
4737
4738 static NTSTATUS rpc_sh_share_info(TALLOC_CTX *mem_ctx,
4739                                   struct rpc_sh_ctx *ctx,
4740                                   struct rpc_pipe_client *pipe_hnd,
4741                                   int argc, const char **argv)
4742 {
4743         union srvsvc_NetShareInfo info;
4744         NTSTATUS result;
4745
4746         if (argc != 1) {
4747                 d_fprintf(stderr, "usage: %s <share>\n", ctx->whoami);
4748                 return NT_STATUS_INVALID_PARAMETER;
4749         }
4750
4751         result = rpccli_srvsvc_NetShareGetInfo(
4752                 pipe_hnd, mem_ctx, NULL, argv[0], 2, &info);
4753         if (!NT_STATUS_IS_OK(result)) {
4754                 goto done;
4755         }
4756
4757         d_printf("Name:     %s\n", info.info2->name);
4758         d_printf("Comment:  %s\n", info.info2->comment);
4759         d_printf("Path:     %s\n", info.info2->path);
4760         d_printf("Password: %s\n", info.info2->password);
4761
4762  done:
4763         return result;
4764 }
4765
4766 struct rpc_sh_cmd *net_rpc_share_cmds(TALLOC_CTX *mem_ctx,
4767                                       struct rpc_sh_ctx *ctx)
4768 {
4769         static struct rpc_sh_cmd cmds[] = {
4770
4771         { "list", NULL, PI_SRVSVC, rpc_sh_share_list,
4772           "List available shares" },
4773
4774         { "add", NULL, PI_SRVSVC, rpc_sh_share_add,
4775           "Add a share" },
4776
4777         { "delete", NULL, PI_SRVSVC, rpc_sh_share_delete,
4778           "Delete a share" },
4779
4780         { "info", NULL, PI_SRVSVC, rpc_sh_share_info,
4781           "Get information about a share" },
4782
4783         { NULL, NULL, 0, NULL, NULL }
4784         };
4785
4786         return cmds;
4787 }
4788
4789 /****************************************************************************/
4790
4791 static int rpc_file_usage(int argc, const char **argv)
4792 {
4793         return net_help_file(argc, argv);
4794 }
4795
4796 /**
4797  * Close a file on a remote RPC server
4798  *
4799  * All parameters are provided by the run_rpc_command function, except for
4800  * argc, argv which are passes through.
4801  *
4802  * @param domain_sid The domain sid acquired from the remote server
4803  * @param cli A cli_state connected to the server.
4804  * @param mem_ctx Talloc context, destoyed on completion of the function.
4805  * @param argc  Standard main() style argc
4806  * @param argv  Standard main() style argv.  Initial components are already
4807  *              stripped
4808  *
4809  * @return Normal NTSTATUS return.
4810  **/
4811 static NTSTATUS rpc_file_close_internals(const DOM_SID *domain_sid,
4812                                         const char *domain_name,
4813                                         struct cli_state *cli,
4814                                         struct rpc_pipe_client *pipe_hnd,
4815                                         TALLOC_CTX *mem_ctx,
4816                                         int argc,
4817                                         const char **argv)
4818 {
4819         NTSTATUS result;
4820         result = rpccli_srvsvc_NetFileClose(pipe_hnd, mem_ctx, NULL, atoi(argv[0]));
4821         return NT_STATUS_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
4822 }
4823
4824 /**
4825  * Close a file on a remote RPC server
4826  *
4827  * @param argc  Standard main() style argc
4828  * @param argv  Standard main() style argv.  Initial components are already
4829  *              stripped
4830  *
4831  * @return A shell status integer (0 for success)
4832  **/
4833 static int rpc_file_close(int argc, const char **argv)
4834 {
4835         if (argc < 1) {
4836                 DEBUG(1, ("No fileid given on close\n"));
4837                 return(rpc_file_usage(argc, argv));
4838         }
4839
4840         return run_rpc_command(NULL, PI_SRVSVC, 0,
4841                                rpc_file_close_internals,
4842                                argc, argv);
4843 }
4844
4845 /**
4846  * Formatted print of open file info
4847  *
4848  * @param info3  FILE_INFO_3 contents
4849  * @param str3   strings for FILE_INFO_3
4850  **/
4851
4852 static void display_file_info_3( struct srvsvc_NetFileInfo3 *info3 )
4853 {
4854         d_printf("%-7.1d %-20.20s 0x%-4.2x %-6.1d %s\n",
4855                  info3->fid, info3->user, info3->permissions, info3->num_locks, info3->path);
4856 }
4857
4858 /**
4859  * List open files on a remote RPC server
4860  *
4861  * All parameters are provided by the run_rpc_command function, except for
4862  * argc, argv which are passes through.
4863  *
4864  * @param domain_sid The domain sid acquired from the remote server
4865  * @param cli A cli_state connected to the server.
4866  * @param mem_ctx Talloc context, destoyed on completion of the function.
4867  * @param argc  Standard main() style argc
4868  * @param argv  Standard main() style argv.  Initial components are already
4869  *              stripped
4870  *
4871  * @return Normal NTSTATUS return.
4872  **/
4873
4874 static NTSTATUS rpc_file_list_internals(const DOM_SID *domain_sid,
4875                                         const char *domain_name,
4876                                         struct cli_state *cli,
4877                                         struct rpc_pipe_client *pipe_hnd,
4878                                         TALLOC_CTX *mem_ctx,
4879                                         int argc,
4880                                         const char **argv)
4881 {
4882         union srvsvc_NetFileCtr ctr;
4883         NTSTATUS result;
4884         uint32 hnd;
4885         uint32 preferred_len = 0xffffffff, i;
4886         const char *username=NULL;
4887         uint32 level = 3;
4888         uint32 numentries;
4889
4890         hnd = 0;
4891
4892         /* if argc > 0, must be user command */
4893         if (argc > 0)
4894                 username = smb_xstrdup(argv[0]);
4895
4896         result = rpccli_srvsvc_NetFileEnum(pipe_hnd, mem_ctx, NULL, NULL,
4897                                            username, &level, &ctr,
4898                                            preferred_len, &numentries, &hnd);
4899
4900         if (!NT_STATUS_IS_OK(result))
4901                 goto done;
4902
4903         /* Display results */
4904
4905         d_printf(
4906                  "\nEnumerating open files on remote server:\n\n"\
4907                  "\nFileId  Opened by            Perms  Locks  Path"\
4908                  "\n------  ---------            -----  -----  ---- \n");
4909         for (i = 0; i < numentries; i++)
4910                 display_file_info_3(&ctr.ctr3->array[i]);
4911  done:
4912         return NT_STATUS_IS_OK(result) ? NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
4913 }
4914
4915 /**
4916  * List files for a user on a remote RPC server
4917  *
4918  * @param argc  Standard main() style argc
4919  * @param argv  Standard main() style argv.  Initial components are already
4920  *              stripped
4921  *
4922  * @return A shell status integer (0 for success)
4923  **/
4924
4925 static int rpc_file_user(int argc, const char **argv)
4926 {
4927         if (argc < 1) {
4928                 DEBUG(1, ("No username given\n"));
4929                 return(rpc_file_usage(argc, argv));
4930         }
4931
4932         return run_rpc_command(NULL, PI_SRVSVC, 0,
4933                                rpc_file_list_internals,
4934                                argc, argv);
4935 }
4936
4937 /**
4938  * 'net rpc file' entrypoint.
4939  * @param argc  Standard main() style argc
4940  * @param argv  Standard main() style argv.  Initial components are already
4941  *              stripped
4942  **/
4943
4944 int net_rpc_file(int argc, const char **argv)
4945 {
4946         struct functable func[] = {
4947                 {"close", rpc_file_close},
4948                 {"user", rpc_file_user},
4949 #if 0
4950                 {"info", rpc_file_info},
4951 #endif
4952                 {NULL, NULL}
4953         };
4954
4955         if (argc == 0)
4956                 return run_rpc_command(NULL, PI_SRVSVC, 0,
4957                                        rpc_file_list_internals,
4958                                        argc, argv);
4959
4960         return net_run_function(argc, argv, func, rpc_file_usage);
4961 }
4962
4963 /**
4964  * ABORT the shutdown of a remote RPC Server over, initshutdown pipe
4965  *
4966  * All parameters are provided by the run_rpc_command function, except for
4967  * argc, argv which are passed through.
4968  *
4969  * @param domain_sid The domain sid aquired from the remote server
4970  * @param cli A cli_state connected to the server.
4971  * @param mem_ctx Talloc context, destoyed on compleation of the function.
4972  * @param argc  Standard main() style argc
4973  * @param argv  Standard main() style argv.  Initial components are already
4974  *              stripped
4975  *
4976  * @return Normal NTSTATUS return.
4977  **/
4978
4979 static NTSTATUS rpc_shutdown_abort_internals(const DOM_SID *domain_sid,
4980                                         const char *domain_name,
4981                                         struct cli_state *cli,
4982                                         struct rpc_pipe_client *pipe_hnd,
4983                                         TALLOC_CTX *mem_ctx,
4984                                         int argc,
4985                                         const char **argv)
4986 {
4987         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
4988
4989         result = rpccli_initshutdown_Abort(pipe_hnd, mem_ctx, NULL);
4990
4991         if (NT_STATUS_IS_OK(result)) {
4992                 d_printf("\nShutdown successfully aborted\n");
4993                 DEBUG(5,("cmd_shutdown_abort: query succeeded\n"));
4994         } else
4995                 DEBUG(5,("cmd_shutdown_abort: query failed\n"));
4996
4997         return result;
4998 }
4999
5000 /**
5001  * ABORT the shutdown of a remote RPC Server,  over winreg pipe
5002  *
5003  * All parameters are provided by the run_rpc_command function, except for
5004  * argc, argv which are passed through.
5005  *
5006  * @param domain_sid The domain sid aquired from the remote server
5007  * @param cli A cli_state connected to the server.
5008  * @param mem_ctx Talloc context, destoyed on compleation of the function.
5009  * @param argc  Standard main() style argc
5010  * @param argv  Standard main() style argv.  Initial components are already
5011  *              stripped
5012  *
5013  * @return Normal NTSTATUS return.
5014  **/
5015
5016 static NTSTATUS rpc_reg_shutdown_abort_internals(const DOM_SID *domain_sid,
5017                                                 const char *domain_name,
5018                                                 struct cli_state *cli,
5019                                                 struct rpc_pipe_client *pipe_hnd,
5020                                                 TALLOC_CTX *mem_ctx,
5021                                                 int argc,
5022                                                 const char **argv)
5023 {
5024         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
5025
5026         result = rpccli_winreg_AbortSystemShutdown(pipe_hnd, mem_ctx, NULL);
5027
5028         if (NT_STATUS_IS_OK(result)) {
5029                 d_printf("\nShutdown successfully aborted\n");
5030                 DEBUG(5,("cmd_reg_abort_shutdown: query succeeded\n"));
5031         } else
5032                 DEBUG(5,("cmd_reg_abort_shutdown: query failed\n"));
5033
5034         return result;
5035 }
5036
5037 /**
5038  * ABORT the Shut down of a remote RPC server
5039  *
5040  * @param argc  Standard main() style argc
5041  * @param argv  Standard main() style argv.  Initial components are already
5042  *              stripped
5043  *
5044  * @return A shell status integer (0 for success)
5045  **/
5046
5047 static int rpc_shutdown_abort(int argc, const char **argv)
5048 {
5049         int rc = run_rpc_command(NULL, PI_INITSHUTDOWN, 0,
5050                                  rpc_shutdown_abort_internals,
5051                                  argc, argv);
5052
5053         if (rc == 0)
5054                 return rc;
5055
5056         DEBUG(1, ("initshutdown pipe didn't work, trying winreg pipe\n"));
5057
5058         return run_rpc_command(NULL, PI_WINREG, 0,
5059                                rpc_reg_shutdown_abort_internals,
5060                                argc, argv);
5061 }
5062
5063 /**
5064  * Shut down a remote RPC Server via initshutdown pipe
5065  *
5066  * All parameters are provided by the run_rpc_command function, except for
5067  * argc, argv which are passes through.
5068  *
5069  * @param domain_sid The domain sid aquired from the remote server
5070  * @param cli A cli_state connected to the server.
5071  * @param mem_ctx Talloc context, destoyed on compleation of the function.
5072  * @param argc  Standard main() style argc
5073  * @param argc  Standard main() style argv.  Initial components are already
5074  *              stripped
5075  *
5076  * @return Normal NTSTATUS return.
5077  **/
5078
5079 static NTSTATUS rpc_init_shutdown_internals(const DOM_SID *domain_sid,
5080                                                 const char *domain_name,
5081                                                 struct cli_state *cli,
5082                                                 struct rpc_pipe_client *pipe_hnd,
5083                                                 TALLOC_CTX *mem_ctx,
5084                                                 int argc,
5085                                                 const char **argv)
5086 {
5087         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
5088         const char *msg = "This machine will be shutdown shortly";
5089         uint32 timeout = 20;
5090         struct initshutdown_String msg_string;
5091         struct initshutdown_String_sub s;
5092
5093         if (opt_comment) {
5094                 msg = opt_comment;
5095         }
5096         if (opt_timeout) {
5097                 timeout = opt_timeout;
5098         }
5099
5100         s.name = msg;
5101         msg_string.name = &s;
5102
5103         /* create an entry */
5104         result = rpccli_initshutdown_Init(pipe_hnd, mem_ctx, NULL,
5105                         &msg_string, timeout, opt_force, opt_reboot);
5106
5107         if (NT_STATUS_IS_OK(result)) {
5108                 d_printf("\nShutdown of remote machine succeeded\n");
5109                 DEBUG(5,("Shutdown of remote machine succeeded\n"));
5110         } else {
5111                 DEBUG(1,("Shutdown of remote machine failed!\n"));
5112         }
5113         return result;
5114 }
5115
5116 /**
5117  * Shut down a remote RPC Server via winreg pipe
5118  *
5119  * All parameters are provided by the run_rpc_command function, except for
5120  * argc, argv which are passes through.
5121  *
5122  * @param domain_sid The domain sid aquired from the remote server
5123  * @param cli A cli_state connected to the server.
5124  * @param mem_ctx Talloc context, destoyed on compleation of the function.
5125  * @param argc  Standard main() style argc
5126  * @param argc  Standard main() style argv.  Initial components are already
5127  *              stripped
5128  *
5129  * @return Normal NTSTATUS return.
5130  **/
5131
5132 static NTSTATUS rpc_reg_shutdown_internals(const DOM_SID *domain_sid,
5133                                                 const char *domain_name,
5134                                                 struct cli_state *cli,
5135                                                 struct rpc_pipe_client *pipe_hnd,
5136                                                 TALLOC_CTX *mem_ctx,
5137                                                 int argc,
5138                                                 const char **argv)
5139 {
5140         const char *msg = "This machine will be shutdown shortly";
5141         uint32 timeout = 20;
5142         struct initshutdown_String msg_string;
5143         struct initshutdown_String_sub s;
5144         NTSTATUS result;
5145
5146         if (opt_comment) {
5147                 msg = opt_comment;
5148         }
5149         s.name = msg;
5150         msg_string.name = &s;
5151
5152         if (opt_timeout) {
5153                 timeout = opt_timeout;
5154         }
5155
5156         /* create an entry */
5157         result = rpccli_winreg_InitiateSystemShutdown(pipe_hnd, mem_ctx, NULL,
5158                         &msg_string, timeout, opt_force, opt_reboot);
5159
5160         if (NT_STATUS_IS_OK(result)) {
5161                 d_printf("\nShutdown of remote machine succeeded\n");
5162         } else {
5163                 d_fprintf(stderr, "\nShutdown of remote machine failed\n");
5164                 if ( W_ERROR_EQUAL(ntstatus_to_werror(result),WERR_MACHINE_LOCKED) )
5165                         d_fprintf(stderr, "\nMachine locked, use -f switch to force\n");
5166                 else
5167                         d_fprintf(stderr, "\nresult was: %s\n", nt_errstr(result));
5168         }
5169
5170         return result;
5171 }
5172
5173 /**
5174  * Shut down a remote RPC server
5175  *
5176  * @param argc  Standard main() style argc
5177  * @param argc  Standard main() style argv.  Initial components are already
5178  *              stripped
5179  *
5180  * @return A shell status integer (0 for success)
5181  **/
5182
5183 static int rpc_shutdown(int argc, const char **argv)
5184 {
5185         int rc = run_rpc_command(NULL, PI_INITSHUTDOWN, 0,
5186                                  rpc_init_shutdown_internals,
5187                                  argc, argv);
5188
5189         if (rc) {
5190                 DEBUG(1, ("initshutdown pipe failed, trying winreg pipe\n"));
5191                 rc = run_rpc_command(NULL, PI_WINREG, 0,
5192                                      rpc_reg_shutdown_internals, argc, argv);
5193         }
5194
5195         return rc;
5196 }
5197
5198 /***************************************************************************
5199   NT Domain trusts code (i.e. 'net rpc trustdom' functionality)
5200
5201  ***************************************************************************/
5202
5203 /**
5204  * Add interdomain trust account to the RPC server.
5205  * All parameters (except for argc and argv) are passed by run_rpc_command
5206  * function.
5207  *
5208  * @param domain_sid The domain sid acquired from the server
5209  * @param cli A cli_state connected to the server.
5210  * @param mem_ctx Talloc context, destoyed on completion of the function.
5211  * @param argc  Standard main() style argc
5212  * @param argc  Standard main() style argv.  Initial components are already
5213  *              stripped
5214  *
5215  * @return normal NTSTATUS return code
5216  */
5217
5218 static NTSTATUS rpc_trustdom_add_internals(const DOM_SID *domain_sid,
5219                                                 const char *domain_name,
5220                                                 struct cli_state *cli,
5221                                                 struct rpc_pipe_client *pipe_hnd,
5222                                                 TALLOC_CTX *mem_ctx,
5223                                                 int argc,
5224                                                 const char **argv)
5225 {
5226         POLICY_HND connect_pol, domain_pol, user_pol;
5227         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
5228         char *acct_name;
5229         uint32 acb_info;
5230         uint32 unknown, user_rid;
5231
5232         if (argc != 2) {
5233                 d_printf("Usage: net rpc trustdom add <domain_name> <pw>\n");
5234                 return NT_STATUS_INVALID_PARAMETER;
5235         }
5236
5237         /*
5238          * Make valid trusting domain account (ie. uppercased and with '$' appended)
5239          */
5240
5241         if (asprintf(&acct_name, "%s$", argv[0]) < 0) {
5242                 return NT_STATUS_NO_MEMORY;
5243         }
5244
5245         strupper_m(acct_name);
5246
5247         /* Get samr policy handle */
5248         result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
5249                                   &connect_pol);
5250         if (!NT_STATUS_IS_OK(result)) {
5251                 goto done;
5252         }
5253
5254         /* Get domain policy handle */
5255         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
5256                                       MAXIMUM_ALLOWED_ACCESS,
5257                                       domain_sid, &domain_pol);
5258         if (!NT_STATUS_IS_OK(result)) {
5259                 goto done;
5260         }
5261
5262         /* Create trusting domain's account */
5263         acb_info = ACB_NORMAL;
5264         unknown = 0xe00500b0; /* No idea what this is - a permission mask?
5265                                  mimir: yes, most probably it is */
5266
5267         result = rpccli_samr_create_dom_user(pipe_hnd, mem_ctx, &domain_pol,
5268                                           acct_name, acb_info, unknown,
5269                                           &user_pol, &user_rid);
5270         if (!NT_STATUS_IS_OK(result)) {
5271                 goto done;
5272         }
5273
5274         {
5275                 SAM_USERINFO_CTR ctr;
5276                 SAM_USER_INFO_23 p23;
5277                 NTTIME notime;
5278                 char nostr[] = "";
5279                 LOGON_HRS hrs;
5280                 uchar pwbuf[516];
5281
5282                 encode_pw_buffer(pwbuf, argv[1], STR_UNICODE);
5283
5284                 ZERO_STRUCT(ctr);
5285                 ZERO_STRUCT(p23);
5286                 ZERO_STRUCT(notime);
5287                 hrs.max_len = 1260;
5288                 hrs.offset = 0;
5289                 hrs.len = 21;
5290                 memset(hrs.hours, 0xFF, sizeof(hrs.hours));
5291                 acb_info = ACB_DOMTRUST;
5292
5293                 init_sam_user_info23A(&p23, &notime, &notime, &notime,
5294                                       &notime, &notime, &notime,
5295                                       nostr, nostr, nostr, nostr, nostr,
5296                                       nostr, nostr, nostr, nostr, nostr,
5297                                       0, 0, acb_info, ACCT_FLAGS, 168, &hrs,
5298                                       0, 0, (char *)pwbuf);
5299                 ctr.switch_value = 23;
5300                 ctr.info.id23 = &p23;
5301                 p23.passmustchange = 0;
5302
5303                 result = rpccli_samr_set_userinfo(pipe_hnd, mem_ctx, &user_pol, 23,
5304                                                &cli->user_session_key, &ctr);
5305
5306                 if (!NT_STATUS_IS_OK(result)) {
5307                         DEBUG(0,("Could not set trust account password: %s\n",
5308                                  nt_errstr(result)));
5309                         goto done;
5310                 }
5311         }
5312
5313  done:
5314         SAFE_FREE(acct_name);
5315         return result;
5316 }
5317
5318 /**
5319  * Create interdomain trust account for a remote domain.
5320  *
5321  * @param argc standard argc
5322  * @param argv standard argv without initial components
5323  *
5324  * @return Integer status (0 means success)
5325  **/
5326
5327 static int rpc_trustdom_add(int argc, const char **argv)
5328 {
5329         if (argc > 0) {
5330                 return run_rpc_command(NULL, PI_SAMR, 0, rpc_trustdom_add_internals,
5331                                        argc, argv);
5332         } else {
5333                 d_printf("Usage: net rpc trustdom add <domain>\n");
5334                 return -1;
5335         }
5336 }
5337
5338
5339 /**
5340  * Remove interdomain trust account from the RPC server.
5341  * All parameters (except for argc and argv) are passed by run_rpc_command
5342  * function.
5343  *
5344  * @param domain_sid The domain sid acquired from the server
5345  * @param cli A cli_state connected to the server.
5346  * @param mem_ctx Talloc context, destoyed on completion of the function.
5347  * @param argc  Standard main() style argc
5348  * @param argc  Standard main() style argv.  Initial components are already
5349  *              stripped
5350  *
5351  * @return normal NTSTATUS return code
5352  */
5353
5354 static NTSTATUS rpc_trustdom_del_internals(const DOM_SID *domain_sid,
5355                                         const char *domain_name,
5356                                         struct cli_state *cli,
5357                                         struct rpc_pipe_client *pipe_hnd,
5358                                         TALLOC_CTX *mem_ctx,
5359                                         int argc,
5360                                         const char **argv)
5361 {
5362         POLICY_HND connect_pol, domain_pol, user_pol;
5363         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
5364         char *acct_name;
5365         const char **names;
5366         DOM_SID trust_acct_sid;
5367         uint32 *user_rids, num_rids, *name_types;
5368         uint32 flags = 0x000003e8; /* Unknown */
5369
5370         if (argc != 1) {
5371                 d_printf("Usage: net rpc trustdom del <domain_name>\n");
5372                 return NT_STATUS_INVALID_PARAMETER;
5373         }
5374
5375         /*
5376          * Make valid trusting domain account (ie. uppercased and with '$' appended)
5377          */
5378         acct_name = talloc_asprintf(mem_ctx, "%s$", argv[0]);
5379
5380         if (acct_name == NULL)
5381                 return NT_STATUS_NO_MEMORY;
5382
5383         strupper_m(acct_name);
5384
5385         if ((names = TALLOC_ARRAY(mem_ctx, const char *, 1)) == NULL) {
5386                 return NT_STATUS_NO_MEMORY;
5387         }
5388         names[0] = acct_name;
5389
5390
5391         /* Get samr policy handle */
5392         result = rpccli_samr_connect(pipe_hnd, mem_ctx, MAXIMUM_ALLOWED_ACCESS,
5393                                   &connect_pol);
5394         if (!NT_STATUS_IS_OK(result)) {
5395                 goto done;
5396         }
5397
5398         /* Get domain policy handle */
5399         result = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_pol,
5400                                       MAXIMUM_ALLOWED_ACCESS,
5401                                       domain_sid, &domain_pol);
5402         if (!NT_STATUS_IS_OK(result)) {
5403                 goto done;
5404         }
5405
5406         result = rpccli_samr_lookup_names(pipe_hnd, mem_ctx, &domain_pol, flags, 1,
5407                                        names, &num_rids,
5408                                        &user_rids, &name_types);
5409
5410         if (!NT_STATUS_IS_OK(result)) {
5411                 goto done;
5412         }
5413
5414         result = rpccli_samr_open_user(pipe_hnd, mem_ctx, &domain_pol,
5415                                     MAXIMUM_ALLOWED_ACCESS,
5416                                     user_rids[0], &user_pol);
5417
5418         if (!NT_STATUS_IS_OK(result)) {
5419                 goto done;
5420         }
5421
5422         /* append the rid to the domain sid */
5423         sid_copy(&trust_acct_sid, domain_sid);
5424         if (!sid_append_rid(&trust_acct_sid, user_rids[0])) {
5425                 goto done;
5426         }
5427
5428         /* remove the sid */
5429
5430         result = rpccli_samr_remove_sid_foreign_domain(pipe_hnd, mem_ctx, &user_pol,
5431                                                     &trust_acct_sid);
5432
5433         if (!NT_STATUS_IS_OK(result)) {
5434                 goto done;
5435         }
5436
5437         /* Delete user */
5438
5439         result = rpccli_samr_delete_dom_user(pipe_hnd, mem_ctx, &user_pol);
5440
5441         if (!NT_STATUS_IS_OK(result)) {
5442                 goto done;
5443         }
5444
5445         if (!NT_STATUS_IS_OK(result)) {
5446           DEBUG(0,("Could not set trust account password: %s\n",
5447                    nt_errstr(result)));
5448           goto done;
5449         }
5450
5451  done:
5452         return result;
5453 }
5454
5455 /**
5456  * Delete interdomain trust account for a remote domain.
5457  *
5458  * @param argc standard argc
5459  * @param argv standard argv without initial components
5460  *
5461  * @return Integer status (0 means success)
5462  **/
5463
5464 static int rpc_trustdom_del(int argc, const char **argv)
5465 {
5466         if (argc > 0) {
5467                 return run_rpc_command(NULL, PI_SAMR, 0, rpc_trustdom_del_internals,
5468                                        argc, argv);
5469         } else {
5470                 d_printf("Usage: net rpc trustdom del <domain>\n");
5471                 return -1;
5472         }
5473 }
5474
5475
5476 /**
5477  * Establish trust relationship to a trusting domain.
5478  * Interdomain account must already be created on remote PDC.
5479  *
5480  * @param argc standard argc
5481  * @param argv standard argv without initial components
5482  *
5483  * @return Integer status (0 means success)
5484  **/
5485
5486 static int rpc_trustdom_establish(int argc, const char **argv)
5487 {
5488         struct cli_state *cli = NULL;
5489         struct in_addr server_ip;
5490         struct rpc_pipe_client *pipe_hnd = NULL;
5491         POLICY_HND connect_hnd;
5492         TALLOC_CTX *mem_ctx;
5493         NTSTATUS nt_status;
5494         DOM_SID *domain_sid;
5495
5496         char* domain_name;
5497         char* domain_name_pol;
5498         char* acct_name;
5499         fstring pdc_name;
5500
5501         /*
5502          * Connect to \\server\ipc$ as 'our domain' account with password
5503          */
5504
5505         if (argc != 1) {
5506                 d_printf("Usage: net rpc trustdom establish <domain_name>\n");
5507                 return -1;
5508         }
5509
5510         domain_name = smb_xstrdup(argv[0]);
5511         strupper_m(domain_name);
5512
5513         /* account name used at first is our domain's name with '$' */
5514         asprintf(&acct_name, "%s$", lp_workgroup());
5515         strupper_m(acct_name);
5516
5517         /*
5518          * opt_workgroup will be used by connection functions further,
5519          * hence it should be set to remote domain name instead of ours
5520          */
5521         if (opt_workgroup) {
5522                 opt_workgroup = smb_xstrdup(domain_name);
5523         };
5524
5525         opt_user_name = acct_name;
5526
5527         /* find the domain controller */
5528         if (!net_find_pdc(&server_ip, pdc_name, domain_name)) {
5529                 DEBUG(0, ("Couldn't find domain controller for domain %s\n", domain_name));
5530                 return -1;
5531         }
5532
5533         /* connect to ipc$ as username/password */
5534         nt_status = connect_to_ipc(&cli, &server_ip, pdc_name);
5535         if (!NT_STATUS_EQUAL(nt_status, NT_STATUS_NOLOGON_INTERDOMAIN_TRUST_ACCOUNT)) {
5536
5537                 /* Is it trusting domain account for sure ? */
5538                 DEBUG(0, ("Couldn't verify trusting domain account. Error was %s\n",
5539                         nt_errstr(nt_status)));
5540                 return -1;
5541         }
5542
5543         /* store who we connected to */
5544
5545         saf_store( domain_name, pdc_name );
5546
5547         /*
5548          * Connect to \\server\ipc$ again (this time anonymously)
5549          */
5550
5551         nt_status = connect_to_ipc_anonymous(&cli, &server_ip, (char*)pdc_name);
5552
5553         if (NT_STATUS_IS_ERR(nt_status)) {
5554                 DEBUG(0, ("Couldn't connect to domain %s controller. Error was %s.\n",
5555                         domain_name, nt_errstr(nt_status)));
5556                 return -1;
5557         }
5558
5559         /*
5560          * Use NetServerEnum2 to make sure we're talking to a proper server
5561          */
5562
5563         if (!cli_get_pdc_name(cli, domain_name, (char*)pdc_name)) {
5564                 DEBUG(0, ("NetServerEnum2 error: Couldn't find primary domain controller\
5565                          for domain %s\n", domain_name));
5566                 cli_shutdown(cli);
5567                 return -1;
5568         }
5569
5570         if (!(mem_ctx = talloc_init("establishing trust relationship to "
5571                                     "domain %s", domain_name))) {
5572                 DEBUG(0, ("talloc_init() failed\n"));
5573                 cli_shutdown(cli);
5574                 return -1;
5575         }
5576
5577         /*
5578          * Call LsaOpenPolicy and LsaQueryInfo
5579          */
5580
5581         pipe_hnd = cli_rpc_pipe_open_noauth(cli, PI_LSARPC, &nt_status);
5582         if (!pipe_hnd) {
5583                 DEBUG(0, ("Could not initialise lsa pipe. Error was %s\n", nt_errstr(nt_status) ));
5584                 cli_shutdown(cli);
5585                 talloc_destroy(mem_ctx);
5586                 return -1;
5587         }
5588
5589         nt_status = rpccli_lsa_open_policy2(pipe_hnd, mem_ctx, True, SEC_RIGHTS_QUERY_VALUE,
5590                                          &connect_hnd);
5591         if (NT_STATUS_IS_ERR(nt_status)) {
5592                 DEBUG(0, ("Couldn't open policy handle. Error was %s\n",
5593                         nt_errstr(nt_status)));
5594                 cli_shutdown(cli);
5595                 talloc_destroy(mem_ctx);
5596                 return -1;
5597         }
5598
5599         /* Querying info level 5 */
5600
5601         nt_status = rpccli_lsa_query_info_policy(pipe_hnd, mem_ctx, &connect_hnd,
5602                                               5 /* info level */,
5603                                               &domain_name_pol, &domain_sid);
5604         if (NT_STATUS_IS_ERR(nt_status)) {
5605                 DEBUG(0, ("LSA Query Info failed. Returned error was %s\n",
5606                         nt_errstr(nt_status)));
5607                 cli_shutdown(cli);
5608                 talloc_destroy(mem_ctx);
5609                 return -1;
5610         }
5611
5612         /* There should be actually query info level 3 (following nt serv behaviour),
5613            but I still don't know if it's _really_ necessary */
5614
5615         /*
5616          * Store the password in secrets db
5617          */
5618
5619         if (!pdb_set_trusteddom_pw(domain_name, opt_password, domain_sid)) {
5620                 DEBUG(0, ("Storing password for trusted domain failed.\n"));
5621                 cli_shutdown(cli);
5622                 talloc_destroy(mem_ctx);
5623                 return -1;
5624         }
5625
5626         /*
5627          * Close the pipes and clean up
5628          */
5629
5630         nt_status = rpccli_lsa_Close(pipe_hnd, mem_ctx, &connect_hnd);
5631         if (NT_STATUS_IS_ERR(nt_status)) {
5632                 DEBUG(0, ("Couldn't close LSA pipe. Error was %s\n",
5633                         nt_errstr(nt_status)));
5634                 cli_shutdown(cli);
5635                 talloc_destroy(mem_ctx);
5636                 return -1;
5637         }
5638
5639         cli_shutdown(cli);
5640
5641         talloc_destroy(mem_ctx);
5642
5643         d_printf("Trust to domain %s established\n", domain_name);
5644         return 0;
5645 }
5646
5647 /**
5648  * Revoke trust relationship to the remote domain
5649  *
5650  * @param argc standard argc
5651  * @param argv standard argv without initial components
5652  *
5653  * @return Integer status (0 means success)
5654  **/
5655
5656 static int rpc_trustdom_revoke(int argc, const char **argv)
5657 {
5658         char* domain_name;
5659         int rc = -1;
5660
5661         if (argc < 1) return -1;
5662
5663         /* generate upper cased domain name */
5664         domain_name = smb_xstrdup(argv[0]);
5665         strupper_m(domain_name);
5666
5667         /* delete password of the trust */
5668         if (!pdb_del_trusteddom_pw(domain_name)) {
5669                 DEBUG(0, ("Failed to revoke relationship to the trusted domain %s\n",
5670                           domain_name));
5671                 goto done;
5672         };
5673
5674         rc = 0;
5675 done:
5676         SAFE_FREE(domain_name);
5677         return rc;
5678 }
5679
5680 /**
5681  * Usage for 'net rpc trustdom' command
5682  *
5683  * @param argc standard argc
5684  * @param argv standard argv without inital components
5685  *
5686  * @return Integer status returned to shell
5687  **/
5688
5689 static int rpc_trustdom_usage(int argc, const char **argv)
5690 {
5691         d_printf("  net rpc trustdom add \t\t add trusting domain's account\n");
5692         d_printf("  net rpc trustdom del \t\t delete trusting domain's account\n");
5693         d_printf("  net rpc trustdom establish \t establish relationship to trusted domain\n");
5694         d_printf("  net rpc trustdom revoke \t abandon relationship to trusted domain\n");
5695         d_printf("  net rpc trustdom list \t show current interdomain trust relationships\n");
5696         d_printf("  net rpc trustdom vampire \t vampire interdomain trust relationships from remote server\n");
5697         return -1;
5698 }
5699
5700
5701 static NTSTATUS rpc_query_domain_sid(const DOM_SID *domain_sid,
5702                                         const char *domain_name,
5703                                         struct cli_state *cli,
5704                                         struct rpc_pipe_client *pipe_hnd,
5705                                         TALLOC_CTX *mem_ctx,
5706                                         int argc,
5707                                         const char **argv)
5708 {
5709         fstring str_sid;
5710         sid_to_string(str_sid, domain_sid);
5711         d_printf("%s\n", str_sid);
5712         return NT_STATUS_OK;
5713 }
5714
5715 static void print_trusted_domain(DOM_SID *dom_sid, const char *trusted_dom_name)
5716 {
5717         fstring ascii_sid, padding;
5718         int pad_len, col_len = 20;
5719
5720         /* convert sid into ascii string */
5721         sid_to_string(ascii_sid, dom_sid);
5722
5723         /* calculate padding space for d_printf to look nicer */
5724         pad_len = col_len - strlen(trusted_dom_name);
5725         padding[pad_len] = 0;
5726         do padding[--pad_len] = ' '; while (pad_len);
5727
5728         d_printf("%s%s%s\n", trusted_dom_name, padding, ascii_sid);
5729 }
5730
5731 static NTSTATUS vampire_trusted_domain(struct rpc_pipe_client *pipe_hnd,
5732                                       TALLOC_CTX *mem_ctx,
5733                                       POLICY_HND *pol,
5734                                       DOM_SID dom_sid,
5735                                       const char *trusted_dom_name)
5736 {
5737         NTSTATUS nt_status;
5738         LSA_TRUSTED_DOMAIN_INFO *info;
5739         char *cleartextpwd = NULL;
5740         DATA_BLOB data;
5741
5742         nt_status = rpccli_lsa_query_trusted_domain_info_by_sid(pipe_hnd, mem_ctx, pol, 4, &dom_sid, &info);
5743
5744         if (NT_STATUS_IS_ERR(nt_status)) {
5745                 DEBUG(0,("Could not query trusted domain info. Error was %s\n",
5746                 nt_errstr(nt_status)));
5747                 goto done;
5748         }
5749
5750         data = data_blob(NULL, info->password.password.length);
5751
5752         memcpy(data.data, info->password.password.data, info->password.password.length);
5753         data.length     = info->password.password.length;
5754
5755         cleartextpwd = decrypt_trustdom_secret(pipe_hnd->cli->pwd.password, &data);
5756
5757         if (cleartextpwd == NULL) {
5758                 DEBUG(0,("retrieved NULL password\n"));
5759                 nt_status = NT_STATUS_UNSUCCESSFUL;
5760                 goto done;
5761         }
5762
5763         if (!pdb_set_trusteddom_pw(trusted_dom_name, cleartextpwd, &dom_sid)) {
5764                 DEBUG(0, ("Storing password for trusted domain failed.\n"));
5765                 nt_status = NT_STATUS_UNSUCCESSFUL;
5766                 goto done;
5767         }
5768
5769 #ifdef DEBUG_PASSWORD
5770         DEBUG(100,("sucessfully vampired trusted domain [%s], sid: [%s], password: [%s]\n",
5771                 trusted_dom_name, sid_string_static(&dom_sid), cleartextpwd));
5772 #endif
5773
5774 done:
5775         SAFE_FREE(cleartextpwd);
5776         data_blob_free(&data);
5777
5778         return nt_status;
5779 }
5780
5781 static int rpc_trustdom_vampire(int argc, const char **argv)
5782 {
5783         /* common variables */
5784         TALLOC_CTX* mem_ctx;
5785         struct cli_state *cli = NULL;
5786         struct rpc_pipe_client *pipe_hnd = NULL;
5787         NTSTATUS nt_status;
5788         const char *domain_name = NULL;
5789         DOM_SID *queried_dom_sid;
5790         POLICY_HND connect_hnd;
5791
5792         /* trusted domains listing variables */
5793         unsigned int num_domains, enum_ctx = 0;
5794         int i;
5795         DOM_SID *domain_sids;
5796         char **trusted_dom_names;
5797         fstring pdc_name;
5798         char *dummy;
5799
5800         /*
5801          * Listing trusted domains (stored in secrets.tdb, if local)
5802          */
5803
5804         mem_ctx = talloc_init("trust relationships vampire");
5805
5806         /*
5807          * set domain and pdc name to local samba server (default)
5808          * or to remote one given in command line
5809          */
5810
5811         if (StrCaseCmp(opt_workgroup, lp_workgroup())) {
5812                 domain_name = opt_workgroup;
5813                 opt_target_workgroup = opt_workgroup;
5814         } else {
5815                 fstrcpy(pdc_name, global_myname());
5816                 domain_name = talloc_strdup(mem_ctx, lp_workgroup());
5817                 opt_target_workgroup = domain_name;
5818         };
5819
5820         /* open \PIPE\lsarpc and open policy handle */
5821         if (!(cli = net_make_ipc_connection(NET_FLAGS_PDC))) {
5822                 DEBUG(0, ("Couldn't connect to domain controller\n"));
5823                 talloc_destroy(mem_ctx);
5824                 return -1;
5825         };
5826
5827         pipe_hnd = cli_rpc_pipe_open_noauth(cli, PI_LSARPC, &nt_status);
5828         if (!pipe_hnd) {
5829                 DEBUG(0, ("Could not initialise lsa pipe. Error was %s\n",
5830                         nt_errstr(nt_status) ));
5831                 cli_shutdown(cli);
5832                 talloc_destroy(mem_ctx);
5833                 return -1;
5834         };
5835
5836         nt_status = rpccli_lsa_open_policy2(pipe_hnd, mem_ctx, False, SEC_RIGHTS_QUERY_VALUE,
5837                                         &connect_hnd);
5838         if (NT_STATUS_IS_ERR(nt_status)) {
5839                 DEBUG(0, ("Couldn't open policy handle. Error was %s\n",
5840                         nt_errstr(nt_status)));
5841                 cli_shutdown(cli);
5842                 talloc_destroy(mem_ctx);
5843                 return -1;
5844         };
5845
5846         /* query info level 5 to obtain sid of a domain being queried */
5847         nt_status = rpccli_lsa_query_info_policy(
5848                 pipe_hnd, mem_ctx, &connect_hnd, 5 /* info level */,
5849                 &dummy, &queried_dom_sid);
5850
5851         if (NT_STATUS_IS_ERR(nt_status)) {
5852                 DEBUG(0, ("LSA Query Info failed. Returned error was %s\n",
5853                         nt_errstr(nt_status)));
5854                 cli_shutdown(cli);
5855                 talloc_destroy(mem_ctx);
5856                 return -1;
5857         }
5858
5859         /*
5860          * Keep calling LsaEnumTrustdom over opened pipe until
5861          * the end of enumeration is reached
5862          */
5863
5864         d_printf("Vampire trusted domains:\n\n");
5865
5866         do {
5867                 nt_status = rpccli_lsa_enum_trust_dom(pipe_hnd, mem_ctx, &connect_hnd, &enum_ctx,
5868                                                    &num_domains,
5869                                                    &trusted_dom_names, &domain_sids);
5870
5871                 if (NT_STATUS_IS_ERR(nt_status)) {
5872                         DEBUG(0, ("Couldn't enumerate trusted domains. Error was %s\n",
5873                                 nt_errstr(nt_status)));
5874                         cli_shutdown(cli);
5875                         talloc_destroy(mem_ctx);
5876                         return -1;
5877                 };
5878
5879                 for (i = 0; i < num_domains; i++) {
5880
5881                         print_trusted_domain(&(domain_sids[i]), trusted_dom_names[i]);
5882
5883                         nt_status = vampire_trusted_domain(pipe_hnd, mem_ctx, &connect_hnd,
5884                                                            domain_sids[i], trusted_dom_names[i]);
5885                         if (!NT_STATUS_IS_OK(nt_status)) {
5886                                 cli_shutdown(cli);
5887                                 talloc_destroy(mem_ctx);
5888                                 return -1;
5889                         }
5890                 };
5891
5892                 /*
5893                  * in case of no trusted domains say something rather
5894                  * than just display blank line
5895                  */
5896                 if (!num_domains) d_printf("none\n");
5897
5898         } while (NT_STATUS_EQUAL(nt_status, STATUS_MORE_ENTRIES));
5899
5900         /* close this connection before doing next one */
5901         nt_status = rpccli_lsa_Close(pipe_hnd, mem_ctx, &connect_hnd);
5902         if (NT_STATUS_IS_ERR(nt_status)) {
5903                 DEBUG(0, ("Couldn't properly close lsa policy handle. Error was %s\n",
5904                         nt_errstr(nt_status)));
5905                 cli_shutdown(cli);
5906                 talloc_destroy(mem_ctx);
5907                 return -1;
5908         };
5909
5910         /* close lsarpc pipe and connection to IPC$ */
5911         cli_shutdown(cli);
5912
5913         talloc_destroy(mem_ctx);
5914         return 0;
5915 }
5916
5917 static int rpc_trustdom_list(int argc, const char **argv)
5918 {
5919         /* common variables */
5920         TALLOC_CTX* mem_ctx;
5921         struct cli_state *cli = NULL, *remote_cli = NULL;
5922         struct rpc_pipe_client *pipe_hnd = NULL;
5923         NTSTATUS nt_status;
5924         const char *domain_name = NULL;
5925         DOM_SID *queried_dom_sid;
5926         fstring padding;
5927         int ascii_dom_name_len;
5928         POLICY_HND connect_hnd;
5929
5930         /* trusted domains listing variables */
5931         unsigned int num_domains, enum_ctx = 0;
5932         int i, pad_len, col_len = 20;
5933         DOM_SID *domain_sids;
5934         char **trusted_dom_names;
5935         fstring pdc_name;
5936         char *dummy;
5937
5938         /* trusting domains listing variables */
5939         POLICY_HND domain_hnd;
5940         char **trusting_dom_names;
5941         uint32 *trusting_dom_rids;
5942
5943         /*
5944          * Listing trusted domains (stored in secrets.tdb, if local)
5945          */
5946
5947         mem_ctx = talloc_init("trust relationships listing");
5948
5949         /*
5950          * set domain and pdc name to local samba server (default)
5951          * or to remote one given in command line
5952          */
5953
5954         if (StrCaseCmp(opt_workgroup, lp_workgroup())) {
5955                 domain_name = opt_workgroup;
5956                 opt_target_workgroup = opt_workgroup;
5957         } else {
5958                 fstrcpy(pdc_name, global_myname());
5959                 domain_name = talloc_strdup(mem_ctx, lp_workgroup());
5960                 opt_target_workgroup = domain_name;
5961         };
5962
5963         /* open \PIPE\lsarpc and open policy handle */
5964         if (!(cli = net_make_ipc_connection(NET_FLAGS_PDC))) {
5965                 DEBUG(0, ("Couldn't connect to domain controller\n"));
5966                 talloc_destroy(mem_ctx);
5967                 return -1;
5968         };
5969
5970         pipe_hnd = cli_rpc_pipe_open_noauth(cli, PI_LSARPC, &nt_status);
5971         if (!pipe_hnd) {
5972                 DEBUG(0, ("Could not initialise lsa pipe. Error was %s\n",
5973                         nt_errstr(nt_status) ));
5974                 cli_shutdown(cli);
5975                 talloc_destroy(mem_ctx);
5976                 return -1;
5977         };
5978
5979         nt_status = rpccli_lsa_open_policy2(pipe_hnd, mem_ctx, False, SEC_RIGHTS_QUERY_VALUE,
5980                                         &connect_hnd);
5981         if (NT_STATUS_IS_ERR(nt_status)) {
5982                 DEBUG(0, ("Couldn't open policy handle. Error was %s\n",
5983                         nt_errstr(nt_status)));
5984                 cli_shutdown(cli);
5985                 talloc_destroy(mem_ctx);
5986                 return -1;
5987         };
5988
5989         /* query info level 5 to obtain sid of a domain being queried */
5990         nt_status = rpccli_lsa_query_info_policy(
5991                 pipe_hnd, mem_ctx, &connect_hnd, 5 /* info level */,
5992                 &dummy, &queried_dom_sid);
5993
5994         if (NT_STATUS_IS_ERR(nt_status)) {
5995                 DEBUG(0, ("LSA Query Info failed. Returned error was %s\n",
5996                         nt_errstr(nt_status)));
5997                 cli_shutdown(cli);
5998                 talloc_destroy(mem_ctx);
5999                 return -1;
6000         }
6001
6002         /*
6003          * Keep calling LsaEnumTrustdom over opened pipe until
6004          * the end of enumeration is reached
6005          */
6006
6007         d_printf("Trusted domains list:\n\n");
6008
6009         do {
6010                 nt_status = rpccli_lsa_enum_trust_dom(pipe_hnd, mem_ctx, &connect_hnd, &enum_ctx,
6011                                                    &num_domains,
6012                                                    &trusted_dom_names, &domain_sids);
6013
6014                 if (NT_STATUS_IS_ERR(nt_status)) {
6015                         DEBUG(0, ("Couldn't enumerate trusted domains. Error was %s\n",
6016                                 nt_errstr(nt_status)));
6017                         cli_shutdown(cli);
6018                         talloc_destroy(mem_ctx);
6019                         return -1;
6020                 };
6021
6022                 for (i = 0; i < num_domains; i++) {
6023                         print_trusted_domain(&(domain_sids[i]), trusted_dom_names[i]);
6024                 };
6025
6026                 /*
6027                  * in case of no trusted domains say something rather
6028                  * than just display blank line
6029                  */
6030                 if (!num_domains) d_printf("none\n");
6031
6032         } while (NT_STATUS_EQUAL(nt_status, STATUS_MORE_ENTRIES));
6033
6034         /* close this connection before doing next one */
6035         nt_status = rpccli_lsa_Close(pipe_hnd, mem_ctx, &connect_hnd);
6036         if (NT_STATUS_IS_ERR(nt_status)) {
6037                 DEBUG(0, ("Couldn't properly close lsa policy handle. Error was %s\n",
6038                         nt_errstr(nt_status)));
6039                 cli_shutdown(cli);
6040                 talloc_destroy(mem_ctx);
6041                 return -1;
6042         };
6043
6044         cli_rpc_pipe_close(pipe_hnd);
6045
6046         /*
6047          * Listing trusting domains (stored in passdb backend, if local)
6048          */
6049
6050         d_printf("\nTrusting domains list:\n\n");
6051
6052         /*
6053          * Open \PIPE\samr and get needed policy handles
6054          */
6055         pipe_hnd = cli_rpc_pipe_open_noauth(cli, PI_SAMR, &nt_status);
6056         if (!pipe_hnd) {
6057                 DEBUG(0, ("Could not initialise samr pipe. Error was %s\n", nt_errstr(nt_status)));
6058                 cli_shutdown(cli);
6059                 talloc_destroy(mem_ctx);
6060                 return -1;
6061         };
6062
6063         /* SamrConnect */
6064         nt_status = rpccli_samr_connect(pipe_hnd, mem_ctx, SA_RIGHT_SAM_OPEN_DOMAIN,
6065                                                                  &connect_hnd);
6066         if (!NT_STATUS_IS_OK(nt_status)) {
6067                 DEBUG(0, ("Couldn't open SAMR policy handle. Error was %s\n",
6068                         nt_errstr(nt_status)));
6069                 cli_shutdown(cli);
6070                 talloc_destroy(mem_ctx);
6071                 return -1;
6072         };
6073
6074         /* SamrOpenDomain - we have to open domain policy handle in order to be
6075            able to enumerate accounts*/
6076         nt_status = rpccli_samr_open_domain(pipe_hnd, mem_ctx, &connect_hnd,
6077                                          SA_RIGHT_DOMAIN_ENUM_ACCOUNTS,
6078                                          queried_dom_sid, &domain_hnd);
6079         if (!NT_STATUS_IS_OK(nt_status)) {
6080                 DEBUG(0, ("Couldn't open domain object. Error was %s\n",
6081                         nt_errstr(nt_status)));
6082                 cli_shutdown(cli);
6083                 talloc_destroy(mem_ctx);
6084                 return -1;
6085         };
6086
6087         /*
6088          * perform actual enumeration
6089          */
6090
6091         enum_ctx = 0;   /* reset enumeration context from last enumeration */
6092         do {
6093
6094                 nt_status = rpccli_samr_enum_dom_users(pipe_hnd, mem_ctx, &domain_hnd,
6095                                                     &enum_ctx, ACB_DOMTRUST, 0xffff,
6096                                                     &trusting_dom_names, &trusting_dom_rids,
6097                                                     &num_domains);
6098                 if (NT_STATUS_IS_ERR(nt_status)) {
6099                         DEBUG(0, ("Couldn't enumerate accounts. Error was: %s\n",
6100                                 nt_errstr(nt_status)));
6101                         cli_shutdown(cli);
6102                         talloc_destroy(mem_ctx);
6103                         return -1;
6104                 };
6105
6106                 for (i = 0; i < num_domains; i++) {
6107
6108                         /*
6109                          * get each single domain's sid (do we _really_ need this ?):
6110                          *  1) connect to domain's pdc
6111                          *  2) query the pdc for domain's sid
6112                          */
6113
6114                         /* get rid of '$' tail */
6115                         ascii_dom_name_len = strlen(trusting_dom_names[i]);
6116                         if (ascii_dom_name_len && ascii_dom_name_len < FSTRING_LEN)
6117                                 trusting_dom_names[i][ascii_dom_name_len - 1] = '\0';
6118
6119                         /* calculate padding space for d_printf to look nicer */
6120                         pad_len = col_len - strlen(trusting_dom_names[i]);
6121                         padding[pad_len] = 0;
6122                         do padding[--pad_len] = ' '; while (pad_len);
6123
6124                         /* set opt_* variables to remote domain */
6125                         strupper_m(trusting_dom_names[i]);
6126                         opt_workgroup = talloc_strdup(mem_ctx, trusting_dom_names[i]);
6127                         opt_target_workgroup = opt_workgroup;
6128
6129                         d_printf("%s%s", trusting_dom_names[i], padding);
6130
6131                         /* connect to remote domain controller */
6132                         remote_cli = net_make_ipc_connection(NET_FLAGS_PDC | NET_FLAGS_ANONYMOUS);
6133                         if (remote_cli) {
6134                                 /* query for domain's sid */
6135                                 if (run_rpc_command(remote_cli, PI_LSARPC, 0, rpc_query_domain_sid, argc, argv))
6136                                         d_fprintf(stderr, "couldn't get domain's sid\n");
6137
6138                                 cli_shutdown(remote_cli);
6139
6140                         } else {
6141                                 d_fprintf(stderr, "domain controller is not responding\n");
6142                         };
6143                 };
6144
6145                 if (!num_domains) d_printf("none\n");
6146
6147         } while (NT_STATUS_EQUAL(nt_status, STATUS_MORE_ENTRIES));
6148
6149         /* close opened samr and domain policy handles */
6150         nt_status = rpccli_samr_close(pipe_hnd, mem_ctx, &domain_hnd);
6151         if (!NT_STATUS_IS_OK(nt_status)) {
6152                 DEBUG(0, ("Couldn't properly close domain policy handle for domain %s\n", domain_name));
6153         };
6154
6155         nt_status = rpccli_samr_close(pipe_hnd, mem_ctx, &connect_hnd);
6156         if (!NT_STATUS_IS_OK(nt_status)) {
6157                 DEBUG(0, ("Couldn't properly close samr policy handle for domain %s\n", domain_name));
6158         };
6159
6160         /* close samr pipe and connection to IPC$ */
6161         cli_shutdown(cli);
6162
6163         talloc_destroy(mem_ctx);
6164         return 0;
6165 }
6166
6167 /**
6168  * Entrypoint for 'net rpc trustdom' code
6169  *
6170  * @param argc standard argc
6171  * @param argv standard argv without initial components
6172  *
6173  * @return Integer status (0 means success)
6174  */
6175
6176 static int rpc_trustdom(int argc, const char **argv)
6177 {
6178         struct functable func[] = {
6179                 {"add", rpc_trustdom_add},
6180                 {"del", rpc_trustdom_del},
6181                 {"establish", rpc_trustdom_establish},
6182                 {"revoke", rpc_trustdom_revoke},
6183                 {"help", rpc_trustdom_usage},
6184                 {"list", rpc_trustdom_list},
6185                 {"vampire", rpc_trustdom_vampire},
6186                 {NULL, NULL}
6187         };
6188
6189         if (argc == 0) {
6190                 rpc_trustdom_usage(argc, argv);
6191                 return -1;
6192         }
6193
6194         return (net_run_function(argc, argv, func, rpc_user_usage));
6195 }
6196
6197 /**
6198  * Check if a server will take rpc commands
6199  * @param flags Type of server to connect to (PDC, DMB, localhost)
6200  *              if the host is not explicitly specified
6201  * @return  BOOL (true means rpc supported)
6202  */
6203 BOOL net_rpc_check(unsigned flags)
6204 {
6205         struct cli_state *cli;
6206         BOOL ret = False;
6207         struct in_addr server_ip;
6208         char *server_name = NULL;
6209
6210         /* flags (i.e. server type) may depend on command */
6211         if (!net_find_server(NULL, flags, &server_ip, &server_name))
6212                 return False;
6213
6214         if ((cli = cli_initialise()) == NULL) {
6215                 return False;
6216         }
6217
6218         if (!cli_connect(cli, server_name, &server_ip))
6219                 goto done;
6220         if (!attempt_netbios_session_request(&cli, global_myname(),
6221                                              server_name, &server_ip))
6222                 goto done;
6223         if (!cli_negprot(cli))
6224                 goto done;
6225         if (cli->protocol < PROTOCOL_NT1)
6226                 goto done;
6227
6228         ret = True;
6229  done:
6230         cli_shutdown(cli);
6231         return ret;
6232 }
6233
6234 /* dump sam database via samsync rpc calls */
6235 static int rpc_samdump(int argc, const char **argv) {
6236                 return run_rpc_command(NULL, PI_NETLOGON, NET_FLAGS_ANONYMOUS, rpc_samdump_internals,
6237                                argc, argv);
6238 }
6239
6240 /* syncronise sam database via samsync rpc calls */
6241 static int rpc_vampire(int argc, const char **argv) {
6242         return run_rpc_command(NULL, PI_NETLOGON, NET_FLAGS_ANONYMOUS, rpc_vampire_internals,
6243                                argc, argv);
6244 }
6245
6246 /**
6247  * Migrate everything from a print-server
6248  *
6249  * @param argc  Standard main() style argc
6250  * @param argv  Standard main() style argv.  Initial components are already
6251  *              stripped
6252  *
6253  * @return A shell status integer (0 for success)
6254  *
6255  * The order is important !
6256  * To successfully add drivers the print-queues have to exist !
6257  * Applying ACLs should be the last step, because you're easily locked out
6258  *
6259  **/
6260 static int rpc_printer_migrate_all(int argc, const char **argv)
6261 {
6262         int ret;
6263
6264         if (!opt_host) {
6265                 printf("no server to migrate\n");
6266                 return -1;
6267         }
6268
6269         ret = run_rpc_command(NULL, PI_SPOOLSS, 0, rpc_printer_migrate_printers_internals, argc, argv);
6270         if (ret)
6271                 return ret;
6272
6273         ret = run_rpc_command(NULL, PI_SPOOLSS, 0, rpc_printer_migrate_drivers_internals, argc, argv);
6274         if (ret)
6275                 return ret;
6276
6277         ret = run_rpc_command(NULL, PI_SPOOLSS, 0, rpc_printer_migrate_forms_internals, argc, argv);
6278         if (ret)
6279                 return ret;
6280
6281         ret = run_rpc_command(NULL, PI_SPOOLSS, 0, rpc_printer_migrate_settings_internals, argc, argv);
6282         if (ret)
6283                 return ret;
6284
6285         return run_rpc_command(NULL, PI_SPOOLSS, 0, rpc_printer_migrate_security_internals, argc, argv);
6286
6287 }
6288
6289 /**
6290  * Migrate print-drivers from a print-server
6291  *
6292  * @param argc  Standard main() style argc
6293  * @param argv  Standard main() style argv.  Initial components are already
6294  *              stripped
6295  *
6296  * @return A shell status integer (0 for success)
6297  **/
6298 static int rpc_printer_migrate_drivers(int argc, const char **argv)
6299 {
6300         if (!opt_host) {
6301                 printf("no server to migrate\n");
6302                 return -1;
6303         }
6304
6305         return run_rpc_command(NULL, PI_SPOOLSS, 0,
6306                                rpc_printer_migrate_drivers_internals,
6307                                argc, argv);
6308 }
6309
6310 /**
6311  * Migrate print-forms from a print-server
6312  *
6313  * @param argc  Standard main() style argc
6314  * @param argv  Standard main() style argv.  Initial components are already
6315  *              stripped
6316  *
6317  * @return A shell status integer (0 for success)
6318  **/
6319 static int rpc_printer_migrate_forms(int argc, const char **argv)
6320 {
6321         if (!opt_host) {
6322                 printf("no server to migrate\n");
6323                 return -1;
6324         }
6325
6326         return run_rpc_command(NULL, PI_SPOOLSS, 0,
6327                                rpc_printer_migrate_forms_internals,
6328                                argc, argv);
6329 }
6330
6331 /**
6332  * Migrate printers from a print-server
6333  *
6334  * @param argc  Standard main() style argc
6335  * @param argv  Standard main() style argv.  Initial components are already
6336  *              stripped
6337  *
6338  * @return A shell status integer (0 for success)
6339  **/
6340 static int rpc_printer_migrate_printers(int argc, const char **argv)
6341 {
6342         if (!opt_host) {
6343                 printf("no server to migrate\n");
6344                 return -1;
6345         }
6346
6347         return run_rpc_command(NULL, PI_SPOOLSS, 0,
6348                                rpc_printer_migrate_printers_internals,
6349                                argc, argv);
6350 }
6351
6352 /**
6353  * Migrate printer-ACLs from a print-server
6354  *
6355  * @param argc  Standard main() style argc
6356  * @param argv  Standard main() style argv.  Initial components are already
6357  *              stripped
6358  *
6359  * @return A shell status integer (0 for success)
6360  **/
6361 static int rpc_printer_migrate_security(int argc, const char **argv)
6362 {
6363         if (!opt_host) {
6364                 printf("no server to migrate\n");
6365                 return -1;
6366         }
6367
6368         return run_rpc_command(NULL, PI_SPOOLSS, 0,
6369                                rpc_printer_migrate_security_internals,
6370                                argc, argv);
6371 }
6372
6373 /**
6374  * Migrate printer-settings from a print-server
6375  *
6376  * @param argc  Standard main() style argc
6377  * @param argv  Standard main() style argv.  Initial components are already
6378  *              stripped
6379  *
6380  * @return A shell status integer (0 for success)
6381  **/
6382 static int rpc_printer_migrate_settings(int argc, const char **argv)
6383 {
6384         if (!opt_host) {
6385                 printf("no server to migrate\n");
6386                 return -1;
6387         }
6388
6389         return run_rpc_command(NULL, PI_SPOOLSS, 0,
6390                                rpc_printer_migrate_settings_internals,
6391                                argc, argv);
6392 }
6393
6394 /**
6395  * 'net rpc printer' entrypoint.
6396  * @param argc  Standard main() style argc
6397  * @param argv  Standard main() style argv.  Initial components are already
6398  *              stripped
6399  **/
6400
6401 int rpc_printer_migrate(int argc, const char **argv)
6402 {
6403
6404         /* ouch: when addriver and setdriver are called from within
6405            rpc_printer_migrate_drivers_internals, the printer-queue already
6406            *has* to exist */
6407
6408         struct functable func[] = {
6409                 {"all",         rpc_printer_migrate_all},
6410                 {"drivers",     rpc_printer_migrate_drivers},
6411                 {"forms",       rpc_printer_migrate_forms},
6412                 {"help",        rpc_printer_usage},
6413                 {"printers",    rpc_printer_migrate_printers},
6414                 {"security",    rpc_printer_migrate_security},
6415                 {"settings",    rpc_printer_migrate_settings},
6416                 {NULL, NULL}
6417         };
6418
6419         return net_run_function(argc, argv, func, rpc_printer_usage);
6420 }
6421
6422
6423 /**
6424  * List printers on a remote RPC server
6425  *
6426  * @param argc  Standard main() style argc
6427  * @param argv  Standard main() style argv.  Initial components are already
6428  *              stripped
6429  *
6430  * @return A shell status integer (0 for success)
6431  **/
6432 static int rpc_printer_list(int argc, const char **argv)
6433 {
6434
6435         return run_rpc_command(NULL, PI_SPOOLSS, 0,
6436                                rpc_printer_list_internals,
6437                                argc, argv);
6438 }
6439
6440 /**
6441  * List printer-drivers on a remote RPC server
6442  *
6443  * @param argc  Standard main() style argc
6444  * @param argv  Standard main() style argv.  Initial components are already
6445  *              stripped
6446  *
6447  * @return A shell status integer (0 for success)
6448  **/
6449 static int rpc_printer_driver_list(int argc, const char **argv)
6450 {
6451
6452         return run_rpc_command(NULL, PI_SPOOLSS, 0,
6453                                rpc_printer_driver_list_internals,
6454                                argc, argv);
6455 }
6456
6457 /**
6458  * Publish printer in ADS via MSRPC
6459  *
6460  * @param argc  Standard main() style argc
6461  * @param argv  Standard main() style argv.  Initial components are already
6462  *              stripped
6463  *
6464  * @return A shell status integer (0 for success)
6465  **/
6466 static int rpc_printer_publish_publish(int argc, const char **argv)
6467 {
6468
6469         return run_rpc_command(NULL, PI_SPOOLSS, 0,
6470                                rpc_printer_publish_publish_internals,
6471                                argc, argv);
6472 }
6473
6474 /**
6475  * Update printer in ADS via MSRPC
6476  *
6477  * @param argc  Standard main() style argc
6478  * @param argv  Standard main() style argv.  Initial components are already
6479  *              stripped
6480  *
6481  * @return A shell status integer (0 for success)
6482  **/
6483 static int rpc_printer_publish_update(int argc, const char **argv)
6484 {
6485
6486         return run_rpc_command(NULL, PI_SPOOLSS, 0,
6487                                rpc_printer_publish_update_internals,
6488                                argc, argv);
6489 }
6490
6491 /**
6492  * UnPublish printer in ADS via MSRPC
6493  *
6494  * @param argc  Standard main() style argc
6495  * @param argv  Standard main() style argv.  Initial components are already
6496  *              stripped
6497  *
6498  * @return A shell status integer (0 for success)
6499  **/
6500 static int rpc_printer_publish_unpublish(int argc, const char **argv)
6501 {
6502
6503         return run_rpc_command(NULL, PI_SPOOLSS, 0,
6504                                rpc_printer_publish_unpublish_internals,
6505                                argc, argv);
6506 }
6507
6508 /**
6509  * List published printers via MSRPC
6510  *
6511  * @param argc  Standard main() style argc
6512  * @param argv  Standard main() style argv.  Initial components are already
6513  *              stripped
6514  *
6515  * @return A shell status integer (0 for success)
6516  **/
6517 static int rpc_printer_publish_list(int argc, const char **argv)
6518 {
6519
6520         return run_rpc_command(NULL, PI_SPOOLSS, 0,
6521                                rpc_printer_publish_list_internals,
6522                                argc, argv);
6523 }
6524
6525
6526 /**
6527  * Publish printer in ADS
6528  *
6529  * @param argc  Standard main() style argc
6530  * @param argv  Standard main() style argv.  Initial components are already
6531  *              stripped
6532  *
6533  * @return A shell status integer (0 for success)
6534  **/
6535 static int rpc_printer_publish(int argc, const char **argv)
6536 {
6537
6538         struct functable func[] = {
6539                 {"publish",     rpc_printer_publish_publish},
6540                 {"update",      rpc_printer_publish_update},
6541                 {"unpublish",   rpc_printer_publish_unpublish},
6542                 {"list",        rpc_printer_publish_list},
6543                 {"help",        rpc_printer_usage},
6544                 {NULL, NULL}
6545         };
6546
6547         if (argc == 0)
6548                 return run_rpc_command(NULL, PI_SPOOLSS, 0,
6549                                rpc_printer_publish_list_internals,
6550                                argc, argv);
6551
6552         return net_run_function(argc, argv, func, rpc_printer_usage);
6553
6554 }
6555
6556
6557 /**
6558  * Display rpc printer help page.
6559  * @param argc  Standard main() style argc
6560  * @param argv  Standard main() style argv.  Initial components are already
6561  *              stripped
6562  **/
6563 int rpc_printer_usage(int argc, const char **argv)
6564 {
6565         return net_help_printer(argc, argv);
6566 }
6567
6568 /**
6569  * 'net rpc printer' entrypoint.
6570  * @param argc  Standard main() style argc
6571  * @param argv  Standard main() style argv.  Initial components are already
6572  *              stripped
6573  **/
6574 int net_rpc_printer(int argc, const char **argv)
6575 {
6576         struct functable func[] = {
6577                 {"list", rpc_printer_list},
6578                 {"migrate", rpc_printer_migrate},
6579                 {"driver", rpc_printer_driver_list},
6580                 {"publish", rpc_printer_publish},
6581                 {NULL, NULL}
6582         };
6583
6584         if (argc == 0)
6585                 return run_rpc_command(NULL, PI_SPOOLSS, 0,
6586                                rpc_printer_list_internals,
6587                                argc, argv);
6588
6589         return net_run_function(argc, argv, func, rpc_printer_usage);
6590 }
6591
6592 /****************************************************************************/
6593
6594
6595 /**
6596  * Basic usage function for 'net rpc'
6597  * @param argc  Standard main() style argc
6598  * @param argv  Standard main() style argv.  Initial components are already
6599  *              stripped
6600  **/
6601
6602 int net_rpc_usage(int argc, const char **argv)
6603 {
6604         d_printf("  net rpc info \t\t\tshow basic info about a domain \n");
6605         d_printf("  net rpc join \t\t\tto join a domain \n");
6606         d_printf("  net rpc oldjoin \t\t\tto join a domain created in server manager\n");
6607         d_printf("  net rpc testjoin \t\ttests that a join is valid\n");
6608         d_printf("  net rpc user \t\t\tto add, delete and list users\n");
6609         d_printf("  net rpc password <username> [<password>] -Uadmin_username%%admin_pass\n");
6610         d_printf("  net rpc group \t\tto list groups\n");
6611         d_printf("  net rpc share \t\tto add, delete, list and migrate shares\n");
6612         d_printf("  net rpc printer \t\tto list and migrate printers\n");
6613         d_printf("  net rpc file \t\t\tto list open files\n");
6614         d_printf("  net rpc changetrustpw \tto change the trust account password\n");
6615         d_printf("  net rpc getsid \t\tfetch the domain sid into the local secrets.tdb\n");
6616         d_printf("  net rpc vampire \t\tsyncronise an NT PDC's users and groups into the local passdb\n");
6617         d_printf("  net rpc samdump \t\tdiplay an NT PDC's users, groups and other data\n");
6618         d_printf("  net rpc trustdom \t\tto create trusting domain's account or establish trust\n");
6619         d_printf("  net rpc abortshutdown \tto abort the shutdown of a remote server\n");
6620         d_printf("  net rpc shutdown \t\tto shutdown a remote server\n");
6621         d_printf("  net rpc rights\t\tto manage privileges assigned to SIDs\n");
6622         d_printf("  net rpc registry\t\tto manage registry hives\n");
6623         d_printf("  net rpc service\t\tto start, stop and query services\n");
6624         d_printf("  net rpc audit\t\t\tto modify global auditing settings\n");
6625         d_printf("  net rpc shell\t\t\tto open an interactive shell for remote server/account management\n");
6626         d_printf("\n");
6627         d_printf("'net rpc shutdown' also accepts the following miscellaneous options:\n"); /* misc options */
6628         d_printf("\t-r or --reboot\trequest remote server reboot on shutdown\n");
6629         d_printf("\t-f or --force\trequest the remote server force its shutdown\n");
6630         d_printf("\t-t or --timeout=<timeout>\tnumber of seconds before shutdown\n");
6631         d_printf("\t-C or --comment=<message>\ttext message to display on impending shutdown\n");
6632         return -1;
6633 }
6634
6635
6636 /**
6637  * Help function for 'net rpc'.  Calls command specific help if requested
6638  * or displays usage of net rpc
6639  * @param argc  Standard main() style argc
6640  * @param argv  Standard main() style argv.  Initial components are already
6641  *              stripped
6642  **/
6643
6644 int net_rpc_help(int argc, const char **argv)
6645 {
6646         struct functable func[] = {
6647                 {"join", rpc_join_usage},
6648                 {"user", rpc_user_usage},
6649                 {"group", rpc_group_usage},
6650                 {"share", rpc_share_usage},
6651                 /*{"changetrustpw", rpc_changetrustpw_usage}, */
6652                 {"trustdom", rpc_trustdom_usage},
6653                 /*{"abortshutdown", rpc_shutdown_abort_usage},*/
6654                 /*{"shutdown", rpc_shutdown_usage}, */
6655                 {"vampire", rpc_vampire_usage},
6656                 {NULL, NULL}
6657         };
6658
6659         if (argc == 0) {
6660                 net_rpc_usage(argc, argv);
6661                 return -1;
6662         }
6663
6664         return (net_run_function(argc, argv, func, rpc_user_usage));
6665 }
6666
6667 /**
6668  * 'net rpc' entrypoint.
6669  * @param argc  Standard main() style argc
6670  * @param argv  Standard main() style argv.  Initial components are already
6671  *              stripped
6672  **/
6673
6674 int net_rpc(int argc, const char **argv)
6675 {
6676         struct functable func[] = {
6677                 {"audit", net_rpc_audit},
6678                 {"info", net_rpc_info},
6679                 {"join", net_rpc_join},
6680                 {"oldjoin", net_rpc_oldjoin},
6681                 {"testjoin", net_rpc_testjoin},
6682                 {"user", net_rpc_user},
6683                 {"password", rpc_user_password},
6684                 {"group", net_rpc_group},
6685                 {"share", net_rpc_share},
6686                 {"file", net_rpc_file},
6687                 {"printer", net_rpc_printer},
6688                 {"changetrustpw", net_rpc_changetrustpw},
6689                 {"trustdom", rpc_trustdom},
6690                 {"abortshutdown", rpc_shutdown_abort},
6691                 {"shutdown", rpc_shutdown},
6692                 {"samdump", rpc_samdump},
6693                 {"vampire", rpc_vampire},
6694                 {"getsid", net_rpc_getsid},
6695                 {"rights", net_rpc_rights},
6696                 {"service", net_rpc_service},
6697                 {"registry", net_rpc_registry},
6698                 {"shell", net_rpc_shell},
6699                 {"help", net_rpc_help},
6700                 {NULL, NULL}
6701         };
6702         return net_run_function(argc, argv, func, net_rpc_usage);
6703 }