1998-09-26 01:01:52 +04:00
/*
2002-01-30 09:08:46 +03:00
Unix SMB / CIFS implementation .
2001-01-12 01:49:30 +03:00
RPC pipe client
2001-08-28 01:32:06 +04:00
Copyright ( C ) Tim Potter 2000 - 2001
2001-01-12 01:49:30 +03:00
1998-09-26 01:01:52 +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
the Free Software Foundation ; either version 2 of the License , or
( 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
along with this program ; if not , write to the Free Software
Foundation , Inc . , 675 Mass Ave , Cambridge , MA 0213 9 , USA .
*/
# include "includes.h"
2001-10-12 09:56:23 +04:00
# include "rpcclient.h"
2001-01-12 01:49:30 +03:00
2001-05-24 04:20:32 +04:00
DOM_SID domain_sid ;
2001-01-16 02:35:59 +03:00
2001-04-28 04:32:56 +04:00
/* List to hold groups of commands */
2001-05-24 04:20:32 +04:00
2001-04-28 04:32:56 +04:00
static struct cmd_list {
struct cmd_list * prev , * next ;
struct cmd_set * cmd_set ;
} * cmd_list ;
/****************************************************************************
handle completion of commands for readline
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static char * * completion_fn ( char * text , int start , int end )
{
# define MAX_COMPLETIONS 100
char * * matches ;
int i , count = 0 ;
struct cmd_list * commands = cmd_list ;
#if 0 /* JERRY */
/* FIXME!!! -- what to do when completing argument? */
/* for words not at the start of the line fallback
to filename completion */
if ( start )
return NULL ;
# endif
/* make sure we have a list of valid commands */
if ( ! commands )
return NULL ;
matches = ( char * * ) malloc ( sizeof ( matches [ 0 ] ) * MAX_COMPLETIONS ) ;
if ( ! matches ) return NULL ;
matches [ count + + ] = strdup ( text ) ;
if ( ! matches [ 0 ] ) return NULL ;
while ( commands & & count < MAX_COMPLETIONS - 1 )
{
if ( ! commands - > cmd_set )
break ;
for ( i = 0 ; commands - > cmd_set [ i ] . name ; i + + )
{
if ( ( strncmp ( text , commands - > cmd_set [ i ] . name , strlen ( text ) ) = = 0 ) & &
commands - > cmd_set [ i ] . fn )
{
matches [ count ] = strdup ( commands - > cmd_set [ i ] . name ) ;
if ( ! matches [ count ] )
return NULL ;
count + + ;
}
}
commands = commands - > next ;
}
if ( count = = 2 ) {
2001-09-17 14:26:23 +04:00
SAFE_FREE ( matches [ 0 ] ) ;
2001-04-28 04:32:56 +04:00
matches [ 0 ] = strdup ( matches [ 1 ] ) ;
}
matches [ count ] = NULL ;
return matches ;
}
2001-03-16 01:06:53 +03:00
/***********************************************************************
* read in username / password credentials from a file
*/
static void read_authfile (
char * filename ,
char * username ,
char * password ,
char * domain
)
{
FILE * auth ;
fstring buf ;
uint16 len = 0 ;
char * ptr , * val , * param ;
if ( ( auth = sys_fopen ( filename , " r " ) ) = = NULL )
{
printf ( " ERROR: Unable to open credentials file! \n " ) ;
return ;
}
while ( ! feof ( auth ) )
{
/* get a line from the file */
if ( ! fgets ( buf , sizeof ( buf ) , auth ) )
continue ;
len = strlen ( buf ) ;
/* skip empty lines */
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 ;
2001-07-04 11:39:01 +04:00
if ( ! ( ptr = strchr_m ( buf , ' = ' ) ) )
2001-03-16 01:06:53 +03:00
continue ;
val = ptr + 1 ;
* ptr = ' \0 ' ;
/* eat leading white space */
while ( ( * val ! = ' \0 ' ) & & ( ( * val = = ' ' ) | | ( * val = = ' \t ' ) ) )
val + + ;
if ( strwicmp ( " password " , param ) = = 0 )
fstrcpy ( password , val ) ;
else if ( strwicmp ( " username " , param ) = = 0 )
fstrcpy ( username , val ) ;
else if ( strwicmp ( " domain " , param ) = = 0 )
fstrcpy ( domain , val ) ;
memset ( buf , 0 , sizeof ( buf ) ) ;
}
fclose ( auth ) ;
return ;
}
2001-05-31 22:35:14 +04:00
static char * next_command ( char * * cmdstr )
{
static pstring command ;
char * p ;
if ( ! cmdstr | | ! ( * cmdstr ) )
return NULL ;
2001-07-04 11:36:09 +04:00
p = strchr_m ( * cmdstr , ' ; ' ) ;
2001-05-31 22:35:14 +04:00
if ( p )
* p = ' \0 ' ;
pstrcpy ( command , * cmdstr ) ;
* cmdstr = p ;
return command ;
}
2001-03-16 01:06:53 +03:00
static void get_username ( char * username )
{
if ( getenv ( " USER " ) )
pstrcpy ( username , getenv ( " USER " ) ) ;
if ( * username = = 0 & & getenv ( " LOGNAME " ) )
pstrcpy ( username , getenv ( " LOGNAME " ) ) ;
if ( * username = = 0 ) {
pstrcpy ( username , " GUEST " ) ;
}
return ;
}
2001-01-16 02:35:59 +03:00
2001-10-22 10:13:38 +04:00
/* Fetch the SID for this computer */
2001-07-20 08:38:58 +04:00
2001-10-22 10:13:38 +04:00
void fetch_machine_sid ( struct cli_state * cli )
2001-01-16 02:35:59 +03:00
{
POLICY_HND pol ;
2001-09-04 11:13:01 +04:00
NTSTATUS result = NT_STATUS_OK ;
uint32 info_class = 5 ;
2001-01-16 02:35:59 +03:00
fstring domain_name ;
static BOOL got_domain_sid ;
2001-04-28 04:32:56 +04:00
TALLOC_CTX * mem_ctx ;
2001-01-16 02:35:59 +03:00
if ( got_domain_sid ) return ;
2001-04-28 04:32:56 +04:00
if ( ! ( mem_ctx = talloc_init ( ) ) )
{
DEBUG ( 0 , ( " fetch_domain_sid: talloc_init returned NULL! \n " ) ) ;
goto error ;
}
2001-01-16 02:35:59 +03:00
2001-03-14 23:22:57 +03:00
if ( ! cli_nt_session_open ( cli , PIPE_LSARPC ) ) {
2001-01-16 02:35:59 +03:00
fprintf ( stderr , " could not initialise lsa pipe \n " ) ;
goto error ;
}
2001-03-14 23:22:57 +03:00
2001-09-04 11:13:01 +04:00
result = cli_lsa_open_policy ( cli , mem_ctx , True ,
SEC_RIGHTS_MAXIMUM_ALLOWED ,
& pol ) ;
if ( ! NT_STATUS_IS_OK ( result ) ) {
2001-01-16 02:35:59 +03:00
goto error ;
}
2001-09-04 11:13:01 +04:00
result = cli_lsa_query_info_policy ( cli , mem_ctx , & pol , info_class ,
domain_name , & domain_sid ) ;
if ( ! NT_STATUS_IS_OK ( result ) ) {
2001-01-16 02:35:59 +03:00
goto error ;
}
got_domain_sid = True ;
2001-04-28 04:32:56 +04:00
cli_lsa_close ( cli , mem_ctx , & pol ) ;
2001-03-14 23:22:57 +03:00
cli_nt_session_close ( cli ) ;
2001-04-28 04:32:56 +04:00
talloc_destroy ( mem_ctx ) ;
2001-01-16 02:35:59 +03:00
return ;
error :
2001-03-16 01:06:53 +03:00
fprintf ( stderr , " could not obtain sid for domain %s \n " , cli - > domain ) ;
2001-01-16 02:35:59 +03:00
2001-09-04 11:13:01 +04:00
if ( ! NT_STATUS_IS_OK ( result ) ) {
2002-03-17 07:36:35 +03:00
fprintf ( stderr , " error: %s \n " , nt_errstr ( result ) ) ;
2001-01-16 02:35:59 +03:00
}
exit ( 1 ) ;
}
2001-01-12 01:49:30 +03:00
2001-07-20 08:38:58 +04:00
/* Display help on commands */
2001-10-12 09:56:23 +04:00
static NTSTATUS cmd_help ( struct cli_state * cli , TALLOC_CTX * mem_ctx ,
int argc , char * * argv )
2001-01-12 01:49:30 +03:00
{
2001-07-20 08:38:58 +04:00
struct cmd_list * tmp ;
struct cmd_set * tmp_set ;
/* Usage */
if ( argc > 2 ) {
printf ( " Usage: %s [command] \n " , argv [ 0 ] ) ;
2001-09-15 07:57:12 +04:00
return NT_STATUS_OK ;
2001-07-20 08:38:58 +04:00
}
/* Help on one command */
if ( argc = = 2 ) {
for ( tmp = cmd_list ; tmp ; tmp = tmp - > next ) {
tmp_set = tmp - > cmd_set ;
while ( tmp_set - > name ) {
if ( strequal ( argv [ 1 ] , tmp_set - > name ) ) {
if ( tmp_set - > usage & &
tmp_set - > usage [ 0 ] )
printf ( " %s \n " , tmp_set - > usage ) ;
else
printf ( " No help for %s \n " , tmp_set - > name ) ;
2001-09-15 07:57:12 +04:00
return NT_STATUS_OK ;
2001-07-20 08:38:58 +04:00
}
tmp_set + + ;
}
}
2001-01-12 01:49:30 +03:00
2001-07-20 08:38:58 +04:00
printf ( " No such command: %s \n " , argv [ 1 ] ) ;
2001-09-15 07:57:12 +04:00
return NT_STATUS_OK ;
2001-07-20 08:38:58 +04:00
}
/* List all commands */
for ( tmp = cmd_list ; tmp ; tmp = tmp - > next ) {
tmp_set = tmp - > cmd_set ;
while ( tmp_set - > name ) {
2001-01-12 01:49:30 +03:00
2001-07-20 08:38:58 +04:00
printf ( " %15s \t \t %s \n " , tmp_set - > name ,
2001-12-21 04:16:37 +03:00
tmp_set - > description ? tmp_set - > description :
" " ) ;
2001-07-20 08:38:58 +04:00
tmp_set + + ;
2001-01-12 01:49:30 +03:00
}
}
2001-09-15 07:57:12 +04:00
return NT_STATUS_OK ;
2001-01-12 01:49:30 +03:00
}
2001-07-20 08:38:58 +04:00
/* Change the debug level */
2001-10-12 09:56:23 +04:00
static NTSTATUS cmd_debuglevel ( struct cli_state * cli , TALLOC_CTX * mem_ctx ,
int argc , char * * argv )
2001-01-12 01:49:30 +03:00
{
if ( argc > 2 ) {
printf ( " Usage: %s [debuglevel] \n " , argv [ 0 ] ) ;
2001-08-27 23:46:22 +04:00
return NT_STATUS_OK ;
2001-01-12 01:49:30 +03:00
}
if ( argc = = 2 ) {
DEBUGLEVEL = atoi ( argv [ 1 ] ) ;
}
printf ( " debuglevel is %d \n " , DEBUGLEVEL ) ;
2001-08-27 23:46:22 +04:00
return NT_STATUS_OK ;
2001-01-12 01:49:30 +03:00
}
2001-10-12 09:56:23 +04:00
static NTSTATUS cmd_quit ( struct cli_state * cli , TALLOC_CTX * mem_ctx ,
int argc , char * * argv )
2001-01-16 02:35:59 +03:00
{
exit ( 0 ) ;
2001-08-27 23:46:22 +04:00
return NT_STATUS_OK ; /* NOTREACHED */
2001-01-16 02:35:59 +03:00
}
2001-01-12 01:49:30 +03:00
/* Build in rpcclient commands */
static struct cmd_set rpcclient_commands [ ] = {
2001-07-20 08:38:58 +04:00
{ " GENERAL OPTIONS " } ,
2001-10-22 10:13:38 +04:00
{ " help " , cmd_help , NULL , " Get help on commands " , " [command] " } ,
{ " ? " , cmd_help , NULL , " Get help on commands " , " [command] " } ,
{ " debuglevel " , cmd_debuglevel , NULL , " Set debug level " , " level " } ,
{ " exit " , cmd_quit , NULL , " Exit program " , " " } ,
{ " quit " , cmd_quit , NULL , " Exit program " , " " } ,
2001-07-20 08:38:58 +04:00
{ NULL }
2001-01-12 01:49:30 +03:00
} ;
2001-03-15 05:15:05 +03:00
static struct cmd_set separator_command [ ] = {
2001-10-22 10:13:38 +04:00
{ " --------------- " , NULL , NULL , " ---------------------- " } ,
2001-07-20 08:38:58 +04:00
{ NULL }
2001-03-15 05:15:05 +03:00
} ;
2001-05-24 04:20:32 +04:00
/* Various pipe commands */
extern struct cmd_set lsarpc_commands [ ] ;
extern struct cmd_set samr_commands [ ] ;
extern struct cmd_set spoolss_commands [ ] ;
extern struct cmd_set netlogon_commands [ ] ;
extern struct cmd_set srvsvc_commands [ ] ;
2001-06-06 11:35:08 +04:00
extern struct cmd_set dfs_commands [ ] ;
2001-08-10 13:52:10 +04:00
extern struct cmd_set reg_commands [ ] ;
2001-05-24 04:20:32 +04:00
static struct cmd_set * rpcclient_command_list [ ] = {
rpcclient_commands ,
lsarpc_commands ,
samr_commands ,
spoolss_commands ,
netlogon_commands ,
srvsvc_commands ,
2001-06-06 11:35:08 +04:00
dfs_commands ,
2001-08-10 13:52:10 +04:00
reg_commands ,
2001-05-24 04:20:32 +04:00
NULL
} ;
2001-10-12 09:56:23 +04:00
static void add_command_set ( struct cmd_set * cmd_set )
2001-01-12 01:49:30 +03:00
{
struct cmd_list * entry ;
if ( ! ( entry = ( struct cmd_list * ) malloc ( sizeof ( struct cmd_list ) ) ) ) {
DEBUG ( 0 , ( " out of memory \n " ) ) ;
return ;
}
ZERO_STRUCTP ( entry ) ;
entry - > cmd_set = cmd_set ;
DLIST_ADD ( cmd_list , entry ) ;
}
2001-10-12 09:56:23 +04:00
static NTSTATUS do_cmd ( struct cli_state * cli , struct cmd_set * cmd_entry ,
char * cmd )
2001-01-12 01:49:30 +03:00
{
char * p = cmd , * * argv = NULL ;
2001-10-12 09:56:23 +04:00
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
2001-01-12 01:49:30 +03:00
pstring buf ;
2001-08-10 13:52:10 +04:00
int argc = 0 , i ;
2001-01-12 01:49:30 +03:00
/* Count number of arguments first time through the loop then
allocate memory and strdup them . */
again :
2001-08-10 13:52:10 +04:00
while ( next_token ( & p , buf , " " , sizeof ( buf ) ) ) {
2001-01-12 01:49:30 +03:00
if ( argv ) {
argv [ argc ] = strdup ( buf ) ;
}
argc + + ;
}
if ( ! argv ) {
/* Create argument list */
argv = ( char * * ) malloc ( sizeof ( char * ) * argc ) ;
2001-10-12 09:56:23 +04:00
memset ( argv , 0 , sizeof ( char * ) * argc ) ;
2001-01-12 21:19:57 +03:00
2001-01-12 01:49:30 +03:00
if ( ! argv ) {
2001-08-10 13:52:10 +04:00
fprintf ( stderr , " out of memory \n " ) ;
2001-10-12 09:56:23 +04:00
result = NT_STATUS_NO_MEMORY ;
goto done ;
2001-01-12 01:49:30 +03:00
}
p = cmd ;
2001-08-10 13:52:10 +04:00
argc = 0 ;
2001-01-12 01:49:30 +03:00
goto again ;
}
/* Call the function */
2001-10-12 09:56:23 +04:00
2001-03-15 05:15:05 +03:00
if ( cmd_entry - > fn ) {
2001-10-12 09:56:23 +04:00
TALLOC_CTX * mem_ctx ;
/* Create mem_ctx */
if ( ! ( mem_ctx = talloc_init ( ) ) ) {
DEBUG ( 0 , ( " talloc_init() failed \n " ) ) ;
goto done ;
}
/* Open pipe */
if ( cmd_entry - > pipe )
if ( ! cli_nt_session_open ( cli , cmd_entry - > pipe ) ) {
DEBUG ( 0 , ( " Could not initialise %s \n " ,
cmd_entry - > pipe ) ) ;
goto done ;
}
/* Run command */
result = cmd_entry - > fn ( cli , mem_ctx , argc , argv ) ;
/* Cleanup */
if ( cmd_entry - > pipe )
cli_nt_session_close ( cli ) ;
talloc_destroy ( mem_ctx ) ;
} else {
2001-03-15 05:15:05 +03:00
fprintf ( stderr , " Invalid command \n " ) ;
2001-10-12 09:56:23 +04:00
goto done ;
}
2001-01-12 01:49:30 +03:00
2001-10-12 09:56:23 +04:00
done :
2001-03-15 05:15:05 +03:00
2001-01-12 01:49:30 +03:00
/* Cleanup */
2001-10-12 09:56:23 +04:00
if ( argv ) {
for ( i = 0 ; i < argc ; i + + )
SAFE_FREE ( argv [ i ] ) ;
2001-01-12 01:49:30 +03:00
2001-10-12 09:56:23 +04:00
SAFE_FREE ( argv ) ;
}
2001-01-12 01:49:30 +03:00
return result ;
}
/* Process a command entered at the prompt or as part of -c */
2001-09-04 11:13:01 +04:00
static NTSTATUS process_cmd ( struct cli_state * cli , char * cmd )
2001-01-12 01:49:30 +03:00
{
struct cmd_list * temp_list ;
BOOL found = False ;
pstring buf ;
char * p = cmd ;
2001-09-04 11:13:01 +04:00
NTSTATUS result = NT_STATUS_OK ;
2001-05-31 22:03:45 +04:00
int len = 0 ;
2001-01-12 01:49:30 +03:00
2001-05-04 08:15:48 +04:00
if ( cmd [ strlen ( cmd ) - 1 ] = = ' \n ' )
cmd [ strlen ( cmd ) - 1 ] = ' \0 ' ;
2001-08-10 13:52:10 +04:00
if ( ! next_token ( & p , buf , " " , sizeof ( buf ) ) ) {
2001-09-04 11:13:01 +04:00
return NT_STATUS_OK ;
2001-01-12 01:49:30 +03:00
}
2001-05-31 22:03:45 +04:00
/* strip the trainly \n if it exsists */
len = strlen ( buf ) ;
if ( buf [ len - 1 ] = = ' \n ' )
buf [ len - 1 ] = ' \0 ' ;
2001-01-12 01:49:30 +03:00
/* Search for matching commands */
for ( temp_list = cmd_list ; temp_list ; temp_list = temp_list - > next ) {
struct cmd_set * temp_set = temp_list - > cmd_set ;
while ( temp_set - > name ) {
if ( strequal ( buf , temp_set - > name ) ) {
2001-10-12 09:56:23 +04:00
found = True ;
2001-03-14 23:22:57 +03:00
result = do_cmd ( cli , temp_set , cmd ) ;
2001-10-12 09:56:23 +04:00
2001-01-12 01:49:30 +03:00
goto done ;
}
temp_set + + ;
}
}
done :
2001-01-12 21:19:57 +03:00
if ( ! found & & buf [ 0 ] ) {
2001-01-12 01:49:30 +03:00
printf ( " command not found: %s \n " , buf ) ;
2001-09-04 11:13:01 +04:00
return NT_STATUS_OK ;
2001-01-12 01:49:30 +03:00
}
2001-09-04 11:13:01 +04:00
if ( ! NT_STATUS_IS_OK ( result ) ) {
2002-03-17 07:36:35 +03:00
printf ( " result was %s \n " , nt_errstr ( result ) ) ;
2001-01-12 01:49:30 +03:00
}
return result ;
}
2001-03-14 23:22:57 +03:00
/* Print usage information */
2001-07-08 22:25:56 +04:00
static void usage ( void )
2001-01-12 01:49:30 +03:00
{
2001-08-28 01:32:06 +04:00
printf ( " Usage: rpcclient server [options] \n " ) ;
2001-01-12 01:49:30 +03:00
2002-03-07 21:56:51 +03:00
printf ( " \t -A or --authfile authfile file containing user credentials \n " ) ;
printf ( " \t -c or --command \" command string \" execute semicolon separated cmds \n " ) ;
printf ( " \t -d or --debug debuglevel set the debuglevel \n " ) ;
printf ( " \t -l or --logfile logfile logfile to use instead of stdout \n " ) ;
printf ( " \t -h or --help Print this help message. \n " ) ;
printf ( " \t -N or --nopass don't ask for a password \n " ) ;
printf ( " \t -s or --conf configfile specify an alternative config file \n " ) ;
printf ( " \t -U or --user username set the network username \n " ) ;
printf ( " \t -W or --workgroup domain set the domain name for user account \n " ) ;
2001-01-12 01:49:30 +03:00
printf ( " \n " ) ;
}
/* Main function */
1998-09-26 01:01:52 +04:00
2000-07-03 08:28:29 +04:00
int main ( int argc , char * argv [ ] )
1999-12-13 16:27:58 +03:00
{
2001-03-16 01:06:53 +03:00
extern char * optarg ;
extern int optind ;
extern pstring global_myname ;
2002-03-08 06:31:01 +03:00
static int got_pass = 0 ;
2001-03-16 01:06:53 +03:00
BOOL interactive = True ;
int opt ;
int olddebug ;
2002-03-08 06:31:01 +03:00
static char * cmdstr = " " ;
2001-12-03 10:42:18 +03:00
struct cli_state * cli ;
2001-12-18 03:27:46 +03:00
fstring password = " " ,
username = " " ,
domain = " " ,
server = " " ;
2002-03-08 06:31:01 +03:00
static char * opt_authfile = NULL ,
* opt_username = NULL ,
* opt_domain = NULL ,
* opt_configfile = NULL ,
* opt_logfile = NULL ;
static int opt_debuglevel ;
pstring logfile ;
struct cmd_set * * cmd_set ;
struct in_addr server_ip ;
NTSTATUS nt_status ;
extern BOOL AllowDebugChange ;
/* make sure the vars that get altered (4th field) are in
a fixed location or certain compilers complain */
2002-03-07 21:56:51 +03:00
poptContext pc ;
struct poptOption long_options [ ] = {
{ " authfile " , ' A ' , POPT_ARG_STRING , & opt_authfile , ' A ' } ,
{ " conf " , ' s ' , POPT_ARG_STRING , & opt_configfile , ' s ' } ,
{ " nopass " , ' N ' , POPT_ARG_NONE , & got_pass } ,
2002-03-08 06:31:01 +03:00
{ " debug " , ' d ' , POPT_ARG_INT , & opt_debuglevel , ' d ' } ,
{ " debuglevel " , ' d ' , POPT_ARG_INT , & opt_debuglevel , ' d ' } ,
2002-03-07 21:56:51 +03:00
{ " user " , ' U ' , POPT_ARG_STRING , & opt_username , ' U ' } ,
{ " workgroup " , ' W ' , POPT_ARG_STRING , & opt_domain , ' W ' } ,
{ " command " , ' c ' , POPT_ARG_STRING , & cmdstr } ,
{ " logfile " , ' l ' , POPT_ARG_STRING , & opt_logfile , ' l ' } ,
{ " help " , ' h ' , POPT_ARG_NONE , 0 , ' h ' } ,
{ 0 , 0 , 0 , 0 }
} ;
2001-01-12 01:49:30 +03:00
setlinebuf ( stdout ) ;
2001-03-14 23:22:57 +03:00
DEBUGLEVEL = 1 ;
2002-02-26 23:04:54 +03:00
AllowDebugChange = False ;
/* Parse options */
2002-03-07 07:03:21 +03:00
if ( argc = = 1 ) {
2002-02-26 23:04:54 +03:00
usage ( ) ;
return 0 ;
}
if ( strncmp ( " // " , argv [ 1 ] , 2 ) = = 0 | | strncmp ( " \\ \\ " , argv [ 1 ] , 2 ) = = 0 )
argv [ 1 ] + = 2 ;
pstrcpy ( server , argv [ 1 ] ) ;
argv + + ;
argc - - ;
2001-01-16 02:35:59 +03:00
2002-03-07 21:56:51 +03:00
pc = poptGetContext ( NULL , argc , ( const char * * ) argv , long_options ,
POPT_CONTEXT_KEEP_FIRST ) ;
while ( ( opt = poptGetNextOpt ( pc ) ) ! = - 1 ) {
2001-01-12 01:49:30 +03:00
switch ( opt ) {
2001-03-16 01:06:53 +03:00
case ' A ' :
/* only get the username, password, and domain from the file */
2002-03-07 21:56:51 +03:00
read_authfile ( opt_authfile , username ,
password , domain ) ;
2001-03-16 01:06:53 +03:00
if ( strlen ( password ) )
2002-03-07 21:56:51 +03:00
got_pass = 1 ;
2001-01-12 01:49:30 +03:00
break ;
2001-03-14 23:22:57 +03:00
2001-12-21 16:30:55 +03:00
case ' l ' :
2002-03-07 21:56:51 +03:00
slprintf ( logfile , sizeof ( logfile ) - 1 , " %s.client " ,
opt_logfile ) ;
2001-12-21 16:30:55 +03:00
lp_set_logfile ( logfile ) ;
interactive = False ;
break ;
2001-03-14 23:22:57 +03:00
case ' s ' :
2002-03-07 21:56:51 +03:00
pstrcpy ( dyn_CONFIGFILE , opt_configfile ) ;
2001-03-14 23:22:57 +03:00
break ;
2002-03-08 06:31:01 +03:00
case ' d ' :
DEBUGLEVEL = opt_debuglevel ;
break ;
2001-01-12 01:49:30 +03:00
case ' U ' : {
char * lp ;
2002-03-07 21:56:51 +03:00
pstrcpy ( username , opt_username ) ;
2001-07-04 11:36:09 +04:00
if ( ( lp = strchr_m ( username , ' % ' ) ) ) {
2001-01-12 01:49:30 +03:00
* lp = 0 ;
pstrcpy ( password , lp + 1 ) ;
2002-03-07 21:56:51 +03:00
got_pass = 1 ;
memset ( strchr_m ( opt_username , ' % ' ) + 1 , ' X ' , strlen ( password ) ) ;
2001-01-12 01:49:30 +03:00
}
break ;
}
2001-03-14 23:22:57 +03:00
2001-01-12 01:49:30 +03:00
case ' W ' :
2002-03-07 21:56:51 +03:00
pstrcpy ( domain , opt_domain ) ;
2001-01-12 01:49:30 +03:00
break ;
2001-03-14 23:22:57 +03:00
2001-01-12 01:49:30 +03:00
case ' h ' :
default :
2001-07-08 22:25:56 +04:00
usage ( ) ;
2001-01-12 01:49:30 +03:00
exit ( 1 ) ;
}
}
2001-07-08 22:25:56 +04:00
2001-03-14 23:22:57 +03:00
/* the following functions are part of the Samba debugging
facilities . See lib / debug . c */
2001-07-08 22:25:56 +04:00
setup_logging ( " rpcclient " , interactive ) ;
2001-03-14 23:22:57 +03:00
if ( ! interactive )
reopen_logs ( ) ;
2001-03-16 01:06:53 +03:00
/* Load smb.conf file */
2001-03-14 23:22:57 +03:00
/* FIXME! How to get this DEBUGLEVEL to last over lp_load()? */
olddebug = DEBUGLEVEL ;
2001-11-19 05:49:53 +03:00
if ( ! lp_load ( dyn_CONFIGFILE , True , False , False ) ) {
fprintf ( stderr , " Can't load %s \n " , dyn_CONFIGFILE ) ;
2001-03-14 23:22:57 +03:00
}
DEBUGLEVEL = olddebug ;
load_interfaces ( ) ;
get_myname ( ( * global_myname ) ? NULL : global_myname ) ;
strupper ( global_myname ) ;
2001-12-03 10:42:18 +03:00
2002-01-06 06:24:51 +03:00
/* Resolve the IP address */
2001-12-03 10:42:18 +03:00
if ( ! resolve_name ( server , & server_ip , 0x20 ) ) {
2002-01-06 06:24:51 +03:00
DEBUG ( 1 , ( " Unable to resolve %s \n " , server ) ) ;
2001-12-03 10:42:18 +03:00
return 1 ;
}
2001-03-14 23:22:57 +03:00
/*
2001-12-03 10:42:18 +03:00
* Get password
2001-03-14 23:22:57 +03:00
* from stdin if necessary
*/
2001-12-03 10:42:18 +03:00
if ( ! got_pass ) {
char * pass = getpass ( " Password: " ) ;
if ( pass ) {
fstrcpy ( password , pass ) ;
}
}
2001-07-09 00:28:17 +04:00
if ( ! strlen ( username ) & & ! got_pass )
get_username ( username ) ;
2001-03-16 01:06:53 +03:00
2001-12-03 10:42:18 +03:00
nt_status = cli_full_connection ( & cli , global_myname , server ,
& server_ip , 0 ,
" IPC$ " , " IPC " ,
username , domain ,
password , strlen ( password ) ) ;
if ( ! NT_STATUS_IS_OK ( nt_status ) ) {
2002-03-17 07:36:35 +03:00
DEBUG ( 1 , ( " Cannot connect to server. Error was %s \n " , nt_errstr ( nt_status ) ) ) ;
2001-07-28 02:54:50 +04:00
return 1 ;
2001-03-14 23:22:57 +03:00
}
2001-05-24 04:20:32 +04:00
2001-12-03 10:42:18 +03:00
memset ( password , ' X ' , sizeof ( password ) ) ;
2001-03-14 23:22:57 +03:00
/* Load command lists */
2001-03-16 01:06:53 +03:00
2001-05-24 04:20:32 +04:00
cmd_set = rpcclient_command_list ;
2001-03-16 01:06:53 +03:00
2001-05-24 04:20:32 +04:00
while ( * cmd_set ) {
add_command_set ( * cmd_set ) ;
add_command_set ( separator_command ) ;
cmd_set + + ;
}
2001-01-12 01:49:30 +03:00
2001-12-03 10:42:18 +03:00
fetch_machine_sid ( cli ) ;
2001-10-22 10:13:38 +04:00
/* Do anything specified with -c */
2001-05-31 22:35:14 +04:00
if ( cmdstr [ 0 ] ) {
char * cmd ;
char * p = cmdstr ;
while ( ( cmd = next_command ( & p ) ) ! = NULL ) {
2001-12-03 10:42:18 +03:00
process_cmd ( cli , cmd ) ;
2001-05-31 22:35:14 +04:00
}
2001-12-03 10:42:18 +03:00
cli_shutdown ( cli ) ;
2001-05-31 22:35:14 +04:00
return 0 ;
}
2001-01-12 01:49:30 +03:00
2001-03-14 23:22:57 +03:00
/* Loop around accepting commands */
2001-05-24 04:20:32 +04:00
2001-01-12 01:49:30 +03:00
while ( 1 ) {
2001-04-28 04:32:56 +04:00
pstring prompt ;
2001-03-19 03:32:16 +03:00
char * line ;
2001-01-12 21:19:57 +03:00
2001-03-14 23:22:57 +03:00
slprintf ( prompt , sizeof ( prompt ) - 1 , " rpcclient $> " ) ;
2001-01-12 01:49:30 +03:00
2001-04-28 04:32:56 +04:00
line = smb_readline ( prompt , NULL , completion_fn ) ;
2001-01-12 01:49:30 +03:00
2001-05-04 05:04:23 +04:00
if ( line = = NULL )
break ;
if ( line [ 0 ] ! = ' \n ' )
2001-12-03 10:42:18 +03:00
process_cmd ( cli , line ) ;
2001-01-12 01:49:30 +03:00
}
2001-12-03 10:42:18 +03:00
cli_shutdown ( cli ) ;
2001-05-04 05:04:23 +04:00
return 0 ;
}