1998-08-17 17:11:34 +04:00
/*
2002-01-30 09:08:46 +03:00
Unix SMB / CIFS implementation .
1998-08-17 17:11:34 +04:00
file opening and share modes
Copyright ( C ) Andrew Tridgell 1992 - 1998
2004-06-08 20:14:31 +04:00
Copyright ( C ) Jeremy Allison 2001 - 2004
2005-07-08 08:51:27 +04:00
Copyright ( C ) Volker Lendecke 2005
1998-08-17 17:11:34 +04:00
This program is free software ; you can redistribute it and / or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation ; either version 2 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 , write to the Free Software
Foundation , Inc . , 675 Mass Ave , Cambridge , MA 0213 9 , USA .
*/
# include "includes.h"
2006-02-04 01:19:41 +03:00
extern struct generic_mapping file_generic_mapping ;
2005-04-06 20:28:04 +04:00
extern struct current_user current_user ;
2001-01-23 04:52:30 +03:00
extern userdom_struct current_user_info ;
2003-08-19 05:53:45 +04:00
extern uint16 global_smbpid ;
1999-12-13 16:27:58 +03:00
extern BOOL global_client_failed_oplock_break ;
1998-08-17 17:11:34 +04:00
2005-09-30 21:13:37 +04:00
struct deferred_open_record {
BOOL delayed_for_oplocks ;
2004-06-08 20:14:31 +04:00
SMB_DEV_T dev ;
SMB_INO_T inode ;
} ;
1998-08-17 17:11:34 +04:00
/****************************************************************************
2000-04-12 01:38:45 +04:00
fd support routines - attempt to do a dos_open .
1998-08-17 17:11:34 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2000-04-12 01:38:45 +04:00
2005-07-08 08:51:27 +04:00
static int fd_open ( struct connection_struct * conn ,
const char * fname ,
int flags ,
mode_t mode )
1998-08-17 17:11:34 +04:00
{
2000-06-15 18:15:48 +04:00
int fd ;
2002-01-12 03:50:01 +03:00
# ifdef O_NOFOLLOW
2005-07-08 08:51:27 +04:00
if ( ! lp_symlinks ( SNUM ( conn ) ) ) {
2002-01-12 03:50:01 +03:00
flags | = O_NOFOLLOW ;
2005-07-08 08:51:27 +04:00
}
2002-01-12 03:50:01 +03:00
# endif
2003-05-14 14:59:01 +04:00
fd = SMB_VFS_OPEN ( conn , fname , flags , mode ) ;
1998-08-17 17:11:34 +04:00
2001-04-15 00:47:30 +04:00
DEBUG ( 10 , ( " fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s \n " , fname ,
flags , ( int ) mode , fd , ( fd = = - 1 ) ? strerror ( errno ) : " " ) ) ;
2000-04-12 01:38:45 +04:00
2000-04-10 17:05:23 +04:00
return fd ;
1998-08-17 17:11:34 +04:00
}
/****************************************************************************
2000-04-12 01:38:45 +04:00
Close the file associated with a fsp .
1998-08-17 17:11:34 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2000-04-12 01:38:45 +04:00
2005-07-08 08:51:27 +04:00
int fd_close ( struct connection_struct * conn ,
files_struct * fsp )
1998-08-17 17:11:34 +04:00
{
2005-07-08 08:51:27 +04:00
if ( fsp - > fh - > fd = = - 1 ) {
return 0 ; /* What we used to call a stat open. */
}
if ( fsp - > fh - > ref_count > 1 ) {
return 0 ; /* Shared handle. Only close last reference. */
}
2000-04-28 04:39:23 +04:00
return fd_close_posix ( conn , fsp ) ;
1998-08-17 17:11:34 +04:00
}
2005-03-15 04:19:58 +03:00
/****************************************************************************
Change the ownership of a file to that of the parent directory .
Do this by fd if possible .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2005-07-08 08:51:27 +04:00
void change_owner_to_parent ( connection_struct * conn ,
files_struct * fsp ,
const char * fname ,
SMB_STRUCT_STAT * psbuf )
2005-03-15 04:19:58 +03:00
{
const char * parent_path = parent_dirname ( fname ) ;
SMB_STRUCT_STAT parent_st ;
int ret ;
ret = SMB_VFS_STAT ( conn , parent_path , & parent_st ) ;
if ( ret = = - 1 ) {
2005-07-08 08:51:27 +04:00
DEBUG ( 0 , ( " change_owner_to_parent: failed to stat parent "
" directory %s. Error was %s \n " ,
parent_path , strerror ( errno ) ) ) ;
2005-03-15 04:19:58 +03:00
return ;
}
2005-07-08 08:51:27 +04:00
if ( fsp & & fsp - > fh - > fd ! = - 1 ) {
2005-03-15 04:19:58 +03:00
become_root ( ) ;
2005-07-08 08:51:27 +04:00
ret = SMB_VFS_FCHOWN ( fsp , fsp - > fh - > fd , parent_st . st_uid , ( gid_t ) - 1 ) ;
2005-03-15 04:19:58 +03:00
unbecome_root ( ) ;
if ( ret = = - 1 ) {
2005-07-08 08:51:27 +04:00
DEBUG ( 0 , ( " change_owner_to_parent: failed to fchown "
" file %s to parent directory uid %u. Error "
" was %s \n " , fname ,
( unsigned int ) parent_st . st_uid ,
strerror ( errno ) ) ) ;
2005-03-15 04:19:58 +03:00
}
2005-07-08 08:51:27 +04:00
DEBUG ( 10 , ( " change_owner_to_parent: changed new file %s to "
" parent directory uid %u. \n " , fname ,
( unsigned int ) parent_st . st_uid ) ) ;
2005-03-15 04:19:58 +03:00
} else {
2005-07-08 08:51:27 +04:00
/* We've already done an lstat into psbuf, and we know it's a
directory . If we can cd into the directory and the dev / ino
are the same then we can safely chown without races as
we ' re locking the directory in place by being in it . This
should work on any UNIX ( thanks tridge : - ) . JRA .
2005-03-17 04:50:09 +03:00
*/
2005-03-15 04:19:58 +03:00
2005-03-17 04:50:09 +03:00
pstring saved_dir ;
2005-03-15 04:19:58 +03:00
SMB_STRUCT_STAT sbuf ;
2005-03-17 04:50:09 +03:00
if ( ! vfs_GetWd ( conn , saved_dir ) ) {
2005-07-08 08:51:27 +04:00
DEBUG ( 0 , ( " change_owner_to_parent: failed to get "
" current working directory \n " ) ) ;
2005-03-17 04:50:09 +03:00
return ;
}
/* Chdir into the new path. */
if ( vfs_ChDir ( conn , fname ) = = - 1 ) {
2005-07-08 08:51:27 +04:00
DEBUG ( 0 , ( " change_owner_to_parent: failed to change "
" current working directory to %s. Error "
" was %s \n " , fname , strerror ( errno ) ) ) ;
2005-03-15 04:19:58 +03:00
goto out ;
}
2005-03-17 04:50:09 +03:00
if ( SMB_VFS_STAT ( conn , " . " , & sbuf ) = = - 1 ) {
2005-07-08 08:51:27 +04:00
DEBUG ( 0 , ( " change_owner_to_parent: failed to stat "
" directory '.' (%s) Error was %s \n " ,
fname , strerror ( errno ) ) ) ;
2005-03-15 04:19:58 +03:00
goto out ;
}
/* Ensure we're pointing at the same place. */
2005-07-08 08:51:27 +04:00
if ( sbuf . st_dev ! = psbuf - > st_dev | |
sbuf . st_ino ! = psbuf - > st_ino | |
sbuf . st_mode ! = psbuf - > st_mode ) {
DEBUG ( 0 , ( " change_owner_to_parent: "
" device/inode/mode on directory %s changed. "
" Refusing to chown ! \n " , fname ) ) ;
2005-03-15 04:19:58 +03:00
goto out ;
}
become_root ( ) ;
2005-03-17 04:50:09 +03:00
ret = SMB_VFS_CHOWN ( conn , " . " , parent_st . st_uid , ( gid_t ) - 1 ) ;
2005-03-15 04:19:58 +03:00
unbecome_root ( ) ;
if ( ret = = - 1 ) {
2005-07-08 08:51:27 +04:00
DEBUG ( 10 , ( " change_owner_to_parent: failed to chown "
" directory %s to parent directory uid %u. "
" Error was %s \n " , fname ,
( unsigned int ) parent_st . st_uid , strerror ( errno ) ) ) ;
2005-03-15 04:19:58 +03:00
goto out ;
}
2005-07-08 08:51:27 +04:00
DEBUG ( 10 , ( " change_owner_to_parent: changed ownership of new "
" directory %s to parent directory uid %u. \n " ,
fname , ( unsigned int ) parent_st . st_uid ) ) ;
2005-03-15 04:19:58 +03:00
out :
2005-03-17 04:50:09 +03:00
vfs_ChDir ( conn , saved_dir ) ;
2005-03-15 04:19:58 +03:00
}
}
1998-08-17 17:11:34 +04:00
/****************************************************************************
2000-04-12 01:38:45 +04:00
Open a file .
1998-08-17 17:11:34 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1999-12-13 16:27:58 +03:00
2005-07-08 08:51:27 +04:00
static BOOL open_file ( files_struct * fsp ,
connection_struct * conn ,
const char * fname ,
SMB_STRUCT_STAT * psbuf ,
int flags ,
mode_t unx_mode ,
uint32 access_mask )
1998-08-17 17:11:34 +04:00
{
2000-04-10 17:05:23 +04:00
int accmode = ( flags & O_ACCMODE ) ;
2001-04-16 04:02:29 +04:00
int local_flags = flags ;
2005-07-08 08:51:27 +04:00
BOOL file_existed = VALID_STAT ( * psbuf ) ;
1998-08-17 17:11:34 +04:00
2005-07-08 08:51:27 +04:00
fsp - > fh - > fd = - 1 ;
2000-04-10 17:05:23 +04:00
errno = EPERM ;
1998-08-17 17:11:34 +04:00
2000-04-12 01:38:45 +04:00
/* Check permissions */
1998-08-17 17:11:34 +04:00
2000-04-10 17:05:23 +04:00
/*
* This code was changed after seeing a client open request
* containing the open mode of ( DENY_WRITE / read - only ) with
* the ' create if not exist ' bit set . The previous code
* would fail to open the file read only on a read - only share
* as it was checking the flags parameter directly against O_RDONLY ,
* this was failing as the flags parameter was set to O_RDONLY | O_CREAT .
* JRA .
*/
1998-08-17 17:11:34 +04:00
2000-04-10 17:05:23 +04:00
if ( ! CAN_WRITE ( conn ) ) {
/* It's a read-only share - fail if we wanted to write. */
if ( accmode ! = O_RDONLY ) {
DEBUG ( 3 , ( " Permission denied opening %s \n " , fname ) ) ;
2000-04-22 04:33:16 +04:00
return False ;
2000-04-10 17:05:23 +04:00
} else if ( flags & O_CREAT ) {
2005-07-08 08:51:27 +04:00
/* We don't want to write - but we must make sure that
O_CREAT doesn ' t create the file if we have write
access into the directory .
2000-04-10 17:05:23 +04:00
*/
flags & = ~ O_CREAT ;
2003-07-24 23:10:52 +04:00
local_flags & = ~ O_CREAT ;
2000-04-10 17:05:23 +04:00
}
}
1998-08-17 17:11:34 +04:00
2001-04-16 04:02:29 +04:00
/*
* This little piece of insanity is inspired by the
* fact that an NT client can open a file for O_RDONLY ,
* but set the create disposition to FILE_EXISTS_TRUNCATE .
* If the client * can * write to the file , then it expects to
* truncate the file , even though it is opening for readonly .
* Quicken uses this stupid trick in backup file creation . . .
* Thanks * greatly * to " David W. Chapman Jr. " < dwcjr @ inethouston . net >
* for helping track this one down . It didn ' t bite us in 2.0 . x
* as we always opened files read - write in that release . JRA .
*/
2002-09-25 19:19:00 +04:00
if ( ( accmode = = O_RDONLY ) & & ( ( flags & O_TRUNC ) = = O_TRUNC ) ) {
2005-07-08 08:51:27 +04:00
DEBUG ( 10 , ( " open_file: truncate requested on read-only open "
" for file %s \n " , fname ) ) ;
2001-04-16 04:02:29 +04:00
local_flags = ( flags & ~ O_ACCMODE ) | O_RDWR ;
2002-09-25 19:19:00 +04:00
}
2001-04-16 04:02:29 +04:00
2005-07-08 08:51:27 +04:00
if ( ( access_mask & ( FILE_READ_DATA | FILE_WRITE_DATA | FILE_APPEND_DATA | FILE_EXECUTE ) ) | |
( local_flags & O_CREAT ) | |
( ( local_flags & O_TRUNC ) = = O_TRUNC ) ) {
2001-04-16 04:34:03 +04:00
2002-09-25 19:19:00 +04:00
/*
* We can ' t actually truncate here as the file may be locked .
* open_file_shared will take care of the truncate later . JRA .
*/
2001-04-16 04:34:03 +04:00
2002-09-25 19:19:00 +04:00
local_flags & = ~ O_TRUNC ;
# if defined(O_NONBLOCK) && defined(S_ISFIFO)
/*
* We would block on opening a FIFO with no one else on the
* other end . Do what we used to do and add O_NONBLOCK to the
* open flags . JRA .
*/
2005-07-08 08:51:27 +04:00
if ( file_existed & & S_ISFIFO ( psbuf - > st_mode ) ) {
2002-09-25 19:19:00 +04:00
local_flags | = O_NONBLOCK ;
2005-07-08 08:51:27 +04:00
}
2002-09-25 19:19:00 +04:00
# endif
1998-08-17 17:11:34 +04:00
2003-07-29 21:34:20 +04:00
/* Don't create files with Microsoft wildcard characters. */
2005-07-08 08:51:27 +04:00
if ( ( local_flags & O_CREAT ) & & ! file_existed & &
ms_has_wild ( fname ) ) {
2005-09-30 21:13:37 +04:00
set_saved_ntstatus ( NT_STATUS_OBJECT_NAME_INVALID ) ;
2003-07-29 21:34:20 +04:00
return False ;
}
2002-10-23 05:22:32 +04:00
/* Actually do the open */
2005-07-08 08:51:27 +04:00
fsp - > fh - > fd = fd_open ( conn , fname , local_flags , unx_mode ) ;
if ( fsp - > fh - > fd = = - 1 ) {
DEBUG ( 3 , ( " Error opening file %s (%s) (local_flags=%d) "
" (flags=%d) \n " ,
2002-03-20 03:46:53 +03:00
fname , strerror ( errno ) , local_flags , flags ) ) ;
return False ;
}
2003-05-01 21:45:38 +04:00
/* Inherit the ACL if the file was created. */
2005-07-08 08:51:27 +04:00
if ( ( local_flags & O_CREAT ) & & ! file_existed ) {
inherit_access_acl ( conn , fname , unx_mode ) ;
}
2003-05-01 21:45:38 +04:00
2005-07-08 08:51:27 +04:00
} else {
fsp - > fh - > fd = - 1 ; /* What we used to call a stat open. */
}
1998-08-17 17:11:34 +04:00
2005-07-08 08:51:27 +04:00
if ( ! file_existed ) {
2002-03-20 03:46:53 +03:00
int ret ;
2005-07-08 08:51:27 +04:00
if ( fsp - > fh - > fd = = - 1 ) {
2003-05-14 14:59:01 +04:00
ret = SMB_VFS_STAT ( conn , fname , psbuf ) ;
2005-07-08 08:51:27 +04:00
} else {
ret = SMB_VFS_FSTAT ( fsp , fsp - > fh - > fd , psbuf ) ;
2002-07-15 14:35:28 +04:00
/* If we have an fd, this stat should succeed. */
2005-07-08 08:51:27 +04:00
if ( ret = = - 1 ) {
DEBUG ( 0 , ( " Error doing fstat on open file %s "
" (%s) \n " , fname , strerror ( errno ) ) ) ;
}
2002-07-15 14:35:28 +04:00
}
2002-03-20 03:46:53 +03:00
2002-07-15 14:35:28 +04:00
/* For a non-io open, this stat failing means file not found. JRA */
2002-03-20 03:46:53 +03:00
if ( ret = = - 1 ) {
2000-10-19 06:58:24 +04:00
fd_close ( conn , fsp ) ;
return False ;
}
2000-05-12 04:11:49 +04:00
}
1998-08-17 17:11:34 +04:00
2000-04-12 01:38:45 +04:00
/*
* POSIX allows read - only opens of directories . We don ' t
* want to do this ( we use a different code path for this )
* so catch a directory open and return an EISDIR . JRA .
*/
2000-10-19 06:58:24 +04:00
if ( S_ISDIR ( psbuf - > st_mode ) ) {
2000-04-12 01:38:45 +04:00
fd_close ( conn , fsp ) ;
errno = EISDIR ;
2000-04-22 04:33:16 +04:00
return False ;
2000-04-12 01:38:45 +04:00
}
2000-10-19 06:58:24 +04:00
fsp - > mode = psbuf - > st_mode ;
fsp - > inode = psbuf - > st_ino ;
fsp - > dev = psbuf - > st_dev ;
2000-04-10 17:05:23 +04:00
fsp - > vuid = current_user . vuid ;
2003-08-19 05:53:45 +04:00
fsp - > file_pid = global_smbpid ;
2000-04-10 17:05:23 +04:00
fsp - > can_lock = True ;
2005-07-08 08:51:27 +04:00
fsp - > can_read = ( access_mask & ( FILE_READ_DATA ) ) ? True : False ;
if ( ! CAN_WRITE ( conn ) ) {
fsp - > can_write = False ;
} else {
fsp - > can_write = ( access_mask & ( FILE_WRITE_DATA | FILE_APPEND_DATA ) ) ? True : False ;
}
2000-04-10 17:05:23 +04:00
fsp - > print_file = False ;
fsp - > modified = False ;
fsp - > sent_oplock_break = NO_BREAK_SENT ;
fsp - > is_directory = False ;
2003-01-03 21:50:13 +03:00
fsp - > is_stat = False ;
2005-07-08 08:51:27 +04:00
if ( conn - > aio_write_behind_list & &
is_in_path ( fname , conn - > aio_write_behind_list , conn - > case_sensitive ) ) {
2005-06-28 02:53:56 +04:00
fsp - > aio_write_behind = True ;
}
2000-04-10 17:05:23 +04:00
string_set ( & fsp - > fsp_name , fname ) ;
fsp - > wcp = NULL ; /* Write cache pointer. */
1998-08-17 17:11:34 +04:00
2000-04-10 17:05:23 +04:00
DEBUG ( 2 , ( " %s opened file %s read=%s write=%s (numopen=%d) \n " ,
2001-01-23 04:52:30 +03:00
* current_user_info . smb_name ? current_user_info . smb_name : conn - > user , fsp - > fsp_name ,
2000-04-10 17:05:23 +04:00
BOOLSTR ( fsp - > can_read ) , BOOLSTR ( fsp - > can_write ) ,
2000-04-22 04:33:16 +04:00
conn - > num_files_open + 1 ) ) ;
2004-06-10 01:03:50 +04:00
errno = 0 ;
2000-04-22 04:33:16 +04:00
return True ;
1998-09-26 03:40:49 +04:00
}
1998-08-17 17:11:34 +04:00
2000-01-16 15:53:12 +03:00
/*******************************************************************
2004-06-08 20:14:31 +04:00
Return True if the filename is one of the special executable types .
2000-01-16 15:53:12 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2004-05-15 02:08:19 +04:00
2000-04-22 04:33:16 +04:00
static BOOL is_executable ( const char * fname )
2000-01-16 15:53:12 +03:00
{
2001-07-04 11:36:09 +04:00
if ( ( fname = strrchr_m ( fname , ' . ' ) ) ) {
2000-01-16 15:53:12 +03:00
if ( strequal ( fname , " .com " ) | |
strequal ( fname , " .dll " ) | |
strequal ( fname , " .exe " ) | |
strequal ( fname , " .sym " ) ) {
return True ;
}
}
return False ;
}
1998-09-05 09:07:05 +04:00
/****************************************************************************
2004-06-08 20:14:31 +04:00
Check if we can open a file with a share mode .
2005-07-08 08:51:27 +04:00
Returns True if conflict , False if not .
1998-09-05 09:07:05 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1999-12-13 16:27:58 +03:00
2005-09-30 21:13:37 +04:00
static BOOL share_conflict ( struct share_mode_entry * entry ,
2005-07-08 08:51:27 +04:00
uint32 access_mask ,
uint32 share_access )
2000-04-22 04:33:16 +04:00
{
2005-07-08 08:51:27 +04:00
DEBUG ( 10 , ( " share_conflict: entry->access_mask = 0x%x, "
" entry->share_access = 0x%x, "
" entry->private_options = 0x%x \n " ,
( unsigned int ) entry - > access_mask ,
( unsigned int ) entry - > share_access ,
( unsigned int ) entry - > private_options ) ) ;
DEBUG ( 10 , ( " share_conflict: access_mask = 0x%x, share_access = 0x%x \n " ,
( unsigned int ) access_mask , ( unsigned int ) share_access ) ) ;
if ( ( entry - > access_mask & ( FILE_WRITE_DATA |
FILE_APPEND_DATA |
FILE_READ_DATA |
FILE_EXECUTE |
DELETE_ACCESS ) ) = = 0 ) {
DEBUG ( 10 , ( " share_conflict: No conflict due to "
" entry->access_mask = 0x%x \n " ,
( unsigned int ) entry - > access_mask ) ) ;
2000-04-22 04:33:16 +04:00
return False ;
}
2005-07-08 08:51:27 +04:00
if ( ( access_mask & ( FILE_WRITE_DATA |
FILE_APPEND_DATA |
FILE_READ_DATA |
FILE_EXECUTE |
DELETE_ACCESS ) ) = = 0 ) {
DEBUG ( 10 , ( " share_conflict: No conflict due to "
" access_mask = 0x%x \n " ,
( unsigned int ) access_mask ) ) ;
This is a big, rather ugly patch. Whilst investigating the files not truncated
when copying to a full disk problem, I discovered that we were not allowing
the delete on close flag to be set properly, this led to other things, and
after investigation of the proper delete on close semantics and their relationship
to the file_share_delete flag I discovered there were some cases where we
weren't doing the deny modes properly. And this after only 5 years working
on them..... :-) :-).
So here's the latest attempt. I realised the delete on close flag needs to
be set across all smbds with a dev/ino pair open - in addition, the delete
on close flag, allow share delete and delete access requested all need to
be stored in the share mode tdb.
The "delete_on_close" entry in the fsp struct is now redundant and should
really be removed. This may also mean we can get rid of the "iterate_fsp"
calls that I didn't like adding in the first place. Whilst doing this patch,
I also discovered we needed to do the se_map_generic() call for file opens
and POSIX ACL mapping, so I added that also.
This code, although ugly, now passes the deny mode torture tests plus the
delete on close tests I added. I do need to add one more multiple connection
delete on close test to make sure I got the semantics exactly right, plus we
should also (as Andrew suggested) move to random testing here.
The good news is that NT should now correctly delete the file on disk
full error when copying to a disk :-).
Jeremy.
(This used to be commit 51987684bd231c744da2e5f3705fd236d5616173)
2001-03-30 12:57:24 +04:00
return False ;
}
2005-07-08 08:51:27 +04:00
# if 1 /* JRA TEST - Superdebug. */
# define CHECK_MASK(num, am, right, sa, share) \
DEBUG ( 10 , ( " share_conflict: [%d] am (0x%x) & right (0x%x) = 0x%x \n " , \
( unsigned int ) ( num ) , ( unsigned int ) ( am ) , \
( unsigned int ) ( right ) , ( unsigned int ) ( am ) & ( right ) ) ) ; \
DEBUG ( 10 , ( " share_conflict: [%d] sa (0x%x) & share (0x%x) = 0x%x \n " , \
( unsigned int ) ( num ) , ( unsigned int ) ( sa ) , \
( unsigned int ) ( share ) , ( unsigned int ) ( sa ) & ( share ) ) ) ; \
if ( ( ( am ) & ( right ) ) & & ! ( ( sa ) & ( share ) ) ) { \
DEBUG ( 10 , ( " share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
sa = 0 x % x , share = 0 x % x \ n " , (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
( unsigned int ) ( share ) ) ) ; \
return True ; \
}
# else
# define CHECK_MASK(num, am, right, sa, share) \
if ( ( ( am ) & ( right ) ) & & ! ( ( sa ) & ( share ) ) ) { \
DEBUG ( 10 , ( " share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
sa = 0 x % x , share = 0 x % x \ n " , (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
( unsigned int ) ( share ) ) ) ; \
return True ; \
This is a big, rather ugly patch. Whilst investigating the files not truncated
when copying to a full disk problem, I discovered that we were not allowing
the delete on close flag to be set properly, this led to other things, and
after investigation of the proper delete on close semantics and their relationship
to the file_share_delete flag I discovered there were some cases where we
weren't doing the deny modes properly. And this after only 5 years working
on them..... :-) :-).
So here's the latest attempt. I realised the delete on close flag needs to
be set across all smbds with a dev/ino pair open - in addition, the delete
on close flag, allow share delete and delete access requested all need to
be stored in the share mode tdb.
The "delete_on_close" entry in the fsp struct is now redundant and should
really be removed. This may also mean we can get rid of the "iterate_fsp"
calls that I didn't like adding in the first place. Whilst doing this patch,
I also discovered we needed to do the se_map_generic() call for file opens
and POSIX ACL mapping, so I added that also.
This code, although ugly, now passes the deny mode torture tests plus the
delete on close tests I added. I do need to add one more multiple connection
delete on close test to make sure I got the semantics exactly right, plus we
should also (as Andrew suggested) move to random testing here.
The good news is that NT should now correctly delete the file on disk
full error when copying to a disk :-).
Jeremy.
(This used to be commit 51987684bd231c744da2e5f3705fd236d5616173)
2001-03-30 12:57:24 +04:00
}
2005-03-03 00:43:54 +03:00
# endif
This is a big, rather ugly patch. Whilst investigating the files not truncated
when copying to a full disk problem, I discovered that we were not allowing
the delete on close flag to be set properly, this led to other things, and
after investigation of the proper delete on close semantics and their relationship
to the file_share_delete flag I discovered there were some cases where we
weren't doing the deny modes properly. And this after only 5 years working
on them..... :-) :-).
So here's the latest attempt. I realised the delete on close flag needs to
be set across all smbds with a dev/ino pair open - in addition, the delete
on close flag, allow share delete and delete access requested all need to
be stored in the share mode tdb.
The "delete_on_close" entry in the fsp struct is now redundant and should
really be removed. This may also mean we can get rid of the "iterate_fsp"
calls that I didn't like adding in the first place. Whilst doing this patch,
I also discovered we needed to do the se_map_generic() call for file opens
and POSIX ACL mapping, so I added that also.
This code, although ugly, now passes the deny mode torture tests plus the
delete on close tests I added. I do need to add one more multiple connection
delete on close test to make sure I got the semantics exactly right, plus we
should also (as Andrew suggested) move to random testing here.
The good news is that NT should now correctly delete the file on disk
full error when copying to a disk :-).
Jeremy.
(This used to be commit 51987684bd231c744da2e5f3705fd236d5616173)
2001-03-30 12:57:24 +04:00
2005-07-08 08:51:27 +04:00
CHECK_MASK ( 1 , entry - > access_mask , FILE_WRITE_DATA | FILE_APPEND_DATA ,
share_access , FILE_SHARE_WRITE ) ;
CHECK_MASK ( 2 , access_mask , FILE_WRITE_DATA | FILE_APPEND_DATA ,
entry - > share_access , FILE_SHARE_WRITE ) ;
CHECK_MASK ( 3 , entry - > access_mask , FILE_READ_DATA | FILE_EXECUTE ,
share_access , FILE_SHARE_READ ) ;
CHECK_MASK ( 4 , access_mask , FILE_READ_DATA | FILE_EXECUTE ,
entry - > share_access , FILE_SHARE_READ ) ;
2000-04-22 04:33:16 +04:00
2005-07-08 08:51:27 +04:00
CHECK_MASK ( 5 , entry - > access_mask , DELETE_ACCESS ,
share_access , FILE_SHARE_DELETE ) ;
CHECK_MASK ( 6 , access_mask , DELETE_ACCESS ,
entry - > share_access , FILE_SHARE_DELETE ) ;
2000-04-22 04:33:16 +04:00
2005-07-08 08:51:27 +04:00
DEBUG ( 10 , ( " share_conflict: No conflict. \n " ) ) ;
return False ;
2000-04-22 04:33:16 +04:00
}
2003-04-22 21:30:53 +04:00
# if defined(DEVELOPER)
2005-07-08 08:51:27 +04:00
static void validate_my_share_entries ( int num ,
2005-09-30 21:13:37 +04:00
struct share_mode_entry * share_entry )
2003-04-22 21:30:53 +04:00
{
files_struct * fsp ;
2005-09-30 21:13:37 +04:00
if ( ! procid_is_me ( & share_entry - > pid ) ) {
return ;
}
if ( is_deferred_open_entry ( share_entry ) & &
! open_was_deferred ( share_entry - > op_mid ) ) {
pstring str ;
DEBUG ( 0 , ( " Got a deferred entry without a request: "
" PANIC: %s \n " , share_mode_str ( num , share_entry ) ) ) ;
smb_panic ( str ) ;
}
if ( ! is_valid_share_mode_entry ( share_entry ) ) {
2003-04-22 21:30:53 +04:00
return ;
2005-07-08 08:51:27 +04:00
}
2003-04-22 21:30:53 +04:00
2005-07-08 08:51:27 +04:00
fsp = file_find_dif ( share_entry - > dev , share_entry - > inode ,
share_entry - > share_file_id ) ;
2003-04-22 21:30:53 +04:00
if ( ! fsp ) {
2005-07-08 08:51:27 +04:00
DEBUG ( 0 , ( " validate_my_share_entries: PANIC : %s \n " ,
share_mode_str ( num , share_entry ) ) ) ;
smb_panic ( " validate_my_share_entries: Cannot match a "
" share entry with an open file \n " ) ;
2003-04-22 21:30:53 +04:00
}
2005-09-30 21:13:37 +04:00
if ( is_deferred_open_entry ( share_entry ) | |
is_unused_share_mode_entry ( share_entry ) ) {
goto panic ;
}
if ( ( share_entry - > op_type = = NO_OPLOCK ) & &
( fsp - > oplock_type = = FAKE_LEVEL_II_OPLOCK ) ) {
/* Someone has already written to it, but I haven't yet
* noticed */
return ;
}
2003-04-22 21:30:53 +04:00
if ( ( ( uint16 ) fsp - > oplock_type ) ! = share_entry - > op_type ) {
2005-09-30 21:13:37 +04:00
goto panic ;
}
return ;
panic :
{
2003-04-22 21:30:53 +04:00
pstring str ;
2005-07-08 08:51:27 +04:00
DEBUG ( 0 , ( " validate_my_share_entries: PANIC : %s \n " ,
share_mode_str ( num , share_entry ) ) ) ;
slprintf ( str , sizeof ( str ) - 1 , " validate_my_share_entries: "
" file %s, oplock_type = 0x%x, op_type = 0x%x \n " ,
fsp - > fsp_name , ( unsigned int ) fsp - > oplock_type ,
( unsigned int ) share_entry - > op_type ) ;
2003-04-22 21:30:53 +04:00
smb_panic ( str ) ;
}
}
# endif
2005-09-30 21:13:37 +04:00
static BOOL is_stat_open ( uint32 access_mask )
2004-06-02 06:12:54 +04:00
{
2005-09-30 21:13:37 +04:00
return ( access_mask & &
( ( access_mask & ~ ( SYNCHRONIZE_ACCESS | FILE_READ_ATTRIBUTES |
FILE_WRITE_ATTRIBUTES ) ) = = 0 ) & &
( ( access_mask & ( SYNCHRONIZE_ACCESS | FILE_READ_ATTRIBUTES |
FILE_WRITE_ATTRIBUTES ) ) ! = 0 ) ) ;
2005-07-08 08:51:27 +04:00
}
2000-04-22 04:33:16 +04:00
/****************************************************************************
2005-09-30 21:13:37 +04:00
Deal with share modes
2000-04-22 04:33:16 +04:00
Invarient : Share mode must be locked on entry and exit .
Returns - 1 on error , or number of share modes on success ( may be zero ) .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2005-09-30 21:13:37 +04:00
static NTSTATUS open_mode_check ( connection_struct * conn ,
const char * fname ,
struct share_mode_lock * lck ,
uint32 access_mask ,
uint32 share_access ,
uint32 create_options ,
BOOL * file_existed )
1998-09-05 09:07:05 +04:00
{
2001-09-06 01:11:52 +04:00
int i ;
2004-05-30 11:21:50 +04:00
2005-09-30 21:13:37 +04:00
if ( lck - > num_share_modes = = 0 ) {
return NT_STATUS_OK ;
2004-08-27 05:16:25 +04:00
}
2005-09-30 21:13:37 +04:00
* file_existed = True ;
2001-09-06 01:11:52 +04:00
2005-09-30 21:13:37 +04:00
if ( is_stat_open ( access_mask ) ) {
2005-07-08 08:51:27 +04:00
/* Stat open that doesn't trigger oplock breaks or share mode
* checks . . . ! JRA . */
2005-09-30 21:13:37 +04:00
return NT_STATUS_OK ;
2004-05-30 11:21:50 +04:00
}
2005-07-08 08:51:27 +04:00
/* A delete on close prohibits everything */
2005-09-30 21:13:37 +04:00
if ( lck - > delete_on_close ) {
return NT_STATUS_DELETE_PENDING ;
2005-07-08 08:51:27 +04:00
}
2001-09-06 01:11:52 +04:00
/*
* Check if the share modes will give us access .
*/
2003-04-22 21:30:53 +04:00
# if defined(DEVELOPER)
2005-09-30 21:13:37 +04:00
for ( i = 0 ; i < lck - > num_share_modes ; i + + ) {
validate_my_share_entries ( i , & lck - > share_modes [ i ] ) ;
}
2003-04-22 21:30:53 +04:00
# endif
2005-09-30 21:13:37 +04:00
if ( ! lp_share_modes ( SNUM ( conn ) ) ) {
return NT_STATUS_OK ;
}
2005-07-08 08:51:27 +04:00
2005-09-30 21:13:37 +04:00
/* Now we check the share modes, after any oplock breaks. */
for ( i = 0 ; i < lck - > num_share_modes ; i + + ) {
2004-06-02 06:12:54 +04:00
2005-09-30 21:13:37 +04:00
if ( ! is_valid_share_mode_entry ( & lck - > share_modes [ i ] ) ) {
continue ;
2004-06-02 06:12:54 +04:00
}
2005-09-30 21:13:37 +04:00
/* someone else has a share lock on it, check to see if we can
* too */
if ( share_conflict ( & lck - > share_modes [ i ] ,
access_mask , share_access ) ) {
return NT_STATUS_SHARING_VIOLATION ;
2004-06-02 06:12:54 +04:00
}
2001-09-06 01:11:52 +04:00
}
2005-09-30 21:13:37 +04:00
return NT_STATUS_OK ;
1998-09-05 09:07:05 +04:00
}
2005-09-30 21:13:37 +04:00
static BOOL is_delete_request ( files_struct * fsp ) {
return ( ( fsp - > access_mask = = DELETE_ACCESS ) & &
( fsp - > oplock_type = = NO_OPLOCK ) ) ;
}
2004-06-08 20:14:31 +04:00
2005-09-30 21:13:37 +04:00
/*
* 1 ) No files open at all : Grant whatever the client wants .
*
* 2 ) Exclusive ( or batch ) oplock around : If the requested access is a delete
* request , break if the oplock around is a batch oplock . If it ' s another
* requested access type , break .
*
* 3 ) Only level2 around : Grant level2 and do nothing else .
*/
static BOOL delay_for_oplocks ( struct share_mode_lock * lck , files_struct * fsp )
2004-06-08 20:14:31 +04:00
{
2005-10-13 01:42:03 +04:00
int i ;
2005-09-30 21:13:37 +04:00
struct share_mode_entry * exclusive = NULL ;
2006-03-21 09:53:49 +03:00
BOOL valid_entry = False ;
2005-09-30 21:13:37 +04:00
BOOL delay_it = False ;
BOOL have_level2 = False ;
2004-06-08 20:14:31 +04:00
2005-09-30 21:13:37 +04:00
if ( is_stat_open ( fsp - > access_mask ) ) {
fsp - > oplock_type = NO_OPLOCK ;
return False ;
2004-06-26 04:47:58 +04:00
}
2005-09-30 21:13:37 +04:00
for ( i = 0 ; i < lck - > num_share_modes ; i + + ) {
if ( ! is_valid_share_mode_entry ( & lck - > share_modes [ i ] ) ) {
continue ;
}
2006-03-21 09:53:49 +03:00
/* At least one entry is not an invalid or deferred entry. */
valid_entry = True ;
2005-09-30 21:13:37 +04:00
if ( EXCLUSIVE_OPLOCK_TYPE ( lck - > share_modes [ i ] . op_type ) ) {
SMB_ASSERT ( exclusive = = NULL ) ;
exclusive = & lck - > share_modes [ i ] ;
}
if ( lck - > share_modes [ i ] . op_type = = LEVEL_II_OPLOCK ) {
2006-03-21 09:53:49 +03:00
SMB_ASSERT ( exclusive = = NULL ) ;
2005-09-30 21:13:37 +04:00
have_level2 = True ;
2004-06-08 20:14:31 +04:00
}
}
2005-09-30 21:13:37 +04:00
2006-03-21 09:53:49 +03:00
if ( ! valid_entry ) {
/* All entries are placeholders or deferred.
* Directly grant whatever the client wants . */
if ( fsp - > oplock_type = = NO_OPLOCK ) {
/* Store a level2 oplock, but don't tell the client */
fsp - > oplock_type = FAKE_LEVEL_II_OPLOCK ;
}
return False ;
}
2005-09-30 21:13:37 +04:00
if ( exclusive ! = NULL ) { /* Found an exclusive oplock */
SMB_ASSERT ( ! have_level2 ) ;
delay_it = is_delete_request ( fsp ) ?
BATCH_OPLOCK_TYPE ( exclusive - > op_type ) : True ;
}
if ( EXCLUSIVE_OPLOCK_TYPE ( fsp - > oplock_type ) ) {
2006-03-21 09:53:49 +03:00
/* We can at most grant level2 as there are other
* level2 or NO_OPLOCK entries . */
2005-09-30 21:13:37 +04:00
fsp - > oplock_type = LEVEL_II_OPLOCK ;
}
if ( ( fsp - > oplock_type = = NO_OPLOCK ) & & have_level2 ) {
/* Store a level2 oplock, but don't tell the client */
fsp - > oplock_type = FAKE_LEVEL_II_OPLOCK ;
}
if ( delay_it ) {
2005-12-25 00:06:41 +03:00
BOOL ret ;
2006-01-13 01:17:54 +03:00
char msg [ MSG_SMB_SHARE_MODE_ENTRY_SIZE ] ;
2005-09-30 21:13:37 +04:00
DEBUG ( 10 , ( " Sending break request to PID %s \n " ,
procid_str_static ( & exclusive - > pid ) ) ) ;
exclusive - > op_mid = get_current_mid ( ) ;
2006-01-13 01:17:54 +03:00
share_mode_entry_to_message ( msg , exclusive ) ;
2005-12-25 00:06:41 +03:00
become_root ( ) ;
ret = message_send_pid ( exclusive - > pid , MSG_SMB_BREAK_REQUEST ,
2006-01-13 01:17:54 +03:00
msg , MSG_SMB_SHARE_MODE_ENTRY_SIZE , True ) ;
2005-12-25 00:06:41 +03:00
unbecome_root ( ) ;
if ( ! ret ) {
2005-09-30 21:13:37 +04:00
DEBUG ( 3 , ( " Could not send oplock break message \n " ) ) ;
}
file_free ( fsp ) ;
}
return delay_it ;
}
static BOOL request_timed_out ( struct timeval request_time ,
struct timeval timeout )
{
struct timeval now , end_time ;
GetTimeOfDay ( & now ) ;
end_time = timeval_sum ( & request_time , & timeout ) ;
return ( timeval_compare ( & end_time , & now ) < 0 ) ;
2004-06-08 20:14:31 +04:00
}
/****************************************************************************
Handle the 1 second delay in returning a SHARING_VIOLATION error .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2005-09-30 21:13:37 +04:00
static void defer_open ( struct share_mode_lock * lck ,
struct timeval request_time ,
struct timeval timeout ,
struct deferred_open_record * state )
2004-06-08 20:14:31 +04:00
{
uint16 mid = get_current_mid ( ) ;
2005-09-30 21:13:37 +04:00
int i ;
2004-06-08 20:14:31 +04:00
2005-09-30 21:13:37 +04:00
/* Paranoia check */
2004-06-26 04:47:58 +04:00
2005-09-30 21:13:37 +04:00
for ( i = 0 ; i < lck - > num_share_modes ; i + + ) {
struct share_mode_entry * e = & lck - > share_modes [ i ] ;
2004-06-08 20:14:31 +04:00
2005-09-30 21:13:37 +04:00
if ( ! is_deferred_open_entry ( e ) ) {
continue ;
}
if ( procid_is_me ( & e - > pid ) & & ( e - > op_mid = = mid ) ) {
DEBUG ( 0 , ( " Trying to defer an already deferred "
" request: mid=%d, exiting \n " , mid ) ) ;
exit_server ( " exiting " ) ;
2004-06-08 20:14:31 +04:00
}
}
2005-09-30 21:13:37 +04:00
/* End paranoia check */
2005-07-08 08:51:27 +04:00
DEBUG ( 10 , ( " defer_open_sharing_error: time [%u.%06u] adding deferred "
2005-09-30 21:13:37 +04:00
" open entry for mid %u \n " ,
( unsigned int ) request_time . tv_sec ,
( unsigned int ) request_time . tv_usec ,
( unsigned int ) mid ) ) ;
2004-06-08 20:14:31 +04:00
2005-09-30 21:13:37 +04:00
if ( ! push_deferred_smb_message ( mid , request_time , timeout ,
( char * ) state , sizeof ( * state ) ) ) {
exit_server ( " push_deferred_smb_message failed \n " ) ;
2004-06-08 20:14:31 +04:00
}
2005-09-30 21:13:37 +04:00
add_deferred_open ( lck , mid , request_time , state - > dev , state - > inode ) ;
2004-06-09 02:13:59 +04:00
/*
* Push the MID of this packet on the signing queue .
* We only do this once , the first time we push the packet
* onto the deferred open queue , as this has a side effect
* of incrementing the response sequence number .
*/
srv_defer_sign_response ( mid ) ;
2004-06-08 20:14:31 +04:00
}
/****************************************************************************
Set a kernel flock on a file for NFS interoperability .
This requires a patch to Linux .
1998-08-17 17:11:34 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2004-06-08 20:14:31 +04:00
2005-07-08 08:51:27 +04:00
static void kernel_flock ( files_struct * fsp , uint32 share_mode )
2000-06-15 13:35:37 +04:00
{
# if HAVE_KERNEL_SHARE_MODES
int kernel_mode = 0 ;
2005-07-08 08:51:27 +04:00
if ( share_mode = = FILE_SHARE_WRITE ) {
kernel_mode = LOCK_MAND | LOCK_WRITE ;
} else if ( share_mode = = FILE_SHARE_READ ) {
kernel_mode = LOCK_MAND | LOCK_READ ;
} else if ( share_mode = = FILE_SHARE_NONE ) {
kernel_mode = LOCK_MAND ;
}
if ( kernel_mode ) {
flock ( fsp - > fh - > fd , kernel_mode ) ;
}
2000-06-15 13:35:37 +04:00
# endif
2005-07-08 08:51:27 +04:00
;
2000-06-15 13:35:37 +04:00
}
2005-07-08 08:51:27 +04:00
/****************************************************************************
On overwrite open ensure that the attributes match .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1999-12-13 16:27:58 +03:00
2005-07-08 08:51:27 +04:00
static BOOL open_match_attributes ( connection_struct * conn ,
const char * path ,
uint32 old_dos_attr ,
uint32 new_dos_attr ,
mode_t existing_unx_mode ,
mode_t new_unx_mode ,
mode_t * returned_unx_mode )
2002-09-25 19:19:00 +04:00
{
2005-07-08 08:51:27 +04:00
uint32 noarch_old_dos_attr , noarch_new_dos_attr ;
2002-09-25 19:19:00 +04:00
2005-07-08 08:51:27 +04:00
noarch_old_dos_attr = ( old_dos_attr & ~ FILE_ATTRIBUTE_ARCHIVE ) ;
noarch_new_dos_attr = ( new_dos_attr & ~ FILE_ATTRIBUTE_ARCHIVE ) ;
2003-02-04 04:11:56 +03:00
2005-07-08 08:51:27 +04:00
if ( ( noarch_old_dos_attr = = 0 & & noarch_new_dos_attr ! = 0 ) | |
( noarch_old_dos_attr ! = 0 & & ( ( noarch_old_dos_attr & noarch_new_dos_attr ) = = noarch_old_dos_attr ) ) ) {
* returned_unx_mode = new_unx_mode ;
} else {
* returned_unx_mode = ( mode_t ) 0 ;
}
2003-01-08 05:09:18 +03:00
2005-07-08 08:51:27 +04:00
DEBUG ( 10 , ( " open_match_attributes: file %s old_dos_attr = 0x%x, "
" existing_unx_mode = 0%o, new_dos_attr = 0x%x "
" returned_unx_mode = 0%o \n " ,
path ,
( unsigned int ) old_dos_attr ,
( unsigned int ) existing_unx_mode ,
( unsigned int ) new_dos_attr ,
( unsigned int ) * returned_unx_mode ) ) ;
2003-01-08 05:09:18 +03:00
2002-09-25 19:19:00 +04:00
/* If we're mapping SYSTEM and HIDDEN ensure they match. */
2004-04-02 22:46:19 +04:00
if ( lp_map_system ( SNUM ( conn ) ) | | lp_store_dos_attributes ( SNUM ( conn ) ) ) {
2005-07-08 08:51:27 +04:00
if ( ( old_dos_attr & FILE_ATTRIBUTE_SYSTEM ) & &
! ( new_dos_attr & FILE_ATTRIBUTE_SYSTEM ) ) {
2002-09-25 19:19:00 +04:00
return False ;
2005-07-08 08:51:27 +04:00
}
2002-09-25 19:19:00 +04:00
}
2004-04-02 22:46:19 +04:00
if ( lp_map_hidden ( SNUM ( conn ) ) | | lp_store_dos_attributes ( SNUM ( conn ) ) ) {
2005-07-08 08:51:27 +04:00
if ( ( old_dos_attr & FILE_ATTRIBUTE_HIDDEN ) & &
! ( new_dos_attr & FILE_ATTRIBUTE_HIDDEN ) ) {
2002-09-25 19:19:00 +04:00
return False ;
2005-07-08 08:51:27 +04:00
}
2002-09-25 19:19:00 +04:00
}
return True ;
}
2000-06-15 13:35:37 +04:00
/****************************************************************************
2005-07-08 08:51:27 +04:00
Special FCB or DOS processing in the case of a sharing violation .
Try and find a duplicated file handle .
2000-06-15 13:35:37 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2003-01-08 05:09:18 +03:00
2005-07-08 08:51:27 +04:00
static files_struct * fcb_or_dos_open ( connection_struct * conn ,
const char * fname , SMB_DEV_T dev ,
SMB_INO_T inode ,
uint32 access_mask ,
uint32 share_access ,
uint32 create_options )
2002-02-26 08:45:33 +03:00
{
2005-07-08 08:51:27 +04:00
files_struct * fsp ;
files_struct * dup_fsp ;
DEBUG ( 5 , ( " fcb_or_dos_open: attempting old open semantics for "
" file %s. \n " , fname ) ) ;
for ( fsp = file_find_di_first ( dev , inode ) ; fsp ;
fsp = file_find_di_next ( fsp ) ) {
DEBUG ( 10 , ( " fcb_or_dos_open: checking file %s, fd = %d, "
" vuid = %u, file_pid = %u, private_options = 0x%x "
" access_mask = 0x%x \n " , fsp - > fsp_name ,
fsp - > fh - > fd , ( unsigned int ) fsp - > vuid ,
( unsigned int ) fsp - > file_pid ,
( unsigned int ) fsp - > fh - > private_options ,
( unsigned int ) fsp - > access_mask ) ) ;
if ( fsp - > fh - > fd ! = - 1 & &
fsp - > vuid = = current_user . vuid & &
fsp - > file_pid = = global_smbpid & &
( fsp - > fh - > private_options & ( NTCREATEX_OPTIONS_PRIVATE_DENY_DOS |
NTCREATEX_OPTIONS_PRIVATE_DENY_FCB ) ) & &
( fsp - > access_mask & FILE_WRITE_DATA ) & &
strequal ( fsp - > fsp_name , fname ) ) {
DEBUG ( 10 , ( " fcb_or_dos_open: file match \n " ) ) ;
break ;
}
}
if ( ! fsp ) {
return NULL ;
}
/* quite an insane set of semantics ... */
if ( is_executable ( fname ) & &
( fsp - > fh - > private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS ) ) {
DEBUG ( 10 , ( " fcb_or_dos_open: file fail due to is_executable. \n " ) ) ;
return NULL ;
}
/* We need to duplicate this fsp. */
dup_fsp = dup_file_fsp ( fsp , access_mask , share_access , create_options ) ;
if ( ! dup_fsp ) {
return NULL ;
}
return dup_fsp ;
}
/****************************************************************************
Open a file with a share mode - old openX method - map into NTCreate .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
BOOL map_open_params_to_ntcreate ( const char * fname , int deny_mode , int open_func ,
uint32 * paccess_mask ,
uint32 * pshare_mode ,
uint32 * pcreate_disposition ,
uint32 * pcreate_options )
{
uint32 access_mask ;
uint32 share_mode ;
uint32 create_disposition ;
uint32 create_options = 0 ;
DEBUG ( 10 , ( " map_open_params_to_ntcreate: fname = %s, deny_mode = 0x%x, "
" open_func = 0x%x \n " ,
fname , ( unsigned int ) deny_mode , ( unsigned int ) open_func ) ) ;
/* Create the NT compatible access_mask. */
switch ( GET_OPENX_MODE ( deny_mode ) ) {
2005-09-10 01:49:16 +04:00
case DOS_OPEN_EXEC : /* Implies read-only - used to be FILE_READ_DATA */
2005-07-08 08:51:27 +04:00
case DOS_OPEN_RDONLY :
access_mask = FILE_GENERIC_READ ;
break ;
case DOS_OPEN_WRONLY :
access_mask = FILE_GENERIC_WRITE ;
break ;
case DOS_OPEN_RDWR :
case DOS_OPEN_FCB :
access_mask = FILE_GENERIC_READ | FILE_GENERIC_WRITE ;
break ;
default :
DEBUG ( 10 , ( " map_open_params_to_ntcreate: bad open mode = 0x%x \n " ,
( unsigned int ) GET_OPENX_MODE ( deny_mode ) ) ) ;
return False ;
}
/* Create the NT compatible create_disposition. */
switch ( open_func ) {
case OPENX_FILE_EXISTS_FAIL | OPENX_FILE_CREATE_IF_NOT_EXIST :
create_disposition = FILE_CREATE ;
break ;
case OPENX_FILE_EXISTS_OPEN :
create_disposition = FILE_OPEN ;
break ;
case OPENX_FILE_EXISTS_OPEN | OPENX_FILE_CREATE_IF_NOT_EXIST :
create_disposition = FILE_OPEN_IF ;
break ;
case OPENX_FILE_EXISTS_TRUNCATE :
create_disposition = FILE_OVERWRITE ;
break ;
case OPENX_FILE_EXISTS_TRUNCATE | OPENX_FILE_CREATE_IF_NOT_EXIST :
create_disposition = FILE_OVERWRITE_IF ;
break ;
default :
/* From samba4 - to be confirmed. */
if ( GET_OPENX_MODE ( deny_mode ) = = DOS_OPEN_EXEC ) {
create_disposition = FILE_CREATE ;
break ;
}
DEBUG ( 10 , ( " map_open_params_to_ntcreate: bad "
" open_func 0x%x \n " , ( unsigned int ) open_func ) ) ;
return False ;
}
/* Create the NT compatible share modes. */
switch ( GET_DENY_MODE ( deny_mode ) ) {
case DENY_ALL :
share_mode = FILE_SHARE_NONE ;
break ;
case DENY_WRITE :
share_mode = FILE_SHARE_READ ;
break ;
case DENY_READ :
share_mode = FILE_SHARE_WRITE ;
break ;
case DENY_NONE :
share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE ;
break ;
case DENY_DOS :
create_options | = NTCREATEX_OPTIONS_PRIVATE_DENY_DOS ;
if ( is_executable ( fname ) ) {
share_mode = FILE_SHARE_READ | FILE_SHARE_WRITE ;
} else {
if ( GET_OPENX_MODE ( deny_mode ) = = DOS_OPEN_RDONLY ) {
share_mode = FILE_SHARE_READ ;
} else {
share_mode = FILE_SHARE_NONE ;
}
}
break ;
case DENY_FCB :
create_options | = NTCREATEX_OPTIONS_PRIVATE_DENY_FCB ;
share_mode = FILE_SHARE_NONE ;
break ;
default :
DEBUG ( 10 , ( " map_open_params_to_ntcreate: bad deny_mode 0x%x \n " ,
( unsigned int ) GET_DENY_MODE ( deny_mode ) ) ) ;
return False ;
}
DEBUG ( 10 , ( " map_open_params_to_ntcreate: file %s, access_mask = 0x%x, "
" share_mode = 0x%x, create_disposition = 0x%x, "
" create_options = 0x%x \n " ,
fname ,
( unsigned int ) access_mask ,
( unsigned int ) share_mode ,
( unsigned int ) create_disposition ,
( unsigned int ) create_options ) ) ;
if ( paccess_mask ) {
* paccess_mask = access_mask ;
}
if ( pshare_mode ) {
* pshare_mode = share_mode ;
}
if ( pcreate_disposition ) {
* pcreate_disposition = create_disposition ;
}
if ( pcreate_options ) {
* pcreate_options = create_options ;
}
return True ;
2002-02-26 08:45:33 +03:00
}
/****************************************************************************
2003-01-08 05:09:18 +03:00
Open a file with a share mode .
2002-02-26 08:45:33 +03:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2003-01-08 05:09:18 +03:00
2005-07-08 08:51:27 +04:00
files_struct * open_file_ntcreate ( connection_struct * conn ,
const char * fname ,
SMB_STRUCT_STAT * psbuf ,
uint32 access_mask , /* access bits (FILE_READ_DATA etc.) */
uint32 share_access , /* share constants (FILE_SHARE_READ etc). */
uint32 create_disposition , /* FILE_OPEN_IF etc. */
uint32 create_options , /* options such as delete on close. */
uint32 new_dos_attributes , /* attributes used for new file. */
int oplock_request , /* internal Samba oplock codes. */
/* Information (FILE_EXISTS etc.) */
int * pinfo )
1998-08-17 17:11:34 +04:00
{
2000-04-22 04:33:16 +04:00
int flags = 0 ;
int flags2 = 0 ;
2000-10-19 06:58:24 +04:00
BOOL file_existed = VALID_STAT ( * psbuf ) ;
2002-03-12 00:57:12 +03:00
BOOL def_acl = False ;
2004-06-08 20:14:31 +04:00
BOOL internal_only_open = False ;
2000-04-22 04:33:16 +04:00
SMB_DEV_T dev = 0 ;
SMB_INO_T inode = 0 ;
2000-04-24 23:23:51 +04:00
BOOL fsp_open = False ;
2000-04-22 04:33:16 +04:00
files_struct * fsp = NULL ;
2005-07-08 08:51:27 +04:00
mode_t new_unx_mode = ( mode_t ) 0 ;
mode_t unx_mode = ( mode_t ) 0 ;
int info ;
uint32 existing_dos_attributes = 0 ;
2004-06-08 20:14:31 +04:00
struct pending_message_list * pml = NULL ;
uint16 mid = get_current_mid ( ) ;
2005-09-30 21:13:37 +04:00
BOOL delayed_for_oplocks = False ;
struct timeval request_time = timeval_zero ( ) ;
struct share_mode_lock * lck = NULL ;
NTSTATUS status ;
2005-07-08 08:51:27 +04:00
if ( conn - > printer ) {
/*
* Printers are handled completely differently .
* Most of the passed parameters are ignored .
*/
if ( pinfo ) {
* pinfo = FILE_WAS_CREATED ;
}
DEBUG ( 10 , ( " open_file_ntcreate: printer open fname=%s \n " , fname ) ) ;
return print_fsp_open ( conn , fname ) ;
}
/* We add aARCH to this as this mode is only used if the file is
* created new . */
unx_mode = unix_mode ( conn , new_dos_attributes | aARCH , fname , True ) ;
DEBUG ( 10 , ( " open_file_ntcreate: fname=%s, dos_attrs=0x%x "
" access_mask=0x%x share_access=0x%x "
" create_disposition = 0x%x create_options=0x%x "
" unix mode=0%o oplock_request=%d \n " ,
fname , new_dos_attributes , access_mask , share_access ,
create_disposition , create_options , unx_mode ,
oplock_request ) ) ;
2000-04-22 04:33:16 +04:00
2004-06-08 20:14:31 +04:00
if ( oplock_request = = INTERNAL_OPEN_ONLY ) {
internal_only_open = True ;
oplock_request = 0 ;
}
if ( ( pml = get_open_deferred_message ( mid ) ) ! = NULL ) {
2005-09-30 21:13:37 +04:00
struct deferred_open_record * state =
( struct deferred_open_record * ) pml - > private_data . data ;
2004-06-08 20:14:31 +04:00
2006-03-21 02:40:43 +03:00
/* Remember the absolute time of the original
request with this mid . We ' ll use it later to
see if this has timed out . */
2005-09-30 21:13:37 +04:00
request_time = pml - > request_time ;
delayed_for_oplocks = state - > delayed_for_oplocks ;
2004-06-08 20:14:31 +04:00
2006-03-21 02:40:43 +03:00
/* Remove the deferred open entry under lock. */
2005-12-13 01:07:36 +03:00
lck = get_share_mode_lock ( NULL , state - > dev , state - > inode , NULL , NULL ) ;
2005-09-30 21:13:37 +04:00
if ( lck = = NULL ) {
DEBUG ( 0 , ( " could not get share mode lock \n " ) ) ;
} else {
del_deferred_open_entry ( lck , mid ) ;
2006-02-26 17:20:29 +03:00
TALLOC_FREE ( lck ) ;
2004-06-08 20:14:31 +04:00
}
2005-09-30 21:13:37 +04:00
2004-06-08 20:14:31 +04:00
/* Ensure we don't reprocess this message. */
2005-09-30 21:13:37 +04:00
remove_deferred_open_smb_message ( mid ) ;
2000-04-22 04:33:16 +04:00
}
1998-08-17 17:11:34 +04:00
2000-04-22 04:33:16 +04:00
if ( ! check_name ( fname , conn ) ) {
return NULL ;
}
2005-07-08 08:51:27 +04:00
new_dos_attributes & = SAMBA_ATTRIBUTES_MASK ;
2004-04-02 22:46:19 +04:00
if ( file_existed ) {
2005-07-08 08:51:27 +04:00
existing_dos_attributes = dos_mode ( conn , fname , psbuf ) ;
2004-04-02 22:46:19 +04:00
}
2000-04-22 04:33:16 +04:00
/* ignore any oplock requests if oplocks are disabled */
2005-09-30 21:13:37 +04:00
if ( ! lp_oplocks ( SNUM ( conn ) ) | | global_client_failed_oplock_break | |
IS_VETO_OPLOCK_PATH ( conn , fname ) ) {
2000-04-22 04:33:16 +04:00
oplock_request = 0 ;
}
2005-03-17 17:32:52 +03:00
/* this is for OS/2 long file names - say we don't support them */
2005-07-08 08:51:27 +04:00
if ( ! lp_posix_pathnames ( ) & & strstr ( fname , " .+,;=[]. " ) ) {
/* OS/2 Workplace shell fix may be main code stream in a later
* release . */
set_saved_error_triple ( ERRDOS , ERRcannotopen ,
NT_STATUS_OBJECT_NAME_NOT_FOUND ) ;
DEBUG ( 5 , ( " open_file_ntcreate: OS/2 long filenames are not "
" supported. \n " ) ) ;
2000-04-22 04:33:16 +04:00
return NULL ;
}
1998-08-17 17:11:34 +04:00
2005-07-08 08:51:27 +04:00
switch ( create_disposition ) {
/*
* Currently we ' re using FILE_SUPERSEDE as the same as
* FILE_OVERWRITE_IF but they really are
* different . FILE_SUPERSEDE deletes an existing file
* ( requiring delete access ) then recreates it .
*/
case FILE_SUPERSEDE :
/* If file exists replace/overwrite. If file doesn't
* exist create . */
flags2 | = ( O_CREAT | O_TRUNC ) ;
break ;
2000-04-22 04:33:16 +04:00
2005-07-08 08:51:27 +04:00
case FILE_OVERWRITE_IF :
/* If file exists replace/overwrite. If file doesn't
* exist create . */
flags2 | = ( O_CREAT | O_TRUNC ) ;
break ;
2000-04-22 04:33:16 +04:00
2005-07-08 08:51:27 +04:00
case FILE_OPEN :
/* If file exists open. If file doesn't exist error. */
if ( ! file_existed ) {
DEBUG ( 5 , ( " open_file_ntcreate: FILE_OPEN "
" requested for file %s and file "
" doesn't exist. \n " , fname ) ) ;
2005-09-30 21:13:37 +04:00
set_saved_ntstatus ( NT_STATUS_OBJECT_NAME_NOT_FOUND ) ;
2005-07-08 08:51:27 +04:00
errno = ENOENT ;
return NULL ;
}
break ;
case FILE_OVERWRITE :
/* If file exists overwrite. If file doesn't exist
* error . */
if ( ! file_existed ) {
DEBUG ( 5 , ( " open_file_ntcreate: FILE_OVERWRITE "
" requested for file %s and file "
" doesn't exist. \n " , fname ) ) ;
2005-09-30 21:13:37 +04:00
set_saved_ntstatus ( NT_STATUS_OBJECT_NAME_NOT_FOUND ) ;
2005-07-08 08:51:27 +04:00
errno = ENOENT ;
return NULL ;
}
flags2 | = O_TRUNC ;
break ;
case FILE_CREATE :
/* If file exists error. If file doesn't exist
* create . */
if ( file_existed ) {
DEBUG ( 5 , ( " open_file_ntcreate: FILE_CREATE "
" requested for file %s and file "
" already exists. \n " , fname ) ) ;
if ( S_ISDIR ( psbuf - > st_mode ) ) {
errno = EISDIR ;
} else {
errno = EEXIST ;
}
return NULL ;
}
flags2 | = ( O_CREAT | O_EXCL ) ;
break ;
case FILE_OPEN_IF :
/* If file exists open. If file doesn't exist
* create . */
flags2 | = O_CREAT ;
break ;
default :
2005-09-30 21:13:37 +04:00
set_saved_ntstatus ( NT_STATUS_INVALID_PARAMETER ) ;
2005-07-08 08:51:27 +04:00
return NULL ;
}
/* We only care about matching attributes on file exists and
* overwrite . */
if ( file_existed & & ( ( create_disposition = = FILE_OVERWRITE ) | |
( create_disposition = = FILE_OVERWRITE_IF ) ) ) {
if ( ! open_match_attributes ( conn , fname ,
existing_dos_attributes ,
new_dos_attributes , psbuf - > st_mode ,
unx_mode , & new_unx_mode ) ) {
DEBUG ( 5 , ( " open_file_ntcreate: attributes missmatch "
" for file %s (%x %x) (0%o, 0%o) \n " ,
fname , existing_dos_attributes ,
new_dos_attributes ,
( unsigned int ) psbuf - > st_mode ,
( unsigned int ) unx_mode ) ) ;
2002-09-25 19:19:00 +04:00
errno = EACCES ;
return NULL ;
}
}
2005-07-08 08:51:27 +04:00
/* This is a nasty hack - must fix... JRA. */
if ( access_mask = = MAXIMUM_ALLOWED_ACCESS ) {
access_mask = FILE_GENERIC_ALL ;
}
2000-04-22 04:33:16 +04:00
2005-07-08 08:51:27 +04:00
/*
* Convert GENERIC bits to specific bits .
*/
2000-04-22 04:33:16 +04:00
2005-07-08 08:51:27 +04:00
se_map_generic ( & access_mask , & file_generic_mapping ) ;
DEBUG ( 10 , ( " open_file_ntcreate: fname=%s, after mapping "
" access_mask=0x%x \n " , fname , access_mask ) ) ;
/*
* Note that we ignore the append flag as append does not
* mean the same thing under DOS and Unix .
*/
if ( access_mask & ( FILE_WRITE_DATA | FILE_APPEND_DATA ) ) {
flags = O_RDWR ;
} else {
flags = O_RDONLY ;
2000-04-22 04:33:16 +04:00
}
1998-08-17 17:11:34 +04:00
2005-07-08 08:51:27 +04:00
/*
* Currently we only look at FILE_WRITE_THROUGH for create options .
*/
1998-08-17 17:11:34 +04:00
# if defined(O_SYNC)
2005-07-08 08:51:27 +04:00
if ( create_options & FILE_WRITE_THROUGH ) {
2000-04-22 04:33:16 +04:00
flags2 | = O_SYNC ;
}
1998-08-17 17:11:34 +04:00
# endif /* O_SYNC */
2005-07-08 08:51:27 +04:00
if ( ! CAN_WRITE ( conn ) ) {
/*
* We should really return a permission denied error if either
* O_CREAT or O_TRUNC are set , but for compatibility with
* older versions of Samba we just AND them out .
*/
flags2 & = ~ ( O_CREAT | O_TRUNC ) ;
2000-04-22 04:33:16 +04:00
}
1998-08-17 17:11:34 +04:00
2005-07-08 08:51:27 +04:00
/*
* Ensure we can ' t write on a read - only share or file .
*/
1998-08-17 17:11:34 +04:00
2005-07-08 08:51:27 +04:00
if ( flags ! = O_RDONLY & & file_existed & &
( ! CAN_WRITE ( conn ) | | IS_DOS_READONLY ( existing_dos_attributes ) ) ) {
DEBUG ( 5 , ( " open_file_ntcreate: write access requested for "
" file %s on read only %s \n " ,
fname , ! CAN_WRITE ( conn ) ? " share " : " file " ) ) ;
2005-09-30 21:13:37 +04:00
set_saved_ntstatus ( NT_STATUS_ACCESS_DENIED ) ;
2005-07-08 08:51:27 +04:00
errno = EACCES ;
return NULL ;
2004-05-30 11:21:50 +04:00
}
2005-03-31 23:10:59 +04:00
fsp = file_new ( conn ) ;
2005-07-08 08:51:27 +04:00
if ( ! fsp ) {
2005-03-31 23:10:59 +04:00
return NULL ;
2005-07-08 08:51:27 +04:00
}
2005-03-31 23:10:59 +04:00
2005-09-30 21:13:37 +04:00
fsp - > dev = psbuf - > st_dev ;
fsp - > inode = psbuf - > st_ino ;
fsp - > share_access = share_access ;
fsp - > fh - > private_options = create_options ;
fsp - > access_mask = access_mask ;
fsp - > oplock_type = oplock_request ;
if ( timeval_is_zero ( & request_time ) ) {
request_time = fsp - > open_time ;
}
2000-04-22 04:33:16 +04:00
if ( file_existed ) {
2000-10-19 06:58:24 +04:00
dev = psbuf - > st_dev ;
inode = psbuf - > st_ino ;
1998-08-17 17:11:34 +04:00
2005-12-13 01:07:36 +03:00
lck = get_share_mode_lock ( NULL , dev , inode ,
conn - > connectpath ,
fname ) ;
2005-09-30 21:13:37 +04:00
if ( lck = = NULL ) {
DEBUG ( 0 , ( " Could not get share mode lock \n " ) ) ;
set_saved_ntstatus ( NT_STATUS_SHARING_VIOLATION ) ;
return NULL ;
}
if ( delay_for_oplocks ( lck , fsp ) ) {
struct deferred_open_record state ;
2006-03-21 02:40:43 +03:00
/* This is a relative time, added to the absolute
request_time value to get the absolute timeout time .
Note that if this is the second or greater time we enter
this codepath for this particular request mid then
request_time is left as the absolute time of the * first *
time this request mid was processed . This is what allows
the request to eventually time out . */
2005-09-30 21:13:37 +04:00
2006-03-21 02:40:43 +03:00
struct timeval timeout ;
2005-09-30 21:13:37 +04:00
/* Normally the smbd we asked should respond within
* OPLOCK_BREAK_TIMEOUT seconds regardless of whether
* the client did , give twice the timeout as a safety
* measure here in case the other smbd is stuck
* somewhere else . */
2006-03-21 02:40:43 +03:00
timeout = timeval_set ( OPLOCK_BREAK_TIMEOUT * 2 , 0 ) ;
/* Nothing actually uses state.delayed_for_oplocks
but it ' s handy to differentiate in debug messages
between a 30 second delay due to oplock break , and
a 1 second delay for share mode conflicts . */
2005-09-30 21:13:37 +04:00
state . delayed_for_oplocks = True ;
state . dev = dev ;
state . inode = inode ;
if ( ! request_timed_out ( request_time , timeout ) ) {
defer_open ( lck , request_time , timeout ,
& state ) ;
}
2006-02-20 20:59:58 +03:00
TALLOC_FREE ( lck ) ;
2005-09-30 21:13:37 +04:00
return NULL ;
}
status = open_mode_check ( conn , fname , lck ,
access_mask , share_access ,
create_options , & file_existed ) ;
if ( NT_STATUS_EQUAL ( status , NT_STATUS_DELETE_PENDING ) ) {
/* DELETE_PENDING is not deferred for a second */
set_saved_ntstatus ( status ) ;
2006-02-20 20:59:58 +03:00
TALLOC_FREE ( lck ) ;
2005-09-30 21:13:37 +04:00
file_free ( fsp ) ;
return NULL ;
}
if ( ! NT_STATUS_IS_OK ( status ) ) {
SMB_ASSERT ( NT_STATUS_EQUAL ( status , NT_STATUS_SHARING_VIOLATION ) ) ;
/* Check if this can be done with the deny_dos and fcb
* calls . */
if ( create_options &
( NTCREATEX_OPTIONS_PRIVATE_DENY_DOS |
NTCREATEX_OPTIONS_PRIVATE_DENY_FCB ) ) {
files_struct * fsp_dup ;
fsp_dup = fcb_or_dos_open ( conn , fname , dev ,
inode , access_mask ,
share_access ,
create_options ) ;
if ( fsp_dup ) {
2006-02-20 20:59:58 +03:00
TALLOC_FREE ( lck ) ;
2005-09-30 21:13:37 +04:00
file_free ( fsp ) ;
if ( pinfo ) {
* pinfo = FILE_WAS_OPENED ;
2005-07-08 08:51:27 +04:00
}
2005-09-30 21:13:37 +04:00
conn - > num_files_open + + ;
return fsp_dup ;
2005-07-08 08:51:27 +04:00
}
}
2000-12-12 00:09:48 +03:00
/*
2005-07-08 08:51:27 +04:00
* This next line is a subtlety we need for
* MS - Access . If a file open will fail due to share
* permissions and also for security ( access ) reasons ,
* we need to return the access failed error , not the
* share error . This means we must attempt to open the
* file anyway in order to get the UNIX access error -
* even if we ' re going to fail the open for share
* reasons . This is bad , as we ' re burning another fd
* if there are existing locks but there ' s nothing
* else we can do . We also ensure we ' re not going to
* create or tuncate the file as we only want an
* access decision at this stage . JRA .
2000-12-12 00:09:48 +03:00
*/
2003-02-12 04:13:35 +03:00
errno = 0 ;
2002-03-20 03:46:53 +03:00
fsp_open = open_file ( fsp , conn , fname , psbuf ,
2005-07-08 08:51:27 +04:00
flags | ( flags2 & ~ ( O_TRUNC | O_CREAT ) ) ,
unx_mode , access_mask ) ;
2001-04-14 00:49:11 +04:00
2005-07-08 08:51:27 +04:00
DEBUG ( 4 , ( " open_file_ntcreate : share_mode deny - "
" calling open_file with flags=0x%X "
" flags2=0x%X mode=0%o returned %d \n " ,
flags , ( flags2 & ~ ( O_TRUNC | O_CREAT ) ) ,
( unsigned int ) unx_mode , ( int ) fsp_open ) ) ;
2000-12-12 00:09:48 +03:00
2003-02-12 04:13:35 +03:00
if ( ! fsp_open & & errno ) {
2005-04-02 03:11:28 +04:00
/* Default error. */
2005-09-30 21:13:37 +04:00
set_saved_ntstatus ( NT_STATUS_ACCESS_DENIED ) ;
2003-02-12 04:13:35 +03:00
}
2004-06-08 20:14:31 +04:00
/*
2005-07-08 08:51:27 +04:00
* If we ' re returning a share violation , ensure we
* cope with the braindead 1 second delay .
2004-06-08 20:14:31 +04:00
*/
2005-09-30 21:13:37 +04:00
if ( ! internal_only_open & &
lp_defer_sharing_violations ( ) ) {
struct timeval timeout ;
struct deferred_open_record state ;
2006-03-21 02:40:43 +03:00
/* This is a relative time, added to the absolute
request_time value to get the absolute timeout time .
Note that if this is the second or greater time we enter
this codepath for this particular request mid then
request_time is left as the absolute time of the * first *
time this request mid was processed . This is what allows
the request to eventually time out . */
2005-09-30 21:13:37 +04:00
timeout = timeval_set ( 0 , SHARING_VIOLATION_USEC_WAIT ) ;
2006-03-21 02:40:43 +03:00
/* Nothing actually uses state.delayed_for_oplocks
but it ' s handy to differentiate in debug messages
between a 30 second delay due to oplock break , and
a 1 second delay for share mode conflicts . */
2005-09-30 21:13:37 +04:00
state . delayed_for_oplocks = False ;
state . dev = dev ;
state . inode = inode ;
if ( ! request_timed_out ( request_time ,
timeout ) ) {
defer_open ( lck , request_time , timeout ,
& state ) ;
2005-04-02 03:11:28 +04:00
}
2004-06-08 20:14:31 +04:00
}
2006-02-20 20:59:58 +03:00
TALLOC_FREE ( lck ) ;
2004-06-08 20:14:31 +04:00
if ( fsp_open ) {
2001-04-14 00:49:11 +04:00
fd_close ( conn , fsp ) ;
2004-06-08 20:14:31 +04:00
/*
* We have detected a sharing violation here
* so return the correct error code
*/
2005-09-30 21:13:37 +04:00
set_saved_ntstatus ( NT_STATUS_SHARING_VIOLATION ) ;
2004-06-08 20:14:31 +04:00
}
2000-04-22 04:33:16 +04:00
file_free ( fsp ) ;
return NULL ;
}
1998-08-17 17:11:34 +04:00
2000-04-22 04:33:16 +04:00
/*
* We exit this block with the share entry * locked * . . . . .
*/
}
1998-08-17 17:11:34 +04:00
2005-09-30 21:13:37 +04:00
SMB_ASSERT ( ! file_existed | | ( lck ! = NULL ) ) ;
2002-03-12 00:57:12 +03:00
/*
* Ensure we pay attention to default ACLs on directories if required .
*/
if ( ( flags2 & O_CREAT ) & & lp_inherit_acls ( SNUM ( conn ) ) & &
2005-09-30 21:13:37 +04:00
( def_acl = directory_has_default_acl ( conn ,
parent_dirname ( fname ) ) ) ) {
2005-07-08 08:51:27 +04:00
unx_mode = 0777 ;
}
2002-03-12 00:57:12 +03:00
2000-04-22 04:33:16 +04:00
DEBUG ( 4 , ( " calling open_file with flags=0x%X flags2=0x%X mode=0%o \n " ,
2005-09-30 21:13:37 +04:00
( unsigned int ) flags , ( unsigned int ) flags2 ,
( unsigned int ) unx_mode ) ) ;
1999-12-13 16:27:58 +03:00
2001-04-16 04:34:03 +04:00
/*
* open_file strips any O_TRUNC flags itself .
*/
2005-09-30 21:13:37 +04:00
fsp_open = open_file ( fsp , conn , fname , psbuf , flags | flags2 , unx_mode ,
access_mask ) ;
1998-08-17 17:11:34 +04:00
2000-04-24 23:23:51 +04:00
if ( ! fsp_open ) {
2005-09-30 21:13:37 +04:00
if ( lck ! = NULL ) {
2006-02-20 20:59:58 +03:00
TALLOC_FREE ( lck ) ;
2005-07-08 08:51:27 +04:00
}
2000-04-22 04:33:16 +04:00
file_free ( fsp ) ;
return NULL ;
}
1998-08-17 17:11:34 +04:00
2000-04-22 04:33:16 +04:00
if ( ! file_existed ) {
1998-09-05 00:53:58 +04:00
2005-09-30 21:13:37 +04:00
/*
* Deal with the race condition where two smbd ' s detect the
* file doesn ' t exist and do the create at the same time . One
* of them will win and set a share mode , the other ( ie . this
* one ) should check if the requested share mode for this
* create is allowed .
*/
2003-07-08 02:29:40 +04:00
/*
* Now the file exists and fsp is successfully opened ,
* fsp - > dev and fsp - > inode are valid and should replace the
* dev = 0 , inode = 0 from a non existent file . Spotted by
* Nadav Danieli < nadavd @ exanet . com > . JRA .
*/
dev = fsp - > dev ;
inode = fsp - > inode ;
2005-12-13 01:07:36 +03:00
lck = get_share_mode_lock ( NULL , dev , inode ,
conn - > connectpath ,
fname ) ;
2004-06-08 20:14:31 +04:00
2005-09-30 21:13:37 +04:00
if ( lck = = NULL ) {
2005-10-28 02:35:08 +04:00
DEBUG ( 0 , ( " open_file_ntcreate: Could not get share mode lock for %s \n " , fname ) ) ;
2005-09-30 21:13:37 +04:00
fd_close ( conn , fsp ) ;
2000-04-22 04:33:16 +04:00
file_free ( fsp ) ;
2005-09-30 21:13:37 +04:00
set_saved_ntstatus ( NT_STATUS_SHARING_VIOLATION ) ;
2000-04-22 04:33:16 +04:00
return NULL ;
}
1999-12-13 16:27:58 +03:00
2005-09-30 21:13:37 +04:00
status = open_mode_check ( conn , fname , lck ,
access_mask , share_access ,
create_options , & file_existed ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
struct deferred_open_record state ;
2001-07-06 03:37:09 +04:00
2005-09-30 21:13:37 +04:00
fd_close ( conn , fsp ) ;
file_free ( fsp ) ;
state . delayed_for_oplocks = False ;
state . dev = dev ;
state . inode = inode ;
/* Do it all over again immediately. In the second
* round we will find that the file existed and handle
* the DELETE_PENDING and FCB cases correctly . No need
* to duplicate the code here . Essentially this is a
* " goto top of this function " , but don ' t tell
* anybody . . . */
defer_open ( lck , request_time , timeval_zero ( ) ,
& state ) ;
2006-02-20 20:59:58 +03:00
TALLOC_FREE ( lck ) ;
2005-09-30 21:13:37 +04:00
return NULL ;
2005-07-08 08:51:27 +04:00
}
2001-07-06 03:37:09 +04:00
2000-04-22 04:33:16 +04:00
/*
* We exit this block with the share entry * locked * . . . . .
*/
}
1999-12-13 16:27:58 +03:00
2005-09-30 21:13:37 +04:00
SMB_ASSERT ( lck ! = NULL ) ;
2000-12-12 00:09:48 +03:00
/* note that we ignore failure for the following. It is
basically a hack for NFS , and NFS will never set one of
these only read them . Nobody but Samba can ever set a deny
mode and we have already checked our more authoritative
locking database for permission to set this deny mode . If
the kernel refuses the operations then the kernel is wrong */
2005-07-08 08:51:27 +04:00
kernel_flock ( fsp , share_access ) ;
2000-12-12 00:09:48 +03:00
2000-04-22 04:33:16 +04:00
/*
* At this point onwards , we can guarentee that the share entry
* is locked , whether we created the file or not , and that the
* deny mode is compatible with all current opens .
*/
1998-08-17 17:11:34 +04:00
2000-04-22 04:33:16 +04:00
/*
* If requested , truncate the file .
*/
1998-08-17 17:11:34 +04:00
2000-10-19 06:58:24 +04:00
if ( flags2 & O_TRUNC ) {
/*
2005-07-08 08:51:27 +04:00
* We are modifing the file after open - update the stat
* struct . .
2000-10-19 06:58:24 +04:00
*/
2005-07-08 08:51:27 +04:00
if ( ( SMB_VFS_FTRUNCATE ( fsp , fsp - > fh - > fd , 0 ) = = - 1 ) | |
( SMB_VFS_FSTAT ( fsp , fsp - > fh - > fd , psbuf ) = = - 1 ) ) {
2006-02-20 20:59:58 +03:00
TALLOC_FREE ( lck ) ;
2000-10-19 06:58:24 +04:00
fd_close ( conn , fsp ) ;
file_free ( fsp ) ;
return NULL ;
}
2000-04-22 04:33:16 +04:00
}
1998-08-17 17:11:34 +04:00
2005-07-08 08:51:27 +04:00
/* Record the options we were opened with. */
fsp - > share_access = share_access ;
fsp - > fh - > private_options = create_options ;
fsp - > access_mask = access_mask ;
1998-08-17 17:11:34 +04:00
2005-07-08 08:51:27 +04:00
if ( file_existed ) {
if ( ! ( flags2 & O_TRUNC ) ) {
info = FILE_WAS_OPENED ;
} else {
info = FILE_WAS_OVERWRITTEN ;
}
} else {
info = FILE_WAS_CREATED ;
2005-03-15 04:19:58 +03:00
/* Change the owner if required. */
if ( lp_inherit_owner ( SNUM ( conn ) ) ) {
2005-07-08 08:51:27 +04:00
change_owner_to_parent ( conn , fsp , fsp - > fsp_name ,
psbuf ) ;
2005-03-15 04:19:58 +03:00
}
}
1998-08-17 17:11:34 +04:00
2005-07-08 08:51:27 +04:00
if ( pinfo ) {
* pinfo = info ;
2000-04-22 04:33:16 +04:00
}
1998-08-17 17:11:34 +04:00
2000-04-22 04:33:16 +04:00
/*
* Setup the oplock info in both the shared memory and
* file structs .
*/
1998-09-23 05:48:45 +04:00
2005-09-30 21:13:37 +04:00
if ( ( fsp - > oplock_type ! = NO_OPLOCK ) & &
( fsp - > oplock_type ! = FAKE_LEVEL_II_OPLOCK ) ) {
if ( ! set_file_oplock ( fsp , fsp - > oplock_type ) ) {
/* Could not get the kernel oplock */
fsp - > oplock_type = NO_OPLOCK ;
}
2000-04-22 04:33:16 +04:00
}
2005-09-30 21:13:37 +04:00
set_share_mode ( lck , fsp , 0 , fsp - > oplock_type ) ;
1998-09-23 05:48:45 +04:00
2006-02-01 07:14:07 +03:00
if ( info = = FILE_WAS_OVERWRITTEN | | info = = FILE_WAS_CREATED | |
2005-07-08 08:51:27 +04:00
info = = FILE_WAS_SUPERSEDED ) {
2006-02-01 07:14:07 +03:00
/* Handle strange delete on close create semantics. */
if ( create_options & FILE_DELETE_ON_CLOSE ) {
NTSTATUS result = can_set_delete_on_close ( fsp , True , new_dos_attributes ) ;
if ( ! NT_STATUS_IS_OK ( result ) ) {
/* Remember to delete the mode we just added. */
del_share_mode ( lck , fsp ) ;
2006-02-20 20:59:58 +03:00
TALLOC_FREE ( lck ) ;
2006-02-01 07:14:07 +03:00
fd_close ( conn , fsp ) ;
file_free ( fsp ) ;
set_saved_ntstatus ( result ) ;
return NULL ;
}
/* Note that here we set the *inital* delete on close flag,
not the regular one . */
2006-02-02 23:44:50 +03:00
set_delete_on_close_token ( lck , & current_user . ut ) ;
2006-02-01 07:14:07 +03:00
lck - > initial_delete_on_close = True ;
lck - > modified = True ;
2001-11-23 14:18:20 +03:00
}
2004-04-02 22:46:19 +04:00
/* Files should be initially set as archive */
2005-07-08 08:51:27 +04:00
if ( lp_map_archive ( SNUM ( conn ) ) | |
lp_store_dos_attributes ( SNUM ( conn ) ) ) {
file_set_dosmode ( conn , fname ,
new_dos_attributes | aARCH , NULL ,
True ) ;
2004-04-02 22:46:19 +04:00
}
}
2001-12-17 02:44:38 +03:00
/*
2002-03-12 00:57:12 +03:00
* Take care of inherited ACLs on created files - if default ACL not
* selected .
2001-12-17 02:44:38 +03:00
*/
2003-05-12 20:03:16 +04:00
if ( ! file_existed & & ! def_acl ) {
2003-01-08 05:09:18 +03:00
2005-07-08 08:51:27 +04:00
int saved_errno = errno ; /* We might get ENOSYS in the next
* call . . */
2003-01-08 05:09:18 +03:00
2005-07-08 08:51:27 +04:00
if ( SMB_VFS_FCHMOD_ACL ( fsp , fsp - > fh - > fd , unx_mode ) = = - 1
& & errno = = ENOSYS ) {
2001-12-17 02:44:38 +03:00
errno = saved_errno ; /* Ignore ENOSYS */
2005-07-08 08:51:27 +04:00
}
2003-01-08 05:09:18 +03:00
2005-07-08 08:51:27 +04:00
} else if ( new_unx_mode ) {
2003-01-08 05:09:18 +03:00
int ret = - 1 ;
/* Attributes need changing. File already existed. */
2003-05-12 20:03:16 +04:00
{
2005-07-08 08:51:27 +04:00
int saved_errno = errno ; /* We might get ENOSYS in the
* next call . . */
ret = SMB_VFS_FCHMOD_ACL ( fsp , fsp - > fh - > fd ,
new_unx_mode ) ;
2003-01-08 05:09:18 +03:00
if ( ret = = - 1 & & errno = = ENOSYS ) {
errno = saved_errno ; /* Ignore ENOSYS */
} else {
2005-10-12 22:20:34 +04:00
DEBUG ( 5 , ( " open_file_shared: reset "
2005-07-08 08:51:27 +04:00
" attributes of file %s to 0%o \n " ,
fname , ( unsigned int ) new_unx_mode ) ) ;
2003-01-08 05:09:18 +03:00
ret = 0 ; /* Don't do the fchmod below. */
}
}
2005-07-08 08:51:27 +04:00
if ( ( ret = = - 1 ) & &
( SMB_VFS_FCHMOD ( fsp , fsp - > fh - > fd , new_unx_mode ) = = - 1 ) )
DEBUG ( 5 , ( " open_file_shared: failed to reset "
" attributes of file %s to 0%o \n " ,
fname , ( unsigned int ) new_unx_mode ) ) ;
2001-12-17 02:44:38 +03:00
}
2003-01-08 05:09:18 +03:00
2005-07-08 08:51:27 +04:00
/* If this is a successful open, we must remove any deferred open
* records . */
2005-09-30 21:13:37 +04:00
del_deferred_open_entry ( lck , mid ) ;
2006-02-20 20:59:58 +03:00
TALLOC_FREE ( lck ) ;
1998-08-17 17:11:34 +04:00
2000-04-22 04:33:16 +04:00
conn - > num_files_open + + ;
1998-08-17 17:11:34 +04:00
2000-04-22 04:33:16 +04:00
return fsp ;
1998-08-17 17:11:34 +04:00
}
2001-04-14 04:19:12 +04:00
/****************************************************************************
Open a file for for write to ensure that we can fchmod it .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2005-07-08 08:51:27 +04:00
files_struct * open_file_fchmod ( connection_struct * conn , const char * fname ,
SMB_STRUCT_STAT * psbuf )
2001-04-14 04:19:12 +04:00
{
files_struct * fsp = NULL ;
BOOL fsp_open ;
2005-07-08 08:51:27 +04:00
if ( ! VALID_STAT ( * psbuf ) ) {
2001-04-14 04:19:12 +04:00
return NULL ;
2005-07-08 08:51:27 +04:00
}
2001-04-14 04:19:12 +04:00
fsp = file_new ( conn ) ;
2005-07-08 08:51:27 +04:00
if ( ! fsp ) {
2001-04-14 04:19:12 +04:00
return NULL ;
2005-07-08 08:51:27 +04:00
}
2001-04-14 04:19:12 +04:00
2002-07-15 14:35:28 +04:00
/* note! we must use a non-zero desired access or we don't get
a real file descriptor . Oh what a twisted web we weave . */
fsp_open = open_file ( fsp , conn , fname , psbuf , O_WRONLY , 0 , FILE_WRITE_DATA ) ;
2001-04-14 04:19:12 +04:00
/*
* This is not a user visible file open .
* Don ' t set a share mode and don ' t increment
* the conn - > num_files_open .
*/
if ( ! fsp_open ) {
file_free ( fsp ) ;
return NULL ;
}
return fsp ;
}
/****************************************************************************
Close the fchmod file fd - ensure no locks are lost .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
int close_file_fchmod ( files_struct * fsp )
{
int ret = fd_close ( fsp - > conn , fsp ) ;
file_free ( fsp ) ;
return ret ;
}
1998-08-17 17:11:34 +04:00
/****************************************************************************
Open a directory from an NT SMB call .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1998-10-23 04:58:28 +04:00
2005-07-08 08:51:27 +04:00
files_struct * open_directory ( connection_struct * conn ,
const char * fname ,
SMB_STRUCT_STAT * psbuf ,
uint32 access_mask ,
uint32 share_access ,
uint32 create_disposition ,
uint32 create_options ,
int * pinfo )
1998-08-17 17:11:34 +04:00
{
2005-07-08 08:51:27 +04:00
files_struct * fsp = NULL ;
BOOL dir_existed = VALID_STAT ( * psbuf ) ? True : False ;
BOOL create_dir = False ;
2005-10-28 02:35:08 +04:00
struct share_mode_lock * lck = NULL ;
NTSTATUS status ;
2005-07-08 08:51:27 +04:00
int info = 0 ;
DEBUG ( 5 , ( " open_directory: opening directory %s, access_mask = 0x%x, "
" share_access = 0x%x create_options = 0x%x, "
" create_disposition = 0x%x \n " ,
fname ,
( unsigned int ) access_mask ,
( unsigned int ) share_access ,
( unsigned int ) create_options ,
( unsigned int ) create_disposition ) ) ;
if ( is_ntfs_stream_name ( fname ) ) {
DEBUG ( 0 , ( " open_directory: %s is a stream name! \n " , fname ) ) ;
2005-09-30 21:13:37 +04:00
set_saved_ntstatus ( NT_STATUS_NOT_A_DIRECTORY ) ;
2000-04-22 04:33:16 +04:00
return NULL ;
2005-07-08 08:51:27 +04:00
}
1998-08-17 17:11:34 +04:00
2005-07-08 08:51:27 +04:00
switch ( create_disposition ) {
case FILE_OPEN :
/* If directory exists open. If directory doesn't
* exist error . */
if ( ! dir_existed ) {
DEBUG ( 5 , ( " open_directory: FILE_OPEN requested "
" for directory %s and it doesn't "
" exist. \n " , fname ) ) ;
2005-09-30 21:13:37 +04:00
set_saved_ntstatus ( NT_STATUS_OBJECT_NAME_NOT_FOUND ) ;
2000-04-22 04:33:16 +04:00
return NULL ;
1999-12-13 16:27:58 +03:00
}
2005-07-08 08:51:27 +04:00
info = FILE_WAS_OPENED ;
break ;
2003-07-29 21:34:20 +04:00
2005-07-08 08:51:27 +04:00
case FILE_CREATE :
/* If directory exists error. If directory doesn't
* exist create . */
if ( dir_existed ) {
DEBUG ( 5 , ( " open_directory: FILE_CREATE "
" requested for directory %s and it "
" already exists. \n " , fname ) ) ;
set_saved_error_triple ( ERRDOS , ERRfilexists ,
NT_STATUS_OBJECT_NAME_COLLISION ) ;
2004-02-24 03:55:05 +03:00
return NULL ;
}
2005-07-08 08:51:27 +04:00
create_dir = True ;
info = FILE_WAS_CREATED ;
break ;
2004-02-24 03:55:05 +03:00
2005-07-08 08:51:27 +04:00
case FILE_OPEN_IF :
/* If directory exists open. If directory doesn't
* exist create . */
if ( ! dir_existed ) {
create_dir = True ;
info = FILE_WAS_CREATED ;
} else {
info = FILE_WAS_OPENED ;
1999-12-13 16:27:58 +03:00
}
2005-07-08 08:51:27 +04:00
break ;
2000-10-19 06:58:24 +04:00
2005-07-08 08:51:27 +04:00
case FILE_SUPERSEDE :
case FILE_OVERWRITE :
case FILE_OVERWRITE_IF :
default :
DEBUG ( 5 , ( " open_directory: invalid create_disposition "
" 0x%x for directory %s \n " ,
( unsigned int ) create_disposition , fname ) ) ;
file_free ( fsp ) ;
2005-09-30 21:13:37 +04:00
set_saved_ntstatus ( NT_STATUS_INVALID_PARAMETER ) ;
2005-07-08 08:51:27 +04:00
return NULL ;
}
if ( create_dir ) {
/*
* Try and create the directory .
*/
2000-10-19 06:58:24 +04:00
2005-07-08 08:51:27 +04:00
/* We know bad_path is false as it's caught earlier. */
1999-12-13 16:27:58 +03:00
2005-10-28 02:35:08 +04:00
status = mkdir_internal ( conn , fname , False ) ;
2005-07-08 08:51:27 +04:00
if ( ! NT_STATUS_IS_OK ( status ) ) {
DEBUG ( 2 , ( " open_directory: unable to create %s. "
" Error was %s \n " , fname , strerror ( errno ) ) ) ;
/* Ensure we return the correct NT status to the
* client . */
set_saved_error_triple ( 0 , 0 , status ) ;
return NULL ;
1999-12-13 16:27:58 +03:00
}
2005-07-08 08:51:27 +04:00
/* Ensure we're checking for a symlink here.... */
/* We don't want to get caught by a symlink racer. */
1998-08-17 17:11:34 +04:00
2005-07-08 08:51:27 +04:00
if ( SMB_VFS_LSTAT ( conn , fname , psbuf ) ! = 0 ) {
2000-04-22 04:33:16 +04:00
return NULL ;
1998-08-17 17:11:34 +04:00
}
2000-10-19 06:58:24 +04:00
if ( ! S_ISDIR ( psbuf - > st_mode ) ) {
2005-07-08 08:51:27 +04:00
DEBUG ( 0 , ( " open_directory: %s is not a directory ! \n " ,
fname ) ) ;
2000-04-22 04:33:16 +04:00
return NULL ;
1998-08-17 17:11:34 +04:00
}
2005-07-08 08:51:27 +04:00
}
1999-12-13 16:27:58 +03:00
2005-07-08 08:51:27 +04:00
fsp = file_new ( conn ) ;
if ( ! fsp ) {
return NULL ;
1998-08-17 17:11:34 +04:00
}
/*
* Setup the files_struct for it .
*/
2000-10-19 06:58:24 +04:00
fsp - > mode = psbuf - > st_mode ;
fsp - > inode = psbuf - > st_ino ;
fsp - > dev = psbuf - > st_dev ;
1998-08-17 17:11:34 +04:00
fsp - > vuid = current_user . vuid ;
2003-08-19 05:53:45 +04:00
fsp - > file_pid = global_smbpid ;
1998-08-17 17:11:34 +04:00
fsp - > can_lock = True ;
fsp - > can_read = False ;
fsp - > can_write = False ;
2005-07-08 08:51:27 +04:00
fsp - > share_access = share_access ;
fsp - > fh - > private_options = create_options ;
fsp - > access_mask = access_mask ;
1998-08-17 17:11:34 +04:00
fsp - > print_file = False ;
fsp - > modified = False ;
1999-12-13 16:27:58 +03:00
fsp - > oplock_type = NO_OPLOCK ;
fsp - > sent_oplock_break = NO_BREAK_SENT ;
1998-08-17 17:11:34 +04:00
fsp - > is_directory = True ;
2003-01-03 21:50:13 +03:00
fsp - > is_stat = False ;
1998-08-17 17:11:34 +04:00
string_set ( & fsp - > fsp_name , fname ) ;
2005-12-13 01:07:36 +03:00
lck = get_share_mode_lock ( NULL , fsp - > dev , fsp - > inode ,
conn - > connectpath ,
fname ) ;
2005-10-28 02:35:08 +04:00
if ( lck = = NULL ) {
DEBUG ( 0 , ( " open_directory: Could not get share mode lock for %s \n " , fname ) ) ;
file_free ( fsp ) ;
set_saved_ntstatus ( NT_STATUS_SHARING_VIOLATION ) ;
return NULL ;
}
status = open_mode_check ( conn , fname , lck ,
access_mask , share_access ,
create_options , & dir_existed ) ;
if ( ! NT_STATUS_IS_OK ( status ) ) {
set_saved_ntstatus ( status ) ;
2006-02-20 20:59:58 +03:00
TALLOC_FREE ( lck ) ;
2005-10-28 02:35:08 +04:00
file_free ( fsp ) ;
return NULL ;
}
set_share_mode ( lck , fsp , 0 , NO_OPLOCK ) ;
2006-02-03 05:16:35 +03:00
/* For directories the delete on close bit at open time seems
always to be honored on close . . . See test 19 in Samba4 BASE - DELETE . */
if ( create_options & FILE_DELETE_ON_CLOSE ) {
2005-10-28 02:35:08 +04:00
status = can_set_delete_on_close ( fsp , True , 0 ) ;
2005-03-15 04:19:58 +03:00
if ( ! NT_STATUS_IS_OK ( status ) ) {
2005-10-28 02:35:08 +04:00
set_saved_ntstatus ( status ) ;
2006-02-20 20:59:58 +03:00
TALLOC_FREE ( lck ) ;
2001-11-23 14:18:20 +03:00
file_free ( fsp ) ;
return NULL ;
}
2005-10-28 02:35:08 +04:00
2006-02-02 23:44:50 +03:00
set_delete_on_close_token ( lck , & current_user . ut ) ;
2006-02-01 07:14:07 +03:00
lck - > initial_delete_on_close = True ;
2005-10-28 02:35:08 +04:00
lck - > modified = True ;
2001-11-23 14:18:20 +03:00
}
2005-03-15 04:19:58 +03:00
2006-02-20 20:59:58 +03:00
TALLOC_FREE ( lck ) ;
2005-10-28 02:35:08 +04:00
2005-03-15 04:19:58 +03:00
/* Change the owner if required. */
2005-07-08 08:51:27 +04:00
if ( ( info = = FILE_WAS_CREATED ) & & lp_inherit_owner ( SNUM ( conn ) ) ) {
2005-03-15 04:19:58 +03:00
change_owner_to_parent ( conn , fsp , fsp - > fsp_name , psbuf ) ;
}
2005-07-08 08:51:27 +04:00
if ( pinfo ) {
* pinfo = info ;
}
2000-04-22 04:33:16 +04:00
conn - > num_files_open + + ;
return fsp ;
1998-08-17 17:11:34 +04:00
}
2002-03-23 05:57:44 +03:00
2003-01-03 21:50:13 +03:00
/****************************************************************************
Open a pseudo - file ( no locking checks - a ' stat ' open ) .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
1998-10-23 04:58:28 +04:00
2005-07-08 08:51:27 +04:00
files_struct * open_file_stat ( connection_struct * conn , char * fname ,
SMB_STRUCT_STAT * psbuf )
1998-08-17 17:11:34 +04:00
{
2003-01-03 21:50:13 +03:00
files_struct * fsp = NULL ;
1998-08-17 17:11:34 +04:00
2003-01-03 21:50:13 +03:00
if ( ! VALID_STAT ( * psbuf ) )
return NULL ;
2002-03-23 05:57:44 +03:00
2003-01-03 21:50:13 +03:00
/* Can't 'stat' open directories. */
if ( S_ISDIR ( psbuf - > st_mode ) )
return NULL ;
1998-09-05 00:53:58 +04:00
2003-01-03 21:50:13 +03:00
fsp = file_new ( conn ) ;
if ( ! fsp )
return NULL ;
2002-03-23 05:57:44 +03:00
2003-01-03 21:50:13 +03:00
DEBUG ( 5 , ( " open_file_stat: 'opening' file %s \n " , fname ) ) ;
2002-03-23 05:57:44 +03:00
/*
2003-01-03 21:50:13 +03:00
* Setup the files_struct for it .
2002-03-23 05:57:44 +03:00
*/
2003-01-03 21:50:13 +03:00
fsp - > mode = psbuf - > st_mode ;
2004-05-19 06:25:48 +04:00
fsp - > inode = psbuf - > st_ino ;
fsp - > dev = psbuf - > st_dev ;
2003-01-03 21:50:13 +03:00
fsp - > vuid = current_user . vuid ;
2003-08-19 05:53:45 +04:00
fsp - > file_pid = global_smbpid ;
2003-01-03 21:50:13 +03:00
fsp - > can_lock = False ;
fsp - > can_read = False ;
fsp - > can_write = False ;
fsp - > print_file = False ;
fsp - > modified = False ;
fsp - > oplock_type = NO_OPLOCK ;
fsp - > sent_oplock_break = NO_BREAK_SENT ;
fsp - > is_directory = False ;
fsp - > is_stat = True ;
string_set ( & fsp - > fsp_name , fname ) ;
2002-03-23 05:57:44 +03:00
2003-01-03 21:50:13 +03:00
conn - > num_files_open + + ;
1998-08-17 17:11:34 +04:00
2003-01-03 21:50:13 +03:00
return fsp ;
1998-08-17 17:11:34 +04:00
}
2005-12-13 21:11:50 +03:00
/****************************************************************************
Receive notification that one of our open files has been renamed by another
smbd process .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
void msg_file_was_renamed ( int msg_type , struct process_id src , void * buf , size_t len )
{
files_struct * fsp ;
2006-01-13 01:17:54 +03:00
char * frm = ( char * ) buf ;
SMB_DEV_T dev ;
SMB_INO_T inode ;
2005-12-13 21:11:50 +03:00
const char * sharepath ;
const char * newname ;
size_t sp_len ;
2006-01-13 01:17:54 +03:00
if ( buf = = NULL | | len < MSG_FILE_RENAMED_MIN_SIZE + 2 ) {
2005-12-13 21:11:50 +03:00
DEBUG ( 0 , ( " msg_file_was_renamed: Got invalid msg len %d \n " , ( int ) len ) ) ;
return ;
}
2006-01-13 01:17:54 +03:00
/* Unpack the message. */
dev = DEV_T_VAL ( frm , 0 ) ;
inode = INO_T_VAL ( frm , 8 ) ;
sharepath = & frm [ 16 ] ;
2005-12-13 21:11:50 +03:00
newname = sharepath + strlen ( sharepath ) + 1 ;
sp_len = strlen ( sharepath ) ;
DEBUG ( 10 , ( " msg_file_was_renamed: Got rename message for sharepath %s, new name %s, "
" dev %x, inode %.0f \n " ,
2006-01-13 01:17:54 +03:00
sharepath , newname , ( unsigned int ) dev , ( double ) inode ) ) ;
2005-12-13 21:11:50 +03:00
2006-01-13 01:17:54 +03:00
for ( fsp = file_find_di_first ( dev , inode ) ; fsp ; fsp = file_find_di_next ( fsp ) ) {
2005-12-13 21:11:50 +03:00
if ( memcmp ( fsp - > conn - > connectpath , sharepath , sp_len ) = = 0 ) {
DEBUG ( 10 , ( " msg_file_was_renamed: renaming file fnum %d from %s -> %s \n " ,
fsp - > fnum , fsp - > fsp_name , newname ) ) ;
string_set ( & fsp - > fsp_name , newname ) ;
} else {
/* TODO. JRA. */
/* Now we have the complete path we can work out if this is
actually within this share and adjust newname accordingly . */
DEBUG ( 10 , ( " msg_file_was_renamed: share mismatch (sharepath %s "
" not sharepath %s) "
" fnum %d from %s -> %s \n " ,
fsp - > conn - > connectpath ,
sharepath ,
fsp - > fnum ,
fsp - > fsp_name ,
newname ) ) ;
}
}
}