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/client/client.c | 85 +++--- source3/client/smbctool.c | 59 ++-- source3/libsmb/cliconnect.c | 15 +- source3/libsmb/clidfs.c | 573 ++++++++++++++++++++++++--------------- source3/libsmb/libsmbclient.c | 169 +++++------- source3/nmbd/nmbd_sendannounce.c | 8 +- source3/smbd/password.c | 6 +- source3/utils/net_rpc.c | 5 +- 8 files changed, 530 insertions(+), 390 deletions(-) diff --git a/source3/client/client.c b/source3/client/client.c index 1c54b2d3f7..a65906c21a 100644 --- a/source3/client/client.c +++ b/source3/client/client.c @@ -226,7 +226,7 @@ static int do_dskattr(void) struct cli_state *targetcli; pstring targetpath; - if ( !cli_resolve_path( "", cli, cur_dir, &targetcli, targetpath ) ) { + if ( !cli_resolve_path_pstring( "", cli, cur_dir, &targetcli, targetpath ) ) { d_printf("Error in dskattr: %s\n", cli_errstr(cli)); return 1; } @@ -286,7 +286,7 @@ static int do_cd(char *newdir) pstring_clean_name(cur_dir); pstrcpy( dname, cur_dir ); - if ( !cli_resolve_path( "", cli, dname, &targetcli, targetpath ) ) { + if ( !cli_resolve_path_pstring( "", cli, dname, &targetcli, targetpath ) ) { d_printf("cd %s: %s\n", dname, cli_errstr(cli)); pstrcpy(cur_dir,saved_dir); goto out; @@ -655,7 +655,7 @@ void do_list(const char *mask,uint16 attribute,void (*fn)(file_info *),bool rec, /* check for dfs */ - if ( !cli_resolve_path( "", cli, head, &targetcli, targetpath ) ) { + if ( !cli_resolve_path_pstring( "", cli, head, &targetcli, targetpath ) ) { d_printf("do_list: [%s] %s\n", head, cli_errstr(cli)); remove_do_list_queue_head(); continue; @@ -685,7 +685,7 @@ void do_list(const char *mask,uint16 attribute,void (*fn)(file_info *),bool rec, } else { /* check for dfs */ - if ( cli_resolve_path( "", cli, mask, &targetcli, targetpath ) ) { + if ( cli_resolve_path_pstring( "", 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); } @@ -823,7 +823,7 @@ static int do_get(char *rname, char *lname, bool reget) strlower_m(lname); } - if ( !cli_resolve_path( "", cli, rname, &targetcli, targetname ) ) { + if ( !cli_resolve_path_pstring( "", cli, rname, &targetcli, targetname ) ) { d_printf("Failed to open %s: %s\n", rname, cli_errstr(cli)); return 1; } @@ -1118,7 +1118,7 @@ static bool do_mkdir(char *name) struct cli_state *targetcli; pstring targetname; - if ( !cli_resolve_path( "", cli, name, &targetcli, targetname ) ) { + if ( !cli_resolve_path_pstring( "", cli, name, &targetcli, targetname ) ) { d_printf("mkdir %s: %s\n", name, cli_errstr(cli)); return False; } @@ -1188,7 +1188,7 @@ static int cmd_mkdir(void) pstring targetname; *ddir2 = 0; - if ( !cli_resolve_path( "", cli, mask, &targetcli, targetname ) ) { + if ( !cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname ) ) { return 1; } @@ -1250,7 +1250,7 @@ static int do_put(char *rname, char *lname, bool reput) struct cli_state *targetcli; pstring targetname; - if ( !cli_resolve_path( "", cli, rname, &targetcli, targetname ) ) { + if ( !cli_resolve_path_pstring( "", cli, rname, &targetcli, targetname ) ) { d_printf("Failed to open %s: %s\n", rname, cli_errstr(cli)); return 1; } @@ -1770,7 +1770,7 @@ static int cmd_wdel(void) pstrcpy(mask,cur_dir); pstrcat(mask,buf); - if ( !cli_resolve_path( "", cli, mask, &targetcli, targetname ) ) { + if ( !cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname ) ) { d_printf("cmd_wdel %s: %s\n", mask, cli_errstr(cli)); return 1; } @@ -1800,7 +1800,7 @@ static int cmd_open(void) } pstrcat(mask,buf); - if ( !cli_resolve_path( "", cli, mask, &targetcli, targetname ) ) { + if ( !cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname ) ) { d_printf("open %s: %s\n", mask, cli_errstr(cli)); return 1; } @@ -1845,7 +1845,7 @@ static int cmd_posix_open(void) } mode = (mode_t)strtol(buf, (char **)NULL, 8); - if (!cli_resolve_path( "", cli, mask, &targetcli, targetname )) { + if (!cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname )) { d_printf("posix_open %s: %s\n", mask, cli_errstr(cli)); return 1; } @@ -1887,7 +1887,7 @@ static int cmd_posix_mkdir(void) } mode = (mode_t)strtol(buf, (char **)NULL, 8); - if (!cli_resolve_path( "", cli, mask, &targetcli, targetname )) { + if (!cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname )) { d_printf("posix_mkdir %s: %s\n", mask, cli_errstr(cli)); return 1; } @@ -1917,7 +1917,7 @@ static int cmd_posix_unlink(void) } pstrcat(mask,buf); - if (!cli_resolve_path( "", cli, mask, &targetcli, targetname )) { + if (!cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname )) { d_printf("posix_unlink %s: %s\n", mask, cli_errstr(cli)); return 1; } @@ -1946,7 +1946,7 @@ static int cmd_posix_rmdir(void) } pstrcat(mask,buf); - if (!cli_resolve_path( "", cli, mask, &targetcli, targetname)) { + if (!cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname)) { d_printf("posix_rmdir %s: %s\n", mask, cli_errstr(cli)); return 1; } @@ -2141,7 +2141,7 @@ static int cmd_rmdir(void) } pstrcat(mask,buf); - if ( !cli_resolve_path( "", cli, mask, &targetcli, targetname ) ) { + if ( !cli_resolve_path_pstring( "", cli, mask, &targetcli, targetname ) ) { d_printf("rmdir %s: %s\n", mask, cli_errstr(cli)); return 1; } @@ -2177,7 +2177,7 @@ static int cmd_link(void) pstrcat(oldname,buf); pstrcat(newname,buf2); - if ( !cli_resolve_path( "", cli, oldname, &targetcli, targetname ) ) { + if ( !cli_resolve_path_pstring( "", cli, oldname, &targetcli, targetname ) ) { d_printf("link %s: %s\n", oldname, cli_errstr(cli)); return 1; } @@ -2222,7 +2222,7 @@ static int cmd_symlink(void) pstrcpy(oldname,buf); pstrcat(newname,buf2); - if ( !cli_resolve_path( "", cli, oldname, &targetcli, targetname ) ) { + if ( !cli_resolve_path_pstring( "", cli, oldname, &targetcli, targetname ) ) { d_printf("link %s: %s\n", oldname, cli_errstr(cli)); return 1; } @@ -2259,7 +2259,7 @@ static int cmd_chmod(void) mode = (mode_t)strtol(buf, NULL, 8); pstrcat(src,buf2); - if ( !cli_resolve_path( "", cli, src, &targetcli, targetname ) ) { + if ( !cli_resolve_path_pstring( "", cli, src, &targetcli, targetname ) ) { d_printf("chmod %s: %s\n", src, cli_errstr(cli)); return 1; } @@ -2407,7 +2407,7 @@ static int cmd_getfacl(void) pstrcat(src,name); - if ( !cli_resolve_path( "", cli, src, &targetcli, targetname ) ) { + if ( !cli_resolve_path_pstring( "", cli, src, &targetcli, targetname ) ) { d_printf("stat %s: %s\n", src, cli_errstr(cli)); return 1; } @@ -2572,7 +2572,7 @@ static int cmd_stat(void) pstrcat(src,name); - if ( !cli_resolve_path( "", cli, src, &targetcli, targetname ) ) { + if ( !cli_resolve_path_pstring( "", cli, src, &targetcli, targetname ) ) { d_printf("stat %s: %s\n", src, cli_errstr(cli)); return 1; } @@ -2663,7 +2663,7 @@ static int cmd_chown(void) gid = (gid_t)atoi(buf2); pstrcat(src,buf3); - if ( !cli_resolve_path( "", cli, src, &targetcli, targetname ) ) { + if ( !cli_resolve_path_pstring( "", cli, src, &targetcli, targetname ) ) { d_printf("chown %s: %s\n", src, cli_errstr(cli)); return 1; } @@ -2706,12 +2706,12 @@ static int cmd_rename(void) pstrcat(src,buf); pstrcat(dest,buf2); - if ( !cli_resolve_path( "", cli, src, &targetcli, targetsrc ) ) { + if ( !cli_resolve_path_pstring( "", cli, src, &targetcli, targetsrc ) ) { d_printf("rename %s: %s\n", src, cli_errstr(cli)); return 1; } - if ( !cli_resolve_path( "", cli, dest, &targetcli, targetdest ) ) { + if ( !cli_resolve_path_pstring( "", cli, dest, &targetcli, targetdest ) ) { d_printf("rename %s: %s\n", dest, cli_errstr(cli)); return 1; } @@ -2769,7 +2769,7 @@ static int cmd_hardlink(void) pstrcat(src,buf); pstrcat(dest,buf2); - if ( !cli_resolve_path( "", cli, src, &targetcli, targetname ) ) { + if ( !cli_resolve_path_pstring( "", cli, src, &targetcli, targetname ) ) { d_printf("hardlink %s: %s\n", src, cli_errstr(cli)); return 1; } @@ -3218,7 +3218,7 @@ static int cmd_show_connect( void ) struct cli_state *targetcli; pstring targetpath; - if ( !cli_resolve_path( "", cli, cur_dir, &targetcli, targetpath ) ) { + if ( !cli_resolve_path_pstring( "", cli, cur_dir, &targetcli, targetpath ) ) { d_printf("showconnect %s: %s\n", cur_dir, cli_errstr(cli)); return 1; } @@ -3417,7 +3417,7 @@ static int process_command_string(char *cmd) /* establish the connection if not already */ if (!cli) { - cli = cli_cm_open(desthost, service, True); + cli = cli_cm_open(talloc_tos(), desthost, service, True); if (!cli) return 0; } @@ -3737,29 +3737,37 @@ static int process_stdin(void) int rc = 0; while (1) { + TALLOC_CTX *frame = talloc_stackframe(); pstring tok; pstring the_prompt; char *cline; pstring line; int i; - + /* display a prompt */ slprintf(the_prompt, sizeof(the_prompt)-1, "smb: %s> ", cur_dir); cline = smb_readline(the_prompt, readline_callback, completion_fn); - - if (!cline) break; - + + if (!cline) { + TALLOC_FREE(frame); + break; + } + pstrcpy(line, cline); /* special case - first char is ! */ if (*line == '!') { system(line + 1); + TALLOC_FREE(frame); continue; } - + /* and get the first part of the command */ ptr = line; - if (!next_token_nr(&ptr,tok,NULL,sizeof(tok))) continue; + if (!next_token_nr(&ptr,tok,NULL,sizeof(tok))) { + TALLOC_FREE(frame); + continue; + } if ((i = process_tok(tok)) >= 0) { rc = commands[i].fn(); @@ -3768,6 +3776,7 @@ static int process_stdin(void) } else { d_printf("%s: command not found\n",tok); } + TALLOC_FREE(frame); } return rc; } @@ -3780,7 +3789,7 @@ static int process(char *base_directory) { int rc = 0; - cli = cli_cm_open(desthost, service, True); + cli = cli_cm_open(talloc_tos(), desthost, service, True); if (!cli) { return 1; } @@ -3809,7 +3818,7 @@ static int process(char *base_directory) static int do_host_query(char *query_host) { - cli = cli_cm_open(query_host, "IPC$", True); + cli = cli_cm_open(talloc_tos(), query_host, "IPC$", True); if (!cli) return 1; @@ -3822,7 +3831,7 @@ static int do_host_query(char *query_host) cli_cm_shutdown(); cli_cm_set_port( 139 ); - cli = cli_cm_open(query_host, "IPC$", True); + cli = cli_cm_open(talloc_tos(), query_host, "IPC$", True); } if (cli == NULL) { @@ -3847,7 +3856,7 @@ static int do_tar_op(char *base_directory) /* do we already have a connection? */ if (!cli) { - cli = cli_cm_open(desthost, service, True); + cli = cli_cm_open(talloc_tos(), desthost, service, True); if (!cli) return 1; } @@ -3961,7 +3970,7 @@ static int do_message_op(void) POPT_TABLEEND }; TALLOC_CTX *frame = talloc_stackframe(); - + load_case_tables(); #ifdef KANJI @@ -4200,7 +4209,7 @@ static int do_message_op(void) if (message) { return do_message_op(); } - + if (process(base_directory)) { return 1; } diff --git a/source3/client/smbctool.c b/source3/client/smbctool.c index b563a33f66..6c0a980a00 100644 --- a/source3/client/smbctool.c +++ b/source3/client/smbctool.c @@ -304,9 +304,9 @@ static int do_dskattr(void) { int total, bsize, avail; struct cli_state *targetcli; - pstring targetpath; + char *targetpath = NULL; - if ( !cli_resolve_path( "", cli, cur_dir, &targetcli, targetpath ) ) { + if ( !cli_resolve_path(talloc_tos(), "", cli, cur_dir, &targetcli, &targetpath ) ) { d_printf("Error in dskattr: %s\n", cli_errstr(cli)); return 1; } @@ -731,7 +731,7 @@ void do_list(const char *mask,uint16 attribute,void (*fn)(file_info *),bool rec, { static int in_do_list = 0; struct cli_state *targetcli; - pstring targetpath; + char *targetpath; if (in_do_list && rec) { fprintf(stderr, "INTERNAL ERROR: do_list called recursively when the recursive flag is true\n"); @@ -747,7 +747,7 @@ void do_list(const char *mask,uint16 attribute,void (*fn)(file_info *),bool rec, if (rec) { init_do_list_queue(); add_to_do_list_queue(mask); - + while (! do_list_queue_empty()) { /* * Need to copy head so that it doesn't become @@ -758,15 +758,15 @@ void do_list(const char *mask,uint16 attribute,void (*fn)(file_info *),bool rec, */ pstring head; pstrcpy(head, do_list_queue_head()); - + /* check for dfs */ - - if ( !cli_resolve_path( "", cli, head, &targetcli, targetpath ) ) { + + if ( !cli_resolve_path(talloc_tos(), "", cli, head, &targetcli, &targetpath ) ) { d_printf("do_list: [%s] %s\n", head, cli_errstr(cli)); remove_do_list_queue_head(); continue; } - + cli_list(targetcli, targetpath, attribute, do_list_helper, NULL); remove_do_list_queue_head(); if ((! do_list_queue_empty()) && (fn == display_finfo)) { @@ -787,8 +787,7 @@ void do_list(const char *mask,uint16 attribute,void (*fn)(file_info *),bool rec, } } else { /* check for dfs */ - - if ( cli_resolve_path( "", cli, mask, &targetcli, targetpath ) ) { + if (cli_resolve_path(talloc_tos(), "", 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); } @@ -1857,21 +1856,21 @@ static int cmd_open(void) pstring mask; pstring buf; struct cli_state *targetcli; - pstring targetname; - + char *targetname; + pstrcpy(mask,cur_dir); - + if (!next_token_nr(NULL,buf,NULL,sizeof(buf))) { d_printf("open \n"); return 1; } pstrcat(mask,buf); - if ( !cli_resolve_path( "", cli, mask, &targetcli, targetname ) ) { + if (!cli_resolve_path(talloc_tos(), "", cli, mask, &targetcli, &targetname ) ) { d_printf("open %s: %s\n", mask, cli_errstr(cli)); return 1; } - + cli_nt_create(targetcli, targetname, FILE_READ_DATA); return 0; @@ -3320,31 +3319,39 @@ static int process_stdin(void) int rc = 0; while (1) { + TALLOC_CTX *ctx = talloc_stackframe(); pstring tok; pstring the_prompt; char *cline; pstring line; int i; - + /* display a prompt */ slprintf(the_prompt, sizeof(the_prompt)-1, "smb: %s> ", cur_dir); /* Removed callback since we don't need to swallow keepalives with libsmbclient */ /*cline = smb_readline(the_prompt, readline_callback, completion_fn);*/ cline = smb_readline(the_prompt, NULL, completion_fn); - - if (!cline) break; - + + if (!cline) { + TALLOC_FREE(frame); + break; + } + pstrcpy(line, cline); /* special case - first char is ! */ if (*line == '!') { system(line + 1); + TALLOC_FREE(frame); continue; } - + /* and get the first part of the command */ ptr = line; - if (!next_token_nr(&ptr,tok,NULL,sizeof(tok))) continue; + if (!next_token_nr(&ptr,tok,NULL,sizeof(tok))) { + TALLOC_FREE(frame); + continue; + } if ((i = process_tok(tok)) >= 0) { rc = commands[i].fn(); @@ -3353,6 +3360,7 @@ static int process_stdin(void) } else { d_printf("%s: command not found\n",tok); } + TALLOC_FREE(frame); } return rc; } @@ -3375,7 +3383,7 @@ static int process(char *base_directory) d_printf("Error initializing libsmbclient: %s\n", strerror(errno)); return 1; } - + if (*base_directory) { rc = do_cd(base_directory); if (rc) { @@ -3386,16 +3394,17 @@ static int process(char *base_directory) else /* start the auth fn*/ { rc = do_cd("/"); - if (rc) + if (rc) { return rc; + } } - + if (cmdstr) { rc = process_command_string(cmdstr); } else { process_stdin(); } - + cli_cm_shutdown(); return rc; } 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; diff --git a/source3/nmbd/nmbd_sendannounce.c b/source3/nmbd/nmbd_sendannounce.c index 73c875d248..a4e646771f 100644 --- a/source3/nmbd/nmbd_sendannounce.c +++ b/source3/nmbd/nmbd_sendannounce.c @@ -34,7 +34,7 @@ extern bool found_lm_clients; void send_browser_reset(int reset_type, const char *to_name, int to_type, struct in_addr to_ip) { - char outbuf[PSTRING_LEN]; + char outbuf[1024]; char *p; DEBUG(3,("send_browser_reset: sending reset request type %d to %s<%02x> IP %s.\n", @@ -59,7 +59,7 @@ void send_browser_reset(int reset_type, const char *to_name, int to_type, struct void broadcast_announce_request(struct subnet_record *subrec, struct work_record *work) { - char outbuf[PSTRING_LEN]; + char outbuf[1024]; char *p; work->needannounce = True; @@ -90,7 +90,7 @@ static void send_announcement(struct subnet_record *subrec, int announce_type, time_t announce_interval, const char *server_name, int server_type, const char *server_comment) { - char outbuf[PSTRING_LEN]; + char outbuf[1024]; unstring upper_server_name; char *p; @@ -131,7 +131,7 @@ static void send_lm_announcement(struct subnet_record *subrec, int announce_type time_t announce_interval, char *server_name, int server_type, char *server_comment) { - char outbuf[PSTRING_LEN]; + char outbuf[1024]; char *p=outbuf; memset(outbuf,'\0',sizeof(outbuf)); diff --git a/source3/smbd/password.c b/source3/smbd/password.c index 7bba458218..75f05dea67 100644 --- a/source3/smbd/password.c +++ b/source3/smbd/password.c @@ -402,14 +402,14 @@ void add_session_user(const char *user) len_session_userlist) ) { char *newlist; - if (len_session_userlist > 128 * PSTRING_LEN) { + if (len_session_userlist > 128 * 1024) { DEBUG(3,("add_session_user: session userlist already " "too large.\n")); return; } newlist = (char *)SMB_REALLOC_KEEP_OLD_ON_ERROR( session_userlist, - len_session_userlist + PSTRING_LEN ); + len_session_userlist + 1024 ); if( newlist == NULL ) { DEBUG(1,("Unable to resize session_userlist\n")); return; @@ -418,7 +418,7 @@ void add_session_user(const char *user) *newlist = '\0'; } session_userlist = newlist; - len_session_userlist += PSTRING_LEN; + len_session_userlist += 1024; } safe_strcat(session_userlist," ",len_session_userlist-1); diff --git a/source3/utils/net_rpc.c b/source3/utils/net_rpc.c index a89f1bf81a..e6a7e954fd 100644 --- a/source3/utils/net_rpc.c +++ b/source3/utils/net_rpc.c @@ -3591,11 +3591,12 @@ static void copy_fn(const char *mnt, file_info *f, const char *mask, void *state bool sync_files(struct copy_clistate *cp_clistate, pstring mask) { struct cli_state *targetcli; - pstring targetpath; + char *targetpath = NULL; DEBUG(3,("calling cli_list with mask: %s\n", mask)); - if ( !cli_resolve_path( "", cp_clistate->cli_share_src, mask, &targetcli, targetpath ) ) { + if ( !cli_resolve_path(talloc_tos(), "", cp_clistate->cli_share_src, + mask, &targetcli, &targetpath ) ) { d_fprintf(stderr, "cli_resolve_path %s failed with error: %s\n", mask, cli_errstr(cp_clistate->cli_share_src)); return False; -- cgit