sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-03-27 22:50:26 +03:00
Code

r25111: Move to talloced pathnames on most code paths.

Browse Source 
There are now ony 17 pstrings left in reply.c,
and these will be easy to remove (and I'll be
doing that shortly). Had to fix an interesting
bug in pull_ucs2_base_talloc() when a source
string is not null terminated :-).
Jeremy.
(This used to be commit 0c9a8c4dff10974dbffd2a302ae982896122fcc0)
This commit is contained in:
Jeremy Allison 2007-09-11 23:57:59 +00:00 committed by Gerald (Jerry) Carter
parent 1ef2464451
commit 3a9d382164
7 changed files with 438 additions and 341 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
source3/lib/charcnv.c
View File

@ -1460,7 +1460,21 @@ static size_t pull_ucs2_base_talloc(TALLOC_CTX *ctx,
if (dest_len) {
/* Did we already process the terminating zero ? */
if (dest[dest_len-1] != 0) {
dest[dest_len-1] = 0;
size_t size = talloc_get_size(dest);
/* Have we got space to append the '\0' ? */
if (size <= dest_len) {
/* No, realloc. */
dest = TALLOC_REALLOC(ctx, dest,
dest_len+1);
if (!dest) {
/* talloc fail. */
dest_len = (size_t)-1;
return 0;
}
}
/* Yay - space ! */
dest[dest_len] = '\0';
dest_len++;
}
} else if (dest) {
dest[0] = 0;

13
source3/smbd/dir.c
View File

@ -752,8 +752,9 @@ BOOL dir_check_ftype(connection_struct *conn, uint32 mode, uint32 dirtype)
return True;
}
static BOOL mangle_mask_match(connection_struct *conn, const char *filename,
char *mask)
static BOOL mangle_mask_match(connection_struct *conn,
const char *filename,
const char *mask)
{
char mname[13];
@ -791,11 +792,11 @@ BOOL get_dir_entry(connection_struct *conn,char *mask,uint32 dirtype, pstring fn
DEBUG(6,("readdir on dirptr 0x%lx now at offset %ld\n",
(long)conn->dirptr,TellDir(conn->dirptr->dir_hnd)));
if (dname == NULL)
if (dname == NULL)
return(False);
pstrcpy(filename,dname);
pstrcpy(filename,dname);
/* notice the special *.* handling. This appears to be the only difference
between the wildcard handling in this routine and in the trans2 routines.

3
source3/smbd/filename.c
View File

@ -553,8 +553,7 @@ NTSTATUS unix_convert(connection_struct *conn,
tmp = talloc_asprintf(ctx,
"%s/%s", dirpath,
found_name);
}
else {
} else {
tmp = talloc_strdup(ctx,
found_name);
}

16
source3/smbd/msdfs.c
View File

@ -817,9 +817,9 @@ NTSTATUS get_referred_path(TALLOC_CTX *ctx,
}
if (pdp->reqpath[0] != '\0') {
ref->alternate_path = talloc_asprintf(ctx,
"%s%s",
ref->alternate_path = talloc_asprintf_append(
ref->alternate_path,
"%s",
pdp->reqpath);
if (!ref->alternate_path) {
TALLOC_FREE(pdp);
@ -1298,7 +1298,6 @@ BOOL create_msdfs_link(const struct junction_map *jucn,
goto out;
}
for(i=0; i<jucn->referral_count; i++) {
char *old_msdfs_link = msdfs_link;
char *refpath = jucn->referral_list[i].alternate_path;
/* Alternate paths always use Windows separators. */
@ -1310,21 +1309,18 @@ BOOL create_msdfs_link(const struct junction_map *jucn,
continue;
}
if (i > 0 && insert_comma) {
msdfs_link = talloc_asprintf(conn->mem_ctx,
"%s,%s",
old_msdfs_link,
msdfs_link = talloc_asprintf_append(msdfs_link,
",%s",
refpath);
} else {
msdfs_link = talloc_asprintf(conn->mem_ctx,
"%s%s",
old_msdfs_link,
msdfs_link = talloc_asprintf_append(msdfs_link,
"%s",
refpath);
}
if (!msdfs_link) {
goto out;
}
TALLOC_FREE(old_msdfs_link);
if (!insert_comma) {
insert_comma = True;
}

376
source3/smbd/nttrans.c
View File

File diff suppressed because it is too large Load Diff

249
source3/smbd/reply.c
View File

@ -1,4 +1,4 @@
/*
/*
Unix SMB/CIFS implementation.
Main SMB reply routines
Copyright (C) Andrew Tridgell 1992-1998
@ -10,12 +10,12 @@
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 <http://www.gnu.org/licenses/>.
*/
@ -208,27 +208,46 @@ NTSTATUS check_path_syntax_posix(char *path)
Pull a string and check the path allowing a wilcard - provide for error return.
****************************************************************************/
size_t srvstr_get_path_wcard(const char *inbuf, uint16 smb_flags2, char *dest,
const char *src, size_t dest_len, size_t src_len,
int flags, NTSTATUS *err, BOOL *contains_wcard)
size_t srvstr_get_path_wcard(TALLOC_CTX *ctx,
const char *inbuf,
uint16 smb_flags2,
char **pp_dest,
const char *src,
size_t src_len,
int flags,
NTSTATUS *err,
BOOL *contains_wcard)
{
size_t ret;
#ifdef DEVELOPER
SMB_ASSERT(dest_len == sizeof(pstring));
#endif
*pp_dest = NULL;
if (src_len == 0) {
ret = srvstr_pull_buf(inbuf, smb_flags2, dest, src,
dest_len, flags);
ret = srvstr_pull_buf_talloc(ctx,
inbuf,
smb_flags2,
pp_dest,
src,
flags);
} else {
ret = srvstr_pull(inbuf, smb_flags2, dest, src,
dest_len, src_len, flags);
ret = srvstr_pull_talloc(ctx,
inbuf,
smb_flags2,
pp_dest,
src,
src_len,
flags);
}
if (!*pp_dest) {
*err = NT_STATUS_INVALID_PARAMETER;
return ret;
}
*contains_wcard = False;
if (smb_flags2 & FLAGS2_DFS_PATHNAMES) {
/*
/*
* For a DFS path the function parse_dfs_path()
* will do the path processing, just make a copy.
*/
@ -237,9 +256,9 @@ size_t srvstr_get_path_wcard(const char *inbuf, uint16 smb_flags2, char *dest,
}
if (lp_posix_pathnames()) {
*err = check_path_syntax_posix(dest);
*err = check_path_syntax_posix(*pp_dest);
} else {
*err = check_path_syntax_wcard(dest, contains_wcard);
*err = check_path_syntax_wcard(*pp_dest, contains_wcard);
}
return ret;
@ -249,25 +268,43 @@ size_t srvstr_get_path_wcard(const char *inbuf, uint16 smb_flags2, char *dest,
Pull a string and check the path - provide for error return.
****************************************************************************/
size_t srvstr_get_path(const char *inbuf, uint16 smb_flags2, char *dest,
const char *src, size_t dest_len, size_t src_len,
int flags, NTSTATUS *err)
size_t srvstr_get_path(TALLOC_CTX *ctx,
const char *inbuf,
uint16 smb_flags2,
char **pp_dest,
const char *src,
size_t src_len,
int flags,
NTSTATUS *err)
{
size_t ret;
#ifdef DEVELOPER
SMB_ASSERT(dest_len == sizeof(pstring));
#endif
*pp_dest = NULL;
if (src_len == 0) {
ret = srvstr_pull_buf(inbuf, smb_flags2, dest, src,
dest_len, flags);
ret = srvstr_pull_buf_talloc(ctx,
inbuf,
smb_flags2,
pp_dest,
src,
flags);
} else {
ret = srvstr_pull(inbuf, smb_flags2, dest, src,
dest_len, src_len, flags);
ret = srvstr_pull_talloc(ctx,
inbuf,
smb_flags2,
pp_dest,
src,
src_len,
flags);
}
if (!*pp_dest) {
*err = NT_STATUS_INVALID_PARAMETER;
return ret;
}
if (smb_flags2 & FLAGS2_DFS_PATHNAMES) {
/*
/*
* For a DFS path the function parse_dfs_path()
* will do the path processing, just make a copy.
*/
@ -276,9 +313,9 @@ size_t srvstr_get_path(const char *inbuf, uint16 smb_flags2, char *dest,
}
if (lp_posix_pathnames()) {
*err = check_path_syntax_posix(dest);
*err = check_path_syntax_posix(*pp_dest);
} else {
*err = check_path_syntax(dest);
*err = check_path_syntax(*pp_dest);
}
return ret;
@ -802,14 +839,13 @@ static NTSTATUS map_checkpath_error(const char *inbuf, NTSTATUS status)
}
return status;
}
/****************************************************************************
Reply to a checkpath.
****************************************************************************/
void reply_checkpath(connection_struct *conn, struct smb_request *req)
{
pstring name_in;
char *name = NULL;
SMB_STRUCT_STAT sbuf;
NTSTATUS status;
@ -817,8 +853,8 @@ void reply_checkpath(connection_struct *conn, struct smb_request *req)
START_PROFILE(SMBcheckpath);
srvstr_get_path((char *)req->inbuf, req->flags2, name_in,
smb_buf(req->inbuf) + 1, sizeof(name_in), 0,
srvstr_get_path(ctx,(char *)req->inbuf, req->flags2, &name,
smb_buf(req->inbuf) + 1, 0,
STR_TERMINATE, &status);
if (!NT_STATUS_IS_OK(status)) {
status = map_checkpath_error((char *)req->inbuf, status);
@ -829,7 +865,7 @@ void reply_checkpath(connection_struct *conn, struct smb_request *req)
status = resolve_dfspath(ctx, conn,
req->flags2 & FLAGS2_DFS_PATHNAMES,
name_in,
name,
&name);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
@ -841,7 +877,7 @@ void reply_checkpath(connection_struct *conn, struct smb_request *req)
goto path_err;
}
DEBUG(3,("reply_checkpath %s mode=%d\n", name_in, (int)SVAL(req->inbuf,smb_vwv0)));
DEBUG(3,("reply_checkpath %s mode=%d\n", name, (int)SVAL(req->inbuf,smb_vwv0)));
status = unix_convert(conn, name, False, &name, NULL, &sbuf);
if (!NT_STATUS_IS_OK(status)) {
@ -904,7 +940,6 @@ void reply_checkpath(connection_struct *conn, struct smb_request *req)
void reply_getatr(connection_struct *conn, struct smb_request *req)
{
pstring fname_in;
char *fname = NULL;
SMB_STRUCT_STAT sbuf;
int mode=0;
@ -917,8 +952,8 @@ void reply_getatr(connection_struct *conn, struct smb_request *req)
START_PROFILE(SMBgetatr);
p = smb_buf(req->inbuf) + 1;
p += srvstr_get_path((char *)req->inbuf, req->flags2, fname_in, p,
sizeof(fname_in), 0, STR_TERMINATE, &status);
p += srvstr_get_path(ctx, (char *)req->inbuf, req->flags2, &fname, p,
0, STR_TERMINATE, &status);
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
END_PROFILE(SMBgetatr);
@ -927,7 +962,7 @@ void reply_getatr(connection_struct *conn, struct smb_request *req)
status = resolve_dfspath(ctx, conn,
req->flags2 & FLAGS2_DFS_PATHNAMES,
fname_in,
fname,
&fname);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
@ -995,7 +1030,7 @@ void reply_getatr(connection_struct *conn, struct smb_request *req)
}
DEBUG(3,("reply_getatr: name=%s mode=%d size=%u\n", fname, mode, (unsigned int)size ) );
END_PROFILE(SMBgetatr);
return;
}
@ -1006,7 +1041,6 @@ void reply_getatr(connection_struct *conn, struct smb_request *req)
void reply_setatr(connection_struct *conn, struct smb_request *req)
{
pstring fname_in;
char *fname = NULL;
int mode;
time_t mtime;
@ -1023,8 +1057,8 @@ void reply_setatr(connection_struct *conn, struct smb_request *req)
}
p = smb_buf(req->inbuf) + 1;
p += srvstr_get_path((char *)req->inbuf, req->flags2, fname_in, p,
sizeof(fname_in), 0, STR_TERMINATE, &status);
p += srvstr_get_path(ctx, (char *)req->inbuf, req->flags2, &fname, p,
0, STR_TERMINATE, &status);
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
END_PROFILE(SMBsetatr);
@ -1033,7 +1067,7 @@ void reply_setatr(connection_struct *conn, struct smb_request *req)
status = resolve_dfspath(ctx, conn,
req->flags2 & FLAGS2_DFS_PATHNAMES,
fname_in,
fname,
&fname);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
@ -1046,7 +1080,7 @@ void reply_setatr(connection_struct *conn, struct smb_request *req)
END_PROFILE(SMBsetatr);
return;
}
status = unix_convert(conn, fname, False, &fname, NULL, &sbuf);
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
@ -1171,7 +1205,6 @@ void reply_search(connection_struct *conn, struct smb_request *req)
BOOL finished = False;
char *p;
int status_len;
pstring path_in;
char *path = NULL;
char status[21];
int dptr_num= -1;
@ -1207,9 +1240,15 @@ void reply_search(connection_struct *conn, struct smb_request *req)
maxentries = SVAL(req->inbuf,smb_vwv0);
dirtype = SVAL(req->inbuf,smb_vwv1);
p = smb_buf(req->inbuf) + 1;
p += srvstr_get_path_wcard((char *)req->inbuf, req->flags2, path_in, p,
sizeof(path_in), 0, STR_TERMINATE, &nt_status,
&mask_contains_wcard);
p += srvstr_get_path_wcard(ctx,
(char *)req->inbuf,
req->flags2,
&path,
p,
0,
STR_TERMINATE,
&nt_status,
&mask_contains_wcard);
if (!NT_STATUS_IS_OK(nt_status)) {
reply_nterror(req, nt_status);
END_PROFILE(SMBsearch);
@ -1218,7 +1257,7 @@ void reply_search(connection_struct *conn, struct smb_request *req)
nt_status = resolve_dfspath_wcard(ctx, conn,
req->flags2 & FLAGS2_DFS_PATHNAMES,
path_in,
path,
&path,
&mask_contains_wcard);
if (!NT_STATUS_IS_OK(nt_status)) {
@ -1440,12 +1479,13 @@ void reply_search(connection_struct *conn, struct smb_request *req)
void reply_fclose(connection_struct *conn, struct smb_request *req)
{
int status_len;
pstring path;
char status[21];
int dptr_num= -2;
char *p;
char *path = NULL;
NTSTATUS err;
BOOL path_contains_wcard = False;
TALLOC_CTX *ctx = talloc_tos();
START_PROFILE(SMBfclose);
@ -1456,9 +1496,15 @@ void reply_fclose(connection_struct *conn, struct smb_request *req)
}
p = smb_buf(req->inbuf) + 1;
p += srvstr_get_path_wcard((char *)req->inbuf, req->flags2, path, p,
sizeof(path), 0, STR_TERMINATE, &err,
&path_contains_wcard);
p += srvstr_get_path_wcard(ctx,
(char *)req->inbuf,
req->flags2,
&path,
p,
0,
STR_TERMINATE,
&err,
&path_contains_wcard);
if (!NT_STATUS_IS_OK(err)) {
reply_nterror(req, err);
END_PROFILE(SMBfclose);
@ -1496,7 +1542,6 @@ void reply_fclose(connection_struct *conn, struct smb_request *req)
void reply_open(connection_struct *conn, struct smb_request *req)
{
pstring fname_in;
char *fname = NULL;
uint32 fattr=0;
SMB_OFF_T size = 0;
@ -1526,8 +1571,8 @@ void reply_open(connection_struct *conn, struct smb_request *req)
deny_mode = SVAL(req->inbuf,smb_vwv0);
dos_attr = SVAL(req->inbuf,smb_vwv1);
srvstr_get_path((char *)req->inbuf, req->flags2, fname_in,
smb_buf(req->inbuf)+1, sizeof(fname_in), 0,
srvstr_get_path(ctx, (char *)req->inbuf, req->flags2, &fname,
smb_buf(req->inbuf)+1, 0,
STR_TERMINATE, &status);
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
@ -1537,7 +1582,7 @@ void reply_open(connection_struct *conn, struct smb_request *req)
status = resolve_dfspath(ctx, conn,
req->flags2 & FLAGS2_DFS_PATHNAMES,
fname_in,
fname,
&fname);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
@ -1634,7 +1679,6 @@ void reply_open(connection_struct *conn, struct smb_request *req)
void reply_open_and_X(connection_struct *conn, struct smb_request *req)
{
pstring fname_in;
char *fname = NULL;
uint16 open_flags;
int deny_mode;
@ -1692,8 +1736,8 @@ void reply_open_and_X(connection_struct *conn, struct smb_request *req)
}
/* XXXX we need to handle passed times, sattr and flags */
srvstr_get_path((char *)req->inbuf, req->flags2, fname_in,
smb_buf(req->inbuf), sizeof(fname_in), 0, STR_TERMINATE,
srvstr_get_path(ctx, (char *)req->inbuf, req->flags2, &fname,
smb_buf(req->inbuf), 0, STR_TERMINATE,
&status);
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
@ -1703,7 +1747,7 @@ void reply_open_and_X(connection_struct *conn, struct smb_request *req)
status = resolve_dfspath(ctx, conn,
req->flags2 & FLAGS2_DFS_PATHNAMES,
fname_in,
fname,
&fname);
if (!NT_STATUS_IS_OK(status)) {
END_PROFILE(SMBopenX);
@ -1882,7 +1926,6 @@ void reply_ulogoffX(connection_struct *conn, struct smb_request *req)
void reply_mknew(connection_struct *conn, struct smb_request *req)
{
pstring fname_in;
char *fname = NULL;
int com;
uint32 fattr = 0;
@ -1913,8 +1956,8 @@ void reply_mknew(connection_struct *conn, struct smb_request *req)
srv_make_unix_date3(req->inbuf + smb_vwv1));
/* mtime. */
srvstr_get_path((char *)req->inbuf, req->flags2, fname_in,
smb_buf(req->inbuf) + 1, sizeof(fname_in), 0,
srvstr_get_path(ctx, (char *)req->inbuf, req->flags2, &fname,
smb_buf(req->inbuf) + 1, 0,
STR_TERMINATE, &status);
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
@ -1924,7 +1967,7 @@ void reply_mknew(connection_struct *conn, struct smb_request *req)
status = resolve_dfspath(ctx, conn,
req->flags2 & FLAGS2_DFS_PATHNAMES,
fname_in,
fname,
&fname);
if (!NT_STATUS_IS_OK(status)) {
END_PROFILE(SMBcreate);
@ -2014,7 +2057,6 @@ void reply_mknew(connection_struct *conn, struct smb_request *req)
void reply_ctemp(connection_struct *conn, struct smb_request *req)
{
pstring fname_in;
char *fname = NULL;
uint32 fattr;
files_struct *fsp;
@ -2036,23 +2078,31 @@ void reply_ctemp(connection_struct *conn, struct smb_request *req)
fattr = SVAL(req->inbuf,smb_vwv0);
oplock_request = CORE_OPLOCK_REQUEST(req->inbuf);
srvstr_get_path((char *)req->inbuf, req->flags2, fname_in,
smb_buf(req->inbuf)+1, sizeof(fname_in), 0, STR_TERMINATE,
srvstr_get_path(ctx, (char *)req->inbuf, req->flags2, &fname,
smb_buf(req->inbuf)+1, 0, STR_TERMINATE,
&status);
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
END_PROFILE(SMBctemp);
return;
}
if (*fname_in) {
pstrcat(fname_in,"/TMXXXXXX");
if (*fname) {
fname = talloc_asprintf(ctx,
"%s/TMXXXXXX",
fname);
} else {
pstrcat(fname_in,"TMXXXXXX");
fname = talloc_strdup(ctx, "TMXXXXXX");
}
if (!fname) {
reply_nterror(req, NT_STATUS_NO_MEMORY);
END_PROFILE(SMBctemp);
return;
}
status = resolve_dfspath(ctx, conn,
req->flags2 & FLAGS2_DFS_PATHNAMES,
fname_in,
fname,
&fname);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
@ -2458,7 +2508,6 @@ NTSTATUS unlink_internals(connection_struct *conn, struct smb_request *req,
void reply_unlink(connection_struct *conn, struct smb_request *req)
{
pstring name_in;
char *name = NULL;
uint32 dirtype;
NTSTATUS status;
@ -2475,8 +2524,8 @@ void reply_unlink(connection_struct *conn, struct smb_request *req)
dirtype = SVAL(req->inbuf,smb_vwv0);
srvstr_get_path_wcard((char *)req->inbuf, req->flags2, name_in,
smb_buf(req->inbuf) + 1, sizeof(name_in), 0,
srvstr_get_path_wcard(ctx, (char *)req->inbuf, req->flags2, &name,
smb_buf(req->inbuf) + 1, 0,
STR_TERMINATE, &status, &path_contains_wcard);
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
@ -2486,7 +2535,7 @@ void reply_unlink(connection_struct *conn, struct smb_request *req)
status = resolve_dfspath_wcard(ctx, conn,
req->flags2 & FLAGS2_DFS_PATHNAMES,
name_in,
name,
&name,
&path_contains_wcard);
if (!NT_STATUS_IS_OK(status)) {
@ -4660,7 +4709,6 @@ void reply_printwrite(connection_struct *conn, struct smb_request *req)
void reply_mkdir(connection_struct *conn, struct smb_request *req)
{
pstring directory_in;
char *directory = NULL;
NTSTATUS status;
SMB_STRUCT_STAT sbuf;
@ -4668,8 +4716,8 @@ void reply_mkdir(connection_struct *conn, struct smb_request *req)
START_PROFILE(SMBmkdir);
srvstr_get_path((char *)req->inbuf, req->flags2, directory_in,
smb_buf(req->inbuf) + 1, sizeof(directory_in), 0,
srvstr_get_path(ctx, (char *)req->inbuf, req->flags2, &directory,
smb_buf(req->inbuf) + 1, 0,
STR_TERMINATE, &status);
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
@ -4679,7 +4727,7 @@ void reply_mkdir(connection_struct *conn, struct smb_request *req)
status = resolve_dfspath(ctx, conn,
req->flags2 & FLAGS2_DFS_PATHNAMES,
directory_in,
directory,
&directory);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
@ -4916,7 +4964,6 @@ NTSTATUS rmdir_internals(connection_struct *conn, const char *directory)
void reply_rmdir(connection_struct *conn, struct smb_request *req)
{
pstring directory_in;
char *directory = NULL;
SMB_STRUCT_STAT sbuf;
NTSTATUS status;
@ -4924,8 +4971,8 @@ void reply_rmdir(connection_struct *conn, struct smb_request *req)
START_PROFILE(SMBrmdir);
srvstr_get_path((char *)req->inbuf, req->flags2, directory_in,
smb_buf(req->inbuf) + 1, sizeof(directory_in), 0,
srvstr_get_path(ctx, (char *)req->inbuf, req->flags2, &directory,
smb_buf(req->inbuf) + 1, 0,
STR_TERMINATE, &status);
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
@ -4935,7 +4982,7 @@ void reply_rmdir(connection_struct *conn, struct smb_request *req)
status = resolve_dfspath(ctx, conn,
req->flags2 & FLAGS2_DFS_PATHNAMES,
directory_in,
directory,
&directory);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
@ -5683,8 +5730,6 @@ NTSTATUS rename_internals(connection_struct *conn, struct smb_request *req,
void reply_mv(connection_struct *conn, struct smb_request *req)
{
pstring name_in;
pstring newname_in;
char *name = NULL;
char *newname = NULL;
char *p;
@ -5705,8 +5750,8 @@ void reply_mv(connection_struct *conn, struct smb_request *req)
attrs = SVAL(req->inbuf,smb_vwv0);
p = smb_buf(req->inbuf) + 1;
p += srvstr_get_path_wcard((char *)req->inbuf, req->flags2, name_in, p,
sizeof(name_in), 0, STR_TERMINATE, &status,
p += srvstr_get_path_wcard(ctx, (char *)req->inbuf, req->flags2, &name, p,
0, STR_TERMINATE, &status,
&src_has_wcard);
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
@ -5714,8 +5759,8 @@ void reply_mv(connection_struct *conn, struct smb_request *req)
return;
}
p++;
p += srvstr_get_path_wcard((char *)req->inbuf, req->flags2, newname_in, p,
sizeof(newname_in), 0, STR_TERMINATE, &status,
p += srvstr_get_path_wcard(ctx, (char *)req->inbuf, req->flags2, &newname, p,
0, STR_TERMINATE, &status,
&dest_has_wcard);
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
@ -5725,7 +5770,7 @@ void reply_mv(connection_struct *conn, struct smb_request *req)
status = resolve_dfspath_wcard(ctx, conn,
req->flags2 & FLAGS2_DFS_PATHNAMES,
name_in,
name,
&name,
&src_has_wcard);
if (!NT_STATUS_IS_OK(status)) {
@ -5742,7 +5787,7 @@ void reply_mv(connection_struct *conn, struct smb_request *req)
status = resolve_dfspath_wcard(ctx, conn,
req->flags2 & FLAGS2_DFS_PATHNAMES,
newname_in,
newname,
&newname,
&dest_has_wcard);
if (!NT_STATUS_IS_OK(status)) {
@ -5903,9 +5948,7 @@ NTSTATUS copy_file(connection_struct *conn,
void reply_copy(connection_struct *conn, struct smb_request *req)
{
pstring name_in;
char *name = NULL;
pstring newname_in;
char *newname = NULL;
pstring directory;
pstring mask;
@ -5938,16 +5981,16 @@ void reply_copy(connection_struct *conn, struct smb_request *req)
*directory = *mask = 0;
p = smb_buf(req->inbuf);
p += srvstr_get_path_wcard((char *)req->inbuf, req->flags2, name_in, p,
sizeof(name_in), 0, STR_TERMINATE, &status,
p += srvstr_get_path_wcard(ctx, (char *)req->inbuf, req->flags2, &name, p,
0, STR_TERMINATE, &status,
&source_has_wild);
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
END_PROFILE(SMBcopy);
return;
}
p += srvstr_get_path_wcard((char *)req->inbuf, req->flags2, newname_in, p,
sizeof(newname_in), 0, STR_TERMINATE, &status,
p += srvstr_get_path_wcard(ctx, (char *)req->inbuf, req->flags2, &newname, p,
0, STR_TERMINATE, &status,
&dest_has_wild);
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
@ -5955,7 +5998,7 @@ void reply_copy(connection_struct *conn, struct smb_request *req)
return;
}
DEBUG(3,("reply_copy : %s -> %s\n",name_in,newname_in));
DEBUG(3,("reply_copy : %s -> %s\n",name,newname));
if (tid2 != conn->cnum) {
/* can't currently handle inter share copies XXXX */
@ -5967,7 +6010,7 @@ void reply_copy(connection_struct *conn, struct smb_request *req)
status = resolve_dfspath_wcard(ctx, conn,
req->flags2 & FLAGS2_DFS_PATHNAMES,
name_in,
name,
&name,
&source_has_wild);
if (!NT_STATUS_IS_OK(status)) {
@ -5984,7 +6027,7 @@ void reply_copy(connection_struct *conn, struct smb_request *req)
status = resolve_dfspath_wcard(ctx, conn,
req->flags2 & FLAGS2_DFS_PATHNAMES,
newname_in,
newname,
&newname,
&dest_has_wild);
if (!NT_STATUS_IS_OK(status)) {
@ -6085,7 +6128,7 @@ void reply_copy(connection_struct *conn, struct smb_request *req)
END_PROFILE(SMBcopy);
return;
}
status = check_name(conn, newname);
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);

106
source3/smbd/trans2.c
View File

@ -783,7 +783,6 @@ static void call_trans2open(connection_struct *conn,
int open_ofun;
uint32 open_size;
char *pname;
pstring fname_in;
char *fname = NULL;
SMB_OFF_T size=0;
int fattr=0,mtime=0;
@ -798,6 +797,7 @@ static void call_trans2open(connection_struct *conn,
uint32 share_mode;
uint32 create_disposition;
uint32 create_options = 0;
TALLOC_CTX *ctx = talloc_tos();
/*
* Ensure we have enough parameters to perform the operation.
@ -830,8 +830,8 @@ static void call_trans2open(connection_struct *conn,
return;
}
srvstr_get_path(params, req->flags2, fname_in, pname,
sizeof(fname_in), total_params - 28, STR_TERMINATE,
srvstr_get_path(ctx, params, req->flags2, &fname, pname,
total_params - 28, STR_TERMINATE,
&status);
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
@ -844,12 +844,12 @@ static void call_trans2open(connection_struct *conn,
/* XXXX we need to handle passed times, sattr and flags */
status = unix_convert(conn, fname_in, False, &fname, NULL, &sbuf);
status = unix_convert(conn, fname, False, &fname, NULL, &sbuf);
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
return;
}
status = check_name(conn, fname);
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
@ -1759,7 +1759,6 @@ static void call_trans2findfirst(connection_struct *conn,
BOOL close_if_end;
BOOL requires_resume_key;
int info_level;
pstring directory_in;
char *directory = NULL;
pstring mask;
char *p;
@ -1791,7 +1790,7 @@ static void call_trans2findfirst(connection_struct *conn,
requires_resume_key = (findfirst_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
info_level = SVAL(params,6);
*directory_in = *mask = 0;
*mask = 0;
DEBUG(3,("call_trans2findfirst: dirtype = %x, maxentries = %d, close_after_first=%d, \
close_if_end = %d requires_resume_key = %d level = 0x%x, max_data_bytes = %d\n",
@ -1826,8 +1825,8 @@ close_if_end = %d requires_resume_key = %d level = 0x%x, max_data_bytes = %d\n",
return;
}
srvstr_get_path_wcard(params, req->flags2, directory_in,
params+12, sizeof(directory_in), total_params - 12,
srvstr_get_path_wcard(ctx, params, req->flags2, &directory,
params+12, total_params - 12,
STR_TERMINATE, &ntstatus, &mask_contains_wcard);
if (!NT_STATUS_IS_OK(ntstatus)) {
reply_nterror(req, ntstatus);
@ -1836,7 +1835,7 @@ close_if_end = %d requires_resume_key = %d level = 0x%x, max_data_bytes = %d\n",
ntstatus = resolve_dfspath_wcard(ctx, conn,
req->flags2 & FLAGS2_DFS_PATHNAMES,
directory_in,
directory,
&directory,
&mask_contains_wcard);
if (!NT_STATUS_IS_OK(ntstatus)) {
@ -2101,7 +2100,7 @@ static void call_trans2findnext(connection_struct *conn,
BOOL requires_resume_key;
BOOL continue_bit;
BOOL mask_contains_wcard = False;
pstring resume_name;
char *resume_name = NULL;
pstring mask;
pstring directory;
char *p;
@ -2115,6 +2114,7 @@ static void call_trans2findnext(connection_struct *conn,
TALLOC_CTX *ea_ctx = NULL;
struct ea_list *ea_list = NULL;
NTSTATUS ntstatus = NT_STATUS_OK;
TALLOC_CTX *ctx = talloc_tos();
if (total_params < 13) {
reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
@ -2131,10 +2131,10 @@ static void call_trans2findnext(connection_struct *conn,
requires_resume_key = (findnext_flags & FLAG_TRANS2_FIND_REQUIRE_RESUME);
continue_bit = (findnext_flags & FLAG_TRANS2_FIND_CONTINUE);
*mask = *directory = *resume_name = 0;
*mask = *directory = 0;
srvstr_get_path_wcard(params, req->flags2, resume_name,
params+12, sizeof(resume_name),
srvstr_get_path_wcard(ctx, params, req->flags2, &resume_name,
params+12,
total_params - 12, STR_TERMINATE, &ntstatus,
&mask_contains_wcard);
if (!NT_STATUS_IS_OK(ntstatus)) {
@ -2142,12 +2142,12 @@ static void call_trans2findnext(connection_struct *conn,
complain (it thinks we're asking for the directory above the shared
path or an invalid name). Catch this as the resume name is only compared, never used in
a file access. JRA. */
srvstr_pull(params, req->flags2,
resume_name, params+12,
sizeof(resume_name), total_params - 12,
srvstr_pull_talloc(ctx, params, req->flags2,
&resume_name, params+12,
total_params - 12,
STR_TERMINATE);
if (!(ISDOT(resume_name) || ISDOTDOT(resume_name))) {
if (!resume_name || !(ISDOT(resume_name) || ISDOTDOT(resume_name))) {
reply_nterror(req, ntstatus);
return;
}
@ -3527,7 +3527,7 @@ static void call_trans2qfilepathinfo(connection_struct *conn,
struct ea_list *ea_list = NULL;
uint32 access_mask = 0x12019F; /* Default - GENERIC_EXECUTE mapping from Windows */
char *lock_data = NULL;
TALLOC_CTX *ctx = NULL;
TALLOC_CTX *ctx = talloc_tos();
if (!params) {
reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
@ -3620,7 +3620,6 @@ static void call_trans2qfilepathinfo(connection_struct *conn,
}
} else {
pstring fname_in;
NTSTATUS status = NT_STATUS_OK;
/* qpathinfo */
@ -3638,8 +3637,8 @@ static void call_trans2qfilepathinfo(connection_struct *conn,
return;
}
srvstr_get_path(params, req->flags2, fname_in, &params[6],
sizeof(fname_in), total_params - 6,
srvstr_get_path(ctx, params, req->flags2, &fname, &params[6],
total_params - 6,
STR_TERMINATE, &status);
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
@ -3649,7 +3648,7 @@ static void call_trans2qfilepathinfo(connection_struct *conn,
status = resolve_dfspath(ctx,
conn,
req->flags2 & FLAGS2_DFS_PATHNAMES,
fname_in,
fname,
&fname);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
@ -4835,9 +4834,10 @@ static NTSTATUS smb_set_file_unix_link(connection_struct *conn,
int total_data,
const char *fname)
{
pstring link_target;
char *link_target = NULL;
const char *newname = fname;
NTSTATUS status = NT_STATUS_OK;
TALLOC_CTX *ctx = talloc_tos();
/* Set a symbolic link. */
/* Don't allow this if follow links is false. */
@ -4850,8 +4850,12 @@ static NTSTATUS smb_set_file_unix_link(connection_struct *conn,
return NT_STATUS_ACCESS_DENIED;
}
srvstr_pull(pdata, req->flags2, link_target, pdata,
sizeof(link_target), total_data, STR_TERMINATE);
srvstr_pull_talloc(ctx, pdata, req->flags2, &link_target, pdata,
total_data, STR_TERMINATE);
if (!link_target) {
return NT_STATUS_INVALID_PARAMETER;
}
/* !widelinks forces the target path to be within the share. */
/* This means we can interpret the target as a pathname. */
@ -4897,7 +4901,6 @@ static NTSTATUS smb_set_file_unix_hlink(connection_struct *conn,
const char *pdata, int total_data,
const char *fname)
{
pstring oldname_in;
char *oldname = NULL;
TALLOC_CTX *ctx = talloc_tos();
NTSTATUS status = NT_STATUS_OK;
@ -4907,15 +4910,15 @@ static NTSTATUS smb_set_file_unix_hlink(connection_struct *conn,
return NT_STATUS_INVALID_PARAMETER;
}
srvstr_get_path(pdata, req->flags2, oldname_in, pdata,
sizeof(oldname_in), total_data, STR_TERMINATE, &status);
srvstr_get_path(ctx, pdata, req->flags2, &oldname, pdata,
total_data, STR_TERMINATE, &status);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
status = resolve_dfspath(ctx, conn,
req->flags2 & FLAGS2_DFS_PATHNAMES,
oldname_in,
oldname,
&oldname);
if (!NT_STATUS_IS_OK(status)) {
return status;
@ -4941,7 +4944,6 @@ static NTSTATUS smb_file_rename_information(connection_struct *conn,
BOOL overwrite;
uint32 root_fid;
uint32 len;
pstring newname_in;
char *newname = NULL;
pstring base_name;
BOOL dest_has_wcard = False;
@ -4961,16 +4963,19 @@ static NTSTATUS smb_file_rename_information(connection_struct *conn,
return NT_STATUS_INVALID_PARAMETER;
}
srvstr_get_path_wcard(pdata, req->flags2, newname_in, &pdata[12],
sizeof(newname_in), len, 0, &status,
srvstr_get_path_wcard(ctx, pdata, req->flags2, &newname, &pdata[12],
len, 0, &status,
&dest_has_wcard);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
DEBUG(10,("smb_file_rename_information: got name |%s|\n",
newname));
status = resolve_dfspath_wcard(ctx, conn,
req->flags2 & FLAGS2_DFS_PATHNAMES,
newname_in,
newname,
&newname,
&dest_has_wcard);
if (!NT_STATUS_IS_OK(status)) {
@ -6265,8 +6270,6 @@ static void call_trans2setfilepathinfo(connection_struct *conn,
}
}
} else {
pstring fname_in;
/* set path info */
if (total_params < 7) {
reply_nterror(req, NT_STATUS_INVALID_PARAMETER);
@ -6274,8 +6277,8 @@ static void call_trans2setfilepathinfo(connection_struct *conn,
}
info_level = SVAL(params,0);
srvstr_get_path(params, req->flags2, fname_in, &params[6],
sizeof(fname_in), total_params - 6, STR_TERMINATE,
srvstr_get_path(ctx, params, req->flags2, &fname, &params[6],
total_params - 6, STR_TERMINATE,
&status);
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
@ -6284,7 +6287,7 @@ static void call_trans2setfilepathinfo(connection_struct *conn,
status = resolve_dfspath(ctx, conn,
req->flags2 & FLAGS2_DFS_PATHNAMES,
fname_in,
fname,
&fname);
if (!NT_STATUS_IS_OK(status)) {
if (NT_STATUS_EQUAL(status,NT_STATUS_PATH_NOT_COVERED)) {
@ -6619,11 +6622,11 @@ static void call_trans2mkdir(connection_struct *conn, struct smb_request *req,
{
char *params = *pparams;
char *pdata = *ppdata;
pstring directory_in;
char *directory = NULL;
SMB_STRUCT_STAT sbuf;
NTSTATUS status = NT_STATUS_OK;
struct ea_list *ea_list = NULL;
TALLOC_CTX *ctx = talloc_tos();
if (!CAN_WRITE(conn)) {
reply_doserror(req, ERRSRV, ERRaccess);
@ -6635,17 +6638,17 @@ static void call_trans2mkdir(connection_struct *conn, struct smb_request *req,
return;
}
srvstr_get_path(params, req->flags2, directory_in, &params[4],
sizeof(directory_in), total_params - 4, STR_TERMINATE,
srvstr_get_path(ctx, params, req->flags2, &directory, &params[4],
total_params - 4, STR_TERMINATE,
&status);
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
return;
}
DEBUG(3,("call_trans2mkdir : name = %s\n", directory_in));
DEBUG(3,("call_trans2mkdir : name = %s\n", directory));
status = unix_convert(conn, directory_in, False, &directory, NULL, &sbuf);
status = unix_convert(conn, directory, False, &directory, NULL, &sbuf);
if (!NT_STATUS_IS_OK(status)) {
reply_nterror(req, status);
return;
@ -6821,10 +6824,11 @@ static void call_trans2getdfsreferral(connection_struct *conn,
unsigned int max_data_bytes)
{
char *params = *pparams;
pstring pathname;
char *pathname = NULL;
int reply_size = 0;
int max_referral_level;
NTSTATUS status = NT_STATUS_OK;
TALLOC_CTX *ctx = talloc_tos();
DEBUG(10,("call_trans2getdfsreferral\n"));
@ -6840,14 +6844,18 @@ static void call_trans2getdfsreferral(connection_struct *conn,
return;
}
srvstr_pull(params, req->flags2, pathname, &params[2],
sizeof(pathname), total_params - 2, STR_TERMINATE);
srvstr_pull_talloc(ctx, params, req->flags2, &pathname, &params[2],
total_params - 2, STR_TERMINATE);
if (!pathname) {
reply_nterror(req, NT_STATUS_NOT_FOUND);
return;
}
if((reply_size = setup_dfs_referral(conn, pathname, max_referral_level,
ppdata,&status)) < 0) {
reply_nterror(req, status);
return;
}
SSVAL(req->inbuf, smb_flg2,
SVAL(req->inbuf,smb_flg2) | FLAGS2_DFS_PATHNAMES);
send_trans2_replies(req,0,0,*ppdata,reply_size, max_data_bytes);
@ -6872,7 +6880,7 @@ static void call_trans2ioctl(connection_struct *conn,
files_struct *fsp = file_fsp(SVAL(req->inbuf,smb_vwv15));
/* check for an invalid fid before proceeding */
if (!fsp) {
reply_doserror(req, ERRDOS, ERRbadfid);
return;