2002-07-29 13:23:01 +04:00
/*
Unix SMB / CIFS implementation .
Common popt routines
Copyright ( C ) Tim Potter 2001 , 2002
2003-04-14 07:30:20 +04:00
Copyright ( C ) Jelmer Vernooij 2002 , 2003
2006-05-24 08:02:14 +04:00
Copyright ( C ) James Peach 2006
2002-07-29 13:23:01 +04:00
This program is free software ; you can redistribute it and / or modify
it under the terms of the GNU General Public License as published by
2007-07-09 23:25:36 +04:00
the Free Software Foundation ; either version 3 of the License , or
2002-07-29 13:23:01 +04:00
( at your option ) any later version .
This program is distributed in the hope that it will be useful ,
but WITHOUT ANY WARRANTY ; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
GNU General Public License for more details .
You should have received a copy of the GNU General Public License
2007-07-10 04:52:41 +04:00
along with this program . If not , see < http : //www.gnu.org/licenses/>.
2002-07-29 13:23:01 +04:00
*/
# include "includes.h"
2002-10-28 22:44:11 +03:00
/* Handle command line options:
2003-04-14 07:30:20 +04:00
* - d , - - debuglevel
* - s , - - configfile
* - O , - - socket - options
* - V , - - version
* - l , - - log - base
* - n , - - netbios - name
* - W , - - workgroup
* - i , - - scope
2002-10-28 22:44:11 +03:00
*/
2002-07-29 13:23:01 +04:00
2007-10-19 04:40:25 +04:00
extern bool AllowDebugChange ;
extern bool override_logfile ;
2002-10-28 22:44:11 +03:00
2006-05-24 08:02:14 +04:00
static void set_logfile ( poptContext con , const char * arg )
2002-07-29 13:23:01 +04:00
{
2006-05-24 08:02:14 +04:00
2007-11-16 01:19:52 +03:00
char * logfile = NULL ;
2002-11-09 19:57:45 +03:00
const char * pname ;
2007-11-16 01:19:52 +03:00
2002-11-09 19:57:45 +03:00
/* Find out basename of current program */
pname = strrchr_m ( poptGetInvocationName ( con ) , ' / ' ) ;
if ( ! pname )
pname = poptGetInvocationName ( con ) ;
2007-11-16 01:19:52 +03:00
else
2002-11-09 19:57:45 +03:00
pname + + ;
2007-11-16 01:19:52 +03:00
if ( asprintf ( & logfile , " %s/log.%s " , arg , pname ) < 0 ) {
return ;
}
2006-05-24 08:02:14 +04:00
lp_set_logfile ( logfile ) ;
2007-11-16 01:19:52 +03:00
SAFE_FREE ( logfile ) ;
2006-05-24 08:02:14 +04:00
}
2007-10-19 04:40:25 +04:00
static bool PrintSambaVersionString ;
2007-08-22 15:55:48 +04:00
2006-05-24 08:02:14 +04:00
static void popt_common_callback ( poptContext con ,
enum poptCallbackReason reason ,
const struct poptOption * opt ,
const char * arg , const void * data )
{
2002-11-09 19:57:45 +03:00
if ( reason = = POPT_CALLBACK_REASON_PRE ) {
2007-12-10 22:30:37 +03:00
set_logfile ( con , get_dyn_LOGFILEBASE ( ) ) ;
2002-11-09 19:57:45 +03:00
return ;
}
2007-08-22 15:55:48 +04:00
if ( reason = = POPT_CALLBACK_REASON_POST ) {
2008-02-04 18:16:59 +03:00
if ( PrintSambaVersionString ) {
printf ( " Version %s \n " , SAMBA_VERSION_STRING ) ;
exit ( 0 ) ;
}
if ( is_default_dyn_CONFIGFILE ( ) ) {
if ( getenv ( " SMB_CONF_PATH " ) ) {
set_dyn_CONFIGFILE ( getenv ( " SMB_CONF_PATH " ) ) ;
}
}
/* Further 'every Samba program must do this' hooks here. */
2007-08-22 15:55:48 +04:00
return ;
}
2002-07-29 13:23:01 +04:00
switch ( opt - > val ) {
case ' d ' :
if ( arg ) {
2002-09-25 19:19:00 +04:00
debug_parse_levels ( arg ) ;
2002-07-29 13:23:01 +04:00
AllowDebugChange = False ;
}
2002-10-28 22:44:11 +03:00
break ;
2002-07-29 13:23:01 +04:00
2002-10-28 22:44:11 +03:00
case ' V ' :
2007-08-22 15:55:48 +04:00
PrintSambaVersionString = True ;
2002-10-28 22:44:11 +03:00
break ;
case ' O ' :
2002-11-09 19:57:45 +03:00
if ( arg ) {
2007-11-01 20:13:00 +03:00
lp_do_parameter ( - 1 , " socket options " , arg ) ;
2002-11-09 19:57:45 +03:00
}
2002-10-28 22:44:11 +03:00
break ;
case ' s ' :
2002-11-09 19:57:45 +03:00
if ( arg ) {
2007-12-10 22:30:37 +03:00
set_dyn_CONFIGFILE ( arg ) ;
2002-11-09 19:57:45 +03:00
}
2002-10-28 22:44:11 +03:00
break ;
case ' n ' :
2002-11-09 19:57:45 +03:00
if ( arg ) {
2002-11-13 02:20:50 +03:00
set_global_myname ( arg ) ;
2002-11-09 19:57:45 +03:00
}
break ;
case ' l ' :
if ( arg ) {
2006-05-24 08:02:14 +04:00
set_logfile ( con , arg ) ;
2006-06-05 17:00:24 +04:00
override_logfile = True ;
2007-12-10 22:30:37 +03:00
set_dyn_LOGFILEBASE ( arg ) ;
2002-11-09 19:57:45 +03:00
}
2002-07-29 13:23:01 +04:00
break ;
2003-04-14 07:30:20 +04:00
case ' i ' :
if ( arg ) {
set_global_scope ( arg ) ;
}
break ;
case ' W ' :
if ( arg ) {
set_global_myworkgroup ( arg ) ;
}
break ;
2002-07-29 13:23:01 +04:00
}
}
2003-04-14 07:30:20 +04:00
struct poptOption popt_common_connection [ ] = {
2006-07-11 22:01:26 +04:00
{ NULL , 0 , POPT_ARG_CALLBACK , ( void * ) popt_common_callback } ,
2003-04-14 07:30:20 +04:00
{ " socket-options " , ' O ' , POPT_ARG_STRING , NULL , ' O ' , " socket options to use " ,
" SOCKETOPTIONS " } ,
{ " netbiosname " , ' n ' , POPT_ARG_STRING , NULL , ' n ' , " Primary netbios name " , " NETBIOSNAME " } ,
{ " workgroup " , ' W ' , POPT_ARG_STRING , NULL , ' W ' , " Set the workgroup name " , " WORKGROUP " } ,
{ " scope " , ' i ' , POPT_ARG_STRING , NULL , ' i ' , " Use this Netbios scope " , " SCOPE " } ,
2003-08-14 05:08:00 +04:00
2003-04-14 07:30:20 +04:00
POPT_TABLEEND
2002-07-29 13:23:01 +04:00
} ;
2002-10-28 22:44:11 +03:00
2003-04-14 07:30:20 +04:00
struct poptOption popt_common_samba [ ] = {
2007-08-22 15:55:48 +04:00
{ NULL , 0 , POPT_ARG_CALLBACK | POPT_CBFLAG_PRE | POPT_CBFLAG_POST , ( void * ) popt_common_callback } ,
2003-04-14 07:30:20 +04:00
{ " debuglevel " , ' d ' , POPT_ARG_STRING , NULL , ' d ' , " Set debug level " , " DEBUGLEVEL " } ,
2006-05-24 08:02:14 +04:00
{ " configfile " , ' s ' , POPT_ARG_STRING , NULL , ' s ' , " Use alternate configuration file " , " CONFIGFILE " } ,
{ " log-basename " , ' l ' , POPT_ARG_STRING , NULL , ' l ' , " Base name for log files " , " LOGFILEBASE " } ,
2003-04-14 07:30:20 +04:00
{ " version " , ' V ' , POPT_ARG_NONE , NULL , ' V ' , " Print version " } ,
POPT_TABLEEND
2002-10-28 22:44:11 +03:00
} ;
2007-12-14 21:36:14 +03:00
struct poptOption popt_common_configfile [ ] = {
{ NULL , 0 , POPT_ARG_CALLBACK | POPT_CBFLAG_PRE | POPT_CBFLAG_POST , ( void * ) popt_common_callback } ,
{ " configfile " , 0 , POPT_ARG_STRING , NULL , ' s ' , " Use alternate configuration file " , " CONFIGFILE " } ,
POPT_TABLEEND
} ;
2002-10-28 22:44:11 +03:00
struct poptOption popt_common_version [ ] = {
2006-07-11 22:01:26 +04:00
{ NULL , 0 , POPT_ARG_CALLBACK , ( void * ) popt_common_callback } ,
2003-04-14 07:30:20 +04:00
{ " version " , ' V ' , POPT_ARG_NONE , NULL , ' V ' , " Print version " } ,
POPT_TABLEEND
2002-10-28 22:44:11 +03:00
} ;
2002-11-09 19:57:45 +03:00
2006-05-24 08:02:14 +04:00
/* Handle command line options:
* - - sbindir
* - - bindir
* - - swatdir
* - - lmhostsfile
* - - libdir
* - - shlibext
* - - lockdir
* - - piddir
* - - smb - passwd - file
* - - private - dir
*/
enum dyn_item {
DYN_SBINDIR = 1 ,
DYN_BINDIR ,
DYN_SWATDIR ,
DYN_LMHOSTSFILE ,
DYN_LIBDIR ,
DYN_SHLIBEXT ,
DYN_LOCKDIR ,
DYN_PIDDIR ,
DYN_SMB_PASSWD_FILE ,
DYN_PRIVATE_DIR ,
} ;
static void popt_dynconfig_callback ( poptContext con ,
enum poptCallbackReason reason ,
const struct poptOption * opt ,
const char * arg , const void * data )
{
switch ( opt - > val ) {
case DYN_SBINDIR :
if ( arg ) {
2007-12-10 22:30:37 +03:00
set_dyn_SBINDIR ( arg ) ;
2006-05-24 08:02:14 +04:00
}
break ;
case DYN_BINDIR :
if ( arg ) {
2007-12-10 22:30:37 +03:00
set_dyn_BINDIR ( arg ) ;
2006-05-24 08:02:14 +04:00
}
break ;
case DYN_SWATDIR :
if ( arg ) {
2007-12-10 22:30:37 +03:00
set_dyn_SWATDIR ( arg ) ;
2006-05-24 08:02:14 +04:00
}
break ;
case DYN_LMHOSTSFILE :
if ( arg ) {
2007-12-10 22:30:37 +03:00
set_dyn_LMHOSTSFILE ( arg ) ;
2006-05-24 08:02:14 +04:00
}
break ;
case DYN_LIBDIR :
if ( arg ) {
2007-12-10 22:30:37 +03:00
set_dyn_LIBDIR ( arg ) ;
2006-05-24 08:02:14 +04:00
}
break ;
case DYN_SHLIBEXT :
if ( arg ) {
2007-12-10 22:30:37 +03:00
set_dyn_SHLIBEXT ( arg ) ;
2006-05-24 08:02:14 +04:00
}
break ;
case DYN_LOCKDIR :
if ( arg ) {
2007-12-10 22:30:37 +03:00
set_dyn_LOCKDIR ( arg ) ;
2006-05-24 08:02:14 +04:00
}
break ;
case DYN_PIDDIR :
if ( arg ) {
2007-12-10 22:30:37 +03:00
set_dyn_PIDDIR ( arg ) ;
2006-05-24 08:02:14 +04:00
}
break ;
case DYN_SMB_PASSWD_FILE :
if ( arg ) {
2007-12-10 22:30:37 +03:00
set_dyn_SMB_PASSWD_FILE ( arg ) ;
2006-05-24 08:02:14 +04:00
}
break ;
case DYN_PRIVATE_DIR :
if ( arg ) {
2007-12-10 22:30:37 +03:00
set_dyn_PRIVATE_DIR ( arg ) ;
2006-05-24 08:02:14 +04:00
}
break ;
}
}
const struct poptOption popt_common_dynconfig [ ] = {
2006-07-11 22:01:26 +04:00
{ NULL , ' \0 ' , POPT_ARG_CALLBACK , ( void * ) popt_dynconfig_callback } ,
2006-05-24 08:02:14 +04:00
{ " sbindir " , ' \0 ' , POPT_ARG_STRING , NULL , DYN_SBINDIR ,
" Path to sbin directory " , " SBINDIR " } ,
{ " bindir " , ' \0 ' , POPT_ARG_STRING , NULL , DYN_BINDIR ,
" Path to bin directory " , " BINDIR " } ,
{ " swatdir " , ' \0 ' , POPT_ARG_STRING , NULL , DYN_SWATDIR ,
" Path to SWAT installation directory " , " SWATDIR " } ,
{ " lmhostsfile " , ' \0 ' , POPT_ARG_STRING , NULL , DYN_LMHOSTSFILE ,
" Path to lmhosts file " , " LMHOSTSFILE " } ,
{ " libdir " , ' \0 ' , POPT_ARG_STRING , NULL , DYN_LIBDIR ,
" Path to shared library directory " , " LIBDIR " } ,
{ " shlibext " , ' \0 ' , POPT_ARG_STRING , NULL , DYN_SHLIBEXT ,
" Shared library extension " , " SHLIBEXT " } ,
{ " lockdir " , ' \0 ' , POPT_ARG_STRING , NULL , DYN_LOCKDIR ,
" Path to lock file directory " , " LOCKDIR " } ,
{ " piddir " , ' \0 ' , POPT_ARG_STRING , NULL , DYN_PIDDIR ,
" Path to PID file directory " , " PIDDIR " } ,
{ " smb-passwd-file " , ' \0 ' , POPT_ARG_STRING , NULL , DYN_SMB_PASSWD_FILE ,
" Path to smbpasswd file " , " SMB_PASSWD_FILE " } ,
{ " private-dir " , ' \0 ' , POPT_ARG_STRING , NULL , DYN_PRIVATE_DIR ,
" Path to private data directory " , " PRIVATE_DIR " } ,
POPT_TABLEEND
} ;
2003-04-14 07:30:20 +04:00
/****************************************************************************
* get a password from a a file or file descriptor
* exit on failure
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-11-16 01:19:52 +03:00
2007-12-07 04:16:33 +03:00
static void get_password_file ( void )
2003-04-14 07:30:20 +04:00
{
int fd = - 1 ;
char * p ;
2007-10-19 04:40:25 +04:00
bool close_it = False ;
2007-11-16 01:19:52 +03:00
char * spec = NULL ;
2003-04-14 07:30:20 +04:00
char pass [ 128 ] ;
if ( ( p = getenv ( " PASSWD_FD " ) ) ! = NULL ) {
2007-11-16 01:19:52 +03:00
if ( asprintf ( & spec , " descriptor %s " , p ) < 0 ) {
return ;
}
2003-04-14 07:30:20 +04:00
sscanf ( p , " %d " , & fd ) ;
2007-11-16 01:19:52 +03:00
close_it = false ;
2003-04-14 07:30:20 +04:00
} else if ( ( p = getenv ( " PASSWD_FILE " ) ) ! = NULL ) {
fd = sys_open ( p , O_RDONLY , 0 ) ;
2007-11-16 01:19:52 +03:00
spec = SMB_STRDUP ( p ) ;
2003-04-14 07:30:20 +04:00
if ( fd < 0 ) {
fprintf ( stderr , " Error opening PASSWD_FILE %s: %s \n " ,
spec , strerror ( errno ) ) ;
exit ( 1 ) ;
}
close_it = True ;
}
2008-03-23 17:56:41 +03:00
if ( fd < 0 ) {
fprintf ( stderr , " fd = %d, < 0 \n " , fd ) ;
exit ( 1 ) ;
}
2003-04-14 07:30:20 +04:00
for ( p = pass , * p = ' \0 ' ; /* ensure that pass is null-terminated */
p & & p - pass < sizeof ( pass ) ; ) {
switch ( read ( fd , p , 1 ) ) {
case 1 :
if ( * p ! = ' \n ' & & * p ! = ' \0 ' ) {
* + + p = ' \0 ' ; /* advance p, and null-terminate pass */
break ;
}
case 0 :
if ( p - pass ) {
* p = ' \0 ' ; /* null-terminate it, just in case... */
p = NULL ; /* then force the loop condition to become false */
break ;
} else {
fprintf ( stderr , " Error reading password from file %s: %s \n " ,
spec , " empty password \n " ) ;
2007-11-16 01:19:52 +03:00
SAFE_FREE ( spec ) ;
2003-04-14 07:30:20 +04:00
exit ( 1 ) ;
}
default :
fprintf ( stderr , " Error reading password from file %s: %s \n " ,
spec , strerror ( errno ) ) ;
2007-11-16 01:19:52 +03:00
SAFE_FREE ( spec ) ;
2003-04-14 07:30:20 +04:00
exit ( 1 ) ;
}
}
2007-11-16 01:19:52 +03:00
SAFE_FREE ( spec ) ;
2007-12-07 04:16:33 +03:00
set_cmdline_auth_info_password ( pass ) ;
if ( close_it ) {
2003-04-14 07:30:20 +04:00
close ( fd ) ;
2007-12-07 04:16:33 +03:00
}
2003-04-14 07:30:20 +04:00
}
2007-12-07 04:22:57 +03:00
static void get_credentials_file ( const char * file )
2003-04-14 07:30:20 +04:00
{
XFILE * auth ;
fstring buf ;
uint16 len = 0 ;
char * ptr , * val , * param ;
if ( ( auth = x_fopen ( file , O_RDONLY , 0 ) ) = = NULL )
{
/* fail if we can't open the credentials file */
d_printf ( " ERROR: Unable to open credentials file! \n " ) ;
exit ( - 1 ) ;
}
while ( ! x_feof ( auth ) )
{
/* get a line from the file */
if ( ! x_fgets ( buf , sizeof ( buf ) , auth ) )
continue ;
len = strlen ( buf ) ;
if ( ( len ) & & ( buf [ len - 1 ] = = ' \n ' ) )
{
buf [ len - 1 ] = ' \0 ' ;
len - - ;
}
if ( len = = 0 )
continue ;
/* break up the line into parameter & value.
* will need to eat a little whitespace possibly */
param = buf ;
if ( ! ( ptr = strchr_m ( buf , ' = ' ) ) )
continue ;
val = ptr + 1 ;
* ptr = ' \0 ' ;
/* eat leading white space */
while ( ( * val ! = ' \0 ' ) & & ( ( * val = = ' ' ) | | ( * val = = ' \t ' ) ) )
val + + ;
2007-12-07 04:16:33 +03:00
if ( strwicmp ( " password " , param ) = = 0 ) {
2007-12-07 04:22:57 +03:00
set_cmdline_auth_info_password ( val ) ;
2007-12-07 04:16:33 +03:00
} else if ( strwicmp ( " username " , param ) = = 0 ) {
2007-12-07 04:22:57 +03:00
set_cmdline_auth_info_username ( val ) ;
2007-12-07 04:16:33 +03:00
} else if ( strwicmp ( " domain " , param ) = = 0 ) {
2003-04-14 07:30:20 +04:00
set_global_myworkgroup ( val ) ;
2007-12-07 04:16:33 +03:00
}
2003-04-14 07:30:20 +04:00
memset ( buf , 0 , sizeof ( buf ) ) ;
}
x_fclose ( auth ) ;
}
/* Handle command line options:
* - U , - - user
* - A , - - authentication - file
* - k , - - use - kerberos
* - N , - - no - pass
2003-07-31 03:49:29 +04:00
* - S , - - signing
2003-08-14 05:08:00 +04:00
* - P - - machine - pass
2008-01-05 11:23:35 +03:00
* - e - - encrypt
2003-04-14 07:30:20 +04:00
*/
2007-12-07 04:16:33 +03:00
static void popt_common_credentials_callback ( poptContext con ,
2003-07-31 03:49:29 +04:00
enum poptCallbackReason reason ,
const struct poptOption * opt ,
const char * arg , const void * data )
2003-04-14 07:30:20 +04:00
{
char * p ;
if ( reason = = POPT_CALLBACK_REASON_PRE ) {
2007-12-07 04:16:33 +03:00
set_cmdline_auth_info_username ( " GUEST " ) ;
2003-04-14 07:30:20 +04:00
2007-12-07 04:16:33 +03:00
if ( getenv ( " LOGNAME " ) ) {
set_cmdline_auth_info_username ( getenv ( " LOGNAME " ) ) ;
}
2003-04-14 07:30:20 +04:00
if ( getenv ( " USER " ) ) {
2007-12-07 04:16:33 +03:00
char * puser = SMB_STRDUP ( getenv ( " USER " ) ) ;
if ( ! puser ) {
exit ( ENOMEM ) ;
}
set_cmdline_auth_info_username ( puser ) ;
2003-04-14 07:30:20 +04:00
2007-12-07 04:16:33 +03:00
if ( ( p = strchr_m ( puser , ' % ' ) ) ) {
2007-12-07 05:49:39 +03:00
size_t len ;
2003-04-14 07:30:20 +04:00
* p = 0 ;
2007-12-07 05:49:39 +03:00
len = strlen ( p + 1 ) ;
2007-12-07 04:16:33 +03:00
set_cmdline_auth_info_password ( p + 1 ) ;
2007-12-07 05:49:39 +03:00
memset ( strchr_m ( getenv ( " USER " ) , ' % ' ) + 1 , ' X ' , len ) ;
2003-04-14 07:30:20 +04:00
}
2007-12-07 04:16:33 +03:00
SAFE_FREE ( puser ) ;
2003-04-14 07:30:20 +04:00
}
if ( getenv ( " PASSWD " ) ) {
2007-12-07 04:16:33 +03:00
set_cmdline_auth_info_password ( getenv ( " PASSWD " ) ) ;
2003-04-14 07:30:20 +04:00
}
if ( getenv ( " PASSWD_FD " ) | | getenv ( " PASSWD_FILE " ) ) {
2007-12-07 04:22:57 +03:00
get_password_file ( ) ;
2003-04-14 07:30:20 +04:00
}
return ;
}
switch ( opt - > val ) {
case ' U ' :
{
char * lp ;
2007-12-07 05:49:39 +03:00
char * puser = SMB_STRDUP ( arg ) ;
2003-04-14 07:30:20 +04:00
2007-12-07 05:49:39 +03:00
if ( ( lp = strchr_m ( puser , ' % ' ) ) ) {
size_t len ;
2003-04-14 07:30:20 +04:00
* lp = 0 ;
2007-12-07 05:49:39 +03:00
set_cmdline_auth_info_username ( puser ) ;
set_cmdline_auth_info_password ( lp + 1 ) ;
len = strlen ( lp + 1 ) ;
memset ( strchr_m ( arg , ' % ' ) + 1 , ' X ' , len ) ;
} else {
set_cmdline_auth_info_username ( puser ) ;
2003-04-14 07:30:20 +04:00
}
2007-12-07 05:49:39 +03:00
SAFE_FREE ( puser ) ;
2003-04-14 07:30:20 +04:00
}
break ;
case ' A ' :
2007-12-07 04:16:33 +03:00
get_credentials_file ( arg ) ;
2003-04-14 07:30:20 +04:00
break ;
case ' k ' :
# ifndef HAVE_KRB5
d_printf ( " No kerberos support compiled in \n " ) ;
exit ( 1 ) ;
# else
2007-12-07 05:49:39 +03:00
set_cmdline_auth_info_use_krb5_ticket ( ) ;
2003-04-14 07:30:20 +04:00
# endif
break ;
2003-07-31 03:49:29 +04:00
case ' S ' :
2007-12-07 05:49:39 +03:00
if ( ! set_cmdline_auth_info_signing_state ( arg ) ) {
fprintf ( stderr , " Unknown signing option %s \n " , arg ) ;
exit ( 1 ) ;
2003-07-31 03:49:29 +04:00
}
break ;
2003-08-14 05:08:00 +04:00
case ' P ' :
{
char * opt_password = NULL ;
2007-12-07 04:16:33 +03:00
char * pwd = NULL ;
2003-08-14 05:08:00 +04:00
/* it is very useful to be able to make ads queries as the
machine account for testing purposes and for domain leave */
2007-12-07 04:16:33 +03:00
2003-08-14 05:08:00 +04:00
if ( ! secrets_init ( ) ) {
d_printf ( " ERROR: Unable to open secrets database \n " ) ;
exit ( 1 ) ;
}
2007-12-07 04:16:33 +03:00
2003-08-14 05:08:00 +04:00
opt_password = secrets_fetch_machine_password ( lp_workgroup ( ) , NULL , NULL ) ;
2007-12-07 04:16:33 +03:00
2003-08-14 05:08:00 +04:00
if ( ! opt_password ) {
d_printf ( " ERROR: Unable to fetch machine password \n " ) ;
exit ( 1 ) ;
}
2007-12-07 04:16:33 +03:00
if ( asprintf ( & pwd , " %s$ " , global_myname ( ) ) < 0 ) {
exit ( ENOMEM ) ;
}
set_cmdline_auth_info_username ( pwd ) ;
set_cmdline_auth_info_password ( opt_password ) ;
SAFE_FREE ( pwd ) ;
2003-08-14 05:08:00 +04:00
SAFE_FREE ( opt_password ) ;
/* machine accounts only work with kerberos */
2007-12-07 05:49:39 +03:00
set_cmdline_auth_info_use_krb5_ticket ( ) ;
2003-08-14 05:08:00 +04:00
}
break ;
2007-12-07 05:49:39 +03:00
case ' N ' :
2007-12-07 06:15:56 +03:00
set_cmdline_auth_info_password ( " " ) ;
2007-12-07 05:49:39 +03:00
break ;
2008-01-05 11:23:35 +03:00
case ' e ' :
set_cmdline_auth_info_smb_encrypt ( ) ;
break ;
2003-04-14 07:30:20 +04:00
}
}
struct poptOption popt_common_credentials [ ] = {
2006-07-11 22:01:26 +04:00
{ NULL , 0 , POPT_ARG_CALLBACK | POPT_CBFLAG_PRE , ( void * ) popt_common_credentials_callback } ,
2003-04-14 07:30:20 +04:00
{ " user " , ' U ' , POPT_ARG_STRING , NULL , ' U ' , " Set the network username " , " USERNAME " } ,
2007-12-07 06:06:34 +03:00
{ " no-pass " , ' N ' , POPT_ARG_NONE , NULL , ' N ' , " Don't ask for a password " } ,
2007-12-07 05:49:39 +03:00
{ " kerberos " , ' k ' , POPT_ARG_NONE , NULL , ' k ' , " Use kerberos (active directory) authentication " } ,
2003-04-14 07:30:20 +04:00
{ " authentication-file " , ' A ' , POPT_ARG_STRING , NULL , ' A ' , " Get the credentials from a file " , " FILE " } ,
2003-07-31 03:49:29 +04:00
{ " signing " , ' S ' , POPT_ARG_STRING , NULL , ' S ' , " Set the client signing state " , " on|off|required " } ,
2003-08-14 05:08:00 +04:00
{ " machine-pass " , ' P ' , POPT_ARG_NONE , NULL , ' P ' , " Use stored machine account password " } ,
2008-01-05 11:23:35 +03:00
{ " encrypt " , ' e ' , POPT_ARG_NONE , NULL , ' e ' , " Encrypt SMB transport (UNIX extended servers only) " } ,
2003-04-14 07:30:20 +04:00
POPT_TABLEEND
2002-11-09 19:57:45 +03:00
} ;