2012-02-01 17:42:39 +04:00
/*
2002-08-18 22:04:00 +04:00
Unix SMB / CIFS implementation .
VFS module tester
Copyright ( C ) Simo Sorce 2002
Copyright ( C ) Eric Lorimer 2002
2003-04-15 01:16:16 +04:00
Copyright ( C ) Jelmer Vernooij 2002 , 2003
2002-08-18 22:04:00 +04:00
Most of this code was ripped off of rpcclient .
Copyright ( C ) Tim Potter 2000 - 2001
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-08-18 22:04:00 +04:00
( at your option ) any later version .
2012-02-01 17:42:39 +04:00
2002-08-18 22:04:00 +04:00
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 .
2012-02-01 17:42:39 +04:00
2002-08-18 22:04:00 +04:00
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-08-18 22:04:00 +04:00
*/
# include "includes.h"
2011-03-23 00:34:22 +03:00
# include "smbd/smbd.h"
2012-02-19 21:48:15 +04:00
# include "smbd/globals.h"
2010-08-05 12:49:53 +04:00
# include "popt_common.h"
2002-08-18 22:04:00 +04:00
# include "vfstest.h"
2010-10-01 12:34:14 +04:00
# include "../libcli/smbreadline/smbreadline.h"
2012-02-19 21:48:15 +04:00
# include "auth.h"
# include "serverid.h"
# include "messages.h"
2012-02-20 19:27:07 +04:00
# include "libcli/security/security.h"
2012-10-09 16:35:04 +04:00
# include "lib/smbd_shim.h"
2012-10-26 07:23:39 +04:00
# include "system/filesys.h"
2002-08-18 22:04:00 +04:00
/* List to hold groups of commands */
static struct cmd_list {
struct cmd_list * prev , * next ;
struct cmd_set * cmd_set ;
} * cmd_list ;
2012-11-17 01:58:06 +04:00
/* shall we do talloc_report after each command? */
static int memreports = 0 ;
2002-08-18 22:04:00 +04:00
/****************************************************************************
handle completion of commands for readline
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2005-09-30 21:13:37 +04:00
static char * * completion_fn ( const char * text , int start , int end )
2002-08-18 22:04:00 +04:00
{
# define MAX_COMPLETIONS 100
char * * matches ;
int i , count = 0 ;
struct cmd_list * commands = cmd_list ;
2012-02-01 17:42:39 +04:00
if ( start )
2002-08-18 22:04:00 +04:00
return NULL ;
/* make sure we have a list of valid commands */
2012-02-01 17:42:39 +04:00
if ( ! commands )
2002-08-18 22:04:00 +04:00
return NULL ;
2005-05-07 10:59:00 +04:00
matches = SMB_MALLOC_ARRAY ( char * , MAX_COMPLETIONS ) ;
2002-08-18 22:04:00 +04:00
if ( ! matches ) return NULL ;
2005-05-07 10:59:00 +04:00
matches [ count + + ] = SMB_STRDUP ( text ) ;
2002-08-18 22:04:00 +04:00
if ( ! matches [ 0 ] ) return NULL ;
2012-02-01 17:42:39 +04:00
while ( commands & & count < MAX_COMPLETIONS - 1 )
2002-08-18 22:04:00 +04:00
{
if ( ! commands - > cmd_set )
break ;
2012-02-01 17:42:39 +04:00
2002-08-18 22:04:00 +04:00
for ( i = 0 ; commands - > cmd_set [ i ] . name ; i + + )
{
if ( ( strncmp ( text , commands - > cmd_set [ i ] . name , strlen ( text ) ) = = 0 ) & &
2012-02-01 17:42:39 +04:00
commands - > cmd_set [ i ] . fn )
2002-08-18 22:04:00 +04:00
{
2005-05-07 10:59:00 +04:00
matches [ count ] = SMB_STRDUP ( commands - > cmd_set [ i ] . name ) ;
2012-02-01 17:42:39 +04:00
if ( ! matches [ count ] )
2002-08-18 22:04:00 +04:00
return NULL ;
count + + ;
}
}
2012-02-01 17:42:39 +04:00
2002-08-18 22:04:00 +04:00
commands = commands - > next ;
}
if ( count = = 2 ) {
SAFE_FREE ( matches [ 0 ] ) ;
2005-05-07 10:59:00 +04:00
matches [ 0 ] = SMB_STRDUP ( matches [ 1 ] ) ;
2002-08-18 22:04:00 +04:00
}
matches [ count ] = NULL ;
return matches ;
}
2007-12-05 03:56:18 +03:00
static char * next_command ( TALLOC_CTX * ctx , char * * cmdstr )
2002-08-18 22:04:00 +04:00
{
2007-12-05 03:56:18 +03:00
char * command ;
char * p ;
2002-08-18 22:04:00 +04:00
if ( ! cmdstr | | ! ( * cmdstr ) )
return NULL ;
2007-12-05 03:56:18 +03:00
2002-08-18 22:04:00 +04:00
p = strchr_m ( * cmdstr , ' ; ' ) ;
if ( p )
* p = ' \0 ' ;
2007-12-05 03:56:18 +03:00
command = talloc_strdup ( ctx , * cmdstr ) ;
2013-03-12 07:51:03 +04:00
/* Pass back the remaining cmdstring
( a trailing delimiter " ; " does also work ) ,
or NULL at last cmdstring .
*/
* cmdstr = p ? p + 1 : p ;
2007-12-05 03:56:18 +03:00
2002-08-18 22:04:00 +04:00
return command ;
}
2002-08-19 04:19:44 +04:00
/* Load specified configuration file */
static NTSTATUS cmd_conf ( struct vfs_state * vfs , TALLOC_CTX * mem_ctx ,
2003-05-12 03:34:18 +04:00
int argc , const char * * argv )
2002-08-19 04:19:44 +04:00
{
if ( argc ! = 2 ) {
printf ( " Usage: %s <smb.conf> \n " , argv [ 0 ] ) ;
return NT_STATUS_OK ;
}
2002-08-18 22:04:00 +04:00
2014-09-18 06:16:56 +04:00
if ( ! lp_load_with_shares ( argv [ 1 ] ) ) {
2002-08-19 04:19:44 +04:00
printf ( " Error loading \" %s \" \n " , argv [ 1 ] ) ;
return NT_STATUS_OK ;
}
printf ( " \" %s \" successfully loaded \n " , argv [ 1 ] ) ;
return NT_STATUS_OK ;
}
2012-02-01 17:42:39 +04:00
2002-08-18 22:04:00 +04:00
/* Display help on commands */
static NTSTATUS cmd_help ( struct vfs_state * vfs , TALLOC_CTX * mem_ctx ,
2003-02-26 02:52:38 +03:00
int argc , const char * * argv )
2002-08-18 22:04:00 +04:00
{
struct cmd_list * tmp ;
struct cmd_set * tmp_set ;
/* Usage */
if ( argc > 2 ) {
printf ( " Usage: %s [command] \n " , argv [ 0 ] ) ;
return NT_STATUS_OK ;
}
/* Help on one command */
if ( argc = = 2 ) {
for ( tmp = cmd_list ; tmp ; tmp = tmp - > next ) {
2012-02-01 17:42:39 +04:00
2002-08-18 22:04:00 +04:00
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 ) ;
return NT_STATUS_OK ;
}
tmp_set + + ;
}
}
printf ( " No such command: %s \n " , argv [ 1 ] ) ;
return NT_STATUS_OK ;
}
/* List all commands */
for ( tmp = cmd_list ; tmp ; tmp = tmp - > next ) {
tmp_set = tmp - > cmd_set ;
while ( tmp_set - > name ) {
printf ( " %15s \t \t %s \n " , tmp_set - > name ,
tmp_set - > description ? tmp_set - > description :
" " ) ;
tmp_set + + ;
}
}
return NT_STATUS_OK ;
}
/* Change the debug level */
2003-05-12 03:34:18 +04:00
static NTSTATUS cmd_debuglevel ( struct vfs_state * vfs , TALLOC_CTX * mem_ctx , int argc , const char * * argv )
2002-08-18 22:04:00 +04:00
{
if ( argc > 2 ) {
printf ( " Usage: %s [debuglevel] \n " , argv [ 0 ] ) ;
return NT_STATUS_OK ;
}
if ( argc = = 2 ) {
2010-10-29 08:29:09 +04:00
lp_set_cmdline ( " log level " , argv [ 1 ] ) ;
2002-08-18 22:04:00 +04:00
}
printf ( " debuglevel is %d \n " , DEBUGLEVEL ) ;
return NT_STATUS_OK ;
}
2003-05-12 03:34:18 +04:00
static NTSTATUS cmd_freemem ( struct vfs_state * vfs , TALLOC_CTX * mem_ctx , int argc , const char * * argv )
2002-08-18 22:04:00 +04:00
{
/* Cleanup */
2002-08-29 15:17:14 +04:00
talloc_destroy ( mem_ctx ) ;
mem_ctx = NULL ;
2002-08-18 22:04:00 +04:00
vfs - > data = NULL ;
2002-08-20 21:58:09 +04:00
vfs - > data_size = 0 ;
return NT_STATUS_OK ;
2002-08-18 22:04:00 +04:00
}
2003-05-12 03:34:18 +04:00
static NTSTATUS cmd_quit ( struct vfs_state * vfs , TALLOC_CTX * mem_ctx , int argc , const char * * argv )
2002-08-18 22:04:00 +04:00
{
/* Cleanup */
2002-08-29 15:17:14 +04:00
talloc_destroy ( mem_ctx ) ;
2002-08-18 22:04:00 +04:00
exit ( 0 ) ;
return NT_STATUS_OK ; /* NOTREACHED */
}
static struct cmd_set vfstest_commands [ ] = {
2019-01-08 19:11:57 +03:00
{ . name = " GENERAL OPTIONS " } ,
2002-08-18 22:04:00 +04:00
2002-08-19 04:19:44 +04:00
{ " conf " , cmd_conf , " Load smb configuration file " , " conf <smb.conf> " } ,
{ " help " , cmd_help , " Get help on commands " , " " } ,
{ " ? " , cmd_help , " Get help on commands " , " " } ,
{ " debuglevel " , cmd_debuglevel , " Set debug level " , " " } ,
{ " freemem " , cmd_freemem , " Free currently allocated buffers " , " " } ,
2002-08-18 22:04:00 +04:00
{ " exit " , cmd_quit , " Exit program " , " " } ,
{ " quit " , cmd_quit , " Exit program " , " " } ,
2019-01-08 19:11:57 +03:00
{ . name = NULL }
2002-08-18 22:04:00 +04:00
} ;
static struct cmd_set separator_command [ ] = {
2019-01-08 19:11:57 +03:00
{
. name = " --------------- " ,
. description = " ---------------------- "
} ,
{
. name = NULL ,
} ,
2002-08-18 22:04:00 +04:00
} ;
extern struct cmd_set vfs_commands [ ] ;
static struct cmd_set * vfstest_command_list [ ] = {
vfstest_commands ,
vfs_commands ,
NULL
} ;
static void add_command_set ( struct cmd_set * cmd_set )
{
struct cmd_list * entry ;
2005-05-07 10:59:00 +04:00
if ( ! ( entry = SMB_MALLOC_P ( struct cmd_list ) ) ) {
2002-08-18 22:04:00 +04:00
DEBUG ( 0 , ( " out of memory \n " ) ) ;
return ;
}
ZERO_STRUCTP ( entry ) ;
entry - > cmd_set = cmd_set ;
DLIST_ADD ( cmd_list , entry ) ;
}
static NTSTATUS do_cmd ( struct vfs_state * vfs , struct cmd_set * cmd_entry , char * cmd )
{
2003-06-04 16:51:21 +04:00
const char * p = cmd ;
2014-02-26 23:16:26 +04:00
const char * * argv = NULL ;
2002-08-18 22:04:00 +04:00
NTSTATUS result = NT_STATUS_UNSUCCESSFUL ;
2007-12-05 03:56:18 +03:00
char * buf ;
TALLOC_CTX * mem_ctx = talloc_stackframe ( ) ;
2014-02-26 23:16:26 +04:00
int argc = 0 ;
2002-08-18 22:04:00 +04:00
/* Count number of arguments first time through the loop then
allocate memory and strdup them . */
again :
2007-12-05 03:56:18 +03:00
while ( next_token_talloc ( mem_ctx , & p , & buf , " " ) ) {
2002-08-18 22:04:00 +04:00
if ( argv ) {
2014-02-26 23:16:26 +04:00
argv [ argc ] = talloc_strdup ( argv , buf ) ;
2002-08-18 22:04:00 +04:00
}
argc + + ;
}
2007-12-05 03:56:18 +03:00
if ( ! argv ) {
2002-08-18 22:04:00 +04:00
/* Create argument list */
2014-02-26 23:16:26 +04:00
argv = talloc_zero_array ( mem_ctx , const char * , argc ) ;
if ( argv = = NULL ) {
2002-08-18 22:04:00 +04:00
fprintf ( stderr , " out of memory \n " ) ;
result = NT_STATUS_NO_MEMORY ;
goto done ;
}
2007-12-05 03:56:18 +03:00
2002-08-18 22:04:00 +04:00
p = cmd ;
argc = 0 ;
2007-12-05 03:56:18 +03:00
2002-08-18 22:04:00 +04:00
goto again ;
}
/* Call the function */
if ( cmd_entry - > fn ) {
/* Run command */
2003-05-12 03:34:18 +04:00
result = cmd_entry - > fn ( vfs , mem_ctx , argc , ( const char * * ) argv ) ;
2002-08-18 22:04:00 +04:00
} else {
fprintf ( stderr , " Invalid command \n " ) ;
goto done ;
}
done :
2007-12-05 03:56:18 +03:00
2002-08-18 22:04:00 +04:00
/* Cleanup */
if ( argv ) {
2014-02-26 23:16:26 +04:00
char * * _argv = discard_const_p ( char * , argv ) ;
TALLOC_FREE ( _argv ) ;
argv = NULL ;
2002-08-18 22:04:00 +04:00
}
2007-12-05 03:56:18 +03:00
2012-11-17 01:58:06 +04:00
if ( memreports ! = 0 ) {
talloc_report_full ( mem_ctx , stdout ) ;
}
2007-12-05 03:56:18 +03:00
TALLOC_FREE ( mem_ctx ) ;
2002-08-18 22:04:00 +04:00
return result ;
}
/* Process a command entered at the prompt or as part of -c */
static NTSTATUS process_cmd ( struct vfs_state * vfs , char * cmd )
{
struct cmd_list * temp_list ;
2007-10-19 04:40:25 +04:00
bool found = False ;
2007-12-05 03:56:18 +03:00
char * buf ;
2003-06-04 16:51:21 +04:00
const char * p = cmd ;
2002-08-18 22:04:00 +04:00
NTSTATUS result = NT_STATUS_OK ;
2007-12-05 03:56:18 +03:00
TALLOC_CTX * mem_ctx = talloc_stackframe ( ) ;
2002-08-18 22:04:00 +04:00
int len = 0 ;
if ( cmd [ strlen ( cmd ) - 1 ] = = ' \n ' )
cmd [ strlen ( cmd ) - 1 ] = ' \0 ' ;
2007-12-05 03:56:18 +03:00
if ( ! next_token_talloc ( mem_ctx , & p , & buf , " " ) ) {
TALLOC_FREE ( mem_ctx ) ;
2002-08-18 22:04:00 +04:00
return NT_STATUS_OK ;
}
2007-12-05 03:56:18 +03:00
/* Strip the trailing \n if it exists */
2002-08-18 22:04:00 +04:00
len = strlen ( buf ) ;
if ( buf [ len - 1 ] = = ' \n ' )
buf [ len - 1 ] = ' \0 ' ;
/* 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 ) ) {
found = True ;
result = do_cmd ( vfs , temp_set , cmd ) ;
goto done ;
}
temp_set + + ;
}
}
done :
if ( ! found & & buf [ 0 ] ) {
printf ( " command not found: %s \n " , buf ) ;
2007-12-05 03:56:18 +03:00
TALLOC_FREE ( mem_ctx ) ;
2002-08-18 22:04:00 +04:00
return NT_STATUS_OK ;
}
if ( ! NT_STATUS_IS_OK ( result ) ) {
printf ( " result was %s \n " , nt_errstr ( result ) ) ;
}
2007-12-05 03:56:18 +03:00
TALLOC_FREE ( mem_ctx ) ;
2002-08-18 22:04:00 +04:00
return result ;
}
2002-08-21 06:34:49 +04:00
static void process_file ( struct vfs_state * pvfs , char * filename ) {
FILE * file ;
char command [ 3 * PATH_MAX ] ;
if ( * filename = = ' - ' ) {
file = stdin ;
} else {
file = fopen ( filename , " r " ) ;
if ( file = = NULL ) {
printf ( " vfstest: error reading file (%s)! " , filename ) ;
printf ( " errno n.%d: %s " , errno , strerror ( errno ) ) ;
exit ( - 1 ) ;
}
}
while ( fgets ( command , 3 * PATH_MAX , file ) ! = NULL ) {
process_cmd ( pvfs , command ) ;
}
2009-05-25 20:59:05 +04:00
if ( file ! = stdin ) {
fclose ( file ) ;
}
2002-08-21 06:34:49 +04:00
}
2014-02-26 23:16:26 +04:00
static void vfstest_exit_server ( const char * const reason ) _NORETURN_ ;
2012-10-09 16:35:04 +04:00
static void vfstest_exit_server ( const char * const reason )
2002-08-18 22:04:00 +04:00
{
DEBUG ( 3 , ( " Server exit (%s) \n " , ( reason ? reason : " " ) ) ) ;
exit ( 0 ) ;
}
2014-02-26 23:16:26 +04:00
static void vfstest_exit_server_cleanly ( const char * const reason ) _NORETURN_ ;
2012-10-09 16:35:04 +04:00
static void vfstest_exit_server_cleanly ( const char * const reason )
2006-04-04 04:27:50 +04:00
{
2012-10-09 16:35:04 +04:00
vfstest_exit_server ( " normal exit " ) ;
2006-04-04 04:27:50 +04:00
}
2012-02-20 19:28:14 +04:00
struct smb_request * vfstest_get_smbreq ( TALLOC_CTX * mem_ctx ,
struct vfs_state * vfs )
{
struct smb_request * result ;
2014-02-26 23:16:26 +04:00
uint8_t * inbuf ;
2012-02-20 19:28:14 +04:00
result = talloc_zero ( mem_ctx , struct smb_request ) ;
if ( result = = NULL ) {
return NULL ;
}
result - > sconn = vfs - > conn - > sconn ;
result - > mid = + + vfs - > mid ;
2014-02-26 23:16:26 +04:00
inbuf = talloc_array ( result , uint8_t , smb_size ) ;
if ( inbuf = = NULL ) {
2012-02-20 19:28:14 +04:00
goto fail ;
}
2014-02-26 23:16:26 +04:00
SSVAL ( inbuf , smb_mid , result - > mid ) ;
smb_setlen ( inbuf , smb_size - 4 ) ;
result - > inbuf = inbuf ;
2012-02-20 19:28:14 +04:00
return result ;
fail :
TALLOC_FREE ( result ) ;
return NULL ;
}
2002-08-18 22:04:00 +04:00
/* Main function */
2014-02-26 23:16:26 +04:00
int main ( int argc , const char * argv [ ] )
2002-08-18 22:04:00 +04:00
{
2012-02-01 22:42:55 +04:00
char * cmdstr = NULL ;
struct cmd_set * * cmd_set ;
2018-05-25 09:49:29 +03:00
struct conn_struct_tos * c = NULL ;
2012-08-16 09:16:01 +04:00
struct vfs_state * vfs ;
2002-08-18 22:04:00 +04:00
int i ;
2012-02-01 22:42:55 +04:00
char * filename = NULL ;
2012-02-01 22:44:32 +04:00
char cwd [ MAXPATHLEN ] ;
2007-12-05 03:56:18 +03:00
TALLOC_CTX * frame = talloc_stackframe ( ) ;
2013-01-09 02:18:55 +04:00
struct auth_session_info * session_info = NULL ;
2012-02-22 20:57:08 +04:00
NTSTATUS status = NT_STATUS_OK ;
2002-08-18 22:04:00 +04:00
/* make sure the vars that get altered (4th field) are in
a fixed location or certain compilers complain */
poptContext pc ;
struct poptOption long_options [ ] = {
2002-08-29 16:05:30 +04:00
POPT_AUTOHELP
2019-01-08 19:07:34 +03:00
{
. longName = " file " ,
. shortName = ' f ' ,
. argInfo = POPT_ARG_STRING ,
. arg = & filename ,
} ,
{
. longName = " command " ,
. shortName = ' c ' ,
. argInfo = POPT_ARG_STRING ,
. arg = & cmdstr ,
. val = 0 ,
. descrip = " Execute specified list of commands " ,
} ,
{
. longName = " memreport " ,
. shortName = ' m ' ,
. argInfo = POPT_ARG_INT ,
. arg = & memreports ,
. descrip = " Report memory left on talloc stackframe after each command " ,
} ,
2003-04-15 01:16:16 +04:00
POPT_COMMON_SAMBA
POPT_TABLEEND
2002-08-18 22:04:00 +04:00
} ;
2012-10-09 16:35:04 +04:00
static const struct smbd_shim vfstest_shim_fns =
{
. exit_server = vfstest_exit_server ,
. exit_server_cleanly = vfstest_exit_server_cleanly ,
} ;
2002-08-18 22:04:00 +04:00
2015-03-21 22:00:06 +03:00
smb_init_locale ( ) ;
2002-08-18 22:04:00 +04:00
setlinebuf ( stdout ) ;
2014-02-26 23:16:26 +04:00
pc = poptGetContext ( " vfstest " , argc , argv , long_options , 0 ) ;
2012-02-01 17:42:39 +04:00
2003-04-15 01:16:16 +04:00
while ( poptGetNextOpt ( pc ) ! = - 1 ) ;
2002-08-18 22:04:00 +04:00
poptFreeContext ( pc ) ;
2012-10-26 07:23:39 +04:00
/* we want total control over the permissions on created files,
so set our umask to 0 */
umask ( 0 ) ;
2010-12-09 14:41:58 +03:00
lp_load_initial_only ( get_dyn_CONFIGFILE ( ) ) ;
2002-08-21 06:34:49 +04:00
/* TODO: check output */
2011-12-14 16:25:20 +04:00
reload_services ( NULL , NULL , false ) ;
2002-08-21 06:34:49 +04:00
2002-08-18 22:04:00 +04:00
/* the following functions are part of the Samba debugging
facilities . See lib / debug . c */
2010-10-29 07:19:32 +04:00
setup_logging ( " vfstest " , DEBUG_STDOUT ) ;
2012-02-01 17:42:39 +04:00
2019-01-11 15:15:58 +03:00
per_thread_cwd_check ( ) ;
2012-10-09 16:35:04 +04:00
set_smbd_shim ( & vfstest_shim_fns ) ;
2002-08-18 22:04:00 +04:00
/* Load command lists */
cmd_set = vfstest_command_list ;
while ( * cmd_set ) {
add_command_set ( * cmd_set ) ;
add_command_set ( separator_command ) ;
cmd_set + + ;
}
/* some basic initialization stuff */
2003-05-12 03:34:18 +04:00
sec_init ( ) ;
2018-02-13 14:09:12 +03:00
init_guest_session_info ( frame ) ;
2012-02-19 21:48:15 +04:00
locking_init ( ) ;
2018-05-25 09:49:29 +03:00
vfs = talloc_zero ( frame , struct vfs_state ) ;
2013-01-09 02:18:55 +04:00
if ( vfs = = NULL ) {
return 1 ;
}
status = make_session_info_guest ( vfs , & session_info ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
return 1 ;
}
2018-08-21 21:09:16 +03:00
status = create_conn_struct_tos ( global_messaging_context ( ) ,
2018-05-25 09:49:29 +03:00
- 1 ,
getcwd ( cwd , sizeof ( cwd ) ) ,
session_info ,
& c ) ;
2013-01-09 02:18:55 +04:00
if ( ! NT_STATUS_IS_OK ( status ) ) {
return 1 ;
}
2018-05-25 09:49:29 +03:00
vfs - > conn = c - > conn ;
2013-01-09 02:18:55 +04:00
2012-08-16 09:16:01 +04:00
vfs - > conn - > share_access = FILE_GENERIC_ALL ;
2013-01-09 02:18:55 +04:00
vfs - > conn - > read_only = false ;
2012-08-16 09:16:01 +04:00
file_init ( vfs - > conn - > sconn ) ;
2002-08-18 22:04:00 +04:00
for ( i = 0 ; i < 1024 ; i + + )
2012-08-16 09:16:01 +04:00
vfs - > files [ i ] = NULL ;
2002-08-18 22:04:00 +04:00
2012-02-02 19:24:30 +04:00
if ( ! posix_locking_init ( false ) ) {
return 1 ;
}
2002-08-21 06:34:49 +04:00
/* Do we have a file input? */
2003-04-15 01:16:16 +04:00
if ( filename & & filename [ 0 ] ) {
2012-08-16 09:16:01 +04:00
process_file ( vfs , filename ) ;
2002-08-21 06:34:49 +04:00
return 0 ;
}
/* Do anything specified with -c */
2003-04-15 01:16:16 +04:00
if ( cmdstr & & cmdstr [ 0 ] ) {
2002-08-18 22:04:00 +04:00
char * cmd ;
char * p = cmdstr ;
2007-12-05 03:56:18 +03:00
while ( ( cmd = next_command ( frame , & p ) ) ! = NULL ) {
2012-08-16 09:16:01 +04:00
status = process_cmd ( vfs , cmd ) ;
2002-08-18 22:04:00 +04:00
}
2007-12-05 03:56:18 +03:00
TALLOC_FREE ( cmd ) ;
2012-02-22 20:57:08 +04:00
return NT_STATUS_IS_OK ( status ) ? 0 : 1 ;
2002-08-18 22:04:00 +04:00
}
/* Loop around accepting commands */
while ( 1 ) {
2007-12-07 04:16:33 +03:00
char * line = NULL ;
2002-08-18 22:04:00 +04:00
2007-12-05 03:56:18 +03:00
line = smb_readline ( " vfstest $> " , NULL , completion_fn ) ;
2002-08-18 22:04:00 +04:00
2007-12-07 04:16:33 +03:00
if ( line = = NULL ) {
2002-08-18 22:04:00 +04:00
break ;
2007-12-07 04:16:33 +03:00
}
2002-08-18 22:04:00 +04:00
2007-12-07 04:16:33 +03:00
if ( line [ 0 ] ! = ' \n ' ) {
2012-08-16 09:16:01 +04:00
status = process_cmd ( vfs , line ) ;
2007-12-07 04:16:33 +03:00
}
SAFE_FREE ( line ) ;
2002-08-18 22:04:00 +04:00
}
2007-12-05 03:56:18 +03:00
2012-08-16 09:16:01 +04:00
TALLOC_FREE ( vfs ) ;
2007-12-05 03:56:18 +03:00
TALLOC_FREE ( frame ) ;
2012-02-22 20:57:08 +04:00
return NT_STATUS_IS_OK ( status ) ? 0 : 1 ;
2002-08-18 22:04:00 +04:00
}