source3/lib/popt_common.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Common popt routines
   4
   5    Copyright (C) Tim Potter 2001,2002
   6    Copyright (C) Jelmer Vernooij 2002,2003
   7    Copyright (C) James Peach 2006
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 #include "includes.h"
  24 #include "popt_common.h"
  25
  26 /* Handle command line options:
  27  *              -d,--debuglevel
  28  *              -s,--configfile
  29  *              -O,--socket-options
  30  *              -V,--version
  31  *              -l,--log-base
  32  *              -n,--netbios-name
  33  *              -W,--workgroup
  34  *              -i,--scope
  35  */
  36
  37 enum {OPT_OPTION=1};
  38
  39 extern bool override_logfile;
  40
  41 static void set_logfile(poptContext con, const char * arg)
  42 {
  43
  44         char *lfile = NULL;
  45         const char *pname;
  46
  47         /* Find out basename of current program */
  48         pname = strrchr_m(poptGetInvocationName(con),'/');
  49
  50         if (!pname)
  51                 pname = poptGetInvocationName(con);
  52         else
  53                 pname++;
  54
  55         if (asprintf(&lfile, "%s/log.%s", arg, pname) < 0) {
  56                 return;
  57         }
  58         lp_set_logfile(lfile);
  59         SAFE_FREE(lfile);
  60 }
  61
  62 static bool PrintSambaVersionString;
  63
  64 static void popt_s3_talloc_log_fn(const char *message)
  65 {
  66         DEBUG(0,("%s", message));
  67 }
  68
  69 static void popt_common_callback(poptContext con,
  70                            enum poptCallbackReason reason,
  71                            const struct poptOption *opt,
  72                            const char *arg, const void *data)
  73 {
  74
  75         if (reason == POPT_CALLBACK_REASON_PRE) {
  76                 set_logfile(con, get_dyn_LOGFILEBASE());
  77                 talloc_set_log_fn(popt_s3_talloc_log_fn);
  78                 talloc_set_abort_fn(smb_panic);
  79                 return;
  80         }
  81
  82         if (reason == POPT_CALLBACK_REASON_POST) {
  83
  84                 if (PrintSambaVersionString) {
  85                         printf( "Version %s\n", samba_version_string());
  86                         exit(0);
  87                 }
  88
  89                 if (is_default_dyn_CONFIGFILE()) {
  90                         if(getenv("SMB_CONF_PATH")) {
  91                                 set_dyn_CONFIGFILE(getenv("SMB_CONF_PATH"));
  92                         }
  93                 }
  94
  95                 /* Further 'every Samba program must do this' hooks here. */
  96                 return;
  97         }
  98
  99         switch(opt->val) {
 100         case OPT_OPTION:
 101                 if (!lp_set_option(arg)) {
 102                         fprintf(stderr, "Error setting option '%s'\n", arg);
 103                         exit(1);
 104                 }
 105                 break;
 106
 107         case 'd':
 108                 if (arg) {
 109                         lp_set_cmdline("log level", arg);
 110                 }
 111                 break;
 112
 113         case 'V':
 114                 PrintSambaVersionString = True;
 115                 break;
 116
 117         case 'O':
 118                 if (arg) {
 119                         lp_do_parameter(-1, "socket options", arg);
 120                 }
 121                 break;
 122
 123         case 's':
 124                 if (arg) {
 125                         set_dyn_CONFIGFILE(arg);
 126                 }
 127                 break;
 128
 129         case 'n':
 130                 if (arg) {
 131                         set_global_myname(arg);
 132                 }
 133                 break;
 134
 135         case 'l':
 136                 if (arg) {
 137                         set_logfile(con, arg);
 138                         override_logfile = True;
 139                         set_dyn_LOGFILEBASE(arg);
 140                 }
 141                 break;
 142
 143         case 'i':
 144                 if (arg) {
 145                           set_global_scope(arg);
 146                 }
 147                 break;
 148
 149         case 'W':
 150                 if (arg) {
 151                         set_global_myworkgroup(arg);
 152                 }
 153                 break;
 154         }
 155 }
 156
 157 struct poptOption popt_common_connection[] = {
 158         { NULL, 0, POPT_ARG_CALLBACK, (void *)popt_common_callback },
 159         { "socket-options", 'O', POPT_ARG_STRING, NULL, 'O', "socket options to use",
 160           "SOCKETOPTIONS" },
 161         { "netbiosname", 'n', POPT_ARG_STRING, NULL, 'n', "Primary netbios name", "NETBIOSNAME" },
 162         { "workgroup", 'W', POPT_ARG_STRING, NULL, 'W', "Set the workgroup name", "WORKGROUP" },
 163         { "scope", 'i', POPT_ARG_STRING, NULL, 'i', "Use this Netbios scope", "SCOPE" },
 164
 165         POPT_TABLEEND
 166 };
 167
 168 struct poptOption popt_common_samba[] = {
 169         { NULL, 0, POPT_ARG_CALLBACK|POPT_CBFLAG_PRE|POPT_CBFLAG_POST, (void *)popt_common_callback },
 170         { "debuglevel", 'd', POPT_ARG_STRING, NULL, 'd', "Set debug level", "DEBUGLEVEL" },
 171         { "configfile", 's', POPT_ARG_STRING, NULL, 's', "Use alternate configuration file", "CONFIGFILE" },
 172         { "log-basename", 'l', POPT_ARG_STRING, NULL, 'l', "Base name for log files", "LOGFILEBASE" },
 173         { "version", 'V', POPT_ARG_NONE, NULL, 'V', "Print version" },
 174         { "option",         0, POPT_ARG_STRING, NULL, OPT_OPTION, "Set smb.conf option from command line", "name=value" },
 175         POPT_TABLEEND
 176 };
 177
 178 struct poptOption popt_common_configfile[] = {
 179         { NULL, 0, POPT_ARG_CALLBACK|POPT_CBFLAG_PRE|POPT_CBFLAG_POST, (void *)popt_common_callback },
 180         { "configfile", 0, POPT_ARG_STRING, NULL, 's', "Use alternate configuration file", "CONFIGFILE" },
 181         POPT_TABLEEND
 182 };
 183
 184 struct poptOption popt_common_version[] = {
 185         { NULL, 0, POPT_ARG_CALLBACK|POPT_CBFLAG_POST, (void *)popt_common_callback },
 186         { "version", 'V', POPT_ARG_NONE, NULL, 'V', "Print version" },
 187         POPT_TABLEEND
 188 };
 189
 190 struct poptOption popt_common_debuglevel[] = {
 191         { NULL, 0, POPT_ARG_CALLBACK, (void *)popt_common_callback },
 192         { "debuglevel", 'd', POPT_ARG_STRING, NULL, 'd', "Set debug level", "DEBUGLEVEL" },
 193         POPT_TABLEEND
 194 };
 195
 196 struct poptOption popt_common_option[] = {
 197         { NULL, 0, POPT_ARG_CALLBACK|POPT_CBFLAG_POST, (void *)popt_common_callback },
 198         { "option",         0, POPT_ARG_STRING, NULL, OPT_OPTION, "Set smb.conf option from command line", "name=value" },
 199         POPT_TABLEEND
 200 };
 201
 202 /* Handle command line options:
 203  *              --sbindir
 204  *              --bindir
 205  *              --swatdir
 206  *              --lmhostsfile
 207  *              --libdir
 208  *              --modulesdir
 209  *              --shlibext
 210  *              --lockdir
 211  *              --statedir
 212  *              --cachedir
 213  *              --piddir
 214  *              --smb-passwd-file
 215  *              --private-dir
 216  */
 217
 218 enum dyn_item{
 219         DYN_SBINDIR = 1,
 220         DYN_BINDIR,
 221         DYN_SWATDIR,
 222         DYN_LMHOSTSFILE,
 223         DYN_LIBDIR,
 224         DYN_MODULESDIR,
 225         DYN_SHLIBEXT,
 226         DYN_LOCKDIR,
 227         DYN_STATEDIR,
 228         DYN_CACHEDIR,
 229         DYN_PIDDIR,
 230         DYN_SMB_PASSWD_FILE,
 231         DYN_PRIVATE_DIR,
 232 };
 233
 234
 235 static void popt_dynconfig_callback(poptContext con,
 236                            enum poptCallbackReason reason,
 237                            const struct poptOption *opt,
 238                            const char *arg, const void *data)
 239 {
 240
 241         switch (opt->val) {
 242         case DYN_SBINDIR:
 243                 if (arg) {
 244                         set_dyn_SBINDIR(arg);
 245                 }
 246                 break;
 247
 248         case DYN_BINDIR:
 249                 if (arg) {
 250                         set_dyn_BINDIR(arg);
 251                 }
 252                 break;
 253
 254         case DYN_SWATDIR:
 255                 if (arg) {
 256                         set_dyn_SWATDIR(arg);
 257                 }
 258                 break;
 259
 260         case DYN_LMHOSTSFILE:
 261                 if (arg) {
 262                         set_dyn_LMHOSTSFILE(arg);
 263                 }
 264                 break;
 265
 266         case DYN_LIBDIR:
 267                 if (arg) {
 268                         set_dyn_LIBDIR(arg);
 269                 }
 270                 break;
 271
 272         case DYN_MODULESDIR:
 273                 if (arg) {
 274                         set_dyn_MODULESDIR(arg);
 275                 }
 276                 break;
 277
 278         case DYN_SHLIBEXT:
 279                 if (arg) {
 280                         set_dyn_SHLIBEXT(arg);
 281                 }
 282                 break;
 283
 284         case DYN_LOCKDIR:
 285                 if (arg) {
 286                         set_dyn_LOCKDIR(arg);
 287                 }
 288                 break;
 289
 290         case DYN_STATEDIR:
 291                 if (arg) {
 292                         set_dyn_STATEDIR(arg);
 293                 }
 294                 break;
 295
 296         case DYN_CACHEDIR:
 297                 if (arg) {
 298                         set_dyn_CACHEDIR(arg);
 299                 }
 300                 break;
 301
 302         case DYN_PIDDIR:
 303                 if (arg) {
 304                         set_dyn_PIDDIR(arg);
 305                 }
 306                 break;
 307
 308         case DYN_SMB_PASSWD_FILE:
 309                 if (arg) {
 310                         set_dyn_SMB_PASSWD_FILE(arg);
 311                 }
 312                 break;
 313
 314         case DYN_PRIVATE_DIR:
 315                 if (arg) {
 316                         set_dyn_PRIVATE_DIR(arg);
 317                 }
 318                 break;
 319
 320         }
 321 }
 322
 323 const struct poptOption popt_common_dynconfig[] = {
 324
 325         { NULL, '\0', POPT_ARG_CALLBACK, (void *)popt_dynconfig_callback },
 326
 327         { "sbindir", '\0' , POPT_ARG_STRING, NULL, DYN_SBINDIR,
 328             "Path to sbin directory", "SBINDIR" },
 329         { "bindir", '\0' , POPT_ARG_STRING, NULL, DYN_BINDIR,
 330             "Path to bin directory", "BINDIR" },
 331         { "swatdir", '\0' , POPT_ARG_STRING, NULL, DYN_SWATDIR,
 332             "Path to SWAT installation directory", "SWATDIR" },
 333         { "lmhostsfile", '\0' , POPT_ARG_STRING, NULL, DYN_LMHOSTSFILE,
 334             "Path to lmhosts file", "LMHOSTSFILE" },
 335         { "libdir", '\0' , POPT_ARG_STRING, NULL, DYN_LIBDIR,
 336             "Path to shared library directory", "LIBDIR" },
 337         { "modulesdir", '\0' , POPT_ARG_STRING, NULL, DYN_MODULESDIR,
 338             "Path to shared modules directory", "MODULESDIR" },
 339         { "shlibext", '\0' , POPT_ARG_STRING, NULL, DYN_SHLIBEXT,
 340             "Shared library extension", "SHLIBEXT" },
 341         { "lockdir", '\0' , POPT_ARG_STRING, NULL, DYN_LOCKDIR,
 342             "Path to lock file directory", "LOCKDIR" },
 343         { "statedir", '\0' , POPT_ARG_STRING, NULL, DYN_STATEDIR,
 344             "Path to persistent state file directory", "STATEDIR" },
 345         { "cachedir", '\0' , POPT_ARG_STRING, NULL, DYN_CACHEDIR,
 346             "Path to temporary cache file directory", "CACHEDIR" },
 347         { "piddir", '\0' , POPT_ARG_STRING, NULL, DYN_PIDDIR,
 348             "Path to PID file directory", "PIDDIR" },
 349         { "smb-passwd-file", '\0' , POPT_ARG_STRING, NULL, DYN_SMB_PASSWD_FILE,
 350             "Path to smbpasswd file", "SMB_PASSWD_FILE" },
 351         { "private-dir", '\0' , POPT_ARG_STRING, NULL, DYN_PRIVATE_DIR,
 352             "Path to private data directory", "PRIVATE_DIR" },
 353
 354         POPT_TABLEEND
 355 };
 356
 357 /****************************************************************************
 358  * get a password from a a file or file descriptor
 359  * exit on failure
 360  * ****************************************************************************/
 361
 362 static void get_password_file(struct user_auth_info *auth_info)
 363 {
 364         int fd = -1;
 365         char *p;
 366         bool close_it = False;
 367         char *spec = NULL;
 368         char pass[128];
 369
 370         if ((p = getenv("PASSWD_FD")) != NULL) {
 371                 if (asprintf(&spec, "descriptor %s", p) < 0) {
 372                         return;
 373                 }
 374                 sscanf(p, "%d", &fd);
 375                 close_it = false;
 376         } else if ((p = getenv("PASSWD_FILE")) != NULL) {
 377                 fd = sys_open(p, O_RDONLY, 0);
 378                 spec = SMB_STRDUP(p);
 379                 if (fd < 0) {
 380                         fprintf(stderr, "Error opening PASSWD_FILE %s: %s\n",
 381                                         spec, strerror(errno));
 382                         exit(1);
 383                 }
 384                 close_it = True;
 385         }
 386
 387         if (fd < 0) {
 388                 fprintf(stderr, "fd = %d, < 0\n", fd);
 389                 exit(1);
 390         }
 391
 392         for(p = pass, *p = '\0'; /* ensure that pass is null-terminated */
 393                 p && p - pass < sizeof(pass);) {
 394                 switch (read(fd, p, 1)) {
 395                 case 1:
 396                         if (*p != '\n' && *p != '\0') {
 397                                 *++p = '\0'; /* advance p, and null-terminate pass */
 398                                 break;
 399                         }
 400                 case 0:
 401                         if (p - pass) {
 402                                 *p = '\0'; /* null-terminate it, just in case... */
 403                                 p = NULL; /* then force the loop condition to become false */
 404                                 break;
 405                         } else {
 406                                 fprintf(stderr, "Error reading password from file %s: %s\n",
 407                                                 spec, "empty password\n");
 408                                 SAFE_FREE(spec);
 409                                 exit(1);
 410                         }
 411
 412                 default:
 413                         fprintf(stderr, "Error reading password from file %s: %s\n",
 414                                         spec, strerror(errno));
 415                         SAFE_FREE(spec);
 416                         exit(1);
 417                 }
 418         }
 419         SAFE_FREE(spec);
 420
 421         set_cmdline_auth_info_password(auth_info, pass);
 422         if (close_it) {
 423                 close(fd);
 424         }
 425 }
 426
 427 static void get_credentials_file(struct user_auth_info *auth_info,
 428                                  const char *file)
 429 {
 430         XFILE *auth;
 431         fstring buf;
 432         uint16 len = 0;
 433         char *ptr, *val, *param;
 434
 435         if ((auth=x_fopen(file, O_RDONLY, 0)) == NULL)
 436         {
 437                 /* fail if we can't open the credentials file */
 438                 d_printf("ERROR: Unable to open credentials file!\n");
 439                 exit(-1);
 440         }
 441
 442         while (!x_feof(auth))
 443         {
 444                 /* get a line from the file */
 445                 if (!x_fgets(buf, sizeof(buf), auth))
 446                         continue;
 447                 len = strlen(buf);
 448
 449                 if ((len) && (buf[len-1]=='\n'))
 450                 {
 451                         buf[len-1] = '\0';
 452                         len--;
 453                 }
 454                 if (len == 0)
 455                         continue;
 456
 457                 /* break up the line into parameter & value.
 458                  * will need to eat a little whitespace possibly */
 459                 param = buf;
 460                 if (!(ptr = strchr_m (buf, '=')))
 461                         continue;
 462
 463                 val = ptr+1;
 464                 *ptr = '\0';
 465
 466                 /* eat leading white space */
 467                 while ((*val!='\0') && ((*val==' ') || (*val=='\t')))
 468                         val++;
 469
 470                 if (strwicmp("password", param) == 0) {
 471                         set_cmdline_auth_info_password(auth_info, val);
 472                 } else if (strwicmp("username", param) == 0) {
 473                         set_cmdline_auth_info_username(auth_info, val);
 474                 } else if (strwicmp("domain", param) == 0) {
 475                         set_global_myworkgroup(val);
 476                 }
 477                 memset(buf, 0, sizeof(buf));
 478         }
 479         x_fclose(auth);
 480 }
 481
 482 /* Handle command line options:
 483  *              -U,--user
 484  *              -A,--authentication-file
 485  *              -k,--use-kerberos
 486  *              -N,--no-pass
 487  *              -S,--signing
 488  *              -P --machine-pass
 489  *              -e --encrypt
 490  *              -C --use-ccache
 491  */
 492
 493
 494 static void popt_common_credentials_callback(poptContext con,
 495                                         enum poptCallbackReason reason,
 496                                         const struct poptOption *opt,
 497                                         const char *arg, const void *data)
 498 {
 499         struct user_auth_info *auth_info = talloc_get_type_abort(
 500                 *((const char **)data), struct user_auth_info);
 501         char *p;
 502
 503         if (reason == POPT_CALLBACK_REASON_PRE) {
 504                 set_cmdline_auth_info_username(auth_info, "GUEST");
 505
 506                 if (getenv("LOGNAME")) {
 507                         set_cmdline_auth_info_username(auth_info,
 508                                                        getenv("LOGNAME"));
 509                 }
 510
 511                 if (getenv("USER")) {
 512                         char *puser = SMB_STRDUP(getenv("USER"));
 513                         if (!puser) {
 514                                 exit(ENOMEM);
 515                         }
 516                         set_cmdline_auth_info_username(auth_info, puser);
 517
 518                         if ((p = strchr_m(puser,'%'))) {
 519                                 size_t len;
 520                                 *p = 0;
 521                                 len = strlen(p+1);
 522                                 set_cmdline_auth_info_password(auth_info, p+1);
 523                                 memset(strchr_m(getenv("USER"),'%')+1,'X',len);
 524                         }
 525                         SAFE_FREE(puser);
 526                 }
 527
 528                 if (getenv("PASSWD")) {
 529                         set_cmdline_auth_info_password(auth_info,
 530                                                        getenv("PASSWD"));
 531                 }
 532
 533                 if (getenv("PASSWD_FD") || getenv("PASSWD_FILE")) {
 534                         get_password_file(auth_info);
 535                 }
 536
 537                 return;
 538         }
 539
 540         switch(opt->val) {
 541         case 'U':
 542                 {
 543                         char *lp;
 544                         char *puser = SMB_STRDUP(arg);
 545
 546                         if ((lp=strchr_m(puser,'%'))) {
 547                                 size_t len;
 548                                 *lp = 0;
 549                                 set_cmdline_auth_info_username(auth_info,
 550                                                                puser);
 551                                 set_cmdline_auth_info_password(auth_info,
 552                                                                lp+1);
 553                                 len = strlen(lp+1);
 554                                 memset(strchr_m(arg,'%')+1,'X',len);
 555                         } else {
 556                                 set_cmdline_auth_info_username(auth_info,
 557                                                                puser);
 558                         }
 559                         SAFE_FREE(puser);
 560                 }
 561                 break;
 562
 563         case 'A':
 564                 get_credentials_file(auth_info, arg);
 565                 break;
 566
 567         case 'k':
 568 #ifndef HAVE_KRB5
 569                 d_printf("No kerberos support compiled in\n");
 570                 exit(1);
 571 #else
 572                 set_cmdline_auth_info_use_krb5_ticket(auth_info);
 573 #endif
 574                 break;
 575
 576         case 'S':
 577                 if (!set_cmdline_auth_info_signing_state(auth_info, arg)) {
 578                         fprintf(stderr, "Unknown signing option %s\n", arg );
 579                         exit(1);
 580                 }
 581                 break;
 582         case 'P':
 583                 set_cmdline_auth_info_use_machine_account(auth_info);
 584                 break;
 585         case 'N':
 586                 set_cmdline_auth_info_password(auth_info, "");
 587                 break;
 588         case 'e':
 589                 set_cmdline_auth_info_smb_encrypt(auth_info);
 590                 break;
 591         case 'C':
 592                 set_cmdline_auth_info_use_ccache(auth_info, true);
 593                 break;
 594         }
 595 }
 596
 597 static struct user_auth_info *global_auth_info;
 598
 599 void popt_common_set_auth_info(struct user_auth_info *auth_info)
 600 {
 601         global_auth_info = auth_info;
 602 }
 603
 604 struct poptOption popt_common_credentials[] = {
 605         { NULL, 0, POPT_ARG_CALLBACK|POPT_CBFLAG_PRE,
 606           (void *)popt_common_credentials_callback, 0,
 607           (const char *)&global_auth_info },
 608         { "user", 'U', POPT_ARG_STRING, NULL, 'U', "Set the network username", "USERNAME" },
 609         { "no-pass", 'N', POPT_ARG_NONE, NULL, 'N', "Don't ask for a password" },
 610         { "kerberos", 'k', POPT_ARG_NONE, NULL, 'k', "Use kerberos (active directory) authentication" },
 611         { "authentication-file", 'A', POPT_ARG_STRING, NULL, 'A', "Get the credentials from a file", "FILE" },
 612         { "signing", 'S', POPT_ARG_STRING, NULL, 'S', "Set the client signing state", "on|off|required" },
 613         {"machine-pass", 'P', POPT_ARG_NONE, NULL, 'P', "Use stored machine account password" },
 614         {"encrypt", 'e', POPT_ARG_NONE, NULL, 'e', "Encrypt SMB transport (UNIX extended servers only)" },
 615         {"use-ccache", 'C', POPT_ARG_NONE, NULL, 'C',
 616          "Use the winbind ccache for authentication" },
 617         POPT_TABLEEND
 618 };