From f692694b99319ef1f534ea29f001922656402cdf Mon Sep 17 00:00:00 2001 From: Jeremy Allison Date: Thu, 29 Nov 2007 17:25:41 -0800 Subject: Remove PSTRING_LEN from smbd/ nmbd/. Remove pstring from libsmb/clidfs.c except for a nasty hack (that will be removed when pstrings are gone from client/). Jeremy. (This used to be commit cc257b71d13daa47e6f2315d0f07a60eb4aaeca6) --- source3/libsmb/cliconnect.c | 15 +- source3/libsmb/clidfs.c | 573 ++++++++++++++++++++++++++---------------- source3/libsmb/libsmbclient.c | 169 ++++++------- 3 files changed, 439 insertions(+), 318 deletions(-) (limited to 'source3/libsmb') diff --git a/source3/libsmb/cliconnect.c b/source3/libsmb/cliconnect.c index e3800bfb33..14140811d2 100644 --- a/source3/libsmb/cliconnect.c +++ b/source3/libsmb/cliconnect.c @@ -879,8 +879,8 @@ ntlmssp: password is in plaintext, the same should be done. ****************************************************************************/ -NTSTATUS cli_session_setup(struct cli_state *cli, - const char *user, +NTSTATUS cli_session_setup(struct cli_state *cli, + const char *user, const char *pass, int passlen, const char *ntpass, int ntpasslen, const char *workgroup) @@ -888,8 +888,17 @@ NTSTATUS cli_session_setup(struct cli_state *cli, char *p; fstring user2; + if (user) { + fstrcpy(user2, user); + } else { + user2[0] ='\0'; + } + + if (!workgroup) { + workgroup = ""; + } + /* allow for workgroups as part of the username */ - fstrcpy(user2, user); if ((p=strchr_m(user2,'\\')) || (p=strchr_m(user2,'/')) || (p=strchr_m(user2,*lp_winbind_separator()))) { *p = 0; diff --git a/source3/libsmb/clidfs.c b/source3/libsmb/clidfs.c index 469cb231d2..8ff358e26f 100644 --- a/source3/libsmb/clidfs.c +++ b/source3/libsmb/clidfs.c @@ -1,20 +1,20 @@ -/* +/* Unix SMB/CIFS implementation. client connect/disconnect routines Copyright (C) Andrew Tridgell 1994-1998 Copyright (C) Gerald (Jerry) Carter 2004 Copyright (C) Jeremy Allison 2007 - + 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 3 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, see . */ @@ -35,18 +35,22 @@ struct client_connection { struct client_connection *prev, *next; struct cli_state *cli; - pstring mount; + char *mount; }; /* global state....globals reek! */ - -static pstring username; -static pstring password; -static bool use_kerberos; -static bool got_pass; -static int signing_state; int max_protocol = PROTOCOL_NT1; +static struct cm_cred_struct { + char *username; + char *password; + bool got_pass; + bool use_kerberos; + int signing_state; +} cm_creds; + +static void cm_set_password(const char *newpass); + static int port; static int name_type = 0x20; static bool have_ip; @@ -58,31 +62,40 @@ static struct client_connection *connections; Return a connection to a server. ********************************************************************/ -static struct cli_state *do_connect( const char *server, const char *share, - bool show_sessetup ) +static struct cli_state *do_connect(TALLOC_CTX *ctx, + const char *server, + const char *share, + bool show_sessetup) { struct cli_state *c = NULL; struct nmb_name called, calling; const char *server_n; struct sockaddr_storage ss; - pstring servicename; + char *servicename; char *sharename; - fstring newserver, newshare; + char *newserver, *newshare; + const char *username; + const char *password; NTSTATUS status; - + /* make a copy so we don't modify the global string 'service' */ - pstrcpy(servicename, share); + servicename = talloc_strdup(ctx,share); + if (!servicename) { + return NULL; + } sharename = servicename; if (*sharename == '\\') { server = sharename+2; sharename = strchr_m(server,'\\'); - if (!sharename) return NULL; + if (!sharename) { + return NULL; + } *sharename = 0; sharename++; } server_n = server; - + zero_addr(&ss); make_nmb_name(&calling, global_myname(), 0x0); @@ -100,18 +113,19 @@ static struct cli_state *do_connect( const char *server, const char *share, } status = cli_connect(c, server_n, &ss); if (!NT_STATUS_IS_OK(status)) { - d_printf("Connection to %s failed (Error %s)\n", server_n, nt_errstr(status)); + d_printf("Connection to %s failed (Error %s)\n", + server_n, + nt_errstr(status)); return NULL; } c->protocol = max_protocol; - c->use_kerberos = use_kerberos; - cli_setup_signing_state(c, signing_state); - + c->use_kerberos = cm_creds.use_kerberos; + cli_setup_signing_state(c, cm_creds.signing_state); if (!cli_session_request(c, &calling, &called)) { char *p; - d_printf("session request to %s failed (%s)\n", + d_printf("session request to %s failed (%s)\n", called.name, cli_errstr(c)); cli_shutdown(c); c = NULL; @@ -134,24 +148,29 @@ static struct cli_state *do_connect( const char *server, const char *share, return NULL; } - if (!got_pass) { + if (!cm_creds.got_pass) { char *pass = getpass("Password: "); if (pass) { - pstrcpy(password, pass); - got_pass = 1; + cm_set_password(pass); } } - if (!NT_STATUS_IS_OK(cli_session_setup(c, username, + username = cm_creds.username ? cm_creds.username : ""; + password = cm_creds.password ? cm_creds.password : ""; + + if (!NT_STATUS_IS_OK(cli_session_setup(c, username, password, strlen(password), password, strlen(password), lp_workgroup()))) { - /* if a password was not supplied then try again with a null username */ - if (password[0] || !username[0] || use_kerberos || - !NT_STATUS_IS_OK(cli_session_setup(c, "", "", 0, "", 0, - lp_workgroup()))) { + /* If a password was not supplied then + * try again with a null username. */ + if (password[0] || !username[0] || cm_creds.use_kerberos || + !NT_STATUS_IS_OK(cli_session_setup(c, "", + "", 0, + "", 0, + lp_workgroup()))) { d_printf("session setup failed: %s\n", cli_errstr(c)); - if (NT_STATUS_V(cli_nt_error(c)) == + if (NT_STATUS_V(cli_nt_error(c)) == NT_STATUS_V(NT_STATUS_MORE_PROCESSING_REQUIRED)) d_printf("did you forget to run kinit?\n"); cli_shutdown(c); @@ -164,55 +183,59 @@ static struct cli_state *do_connect( const char *server, const char *share, if (*c->server_domain) { DEBUG(0,("Domain=[%s] OS=[%s] Server=[%s]\n", c->server_domain,c->server_os,c->server_type)); - } else if (*c->server_os || *c->server_type){ + } else if (*c->server_os || *c->server_type) { DEBUG(0,("OS=[%s] Server=[%s]\n", c->server_os,c->server_type)); - } + } } DEBUG(4,(" session setup ok\n")); /* here's the fun part....to support 'msdfs proxy' shares - (on Samba or windows) we have to issues a TRANS_GET_DFS_REFERRAL + (on Samba or windows) we have to issues a TRANS_GET_DFS_REFERRAL here before trying to connect to the original share. check_dfs_proxy() will fail if it is a normal share. */ - if ( (c->capabilities & CAP_DFS) && cli_check_msdfs_proxy( c, sharename, newserver, newshare ) ) { + if ((c->capabilities & CAP_DFS) && + cli_check_msdfs_proxy(ctx, c, sharename, + &newserver, &newshare)) { cli_shutdown(c); - return do_connect( newserver, newshare, False ); + return do_connect(ctx, newserver, newshare, false); } /* must be a normal share */ - if (!cli_send_tconX(c, sharename, "?????", password, strlen(password)+1)) { + if (!cli_send_tconX(c, sharename, "?????", + password, strlen(password)+1)) { d_printf("tree connect failed: %s\n", cli_errstr(c)); cli_shutdown(c); return NULL; } DEBUG(4,(" tconx ok\n")); - return c; } /**************************************************************************** ****************************************************************************/ -static void cli_cm_set_mntpoint( struct cli_state *c, const char *mnt ) +static void cli_cm_set_mntpoint(struct cli_state *c, const char *mnt) { struct client_connection *p; int i; - for ( p=connections,i=0; p; p=p->next,i++ ) { - if ( strequal(p->cli->desthost, c->desthost) && strequal(p->cli->share, c->share) ) + for (p=connections,i=0; p; p=p->next,i++) { + if (strequal(p->cli->desthost, c->desthost) && + strequal(p->cli->share, c->share)) { break; + } } - - if ( p ) { + + if (p) { char *name = clean_name(NULL, p->mount); if (!name) { return; } - pstrcpy( p->mount, name ); + p->mount = talloc_strdup(p, name); TALLOC_FREE(name); } } @@ -220,19 +243,21 @@ static void cli_cm_set_mntpoint( struct cli_state *c, const char *mnt ) /**************************************************************************** ****************************************************************************/ -const char *cli_cm_get_mntpoint( struct cli_state *c ) +const char *cli_cm_get_mntpoint(struct cli_state *c) { struct client_connection *p; int i; - for ( p=connections,i=0; p; p=p->next,i++ ) { - if ( strequal(p->cli->desthost, c->desthost) && strequal(p->cli->share, c->share) ) + for (p=connections,i=0; p; p=p->next,i++) { + if (strequal(p->cli->desthost, c->desthost) && + strequal(p->cli->share, c->share)) { break; + } } - - if ( p ) + + if (p) { return p->mount; - + } return NULL; } @@ -240,27 +265,29 @@ const char *cli_cm_get_mntpoint( struct cli_state *c ) Add a new connection to the list ********************************************************************/ -static struct cli_state *cli_cm_connect( const char *server, +static struct cli_state *cli_cm_connect(TALLOC_CTX *ctx, + const char *server, const char *share, bool show_hdr) { struct client_connection *node; - node = SMB_CALLOC_ARRAY( struct client_connection, 1); + /* NB This must be the null context here... JRA. */ + node = TALLOC_ZERO_ARRAY(NULL, struct client_connection, 1); if (!node) { return NULL; } - node->cli = do_connect( server, share, show_hdr ); + node->cli = do_connect(ctx, server, share, show_hdr); if ( !node->cli ) { - SAFE_FREE( node ); + TALLOC_FREE( node ); return NULL; } DLIST_ADD( connections, node ); - cli_cm_set_mntpoint( node->cli, "" ); + cli_cm_set_mntpoint(node->cli, ""); return node->cli; @@ -270,35 +297,37 @@ static struct cli_state *cli_cm_connect( const char *server, Return a connection to a server. ********************************************************************/ -static struct cli_state *cli_cm_find( const char *server, const char *share ) +static struct cli_state *cli_cm_find(const char *server, const char *share) { struct client_connection *p; - for ( p=connections; p; p=p->next ) { - if ( strequal(server, p->cli->desthost) && strequal(share,p->cli->share) ) + for (p=connections; p; p=p->next) { + if ( strequal(server, p->cli->desthost) && + strequal(share,p->cli->share)) { return p->cli; + } } return NULL; } /**************************************************************************** - open a client connection to a \\server\share. Set's the current *cli + 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, +struct cli_state *cli_cm_open(TALLOC_CTX *ctx, + 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); + c = cli_cm_find(server, share); + if (!c) { + c = cli_cm_connect(ctx, server, share, show_hdr); } return c; @@ -307,17 +336,16 @@ struct cli_state *cli_cm_open(const char *server, /**************************************************************************** ****************************************************************************/ -void cli_cm_shutdown( void ) +void cli_cm_shutdown(void) { - struct client_connection *p, *x; - for ( p=connections; p; ) { - cli_shutdown( p->cli ); + for (p=connections; p;) { + cli_shutdown(p->cli); x = p; p = p->next; - SAFE_FREE( x ); + TALLOC_FREE(x); } connections = NULL; @@ -333,7 +361,7 @@ void cli_cm_display(void) int i; for ( p=connections,i=0; p; p=p->next,i++ ) { - d_printf("%d:\tserver=%s, share=%s\n", + d_printf("%d:\tserver=%s, share=%s\n", i, p->cli->desthost, p->cli->share ); } } @@ -341,23 +369,32 @@ void cli_cm_display(void) /**************************************************************************** ****************************************************************************/ -void cli_cm_set_credentials( struct user_auth_info *user ) +static void cm_set_password(const char *newpass) +{ + SAFE_FREE(cm_creds.password); + cm_creds.password = SMB_STRDUP(newpass); + if (cm_creds.password) { + cm_creds.got_pass = true; + } +} + +void cli_cm_set_credentials(struct user_auth_info *user) { - pstrcpy( username, user->username ); - - if ( user->got_pass ) { - pstrcpy( password, user->password ); - got_pass = True; - } - - use_kerberos = user->use_kerberos; - signing_state = user->signing_state; + SAFE_FREE(cm_creds.username); + cm_creds.username = SMB_STRDUP(user->username); + + if (user->got_pass) { + cm_set_password(user->password); + } + + cm_creds.use_kerberos = user->use_kerberos; + cm_creds.signing_state = user->signing_state; } /**************************************************************************** ****************************************************************************/ -void cli_cm_set_port( int port_number ) +void cli_cm_set_port(int port_number) { port = port_number; } @@ -365,7 +402,7 @@ void cli_cm_set_port( int port_number ) /**************************************************************************** ****************************************************************************/ -void cli_cm_set_dest_name_type( int type ) +void cli_cm_set_dest_name_type(int type) { name_type = type; } @@ -383,12 +420,23 @@ void cli_cm_set_dest_ss(struct sockaddr_storage *pss) split a dfs path into the server, share name, and extrapath components **********************************************************************/ -static void split_dfs_path( const char *nodepath, fstring server, fstring share, pstring extrapath ) +static void split_dfs_path(TALLOC_CTX *ctx, + const char *nodepath, + char **pp_server, + char **pp_share, + char **pp_extrapath) { char *p, *q; - pstring path; + char *path; - pstrcpy( path, nodepath ); + *pp_server = NULL; + *pp_share = NULL; + *pp_extrapath = NULL; + + path = talloc_strdup(ctx, nodepath); + if (!path) { + return; + } if ( path[0] != '\\' ) { return; @@ -407,32 +455,36 @@ static void split_dfs_path( const char *nodepath, fstring server, fstring share, if (q != NULL) { *q = '\0'; q++; - pstrcpy( extrapath, q ); + *pp_extrapath = talloc_strdup(ctx, q); } else { - pstrcpy( extrapath, '\0' ); + *pp_extrapath = talloc_strdup(ctx, ""); } - - fstrcpy( share, p ); - fstrcpy( server, &path[1] ); + + *pp_share = talloc_strdup(ctx, p); + *pp_server = talloc_strdup(ctx, &path[1]); } /**************************************************************************** Return the original path truncated at the directory component before - the first wildcard character. Trust the caller to provide a NULL + the first wildcard character. Trust the caller to provide a NULL terminated string ****************************************************************************/ -static void clean_path(const char *path, pstring path_out) +static char *clean_path(TALLOC_CTX *ctx, const char *path) { size_t len; char *p1, *p2, *p; - + char *path_out; + /* No absolute paths. */ while (IS_DIRECTORY_SEP(*path)) { path++; } - pstrcpy(path_out, path); + path_out = talloc_strdup(ctx, path); + if (!path_out) { + return NULL; + } p1 = strchr_m(path_out, '*'); p2 = strchr_m(path_out, '?'); @@ -462,21 +514,24 @@ static void clean_path(const char *path, pstring path_out) if ( (len > 0) && IS_DIRECTORY_SEP(path_out[len-1])) { path_out[len-1] = '\0'; } + + return path_out; } /**************************************************************************** ****************************************************************************/ -static void cli_dfs_make_full_path( struct cli_state *cli, - const char *dir, - pstring path_out) +static char *cli_dfs_make_full_path(TALLOC_CTX *ctx, + struct cli_state *cli, + const char *dir) { /* Ensure the extrapath doesn't start with a separator. */ while (IS_DIRECTORY_SEP(*dir)) { dir++; } - pstr_sprintf( path_out, "\\%s\\%s\\%s", cli->desthost, cli->share, dir); + return talloc_asprintf(ctx, "\\%s\\%s\\%s", + cli->desthost, cli->share, dir); } /******************************************************************** @@ -489,21 +544,22 @@ static bool cli_dfs_check_error( struct cli_state *cli, NTSTATUS status ) /* 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 (!((flgs2&FLAGS2_32_BIT_ERROR_CODES) && + (flgs2&FLAGS2_UNICODE_STRINGS))) + return false; - if ( NT_STATUS_EQUAL( status, NT_STATUS(IVAL(cli->inbuf,smb_rcls)) ) ) - return True; + if (NT_STATUS_EQUAL(status, NT_STATUS(IVAL(cli->inbuf,smb_rcls)))) + return true; - return False; + return false; } /******************************************************************** - get the dfs referral link + Get the dfs referral link. ********************************************************************/ -bool cli_dfs_get_referral( struct cli_state *cli, - const char *path, +bool cli_dfs_get_referral(struct cli_state *cli, + const char *path, CLIENT_DFS_REFERRAL**refs, size_t *num_refs, uint16 *consumed) @@ -511,19 +567,19 @@ bool cli_dfs_get_referral( struct cli_state *cli, unsigned int data_len = 0; unsigned int param_len = 0; uint16 setup = TRANSACT2_GET_DFS_REFERRAL; - char param[sizeof(pstring)+2]; - pstring data; + char param[1024+2]; char *rparam=NULL, *rdata=NULL; char *p; size_t pathlen = 2*(strlen(path)+1); uint16 num_referrals; CLIENT_DFS_REFERRAL *referrals = NULL; - + memset(param, 0, sizeof(param)); SSVAL(param, 0, 0x03); /* max referral level */ p = ¶m[2]; - p += clistr_push(cli, p, path, MIN(pathlen, sizeof(param)-2), STR_TERMINATE); + p += clistr_push(cli, p, path, MIN(pathlen, sizeof(param)-2), + STR_TERMINATE); param_len = PTR_DIFF(p, param); if (!cli_send_trans(cli, SMBtrans2, @@ -531,283 +587,366 @@ bool cli_dfs_get_referral( struct cli_state *cli, -1, 0, /* fid, flags */ &setup, 1, 0, /* setup, length, max */ param, param_len, 2, /* param, length, max */ - (char *)&data, data_len, cli->max_xmit /* data, length, max */ + NULL, 0, cli->max_xmit /* data, length, max */ )) { - return False; + return false; } if (!cli_receive_trans(cli, SMBtrans2, &rparam, ¶m_len, &rdata, &data_len)) { - return False; + return false; } - + *consumed = SVAL( rdata, 0 ); num_referrals = SVAL( rdata, 2 ); - + if ( num_referrals != 0 ) { uint16 ref_version; uint16 ref_size; int i; uint16 node_offset; - referrals = SMB_XMALLOC_ARRAY( CLIENT_DFS_REFERRAL, num_referrals ); + referrals = SMB_XMALLOC_ARRAY( CLIENT_DFS_REFERRAL, + num_referrals); /* start at the referrals array */ - + p = rdata+8; for ( i=0; idfsroot) { *targetcli = rootcli; - pstrcpy( targetpath, path ); - return True; + *pp_targetpath = talloc_strdup(ctx, path); + if (!*pp_targetpath) { + return false; + } + return true; } *targetcli = NULL; /* Send a trans2_query_path_info to check for a referral. */ - clean_path(path, cleanpath); - cli_dfs_make_full_path(rootcli, cleanpath, dfs_path ); + cleanpath = clean_path(ctx, path); + if (!cleanpath) { + return false; + } + + dfs_path = cli_dfs_make_full_path(ctx, rootcli, cleanpath); + if (!dfs_path) { + return false; + } - if (cli_qpathinfo_basic( rootcli, dfs_path, &sbuf, &attributes ) ) { + if (cli_qpathinfo_basic( rootcli, dfs_path, &sbuf, &attributes)) { /* This is an ordinary path, just return it. */ *targetcli = rootcli; - pstrcpy( targetpath, path ); + *pp_targetpath = talloc_strdup(ctx, path); + if (!*pp_targetpath) { + return false; + } goto done; } /* Special case where client asked for a path that does not exist */ - if ( cli_dfs_check_error(rootcli, NT_STATUS_OBJECT_NAME_NOT_FOUND) ) { + if (cli_dfs_check_error(rootcli, NT_STATUS_OBJECT_NAME_NOT_FOUND)) { *targetcli = rootcli; - pstrcpy( targetpath, path ); + *pp_targetpath = talloc_strdup(ctx, path); + if (!*pp_targetpath) { + return false; + } goto done; } /* We got an error, check for DFS referral. */ - if ( !cli_dfs_check_error(rootcli, NT_STATUS_PATH_NOT_COVERED)) { - return False; + if (!cli_dfs_check_error(rootcli, NT_STATUS_PATH_NOT_COVERED)) { + return false; } /* Check for the referral. */ - if ( !(cli_ipc = cli_cm_open( rootcli->desthost, "IPC$", False )) ) { - return False; + if (!(cli_ipc = cli_cm_open(ctx, rootcli->desthost, "IPC$", false))) { + return false; } - - if ( !cli_dfs_get_referral(cli_ipc, dfs_path, &refs, &num_refs, &consumed) - || !num_refs ) { - return False; + + if (!cli_dfs_get_referral(cli_ipc, dfs_path, &refs, + &num_refs, &consumed) || !num_refs) { + return false; } - + /* Just store the first referral for now. */ - split_dfs_path( refs[0].dfspath, server, share, extrapath ); + split_dfs_path(ctx, refs[0].dfspath, &server, &share, &extrapath ); SAFE_FREE(refs); + if (!server || !share) { + return false; + } + /* Make sure to recreate the original string including any wildcards. */ - - cli_dfs_make_full_path( rootcli, path, dfs_path); - pathlen = strlen( dfs_path )*2; - consumed = MIN(pathlen, consumed ); - pstrcpy( targetpath, &dfs_path[consumed/2] ); + + dfs_path = cli_dfs_make_full_path(ctx, rootcli, path); + if (!dfs_path) { + return false; + } + pathlen = strlen(dfs_path)*2; + consumed = MIN(pathlen, consumed); + *pp_targetpath = talloc_strdup(ctx, &dfs_path[consumed/2]); + if (!*pp_targetpath) { + return false; + } dfs_path[consumed/2] = '\0'; /* - * targetpath is now the unconsumed part of the path. - * dfs_path is now the consumed part of the path (in \server\share\path format). + * *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). */ /* Open the connection to the target server & share */ - - if ( (*targetcli = cli_cm_open(server, share, False)) == NULL ) { + if ((*targetcli = cli_cm_open(ctx, server, share, false)) == NULL) { d_printf("Unable to follow dfs referral [\\%s\\%s]\n", server, share ); - return False; + return false; } - - if (strlen(extrapath) > 0) { - string_append(&temppath, extrapath); - string_append(&temppath, targetpath); - pstrcpy( targetpath, temppath ); + + if (extrapath && strlen(extrapath) > 0) { + *pp_targetpath = talloc_asprintf(ctx, + "%s%s", + extrapath, + *pp_targetpath); + if (!*pp_targetpath) { + return false; + } } - + /* parse out the consumed mount path */ /* trim off the \server\share\ */ ppath = dfs_path; if (*ppath != '\\') { - d_printf("cli_resolve_path: dfs_path (%s) not in correct format.\n", + d_printf("cli_resolve_path: " + "dfs_path (%s) not in correct format.\n", dfs_path ); - return False; + return false; } ppath++; /* Now pointing at start of server name. */ - + if ((ppath = strchr_m( dfs_path, '\\' )) == NULL) { - return False; + return false; } ppath++; /* Now pointing at start of share name. */ if ((ppath = strchr_m( ppath+1, '\\' )) == NULL) { - return False; + return false; } ppath++; /* Now pointing at path component. */ - pstr_sprintf( newmount, "%s\\%s", mountpt, ppath ); + newmount = talloc_asprintf(ctx, "%s\\%s", mountpt, ppath ); + if (!newmount) { + return false; + } - cli_cm_set_mntpoint( *targetcli, newmount ); + cli_cm_set_mntpoint(*targetcli, newmount); - /* Check for another dfs referral, note that we are not + /* Check for another dfs referral, note that we are not checking for loops here. */ - if ( !strequal( targetpath, "\\" ) && !strequal( targetpath, "/")) { - if ( cli_resolve_path( newmount, *targetcli, targetpath, &newcli, newpath ) ) { + if (!strequal(*pp_targetpath, "\\") && !strequal(*pp_targetpath, "/")) { + if (cli_resolve_path(ctx, + newmount, + *targetcli, + *pp_targetpath, + &newcli, + &newpath)) { /* * When cli_resolve_path returns true here it's always * returning the complete path in newpath, so we're done * here. */ *targetcli = newcli; - pstrcpy( targetpath, newpath ); - return True; + *pp_targetpath = newpath; + return true; } } done: - /* If returning True ensure we return a dfs root full path. */ - if ( (*targetcli)->dfsroot ) { - pstrcpy(dfs_path, targetpath ); - cli_dfs_make_full_path( *targetcli, dfs_path, targetpath); + /* If returning true ensure we return a dfs root full path. */ + if ((*targetcli)->dfsroot) { + dfs_path = talloc_strdup(ctx, *pp_targetpath); + if (!dfs_path) { + return false; + } + *pp_targetpath = cli_dfs_make_full_path(ctx, *targetcli, dfs_path); } - return True; + return true; +} + +/******************************************************************** + Temporary hack - remove when pstring is dead. JRA. +********************************************************************/ + +bool cli_resolve_path_pstring( const char *mountpt, + struct cli_state *rootcli, + const char *path, + struct cli_state **targetcli, + pstring targetpath) +{ + char *tpath = NULL; + TALLOC_CTX *ctx = talloc_stackframe(); + bool ret = cli_resolve_path(ctx, + mountpt, + rootcli, + path, + targetcli, + &tpath); + if (tpath) { + pstrcpy(targetpath, tpath); + } + return ret; } /******************************************************************** ********************************************************************/ -bool cli_check_msdfs_proxy( struct cli_state *cli, const char *sharename, - fstring newserver, fstring newshare ) +bool cli_check_msdfs_proxy(TALLOC_CTX *ctx, + struct cli_state *cli, + const char *sharename, + char **pp_newserver, + char **pp_newshare ) { CLIENT_DFS_REFERRAL *refs = NULL; size_t num_refs; uint16 consumed; - pstring fullpath; + char *fullpath = NULL; bool res; uint16 cnum; - pstring newextrapath; - - if ( !cli || !sharename ) - return False; + char *newextrapath = NULL; + + if (!cli || !sharename) { + return false; + } cnum = cli->cnum; /* special case. never check for a referral on the IPC$ share */ - if ( strequal( sharename, "IPC$" ) ) { - return False; + if (strequal(sharename, "IPC$")) { + return false; } - + /* send a trans2_query_path_info to check for a referral */ - - pstr_sprintf( fullpath, "\\%s\\%s", cli->desthost, sharename ); + + fullpath = talloc_asprintf(ctx, "\\%s\\%s", cli->desthost, sharename ); + if (!fullpath) { + return false; + } /* check for the referral */ if (!cli_send_tconX(cli, "IPC$", "IPC", NULL, 0)) { - return False; + return false; } res = cli_dfs_get_referral(cli, fullpath, &refs, &num_refs, &consumed); if (!cli_tdis(cli)) { - SAFE_FREE( refs ); - return False; + SAFE_FREE(refs); + return false; } cli->cnum = cnum; - if (!res || !num_refs ) { - SAFE_FREE( refs ); - return False; + if (!res || !num_refs) { + SAFE_FREE(refs); + return false; + } + + split_dfs_path(ctx, refs[0].dfspath, pp_newserver, + pp_newshare, &newextrapath ); + + SAFE_FREE(refs); + + if (!pp_newserver || !pp_newshare) { + return false; } - - split_dfs_path( refs[0].dfspath, newserver, newshare, newextrapath ); /* check that this is not a self-referral */ - if ( strequal( cli->desthost, newserver ) && strequal( sharename, newshare ) ) { - SAFE_FREE( refs ); - return False; + if (strequal(cli->desthost, *pp_newserver) && + strequal(sharename, *pp_newshare)) { + return false; } - - SAFE_FREE( refs ); - - return True; + + return true; } diff --git a/source3/libsmb/libsmbclient.c b/source3/libsmb/libsmbclient.c index 4f2503731d..b20b1cadaf 100644 --- a/source3/libsmb/libsmbclient.c +++ b/source3/libsmb/libsmbclient.c @@ -1055,7 +1055,7 @@ smbc_open_ctx(SMBCCTX *context, { fstring server, share, user, password, workgroup; pstring path; - pstring targetpath; + char *targetpath = NULL; struct cli_state *targetcli; SMBCSRV *srv = NULL; SMBCFILE *file = NULL; @@ -1102,18 +1102,14 @@ smbc_open_ctx(SMBCCTX *context, if (errno == EPERM) errno = EACCES; TALLOC_FREE(frame); return NULL; /* smbc_server sets errno */ - + } /* Hmmm, the test for a directory is suspect here ... FIXME */ if (strlen(path) > 0 && path[strlen(path) - 1] == '\\') { - fd = -1; - - } - else { - + } else { file = SMB_MALLOC_P(SMBCFILE); if (!file) { @@ -1127,7 +1123,7 @@ smbc_open_ctx(SMBCCTX *context, ZERO_STRUCTP(file); /*d_printf(">>>open: resolving %s\n", path);*/ - if (!cli_resolve_path( "", srv->cli, path, &targetcli, targetpath)) + if (!cli_resolve_path(frame, "", srv->cli, path, &targetcli, &targetpath)) { d_printf("Could not resolve %s\n", path); SAFE_FREE(file); @@ -1135,7 +1131,7 @@ smbc_open_ctx(SMBCCTX *context, return NULL; } /*d_printf(">>>open: resolved %s as %s\n", path, targetpath);*/ - + if ((fd = cli_open(targetcli, targetpath, flags, context->internal->_share_mode)) < 0) { @@ -1248,7 +1244,8 @@ smbc_read_ctx(SMBCCTX *context, { int ret; fstring server, share, user, password; - pstring path, targetpath; + pstring path; + char *targetpath = NULL; struct cli_state *targetcli; TALLOC_CTX *frame = talloc_stackframe(); @@ -1307,17 +1304,17 @@ smbc_read_ctx(SMBCCTX *context, TALLOC_FREE(frame); return -1; } - + /*d_printf(">>>read: resolving %s\n", path);*/ - if (!cli_resolve_path("", file->srv->cli, path, - &targetcli, targetpath)) + if (!cli_resolve_path(frame, "", file->srv->cli, path, + &targetcli, &targetpath)) { d_printf("Could not resolve %s\n", path); TALLOC_FREE(frame); return -1; } /*d_printf(">>>fstat: resolved path as %s\n", targetpath);*/ - + ret = cli_read(targetcli, file->cli_fd, (char *)buf, offset, count); if (ret < 0) { @@ -1350,15 +1347,15 @@ smbc_write_ctx(SMBCCTX *context, int ret; off_t offset; fstring server, share, user, password; - pstring path, targetpath; + pstring path; + char *targetpath = NULL; struct cli_state *targetcli; TALLOC_CTX *frame = talloc_stackframe(); /* First check all pointers before dereferencing them */ - + if (!context || !context->internal || !context->internal->_initialized) { - errno = EINVAL; TALLOC_FREE(frame); return -1; @@ -1366,17 +1363,14 @@ smbc_write_ctx(SMBCCTX *context, } if (!file || !DLIST_CONTAINS(context->internal->_files, file)) { - errno = EBADF; TALLOC_FREE(frame); return -1; - } /* Check that the buffer exists ... */ if (buf == NULL) { - errno = EINVAL; TALLOC_FREE(frame); return -1; @@ -1398,22 +1392,19 @@ smbc_write_ctx(SMBCCTX *context, TALLOC_FREE(frame); return -1; } - + /*d_printf(">>>write: resolving %s\n", path);*/ - if (!cli_resolve_path("", file->srv->cli, path, - &targetcli, targetpath)) - { + if (!cli_resolve_path(frame, "", file->srv->cli, path, + &targetcli, &targetpath)) { d_printf("Could not resolve %s\n", path); TALLOC_FREE(frame); return -1; } /*d_printf(">>>write: resolved path as %s\n", targetpath);*/ - ret = cli_write(targetcli, file->cli_fd, 0, (char *)buf, offset, count); if (ret <= 0) { - errno = smbc_errno(context, targetcli); TALLOC_FREE(frame); return -1; @@ -1425,7 +1416,7 @@ smbc_write_ctx(SMBCCTX *context, TALLOC_FREE(frame); return ret; /* Success, 0 bytes of data ... */ } - + /* * Routine to close() a file ... */ @@ -1434,9 +1425,10 @@ static int smbc_close_ctx(SMBCCTX *context, SMBCFILE *file) { - SMBCSRV *srv; + SMBCSRV *srv; fstring server, share, user, password; - pstring path, targetpath; + pstring path; + char *targetpath = NULL; struct cli_state *targetcli; TALLOC_CTX *frame = talloc_stackframe(); @@ -1450,7 +1442,6 @@ smbc_close_ctx(SMBCCTX *context, } if (!file || !DLIST_CONTAINS(context->internal->_files, file)) { - errno = EBADF; TALLOC_FREE(frame); return -1; @@ -1459,7 +1450,6 @@ smbc_close_ctx(SMBCCTX *context, /* IS a dir ... */ if (!file->file) { - TALLOC_FREE(frame); return (context->closedir)(context, file); @@ -1478,11 +1468,10 @@ smbc_close_ctx(SMBCCTX *context, TALLOC_FREE(frame); return -1; } - + /*d_printf(">>>close: resolving %s\n", path);*/ - if (!cli_resolve_path("", file->srv->cli, path, - &targetcli, targetpath)) - { + if (!cli_resolve_path(frame, "", file->srv->cli, path, + &targetcli, &targetpath)) { d_printf("Could not resolve %s\n", path); TALLOC_FREE(frame); return -1; @@ -1531,18 +1520,16 @@ smbc_getatr(SMBCCTX * context, SMB_INO_T *ino) { pstring fixedpath; - pstring targetpath; + char *targetpath = NULL; struct cli_state *targetcli; time_t write_time; TALLOC_CTX *frame = talloc_stackframe(); if (!context || !context->internal || !context->internal->_initialized) { - errno = EINVAL; TALLOC_FREE(frame); return -1; - } /* path fixup for . and .. */ @@ -1555,14 +1542,14 @@ smbc_getatr(SMBCCTX * context, trim_string(fixedpath, NULL, "\\."); } DEBUG(4,("smbc_getatr: sending qpathinfo\n")); - - if (!cli_resolve_path( "", srv->cli, fixedpath, &targetcli, targetpath)) - { + + if (!cli_resolve_path(frame, "", srv->cli, fixedpath, + &targetcli, &targetpath)) { d_printf("Couldn't resolve %s\n", path); TALLOC_FREE(frame); return False; } - + if (!srv->no_pathinfo2 && cli_qpathinfo2(targetcli, targetpath, create_time_ts, @@ -1710,7 +1697,8 @@ smbc_unlink_ctx(SMBCCTX *context, const char *fname) { fstring server, share, user, password, workgroup; - pstring path, targetpath; + pstring path; + char *targetpath; struct cli_state *targetcli; SMBCSRV *srv = NULL; TALLOC_CTX *frame = talloc_stackframe(); @@ -1758,8 +1746,8 @@ smbc_unlink_ctx(SMBCCTX *context, } /*d_printf(">>>unlink: resolving %s\n", path);*/ - if (!cli_resolve_path( "", srv->cli, path, &targetcli, targetpath)) - { + if (!cli_resolve_path(frame, "", srv->cli, path, + &targetcli, &targetpath)) { d_printf("Could not resolve %s\n", path); TALLOC_FREE(frame); return -1; @@ -1835,16 +1823,16 @@ smbc_rename_ctx(SMBCCTX *ocontext, fstring workgroup; pstring path1; pstring path2; - pstring targetpath1; - pstring targetpath2; + char *targetpath1; + char *targetpath2; struct cli_state *targetcli1; struct cli_state *targetcli2; SMBCSRV *srv = NULL; TALLOC_CTX *frame = talloc_stackframe(); - if (!ocontext || !ncontext || + if (!ocontext || !ncontext || !ocontext->internal || !ncontext->internal || - !ocontext->internal->_initialized || + !ocontext->internal->_initialized || !ncontext->internal->_initialized) { errno = EINVAL; /* Best I can think of ... */ @@ -1852,15 +1840,14 @@ smbc_rename_ctx(SMBCCTX *ocontext, return -1; } - - if (!oname || !nname) { + if (!oname || !nname) { errno = EINVAL; TALLOC_FREE(frame); return -1; } - + DEBUG(4, ("smbc_rename(%s,%s)\n", oname, nname)); smbc_parse_path(ocontext, oname, @@ -1887,9 +1874,7 @@ smbc_rename_ctx(SMBCCTX *ocontext, if (strcmp(server1, server2) || strcmp(share1, share2) || strcmp(user1, user2)) { - /* Can't rename across file systems, or users?? */ - errno = EXDEV; TALLOC_FREE(frame); return -1; @@ -1906,27 +1891,26 @@ smbc_rename_ctx(SMBCCTX *ocontext, } /*d_printf(">>>rename: resolving %s\n", path1);*/ - if (!cli_resolve_path( "", srv->cli, path1, &targetcli1, targetpath1)) - { + if (!cli_resolve_path(frame, "", srv->cli, path1, + &targetcli1, &targetpath1)) { d_printf("Could not resolve %s\n", path1); TALLOC_FREE(frame); return -1; } /*d_printf(">>>rename: resolved path as %s\n", targetpath1);*/ /*d_printf(">>>rename: resolving %s\n", path2);*/ - if (!cli_resolve_path( "", srv->cli, path2, &targetcli2, targetpath2)) - { + if (!cli_resolve_path(frame, "", srv->cli, path2, + &targetcli2, &targetpath2)) { d_printf("Could not resolve %s\n", path2); TALLOC_FREE(frame); return -1; } /*d_printf(">>>rename: resolved path as %s\n", targetpath2);*/ - + if (strcmp(targetcli1->desthost, targetcli2->desthost) || strcmp(targetcli1->share, targetcli2->share)) { /* can't rename across file systems */ - errno = EXDEV; TALLOC_FREE(frame); return -1; @@ -1962,17 +1946,16 @@ smbc_lseek_ctx(SMBCCTX *context, { SMB_OFF_T size; fstring server, share, user, password; - pstring path, targetpath; + pstring path; + char *targetpath; struct cli_state *targetcli; TALLOC_CTX *frame = talloc_stackframe(); if (!context || !context->internal || !context->internal->_initialized) { - errno = EINVAL; TALLOC_FREE(frame); return -1; - } if (!file || !DLIST_CONTAINS(context->internal->_files, file)) { @@ -2010,28 +1993,26 @@ smbc_lseek_ctx(SMBCCTX *context, user, sizeof(user), password, sizeof(password), NULL, 0)) { - errno = EINVAL; TALLOC_FREE(frame); return -1; } - + /*d_printf(">>>lseek: resolving %s\n", path);*/ - if (!cli_resolve_path("", file->srv->cli, path, - &targetcli, targetpath)) - { + if (!cli_resolve_path(frame, "", file->srv->cli, path, + &targetcli, &targetpath)) { d_printf("Could not resolve %s\n", path); TALLOC_FREE(frame); return -1; } /*d_printf(">>>lseek: resolved path as %s\n", targetpath);*/ - + if (!cli_qfileinfo(targetcli, file->cli_fd, NULL, - &size, NULL, NULL, NULL, NULL, NULL)) + &size, NULL, NULL, NULL, NULL, NULL)) { SMB_OFF_T b_size = size; if (!cli_getattrE(targetcli, file->cli_fd, - NULL, &b_size, NULL, NULL, NULL)) + NULL, &b_size, NULL, NULL, NULL)) { errno = EINVAL; TALLOC_FREE(frame); @@ -2238,14 +2219,13 @@ smbc_fstat_ctx(SMBCCTX *context, fstring user; fstring password; pstring path; - pstring targetpath; + char *targetpath; struct cli_state *targetcli; SMB_INO_T ino = 0; TALLOC_CTX *frame = talloc_stackframe(); if (!context || !context->internal || !context->internal->_initialized) { - errno = EINVAL; TALLOC_FREE(frame); return -1; @@ -2253,7 +2233,6 @@ smbc_fstat_ctx(SMBCCTX *context, } if (!file || !DLIST_CONTAINS(context->internal->_files, file)) { - errno = EBADF; TALLOC_FREE(frame); return -1; @@ -2261,7 +2240,6 @@ smbc_fstat_ctx(SMBCCTX *context, } if (!file->file) { - TALLOC_FREE(frame); return (context->fstatdir)(context, file, st); @@ -2280,11 +2258,10 @@ smbc_fstat_ctx(SMBCCTX *context, TALLOC_FREE(frame); return -1; } - + /*d_printf(">>>fstat: resolving %s\n", path);*/ - if (!cli_resolve_path("", file->srv->cli, path, - &targetcli, targetpath)) - { + if (!cli_resolve_path(frame, "", file->srv->cli, path, + &targetcli, &targetpath)) { d_printf("Could not resolve %s\n", path); TALLOC_FREE(frame); return -1; @@ -2979,7 +2956,7 @@ smbc_opendir_ctx(SMBCCTX *context, * The server and share are specified ... work from * there ... */ - pstring targetpath; + char *targetpath; struct cli_state *targetcli; /* We connect to the server and list the directory */ @@ -3006,9 +2983,8 @@ smbc_opendir_ctx(SMBCCTX *context, p = path + strlen(path); pstrcat(path, "\\*"); - if (!cli_resolve_path("", srv->cli, path, - &targetcli, targetpath)) - { + if (!cli_resolve_path(frame, "", srv->cli, path, + &targetcli, &targetpath)) { d_printf("Could not resolve %s\n", path); if (dir) { SAFE_FREE(dir->fname); @@ -3017,7 +2993,7 @@ smbc_opendir_ctx(SMBCCTX *context, TALLOC_FREE(frame); return NULL; } - + if (cli_list(targetcli, targetpath, aDIR | aSYSTEM | aHIDDEN, dir_list_fn, (void *)dir) < 0) { @@ -3358,13 +3334,13 @@ smbc_mkdir_ctx(SMBCCTX *context, fstring user; fstring password; fstring workgroup; - pstring path, targetpath; + pstring path; + char *targetpath; struct cli_state *targetcli; TALLOC_CTX *frame = talloc_stackframe(); - if (!context || !context->internal || + if (!context || !context->internal || !context->internal->_initialized) { - errno = EINVAL; TALLOC_FREE(frame); return -1; @@ -3372,13 +3348,12 @@ smbc_mkdir_ctx(SMBCCTX *context, } if (!fname) { - errno = EINVAL; TALLOC_FREE(frame); return -1; } - + DEBUG(4, ("smbc_mkdir(%s)\n", fname)); if (smbc_parse_path(context, fname, @@ -3407,8 +3382,8 @@ smbc_mkdir_ctx(SMBCCTX *context, } /*d_printf(">>>mkdir: resolving %s\n", path);*/ - if (!cli_resolve_path( "", srv->cli, path, &targetcli, targetpath)) - { + if (!cli_resolve_path(frame, "", srv->cli, path, + &targetcli, &targetpath)) { d_printf("Could not resolve %s\n", path); TALLOC_FREE(frame); return -1; @@ -3462,13 +3437,12 @@ smbc_rmdir_ctx(SMBCCTX *context, fstring password; fstring workgroup; pstring path; - pstring targetpath; + char *targetpath; struct cli_state *targetcli; TALLOC_CTX *frame = talloc_stackframe(); - if (!context || !context->internal || + if (!context || !context->internal || !context->internal->_initialized) { - errno = EINVAL; TALLOC_FREE(frame); return -1; @@ -3476,13 +3450,12 @@ smbc_rmdir_ctx(SMBCCTX *context, } if (!fname) { - errno = EINVAL; TALLOC_FREE(frame); return -1; } - + DEBUG(4, ("smbc_rmdir(%s)\n", fname)); if (smbc_parse_path(context, fname, @@ -3512,8 +3485,8 @@ smbc_rmdir_ctx(SMBCCTX *context, } /*d_printf(">>>rmdir: resolving %s\n", path);*/ - if (!cli_resolve_path( "", srv->cli, path, &targetcli, targetpath)) - { + if (!cli_resolve_path(frame, "", srv->cli, path, + &targetcli, &targetpath)) { d_printf("Could not resolve %s\n", path); TALLOC_FREE(frame); return -1; -- cgit