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 = conn->vfs_ops.open(conn,fname,flags,mode);
43 /* Fix for files ending in '.' */
44 if((fd == -1) && (errno == ENOENT) &&
45 (strchr_m(fname,'.')==NULL)) {
47 fd = conn->vfs_ops.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)
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;
85 /****************************************************************************
87 ****************************************************************************/
89 static BOOL open_file(files_struct *fsp,connection_struct *conn,
90 char *fname1,SMB_STRUCT_STAT *psbuf,int flags,mode_t mode)
92 extern struct current_user current_user;
94 int accmode = (flags & O_ACCMODE);
95 int local_flags = flags;
98 fsp->oplock_type = NO_OPLOCK;
101 pstrcpy(fname,fname1);
103 /* Check permissions */
106 * This code was changed after seeing a client open request
107 * containing the open mode of (DENY_WRITE/read-only) with
108 * the 'create if not exist' bit set. The previous code
109 * would fail to open the file read only on a read-only share
110 * as it was checking the flags parameter directly against O_RDONLY,
111 * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
115 if (!CAN_WRITE(conn)) {
116 /* It's a read-only share - fail if we wanted to write. */
117 if(accmode != O_RDONLY) {
118 DEBUG(3,("Permission denied opening %s\n",fname));
119 check_for_pipe(fname);
121 } else if(flags & O_CREAT) {
122 /* We don't want to write - but we must make sure that O_CREAT
123 doesn't create the file if we have write access into the
131 * This little piece of insanity is inspired by the
132 * fact that an NT client can open a file for O_RDONLY,
133 * but set the create disposition to FILE_EXISTS_TRUNCATE.
134 * If the client *can* write to the file, then it expects to
135 * truncate the file, even though it is opening for readonly.
136 * Quicken uses this stupid trick in backup file creation...
137 * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
138 * for helping track this one down. It didn't bite us in 2.0.x
139 * as we always opened files read-write in that release. JRA.
142 if ((accmode == O_RDONLY) && ((flags & O_TRUNC) == O_TRUNC))
143 local_flags = (flags & ~O_ACCMODE)|O_RDWR;
146 * We can't actually truncate here as the file may be locked.
147 * open_file_shared will take care of the truncate later. JRA.
150 local_flags &= ~O_TRUNC;
152 /* actually do the open */
153 fsp->fd = fd_open(conn, fname, local_flags, mode);
156 DEBUG(3,("Error opening file %s (%s) (local_flags=%d) (flags=%d)\n",
157 fname,strerror(errno),local_flags,flags));
158 check_for_pipe(fname);
162 if (!VALID_STAT(*psbuf)) {
163 if (vfs_fstat(fsp,fsp->fd,psbuf) == -1) {
164 DEBUG(0,("Error doing fstat on open file %s (%s)\n", fname,strerror(errno) ));
171 * POSIX allows read-only opens of directories. We don't
172 * want to do this (we use a different code path for this)
173 * so catch a directory open and return an EISDIR. JRA.
176 if(S_ISDIR(psbuf->st_mode)) {
182 fsp->mode = psbuf->st_mode;
183 fsp->inode = psbuf->st_ino;
184 fsp->dev = psbuf->st_dev;
185 fsp->vuid = current_user.vuid;
186 fsp->size = psbuf->st_size;
188 fsp->can_lock = True;
189 fsp->can_read = ((flags & O_WRONLY)==0);
190 fsp->can_write = ((flags & (O_WRONLY|O_RDWR))!=0);
192 fsp->print_file = False;
193 fsp->modified = False;
194 fsp->oplock_type = NO_OPLOCK;
195 fsp->sent_oplock_break = NO_BREAK_SENT;
196 fsp->is_directory = False;
197 fsp->stat_open = False;
198 fsp->directory_delete_on_close = False;
200 string_set(&fsp->fsp_name,fname);
201 fsp->wcp = NULL; /* Write cache pointer. */
203 DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
204 *current_user_info.smb_name ? current_user_info.smb_name : conn->user,fsp->fsp_name,
205 BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
206 conn->num_files_open + 1));
211 /****************************************************************************
213 Helper for open_file_shared.
214 Truncate a file after checking locking; close file if locked.
215 **************************************************************************/
217 static int truncate_unless_locked(struct connection_struct *conn, files_struct *fsp)
219 SMB_BIG_UINT mask = (SMB_BIG_UINT)-1;
221 if (is_locked(fsp,fsp->conn,mask,0,WRITE_LOCK,True)){
223 unix_ERR_class = ERRDOS;
224 unix_ERR_code = ERRlock;
227 return conn->vfs_ops.ftruncate(fsp,fsp->fd,0);
231 /*******************************************************************
232 return True if the filename is one of the special executable types
233 ********************************************************************/
234 static BOOL is_executable(const char *fname)
236 if ((fname = strrchr_m(fname,'.'))) {
237 if (strequal(fname,".com") ||
238 strequal(fname,".dll") ||
239 strequal(fname,".exe") ||
240 strequal(fname,".sym")) {
247 enum {AFAIL,AREAD,AWRITE,AALL};
249 /*******************************************************************
250 reproduce the share mode access table
251 this is horrendoously complex, and really can't be justified on any
252 rational grounds except that this is _exactly_ what NT does. See
253 the DENY1 and DENY2 tests in smbtorture for a comprehensive set of
255 ********************************************************************/
256 static int access_table(int new_deny,int old_deny,int old_mode,
257 BOOL same_pid, BOOL isexe)
259 if (new_deny == DENY_ALL || old_deny == DENY_ALL) return(AFAIL);
262 if (isexe && old_mode == DOS_OPEN_RDONLY &&
263 old_deny == DENY_DOS && new_deny == DENY_READ) {
266 if (!isexe && old_mode == DOS_OPEN_RDONLY &&
267 old_deny == DENY_DOS && new_deny == DENY_DOS) {
270 if (new_deny == DENY_FCB && old_deny == DENY_DOS) {
271 if (isexe) return AFAIL;
272 if (old_mode == DOS_OPEN_RDONLY) return AFAIL;
275 if (old_mode == DOS_OPEN_RDONLY && old_deny == DENY_DOS) {
276 if (new_deny == DENY_FCB || new_deny == DENY_READ) {
277 if (isexe) return AREAD;
281 if (old_deny == DENY_FCB) {
282 if (new_deny == DENY_DOS || new_deny == DENY_FCB) return AALL;
287 if (old_deny == DENY_DOS || new_deny == DENY_DOS ||
288 old_deny == DENY_FCB || new_deny == DENY_FCB) {
290 if (old_deny == DENY_FCB || new_deny == DENY_FCB) {
293 if (old_deny == DENY_DOS) {
294 if (new_deny == DENY_READ &&
295 (old_mode == DOS_OPEN_RDONLY ||
296 old_mode == DOS_OPEN_RDWR)) {
299 if (new_deny == DENY_WRITE &&
300 (old_mode == DOS_OPEN_WRONLY ||
301 old_mode == DOS_OPEN_RDWR)) {
306 if (old_deny == DENY_NONE) return AALL;
307 if (old_deny == DENY_READ) return AWRITE;
308 if (old_deny == DENY_WRITE) return AREAD;
310 /* it isn't a exe, dll, sym or com file */
311 if (old_deny == new_deny && same_pid)
314 if (old_deny == DENY_READ || new_deny == DENY_READ) return AFAIL;
315 if (old_mode == DOS_OPEN_RDONLY) return(AREAD);
323 if (old_deny==DENY_WRITE && old_mode==DOS_OPEN_RDONLY) return(AREAD);
324 if (old_deny==DENY_READ && old_mode==DOS_OPEN_RDONLY) return(AWRITE);
325 if (old_deny==DENY_NONE && old_mode==DOS_OPEN_RDONLY) return(AALL);
328 if (old_deny==DENY_WRITE && old_mode==DOS_OPEN_WRONLY) return(AREAD);
329 if (old_deny==DENY_READ && old_mode==DOS_OPEN_WRONLY) return(AWRITE);
330 if (old_deny==DENY_NONE && old_mode==DOS_OPEN_WRONLY) return(AALL);
333 if (old_deny==DENY_WRITE) return(AREAD);
334 if (old_deny==DENY_READ) return(AWRITE);
335 if (old_deny==DENY_NONE) return(AALL);
342 /****************************************************************************
343 check if we can open a file with a share mode
344 ****************************************************************************/
346 static BOOL check_share_mode(connection_struct *conn, share_mode_entry *share, int share_mode,
347 const char *fname, BOOL fcbopen, int *flags)
349 int deny_mode = GET_DENY_MODE(share_mode);
350 int old_open_mode = GET_OPEN_MODE(share->share_mode);
351 int old_deny_mode = GET_DENY_MODE(share->share_mode);
354 * share modes = false means don't bother to check for
355 * DENY mode conflict. This is a *really* bad idea :-). JRA.
358 if(!lp_share_modes(SNUM(conn)))
362 * Don't allow any opens once the delete on close flag has been
366 if (GET_DELETE_ON_CLOSE_FLAG(share->share_mode)) {
367 DEBUG(5,("check_share_mode: Failing open on file %s as delete on close flag is set.\n",
369 unix_ERR_class = ERRDOS;
370 unix_ERR_code = ERRnoaccess;
375 * If delete access was requested and the existing share mode doesn't have
376 * ALLOW_SHARE_DELETE then deny.
379 if (GET_DELETE_ACCESS_REQUESTED(share_mode) && !GET_ALLOW_SHARE_DELETE(share->share_mode)) {
380 DEBUG(5,("check_share_mode: Failing open on file %s as delete access requested and allow share delete not set.\n",
382 unix_ERR_class = ERRDOS;
383 unix_ERR_code = ERRbadshare;
389 * The inverse of the above.
390 * If delete access was granted and the new share mode doesn't have
391 * ALLOW_SHARE_DELETE then deny.
394 if (GET_DELETE_ACCESS_REQUESTED(share->share_mode) && !GET_ALLOW_SHARE_DELETE(share_mode)) {
395 DEBUG(5,("check_share_mode: Failing open on file %s as delete access granted and allow share delete not requested.\n",
397 unix_ERR_class = ERRDOS;
398 unix_ERR_code = ERRbadshare;
404 int access_allowed = access_table(deny_mode,old_deny_mode,old_open_mode,
405 (share->pid == sys_getpid()),is_executable(fname));
407 if ((access_allowed == AFAIL) ||
408 (!fcbopen && (access_allowed == AREAD && *flags == O_RDWR)) ||
409 (access_allowed == AREAD && *flags != O_RDONLY) ||
410 (access_allowed == AWRITE && *flags != O_WRONLY)) {
412 DEBUG(2,("Share violation on file (%d,%d,%d,%d,%s,fcbopen = %d, flags = %d) = %d\n",
413 deny_mode,old_deny_mode,old_open_mode,
414 (int)share->pid,fname, fcbopen, *flags, access_allowed));
416 unix_ERR_class = ERRDOS;
417 unix_ERR_code = ERRbadshare;
422 if (access_allowed == AREAD)
425 if (access_allowed == AWRITE)
433 /****************************************************************************
434 Deal with open deny mode and oplock break processing.
435 Invarient: Share mode must be locked on entry and exit.
436 Returns -1 on error, or number of share modes on success (may be zero).
437 ****************************************************************************/
439 static int open_mode_check(connection_struct *conn, const char *fname, SMB_DEV_T dev,
441 uint32 desired_access,
442 int share_mode, int *p_flags, int *p_oplock_request,
443 BOOL *p_all_current_opens_are_level_II)
447 int oplock_contention_count = 0;
448 share_mode_entry *old_shares = 0;
449 BOOL fcbopen = False;
452 if(GET_OPEN_MODE(share_mode) == DOS_OPEN_FCB)
455 num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
457 if(num_share_modes == 0)
461 * Check if the share modes will give us access.
465 share_mode_entry broken_entry;
467 broke_oplock = False;
468 *p_all_current_opens_are_level_II = True;
470 for(i = 0; i < num_share_modes; i++) {
471 share_mode_entry *share_entry = &old_shares[i];
474 * By observation of NetBench, oplocks are broken *before* share
475 * modes are checked. This allows a file to be closed by the client
476 * if the share mode would deny access and the client has an oplock.
477 * Check if someone has an oplock on this file. If so we must break
478 * it before continuing.
481 if((*p_oplock_request && EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type)) ||
482 (!*p_oplock_request && (share_entry->op_type != NO_OPLOCK))) {
486 DEBUG(5,("open_mode_check: oplock_request = %d, breaking oplock (%x) on file %s, \
487 dev = %x, inode = %.0f\n", *p_oplock_request, share_entry->op_type, fname, (unsigned int)dev, (double)inode));
489 /* Oplock break - unlock to request it. */
490 unlock_share_entry(conn, dev, inode);
492 opb_ret = request_oplock_break(share_entry);
495 lock_share_entry(conn, dev, inode);
497 if(opb_ret == False) {
498 DEBUG(0,("open_mode_check: FAILED when breaking oplock (%x) on file %s, \
499 dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
500 SAFE_FREE(old_shares);
502 unix_ERR_class = ERRDOS;
503 unix_ERR_code = ERRbadshare;
508 broken_entry = *share_entry;
511 } else if (!LEVEL_II_OPLOCK_TYPE(share_entry->op_type)) {
512 *p_all_current_opens_are_level_II = False;
515 /* this is a nasty hack, but necessary until we rewrite our open
516 handling to use a NTCreateX call as the basic call.
517 NT may open a file with neither read nor write access, and in
518 this case it expects the open not to conflict with any
519 existing deny modes. This happens (for example) during a
520 "xcopy /o" where the second file descriptor is used for
522 This code should be removed once we have a propoer ntcreateX
526 if (desired_access == 0 ||
527 (desired_access & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE))) {
528 /* someone else has a share lock on it, check to see
530 if (!check_share_mode(conn, share_entry, share_mode,
531 fname, fcbopen, p_flags)) {
532 SAFE_FREE(old_shares);
541 SAFE_FREE(old_shares);
542 num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
543 oplock_contention_count++;
545 /* Paranoia check that this is no longer an exlusive entry. */
546 for(i = 0; i < num_share_modes; i++) {
547 share_mode_entry *share_entry = &old_shares[i];
549 if (share_modes_identical(&broken_entry, share_entry) &&
550 EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type) ) {
553 * This should not happen. The target left this oplock
554 * as exlusive.... The process *must* be dead....
557 DEBUG(0,("open_mode_check: exlusive oplock left by process %d after break ! For file %s, \
558 dev = %x, inode = %.0f. Deleting it to continue...\n", (int)broken_entry.pid, fname, (unsigned int)dev, (double)inode));
560 if (process_exists(broken_entry.pid)) {
561 DEBUG(0,("open_mode_check: Existent process %d left active oplock.\n",
565 if (del_share_entry(dev, inode, &broken_entry, NULL) == -1) {
567 unix_ERR_class = ERRDOS;
568 unix_ERR_code = ERRbadshare;
573 * We must reload the share modes after deleting the
574 * other process's entry.
577 SAFE_FREE(old_shares);
578 num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
581 } /* end for paranoia... */
582 } /* end if broke_oplock */
584 } while(broke_oplock);
587 SAFE_FREE(old_shares);
590 * Refuse to grant an oplock in case the contention limit is
591 * reached when going through the lock list multiple times.
594 if(oplock_contention_count >= lp_oplock_contention_limit(SNUM(conn))) {
595 *p_oplock_request = 0;
596 DEBUG(4,("open_mode_check: oplock contention = %d. Not granting oplock.\n",
597 oplock_contention_count ));
600 return num_share_modes;
603 /****************************************************************************
604 set a kernel flock on a file for NFS interoperability
605 this requires a patch to Linux
606 ****************************************************************************/
607 static void kernel_flock(files_struct *fsp, int deny_mode)
609 #if HAVE_KERNEL_SHARE_MODES
611 if (deny_mode == DENY_READ) kernel_mode = LOCK_MAND|LOCK_WRITE;
612 else if (deny_mode == DENY_WRITE) kernel_mode = LOCK_MAND|LOCK_READ;
613 else if (deny_mode == DENY_ALL) kernel_mode = LOCK_MAND;
614 if (kernel_mode) flock(fsp->fd, kernel_mode);
620 /****************************************************************************
621 Open a file with a share mode. On output from this open we are guarenteeing
623 ****************************************************************************/
624 files_struct *open_file_shared(connection_struct *conn,char *fname, SMB_STRUCT_STAT *psbuf,
625 int share_mode,int ofun, mode_t mode,int oplock_request,
626 int *Access,int *action)
628 return open_file_shared1(conn, fname, psbuf, 0, share_mode, ofun, mode,
629 oplock_request, Access, action);
632 /****************************************************************************
633 Open a file with a share mode. On output from this open we are guarenteeing
635 ****************************************************************************/
636 files_struct *open_file_shared1(connection_struct *conn,char *fname, SMB_STRUCT_STAT *psbuf,
637 uint32 desired_access,
638 int share_mode,int ofun, mode_t mode,int oplock_request,
639 int *Access,int *action)
643 int deny_mode = GET_DENY_MODE(share_mode);
644 BOOL allow_share_delete = GET_ALLOW_SHARE_DELETE(share_mode);
645 BOOL delete_access_requested = GET_DELETE_ACCESS_REQUESTED(share_mode);
646 BOOL delete_on_close = GET_DELETE_ON_CLOSE_FLAG(share_mode);
647 BOOL file_existed = VALID_STAT(*psbuf);
648 BOOL fcbopen = False;
649 BOOL def_acl = False;
652 int num_share_modes = 0;
653 BOOL all_current_opens_are_level_II = False;
654 BOOL fsp_open = False;
655 files_struct *fsp = NULL;
660 /* printers are handled completely differently. Most of the passed parameters are
663 *Access = DOS_OPEN_WRONLY;
665 *action = FILE_WAS_CREATED;
666 return print_fsp_open(conn, fname);
669 fsp = file_new(conn);
673 DEBUG(10,("open_file_shared: fname = %s, share_mode = %x, ofun = %x, mode = %o, oplock request = %d\n",
674 fname, share_mode, ofun, (int)mode, oplock_request ));
676 if (!check_name(fname,conn)) {
681 /* ignore any oplock requests if oplocks are disabled */
682 if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break) {
686 /* this is for OS/2 EAs - try and say we don't support them */
687 if (strstr(fname,".+,;=[].")) {
688 unix_ERR_class = ERRDOS;
689 /* OS/2 Workplace shell fix may be main code stream in a later release. */
690 #if 1 /* OS2_WPS_FIX - Recent versions of OS/2 need this. */
691 unix_ERR_code = ERRcannotopen;
692 #else /* OS2_WPS_FIX */
693 unix_ERR_code = ERROR_EAS_NOT_SUPPORTED;
694 #endif /* OS2_WPS_FIX */
696 DEBUG(5,("open_file_shared: OS/2 EA's are not supported.\n"));
701 if ((GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL) && file_existed) {
702 DEBUG(5,("open_file_shared: create new requested for file %s and file already exists.\n",
709 if (CAN_WRITE(conn) && (GET_FILE_CREATE_DISPOSITION(ofun) == FILE_CREATE_IF_NOT_EXIST))
712 if (CAN_WRITE(conn) && (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_TRUNCATE))
715 if (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL)
718 /* note that we ignore the append flag as
719 append does not mean the same thing under dos and unix */
721 switch (GET_OPEN_MODE(share_mode)) {
722 case DOS_OPEN_WRONLY:
738 if (GET_FILE_SYNC_OPENMODE(share_mode)) {
743 if (flags != O_RDONLY && file_existed &&
744 (!CAN_WRITE(conn) || IS_DOS_READONLY(dos_mode(conn,fname,psbuf)))) {
746 DEBUG(5,("open_file_shared: read/write access requested for file %s on read only %s\n",
747 fname, !CAN_WRITE(conn) ? "share" : "file" ));
755 if (deny_mode > DENY_NONE && deny_mode!=DENY_FCB) {
756 DEBUG(2,("Invalid deny mode %d on file %s\n",deny_mode,fname));
765 inode = psbuf->st_ino;
767 lock_share_entry(conn, dev, inode);
769 num_share_modes = open_mode_check(conn, fname, dev, inode,
772 &flags, &oplock_request, &all_current_opens_are_level_II);
773 if(num_share_modes == -1) {
776 * This next line is a subtlety we need for MS-Access. If a file open will
777 * fail due to share permissions and also for security (access)
778 * reasons, we need to return the access failed error, not the
779 * share error. This means we must attempt to open the file anyway
780 * in order to get the UNIX access error - even if we're going to
781 * fail the open for share reasons. This is bad, as we're burning
782 * another fd if there are existing locks but there's nothing else
783 * we can do. We also ensure we're not going to create or tuncate
784 * the file as we only want an access decision at this stage. JRA.
786 fsp_open = open_file(fsp,conn,fname,psbuf,flags|(flags2&~(O_TRUNC|O_CREAT)),mode);
788 DEBUG(4,("open_file_shared : share_mode deny - calling open_file with \
789 flags=0x%X flags2=0x%X mode=0%o returned %d\n",
790 flags,(flags2&~(O_TRUNC|O_CREAT)),(int)mode,(int)fsp_open ));
792 unlock_share_entry(conn, dev, inode);
800 * We exit this block with the share entry *locked*.....
805 * Ensure we pay attention to default ACLs on directories if required.
808 if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
809 (def_acl = directory_has_default_acl(conn, parent_dirname(fname))))
812 DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
813 flags,flags2,(int)mode));
816 * open_file strips any O_TRUNC flags itself.
819 fsp_open = open_file(fsp,conn,fname,psbuf,flags|flags2,mode);
821 if (!fsp_open && (flags == O_RDWR) && (errno != ENOENT) && fcbopen) {
822 if((fsp_open = open_file(fsp,conn,fname,psbuf,O_RDONLY,mode)) == True)
828 unlock_share_entry(conn, dev, inode);
834 * Deal with the race condition where two smbd's detect the file doesn't
835 * exist and do the create at the same time. One of them will win and
836 * set a share mode, the other (ie. this one) should check if the
837 * requested share mode for this create is allowed.
842 lock_share_entry_fsp(fsp);
844 num_share_modes = open_mode_check(conn, fname, dev, inode,
847 &flags, &oplock_request, &all_current_opens_are_level_II);
849 if(num_share_modes == -1) {
850 unlock_share_entry_fsp(fsp);
857 * If there are any share modes set then the file *did*
858 * exist. Ensure we return the correct value for action.
861 if (num_share_modes > 0)
865 * We exit this block with the share entry *locked*.....
869 /* note that we ignore failure for the following. It is
870 basically a hack for NFS, and NFS will never set one of
871 these only read them. Nobody but Samba can ever set a deny
872 mode and we have already checked our more authoritative
873 locking database for permission to set this deny mode. If
874 the kernel refuses the operations then the kernel is wrong */
875 kernel_flock(fsp, deny_mode);
878 * At this point onwards, we can guarentee that the share entry
879 * is locked, whether we created the file or not, and that the
880 * deny mode is compatible with all current opens.
884 * If requested, truncate the file.
887 if (flags2&O_TRUNC) {
889 * We are modifing the file after open - update the stat struct..
891 if ((truncate_unless_locked(conn,fsp) == -1) || (vfs_fstat(fsp,fsp->fd,psbuf)==-1)) {
892 unlock_share_entry_fsp(fsp);
901 open_mode = DOS_OPEN_RDONLY;
904 open_mode = DOS_OPEN_RDWR;
907 open_mode = DOS_OPEN_WRONLY;
911 fsp->share_mode = SET_DENY_MODE(deny_mode) |
912 SET_OPEN_MODE(open_mode) |
913 SET_ALLOW_SHARE_DELETE(allow_share_delete) |
914 SET_DELETE_ACCESS_REQUESTED(delete_access_requested);
916 DEBUG(10,("open_file_shared : share_mode = %x\n", fsp->share_mode ));
919 (*Access) = open_mode;
922 if (file_existed && !(flags2 & O_TRUNC))
923 *action = FILE_WAS_OPENED;
925 *action = FILE_WAS_CREATED;
926 if (file_existed && (flags2 & O_TRUNC))
927 *action = FILE_WAS_OVERWRITTEN;
931 * Setup the oplock info in both the shared memory and
935 if(oplock_request && (num_share_modes == 0) &&
936 !IS_VETO_OPLOCK_PATH(conn,fname) && set_file_oplock(fsp, oplock_request) ) {
937 port = global_oplock_port;
938 } else if (oplock_request && all_current_opens_are_level_II) {
939 port = global_oplock_port;
940 oplock_request = LEVEL_II_OPLOCK;
941 set_file_oplock(fsp, oplock_request);
947 set_share_mode(fsp, port, oplock_request);
949 if (delete_on_close) {
950 NTSTATUS result = set_delete_on_close_internal(fsp, delete_on_close);
952 if (NT_STATUS_V(result) != NT_STATUS_V(NT_STATUS_OK)) {
953 /* Remember to delete the mode we just added. */
954 del_share_mode(fsp, NULL);
955 unlock_share_entry_fsp(fsp);
963 * Take care of inherited ACLs on created files - if default ACL not
967 if (!file_existed && !def_acl && (conn->vfs_ops.fchmod_acl != NULL)) {
968 int saved_errno = errno; /* We might get ENOSYS in the next call.. */
969 if (conn->vfs_ops.fchmod_acl(fsp, fsp->fd, mode) == -1 && errno == ENOSYS)
970 errno = saved_errno; /* Ignore ENOSYS */
973 unlock_share_entry_fsp(fsp);
975 conn->num_files_open++;
980 /****************************************************************************
981 Open a file for permissions read only. Return a pseudo file entry
982 with the 'stat_open' flag set
983 ****************************************************************************/
985 files_struct *open_file_stat(connection_struct *conn, char *fname,
986 SMB_STRUCT_STAT *psbuf, int smb_ofun, int *action)
988 extern struct current_user current_user;
989 files_struct *fsp = NULL;
991 if (!VALID_STAT(*psbuf)) {
992 DEBUG(0,("open_file_stat: unable to stat name = %s. Error was %s\n", fname, strerror(errno) ));
996 if(S_ISDIR(psbuf->st_mode)) {
997 DEBUG(0,("open_file_stat: %s is a directory !\n", fname ));
1001 fsp = file_new(conn);
1005 *action = FILE_WAS_OPENED;
1007 DEBUG(5,("open_file_stat: opening file %s as a stat entry\n", fname));
1010 * Setup the files_struct for it.
1013 fsp->mode = psbuf->st_mode;
1014 fsp->inode = psbuf->st_ino;
1015 fsp->dev = psbuf->st_dev;
1016 fsp->size = psbuf->st_size;
1017 fsp->vuid = current_user.vuid;
1019 fsp->can_lock = False;
1020 fsp->can_read = False;
1021 fsp->can_write = False;
1022 fsp->share_mode = 0;
1023 fsp->print_file = False;
1024 fsp->modified = False;
1025 fsp->oplock_type = NO_OPLOCK;
1026 fsp->sent_oplock_break = NO_BREAK_SENT;
1027 fsp->is_directory = False;
1028 fsp->stat_open = True;
1029 fsp->directory_delete_on_close = False;
1031 string_set(&fsp->fsp_name,fname);
1032 fsp->wcp = NULL; /* Write cache pointer. */
1034 conn->num_files_open++;
1039 /****************************************************************************
1040 Open a file for for write to ensure that we can fchmod it.
1041 ****************************************************************************/
1043 files_struct *open_file_fchmod(connection_struct *conn, char *fname, SMB_STRUCT_STAT *psbuf)
1045 files_struct *fsp = NULL;
1048 if (!VALID_STAT(*psbuf))
1051 fsp = file_new(conn);
1055 fsp_open = open_file(fsp,conn,fname,psbuf,O_WRONLY,0);
1058 * This is not a user visible file open.
1059 * Don't set a share mode and don't increment
1060 * the conn->num_files_open.
1071 /****************************************************************************
1072 Close the fchmod file fd - ensure no locks are lost.
1073 ****************************************************************************/
1075 int close_file_fchmod(files_struct *fsp)
1077 int ret = fd_close(fsp->conn, fsp);
1082 /****************************************************************************
1083 Open a directory from an NT SMB call.
1084 ****************************************************************************/
1086 files_struct *open_directory(connection_struct *conn, char *fname,
1087 SMB_STRUCT_STAT *psbuf, int share_mode, int smb_ofun, mode_t unixmode, int *action)
1089 extern struct current_user current_user;
1090 BOOL got_stat = False;
1091 files_struct *fsp = file_new(conn);
1092 BOOL delete_on_close = GET_DELETE_ON_CLOSE_FLAG(share_mode);
1097 fsp->conn = conn; /* The vfs_fXXX() macros need this. */
1099 if (VALID_STAT(*psbuf))
1102 if (got_stat && (GET_FILE_OPEN_DISPOSITION(smb_ofun) == FILE_EXISTS_FAIL)) {
1104 errno = EEXIST; /* Setup so correct error is returned to client. */
1108 if (GET_FILE_CREATE_DISPOSITION(smb_ofun) == FILE_CREATE_IF_NOT_EXIST) {
1112 if(!S_ISDIR(psbuf->st_mode)) {
1113 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1118 *action = FILE_WAS_OPENED;
1123 * Try and create the directory.
1126 if(!CAN_WRITE(conn)) {
1127 DEBUG(2,("open_directory: failing create on read-only share\n"));
1133 if(vfs_mkdir(conn,fname, unix_mode(conn,aDIR, fname)) < 0) {
1134 DEBUG(2,("open_directory: unable to create %s. Error was %s\n",
1135 fname, strerror(errno) ));
1140 if(vfs_stat(conn,fname, psbuf) != 0) {
1145 *action = FILE_WAS_CREATED;
1151 * Don't create - just check that it *was* a directory.
1155 DEBUG(0,("open_directory: unable to stat name = %s. Error was %s\n",
1156 fname, strerror(errno) ));
1161 if(!S_ISDIR(psbuf->st_mode)) {
1162 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1167 *action = FILE_WAS_OPENED;
1170 DEBUG(5,("open_directory: opening directory %s\n", fname));
1173 * Setup the files_struct for it.
1176 fsp->mode = psbuf->st_mode;
1177 fsp->inode = psbuf->st_ino;
1178 fsp->dev = psbuf->st_dev;
1179 fsp->size = psbuf->st_size;
1180 fsp->vuid = current_user.vuid;
1182 fsp->can_lock = True;
1183 fsp->can_read = False;
1184 fsp->can_write = False;
1185 fsp->share_mode = share_mode;
1186 fsp->print_file = False;
1187 fsp->modified = False;
1188 fsp->oplock_type = NO_OPLOCK;
1189 fsp->sent_oplock_break = NO_BREAK_SENT;
1190 fsp->is_directory = True;
1191 fsp->directory_delete_on_close = False;
1193 string_set(&fsp->fsp_name,fname);
1195 if (delete_on_close) {
1196 NTSTATUS result = set_delete_on_close_internal(fsp, delete_on_close);
1198 if (NT_STATUS_V(result) != NT_STATUS_V(NT_STATUS_OK)) {
1203 conn->num_files_open++;
1208 /*******************************************************************
1209 Check if the share mode on a file allows it to be deleted or unlinked.
1210 Return True if sharing doesn't prevent the operation.
1211 ********************************************************************/
1213 BOOL check_file_sharing(connection_struct *conn,char *fname, BOOL rename_op)
1217 share_mode_entry *old_shares = 0;
1218 int num_share_modes;
1219 SMB_STRUCT_STAT sbuf;
1220 pid_t pid = sys_getpid();
1224 if (vfs_stat(conn,fname,&sbuf) == -1)
1228 inode = sbuf.st_ino;
1230 lock_share_entry(conn, dev, inode);
1231 num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
1234 * Check if the share modes will give us access.
1237 if(num_share_modes != 0)
1244 broke_oplock = False;
1245 for(i = 0; i < num_share_modes; i++)
1247 share_mode_entry *share_entry = &old_shares[i];
1250 * Break oplocks before checking share modes. See comment in
1251 * open_file_shared for details.
1252 * Check if someone has an oplock on this file. If so we must
1253 * break it before continuing.
1255 if(BATCH_OPLOCK_TYPE(share_entry->op_type))
1260 /* JRA. Try removing this code to see if the new oplock changes
1261 fix the problem. I'm dubious, but Andrew is recommending we
1266 * It appears that the NT redirector may have a bug, in that
1267 * it tries to do an SMBmv on a file that it has open with a
1268 * batch oplock, and then fails to respond to the oplock break
1269 * request. This only seems to occur when the client is doing an
1270 * SMBmv to the smbd it is using - thus we try and detect this
1271 * condition by checking if the file being moved is open and oplocked by
1272 * this smbd process, and then not sending the oplock break in this
1273 * special case. If the file was open with a deny mode that
1274 * prevents the move the SMBmv will fail anyway with a share
1275 * violation error. JRA.
1277 if(rename_op && (share_entry->pid == pid))
1280 DEBUG(0,("check_file_sharing: NT redirector workaround - rename attempted on \
1281 batch oplocked file %s, dev = %x, inode = %.0f\n", fname, (unsigned int)dev, (double)inode));
1284 * This next line is a test that allows the deny-mode
1285 * processing to be skipped. This seems to be needed as
1286 * NT insists on the rename succeeding (in Office 9x no less !).
1287 * This should be removed as soon as (a) MS fix the redirector
1288 * bug or (b) NT SMB support in Samba makes NT not issue the
1289 * call (as is my fervent hope). JRA.
1297 DEBUG(5,("check_file_sharing: breaking oplock (%x) on file %s, \
1298 dev = %x, inode = %.0f\n", share_entry->op_type, fname, (unsigned int)dev, (double)inode));
1300 /* Oplock break.... */
1301 unlock_share_entry(conn, dev, inode);
1302 if(request_oplock_break(share_entry) == False)
1304 DEBUG(0,("check_file_sharing: FAILED when breaking oplock (%x) on file %s, \
1305 dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
1307 SAFE_FREE(old_shares);
1310 lock_share_entry(conn, dev, inode);
1311 broke_oplock = True;
1317 * If this is a delete request and ALLOW_SHARE_DELETE is set then allow
1318 * this to proceed. This takes precedence over share modes.
1321 if(!rename_op && GET_ALLOW_SHARE_DELETE(share_entry->share_mode))
1325 * Someone else has a share lock on it, check to see
1329 if ((GET_DENY_MODE(share_entry->share_mode) != DENY_DOS) ||
1330 (share_entry->pid != pid))
1337 SAFE_FREE(old_shares);
1338 num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
1340 } while(broke_oplock);
1343 /* XXXX exactly what share mode combinations should be allowed for
1344 deleting/renaming? */
1346 * If we got here then either there were no share modes or
1347 * all share modes were DENY_DOS and the pid == getpid() or
1348 * delete access was requested and all share modes had the
1349 * ALLOW_SHARE_DELETE bit set (takes precedence over other
1357 unlock_share_entry(conn, dev, inode);
1358 SAFE_FREE(old_shares);