2 Unix SMB/CIFS implementation.
3 file opening and share modes
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Jeremy Allison 2001
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 extern userdom_struct current_user_info
;
25 extern uint16 global_oplock_port
;
26 extern BOOL global_client_failed_oplock_break
;
28 /****************************************************************************
29 fd support routines - attempt to do a dos_open.
30 ****************************************************************************/
32 static int fd_open(struct connection_struct
*conn
, char *fname
,
33 int flags
, mode_t mode
)
37 if (!lp_symlinks(SNUM(conn
)))
41 fd
= VFS_OPEN(conn
,fname
,flags
,mode
);
43 /* Fix for files ending in '.' */
44 if((fd
== -1) && (errno
== ENOENT
) &&
45 (strchr_m(fname
,'.')==NULL
)) {
47 fd
= VFS_OPEN(conn
,fname
,flags
,mode
);
50 DEBUG(10,("fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s\n", fname
,
51 flags
, (int)mode
, fd
, (fd
== -1) ? strerror(errno
) : "" ));
56 /****************************************************************************
57 Close the file associated with a fsp.
58 ****************************************************************************/
60 int fd_close(struct connection_struct
*conn
, files_struct
*fsp
)
63 return 0; /* what we used to call a stat open. */
64 return fd_close_posix(conn
, fsp
);
68 /****************************************************************************
69 Check a filename for the pipe string.
70 ****************************************************************************/
72 static void check_for_pipe(char *fname
)
74 /* special case of pipe opens */
76 StrnCpy(s
,fname
,sizeof(s
)-1);
78 if (strstr(s
,"pipe/")) {
79 DEBUG(3,("Rejecting named pipe open for %s\n",fname
));
80 unix_ERR_class
= ERRSRV
;
81 unix_ERR_code
= ERRaccess
;
82 unix_ERR_ntstatus
= NT_STATUS_ACCESS_DENIED
;
86 /****************************************************************************
88 ****************************************************************************/
90 static BOOL
open_file(files_struct
*fsp
,connection_struct
*conn
,
91 const char *fname1
,SMB_STRUCT_STAT
*psbuf
,int flags
,mode_t mode
, uint32 desired_access
)
93 extern struct current_user current_user
;
95 int accmode
= (flags
& O_ACCMODE
);
96 int local_flags
= flags
;
99 fsp
->oplock_type
= NO_OPLOCK
;
102 pstrcpy(fname
,fname1
);
104 /* Check permissions */
107 * This code was changed after seeing a client open request
108 * containing the open mode of (DENY_WRITE/read-only) with
109 * the 'create if not exist' bit set. The previous code
110 * would fail to open the file read only on a read-only share
111 * as it was checking the flags parameter directly against O_RDONLY,
112 * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
116 if (!CAN_WRITE(conn
)) {
117 /* It's a read-only share - fail if we wanted to write. */
118 if(accmode
!= O_RDONLY
) {
119 DEBUG(3,("Permission denied opening %s\n",fname
));
120 check_for_pipe(fname
);
122 } else if(flags
& O_CREAT
) {
123 /* We don't want to write - but we must make sure that O_CREAT
124 doesn't create the file if we have write access into the
132 * This little piece of insanity is inspired by the
133 * fact that an NT client can open a file for O_RDONLY,
134 * but set the create disposition to FILE_EXISTS_TRUNCATE.
135 * If the client *can* write to the file, then it expects to
136 * truncate the file, even though it is opening for readonly.
137 * Quicken uses this stupid trick in backup file creation...
138 * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
139 * for helping track this one down. It didn't bite us in 2.0.x
140 * as we always opened files read-write in that release. JRA.
143 if ((accmode
== O_RDONLY
) && ((flags
& O_TRUNC
) == O_TRUNC
)) {
144 DEBUG(10,("open_file: truncate requested on read-only open for file %s\n",fname
));
145 local_flags
= (flags
& ~O_ACCMODE
)|O_RDWR
;
148 if ((desired_access
& (FILE_READ_DATA
|FILE_WRITE_DATA
|FILE_APPEND_DATA
|FILE_EXECUTE
)) ||
149 (local_flags
& O_CREAT
) || ((local_flags
& O_TRUNC
) == O_TRUNC
) ) {
152 * We can't actually truncate here as the file may be locked.
153 * open_file_shared will take care of the truncate later. JRA.
156 local_flags
&= ~O_TRUNC
;
158 #if defined(O_NONBLOCK) && defined(S_ISFIFO)
160 * We would block on opening a FIFO with no one else on the
161 * other end. Do what we used to do and add O_NONBLOCK to the
165 if (VALID_STAT(*psbuf
) && S_ISFIFO(psbuf
->st_mode
))
166 local_flags
|= O_NONBLOCK
;
169 /* Actually do the open */
170 fsp
->fd
= fd_open(conn
, fname
, local_flags
, mode
);
172 DEBUG(3,("Error opening file %s (%s) (local_flags=%d) (flags=%d)\n",
173 fname
,strerror(errno
),local_flags
,flags
));
174 check_for_pipe(fname
);
178 /* Inherit the ACL if the file was created. */
179 if ((local_flags
& O_CREAT
) && !VALID_STAT(*psbuf
))
180 inherit_access_acl(conn
, fname
, mode
);
183 fsp
->fd
= -1; /* What we used to call a stat open. */
185 if (!VALID_STAT(*psbuf
)) {
189 ret
= VFS_STAT(conn
, fname
, psbuf
);
191 ret
= VFS_FSTAT(fsp
,fsp
->fd
,psbuf
);
192 /* If we have an fd, this stat should succeed. */
194 DEBUG(0,("Error doing fstat on open file %s (%s)\n", fname
,strerror(errno
) ));
197 /* For a non-io open, this stat failing means file not found. JRA */
205 * POSIX allows read-only opens of directories. We don't
206 * want to do this (we use a different code path for this)
207 * so catch a directory open and return an EISDIR. JRA.
210 if(S_ISDIR(psbuf
->st_mode
)) {
216 fsp
->mode
= psbuf
->st_mode
;
217 fsp
->inode
= psbuf
->st_ino
;
218 fsp
->dev
= psbuf
->st_dev
;
219 fsp
->vuid
= current_user
.vuid
;
220 fsp
->size
= psbuf
->st_size
;
222 fsp
->can_lock
= True
;
223 fsp
->can_read
= ((flags
& O_WRONLY
)==0);
224 fsp
->can_write
= ((flags
& (O_WRONLY
|O_RDWR
))!=0);
226 fsp
->desired_access
= desired_access
;
227 fsp
->print_file
= False
;
228 fsp
->modified
= False
;
229 fsp
->oplock_type
= NO_OPLOCK
;
230 fsp
->sent_oplock_break
= NO_BREAK_SENT
;
231 fsp
->is_directory
= False
;
232 fsp
->is_stat
= False
;
233 fsp
->directory_delete_on_close
= False
;
234 string_set(&fsp
->fsp_name
,fname
);
235 fsp
->wcp
= NULL
; /* Write cache pointer. */
237 DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
238 *current_user_info
.smb_name
? current_user_info
.smb_name
: conn
->user
,fsp
->fsp_name
,
239 BOOLSTR(fsp
->can_read
), BOOLSTR(fsp
->can_write
),
240 conn
->num_files_open
+ 1));
245 /****************************************************************************
247 Helper for open_file_shared.
248 Truncate a file after checking locking; close file if locked.
249 **************************************************************************/
251 static int truncate_unless_locked(struct connection_struct
*conn
, files_struct
*fsp
)
253 SMB_BIG_UINT mask
= (SMB_BIG_UINT
)-1;
255 if (is_locked(fsp
,fsp
->conn
,mask
,0,WRITE_LOCK
,True
)){
257 unix_ERR_class
= ERRDOS
;
258 unix_ERR_code
= ERRlock
;
259 unix_ERR_ntstatus
= dos_to_ntstatus(ERRDOS
, ERRlock
);
262 return VFS_FTRUNCATE(fsp
,fsp
->fd
,0);
266 /*******************************************************************
267 return True if the filename is one of the special executable types
268 ********************************************************************/
269 static BOOL
is_executable(const char *fname
)
271 if ((fname
= strrchr_m(fname
,'.'))) {
272 if (strequal(fname
,".com") ||
273 strequal(fname
,".dll") ||
274 strequal(fname
,".exe") ||
275 strequal(fname
,".sym")) {
282 enum {AFAIL
,AREAD
,AWRITE
,AALL
};
284 /*******************************************************************
285 reproduce the share mode access table
286 this is horrendoously complex, and really can't be justified on any
287 rational grounds except that this is _exactly_ what NT does. See
288 the DENY1 and DENY2 tests in smbtorture for a comprehensive set of
290 ********************************************************************/
291 static int access_table(int new_deny
,int old_deny
,int old_mode
,
292 BOOL same_pid
, BOOL isexe
)
294 if (new_deny
== DENY_ALL
|| old_deny
== DENY_ALL
) return(AFAIL
);
297 if (isexe
&& old_mode
== DOS_OPEN_RDONLY
&&
298 old_deny
== DENY_DOS
&& new_deny
== DENY_READ
) {
301 if (!isexe
&& old_mode
== DOS_OPEN_RDONLY
&&
302 old_deny
== DENY_DOS
&& new_deny
== DENY_DOS
) {
305 if (new_deny
== DENY_FCB
&& old_deny
== DENY_DOS
) {
306 if (isexe
) return AFAIL
;
307 if (old_mode
== DOS_OPEN_RDONLY
) return AFAIL
;
310 if (old_mode
== DOS_OPEN_RDONLY
&& old_deny
== DENY_DOS
) {
311 if (new_deny
== DENY_FCB
|| new_deny
== DENY_READ
) {
312 if (isexe
) return AREAD
;
316 if (old_deny
== DENY_FCB
) {
317 if (new_deny
== DENY_DOS
|| new_deny
== DENY_FCB
) return AALL
;
322 if (old_deny
== DENY_DOS
|| new_deny
== DENY_DOS
||
323 old_deny
== DENY_FCB
|| new_deny
== DENY_FCB
) {
325 if (old_deny
== DENY_FCB
|| new_deny
== DENY_FCB
) {
328 if (old_deny
== DENY_DOS
) {
329 if (new_deny
== DENY_READ
&&
330 (old_mode
== DOS_OPEN_RDONLY
||
331 old_mode
== DOS_OPEN_RDWR
)) {
334 if (new_deny
== DENY_WRITE
&&
335 (old_mode
== DOS_OPEN_WRONLY
||
336 old_mode
== DOS_OPEN_RDWR
)) {
341 if (old_deny
== DENY_NONE
) return AALL
;
342 if (old_deny
== DENY_READ
) return AWRITE
;
343 if (old_deny
== DENY_WRITE
) return AREAD
;
345 /* it isn't a exe, dll, sym or com file */
346 if (old_deny
== new_deny
&& same_pid
)
349 if (old_deny
== DENY_READ
|| new_deny
== DENY_READ
) return AFAIL
;
350 if (old_mode
== DOS_OPEN_RDONLY
) return(AREAD
);
358 if (old_deny
==DENY_WRITE
&& old_mode
==DOS_OPEN_RDONLY
) return(AREAD
);
359 if (old_deny
==DENY_READ
&& old_mode
==DOS_OPEN_RDONLY
) return(AWRITE
);
360 if (old_deny
==DENY_NONE
&& old_mode
==DOS_OPEN_RDONLY
) return(AALL
);
363 if (old_deny
==DENY_WRITE
&& old_mode
==DOS_OPEN_WRONLY
) return(AREAD
);
364 if (old_deny
==DENY_READ
&& old_mode
==DOS_OPEN_WRONLY
) return(AWRITE
);
365 if (old_deny
==DENY_NONE
&& old_mode
==DOS_OPEN_WRONLY
) return(AALL
);
368 if (old_deny
==DENY_WRITE
) return(AREAD
);
369 if (old_deny
==DENY_READ
) return(AWRITE
);
370 if (old_deny
==DENY_NONE
) return(AALL
);
377 /****************************************************************************
378 check if we can open a file with a share mode
379 ****************************************************************************/
381 static BOOL
check_share_mode(connection_struct
*conn
, share_mode_entry
*share
, int share_mode
, uint32 desired_access
,
382 const char *fname
, BOOL fcbopen
, int *flags
)
384 int deny_mode
= GET_DENY_MODE(share_mode
);
385 int old_open_mode
= GET_OPEN_MODE(share
->share_mode
);
386 int old_deny_mode
= GET_DENY_MODE(share
->share_mode
);
389 * share modes = false means don't bother to check for
390 * DENY mode conflict. This is a *really* bad idea :-). JRA.
393 if(!lp_share_modes(SNUM(conn
)))
397 * Don't allow any opens once the delete on close flag has been
401 if (GET_DELETE_ON_CLOSE_FLAG(share
->share_mode
)) {
402 DEBUG(5,("check_share_mode: Failing open on file %s as delete on close flag is set.\n",
404 /* Use errno to map to correct error. */
405 unix_ERR_class
= SMB_SUCCESS
;
407 unix_ERR_ntstatus
= NT_STATUS_OK
;
411 /* this is a nasty hack, but necessary until we rewrite our open
412 handling to use a NTCreateX call as the basic call.
413 NT may open a file with neither read nor write access, and in
414 this case it expects the open not to conflict with any
415 existing deny modes. This happens (for example) during a
416 "xcopy /o" where the second file descriptor is used for
422 * This is a bit wierd - the test for desired access not having the
423 * critical bits seems seems odd. Firstly, if both opens have no
424 * critical bits then always ignore. Then check the "allow delete"
425 * then check for either. This probably isn't quite right yet but
426 * gets us much closer. JRA.
430 * If desired_access doesn't contain READ_DATA,WRITE_DATA,APPEND_DATA or EXECUTE
431 * and the existing desired_acces then share modes don't conflict.
434 if ( !(desired_access
& (FILE_READ_DATA
|FILE_WRITE_DATA
|FILE_APPEND_DATA
|FILE_EXECUTE
)) &&
435 !(share
->desired_access
& (FILE_READ_DATA
|FILE_WRITE_DATA
|FILE_APPEND_DATA
|FILE_EXECUTE
)) ) {
438 * Wrinkle discovered by smbtorture....
439 * If both are non-io open and requester is asking for delete and current open has delete access
440 * but neither open has allowed file share delete then deny.... this is very strange and
441 * seems to be the only case in which non-io opens conflict. JRA.
444 if ((desired_access
& DELETE_ACCESS
) && (share
->desired_access
& DELETE_ACCESS
) &&
445 (!GET_ALLOW_SHARE_DELETE(share
->share_mode
) || !GET_ALLOW_SHARE_DELETE(share_mode
))) {
446 DEBUG(5,("check_share_mode: Failing open on file %s as delete access requests conflict.\n",
448 unix_ERR_class
= ERRDOS
;
449 unix_ERR_code
= ERRbadshare
;
450 unix_ERR_ntstatus
= NT_STATUS_SHARING_VIOLATION
;
455 DEBUG(5,("check_share_mode: Allowing open on file %s as both desired access (0x%x) \
456 and existing desired access (0x%x) are non-data opens\n",
457 fname
, (unsigned int)desired_access
, (unsigned int)share
->desired_access
));
462 * If delete access was requested and the existing share mode doesn't have
463 * ALLOW_SHARE_DELETE then deny.
466 if ((desired_access
& DELETE_ACCESS
) && !GET_ALLOW_SHARE_DELETE(share
->share_mode
)) {
467 DEBUG(5,("check_share_mode: Failing open on file %s as delete access requested and allow share delete not set.\n",
469 unix_ERR_class
= ERRDOS
;
470 unix_ERR_code
= ERRbadshare
;
471 unix_ERR_ntstatus
= NT_STATUS_SHARING_VIOLATION
;
477 * The inverse of the above.
478 * If delete access was granted and the new share mode doesn't have
479 * ALLOW_SHARE_DELETE then deny.
482 if ((share
->desired_access
& DELETE_ACCESS
) && !GET_ALLOW_SHARE_DELETE(share_mode
)) {
483 DEBUG(5,("check_share_mode: Failing open on file %s as delete access granted and allow share delete not requested.\n",
485 unix_ERR_class
= ERRDOS
;
486 unix_ERR_code
= ERRbadshare
;
487 unix_ERR_ntstatus
= NT_STATUS_SHARING_VIOLATION
;
493 * If desired_access doesn't contain READ_DATA,WRITE_DATA,APPEND_DATA or EXECUTE
494 * then share modes don't conflict. Likewise with existing desired access.
497 if ( !(desired_access
& (FILE_READ_DATA
|FILE_WRITE_DATA
|FILE_APPEND_DATA
|FILE_EXECUTE
)) ||
498 !(share
->desired_access
& (FILE_READ_DATA
|FILE_WRITE_DATA
|FILE_APPEND_DATA
|FILE_EXECUTE
)) ) {
499 DEBUG(5,("check_share_mode: Allowing open on file %s as desired access (0x%x) doesn't conflict with\
500 existing desired access (0x%x).\n", fname
, (unsigned int)desired_access
, (unsigned int)share
->desired_access
));
505 int access_allowed
= access_table(deny_mode
,old_deny_mode
,old_open_mode
,
506 (share
->pid
== sys_getpid()),is_executable(fname
));
508 if ((access_allowed
== AFAIL
) ||
509 (!fcbopen
&& (access_allowed
== AREAD
&& *flags
== O_RDWR
)) ||
510 (access_allowed
== AREAD
&& *flags
!= O_RDONLY
) ||
511 (access_allowed
== AWRITE
&& *flags
!= O_WRONLY
)) {
513 DEBUG(2,("Share violation on file (%d,%d,%d,%d,%s,fcbopen = %d, flags = %d) = %d\n",
514 deny_mode
,old_deny_mode
,old_open_mode
,
515 (int)share
->pid
,fname
, fcbopen
, *flags
, access_allowed
));
517 unix_ERR_class
= ERRDOS
;
518 unix_ERR_code
= ERRbadshare
;
519 unix_ERR_ntstatus
= NT_STATUS_SHARING_VIOLATION
;
524 if (access_allowed
== AREAD
)
527 if (access_allowed
== AWRITE
)
536 #if defined(DEVELOPER)
537 static void validate_my_share_entries(share_mode_entry
*share_entry
)
541 if (share_entry
->pid
!= sys_getpid())
544 fsp
= file_find_dif(share_entry
->dev
, share_entry
->inode
, share_entry
->share_file_id
);
546 smb_panic("validate_my_share_entries: Cannot match a share entry with an open file\n");
549 if (((uint16
)fsp
->oplock_type
) != share_entry
->op_type
) {
551 slprintf(str
, sizeof(str
)-1, "validate_my_share_entries: file %s, oplock_type = 0x%x, op_type = 0x%x\n",
552 fsp
->fsp_name
, (unsigned int)fsp
->oplock_type
, (unsigned int)share_entry
->op_type
);
558 /****************************************************************************
559 Deal with open deny mode and oplock break processing.
560 Invarient: Share mode must be locked on entry and exit.
561 Returns -1 on error, or number of share modes on success (may be zero).
562 ****************************************************************************/
564 static int open_mode_check(connection_struct
*conn
, const char *fname
, SMB_DEV_T dev
,
566 uint32 desired_access
,
567 int share_mode
, int *p_flags
, int *p_oplock_request
,
568 BOOL
*p_all_current_opens_are_level_II
)
572 int oplock_contention_count
= 0;
573 share_mode_entry
*old_shares
= 0;
574 BOOL fcbopen
= False
;
577 if(GET_OPEN_MODE(share_mode
) == DOS_OPEN_FCB
)
580 num_share_modes
= get_share_modes(conn
, dev
, inode
, &old_shares
);
582 if(num_share_modes
== 0)
586 * Check if the share modes will give us access.
590 share_mode_entry broken_entry
;
592 broke_oplock
= False
;
593 *p_all_current_opens_are_level_II
= True
;
595 for(i
= 0; i
< num_share_modes
; i
++) {
596 share_mode_entry
*share_entry
= &old_shares
[i
];
598 #if defined(DEVELOPER)
599 validate_my_share_entries(share_entry
);
603 * By observation of NetBench, oplocks are broken *before* share
604 * modes are checked. This allows a file to be closed by the client
605 * if the share mode would deny access and the client has an oplock.
606 * Check if someone has an oplock on this file. If so we must break
607 * it before continuing.
610 if((*p_oplock_request
&& EXCLUSIVE_OPLOCK_TYPE(share_entry
->op_type
)) ||
611 (!*p_oplock_request
&& (share_entry
->op_type
!= NO_OPLOCK
))) {
615 DEBUG(5,("open_mode_check: oplock_request = %d, breaking oplock (%x) on file %s, \
616 dev = %x, inode = %.0f\n", *p_oplock_request
, share_entry
->op_type
, fname
, (unsigned int)dev
, (double)inode
));
618 /* Oplock break - unlock to request it. */
619 unlock_share_entry(conn
, dev
, inode
);
621 opb_ret
= request_oplock_break(share_entry
, False
);
624 lock_share_entry(conn
, dev
, inode
);
626 if(opb_ret
== False
) {
627 DEBUG(0,("open_mode_check: FAILED when breaking oplock (%x) on file %s, \
628 dev = %x, inode = %.0f\n", old_shares
[i
].op_type
, fname
, (unsigned int)dev
, (double)inode
));
629 SAFE_FREE(old_shares
);
631 unix_ERR_class
= ERRDOS
;
632 unix_ERR_code
= ERRbadshare
;
633 unix_ERR_ntstatus
= NT_STATUS_SHARING_VIOLATION
;
638 broken_entry
= *share_entry
;
641 } else if (!LEVEL_II_OPLOCK_TYPE(share_entry
->op_type
)) {
642 *p_all_current_opens_are_level_II
= False
;
645 /* someone else has a share lock on it, check to see if we can too */
646 if (!check_share_mode(conn
, share_entry
, share_mode
, desired_access
,
647 fname
, fcbopen
, p_flags
)) {
648 SAFE_FREE(old_shares
);
656 SAFE_FREE(old_shares
);
657 num_share_modes
= get_share_modes(conn
, dev
, inode
, &old_shares
);
658 oplock_contention_count
++;
660 /* Paranoia check that this is no longer an exlusive entry. */
661 for(i
= 0; i
< num_share_modes
; i
++) {
662 share_mode_entry
*share_entry
= &old_shares
[i
];
664 if (share_modes_identical(&broken_entry
, share_entry
) &&
665 EXCLUSIVE_OPLOCK_TYPE(share_entry
->op_type
) ) {
668 * This should not happen. The target left this oplock
669 * as exlusive.... The process *must* be dead....
672 DEBUG(0,("open_mode_check: exlusive oplock left by process %d after break ! For file %s, \
673 dev = %x, inode = %.0f. Deleting it to continue...\n", (int)broken_entry
.pid
, fname
, (unsigned int)dev
, (double)inode
));
675 if (process_exists(broken_entry
.pid
)) {
676 DEBUG(0,("open_mode_check: Existent process %d left active oplock.\n",
680 if (del_share_entry(dev
, inode
, &broken_entry
, NULL
) == -1) {
682 unix_ERR_class
= ERRDOS
;
683 unix_ERR_code
= ERRbadshare
;
684 unix_ERR_ntstatus
= NT_STATUS_SHARING_VIOLATION
;
689 * We must reload the share modes after deleting the
690 * other process's entry.
693 SAFE_FREE(old_shares
);
694 num_share_modes
= get_share_modes(conn
, dev
, inode
, &old_shares
);
697 } /* end for paranoia... */
698 } /* end if broke_oplock */
700 } while(broke_oplock
);
703 SAFE_FREE(old_shares
);
706 * Refuse to grant an oplock in case the contention limit is
707 * reached when going through the lock list multiple times.
710 if(oplock_contention_count
>= lp_oplock_contention_limit(SNUM(conn
))) {
711 *p_oplock_request
= 0;
712 DEBUG(4,("open_mode_check: oplock contention = %d. Not granting oplock.\n",
713 oplock_contention_count
));
716 return num_share_modes
;
719 /****************************************************************************
720 set a kernel flock on a file for NFS interoperability
721 this requires a patch to Linux
722 ****************************************************************************/
723 static void kernel_flock(files_struct
*fsp
, int deny_mode
)
725 #if HAVE_KERNEL_SHARE_MODES
727 if (deny_mode
== DENY_READ
) kernel_mode
= LOCK_MAND
|LOCK_WRITE
;
728 else if (deny_mode
== DENY_WRITE
) kernel_mode
= LOCK_MAND
|LOCK_READ
;
729 else if (deny_mode
== DENY_ALL
) kernel_mode
= LOCK_MAND
;
730 if (kernel_mode
) flock(fsp
->fd
, kernel_mode
);
736 static BOOL
open_match_attributes(connection_struct
*conn
, char *path
, mode_t existing_mode
,
737 mode_t new_mode
, mode_t
*returned_mode
)
739 uint32 old_dos_mode
, new_dos_mode
;
740 uint32 noarch_old_dos_mode
, noarch_new_dos_mode
;
741 SMB_STRUCT_STAT sbuf
;
745 sbuf
.st_mode
= existing_mode
;
746 old_dos_mode
= dos_mode(conn
, path
, &sbuf
);
748 sbuf
.st_mode
= new_mode
;
749 new_dos_mode
= dos_mode(conn
, path
, &sbuf
);
751 noarch_old_dos_mode
= (old_dos_mode
& ~FILE_ATTRIBUTE_ARCHIVE
);
752 noarch_new_dos_mode
= (new_dos_mode
& ~FILE_ATTRIBUTE_ARCHIVE
);
754 if((noarch_old_dos_mode
== 0 && noarch_new_dos_mode
!= 0) ||
755 (noarch_old_dos_mode
!= 0 && ((noarch_old_dos_mode
& noarch_new_dos_mode
) == noarch_old_dos_mode
)))
756 *returned_mode
= new_mode
;
758 *returned_mode
= (mode_t
)0;
760 DEBUG(10,("open_match_attributes: file %s old_dos_mode = 0x%x, existing_mode = 0%o, new_dos_mode = 0x%x returned_mode = 0%o\n",
762 old_dos_mode
, (unsigned int)existing_mode
, new_dos_mode
, (unsigned int)*returned_mode
));
764 /* If we're mapping SYSTEM and HIDDEN ensure they match. */
765 if (lp_map_system(SNUM(conn
))) {
766 if ((old_dos_mode
& FILE_ATTRIBUTE_SYSTEM
) && !(new_dos_mode
& FILE_ATTRIBUTE_SYSTEM
))
769 if (lp_map_hidden(SNUM(conn
))) {
770 if ((old_dos_mode
& FILE_ATTRIBUTE_HIDDEN
) && !(new_dos_mode
& FILE_ATTRIBUTE_HIDDEN
))
776 /****************************************************************************
777 Open a file with a share mode.
778 ****************************************************************************/
780 files_struct
*open_file_shared(connection_struct
*conn
,char *fname
, SMB_STRUCT_STAT
*psbuf
,
781 int share_mode
,int ofun
, mode_t mode
,int oplock_request
,
782 int *Access
,int *action
)
784 return open_file_shared1(conn
, fname
, psbuf
, 0, share_mode
, ofun
, mode
,
785 oplock_request
, Access
, action
);
788 /****************************************************************************
789 Open a file with a share mode.
790 ****************************************************************************/
792 files_struct
*open_file_shared1(connection_struct
*conn
,char *fname
, SMB_STRUCT_STAT
*psbuf
,
793 uint32 desired_access
,
794 int share_mode
,int ofun
, mode_t mode
,int oplock_request
,
795 int *Access
,int *action
)
799 int deny_mode
= GET_DENY_MODE(share_mode
);
800 BOOL allow_share_delete
= GET_ALLOW_SHARE_DELETE(share_mode
);
801 BOOL delete_on_close
= GET_DELETE_ON_CLOSE_FLAG(share_mode
);
802 BOOL file_existed
= VALID_STAT(*psbuf
);
803 BOOL fcbopen
= False
;
804 BOOL def_acl
= False
;
807 int num_share_modes
= 0;
808 BOOL all_current_opens_are_level_II
= False
;
809 BOOL fsp_open
= False
;
810 files_struct
*fsp
= NULL
;
813 mode_t new_mode
= (mode_t
)0;
816 /* printers are handled completely differently. Most of the passed parameters are
819 *Access
= DOS_OPEN_WRONLY
;
821 *action
= FILE_WAS_CREATED
;
822 return print_fsp_open(conn
, fname
);
825 fsp
= file_new(conn
);
829 DEBUG(10,("open_file_shared: fname = %s, share_mode = %x, ofun = %x, mode = %o, oplock request = %d\n",
830 fname
, share_mode
, ofun
, (int)mode
, oplock_request
));
832 if (!check_name(fname
,conn
)) {
837 /* ignore any oplock requests if oplocks are disabled */
838 if (!lp_oplocks(SNUM(conn
)) || global_client_failed_oplock_break
) {
842 /* this is for OS/2 EAs - try and say we don't support them */
843 if (strstr(fname
,".+,;=[].")) {
844 unix_ERR_class
= ERRDOS
;
845 /* OS/2 Workplace shell fix may be main code stream in a later release. */
846 #if 1 /* OS2_WPS_FIX - Recent versions of OS/2 need this. */
847 unix_ERR_code
= ERRcannotopen
;
848 #else /* OS2_WPS_FIX */
849 unix_ERR_code
= ERROR_EAS_NOT_SUPPORTED
;
850 #endif /* OS2_WPS_FIX */
852 DEBUG(5,("open_file_shared: OS/2 EA's are not supported.\n"));
857 if ((GET_FILE_OPEN_DISPOSITION(ofun
) == FILE_EXISTS_FAIL
) && file_existed
) {
858 DEBUG(5,("open_file_shared: create new requested for file %s and file already exists.\n",
865 if (CAN_WRITE(conn
) && (GET_FILE_CREATE_DISPOSITION(ofun
) == FILE_CREATE_IF_NOT_EXIST
))
868 if (CAN_WRITE(conn
) && (GET_FILE_OPEN_DISPOSITION(ofun
) == FILE_EXISTS_TRUNCATE
))
871 /* We only care about matching attributes on file exists and truncate. */
872 if (file_existed
&& (GET_FILE_OPEN_DISPOSITION(ofun
) == FILE_EXISTS_TRUNCATE
)) {
873 if (!open_match_attributes(conn
, fname
, psbuf
->st_mode
, mode
, &new_mode
)) {
874 DEBUG(5,("open_file_shared: attributes missmatch for file %s (0%o, 0%o)\n",
875 fname
, psbuf
->st_mode
, mode
));
882 if (GET_FILE_OPEN_DISPOSITION(ofun
) == FILE_EXISTS_FAIL
)
885 /* note that we ignore the append flag as
886 append does not mean the same thing under dos and unix */
888 switch (GET_OPEN_MODE(share_mode
)) {
889 case DOS_OPEN_WRONLY
:
891 if (desired_access
== 0)
892 desired_access
= FILE_WRITE_DATA
;
897 if (desired_access
== 0)
898 desired_access
= FILE_READ_DATA
|FILE_WRITE_DATA
;
902 if (desired_access
== 0)
903 desired_access
= FILE_READ_DATA
|FILE_WRITE_DATA
;
907 if (desired_access
== 0)
908 desired_access
= FILE_READ_DATA
;
913 if (GET_FILE_SYNC_OPENMODE(share_mode
)) {
918 if (flags
!= O_RDONLY
&& file_existed
&&
919 (!CAN_WRITE(conn
) || IS_DOS_READONLY(dos_mode(conn
,fname
,psbuf
)))) {
921 DEBUG(5,("open_file_shared: read/write access requested for file %s on read only %s\n",
922 fname
, !CAN_WRITE(conn
) ? "share" : "file" ));
930 if (deny_mode
> DENY_NONE
&& deny_mode
!=DENY_FCB
) {
931 DEBUG(2,("Invalid deny mode %d on file %s\n",deny_mode
,fname
));
940 inode
= psbuf
->st_ino
;
942 lock_share_entry(conn
, dev
, inode
);
944 num_share_modes
= open_mode_check(conn
, fname
, dev
, inode
,
947 &flags
, &oplock_request
, &all_current_opens_are_level_II
);
948 if(num_share_modes
== -1) {
951 * This next line is a subtlety we need for MS-Access. If a file open will
952 * fail due to share permissions and also for security (access)
953 * reasons, we need to return the access failed error, not the
954 * share error. This means we must attempt to open the file anyway
955 * in order to get the UNIX access error - even if we're going to
956 * fail the open for share reasons. This is bad, as we're burning
957 * another fd if there are existing locks but there's nothing else
958 * we can do. We also ensure we're not going to create or tuncate
959 * the file as we only want an access decision at this stage. JRA.
962 fsp_open
= open_file(fsp
,conn
,fname
,psbuf
,
963 flags
|(flags2
&~(O_TRUNC
|O_CREAT
)),mode
,desired_access
);
965 DEBUG(4,("open_file_shared : share_mode deny - calling open_file with \
966 flags=0x%X flags2=0x%X mode=0%o returned %d\n",
967 flags
,(flags2
&~(O_TRUNC
|O_CREAT
)),(int)mode
,(int)fsp_open
));
969 if (!fsp_open
&& errno
) {
970 unix_ERR_class
= ERRDOS
;
971 unix_ERR_code
= ERRnoaccess
;
972 unix_ERR_ntstatus
= NT_STATUS_ACCESS_DENIED
;
975 unlock_share_entry(conn
, dev
, inode
);
983 * We exit this block with the share entry *locked*.....
988 * Ensure we pay attention to default ACLs on directories if required.
991 if ((flags2
& O_CREAT
) && lp_inherit_acls(SNUM(conn
)) &&
992 (def_acl
= directory_has_default_acl(conn
, parent_dirname(fname
))))
995 DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
996 flags
,flags2
,(int)mode
));
999 * open_file strips any O_TRUNC flags itself.
1002 fsp_open
= open_file(fsp
,conn
,fname
,psbuf
,flags
|flags2
,mode
,desired_access
);
1004 if (!fsp_open
&& (flags
== O_RDWR
) && (errno
!= ENOENT
) && fcbopen
) {
1005 if((fsp_open
= open_file(fsp
,conn
,fname
,psbuf
,O_RDONLY
,mode
,desired_access
)) == True
)
1011 unlock_share_entry(conn
, dev
, inode
);
1017 * Deal with the race condition where two smbd's detect the file doesn't
1018 * exist and do the create at the same time. One of them will win and
1019 * set a share mode, the other (ie. this one) should check if the
1020 * requested share mode for this create is allowed.
1023 if (!file_existed
) {
1025 lock_share_entry_fsp(fsp
);
1027 num_share_modes
= open_mode_check(conn
, fname
, dev
, inode
,
1030 &flags
, &oplock_request
, &all_current_opens_are_level_II
);
1032 if(num_share_modes
== -1) {
1033 unlock_share_entry_fsp(fsp
);
1040 * If there are any share modes set then the file *did*
1041 * exist. Ensure we return the correct value for action.
1044 if (num_share_modes
> 0)
1045 file_existed
= True
;
1048 * We exit this block with the share entry *locked*.....
1052 /* note that we ignore failure for the following. It is
1053 basically a hack for NFS, and NFS will never set one of
1054 these only read them. Nobody but Samba can ever set a deny
1055 mode and we have already checked our more authoritative
1056 locking database for permission to set this deny mode. If
1057 the kernel refuses the operations then the kernel is wrong */
1058 kernel_flock(fsp
, deny_mode
);
1061 * At this point onwards, we can guarentee that the share entry
1062 * is locked, whether we created the file or not, and that the
1063 * deny mode is compatible with all current opens.
1067 * If requested, truncate the file.
1070 if (flags2
&O_TRUNC
) {
1072 * We are modifing the file after open - update the stat struct..
1074 if ((truncate_unless_locked(conn
,fsp
) == -1) || (VFS_FSTAT(fsp
,fsp
->fd
,psbuf
)==-1)) {
1075 unlock_share_entry_fsp(fsp
);
1084 open_mode
= DOS_OPEN_RDONLY
;
1087 open_mode
= DOS_OPEN_RDWR
;
1090 open_mode
= DOS_OPEN_WRONLY
;
1094 fsp
->share_mode
= SET_DENY_MODE(deny_mode
) |
1095 SET_OPEN_MODE(open_mode
) |
1096 SET_ALLOW_SHARE_DELETE(allow_share_delete
);
1098 DEBUG(10,("open_file_shared : share_mode = %x\n", fsp
->share_mode
));
1101 (*Access
) = open_mode
;
1104 if (file_existed
&& !(flags2
& O_TRUNC
))
1105 *action
= FILE_WAS_OPENED
;
1107 *action
= FILE_WAS_CREATED
;
1108 if (file_existed
&& (flags2
& O_TRUNC
))
1109 *action
= FILE_WAS_OVERWRITTEN
;
1113 * Setup the oplock info in both the shared memory and
1117 if(oplock_request
&& (num_share_modes
== 0) &&
1118 !IS_VETO_OPLOCK_PATH(conn
,fname
) && set_file_oplock(fsp
, oplock_request
) ) {
1119 port
= global_oplock_port
;
1120 } else if (oplock_request
&& all_current_opens_are_level_II
) {
1121 port
= global_oplock_port
;
1122 oplock_request
= LEVEL_II_OPLOCK
;
1123 set_file_oplock(fsp
, oplock_request
);
1129 set_share_mode(fsp
, port
, oplock_request
);
1131 if (delete_on_close
) {
1132 NTSTATUS result
= set_delete_on_close_internal(fsp
, delete_on_close
);
1134 if (NT_STATUS_V(result
) != NT_STATUS_V(NT_STATUS_OK
)) {
1135 /* Remember to delete the mode we just added. */
1136 del_share_mode(fsp
, NULL
);
1137 unlock_share_entry_fsp(fsp
);
1145 * Take care of inherited ACLs on created files - if default ACL not
1149 if (!file_existed
&& !def_acl
) {
1151 int saved_errno
= errno
; /* We might get ENOSYS in the next call.. */
1153 if (VFS_FCHMOD_ACL(fsp
, fsp
->fd
, mode
) == -1 && errno
== ENOSYS
)
1154 errno
= saved_errno
; /* Ignore ENOSYS */
1156 } else if (new_mode
) {
1160 /* Attributes need changing. File already existed. */
1163 int saved_errno
= errno
; /* We might get ENOSYS in the next call.. */
1164 ret
= VFS_FCHMOD_ACL(fsp
, fsp
->fd
, new_mode
);
1166 if (ret
== -1 && errno
== ENOSYS
) {
1167 errno
= saved_errno
; /* Ignore ENOSYS */
1169 DEBUG(5, ("open_file_shared: failed to reset attributes of file %s to 0%o\n",
1170 fname
, (int)new_mode
));
1171 ret
= 0; /* Don't do the fchmod below. */
1175 if ((ret
== -1) && (VFS_FCHMOD(fsp
, fsp
->fd
, new_mode
) == -1))
1176 DEBUG(5, ("open_file_shared: failed to reset attributes of file %s to 0%o\n",
1177 fname
, (int)new_mode
));
1180 unlock_share_entry_fsp(fsp
);
1182 conn
->num_files_open
++;
1187 /****************************************************************************
1188 Open a file for for write to ensure that we can fchmod it.
1189 ****************************************************************************/
1191 files_struct
*open_file_fchmod(connection_struct
*conn
, const char *fname
, SMB_STRUCT_STAT
*psbuf
)
1193 files_struct
*fsp
= NULL
;
1196 if (!VALID_STAT(*psbuf
))
1199 fsp
= file_new(conn
);
1203 /* note! we must use a non-zero desired access or we don't get
1204 a real file descriptor. Oh what a twisted web we weave. */
1205 fsp_open
= open_file(fsp
,conn
,fname
,psbuf
,O_WRONLY
,0,FILE_WRITE_DATA
);
1208 * This is not a user visible file open.
1209 * Don't set a share mode and don't increment
1210 * the conn->num_files_open.
1221 /****************************************************************************
1222 Close the fchmod file fd - ensure no locks are lost.
1223 ****************************************************************************/
1225 int close_file_fchmod(files_struct
*fsp
)
1227 int ret
= fd_close(fsp
->conn
, fsp
);
1232 /****************************************************************************
1233 Open a directory from an NT SMB call.
1234 ****************************************************************************/
1236 files_struct
*open_directory(connection_struct
*conn
, char *fname
, SMB_STRUCT_STAT
*psbuf
,
1237 uint32 desired_access
, int share_mode
, int smb_ofun
, mode_t unixmode
, int *action
)
1239 extern struct current_user current_user
;
1240 BOOL got_stat
= False
;
1241 files_struct
*fsp
= file_new(conn
);
1242 BOOL delete_on_close
= GET_DELETE_ON_CLOSE_FLAG(share_mode
);
1247 if (VALID_STAT(*psbuf
))
1250 if (got_stat
&& (GET_FILE_OPEN_DISPOSITION(smb_ofun
) == FILE_EXISTS_FAIL
)) {
1252 errno
= EEXIST
; /* Setup so correct error is returned to client. */
1256 if (GET_FILE_CREATE_DISPOSITION(smb_ofun
) == FILE_CREATE_IF_NOT_EXIST
) {
1260 if(!S_ISDIR(psbuf
->st_mode
)) {
1261 DEBUG(0,("open_directory: %s is not a directory !\n", fname
));
1266 *action
= FILE_WAS_OPENED
;
1271 * Try and create the directory.
1274 if(!CAN_WRITE(conn
)) {
1275 DEBUG(2,("open_directory: failing create on read-only share\n"));
1281 if(vfs_MkDir(conn
,fname
, unix_mode(conn
,aDIR
, fname
)) < 0) {
1282 DEBUG(2,("open_directory: unable to create %s. Error was %s\n",
1283 fname
, strerror(errno
) ));
1288 if(VFS_STAT(conn
,fname
, psbuf
) != 0) {
1293 *action
= FILE_WAS_CREATED
;
1299 * Don't create - just check that it *was* a directory.
1303 DEBUG(3,("open_directory: unable to stat name = %s. Error was %s\n",
1304 fname
, strerror(errno
) ));
1309 if(!S_ISDIR(psbuf
->st_mode
)) {
1310 DEBUG(0,("open_directory: %s is not a directory !\n", fname
));
1315 *action
= FILE_WAS_OPENED
;
1318 DEBUG(5,("open_directory: opening directory %s\n", fname
));
1321 * Setup the files_struct for it.
1324 fsp
->mode
= psbuf
->st_mode
;
1325 fsp
->inode
= psbuf
->st_ino
;
1326 fsp
->dev
= psbuf
->st_dev
;
1327 fsp
->size
= psbuf
->st_size
;
1328 fsp
->vuid
= current_user
.vuid
;
1330 fsp
->can_lock
= True
;
1331 fsp
->can_read
= False
;
1332 fsp
->can_write
= False
;
1333 fsp
->share_mode
= share_mode
;
1334 fsp
->desired_access
= desired_access
;
1335 fsp
->print_file
= False
;
1336 fsp
->modified
= False
;
1337 fsp
->oplock_type
= NO_OPLOCK
;
1338 fsp
->sent_oplock_break
= NO_BREAK_SENT
;
1339 fsp
->is_directory
= True
;
1340 fsp
->is_stat
= False
;
1341 fsp
->directory_delete_on_close
= False
;
1342 string_set(&fsp
->fsp_name
,fname
);
1344 if (delete_on_close
) {
1345 NTSTATUS result
= set_delete_on_close_internal(fsp
, delete_on_close
);
1347 if (NT_STATUS_V(result
) != NT_STATUS_V(NT_STATUS_OK
)) {
1352 conn
->num_files_open
++;
1357 /****************************************************************************
1358 Open a pseudo-file (no locking checks - a 'stat' open).
1359 ****************************************************************************/
1361 files_struct
*open_file_stat(connection_struct
*conn
, char *fname
, SMB_STRUCT_STAT
*psbuf
)
1363 extern struct current_user current_user
;
1364 files_struct
*fsp
= NULL
;
1366 if (!VALID_STAT(*psbuf
))
1369 /* Can't 'stat' open directories. */
1370 if(S_ISDIR(psbuf
->st_mode
))
1373 fsp
= file_new(conn
);
1377 DEBUG(5,("open_file_stat: 'opening' file %s\n", fname
));
1380 * Setup the files_struct for it.
1383 fsp
->mode
= psbuf
->st_mode
;
1385 * Don't store dev or inode, we don't want any iterator
1388 fsp
->inode
= (SMB_INO_T
)0;
1389 fsp
->dev
= (SMB_DEV_T
)0;
1390 fsp
->size
= psbuf
->st_size
;
1391 fsp
->vuid
= current_user
.vuid
;
1393 fsp
->can_lock
= False
;
1394 fsp
->can_read
= False
;
1395 fsp
->can_write
= False
;
1396 fsp
->share_mode
= 0;
1397 fsp
->desired_access
= 0;
1398 fsp
->print_file
= False
;
1399 fsp
->modified
= False
;
1400 fsp
->oplock_type
= NO_OPLOCK
;
1401 fsp
->sent_oplock_break
= NO_BREAK_SENT
;
1402 fsp
->is_directory
= False
;
1403 fsp
->is_stat
= True
;
1404 fsp
->directory_delete_on_close
= False
;
1405 string_set(&fsp
->fsp_name
,fname
);
1407 conn
->num_files_open
++;