source3/utils/net.c

   1 /*
   2    Samba Unix/Linux SMB client library
   3    Distributed SMB/CIFS Server Management Utility
   4    Copyright (C) 2001 Steve French  (sfrench@us.ibm.com)
   5    Copyright (C) 2001 Jim McDonough (jmcd@us.ibm.com)
   6    Copyright (C) 2001 Andrew Tridgell (tridge@samba.org)
   7    Copyright (C) 2001 Andrew Bartlett (abartlet@samba.org)
   8
   9    Originally written by Steve and Jim. Largely rewritten by tridge in
  10    November 2001.
  11
  12    Reworked again by abartlet in December 2001
  13
  14    This program is free software; you can redistribute it and/or modify
  15    it under the terms of the GNU General Public License as published by
  16    the Free Software Foundation; either version 2 of the License, or
  17    (at your option) any later version.
  18
  19    This program is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22    GNU General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public License
  25    along with this program; if not, write to the Free Software
  26    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  27
  28 /*****************************************************/
  29 /*                                                   */
  30 /*   Distributed SMB/CIFS Server Management Utility  */
  31 /*                                                   */
  32 /*   The intent was to make the syntax similar       */
  33 /*   to the NET utility (first developed in DOS      */
  34 /*   with additional interesting & useful functions  */
  35 /*   added in later SMB server network operating     */
  36 /*   systems).                                       */
  37 /*                                                   */
  38 /*****************************************************/
  39
  40 #include "includes.h"
  41 #include "../utils/net.h"
  42
  43 /***********************************************************************/
  44 /* Beginning of internationalization section.  Translatable constants  */
  45 /* should be kept in this area and referenced in the rest of the code. */
  46 /*                                                                     */
  47 /* No functions, outside of Samba or LSB (Linux Standards Base) should */
  48 /* be used (if possible).                                              */
  49 /***********************************************************************/
  50
  51 #define YES_STRING              "Yes"
  52 #define NO_STRING               "No"
  53
  54 /************************************************************************************/
  55 /*                       end of internationalization section                        */
  56 /************************************************************************************/
  57
  58 /* Yes, these buggers are globals.... */
  59 const char *opt_requester_name = NULL;
  60 const char *opt_host = NULL;
  61 const char *opt_password = NULL;
  62 const char *opt_user_name = NULL;
  63 BOOL opt_user_specified = False;
  64 const char *opt_workgroup = NULL;
  65 int opt_long_list_entries = 0;
  66 int opt_reboot = 0;
  67 int opt_force = 0;
  68 int opt_port = 0;
  69 int opt_maxusers = -1;
  70 const char *opt_comment = "";
  71 char *opt_container = "cn=Users";
  72 int opt_flags = -1;
  73 int opt_jobid = 0;
  74 int opt_timeout = 0;
  75 const char *opt_target_workgroup = NULL;
  76 static int opt_machine_pass = 0;
  77
  78 BOOL opt_have_ip = False;
  79 struct in_addr opt_dest_ip;
  80
  81 /*
  82   run a function from a function table. If not found then
  83   call the specified usage function
  84 */
  85 int net_run_function(int argc, const char **argv, struct functable *table,
  86                      int (*usage_fn)(int argc, const char **argv))
  87 {
  88         int i;
  89
  90         if (argc < 1) {
  91                 d_printf("\nUsage: \n");
  92                 return usage_fn(argc, argv);
  93         }
  94         for (i=0; table[i].funcname; i++) {
  95                 if (StrCaseCmp(argv[0], table[i].funcname) == 0)
  96                         return table[i].fn(argc-1, argv+1);
  97         }
  98         d_printf("No command: %s\n", argv[0]);
  99         return usage_fn(argc, argv);
 100 }
 101
 102
 103 /****************************************************************************
 104 connect to \\server\ipc$
 105 ****************************************************************************/
 106 NTSTATUS connect_to_ipc(struct cli_state **c, struct in_addr *server_ip,
 107                                         const char *server_name)
 108 {
 109         NTSTATUS nt_status;
 110
 111         if (!opt_password) {
 112                 char *pass = getpass("Password:");
 113                 if (pass) {
 114                         opt_password = strdup(pass);
 115                 }
 116         }
 117
 118         nt_status = cli_full_connection(c, opt_requester_name, server_name,
 119                                         server_ip, opt_port,
 120                                         "IPC$", "IPC",
 121                                         opt_user_name, opt_workgroup,
 122                                         opt_password, 0, NULL);
 123
 124         if (NT_STATUS_IS_OK(nt_status)) {
 125                 return nt_status;
 126         } else {
 127                 DEBUG(1,("Cannot connect to server.  Error was %s\n",
 128                          nt_errstr(nt_status)));
 129
 130                 /* Display a nicer message depending on the result */
 131
 132                 if (NT_STATUS_V(nt_status) ==
 133                     NT_STATUS_V(NT_STATUS_LOGON_FAILURE))
 134                         d_printf("The username or password was not correct.\n");
 135
 136                 return nt_status;
 137         }
 138 }
 139
 140 /****************************************************************************
 141 connect to \\server\ipc$ anonymously
 142 ****************************************************************************/
 143 NTSTATUS connect_to_ipc_anonymous(struct cli_state **c,
 144                         struct in_addr *server_ip, const char *server_name)
 145 {
 146         NTSTATUS nt_status;
 147
 148         nt_status = cli_full_connection(c, opt_requester_name, server_name,
 149                                         server_ip, opt_port,
 150                                         "IPC$", "IPC",
 151                                         "", "",
 152                                         "", 0, NULL);
 153
 154         if (NT_STATUS_IS_OK(nt_status)) {
 155                 return nt_status;
 156         } else {
 157                 DEBUG(1,("Cannot connect to server (anonymously).  Error was %s\n", nt_errstr(nt_status)));
 158                 return nt_status;
 159         }
 160 }
 161
 162 BOOL net_find_server(unsigned flags, struct in_addr *server_ip, char **server_name)
 163 {
 164
 165         if (opt_host) {
 166                 *server_name = strdup(opt_host);
 167         }
 168
 169         if (opt_have_ip) {
 170                 *server_ip = opt_dest_ip;
 171                 if (!*server_name) {
 172                         *server_name = strdup(inet_ntoa(opt_dest_ip));
 173                 }
 174         } else if (*server_name) {
 175                 /* resolve the IP address */
 176                 if (!resolve_name(*server_name, server_ip, 0x20))  {
 177                         DEBUG(1,("Unable to resolve server name\n"));
 178                         return False;
 179                 }
 180         } else if (flags & NET_FLAGS_PDC) {
 181                 struct in_addr pdc_ip;
 182
 183                 if (get_pdc_ip(opt_target_workgroup, &pdc_ip)) {
 184                         fstring dc_name;
 185
 186                         if (is_zero_ip(pdc_ip))
 187                                 return False;
 188
 189                         if (!lookup_dc_name(global_myname(), opt_target_workgroup, &pdc_ip, dc_name))
 190                                 return False;
 191
 192                         *server_name = strdup(dc_name);
 193                         *server_ip = pdc_ip;
 194                 }
 195
 196         } else if (flags & NET_FLAGS_DMB) {
 197                 struct in_addr msbrow_ip;
 198                 /*  if (!resolve_name(MSBROWSE, &msbrow_ip, 1)) */
 199                 if (!resolve_name(opt_target_workgroup, &msbrow_ip, 0x1B))  {
 200                         DEBUG(1,("Unable to resolve domain browser via name lookup\n"));
 201                         return False;
 202                 } else {
 203                         *server_ip = msbrow_ip;
 204                 }
 205                 *server_name = strdup(inet_ntoa(opt_dest_ip));
 206         } else if (flags & NET_FLAGS_MASTER) {
 207                 struct in_addr brow_ips;
 208                 if (!resolve_name(opt_target_workgroup, &brow_ips, 0x1D))  {
 209                                 /* go looking for workgroups */
 210                         DEBUG(1,("Unable to resolve master browser via name lookup\n"));
 211                         return False;
 212                 } else {
 213                         *server_ip = brow_ips;
 214                 }
 215                 *server_name = strdup(inet_ntoa(opt_dest_ip));
 216         } else if (!(flags & NET_FLAGS_LOCALHOST_DEFAULT_INSANE)) {
 217                 extern struct in_addr loopback_ip;
 218                 *server_ip = loopback_ip;
 219                 *server_name = strdup("127.0.0.1");
 220         }
 221
 222         if (!server_name || !*server_name) {
 223                 DEBUG(1,("no server to connect to\n"));
 224                 return False;
 225         }
 226
 227         return True;
 228 }
 229
 230
 231 BOOL net_find_dc(struct in_addr *server_ip, fstring server_name, const char *domain_name)
 232 {
 233         if (get_pdc_ip(domain_name, server_ip)) {
 234                 fstring dc_name;
 235
 236                 if (is_zero_ip(*server_ip))
 237                         return False;
 238
 239                 if (!lookup_dc_name(global_myname(), domain_name, server_ip, dc_name))
 240                         return False;
 241
 242                 fstrcpy(server_name, dc_name);
 243                 return True;
 244         } else
 245                 return False;
 246 }
 247
 248
 249 struct cli_state *net_make_ipc_connection(unsigned flags)
 250 {
 251         char *server_name = NULL;
 252         struct in_addr server_ip;
 253         struct cli_state *cli = NULL;
 254         NTSTATUS nt_status;
 255
 256         if (!net_find_server(flags, &server_ip, &server_name)) {
 257                 d_printf("\nUnable to find a suitable server\n");
 258                 return NULL;
 259         }
 260
 261         if (flags & NET_FLAGS_ANONYMOUS) {
 262                 nt_status = connect_to_ipc_anonymous(&cli, &server_ip, server_name);
 263         } else {
 264                 nt_status = connect_to_ipc(&cli, &server_ip, server_name);
 265         }
 266
 267         SAFE_FREE(server_name);
 268         if (NT_STATUS_IS_OK(nt_status)) {
 269                 return cli;
 270         } else {
 271                 return NULL;
 272         }
 273 }
 274
 275 static int net_user(int argc, const char **argv)
 276 {
 277         if (net_ads_check() == 0)
 278                 return net_ads_user(argc, argv);
 279
 280         /* if server is not specified, default to PDC? */
 281         if (net_rpc_check(NET_FLAGS_PDC))
 282                 return net_rpc_user(argc, argv);
 283
 284         return net_rap_user(argc, argv);
 285 }
 286
 287 static int net_group(int argc, const char **argv)
 288 {
 289         if (net_ads_check() == 0)
 290                 return net_ads_group(argc, argv);
 291
 292         if (argc == 0 && net_rpc_check(NET_FLAGS_PDC))
 293                 return net_rpc_group(argc, argv);
 294
 295         return net_rap_group(argc, argv);
 296 }
 297
 298 static int net_join(int argc, const char **argv)
 299 {
 300         if (net_ads_check() == 0) {
 301                 if (net_ads_join(argc, argv) == 0)
 302                         return 0;
 303                 else
 304                         d_printf("ADS join did not work, trying RPC...\n");
 305         }
 306         return net_rpc_join(argc, argv);
 307 }
 308
 309 static int net_share(int argc, const char **argv)
 310 {
 311         if (net_rpc_check(0))
 312                 return net_rpc_share(argc, argv);
 313         return net_rap_share(argc, argv);
 314 }
 315
 316 static int net_file(int argc, const char **argv)
 317 {
 318         if (net_rpc_check(0))
 319                 return net_rpc_file(argc, argv);
 320         return net_rap_file(argc, argv);
 321 }
 322
 323 /*
 324  Retrieve our local SID or the SID for the specified name
 325  */
 326 static int net_getlocalsid(int argc, const char **argv)
 327 {
 328         DOM_SID sid;
 329         const char *name;
 330         fstring sid_str;
 331
 332         if (argc >= 1) {
 333                 name = argv[0];
 334         }
 335         else {
 336                 name = global_myname();
 337         }
 338
 339         if (!secrets_fetch_domain_sid(name, &sid)) {
 340                 DEBUG(0, ("Can't fetch domain SID for name: %s\n", name));
 341                 return 1;
 342         }
 343         sid_to_string(sid_str, &sid);
 344         d_printf("SID for domain %s is: %s\n", name, sid_str);
 345         return 0;
 346 }
 347
 348 static int net_setlocalsid(int argc, const char **argv)
 349 {
 350         DOM_SID sid;
 351
 352         if ( (argc != 1)
 353              || (strncmp(argv[0], "S-1-5-21-", strlen("S-1-5-21-")) != 0)
 354              || (!string_to_sid(&sid, argv[0]))
 355              || (sid.num_auths != 4)) {
 356                 d_printf("usage: net setlocalsid S-1-5-21-x-y-z\n");
 357                 return 1;
 358         }
 359
 360         if (!secrets_store_domain_sid(global_myname(), &sid)) {
 361                 DEBUG(0,("Can't store domain SID as a pdc/bdc.\n"));
 362                 return 1;
 363         }
 364
 365         return 0;
 366 }
 367
 368 static int net_getdomainsid(int argc, const char **argv)
 369 {
 370         DOM_SID domain_sid;
 371         fstring sid_str;
 372
 373         if (!secrets_fetch_domain_sid(global_myname(), &domain_sid)) {
 374                 d_printf("Could not fetch local SID\n");
 375                 return 1;
 376         }
 377         sid_to_string(sid_str, &domain_sid);
 378         d_printf("SID for domain %s is: %s\n", global_myname(), sid_str);
 379
 380         if (!secrets_fetch_domain_sid(lp_workgroup(), &domain_sid)) {
 381                 d_printf("Could not fetch domain SID\n");
 382                 return 1;
 383         }
 384
 385         sid_to_string(sid_str, &domain_sid);
 386         d_printf("SID for domain %s is: %s\n", lp_workgroup(), sid_str);
 387
 388         return 0;
 389 }
 390
 391 static uint32 get_maxrid(void)
 392 {
 393         SAM_ACCOUNT *pwd = NULL;
 394         uint32 max_rid = 0;
 395         GROUP_MAP *map = NULL;
 396         int num_entries = 0;
 397         int i;
 398
 399         if (!pdb_setsampwent(False)) {
 400                 DEBUG(0, ("load_sampwd_entries: Unable to open passdb.\n"));
 401                 return 0;
 402         }
 403
 404         for (; (NT_STATUS_IS_OK(pdb_init_sam(&pwd)))
 405                      && pdb_getsampwent(pwd) == True; pwd=NULL) {
 406                 uint32 rid;
 407
 408                 if (!sid_peek_rid(pdb_get_user_sid(pwd), &rid)) {
 409                         DEBUG(0, ("can't get RID for user '%s'\n",
 410                                   pdb_get_username(pwd)));
 411                         pdb_free_sam(&pwd);
 412                         continue;
 413                 }
 414
 415                 if (rid > max_rid)
 416                         max_rid = rid;
 417
 418                 DEBUG(1,("%d is user '%s'\n", rid, pdb_get_username(pwd)));
 419                 pdb_free_sam(&pwd);
 420         }
 421
 422         pdb_endsampwent();
 423         pdb_free_sam(&pwd);
 424
 425         if (!pdb_enum_group_mapping(SID_NAME_UNKNOWN, &map, &num_entries,
 426                                     ENUM_ONLY_MAPPED, MAPPING_WITHOUT_PRIV))
 427                 return max_rid;
 428
 429         for (i = 0; i < num_entries; i++) {
 430                 uint32 rid;
 431
 432                 if (!sid_peek_check_rid(get_global_sam_sid(), &map[i].sid,
 433                                         &rid)) {
 434                         DEBUG(3, ("skipping map for group '%s', SID %s\n",
 435                                   map[i].nt_name,
 436                                   sid_string_static(&map[i].sid)));
 437                         continue;
 438                 }
 439                 DEBUG(1,("%d is group '%s'\n", rid, map[i].nt_name));
 440
 441                 if (rid > max_rid)
 442                         max_rid = rid;
 443         }
 444
 445         SAFE_FREE(map);
 446
 447         return max_rid;
 448 }
 449
 450 static int net_maxrid(int argc, const char **argv)
 451 {
 452         uint32 rid;
 453
 454         if (argc != 0) {
 455                 DEBUG(0, ("usage: net initrid\n"));
 456                 return 1;
 457         }
 458
 459         if ((rid = get_maxrid()) == 0) {
 460                 DEBUG(0, ("can't get current maximum rid\n"));
 461                 return 1;
 462         }
 463
 464         d_printf("Currently used maximum rid: %d\n", rid);
 465
 466         return 0;
 467 }
 468
 469 /* main function table */
 470 static struct functable net_func[] = {
 471         {"RPC", net_rpc},
 472         {"RAP", net_rap},
 473         {"ADS", net_ads},
 474
 475         /* eventually these should auto-choose the transport ... */
 476         {"FILE", net_file},
 477         {"SHARE", net_share},
 478         {"SESSION", net_rap_session},
 479         {"SERVER", net_rap_server},
 480         {"DOMAIN", net_rap_domain},
 481         {"PRINTQ", net_rap_printq},
 482         {"USER", net_user},
 483         {"GROUP", net_group},
 484         {"VALIDATE", net_rap_validate},
 485         {"GROUPMEMBER", net_rap_groupmember},
 486         {"ADMIN", net_rap_admin},
 487         {"SERVICE", net_rap_service},
 488         {"PASSWORD", net_rap_password},
 489         {"TIME", net_time},
 490         {"LOOKUP", net_lookup},
 491         {"JOIN", net_join},
 492         {"CACHE", net_cache},
 493         {"GETLOCALSID", net_getlocalsid},
 494         {"SETLOCALSID", net_setlocalsid},
 495         {"GETDOMAINSID", net_getdomainsid},
 496         {"MAXRID", net_maxrid},
 497
 498         {"HELP", net_help},
 499         {NULL, NULL}
 500 };
 501
 502
 503 /****************************************************************************
 504   main program
 505 ****************************************************************************/
 506  int main(int argc, const char **argv)
 507 {
 508         int opt,i;
 509         char *p;
 510         int rc = 0;
 511         int argc_new = 0;
 512         const char ** argv_new;
 513         poptContext pc;
 514
 515         struct poptOption long_options[] = {
 516                 {"help",        'h', POPT_ARG_NONE,   0, 'h'},
 517                 {"workgroup",   'w', POPT_ARG_STRING, &opt_target_workgroup},
 518                 {"myworkgroup", 'W', POPT_ARG_STRING, &opt_workgroup},
 519                 {"user",        'U', POPT_ARG_STRING, &opt_user_name, 'U'},
 520                 {"ipaddress",   'I', POPT_ARG_STRING, 0,'I'},
 521                 {"port",        'p', POPT_ARG_INT,    &opt_port},
 522                 {"myname",      'n', POPT_ARG_STRING, &opt_requester_name},
 523                 {"server",      'S', POPT_ARG_STRING, &opt_host},
 524                 {"container",   'c', POPT_ARG_STRING, &opt_container},
 525                 {"comment",     'C', POPT_ARG_STRING, &opt_comment},
 526                 {"maxusers",    'M', POPT_ARG_INT,    &opt_maxusers},
 527                 {"flags",       'F', POPT_ARG_INT,    &opt_flags},
 528                 {"jobid",       'j', POPT_ARG_INT,    &opt_jobid},
 529                 {"long",        'l', POPT_ARG_NONE,   &opt_long_list_entries},
 530                 {"reboot",      'r', POPT_ARG_NONE,   &opt_reboot},
 531                 {"force",       'f', POPT_ARG_NONE,   &opt_force},
 532                 {"timeout",     't', POPT_ARG_INT,    &opt_timeout},
 533                 {"machine-pass",'P', POPT_ARG_NONE,   &opt_machine_pass},
 534                 POPT_COMMON_SAMBA
 535                 { NULL, 0, POPT_ARG_INCLUDE_TABLE, popt_common_debug },
 536                 { NULL, 0, POPT_ARG_INCLUDE_TABLE, popt_common_configfile },
 537                 { 0, 0, 0, 0}
 538         };
 539
 540         zero_ip(&opt_dest_ip);
 541
 542         dbf = x_stderr;
 543
 544         pc = poptGetContext(NULL, argc, (const char **) argv, long_options,
 545                             POPT_CONTEXT_KEEP_FIRST);
 546
 547         while((opt = poptGetNextOpt(pc)) != -1) {
 548                 switch (opt) {
 549                 case 'h':
 550                         net_help(argc, argv);
 551                         exit(0);
 552                         break;
 553                 case 'I':
 554                         opt_dest_ip = *interpret_addr2(poptGetOptArg(pc));
 555                         if (is_zero_ip(opt_dest_ip))
 556                                 d_printf("\nInvalid ip address specified\n");
 557                         else
 558                                 opt_have_ip = True;
 559                         break;
 560                 case 'U':
 561                         opt_user_specified = True;
 562                         opt_user_name = strdup(opt_user_name);
 563                         p = strchr(opt_user_name,'%');
 564                         if (p) {
 565                                 *p = 0;
 566                                 opt_password = p+1;
 567                         }
 568                         break;
 569                 default:
 570                         d_printf("\nInvalid option %s: %s\n",
 571                                  poptBadOption(pc, 0), poptStrerror(opt));
 572                         net_help(argc, argv);
 573                         exit(1);
 574                 }
 575         }
 576
 577         lp_load(dyn_CONFIGFILE,True,False,False);
 578
 579         argv_new = (const char **)poptGetArgs(pc);
 580
 581         argc_new = argc;
 582         for (i=0; i<argc; i++) {
 583                 if (argv_new[i] == NULL) {
 584                         argc_new = i;
 585                         break;
 586                 }
 587         }
 588
 589         if (!opt_requester_name) {
 590                 static fstring myname;
 591                 get_myname(myname);
 592                 opt_requester_name = myname;
 593         }
 594
 595         if (!opt_user_name && getenv("LOGNAME")) {
 596                 opt_user_name = getenv("LOGNAME");
 597         }
 598
 599         if (!opt_workgroup) {
 600                 opt_workgroup = lp_workgroup();
 601         }
 602
 603         if (!opt_target_workgroup) {
 604                 opt_target_workgroup = strdup(lp_workgroup());
 605         }
 606
 607         if (!init_names())
 608                 exit(1);
 609
 610         load_interfaces();
 611
 612         if (opt_machine_pass) {
 613                 char *user;
 614                 /* it is very useful to be able to make ads queries as the
 615                    machine account for testing purposes and for domain leave */
 616
 617                 if (!secrets_init()) {
 618                         d_printf("ERROR: Unable to open secrets database\n");
 619                         exit(1);
 620                 }
 621
 622                 asprintf(&user,"%s$", global_myname());
 623                 opt_user_name = user;
 624                 opt_password = secrets_fetch_machine_password();
 625                 if (!opt_password) {
 626                         d_printf("ERROR: Unable to fetch machine password\n");
 627                         exit(1);
 628                 }
 629         }
 630
 631         if (!opt_password) {
 632                 opt_password = getenv("PASSWD");
 633         }
 634
 635         rc = net_run_function(argc_new-1, argv_new+1, net_func, net_help);
 636
 637         DEBUG(2,("return code = %d\n", rc));
 638         return rc;
 639 }