/*
Unix SMB/CIFS implementation.
SMB client
- Copyright (C) Andrew Tridgell 1994-1998
- Copyright (C) Simo Sorce 2001-2002
- Copyright (C) Jelmer Vernooij 2003
+ Copyright (C) Andrew Tridgell 1994-1998
+ Copyright (C) Simo Sorce 2001-2002
+ Copyright (C) Jelmer Vernooij 2003
+ Copyright (C) Gerald (Jerry) Carter 2004
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
/* totals globals */
static double dir_total;
+
struct client_connection {
struct client_connection *prev, *next;
+ struct client_connection *parent;
struct cli_state *cli;
+ pstring mntpath;
};
struct cli_state *cli;
-struct client_connection *connections;
+static struct client_connection *connections;
/********************************************************************
Return a connection to a server.
********************************************************************/
-static struct cli_state *do_connect(const char *server, const char *share)
+static struct cli_state *do_connect( const char *server, const char *share,
+ BOOL show_sessetup )
{
struct cli_state *c;
struct nmb_name called, calling;
d_printf("Anonymous login successful\n");
}
- if (*c->server_domain) {
- DEBUG(1,("Domain=[%s] OS=[%s] Server=[%s]\n",
- c->server_domain,c->server_os,c->server_type));
- } else if (*c->server_os || *c->server_type){
- DEBUG(1,("OS=[%s] Server=[%s]\n",
- c->server_os,c->server_type));
- }
+ if ( show_sessetup ) {
+ if (*c->server_domain) {
+ DEBUG(1,("Domain=[%s] OS=[%s] Server=[%s]\n",
+ c->server_domain,c->server_os,c->server_type));
+ } else if (*c->server_os || *c->server_type){
+ DEBUG(1,("OS=[%s] Server=[%s]\n",
+ c->server_os,c->server_type));
+ }
+ }
DEBUG(4,(" session setup ok\n"));
if (!cli_send_tconX(c, sharename, "?????",
Add a new connection to the list
********************************************************************/
-static struct cli_state* add_new_connection( const char *server, const char *share )
+static struct cli_state* cli_cm_connect( const char *server, const char *share,
+ BOOL show_hdr )
{
- struct client_connection *node;
+ struct client_connection *node, *pparent, *p;
node = SMB_XMALLOC_P( struct client_connection );
- node->cli = do_connect( server, share );
+ node->cli = do_connect( server, share, show_hdr );
if ( !node->cli ) {
SAFE_FREE( node );
return NULL;
}
+ pparent = NULL;
+ for ( p=connections; p; p=p->next ) {
+ if ( strequal(cli->desthost, p->cli->desthost) && strequal(cli->share, p->cli->share) )
+ pparent = p;
+ }
+
+ node->parent = pparent;
+ pstrcpy( node->mntpath, cur_dir );
+
DLIST_ADD( connections, node );
return node->cli;
Return a connection to a server.
********************************************************************/
-static struct cli_state* find_connection ( const char *server, const char *share )
+static struct cli_state* cli_cm_find( const char *server, const char *share )
{
struct client_connection *p;
return NULL;
}
+/****************************************************************************
+ open a client connection to a \\server\share. Set's the current *cli
+ global variable as a side-effect (but only if the connection is successful).
+****************************************************************************/
+
+struct cli_state* cli_cm_open( const char *server, const char *share, BOOL show_hdr )
+{
+ struct cli_state *c;
+
+ /* try to reuse an existing connection */
+
+ c = cli_cm_find( server, share );
+
+ if ( !c )
+ c = cli_cm_connect( server, share, show_hdr );
+
+ return c;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+struct cli_state* cli_cm_current( void )
+{
+ return cli;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+const char* cli_cm_get_mntpath( struct cli_state *pcli )
+{
+ struct client_connection *p;
+
+ for ( p=connections; p; p=p->next ) {
+ if ( strequal(pcli->desthost, p->cli->desthost) && strequal(pcli->share, p->cli->share) )
+ break;
+ }
+
+ if ( !p )
+ return NULL;
+
+ return p->mntpath;
+}
+
/****************************************************************************
Write to a local file with CR/LF->LF translation if appropriate. Return the
number taken from the buffer. This may not equal the number written.
static int do_dskattr(void)
{
int total, bsize, avail;
+ struct cli_state *targetcli;
+ pstring targetpath;
+
+ if ( !cli_resolve_path( cli, cur_dir, &targetcli, targetpath ) ) {
+ d_printf("Error in dskattr: %s\n", cli_errstr(cli));
+ }
- if (!cli_dskattr(cli, &bsize, &total, &avail)) {
- d_printf("Error in dskattr: %s\n",cli_errstr(cli));
+ if (!cli_dskattr(targetcli, &bsize, &total, &avail)) {
+ d_printf("Error in dskattr: %s\n",cli_errstr(targetcli));
return 1;
}
char *p = newdir;
pstring saved_dir;
pstring dname;
+ pstring targetpath;
+ struct cli_state *targetcli;
dos_format(newdir);
- /* Save the current directory in case the
- new directory is invalid */
+ /* Save the current directory in case the new directory is invalid */
+
pstrcpy(saved_dir, cur_dir);
+
if (*p == '\\')
pstrcpy(cur_dir,p);
else
pstrcat(cur_dir,p);
+
if (*(cur_dir+strlen(cur_dir)-1) != '\\') {
pstrcat(cur_dir, "\\");
}
+
dos_clean_name(cur_dir);
- pstrcpy(dname,cur_dir);
+ pstrcpy( dname, cur_dir );
pstrcat(cur_dir,"\\");
dos_clean_name(cur_dir);
- if (!strequal(cur_dir,"\\")) {
- if (!cli_chkpath(cli, dname)) {
- d_printf("cd %s: %s\n", dname, cli_errstr(cli));
+ if ( !cli_resolve_path( cli, dname, &targetcli, targetpath ) ) {
+ d_printf("cd %s: %s\n", dname, cli_errstr(cli));
+ pstrcpy(cur_dir,saved_dir);
+ }
+
+ pstrcat( targetpath, "\\" );
+ dos_clean_name( targetpath );
+
+ if ( !strequal(targetpath,"\\") ) {
+ if ( !cli_chkpath(targetcli, targetpath) ) {
+ d_printf("cd %s: %s\n", dname, cli_errstr(targetcli));
pstrcpy(cur_dir,saved_dir);
}
}
-
+
pstrcpy(cd_path,cur_dir);
return 0;
{
pstring buf;
int rc = 0;
-
+
if (next_token_nr(NULL,buf,NULL,sizeof(buf)))
rc = do_cd(buf);
else
void do_list(const char *mask,uint16 attribute,void (*fn)(file_info *),BOOL rec, BOOL dirs)
{
static int in_do_list = 0;
+ struct cli_state *targetcli;
+ pstring targetpath;
if (in_do_list && rec) {
fprintf(stderr, "INTERNAL ERROR: do_list called recursively when the recursive flag is true\n");
*/
pstring head;
pstrcpy(head, do_list_queue_head());
- cli_list(cli, head, attribute, do_list_helper, NULL);
+
+ /* check for dfs */
+
+ if ( !cli_resolve_path( cli, head, &targetcli, targetpath ) ) {
+ d_printf("do_list: [%s] %s\n", head, cli_errstr(cli));
+ continue;
+ }
+
+ cli_list(targetcli, targetpath, attribute, do_list_helper, NULL);
remove_do_list_queue_head();
if ((! do_list_queue_empty()) && (fn == display_finfo)) {
char* next_file = do_list_queue_head();
}
}
} else {
- if (cli_list(cli, mask, attribute, do_list_helper, NULL) == -1) {
- d_printf("%s listing %s\n", cli_errstr(cli), mask);
+ /* check for dfs */
+
+ if ( cli_resolve_path( cli, mask, &targetcli, targetpath ) ) {
+ if (cli_list(targetcli, targetpath, attribute, do_list_helper, NULL) == -1)
+ d_printf("%s listing %s\n", cli_errstr(targetcli), targetpath);
}
+ else
+ d_printf("do_list: [%s] %s\n", mask, cli_errstr(cli));
+
}
in_do_list = 0;
}
-/****************************************************************************
- Add a connection to a new //server/share path
-****************************************************************************/
-
-static int cmd_add_connect(void)
-{
- pstring path;
- struct cli_state *new_cli;
-
- if ( !next_token_nr(NULL, path, NULL, sizeof(path)) ) {
- d_printf("connect <uncpath>\n");
- return 0;
- }
-
- string_replace(path, '/','\\');
-
- new_cli = add_new_connection( "", path );
-
- /* if successful, set this as the current connection */
-
- if ( new_cli )
- cli = new_cli;
-
- return 0;
-}
-
/****************************************************************************
list active connections
****************************************************************************/
}
/****************************************************************************
- set the current active_connection
+ display the current active client connection
****************************************************************************/
-static int cmd_set_connect(void)
+static int cmd_show_connect( void )
{
- pstring path;
- char *server, *share;
- struct cli_state *c;
-
- if ( !next_token_nr(NULL, path, NULL, sizeof(path)) ) {
- d_printf("setconnect <uncpath>\n");
- return 0;
- }
-
- if ( strlen(path) < 5 ) {
- d_printf("Invalid UNC path [%s]\n", path );
- return 1;
- }
-
-
- string_replace(path, '/','\\');
-
- share = strrchr_m( path, '\\' );
- if ( !share ) {
- d_printf("Invalid UNC path [%s]\n", path );
- return 1;
- };
-
- *share = '\0';
- share++;
-
- if ( path[0] != '\\' || path[1]!='\\' ) {
- d_printf("Invalid UNC path [%s]\n", path );
- return 1;
- }
-
- server = path+2;
-
- c = find_connection( server, share );
- if ( !c ) {
- d_printf("Cannot find existing connection for //%s/%s\n",
- server, share);
+ struct cli_state *targetcli;
+ pstring targetpath;
+
+ if ( !cli_resolve_path( cli, cur_dir, &targetcli, targetpath ) ) {
+ d_printf("showconnect %s: %s\n", cur_dir, cli_errstr(cli));
return 1;
}
-
- cli = c;
-
+
+ d_printf("//%s/%s\n", targetcli->desthost, targetcli->share);
return 0;
}
{"translate",cmd_translate,"toggle text translation for printing",{COMPL_NONE,COMPL_NONE}},
{"vuid",cmd_vuid,"change current vuid",{COMPL_NONE,COMPL_NONE}},
{"logon",cmd_logon,"establish new logon",{COMPL_NONE,COMPL_NONE}},
- {"addconnect",cmd_add_connect,"add a connection to a new //server/share",{COMPL_NONE,COMPL_NONE}},
{"listconnect",cmd_list_connect,"list open connections",{COMPL_NONE,COMPL_NONE}},
- {"setconnect",cmd_set_connect,"set the current active connection",{COMPL_NONE,COMPL_NONE}},
+ {"showconnect",cmd_show_connect,"display the current active connection",{COMPL_NONE,COMPL_NONE}},
/* Yes, this must be here, see crh's comment above. */
{"!",NULL,"run a shell command on the local system",{COMPL_NONE,COMPL_NONE}},
/* establish the connection if not already */
if (!cli) {
- cli = add_new_connection(desthost, service);
+ cli = cli_cm_connect(desthost, service, True);
if (!cli)
return 0;
}
{
int rc = 0;
- cli = add_new_connection(desthost, service);
+ cli = cli_cm_connect(desthost, service, True);
if (!cli) {
return 1;
}
static int do_host_query(char *query_host)
{
- cli = add_new_connection(query_host, "IPC$");
+ cli = cli_cm_connect(query_host, "IPC$", True);
if (!cli)
return 1;
cli_shutdown(cli);
port = 139;
- cli = add_new_connection(query_host, "IPC$");
+ cli = cli_cm_connect(query_host, "IPC$", True);
}
if (cli == NULL) {
/* do we already have a connection? */
if (!cli) {
- cli = add_new_connection(desthost, service);
+ cli = cli_cm_connect(desthost, service, True);
if (!cli)
return 1;
}
/*
Unix SMB/CIFS implementation.
client connect/disconnect routines
- Copyright (C) Gerald (Jerry) Carter
-
+ Copyright (C) Gerald (Jerry) Carter 2004
+
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
#include "includes.h"
-/********************************************************************
- check for dfs referral
-********************************************************************/
-
-BOOL check_for_dfs_referral( struct cli_state *cli )
-{
- uint32 flgs2 = SVAL(cli->inbuf,smb_flg2);
-
- /* only deal with DS when we negotiated NT_STATUS codes and UNICODE */
-
- if ( !( (flgs2&FLAGS2_32_BIT_ERROR_CODES) && (flgs2&FLAGS2_UNICODE_STRINGS) ) )
- return False;
-
- if ( NT_STATUS_EQUAL( NT_STATUS_PATH_NOT_COVERED, NT_STATUS(IVAL(cli->inbuf,smb_rcls)) ) )
- return True;
-
- return False;
-}
/********************************************************************
split a dfs path into the server and share name components
********************************************************************/
-void split_dfs_path( const char *nodepath, fstring server, fstring share )
+static void split_dfs_path( const char *nodepath, fstring server, fstring share )
{
char *p;
pstring path;
fstrcpy( server, &path[1] );
}
+/****************************************************************************
+ return the original path truncated at the first wildcard character
+ (also strips trailing \'s). Trust the caller to provide a NULL
+ terminated string
+****************************************************************************/
+
+static void clean_path( pstring clean, const char *path )
+{
+ int len;
+ char *p;
+ pstring newpath;
+
+ pstrcpy( newpath, path );
+ p = newpath;
+
+ while ( p ) {
+ /* first check for '*' */
+
+ p = strrchr_m( newpath, '*' );
+ if ( p ) {
+ *p = '\0';
+ p = newpath;
+ continue;
+ }
+
+ /* first check for '?' */
+
+ p = strrchr_m( newpath, '?' );
+ if ( p ) {
+ *p = '\0';
+ p = newpath;
+ }
+ }
+
+ /* strip a trailing backslash */
+
+ len = strlen( newpath );
+ if ( newpath[len-1] == '\\' )
+ newpath[len-1] = '\0';
+
+ pstrcpy( clean, newpath );
+}
+
+/****************************************************************************
+****************************************************************************/
+
+static BOOL make_full_path( pstring path, const char *server, const char *share,
+ const char *dir )
+{
+ pstring servicename;
+ char *sharename;
+ const char *directory;
+
+
+ /* make a copy so we don't modify the global string 'service' */
+
+ pstrcpy(servicename, share);
+ sharename = servicename;
+
+ if (*sharename == '\\') {
+
+ server = sharename+2;
+ sharename = strchr_m(server,'\\');
+
+ if (!sharename)
+ return False;
+
+ *sharename = 0;
+ sharename++;
+ }
+
+ directory = dir;
+ if ( *directory == '\\' )
+ directory++;
+
+ pstr_sprintf( path, "\\%s\\%s\\%s", server, sharename, directory );
+
+ return True;
+}
+
+/********************************************************************
+ check for dfs referral
+********************************************************************/
+
+static BOOL cli_dfs_check_error( struct cli_state *cli )
+{
+ uint32 flgs2 = SVAL(cli->inbuf,smb_flg2);
+
+ /* only deal with DS when we negotiated NT_STATUS codes and UNICODE */
+
+ if ( !( (flgs2&FLAGS2_32_BIT_ERROR_CODES) && (flgs2&FLAGS2_UNICODE_STRINGS) ) )
+ return False;
+
+ if ( NT_STATUS_EQUAL( NT_STATUS_PATH_NOT_COVERED, NT_STATUS(IVAL(cli->inbuf,smb_rcls)) ) )
+ return True;
+
+ return False;
+}
+
/********************************************************************
get the dfs referral link
********************************************************************/
BOOL cli_dfs_get_referral( struct cli_state *cli, const char *path,
- struct referral **refs, size_t *num_refs)
+ CLIENT_DFS_REFERRAL**refs, size_t *num_refs,
+ uint16 *consumed)
{
unsigned int data_len = 0;
unsigned int param_len = 0;
char *p;
size_t pathlen = 2*(strlen(path)+1);
uint16 num_referrals;
- struct referral *referrals;
+ CLIENT_DFS_REFERRAL *referrals;
memset(param, 0, sizeof(param));
SSVAL(param, 0, 0x03); /* max referral level */
return False;
}
+ *consumed = SVAL( rdata, 0 );
num_referrals = SVAL( rdata, 2 );
if ( num_referrals != 0 ) {
uint16 node_offset;
- referrals = SMB_XMALLOC_ARRAY( struct referral, num_referrals );
+ referrals = SMB_XMALLOC_ARRAY( CLIENT_DFS_REFERRAL, num_referrals );
/* start at the referrals array */
continue;
}
- referrals[0].proximity = SVAL( p, 8 );
- referrals[0].ttl = SVAL( p, 10 );
+ referrals[i].proximity = SVAL( p, 8 );
+ referrals[i].ttl = SVAL( p, 10 );
- clistr_pull( cli, referrals[0].alternate_path, p+node_offset,
- sizeof(referrals[0].alternate_path), -1, STR_TERMINATE|STR_UNICODE );
+ clistr_pull( cli, referrals[i].dfspath, p+node_offset,
+ sizeof(referrals[i].dfspath), -1, STR_TERMINATE|STR_UNICODE );
p += ref_size;
}
return True;
}
+#if 0
+/********************************************************************
+********************************************************************/
+
+BOOL cli_dfs_handle_referral( struct cli_state *cli, const char *path )
+{
+ struct cli_state *cli_ipc;
+ pstring fullpath;
+ CLIENT_DFS_REFERRAL *refs = NULL;
+ size_t num_refs;
+ uint16 consumed;
+ fstring server, share;
+
+ if ( !cli_dfs_check_error(cli) )
+ return False;
+
+ if ( !(cli_ipc = cli_cm_open( cli->desthost, "IPC$", False )) )
+ return False;
+
+ make_full_path( fullpath, cli->desthost, cli->share, path );
+
+ if ( !cli_dfs_get_referral( cli_ipc, fullpath, &refs, &num_refs, &consumed ) ) {
+ d_printf("cli_get_dfs_referral() failed!\n");
+ /* reset the current client connection */
+ cli_cm_open( cli->desthost, cli->share, False );
+
+ return False;
+ }
+
+ /* just pick the first one */
+ if ( num_refs ) {
+ split_dfs_path( refs[0].alternate_path, server, share );
+ if ( cli_cm_open( server, share, False ) == NULL ) {
+ d_printf("Unable to follow dfs referral [\\\\%s\\%s]\n",
+ server, share );
+ cli_cm_open( cli->desthost, cli->share, False );
+
+ return False;
+ }
+ }
+
+ SAFE_FREE( refs );
+
+ return True;
+}
+#endif
+
+/********************************************************************
+********************************************************************/
+
+BOOL cli_resolve_path( struct cli_state *rootcli, const char *path,
+ struct cli_state **targetcli, pstring targetpath )
+{
+ CLIENT_DFS_REFERRAL *refs = NULL;
+ size_t num_refs;
+ uint16 consumed;
+ struct cli_state *cli_ipc;
+ pstring fullpath, cleanpath;
+ int pathlen;
+ fstring server, share;
+
+ SMB_STRUCT_STAT sbuf;
+ uint32 attributes;
+
+ if ( !rootcli || !path || !targetcli )
+ return False;
+
+ /* send a trans2_query_path_info to check for a referral */
+
+ clean_path( cleanpath, path );
+ make_full_path( fullpath, rootcli->desthost, rootcli->share, cleanpath );
+
+ /* don't bother continuing if this is not a dfs root */
+
+ if ( !rootcli->dfsroot || cli_qpathinfo_basic( rootcli, fullpath, &sbuf, &attributes ) ) {
+ *targetcli = rootcli;
+ pstrcpy( targetpath, path );
+ return True;
+ }
+
+ /* we got an error, check for DFS referral */
+
+ if ( !cli_dfs_check_error(rootcli) )
+ return False;
+
+ /* check for the referral */
+
+ if ( !(cli_ipc = cli_cm_open( rootcli->desthost, "IPC$", False )) )
+ return False;
+
+ if ( !cli_dfs_get_referral(cli_ipc, fullpath, &refs, &num_refs, &consumed)
+ || !num_refs )
+ {
+ return False;
+ }
+
+ /* just store the first referral for now
+ Make sure to recreate the original string including any wildcards */
+
+ make_full_path( fullpath, rootcli->desthost, rootcli->share, path );
+ pathlen = strlen( fullpath )*2;
+ consumed = MIN(pathlen, consumed );
+ pstrcpy( targetpath, &fullpath[consumed/2] );
+
+ split_dfs_path( refs[0].dfspath, server, share );
+ SAFE_FREE( refs );
+
+ /* open the connection to the target path */
+
+ if ( (*targetcli = cli_cm_open(server, share, False)) == NULL ) {
+ d_printf("Unable to follow dfs referral [//%s/%s]\n",
+ server, share );
+
+ return False;
+ }
+
+ return True;
+}
git.samba.org / tprouty / samba.git / commitdiff