2 Unix SMB/Netbios implementation.
4 file opening and share modes
5 Copyright (C) Andrew Tridgell 1992-1998
6 Copyright (C) Jeremy Allison 2001
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 extern userdom_struct current_user_info;
26 extern uint16 global_oplock_port;
27 extern BOOL global_client_failed_oplock_break;
29 /****************************************************************************
30 fd support routines - attempt to do a dos_open.
31 ****************************************************************************/
33 static int fd_open(struct connection_struct *conn, char *fname,
34 int flags, mode_t mode)
40 fd = conn->vfs_ops.open(conn,fname,flags,mode);
42 /* Fix for files ending in '.' */
43 if((fd == -1) && (errno == ENOENT) &&
44 (strchr_m(fname,'.')==NULL)) {
46 fd = conn->vfs_ops.open(conn,fname,flags,mode);
49 DEBUG(10,("fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s\n", fname,
50 flags, (int)mode, fd, (fd == -1) ? strerror(errno) : "" ));
55 /****************************************************************************
56 Close the file associated with a fsp.
57 ****************************************************************************/
59 int fd_close(struct connection_struct *conn, files_struct *fsp)
63 return fd_close_posix(conn, fsp);
67 /****************************************************************************
68 Check a filename for the pipe string.
69 ****************************************************************************/
71 static void check_for_pipe(char *fname)
73 /* special case of pipe opens */
75 StrnCpy(s,fname,sizeof(s)-1);
77 if (strstr(s,"pipe/")) {
78 DEBUG(3,("Rejecting named pipe open for %s\n",fname));
79 unix_ERR_class = ERRSRV;
80 unix_ERR_code = ERRaccess;
84 /****************************************************************************
86 ****************************************************************************/
88 static BOOL open_file(files_struct *fsp,connection_struct *conn,
89 char *fname1,SMB_STRUCT_STAT *psbuf,int flags,mode_t mode)
91 extern struct current_user current_user;
93 int accmode = (flags & O_ACCMODE);
94 int local_flags = flags;
97 fsp->oplock_type = NO_OPLOCK;
100 pstrcpy(fname,fname1);
102 /* Check permissions */
105 * This code was changed after seeing a client open request
106 * containing the open mode of (DENY_WRITE/read-only) with
107 * the 'create if not exist' bit set. The previous code
108 * would fail to open the file read only on a read-only share
109 * as it was checking the flags parameter directly against O_RDONLY,
110 * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
114 if (!CAN_WRITE(conn)) {
115 /* It's a read-only share - fail if we wanted to write. */
116 if(accmode != O_RDONLY) {
117 DEBUG(3,("Permission denied opening %s\n",fname));
118 check_for_pipe(fname);
120 } else if(flags & O_CREAT) {
121 /* We don't want to write - but we must make sure that O_CREAT
122 doesn't create the file if we have write access into the
130 * This little piece of insanity is inspired by the
131 * fact that an NT client can open a file for O_RDONLY,
132 * but set the create disposition to FILE_EXISTS_TRUNCATE.
133 * If the client *can* write to the file, then it expects to
134 * truncate the file, even though it is opening for readonly.
135 * Quicken uses this stupid trick in backup file creation...
136 * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
137 * for helping track this one down. It didn't bite us in 2.0.x
138 * as we always opened files read-write in that release. JRA.
141 if ((accmode == O_RDONLY) && ((flags & O_TRUNC) == O_TRUNC))
142 local_flags = (flags & ~O_ACCMODE)|O_RDWR;
145 * We can't actually truncate here as the file may be locked.
146 * open_file_shared will take care of the truncate later. JRA.
149 local_flags &= ~O_TRUNC;
151 /* actually do the open */
152 fsp->fd = fd_open(conn, fname, local_flags, mode);
155 DEBUG(3,("Error opening file %s (%s) (local_flags=%d) (flags=%d)\n",
156 fname,strerror(errno),local_flags,flags));
157 check_for_pipe(fname);
161 if (!VALID_STAT(*psbuf)) {
162 if (vfs_fstat(fsp,fsp->fd,psbuf) == -1) {
163 DEBUG(0,("Error doing fstat on open file %s (%s)\n", fname,strerror(errno) ));
170 * POSIX allows read-only opens of directories. We don't
171 * want to do this (we use a different code path for this)
172 * so catch a directory open and return an EISDIR. JRA.
175 if(S_ISDIR(psbuf->st_mode)) {
181 fsp->mode = psbuf->st_mode;
182 fsp->inode = psbuf->st_ino;
183 fsp->dev = psbuf->st_dev;
184 fsp->vuid = current_user.vuid;
185 fsp->size = psbuf->st_size;
187 fsp->can_lock = True;
188 fsp->can_read = ((flags & O_WRONLY)==0);
189 fsp->can_write = ((flags & (O_WRONLY|O_RDWR))!=0);
191 fsp->print_file = False;
192 fsp->modified = False;
193 fsp->oplock_type = NO_OPLOCK;
194 fsp->sent_oplock_break = NO_BREAK_SENT;
195 fsp->is_directory = False;
196 fsp->stat_open = False;
197 fsp->directory_delete_on_close = False;
199 string_set(&fsp->fsp_name,fname);
200 fsp->wcp = NULL; /* Write cache pointer. */
202 DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
203 *current_user_info.smb_name ? current_user_info.smb_name : conn->user,fsp->fsp_name,
204 BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
205 conn->num_files_open + 1));
210 /****************************************************************************
212 Helper for open_file_shared.
213 Truncate a file after checking locking; close file if locked.
214 **************************************************************************/
216 static int truncate_unless_locked(struct connection_struct *conn, files_struct *fsp)
218 SMB_BIG_UINT mask = (SMB_BIG_UINT)-1;
220 if (is_locked(fsp,fsp->conn,mask,0,WRITE_LOCK,True)){
222 unix_ERR_class = ERRDOS;
223 unix_ERR_code = ERRlock;
226 return conn->vfs_ops.ftruncate(fsp,fsp->fd,0);
230 /*******************************************************************
231 return True if the filename is one of the special executable types
232 ********************************************************************/
233 static BOOL is_executable(const char *fname)
235 if ((fname = strrchr_m(fname,'.'))) {
236 if (strequal(fname,".com") ||
237 strequal(fname,".dll") ||
238 strequal(fname,".exe") ||
239 strequal(fname,".sym")) {
246 enum {AFAIL,AREAD,AWRITE,AALL};
248 /*******************************************************************
249 reproduce the share mode access table
250 this is horrendoously complex, and really can't be justified on any
251 rational grounds except that this is _exactly_ what NT does. See
252 the DENY1 and DENY2 tests in smbtorture for a comprehensive set of
254 ********************************************************************/
255 static int access_table(int new_deny,int old_deny,int old_mode,
256 BOOL same_pid, BOOL isexe)
258 if (new_deny == DENY_ALL || old_deny == DENY_ALL) return(AFAIL);
261 if (isexe && old_mode == DOS_OPEN_RDONLY &&
262 old_deny == DENY_DOS && new_deny == DENY_READ) {
265 if (!isexe && old_mode == DOS_OPEN_RDONLY &&
266 old_deny == DENY_DOS && new_deny == DENY_DOS) {
269 if (new_deny == DENY_FCB && old_deny == DENY_DOS) {
270 if (isexe) return AFAIL;
271 if (old_mode == DOS_OPEN_RDONLY) return AFAIL;
274 if (old_mode == DOS_OPEN_RDONLY && old_deny == DENY_DOS) {
275 if (new_deny == DENY_FCB || new_deny == DENY_READ) {
276 if (isexe) return AREAD;
280 if (old_deny == DENY_FCB) {
281 if (new_deny == DENY_DOS || new_deny == DENY_FCB) return AALL;
286 if (old_deny == DENY_DOS || new_deny == DENY_DOS ||
287 old_deny == DENY_FCB || new_deny == DENY_FCB) {
289 if (old_deny == DENY_FCB || new_deny == DENY_FCB) {
292 if (old_deny == DENY_DOS) {
293 if (new_deny == DENY_READ &&
294 (old_mode == DOS_OPEN_RDONLY ||
295 old_mode == DOS_OPEN_RDWR)) {
298 if (new_deny == DENY_WRITE &&
299 (old_mode == DOS_OPEN_WRONLY ||
300 old_mode == DOS_OPEN_RDWR)) {
305 if (old_deny == DENY_NONE) return AALL;
306 if (old_deny == DENY_READ) return AWRITE;
307 if (old_deny == DENY_WRITE) return AREAD;
309 /* it isn't a exe, dll, sym or com file */
310 if (old_deny == new_deny && same_pid)
313 if (old_deny == DENY_READ || new_deny == DENY_READ) return AFAIL;
314 if (old_mode == DOS_OPEN_RDONLY) return(AREAD);
322 if (old_deny==DENY_WRITE && old_mode==DOS_OPEN_RDONLY) return(AREAD);
323 if (old_deny==DENY_READ && old_mode==DOS_OPEN_RDONLY) return(AWRITE);
324 if (old_deny==DENY_NONE && old_mode==DOS_OPEN_RDONLY) return(AALL);
327 if (old_deny==DENY_WRITE && old_mode==DOS_OPEN_WRONLY) return(AREAD);
328 if (old_deny==DENY_READ && old_mode==DOS_OPEN_WRONLY) return(AWRITE);
329 if (old_deny==DENY_NONE && old_mode==DOS_OPEN_WRONLY) return(AALL);
332 if (old_deny==DENY_WRITE) return(AREAD);
333 if (old_deny==DENY_READ) return(AWRITE);
334 if (old_deny==DENY_NONE) return(AALL);
341 /****************************************************************************
342 check if we can open a file with a share mode
343 ****************************************************************************/
345 static BOOL check_share_mode(connection_struct *conn, share_mode_entry *share, int share_mode,
346 const char *fname, BOOL fcbopen, int *flags)
348 int deny_mode = GET_DENY_MODE(share_mode);
349 int old_open_mode = GET_OPEN_MODE(share->share_mode);
350 int old_deny_mode = GET_DENY_MODE(share->share_mode);
353 * share modes = false means don't bother to check for
354 * DENY mode conflict. This is a *really* bad idea :-). JRA.
357 if(!lp_share_modes(SNUM(conn)))
361 * Don't allow any opens once the delete on close flag has been
365 if (GET_DELETE_ON_CLOSE_FLAG(share->share_mode)) {
366 DEBUG(5,("check_share_mode: Failing open on file %s as delete on close flag is set.\n",
368 unix_ERR_class = ERRDOS;
369 unix_ERR_code = ERRnoaccess;
374 * If delete access was requested and the existing share mode doesn't have
375 * ALLOW_SHARE_DELETE then deny.
378 if (GET_DELETE_ACCESS_REQUESTED(share_mode) && !GET_ALLOW_SHARE_DELETE(share->share_mode)) {
379 DEBUG(5,("check_share_mode: Failing open on file %s as delete access requested and allow share delete not set.\n",
381 unix_ERR_class = ERRDOS;
382 unix_ERR_code = ERRbadshare;
388 * The inverse of the above.
389 * If delete access was granted and the new share mode doesn't have
390 * ALLOW_SHARE_DELETE then deny.
393 if (GET_DELETE_ACCESS_REQUESTED(share->share_mode) && !GET_ALLOW_SHARE_DELETE(share_mode)) {
394 DEBUG(5,("check_share_mode: Failing open on file %s as delete access granted and allow share delete not requested.\n",
396 unix_ERR_class = ERRDOS;
397 unix_ERR_code = ERRbadshare;
403 int access_allowed = access_table(deny_mode,old_deny_mode,old_open_mode,
404 (share->pid == sys_getpid()),is_executable(fname));
406 if ((access_allowed == AFAIL) ||
407 (!fcbopen && (access_allowed == AREAD && *flags == O_RDWR)) ||
408 (access_allowed == AREAD && *flags != O_RDONLY) ||
409 (access_allowed == AWRITE && *flags != O_WRONLY)) {
411 DEBUG(2,("Share violation on file (%d,%d,%d,%d,%s,fcbopen = %d, flags = %d) = %d\n",
412 deny_mode,old_deny_mode,old_open_mode,
413 (int)share->pid,fname, fcbopen, *flags, access_allowed));
415 unix_ERR_class = ERRDOS;
416 unix_ERR_code = ERRbadshare;
421 if (access_allowed == AREAD)
424 if (access_allowed == AWRITE)
432 /****************************************************************************
433 Deal with open deny mode and oplock break processing.
434 Invarient: Share mode must be locked on entry and exit.
435 Returns -1 on error, or number of share modes on success (may be zero).
436 ****************************************************************************/
438 static int open_mode_check(connection_struct *conn, const char *fname, SMB_DEV_T dev,
439 SMB_INO_T inode, int share_mode, int *p_flags, int *p_oplock_request,
440 BOOL *p_all_current_opens_are_level_II)
444 int oplock_contention_count = 0;
445 share_mode_entry *old_shares = 0;
446 BOOL fcbopen = False;
449 if(GET_OPEN_MODE(share_mode) == DOS_OPEN_FCB)
452 num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
454 if(num_share_modes == 0)
458 * Check if the share modes will give us access.
462 share_mode_entry broken_entry;
464 broke_oplock = False;
465 *p_all_current_opens_are_level_II = True;
467 for(i = 0; i < num_share_modes; i++) {
468 share_mode_entry *share_entry = &old_shares[i];
471 * By observation of NetBench, oplocks are broken *before* share
472 * modes are checked. This allows a file to be closed by the client
473 * if the share mode would deny access and the client has an oplock.
474 * Check if someone has an oplock on this file. If so we must break
475 * it before continuing.
478 if((*p_oplock_request && EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type)) ||
479 (!*p_oplock_request && (share_entry->op_type != NO_OPLOCK))) {
483 DEBUG(5,("open_mode_check: oplock_request = %d, breaking oplock (%x) on file %s, \
484 dev = %x, inode = %.0f\n", *p_oplock_request, share_entry->op_type, fname, (unsigned int)dev, (double)inode));
486 /* Oplock break - unlock to request it. */
487 unlock_share_entry(conn, dev, inode);
489 opb_ret = request_oplock_break(share_entry);
492 lock_share_entry(conn, dev, inode);
494 if(opb_ret == False) {
495 DEBUG(0,("open_mode_check: FAILED when breaking oplock (%x) on file %s, \
496 dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
497 SAFE_FREE(old_shares);
499 unix_ERR_class = ERRDOS;
500 unix_ERR_code = ERRbadshare;
505 broken_entry = *share_entry;
508 } else if (!LEVEL_II_OPLOCK_TYPE(share_entry->op_type)) {
509 *p_all_current_opens_are_level_II = False;
512 /* someone else has a share lock on it, check to see
515 if(check_share_mode(conn, share_entry, share_mode, fname, fcbopen, p_flags) == False) {
516 SAFE_FREE(old_shares);
524 SAFE_FREE(old_shares);
525 num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
526 oplock_contention_count++;
528 /* Paranoia check that this is no longer an exlusive entry. */
529 for(i = 0; i < num_share_modes; i++) {
530 share_mode_entry *share_entry = &old_shares[i];
532 if (share_modes_identical(&broken_entry, share_entry) &&
533 EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type) ) {
536 * This should not happen. The target left this oplock
537 * as exlusive.... The process *must* be dead....
540 DEBUG(0,("open_mode_check: exlusive oplock left by process %d after break ! For file %s, \
541 dev = %x, inode = %.0f. Deleting it to continue...\n", (int)broken_entry.pid, fname, (unsigned int)dev, (double)inode));
543 if (process_exists(broken_entry.pid)) {
544 DEBUG(0,("open_mode_check: Existent process %d left active oplock.\n",
548 if (del_share_entry(dev, inode, &broken_entry, NULL) == -1) {
550 unix_ERR_class = ERRDOS;
551 unix_ERR_code = ERRbadshare;
556 * We must reload the share modes after deleting the
557 * other process's entry.
560 SAFE_FREE(old_shares);
561 num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
564 } /* end for paranoia... */
565 } /* end if broke_oplock */
567 } while(broke_oplock);
570 SAFE_FREE(old_shares);
573 * Refuse to grant an oplock in case the contention limit is
574 * reached when going through the lock list multiple times.
577 if(oplock_contention_count >= lp_oplock_contention_limit(SNUM(conn))) {
578 *p_oplock_request = 0;
579 DEBUG(4,("open_mode_check: oplock contention = %d. Not granting oplock.\n",
580 oplock_contention_count ));
583 return num_share_modes;
586 /****************************************************************************
587 set a kernel flock on a file for NFS interoperability
588 this requires a patch to Linux
589 ****************************************************************************/
590 static void kernel_flock(files_struct *fsp, int deny_mode)
592 #if HAVE_KERNEL_SHARE_MODES
594 if (deny_mode == DENY_READ) kernel_mode = LOCK_MAND|LOCK_WRITE;
595 else if (deny_mode == DENY_WRITE) kernel_mode = LOCK_MAND|LOCK_READ;
596 else if (deny_mode == DENY_ALL) kernel_mode = LOCK_MAND;
597 if (kernel_mode) flock(fsp->fd, kernel_mode);
603 /****************************************************************************
604 Open a file with a share mode. On output from this open we are guarenteeing
606 ****************************************************************************/
607 files_struct *open_file_shared(connection_struct *conn,char *fname, SMB_STRUCT_STAT *psbuf,
608 int share_mode,int ofun, mode_t mode,int oplock_request,
609 int *Access,int *action)
613 int deny_mode = GET_DENY_MODE(share_mode);
614 BOOL allow_share_delete = GET_ALLOW_SHARE_DELETE(share_mode);
615 BOOL delete_access_requested = GET_DELETE_ACCESS_REQUESTED(share_mode);
616 BOOL delete_on_close = GET_DELETE_ON_CLOSE_FLAG(share_mode);
617 BOOL file_existed = VALID_STAT(*psbuf);
618 BOOL fcbopen = False;
621 int num_share_modes = 0;
622 BOOL all_current_opens_are_level_II = False;
623 BOOL fsp_open = False;
624 files_struct *fsp = NULL;
629 /* printers are handled completely differently. Most of the passed parameters are
631 *Access = DOS_OPEN_WRONLY;
632 *action = FILE_WAS_CREATED;
633 return print_fsp_open(conn);
636 fsp = file_new(conn);
640 DEBUG(10,("open_file_shared: fname = %s, share_mode = %x, ofun = %x, mode = %o, oplock request = %d\n",
641 fname, share_mode, ofun, (int)mode, oplock_request ));
643 if (!check_name(fname,conn)) {
648 /* ignore any oplock requests if oplocks are disabled */
649 if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break) {
653 /* this is for OS/2 EAs - try and say we don't support them */
654 if (strstr(fname,".+,;=[].")) {
655 unix_ERR_class = ERRDOS;
656 /* OS/2 Workplace shell fix may be main code stream in a later release. */
657 #if 1 /* OS2_WPS_FIX - Recent versions of OS/2 need this. */
658 unix_ERR_code = ERRcannotopen;
659 #else /* OS2_WPS_FIX */
660 unix_ERR_code = ERROR_EAS_NOT_SUPPORTED;
661 #endif /* OS2_WPS_FIX */
663 DEBUG(5,("open_file_shared: OS/2 EA's are not supported.\n"));
668 if ((GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL) && file_existed) {
669 DEBUG(5,("open_file_shared: create new requested for file %s and file already exists.\n",
676 if (CAN_WRITE(conn) && (GET_FILE_CREATE_DISPOSITION(ofun) == FILE_CREATE_IF_NOT_EXIST))
679 if (CAN_WRITE(conn) && (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_TRUNCATE))
682 if (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL)
685 /* note that we ignore the append flag as
686 append does not mean the same thing under dos and unix */
688 switch (GET_OPEN_MODE(share_mode)) {
689 case DOS_OPEN_WRONLY:
705 if (GET_FILE_SYNC_OPENMODE(share_mode)) {
710 if (flags != O_RDONLY && file_existed &&
711 (!CAN_WRITE(conn) || IS_DOS_READONLY(dos_mode(conn,fname,psbuf)))) {
713 DEBUG(5,("open_file_shared: read/write access requested for file %s on read only %s\n",
714 fname, !CAN_WRITE(conn) ? "share" : "file" ));
722 if (deny_mode > DENY_NONE && deny_mode!=DENY_FCB) {
723 DEBUG(2,("Invalid deny mode %d on file %s\n",deny_mode,fname));
732 inode = psbuf->st_ino;
734 lock_share_entry(conn, dev, inode);
736 num_share_modes = open_mode_check(conn, fname, dev, inode, share_mode,
737 &flags, &oplock_request, &all_current_opens_are_level_II);
738 if(num_share_modes == -1) {
741 * This next line is a subtlety we need for MS-Access. If a file open will
742 * fail due to share permissions and also for security (access)
743 * reasons, we need to return the access failed error, not the
744 * share error. This means we must attempt to open the file anyway
745 * in order to get the UNIX access error - even if we're going to
746 * fail the open for share reasons. This is bad, as we're burning
747 * another fd if there are existing locks but there's nothing else
748 * we can do. We also ensure we're not going to create or tuncate
749 * the file as we only want an access decision at this stage. JRA.
751 fsp_open = open_file(fsp,conn,fname,psbuf,flags|(flags2&~(O_TRUNC|O_CREAT)),mode);
753 DEBUG(4,("open_file_shared : share_mode deny - calling open_file with \
754 flags=0x%X flags2=0x%X mode=0%o returned %d\n",
755 flags,(flags2&~(O_TRUNC|O_CREAT)),(int)mode,(int)fsp_open ));
757 unlock_share_entry(conn, dev, inode);
765 * We exit this block with the share entry *locked*.....
769 DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
770 flags,flags2,(int)mode));
773 * open_file strips any O_TRUNC flags itself.
776 fsp_open = open_file(fsp,conn,fname,psbuf,flags|flags2,mode);
778 if (!fsp_open && (flags == O_RDWR) && (errno != ENOENT) && fcbopen) {
779 if((fsp_open = open_file(fsp,conn,fname,psbuf,O_RDONLY,mode)) == True)
785 unlock_share_entry(conn, dev, inode);
791 * Deal with the race condition where two smbd's detect the file doesn't
792 * exist and do the create at the same time. One of them will win and
793 * set a share mode, the other (ie. this one) should check if the
794 * requested share mode for this create is allowed.
799 lock_share_entry_fsp(fsp);
801 num_share_modes = open_mode_check(conn, fname, dev, inode, share_mode,
802 &flags, &oplock_request, &all_current_opens_are_level_II);
804 if(num_share_modes == -1) {
805 unlock_share_entry_fsp(fsp);
812 * If there are any share modes set then the file *did*
813 * exist. Ensure we return the correct value for action.
816 if (num_share_modes > 0)
820 * We exit this block with the share entry *locked*.....
824 /* note that we ignore failure for the following. It is
825 basically a hack for NFS, and NFS will never set one of
826 these only read them. Nobody but Samba can ever set a deny
827 mode and we have already checked our more authoritative
828 locking database for permission to set this deny mode. If
829 the kernel refuses the operations then the kernel is wrong */
830 kernel_flock(fsp, deny_mode);
833 * At this point onwards, we can guarentee that the share entry
834 * is locked, whether we created the file or not, and that the
835 * deny mode is compatible with all current opens.
839 * If requested, truncate the file.
842 if (flags2&O_TRUNC) {
844 * We are modifing the file after open - update the stat struct..
846 if ((truncate_unless_locked(conn,fsp) == -1) || (vfs_fstat(fsp,fsp->fd,psbuf)==-1)) {
847 unlock_share_entry_fsp(fsp);
856 open_mode = DOS_OPEN_RDONLY;
859 open_mode = DOS_OPEN_RDWR;
862 open_mode = DOS_OPEN_WRONLY;
866 fsp->share_mode = SET_DENY_MODE(deny_mode) |
867 SET_OPEN_MODE(open_mode) |
868 SET_ALLOW_SHARE_DELETE(allow_share_delete) |
869 SET_DELETE_ACCESS_REQUESTED(delete_access_requested);
871 DEBUG(10,("open_file_shared : share_mode = %x\n", fsp->share_mode ));
874 (*Access) = open_mode;
877 if (file_existed && !(flags2 & O_TRUNC))
878 *action = FILE_WAS_OPENED;
880 *action = FILE_WAS_CREATED;
881 if (file_existed && (flags2 & O_TRUNC))
882 *action = FILE_WAS_OVERWRITTEN;
886 * Setup the oplock info in both the shared memory and
890 if(oplock_request && (num_share_modes == 0) &&
891 !IS_VETO_OPLOCK_PATH(conn,fname) && set_file_oplock(fsp, oplock_request) ) {
892 port = global_oplock_port;
893 } else if (oplock_request && all_current_opens_are_level_II) {
894 port = global_oplock_port;
895 oplock_request = LEVEL_II_OPLOCK;
896 set_file_oplock(fsp, oplock_request);
902 set_share_mode(fsp, port, oplock_request);
904 if (delete_on_close) {
905 NTSTATUS result = set_delete_on_close_internal(fsp, delete_on_close);
907 if (NT_STATUS_V(result) != NT_STATUS_V(NT_STATUS_OK)) {
908 unlock_share_entry_fsp(fsp);
916 * Take care of inherited ACLs on created files. JRA.
919 if (!file_existed && (conn->vfs_ops.fchmod_acl != NULL)) {
920 int saved_errno = errno; /* We might get ENOSYS in the next call.. */
921 if (conn->vfs_ops.fchmod_acl(fsp, fsp->fd, mode) == -1 && errno == ENOSYS)
922 errno = saved_errno; /* Ignore ENOSYS */
925 unlock_share_entry_fsp(fsp);
927 conn->num_files_open++;
932 /****************************************************************************
933 Open a file for permissions read only. Return a pseudo file entry
934 with the 'stat_open' flag set
935 ****************************************************************************/
937 files_struct *open_file_stat(connection_struct *conn, char *fname,
938 SMB_STRUCT_STAT *psbuf, int smb_ofun, int *action)
940 extern struct current_user current_user;
941 files_struct *fsp = NULL;
943 if (!VALID_STAT(*psbuf)) {
944 DEBUG(0,("open_file_stat: unable to stat name = %s. Error was %s\n", fname, strerror(errno) ));
948 if(S_ISDIR(psbuf->st_mode)) {
949 DEBUG(0,("open_file_stat: %s is a directory !\n", fname ));
953 fsp = file_new(conn);
957 *action = FILE_WAS_OPENED;
959 DEBUG(5,("open_file_stat: opening file %s as a stat entry\n", fname));
962 * Setup the files_struct for it.
965 fsp->mode = psbuf->st_mode;
966 fsp->inode = psbuf->st_ino;
967 fsp->dev = psbuf->st_dev;
968 fsp->size = psbuf->st_size;
969 fsp->vuid = current_user.vuid;
971 fsp->can_lock = False;
972 fsp->can_read = False;
973 fsp->can_write = False;
975 fsp->print_file = False;
976 fsp->modified = False;
977 fsp->oplock_type = NO_OPLOCK;
978 fsp->sent_oplock_break = NO_BREAK_SENT;
979 fsp->is_directory = False;
980 fsp->stat_open = True;
981 fsp->directory_delete_on_close = False;
983 string_set(&fsp->fsp_name,fname);
984 fsp->wcp = NULL; /* Write cache pointer. */
986 conn->num_files_open++;
991 /****************************************************************************
992 Open a file for for write to ensure that we can fchmod it.
993 ****************************************************************************/
995 files_struct *open_file_fchmod(connection_struct *conn, char *fname, SMB_STRUCT_STAT *psbuf)
997 files_struct *fsp = NULL;
1000 if (!VALID_STAT(*psbuf))
1003 fsp = file_new(conn);
1007 fsp_open = open_file(fsp,conn,fname,psbuf,O_WRONLY,0);
1010 * This is not a user visible file open.
1011 * Don't set a share mode and don't increment
1012 * the conn->num_files_open.
1023 /****************************************************************************
1024 Close the fchmod file fd - ensure no locks are lost.
1025 ****************************************************************************/
1027 int close_file_fchmod(files_struct *fsp)
1029 int ret = fd_close(fsp->conn, fsp);
1034 /****************************************************************************
1035 Open a directory from an NT SMB call.
1036 ****************************************************************************/
1038 files_struct *open_directory(connection_struct *conn, char *fname,
1039 SMB_STRUCT_STAT *psbuf, int share_mode, int smb_ofun, mode_t unixmode, int *action)
1041 extern struct current_user current_user;
1042 BOOL got_stat = False;
1043 files_struct *fsp = file_new(conn);
1044 BOOL delete_on_close = GET_DELETE_ON_CLOSE_FLAG(share_mode);
1049 fsp->conn = conn; /* The vfs_fXXX() macros need this. */
1051 if (VALID_STAT(*psbuf))
1054 if (got_stat && (GET_FILE_OPEN_DISPOSITION(smb_ofun) == FILE_EXISTS_FAIL)) {
1056 errno = EEXIST; /* Setup so correct error is returned to client. */
1060 if (GET_FILE_CREATE_DISPOSITION(smb_ofun) == FILE_CREATE_IF_NOT_EXIST) {
1064 if(!S_ISDIR(psbuf->st_mode)) {
1065 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1070 *action = FILE_WAS_OPENED;
1075 * Try and create the directory.
1078 if(!CAN_WRITE(conn)) {
1079 DEBUG(2,("open_directory: failing create on read-only share\n"));
1085 if(vfs_mkdir(conn,fname, unix_mode(conn,aDIR, fname)) < 0) {
1086 DEBUG(2,("open_directory: unable to create %s. Error was %s\n",
1087 fname, strerror(errno) ));
1092 if(vfs_stat(conn,fname, psbuf) != 0) {
1097 *action = FILE_WAS_CREATED;
1103 * Don't create - just check that it *was* a directory.
1107 DEBUG(0,("open_directory: unable to stat name = %s. Error was %s\n",
1108 fname, strerror(errno) ));
1113 if(!S_ISDIR(psbuf->st_mode)) {
1114 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1119 *action = FILE_WAS_OPENED;
1122 DEBUG(5,("open_directory: opening directory %s\n", fname));
1125 * Setup the files_struct for it.
1128 fsp->mode = psbuf->st_mode;
1129 fsp->inode = psbuf->st_ino;
1130 fsp->dev = psbuf->st_dev;
1131 fsp->size = psbuf->st_size;
1132 fsp->vuid = current_user.vuid;
1134 fsp->can_lock = True;
1135 fsp->can_read = False;
1136 fsp->can_write = False;
1137 fsp->share_mode = share_mode;
1138 fsp->print_file = False;
1139 fsp->modified = False;
1140 fsp->oplock_type = NO_OPLOCK;
1141 fsp->sent_oplock_break = NO_BREAK_SENT;
1142 fsp->is_directory = True;
1143 fsp->directory_delete_on_close = False;
1145 string_set(&fsp->fsp_name,fname);
1147 if (delete_on_close) {
1148 NTSTATUS result = set_delete_on_close_internal(fsp, delete_on_close);
1150 if (NT_STATUS_V(result) != NT_STATUS_V(NT_STATUS_OK)) {
1155 conn->num_files_open++;
1160 /*******************************************************************
1161 Check if the share mode on a file allows it to be deleted or unlinked.
1162 Return True if sharing doesn't prevent the operation.
1163 ********************************************************************/
1165 BOOL check_file_sharing(connection_struct *conn,char *fname, BOOL rename_op)
1169 share_mode_entry *old_shares = 0;
1170 int num_share_modes;
1171 SMB_STRUCT_STAT sbuf;
1172 pid_t pid = sys_getpid();
1176 if (vfs_stat(conn,fname,&sbuf) == -1)
1180 inode = sbuf.st_ino;
1182 lock_share_entry(conn, dev, inode);
1183 num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
1186 * Check if the share modes will give us access.
1189 if(num_share_modes != 0)
1196 broke_oplock = False;
1197 for(i = 0; i < num_share_modes; i++)
1199 share_mode_entry *share_entry = &old_shares[i];
1202 * Break oplocks before checking share modes. See comment in
1203 * open_file_shared for details.
1204 * Check if someone has an oplock on this file. If so we must
1205 * break it before continuing.
1207 if(BATCH_OPLOCK_TYPE(share_entry->op_type))
1212 /* JRA. Try removing this code to see if the new oplock changes
1213 fix the problem. I'm dubious, but Andrew is recommending we
1218 * It appears that the NT redirector may have a bug, in that
1219 * it tries to do an SMBmv on a file that it has open with a
1220 * batch oplock, and then fails to respond to the oplock break
1221 * request. This only seems to occur when the client is doing an
1222 * SMBmv to the smbd it is using - thus we try and detect this
1223 * condition by checking if the file being moved is open and oplocked by
1224 * this smbd process, and then not sending the oplock break in this
1225 * special case. If the file was open with a deny mode that
1226 * prevents the move the SMBmv will fail anyway with a share
1227 * violation error. JRA.
1229 if(rename_op && (share_entry->pid == pid))
1232 DEBUG(0,("check_file_sharing: NT redirector workaround - rename attempted on \
1233 batch oplocked file %s, dev = %x, inode = %.0f\n", fname, (unsigned int)dev, (double)inode));
1236 * This next line is a test that allows the deny-mode
1237 * processing to be skipped. This seems to be needed as
1238 * NT insists on the rename succeeding (in Office 9x no less !).
1239 * This should be removed as soon as (a) MS fix the redirector
1240 * bug or (b) NT SMB support in Samba makes NT not issue the
1241 * call (as is my fervent hope). JRA.
1249 DEBUG(5,("check_file_sharing: breaking oplock (%x) on file %s, \
1250 dev = %x, inode = %.0f\n", share_entry->op_type, fname, (unsigned int)dev, (double)inode));
1252 /* Oplock break.... */
1253 unlock_share_entry(conn, dev, inode);
1254 if(request_oplock_break(share_entry) == False)
1256 DEBUG(0,("check_file_sharing: FAILED when breaking oplock (%x) on file %s, \
1257 dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
1259 SAFE_FREE(old_shares);
1262 lock_share_entry(conn, dev, inode);
1263 broke_oplock = True;
1269 * If this is a delete request and ALLOW_SHARE_DELETE is set then allow
1270 * this to proceed. This takes precedence over share modes.
1273 if(!rename_op && GET_ALLOW_SHARE_DELETE(share_entry->share_mode))
1277 * Someone else has a share lock on it, check to see
1281 if ((GET_DENY_MODE(share_entry->share_mode) != DENY_DOS) ||
1282 (share_entry->pid != pid))
1289 SAFE_FREE(old_shares);
1290 num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
1292 } while(broke_oplock);
1295 /* XXXX exactly what share mode combinations should be allowed for
1296 deleting/renaming? */
1298 * If we got here then either there were no share modes or
1299 * all share modes were DENY_DOS and the pid == getpid() or
1300 * delete access was requested and all share modes had the
1301 * ALLOW_SHARE_DELETE bit set (takes precedence over other
1309 unlock_share_entry(conn, dev, inode);
1310 SAFE_FREE(old_shares);