2007-11-30 04:25:41 +03:00
/*
2005-02-22 06:31:22 +03:00
Unix SMB / CIFS implementation .
client connect / disconnect routines
2005-02-25 00:54:52 +03:00
Copyright ( C ) Andrew Tridgell 1994 - 1998
2005-02-23 20:29:28 +03:00
Copyright ( C ) Gerald ( Jerry ) Carter 2004
2009-03-13 03:59:24 +03:00
Copyright ( C ) Jeremy Allison 2007 - 2009
2007-11-30 04:25:41 +03:00
2005-02-22 06:31:22 +03: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
2005-02-22 06:31:22 +03:00
( at your option ) any later version .
2007-11-30 04:25:41 +03:00
2005-02-22 06:31:22 +03: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 .
2007-11-30 04:25:41 +03:00
2005-02-22 06:31:22 +03: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/>.
2005-02-22 06:31:22 +03:00
*/
# include "includes.h"
2011-05-06 13:47:43 +04:00
# include "libsmb/libsmb.h"
2011-02-24 12:46:55 +03:00
# include "libsmb/clirap.h"
2011-02-25 00:58:08 +03:00
# include "msdfs.h"
2011-02-25 02:03:01 +03:00
# include "trans2.h"
2011-03-23 16:18:59 +03:00
# include "libsmb/nmblib.h"
2005-02-22 06:31:22 +03:00
2007-03-09 02:54:57 +03:00
/********************************************************************
Important point .
2007-03-12 20:55:24 +03:00
DFS paths are * always * of the form \ server \ share \ < pathname > ( the \ characters
2007-03-09 02:54:57 +03:00
are not C escaped here ) .
- but if we ' re using POSIX paths then < pathname > may contain
' / ' separators , not ' \\ ' separators . So cope with ' \\ ' or ' / '
as a separator when looking at the pathname part . . . . JRA .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2005-02-22 06:31:22 +03:00
2007-12-30 09:39:52 +03:00
/********************************************************************
Ensure a connection is encrypted .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2008-01-05 11:23:35 +03:00
NTSTATUS cli_cm_force_encryption ( struct cli_state * c ,
2007-12-30 09:39:52 +03:00
const char * username ,
const char * password ,
const char * domain ,
const char * sharename )
{
2008-01-05 11:23:35 +03:00
NTSTATUS status = cli_force_encryption ( c ,
username ,
password ,
domain ) ;
2007-12-30 09:39:52 +03:00
2008-01-05 11:23:35 +03:00
if ( NT_STATUS_EQUAL ( status , NT_STATUS_NOT_SUPPORTED ) ) {
2007-12-30 09:39:52 +03:00
d_printf ( " Encryption required and "
" server that doesn't support "
" UNIX extensions - failing connect \n " ) ;
2008-01-05 11:23:35 +03:00
} else if ( NT_STATUS_EQUAL ( status , NT_STATUS_UNKNOWN_REVISION ) ) {
2007-12-30 09:39:52 +03:00
d_printf ( " Encryption required and "
" can't get UNIX CIFS extensions "
" version from server. \n " ) ;
2008-01-05 11:23:35 +03:00
} else if ( NT_STATUS_EQUAL ( status , NT_STATUS_UNSUPPORTED_COMPRESSION ) ) {
2007-12-30 09:39:52 +03:00
d_printf ( " Encryption required and "
" share %s doesn't support "
" encryption. \n " , sharename ) ;
2008-01-05 11:23:35 +03:00
} else if ( ! NT_STATUS_IS_OK ( status ) ) {
2007-12-30 09:39:52 +03:00
d_printf ( " Encryption required and "
" setup failed with error %s. \n " ,
nt_errstr ( status ) ) ;
}
2008-01-05 11:23:35 +03:00
return status ;
2007-12-30 09:39:52 +03:00
}
2009-03-13 03:59:24 +03:00
2005-02-25 00:54:52 +03:00
/********************************************************************
Return a connection to a server .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2011-07-03 14:08:54 +04:00
static NTSTATUS do_connect ( TALLOC_CTX * ctx ,
2007-11-30 04:25:41 +03:00
const char * server ,
const char * share ,
2009-03-18 00:53:06 +03:00
const struct user_auth_info * auth_info ,
2007-12-30 09:39:52 +03:00
bool show_sessetup ,
2009-01-15 01:26:56 +03:00
bool force_encrypt ,
2009-01-15 03:08:19 +03:00
int max_protocol ,
int port ,
2011-07-03 14:08:54 +04:00
int name_type ,
struct cli_state * * pcli )
2005-02-25 00:54:52 +03:00
{
2006-07-11 22:01:26 +04:00
struct cli_state * c = NULL ;
2007-11-30 04:25:41 +03:00
char * servicename ;
2005-02-25 00:54:52 +03:00
char * sharename ;
2007-11-30 04:25:41 +03:00
char * newserver , * newshare ;
const char * username ;
const char * password ;
2007-06-20 21:38:42 +04:00
NTSTATUS status ;
2007-11-30 04:25:41 +03:00
2005-02-25 00:54:52 +03:00
/* make a copy so we don't modify the global string 'service' */
2007-11-30 04:25:41 +03:00
servicename = talloc_strdup ( ctx , share ) ;
if ( ! servicename ) {
2011-07-03 14:08:54 +04:00
return NT_STATUS_NO_MEMORY ;
2007-11-30 04:25:41 +03:00
}
2005-02-25 00:54:52 +03:00
sharename = servicename ;
if ( * sharename = = ' \\ ' ) {
2009-01-02 23:49:49 +03:00
sharename + = 2 ;
if ( server = = NULL ) {
server = sharename ;
}
sharename = strchr_m ( sharename , ' \\ ' ) ;
2007-11-30 04:25:41 +03:00
if ( ! sharename ) {
2011-07-03 14:08:54 +04:00
return NT_STATUS_NO_MEMORY ;
2007-11-30 04:25:41 +03:00
}
2005-02-25 00:54:52 +03:00
* sharename = 0 ;
sharename + + ;
}
2011-05-29 15:17:23 +04:00
if ( server = = NULL ) {
2011-07-03 14:08:54 +04:00
return NT_STATUS_INVALID_PARAMETER ;
2005-02-25 00:54:52 +03:00
}
2009-01-15 03:08:19 +03:00
2011-05-29 15:17:23 +04:00
status = cli_connect_nb (
server , NULL , port , name_type , NULL ,
get_cmdline_auth_info_signing_state ( auth_info ) , & c ) ;
2007-06-20 21:38:42 +04:00
if ( ! NT_STATUS_IS_OK ( status ) ) {
2007-11-30 04:25:41 +03:00
d_printf ( " Connection to %s failed (Error %s) \n " ,
2011-05-29 15:17:23 +04:00
server ,
2007-11-30 04:25:41 +03:00
nt_errstr ( status ) ) ;
2011-07-03 14:08:54 +04:00
return status ;
2007-06-20 21:38:42 +04:00
}
2005-02-25 00:54:52 +03:00
2009-01-15 03:08:19 +03:00
if ( max_protocol = = 0 ) {
max_protocol = PROTOCOL_NT1 ;
}
2005-02-25 00:54:52 +03:00
c - > protocol = max_protocol ;
2009-03-18 00:53:06 +03:00
c - > use_kerberos = get_cmdline_auth_info_use_kerberos ( auth_info ) ;
c - > fallback_after_kerberos =
get_cmdline_auth_info_fallback_after_kerberos ( auth_info ) ;
2010-01-24 19:08:56 +03:00
c - > use_ccache = get_cmdline_auth_info_use_ccache ( auth_info ) ;
2005-02-25 00:54:52 +03:00
DEBUG ( 4 , ( " session request ok \n " ) ) ;
2008-09-11 20:57:49 +04:00
status = cli_negprot ( c ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
d_printf ( " protocol negotiation failed: %s \n " ,
nt_errstr ( status ) ) ;
2005-02-25 00:54:52 +03:00
cli_shutdown ( c ) ;
2011-07-03 14:08:54 +04:00
return status ;
2005-02-25 00:54:52 +03:00
}
2009-03-18 00:53:06 +03:00
username = get_cmdline_auth_info_username ( auth_info ) ;
password = get_cmdline_auth_info_password ( auth_info ) ;
2007-11-30 04:25:41 +03:00
2011-07-03 14:04:24 +04:00
status = cli_session_setup ( c , username ,
password , strlen ( password ) ,
password , strlen ( password ) ,
lp_workgroup ( ) ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
2007-11-30 04:25:41 +03:00
/* If a password was not supplied then
* try again with a null username . */
2009-03-18 00:53:06 +03:00
if ( password [ 0 ] | | ! username [ 0 ] | |
get_cmdline_auth_info_use_kerberos ( auth_info ) | |
2011-07-03 14:04:24 +04:00
! NT_STATUS_IS_OK ( status = cli_session_setup ( c , " " ,
2007-11-30 04:25:41 +03:00
" " , 0 ,
" " , 0 ,
lp_workgroup ( ) ) ) ) {
2011-07-03 14:04:24 +04:00
d_printf ( " session setup failed: %s \n " ,
nt_errstr ( status ) ) ;
2007-11-30 04:25:41 +03:00
if ( NT_STATUS_V ( cli_nt_error ( c ) ) = =
2005-02-25 00:54:52 +03:00
NT_STATUS_V ( NT_STATUS_MORE_PROCESSING_REQUIRED ) )
d_printf ( " did you forget to run kinit? \n " ) ;
cli_shutdown ( c ) ;
2011-07-03 14:08:54 +04:00
return status ;
2005-02-25 00:54:52 +03:00
}
d_printf ( " Anonymous login successful \n " ) ;
2009-10-23 02:06:38 +04:00
status = cli_init_creds ( c , " " , lp_workgroup ( ) , " " ) ;
} else {
status = cli_init_creds ( c , username , lp_workgroup ( ) , password ) ;
}
if ( ! NT_STATUS_IS_OK ( status ) ) {
DEBUG ( 10 , ( " cli_init_creds() failed: %s \n " , nt_errstr ( status ) ) ) ;
cli_shutdown ( c ) ;
2011-07-03 14:08:54 +04:00
return status ;
2005-02-25 00:54:52 +03:00
}
if ( show_sessetup ) {
if ( * c - > server_domain ) {
2005-02-25 18:22:49 +03:00
DEBUG ( 0 , ( " Domain=[%s] OS=[%s] Server=[%s] \n " ,
2005-02-25 00:54:52 +03:00
c - > server_domain , c - > server_os , c - > server_type ) ) ;
2007-11-30 04:25:41 +03:00
} else if ( * c - > server_os | | * c - > server_type ) {
2005-02-25 18:22:49 +03:00
DEBUG ( 0 , ( " OS=[%s] Server=[%s] \n " ,
2005-02-25 00:54:52 +03:00
c - > server_os , c - > server_type ) ) ;
2007-11-30 04:25:41 +03:00
}
2005-02-25 00:54:52 +03:00
}
DEBUG ( 4 , ( " session setup ok \n " ) ) ;
2005-05-10 02:39:20 +04:00
/* here's the fun part....to support 'msdfs proxy' shares
2007-11-30 04:25:41 +03:00
( on Samba or windows ) we have to issues a TRANS_GET_DFS_REFERRAL
2005-05-10 02:39:20 +04:00
here before trying to connect to the original share .
2009-10-28 22:48:36 +03:00
cli_check_msdfs_proxy ( ) will fail if it is a normal share . */
2005-05-10 02:39:20 +04:00
2007-11-30 04:25:41 +03:00
if ( ( c - > capabilities & CAP_DFS ) & &
cli_check_msdfs_proxy ( ctx , c , sharename ,
2007-12-30 09:39:52 +03:00
& newserver , & newshare ,
force_encrypt ,
username ,
password ,
lp_workgroup ( ) ) ) {
2005-05-10 02:39:20 +04:00
cli_shutdown ( c ) ;
2007-12-30 09:39:52 +03:00
return do_connect ( ctx , newserver ,
2009-03-18 00:53:06 +03:00
newshare , auth_info , false ,
2009-01-15 03:08:19 +03:00
force_encrypt , max_protocol ,
2011-07-03 14:08:54 +04:00
port , name_type , pcli ) ;
2005-05-10 02:39:20 +04:00
}
/* must be a normal share */
2009-01-26 10:37:13 +03:00
status = cli_tcon_andx ( c , sharename , " ????? " ,
password , strlen ( password ) + 1 ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
d_printf ( " tree connect failed: %s \n " , nt_errstr ( status ) ) ;
2005-02-25 00:54:52 +03:00
cli_shutdown ( c ) ;
2011-07-03 14:08:54 +04:00
return status ;
2005-02-25 00:54:52 +03:00
}
2008-01-05 11:23:35 +03:00
if ( force_encrypt ) {
status = cli_cm_force_encryption ( c ,
2007-12-30 09:39:52 +03:00
username ,
password ,
lp_workgroup ( ) ,
2008-01-05 11:23:35 +03:00
sharename ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
cli_shutdown ( c ) ;
2011-07-03 14:08:54 +04:00
return status ;
2008-01-05 11:23:35 +03:00
}
2007-12-30 09:39:52 +03:00
}
2005-02-25 00:54:52 +03:00
DEBUG ( 4 , ( " tconx ok \n " ) ) ;
2011-07-03 14:08:54 +04:00
* pcli = c ;
return NT_STATUS_OK ;
2005-02-25 00:54:52 +03:00
}
2005-02-26 17:42:55 +03:00
/****************************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-03-13 03:59:24 +03:00
static void cli_set_mntpoint ( struct cli_state * cli , const char * mnt )
2005-02-26 17:42:55 +03:00
{
2009-03-13 03:59:24 +03:00
char * name = clean_name ( NULL , mnt ) ;
if ( ! name ) {
return ;
2007-11-30 04:25:41 +03:00
}
2009-03-13 03:59:24 +03:00
TALLOC_FREE ( cli - > dfs_mountpoint ) ;
cli - > dfs_mountpoint = talloc_strdup ( cli , name ) ;
TALLOC_FREE ( name ) ;
2005-02-26 17:42:55 +03:00
}
2005-02-25 00:54:52 +03:00
/********************************************************************
2009-03-13 03:59:24 +03:00
Add a new connection to the list .
referring_cli = = NULL means a new initial connection .
2005-02-25 00:54:52 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2011-07-03 14:12:45 +04:00
static NTSTATUS cli_cm_connect ( TALLOC_CTX * ctx ,
struct cli_state * referring_cli ,
const char * server ,
const char * share ,
const struct user_auth_info * auth_info ,
bool show_hdr ,
bool force_encrypt ,
int max_protocol ,
int port ,
int name_type ,
struct cli_state * * pcli )
2005-02-25 00:54:52 +03:00
{
2009-03-13 03:59:24 +03:00
struct cli_state * cli ;
2011-07-03 14:08:54 +04:00
NTSTATUS status ;
2007-11-30 00:24:54 +03:00
2011-07-03 14:08:54 +04:00
status = do_connect ( ctx , server , share ,
2009-03-18 00:53:06 +03:00
auth_info ,
2009-01-15 03:08:19 +03:00
show_hdr , force_encrypt , max_protocol ,
2011-07-03 14:08:54 +04:00
port , name_type , & cli ) ;
2005-02-25 00:54:52 +03:00
2011-07-03 14:08:54 +04:00
if ( ! NT_STATUS_IS_OK ( status ) ) {
2011-07-03 14:12:45 +04:00
return status ;
2005-02-25 00:54:52 +03:00
}
2009-03-13 03:59:24 +03:00
/* Enter into the list. */
if ( referring_cli ) {
DLIST_ADD_END ( referring_cli , cli , struct cli_state * ) ;
}
2005-02-26 17:42:55 +03:00
2010-04-14 05:41:14 +04:00
if ( referring_cli & & referring_cli - > requested_posix_capabilities ) {
2007-12-07 04:16:33 +03:00
uint16 major , minor ;
uint32 caplow , caphigh ;
2009-11-13 01:07:21 +03:00
status = cli_unix_extensions_version ( cli , & major , & minor ,
& caplow , & caphigh ) ;
if ( NT_STATUS_IS_OK ( status ) ) {
2009-03-13 03:59:24 +03:00
cli_set_unix_extensions_capabilities ( cli ,
2007-12-07 04:17:03 +03:00
major , minor ,
2007-12-07 04:16:33 +03:00
caplow , caphigh ) ;
}
}
2005-02-25 00:54:52 +03:00
2011-07-03 14:12:45 +04:00
* pcli = cli ;
return NT_STATUS_OK ;
2005-02-25 00:54:52 +03:00
}
/********************************************************************
2009-03-13 03:59:24 +03:00
Return a connection to a server on a particular share .
2005-02-25 00:54:52 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-03-13 03:59:24 +03:00
static struct cli_state * cli_cm_find ( struct cli_state * cli ,
const char * server ,
const char * share )
2005-02-25 00:54:52 +03:00
{
2009-03-13 03:59:24 +03:00
struct cli_state * p ;
2005-02-25 00:54:52 +03:00
2009-03-13 03:59:24 +03:00
if ( cli = = NULL ) {
return NULL ;
}
/* Search to the start of the list. */
2010-02-06 04:40:38 +03:00
for ( p = cli ; p ; p = DLIST_PREV ( p ) ) {
2009-03-13 03:59:24 +03:00
if ( strequal ( server , p - > desthost ) & &
strequal ( share , p - > share ) ) {
return p ;
}
}
/* Search to the end of the list. */
for ( p = cli - > next ; p ; p = p - > next ) {
if ( strequal ( server , p - > desthost ) & &
strequal ( share , p - > share ) ) {
return p ;
2007-11-30 04:25:41 +03:00
}
2005-02-25 00:54:52 +03:00
}
return NULL ;
}
/****************************************************************************
2009-03-13 03:59:24 +03:00
Open a client connection to a \ \ server \ share .
2005-02-25 00:54:52 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2011-07-03 21:59:37 +04:00
NTSTATUS cli_cm_open ( TALLOC_CTX * ctx ,
2007-12-07 04:16:33 +03:00
struct cli_state * referring_cli ,
2007-11-30 04:25:41 +03:00
const char * server ,
2007-03-12 20:55:24 +03:00
const char * share ,
2009-03-18 00:53:06 +03:00
const struct user_auth_info * auth_info ,
2007-12-30 09:39:52 +03:00
bool show_hdr ,
2009-01-15 01:26:56 +03:00
bool force_encrypt ,
2009-01-15 03:08:19 +03:00
int max_protocol ,
int port ,
2011-07-03 21:59:37 +04:00
int name_type ,
struct cli_state * * pcli )
2005-02-25 00:54:52 +03:00
{
2009-03-13 03:59:24 +03:00
/* Try to reuse an existing connection in this list. */
struct cli_state * c = cli_cm_find ( referring_cli , server , share ) ;
2011-07-03 14:12:45 +04:00
NTSTATUS status ;
2007-11-30 04:25:41 +03:00
2009-03-13 03:59:24 +03:00
if ( c ) {
2011-07-03 21:59:37 +04:00
* pcli = c ;
return NT_STATUS_OK ;
2009-03-13 03:59:24 +03:00
}
2005-02-25 00:54:52 +03:00
2009-03-18 00:53:06 +03:00
if ( auth_info = = NULL ) {
/* Can't do a new connection
* without auth info . */
d_printf ( " cli_cm_open() Unable to open connection [ \\ %s \\ %s] "
" without auth info \n " ,
server , share ) ;
2011-07-03 21:59:37 +04:00
return NT_STATUS_INVALID_PARAMETER ;
2009-03-18 00:53:06 +03:00
}
2011-07-03 14:12:45 +04:00
status = cli_cm_connect ( ctx ,
2009-03-18 00:53:06 +03:00
referring_cli ,
server ,
share ,
auth_info ,
show_hdr ,
force_encrypt ,
max_protocol ,
port ,
2011-07-03 14:12:45 +04:00
name_type ,
& c ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
2011-07-03 21:59:37 +04:00
return status ;
2011-07-03 14:12:45 +04:00
}
2011-07-03 21:59:37 +04:00
* pcli = c ;
return NT_STATUS_OK ;
2005-02-25 00:54:52 +03:00
}
/****************************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-03-13 03:59:24 +03:00
void cli_cm_display ( const struct cli_state * cli )
2005-02-25 00:54:52 +03:00
{
int i ;
2009-03-13 03:59:24 +03:00
for ( i = 0 ; cli ; cli = cli - > next , i + + ) {
2007-11-30 04:25:41 +03:00
d_printf ( " %d: \t server=%s, share=%s \n " ,
2009-03-13 03:59:24 +03:00
i , cli - > desthost , cli - > share ) ;
2005-02-25 00:54:52 +03:00
}
}
/****************************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2008-04-10 23:21:27 +04:00
/****************************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-03-18 00:53:06 +03:00
#if 0
2008-12-14 15:06:19 +03:00
void cli_cm_set_credentials ( struct user_auth_info * auth_info )
2005-02-25 00:54:52 +03:00
{
2007-11-30 04:25:41 +03:00
SAFE_FREE ( cm_creds . username ) ;
2008-12-14 15:06:19 +03:00
cm_creds . username = SMB_STRDUP ( get_cmdline_auth_info_username (
auth_info ) ) ;
2007-11-30 04:25:41 +03:00
2008-12-14 15:06:19 +03:00
if ( get_cmdline_auth_info_got_pass ( auth_info ) ) {
cm_set_password ( get_cmdline_auth_info_password ( auth_info ) ) ;
2007-11-30 04:25:41 +03:00
}
2008-12-14 15:06:19 +03:00
cm_creds . use_kerberos = get_cmdline_auth_info_use_kerberos ( auth_info ) ;
2008-04-10 23:21:27 +04:00
cm_creds . fallback_after_kerberos = false ;
2008-12-14 15:06:19 +03:00
cm_creds . signing_state = get_cmdline_auth_info_signing_state ( auth_info ) ;
2005-02-25 00:54:52 +03:00
}
2009-03-18 00:53:06 +03:00
# endif
2008-04-10 23:21:27 +04:00
2007-02-03 20:20:53 +03:00
/**********************************************************************
split a dfs path into the server , share name , and extrapath components
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2005-02-22 06:31:22 +03:00
2010-11-11 16:04:06 +03:00
static bool split_dfs_path ( TALLOC_CTX * ctx ,
2007-11-30 04:25:41 +03:00
const char * nodepath ,
char * * pp_server ,
char * * pp_share ,
char * * pp_extrapath )
2005-02-22 06:31:22 +03:00
{
2007-02-03 20:20:53 +03:00
char * p , * q ;
2007-11-30 04:25:41 +03:00
char * path ;
2005-02-22 06:31:22 +03:00
2007-11-30 04:25:41 +03:00
* pp_server = NULL ;
* pp_share = NULL ;
* pp_extrapath = NULL ;
path = talloc_strdup ( ctx , nodepath ) ;
if ( ! path ) {
2010-11-11 16:04:06 +03:00
goto fail ;
2007-11-30 04:25:41 +03:00
}
2005-02-22 06:31:22 +03:00
2007-03-12 20:55:24 +03:00
if ( path [ 0 ] ! = ' \\ ' ) {
2010-11-11 16:04:06 +03:00
goto fail ;
2007-03-12 20:55:24 +03:00
}
2005-02-22 06:31:22 +03:00
2007-02-03 20:20:53 +03:00
p = strchr_m ( path + 1 , ' \\ ' ) ;
2007-03-12 20:55:24 +03:00
if ( ! p ) {
2010-11-11 16:04:06 +03:00
goto fail ;
2007-03-12 20:55:24 +03:00
}
2005-02-22 06:31:22 +03:00
* p = ' \0 ' ;
p + + ;
2007-02-03 20:20:53 +03:00
/* Look for any extra/deep path */
q = strchr_m ( p , ' \\ ' ) ;
if ( q ! = NULL ) {
* q = ' \0 ' ;
q + + ;
2007-11-30 04:25:41 +03:00
* pp_extrapath = talloc_strdup ( ctx , q ) ;
2007-02-03 20:20:53 +03:00
} else {
2007-11-30 04:25:41 +03:00
* pp_extrapath = talloc_strdup ( ctx , " " ) ;
2007-02-03 20:20:53 +03:00
}
2010-11-11 16:04:06 +03:00
if ( * pp_extrapath = = NULL ) {
goto fail ;
}
2007-11-30 04:25:41 +03:00
* pp_share = talloc_strdup ( ctx , p ) ;
2010-11-11 16:04:06 +03:00
if ( * pp_share = = NULL ) {
goto fail ;
}
2007-11-30 04:25:41 +03:00
* pp_server = talloc_strdup ( ctx , & path [ 1 ] ) ;
2010-11-11 16:04:06 +03:00
if ( * pp_server = = NULL ) {
goto fail ;
}
TALLOC_FREE ( path ) ;
return true ;
fail :
TALLOC_FREE ( * pp_share ) ;
TALLOC_FREE ( * pp_extrapath ) ;
TALLOC_FREE ( path ) ;
return false ;
2005-02-22 06:31:22 +03:00
}
2005-02-23 20:29:28 +03:00
/****************************************************************************
2007-03-12 20:55:24 +03:00
Return the original path truncated at the directory component before
2007-11-30 04:25:41 +03:00
the first wildcard character . Trust the caller to provide a NULL
2005-02-23 20:29:28 +03:00
terminated string
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-11-30 04:25:41 +03:00
static char * clean_path ( TALLOC_CTX * ctx , const char * path )
2005-02-23 20:29:28 +03:00
{
2007-03-12 20:55:24 +03:00
size_t len ;
char * p1 , * p2 , * p ;
2007-11-30 04:25:41 +03:00
char * path_out ;
2007-03-12 20:55:24 +03:00
/* No absolute paths. */
while ( IS_DIRECTORY_SEP ( * path ) ) {
path + + ;
}
2007-11-30 04:25:41 +03:00
path_out = talloc_strdup ( ctx , path ) ;
if ( ! path_out ) {
return NULL ;
}
2007-03-12 20:55:24 +03:00
p1 = strchr_m ( path_out , ' * ' ) ;
p2 = strchr_m ( path_out , ' ? ' ) ;
if ( p1 | | p2 ) {
if ( p1 & & p2 ) {
p = MIN ( p1 , p2 ) ;
} else if ( ! p1 ) {
p = p2 ;
} else {
p = p1 ;
2005-02-23 20:29:28 +03:00
}
2007-03-12 20:55:24 +03:00
* p = ' \0 ' ;
/* Now go back to the start of this component. */
p1 = strrchr_m ( path_out , ' / ' ) ;
p2 = strrchr_m ( path_out , ' \\ ' ) ;
p = MAX ( p1 , p2 ) ;
if ( p ) {
2005-02-23 20:29:28 +03:00
* p = ' \0 ' ;
}
}
2007-03-12 20:55:24 +03:00
/* Strip any trailing separator */
len = strlen ( path_out ) ;
if ( ( len > 0 ) & & IS_DIRECTORY_SEP ( path_out [ len - 1 ] ) ) {
path_out [ len - 1 ] = ' \0 ' ;
}
2007-11-30 04:25:41 +03:00
return path_out ;
2005-02-23 20:29:28 +03:00
}
/****************************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-11-30 04:25:41 +03:00
static char * cli_dfs_make_full_path ( TALLOC_CTX * ctx ,
struct cli_state * cli ,
const char * dir )
2005-02-23 20:29:28 +03:00
{
2009-03-19 06:56:48 +03:00
char path_sep = ' \\ ' ;
2007-03-12 20:55:24 +03:00
/* Ensure the extrapath doesn't start with a separator. */
while ( IS_DIRECTORY_SEP ( * dir ) ) {
dir + + ;
2005-02-23 20:29:28 +03:00
}
2010-04-14 05:41:14 +04:00
if ( cli - > requested_posix_capabilities & CIFS_UNIX_POSIX_PATHNAMES_CAP ) {
2009-03-19 06:56:48 +03:00
path_sep = ' / ' ;
}
return talloc_asprintf ( ctx , " %c%s%c%s%c%s " ,
path_sep ,
cli - > desthost ,
path_sep ,
cli - > share ,
path_sep ,
dir ) ;
2005-02-23 20:29:28 +03:00
}
/********************************************************************
check for dfs referral
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2010-11-11 16:46:58 +03:00
static bool cli_dfs_check_error ( struct cli_state * cli , NTSTATUS expected ,
NTSTATUS status )
2005-02-23 20:29:28 +03:00
{
/* only deal with DS when we negotiated NT_STATUS codes and UNICODE */
2010-11-11 16:46:58 +03:00
if ( ! ( cli - > capabilities & CAP_UNICODE ) ) {
2007-11-30 04:25:41 +03:00
return false ;
2010-11-11 16:46:58 +03:00
}
if ( ! ( cli - > capabilities & CAP_STATUS32 ) ) {
return false ;
}
if ( NT_STATUS_EQUAL ( status , expected ) ) {
2007-11-30 04:25:41 +03:00
return true ;
2010-11-11 16:46:58 +03:00
}
2007-11-30 04:25:41 +03:00
return false ;
2005-02-23 20:29:28 +03:00
}
2005-02-22 06:31:22 +03:00
/********************************************************************
2007-11-30 04:25:41 +03:00
Get the dfs referral link .
2005-02-22 06:31:22 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2010-11-11 16:54:25 +03:00
NTSTATUS cli_dfs_get_referral ( TALLOC_CTX * ctx ,
2007-12-07 23:02:44 +03:00
struct cli_state * cli ,
2007-11-30 04:25:41 +03:00
const char * path ,
2009-11-21 23:36:01 +03:00
struct client_dfs_referral * * refs ,
2007-03-12 20:55:24 +03:00
size_t * num_refs ,
2009-07-01 02:29:08 +04:00
size_t * consumed )
2005-02-22 06:31:22 +03:00
{
unsigned int data_len = 0 ;
unsigned int param_len = 0 ;
2010-11-11 16:54:25 +03:00
uint16 setup [ 1 ] ;
uint8_t * param = NULL ;
uint8_t * rdata = NULL ;
2005-02-22 06:31:22 +03:00
char * p ;
2007-12-07 23:02:44 +03:00
char * endp ;
2005-02-22 06:31:22 +03:00
size_t pathlen = 2 * ( strlen ( path ) + 1 ) ;
2009-07-01 02:29:08 +04:00
smb_ucs2_t * path_ucs ;
char * consumed_path = NULL ;
uint16_t consumed_ucs ;
2005-02-22 06:31:22 +03:00
uint16 num_referrals ;
2009-11-21 23:36:01 +03:00
struct client_dfs_referral * referrals = NULL ;
2010-11-11 16:54:25 +03:00
NTSTATUS status ;
2007-11-30 04:25:41 +03:00
2007-12-07 23:02:44 +03:00
* num_refs = 0 ;
* refs = NULL ;
2010-11-11 16:54:25 +03:00
SSVAL ( setup , 0 , TRANSACT2_GET_DFS_REFERRAL ) ;
param = SMB_MALLOC_ARRAY ( uint8_t , 2 + pathlen + 2 ) ;
2007-12-07 23:02:44 +03:00
if ( ! param ) {
2010-11-11 16:54:25 +03:00
status = NT_STATUS_NO_MEMORY ;
2009-07-01 02:29:08 +04:00
goto out ;
2007-12-07 23:02:44 +03:00
}
2005-02-22 06:31:22 +03:00
SSVAL ( param , 0 , 0x03 ) ; /* max referral level */
2010-11-11 16:54:25 +03:00
p = ( char * ) ( & param [ 2 ] ) ;
2005-02-22 06:31:22 +03:00
2009-07-01 02:29:08 +04:00
path_ucs = ( smb_ucs2_t * ) p ;
2007-12-07 23:02:44 +03:00
p + = clistr_push ( cli , p , path , pathlen , STR_TERMINATE ) ;
2005-02-22 06:31:22 +03:00
param_len = PTR_DIFF ( p , param ) ;
2010-11-11 16:54:25 +03:00
status = cli_trans ( talloc_tos ( ) , cli , SMBtrans2 ,
NULL , 0xffff , 0 , 0 ,
setup , 1 , 0 ,
param , param_len , 2 ,
NULL , 0 , cli - > max_xmit ,
NULL ,
NULL , 0 , NULL , /* rsetup */
NULL , 0 , NULL ,
& rdata , 4 , & data_len ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
2009-07-01 02:29:08 +04:00
goto out ;
2005-02-22 06:31:22 +03:00
}
2007-12-07 23:02:44 +03:00
if ( data_len < 4 ) {
goto out ;
}
2007-11-30 04:25:41 +03:00
2010-11-11 16:54:25 +03:00
endp = ( char * ) rdata + data_len ;
2007-12-07 23:02:44 +03:00
2009-07-01 02:29:08 +04:00
consumed_ucs = SVAL ( rdata , 0 ) ;
2007-12-07 23:02:44 +03:00
num_referrals = SVAL ( rdata , 2 ) ;
2009-07-01 02:29:08 +04:00
/* consumed_ucs is the number of bytes
* of the UCS2 path consumed not counting any
* terminating null . We need to convert
* back to unix charset and count again
* to get the number of bytes consumed from
* the incoming path . */
if ( pull_string_talloc ( talloc_tos ( ) ,
NULL ,
0 ,
& consumed_path ,
path_ucs ,
consumed_ucs ,
STR_UNICODE ) = = 0 ) {
goto out ;
}
if ( consumed_path = = NULL ) {
goto out ;
}
* consumed = strlen ( consumed_path ) ;
2007-12-07 23:02:44 +03:00
if ( num_referrals ! = 0 ) {
2005-02-22 06:31:22 +03:00
uint16 ref_version ;
uint16 ref_size ;
int i ;
uint16 node_offset ;
2007-03-12 20:55:24 +03:00
2009-11-21 23:36:01 +03:00
referrals = talloc_array ( ctx , struct client_dfs_referral ,
num_referrals ) ;
2007-03-12 20:55:24 +03:00
2007-12-07 23:02:44 +03:00
if ( ! referrals ) {
goto out ;
}
2005-02-22 06:31:22 +03:00
/* start at the referrals array */
2007-11-30 04:25:41 +03:00
2010-11-11 16:54:25 +03:00
p = ( char * ) rdata + 8 ;
2007-12-07 23:02:44 +03:00
for ( i = 0 ; i < num_referrals & & p < endp ; i + + ) {
if ( p + 18 > endp ) {
goto out ;
}
ref_version = SVAL ( p , 0 ) ;
ref_size = SVAL ( p , 2 ) ;
node_offset = SVAL ( p , 16 ) ;
2007-11-30 04:25:41 +03:00
2007-12-07 23:02:44 +03:00
if ( ref_version ! = 3 ) {
2005-02-22 06:31:22 +03:00
p + = ref_size ;
continue ;
}
2007-11-30 04:25:41 +03:00
2007-12-07 23:02:44 +03:00
referrals [ i ] . proximity = SVAL ( p , 8 ) ;
referrals [ i ] . ttl = SVAL ( p , 10 ) ;
2005-02-22 06:31:22 +03:00
2007-12-07 23:02:44 +03:00
if ( p + node_offset > endp ) {
goto out ;
}
2009-01-26 05:38:05 +03:00
clistr_pull_talloc ( ctx , cli - > inbuf ,
2010-08-05 15:45:59 +04:00
SVAL ( cli - > inbuf , smb_flg2 ) ,
2009-01-26 05:38:05 +03:00
& referrals [ i ] . dfspath ,
2011-03-24 05:00:37 +03:00
p + node_offset ,
cli - > bufsize - ( ( p + node_offset ) - cli - > inbuf ) ,
2009-01-26 05:38:05 +03:00
STR_TERMINATE | STR_UNICODE ) ;
2005-02-22 06:31:22 +03:00
2007-12-07 23:02:44 +03:00
if ( ! referrals [ i ] . dfspath ) {
goto out ;
}
2005-02-22 06:31:22 +03:00
p + = ref_size ;
}
2007-12-07 23:02:44 +03:00
if ( i < num_referrals ) {
goto out ;
}
2005-02-22 06:31:22 +03:00
}
2007-11-30 04:25:41 +03:00
2005-02-22 06:31:22 +03:00
* num_refs = num_referrals ;
* refs = referrals ;
2007-12-07 23:02:44 +03:00
out :
2009-07-01 02:29:08 +04:00
TALLOC_FREE ( consumed_path ) ;
SAFE_FREE ( param ) ;
2010-11-11 16:54:25 +03:00
TALLOC_FREE ( rdata ) ;
return status ;
2005-02-22 06:31:22 +03:00
}
2005-02-23 20:29:28 +03:00
/********************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2011-07-03 22:53:55 +04:00
NTSTATUS cli_resolve_path ( TALLOC_CTX * ctx ,
const char * mountpt ,
const struct user_auth_info * dfs_auth_info ,
struct cli_state * rootcli ,
const char * path ,
struct cli_state * * targetcli ,
char * * pp_targetpath )
2005-02-23 20:29:28 +03:00
{
2009-11-21 23:36:01 +03:00
struct client_dfs_referral * refs = NULL ;
2007-12-07 23:02:44 +03:00
size_t num_refs = 0 ;
2009-07-01 02:29:08 +04:00
size_t consumed = 0 ;
2007-11-30 04:25:41 +03:00
struct cli_state * cli_ipc = NULL ;
char * dfs_path = NULL ;
char * cleanpath = NULL ;
char * extrapath = NULL ;
2005-02-23 20:29:28 +03:00
int pathlen ;
2007-11-30 04:25:41 +03:00
char * server = NULL ;
char * share = NULL ;
struct cli_state * newcli = NULL ;
char * newpath = NULL ;
char * newmount = NULL ;
char * ppath = NULL ;
2005-02-23 20:29:28 +03:00
SMB_STRUCT_STAT sbuf ;
uint32 attributes ;
2010-02-07 16:07:17 +03:00
NTSTATUS status ;
2007-11-30 04:25:41 +03:00
2007-03-09 02:54:57 +03:00
if ( ! rootcli | | ! path | | ! targetcli ) {
2011-07-03 22:53:55 +04:00
return NT_STATUS_INVALID_PARAMETER ;
2007-03-09 02:54:57 +03:00
}
2007-11-30 04:25:41 +03:00
2007-03-12 20:55:24 +03:00
/* Don't do anything if this is not a DFS root. */
2005-02-23 20:29:28 +03:00
2007-03-12 20:55:24 +03:00
if ( ! rootcli - > dfsroot ) {
2005-02-23 20:29:28 +03:00
* targetcli = rootcli ;
2007-11-30 04:25:41 +03:00
* pp_targetpath = talloc_strdup ( ctx , path ) ;
if ( ! * pp_targetpath ) {
2011-07-03 22:53:55 +04:00
return NT_STATUS_NO_MEMORY ;
2007-11-30 04:25:41 +03:00
}
2011-07-03 22:53:55 +04:00
return NT_STATUS_OK ;
2005-02-23 20:29:28 +03:00
}
2007-03-12 20:55:24 +03:00
* targetcli = NULL ;
/* Send a trans2_query_path_info to check for a referral. */
2007-11-30 04:25:41 +03:00
cleanpath = clean_path ( ctx , path ) ;
if ( ! cleanpath ) {
2011-07-03 22:53:55 +04:00
return NT_STATUS_NO_MEMORY ;
2007-11-30 04:25:41 +03:00
}
dfs_path = cli_dfs_make_full_path ( ctx , rootcli , cleanpath ) ;
if ( ! dfs_path ) {
2011-07-03 22:53:55 +04:00
return NT_STATUS_NO_MEMORY ;
2007-11-30 04:25:41 +03:00
}
2007-03-12 20:55:24 +03:00
2010-02-07 16:07:17 +03:00
status = cli_qpathinfo_basic ( rootcli , dfs_path , & sbuf , & attributes ) ;
if ( NT_STATUS_IS_OK ( status ) ) {
2007-03-12 20:55:24 +03:00
/* This is an ordinary path, just return it. */
* targetcli = rootcli ;
2007-11-30 04:25:41 +03:00
* pp_targetpath = talloc_strdup ( ctx , path ) ;
if ( ! * pp_targetpath ) {
2011-07-03 22:53:55 +04:00
return NT_STATUS_NO_MEMORY ;
2007-11-30 04:25:41 +03:00
}
2007-03-12 20:55:24 +03:00
goto done ;
}
/* Special case where client asked for a path that does not exist */
2005-05-10 16:21:02 +04:00
2010-11-11 16:46:58 +03:00
if ( cli_dfs_check_error ( rootcli , NT_STATUS_OBJECT_NAME_NOT_FOUND ,
status ) ) {
2005-05-10 16:21:02 +04:00
* targetcli = rootcli ;
2007-11-30 04:25:41 +03:00
* pp_targetpath = talloc_strdup ( ctx , path ) ;
if ( ! * pp_targetpath ) {
2011-07-03 22:53:55 +04:00
return NT_STATUS_NO_MEMORY ;
2007-11-30 04:25:41 +03:00
}
2007-03-09 02:54:57 +03:00
goto done ;
2005-05-10 16:21:02 +04:00
}
2007-03-12 20:55:24 +03:00
/* We got an error, check for DFS referral. */
2010-11-11 16:46:58 +03:00
if ( ! cli_dfs_check_error ( rootcli , NT_STATUS_PATH_NOT_COVERED ,
status ) ) {
2011-07-03 22:53:55 +04:00
return status ;
2007-03-09 02:54:57 +03:00
}
2005-02-23 20:29:28 +03:00
2007-03-12 20:55:24 +03:00
/* Check for the referral. */
2005-02-23 20:29:28 +03:00
2011-07-03 21:59:37 +04:00
status = cli_cm_open ( ctx ,
rootcli ,
rootcli - > desthost ,
" IPC$ " ,
dfs_auth_info ,
false ,
( rootcli - > trans_enc_state ! = NULL ) ,
rootcli - > protocol ,
0 ,
0x20 ,
& cli_ipc ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
2011-07-03 22:53:55 +04:00
return status ;
2007-03-09 02:54:57 +03:00
}
2007-11-30 04:25:41 +03:00
2010-11-11 16:54:25 +03:00
status = cli_dfs_get_referral ( ctx , cli_ipc , dfs_path , & refs ,
& num_refs , & consumed ) ;
if ( ! NT_STATUS_IS_OK ( status ) | | ! num_refs ) {
2011-07-03 22:53:55 +04:00
return status ;
2005-02-23 20:29:28 +03:00
}
2007-11-30 04:25:41 +03:00
2007-03-12 20:55:24 +03:00
/* Just store the first referral for now. */
2005-02-23 20:29:28 +03:00
2007-12-07 23:02:44 +03:00
if ( ! refs [ 0 ] . dfspath ) {
2011-07-03 22:53:55 +04:00
return NT_STATUS_NOT_FOUND ;
2007-12-07 23:02:44 +03:00
}
2010-11-11 16:04:06 +03:00
if ( ! split_dfs_path ( ctx , refs [ 0 ] . dfspath , & server , & share ,
& extrapath ) ) {
2011-07-03 22:53:55 +04:00
return NT_STATUS_NOT_FOUND ;
2007-11-30 04:25:41 +03:00
}
2007-03-12 20:55:24 +03:00
/* Make sure to recreate the original string including any wildcards. */
2007-11-30 04:25:41 +03:00
dfs_path = cli_dfs_make_full_path ( ctx , rootcli , path ) ;
if ( ! dfs_path ) {
2011-07-03 22:53:55 +04:00
return NT_STATUS_NO_MEMORY ;
2007-11-30 04:25:41 +03:00
}
2009-07-01 02:29:08 +04:00
pathlen = strlen ( dfs_path ) ;
2007-11-30 04:25:41 +03:00
consumed = MIN ( pathlen , consumed ) ;
2009-07-01 02:29:08 +04:00
* pp_targetpath = talloc_strdup ( ctx , & dfs_path [ consumed ] ) ;
2007-11-30 04:25:41 +03:00
if ( ! * pp_targetpath ) {
2011-07-03 22:53:55 +04:00
return NT_STATUS_NO_MEMORY ;
2007-11-30 04:25:41 +03:00
}
2009-07-01 02:29:08 +04:00
dfs_path [ consumed ] = ' \0 ' ;
2007-03-12 20:55:24 +03:00
/*
2007-11-30 04:25:41 +03:00
* * pp_targetpath is now the unconsumed part of the path .
* dfs_path is now the consumed part of the path
* ( in \ server \ share \ path format ) .
2007-03-12 20:55:24 +03:00
*/
/* Open the connection to the target server & share */
2011-07-03 21:59:37 +04:00
status = cli_cm_open ( ctx , rootcli ,
server ,
share ,
dfs_auth_info ,
false ,
( rootcli - > trans_enc_state ! = NULL ) ,
rootcli - > protocol ,
0 ,
0x20 ,
targetcli ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
2007-03-12 20:55:24 +03:00
d_printf ( " Unable to follow dfs referral [ \\ %s \\ %s] \n " ,
2005-02-23 20:29:28 +03:00
server , share ) ;
2011-07-03 22:53:55 +04:00
return status ;
2005-02-23 20:29:28 +03:00
}
2007-11-30 04:25:41 +03:00
if ( extrapath & & strlen ( extrapath ) > 0 ) {
2011-03-27 01:39:27 +03:00
/* EMC Celerra NAS version 5.6.50 (at least) doesn't appear to */
/* put the trailing \ on the path, so to be save we put one in if needed */
if ( extrapath [ strlen ( extrapath ) - 1 ] ! = ' \\ ' & & * * pp_targetpath ! = ' \\ ' ) {
* pp_targetpath = talloc_asprintf ( ctx ,
" %s \\ %s " ,
extrapath ,
* pp_targetpath ) ;
} else {
* pp_targetpath = talloc_asprintf ( ctx ,
" %s%s " ,
extrapath ,
* pp_targetpath ) ;
}
2007-11-30 04:25:41 +03:00
if ( ! * pp_targetpath ) {
2011-07-03 22:53:55 +04:00
return NT_STATUS_NO_MEMORY ;
2007-11-30 04:25:41 +03:00
}
2007-03-12 20:55:24 +03:00
}
2007-11-30 04:25:41 +03:00
2005-02-26 18:03:16 +03:00
/* parse out the consumed mount path */
/* trim off the \server\share\ */
2005-02-23 23:00:26 +03:00
2007-03-12 20:55:24 +03:00
ppath = dfs_path ;
if ( * ppath ! = ' \\ ' ) {
2007-11-30 04:25:41 +03:00
d_printf ( " cli_resolve_path: "
" dfs_path (%s) not in correct format. \n " ,
2007-03-12 20:55:24 +03:00
dfs_path ) ;
2011-07-03 22:53:55 +04:00
return NT_STATUS_NOT_FOUND ;
2007-03-09 02:54:57 +03:00
}
2007-03-12 20:55:24 +03:00
ppath + + ; /* Now pointing at start of server name. */
2007-11-30 04:25:41 +03:00
2007-03-12 20:55:24 +03:00
if ( ( ppath = strchr_m ( dfs_path , ' \\ ' ) ) = = NULL ) {
2011-07-03 22:53:55 +04:00
return NT_STATUS_NOT_FOUND ;
2007-03-09 02:54:57 +03:00
}
2007-03-12 20:55:24 +03:00
ppath + + ; /* Now pointing at start of share name. */
2007-03-09 02:54:57 +03:00
2007-03-12 20:55:24 +03:00
if ( ( ppath = strchr_m ( ppath + 1 , ' \\ ' ) ) = = NULL ) {
2011-07-03 22:53:55 +04:00
return NT_STATUS_NOT_FOUND ;
2007-03-09 02:54:57 +03:00
}
2007-03-12 20:55:24 +03:00
ppath + + ; /* Now pointing at path component. */
2007-11-30 04:25:41 +03:00
newmount = talloc_asprintf ( ctx , " %s \\ %s " , mountpt , ppath ) ;
if ( ! newmount ) {
2011-07-03 22:53:55 +04:00
return NT_STATUS_NOT_FOUND ;
2007-11-30 04:25:41 +03:00
}
2007-03-12 20:55:24 +03:00
2009-03-13 03:59:24 +03:00
cli_set_mntpoint ( * targetcli , newmount ) ;
2005-02-26 18:03:16 +03:00
2007-11-30 04:25:41 +03:00
/* Check for another dfs referral, note that we are not
2007-03-12 20:55:24 +03:00
checking for loops here . */
2005-02-23 23:00:26 +03:00
2007-11-30 04:25:41 +03:00
if ( ! strequal ( * pp_targetpath , " \\ " ) & & ! strequal ( * pp_targetpath , " / " ) ) {
2011-07-03 22:53:55 +04:00
status = cli_resolve_path ( ctx ,
newmount ,
dfs_auth_info ,
* targetcli ,
* pp_targetpath ,
& newcli ,
& newpath ) ;
if ( NT_STATUS_IS_OK ( status ) ) {
2007-03-12 20:55:24 +03:00
/*
* When cli_resolve_path returns true here it ' s always
* returning the complete path in newpath , so we ' re done
* here .
*/
2005-02-24 22:10:28 +03:00
* targetcli = newcli ;
2007-11-30 04:25:41 +03:00
* pp_targetpath = newpath ;
2011-07-03 22:53:55 +04:00
return status ;
2005-02-24 22:10:28 +03:00
}
2005-02-23 23:00:26 +03:00
}
2005-02-26 18:03:16 +03:00
2007-03-09 02:54:57 +03:00
done :
2007-11-30 04:25:41 +03:00
/* If returning true ensure we return a dfs root full path. */
if ( ( * targetcli ) - > dfsroot ) {
dfs_path = talloc_strdup ( ctx , * pp_targetpath ) ;
if ( ! dfs_path ) {
2011-07-03 22:53:55 +04:00
return NT_STATUS_NO_MEMORY ;
2007-11-30 04:25:41 +03:00
}
* pp_targetpath = cli_dfs_make_full_path ( ctx , * targetcli , dfs_path ) ;
2011-07-03 22:53:55 +04:00
if ( * pp_targetpath = = NULL ) {
return NT_STATUS_NO_MEMORY ;
}
2007-03-09 02:54:57 +03:00
}
2011-07-03 22:53:55 +04:00
return NT_STATUS_OK ;
2007-11-30 04:25:41 +03:00
}
2005-05-10 02:39:20 +04:00
/********************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-10-28 22:48:36 +03:00
bool cli_check_msdfs_proxy ( TALLOC_CTX * ctx ,
2007-11-30 04:25:41 +03:00
struct cli_state * cli ,
const char * sharename ,
char * * pp_newserver ,
2007-12-30 09:39:52 +03:00
char * * pp_newshare ,
bool force_encrypt ,
const char * username ,
const char * password ,
const char * domain )
2005-05-10 02:39:20 +04:00
{
2009-11-21 23:36:01 +03:00
struct client_dfs_referral * refs = NULL ;
2007-12-07 23:02:44 +03:00
size_t num_refs = 0 ;
2009-07-01 02:29:08 +04:00
size_t consumed = 0 ;
2007-11-30 04:25:41 +03:00
char * fullpath = NULL ;
2007-10-19 04:40:25 +04:00
bool res ;
2006-02-04 01:19:41 +03:00
uint16 cnum ;
2007-11-30 04:25:41 +03:00
char * newextrapath = NULL ;
2010-01-03 20:46:57 +03:00
NTSTATUS status ;
2007-11-30 04:25:41 +03:00
if ( ! cli | | ! sharename ) {
return false ;
}
2005-05-10 02:39:20 +04:00
2006-02-04 01:19:41 +03:00
cnum = cli - > cnum ;
2005-05-10 02:39:20 +04:00
/* special case. never check for a referral on the IPC$ share */
2007-11-30 04:25:41 +03:00
if ( strequal ( sharename , " IPC$ " ) ) {
return false ;
2007-03-12 20:55:24 +03:00
}
2007-11-30 04:25:41 +03:00
2005-05-10 02:39:20 +04:00
/* send a trans2_query_path_info to check for a referral */
2007-11-30 04:25:41 +03:00
fullpath = talloc_asprintf ( ctx , " \\ %s \\ %s " , cli - > desthost , sharename ) ;
if ( ! fullpath ) {
return false ;
}
2005-05-10 02:39:20 +04:00
/* check for the referral */
2009-01-26 10:37:13 +03:00
if ( ! NT_STATUS_IS_OK ( cli_tcon_andx ( cli , " IPC$ " , " IPC " , NULL , 0 ) ) ) {
2007-11-30 04:25:41 +03:00
return false ;
2006-02-04 01:19:41 +03:00
}
2008-01-05 11:23:35 +03:00
if ( force_encrypt ) {
2010-01-03 20:46:57 +03:00
status = cli_cm_force_encryption ( cli ,
2007-12-30 09:39:52 +03:00
username ,
password ,
lp_workgroup ( ) ,
2008-01-05 11:23:35 +03:00
" IPC$ " ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
return false ;
}
2007-12-30 09:39:52 +03:00
}
2010-11-11 16:54:25 +03:00
status = cli_dfs_get_referral ( ctx , cli , fullpath , & refs ,
& num_refs , & consumed ) ;
res = NT_STATUS_IS_OK ( status ) ;
2006-02-04 01:19:41 +03:00
2010-01-03 20:46:57 +03:00
status = cli_tdis ( cli ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
2007-11-30 04:25:41 +03:00
return false ;
2006-02-04 01:19:41 +03:00
}
cli - > cnum = cnum ;
2007-03-09 02:54:57 +03:00
2007-11-30 04:25:41 +03:00
if ( ! res | | ! num_refs ) {
2007-12-07 23:02:44 +03:00
return false ;
}
if ( ! refs [ 0 ] . dfspath ) {
2007-11-30 04:25:41 +03:00
return false ;
}
2010-11-11 16:04:06 +03:00
if ( ! split_dfs_path ( ctx , refs [ 0 ] . dfspath , pp_newserver ,
pp_newshare , & newextrapath ) ) {
2007-11-30 04:25:41 +03:00
return false ;
2005-05-10 02:39:20 +04:00
}
/* check that this is not a self-referral */
2007-11-30 04:25:41 +03:00
if ( strequal ( cli - > desthost , * pp_newserver ) & &
strequal ( sharename , * pp_newshare ) ) {
return false ;
2006-07-29 00:35:00 +04:00
}
2007-11-30 04:25:41 +03:00
return true ;
2005-05-10 02:39:20 +04:00
}