2 Unix SMB/Netbios implementation.
4 file opening and share modes
5 Copyright (C) Andrew Tridgell 1992-1998
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 int DEBUGLEVEL;
26 extern userdom_struct current_user_info;
27 extern uint16 global_oplock_port;
28 extern BOOL global_client_failed_oplock_break;
30 /****************************************************************************
31 fd support routines - attempt to do a dos_open.
32 ****************************************************************************/
34 static int fd_open(struct connection_struct *conn, char *fname,
35 int flags, mode_t mode)
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 GetTimeOfDay(&fsp->open_time);
186 fsp->vuid = current_user.vuid;
187 fsp->size = psbuf->st_size;
189 fsp->can_lock = True;
190 fsp->can_read = ((flags & O_WRONLY)==0);
191 fsp->can_write = ((flags & (O_WRONLY|O_RDWR))!=0);
193 fsp->print_file = False;
194 fsp->modified = False;
195 fsp->oplock_type = NO_OPLOCK;
196 fsp->sent_oplock_break = NO_BREAK_SENT;
197 fsp->is_directory = False;
198 fsp->stat_open = False;
199 fsp->directory_delete_on_close = False;
201 string_set(&fsp->fsp_name,fname);
202 fsp->wbmpx_ptr = NULL;
203 fsp->wcp = NULL; /* Write cache pointer. */
205 DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
206 *current_user_info.smb_name ? current_user_info.smb_name : conn->user,fsp->fsp_name,
207 BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
208 conn->num_files_open + 1));
211 * Take care of inherited ACLs on created files. JRA.
214 if ((flags & O_CREAT) && (conn->vfs_ops.fchmod_acl != NULL)) {
215 int saved_errno = errno; /* We might get ENOSYS in the next call.. */
216 if (conn->vfs_ops.fchmod_acl(fsp, fsp->fd, mode) == -1 && errno == ENOSYS)
217 errno = saved_errno; /* Ignore ENOSYS */
223 /****************************************************************************
225 Helper for open_file_shared.
226 Truncate a file after checking locking; close file if locked.
227 **************************************************************************/
229 static int truncate_unless_locked(struct connection_struct *conn, files_struct *fsp)
231 SMB_BIG_UINT mask = (SMB_BIG_UINT)-1;
233 if (is_locked(fsp,fsp->conn,mask,0,WRITE_LOCK,True)){
235 unix_ERR_class = ERRDOS;
236 unix_ERR_code = ERRlock;
239 return conn->vfs_ops.ftruncate(fsp,fsp->fd,0);
243 /*******************************************************************
244 return True if the filename is one of the special executable types
245 ********************************************************************/
246 static BOOL is_executable(const char *fname)
248 if ((fname = strrchr_m(fname,'.'))) {
249 if (strequal(fname,".com") ||
250 strequal(fname,".dll") ||
251 strequal(fname,".exe") ||
252 strequal(fname,".sym")) {
259 enum {AFAIL,AREAD,AWRITE,AALL};
261 /*******************************************************************
262 reproduce the share mode access table
263 this is horrendoously complex, and really can't be justified on any
264 rational grounds except that this is _exactly_ what NT does. See
265 the DENY1 and DENY2 tests in smbtorture for a comprehensive set of
267 ********************************************************************/
268 static int access_table(int new_deny,int old_deny,int old_mode,
269 BOOL same_pid, BOOL isexe)
271 if (new_deny == DENY_ALL || old_deny == DENY_ALL) return(AFAIL);
274 if (isexe && old_mode == DOS_OPEN_RDONLY &&
275 old_deny == DENY_DOS && new_deny == DENY_READ) {
278 if (!isexe && old_mode == DOS_OPEN_RDONLY &&
279 old_deny == DENY_DOS && new_deny == DENY_DOS) {
282 if (new_deny == DENY_FCB && old_deny == DENY_DOS) {
283 if (isexe) return AFAIL;
284 if (old_mode == DOS_OPEN_RDONLY) return AFAIL;
287 if (old_mode == DOS_OPEN_RDONLY && old_deny == DENY_DOS) {
288 if (new_deny == DENY_FCB || new_deny == DENY_READ) {
289 if (isexe) return AREAD;
293 if (old_deny == DENY_FCB) {
294 if (new_deny == DENY_DOS || new_deny == DENY_FCB) return AALL;
299 if (old_deny == DENY_DOS || new_deny == DENY_DOS ||
300 old_deny == DENY_FCB || new_deny == DENY_FCB) {
302 if (old_deny == DENY_FCB || new_deny == DENY_FCB) {
305 if (old_deny == DENY_DOS) {
306 if (new_deny == DENY_READ &&
307 (old_mode == DOS_OPEN_RDONLY ||
308 old_mode == DOS_OPEN_RDWR)) {
311 if (new_deny == DENY_WRITE &&
312 (old_mode == DOS_OPEN_WRONLY ||
313 old_mode == DOS_OPEN_RDWR)) {
318 if (old_deny == DENY_NONE) return AALL;
319 if (old_deny == DENY_READ) return AWRITE;
320 if (old_deny == DENY_WRITE) return AREAD;
322 /* it isn't a exe, dll, sym or com file */
323 if (old_deny == new_deny && same_pid)
326 if (old_deny == DENY_READ || new_deny == DENY_READ) return AFAIL;
327 if (old_mode == DOS_OPEN_RDONLY) return(AREAD);
335 if (old_deny==DENY_WRITE && old_mode==DOS_OPEN_RDONLY) return(AREAD);
336 if (old_deny==DENY_READ && old_mode==DOS_OPEN_RDONLY) return(AWRITE);
337 if (old_deny==DENY_NONE && old_mode==DOS_OPEN_RDONLY) return(AALL);
340 if (old_deny==DENY_WRITE && old_mode==DOS_OPEN_WRONLY) return(AREAD);
341 if (old_deny==DENY_READ && old_mode==DOS_OPEN_WRONLY) return(AWRITE);
342 if (old_deny==DENY_NONE && old_mode==DOS_OPEN_WRONLY) return(AALL);
345 if (old_deny==DENY_WRITE) return(AREAD);
346 if (old_deny==DENY_READ) return(AWRITE);
347 if (old_deny==DENY_NONE) return(AALL);
354 /****************************************************************************
355 check if we can open a file with a share mode
356 ****************************************************************************/
358 static int check_share_mode( share_mode_entry *share, int share_mode,
359 const char *fname, BOOL fcbopen, int *flags)
361 int deny_mode = GET_DENY_MODE(share_mode);
362 int old_open_mode = GET_OPEN_MODE(share->share_mode);
363 int old_deny_mode = GET_DENY_MODE(share->share_mode);
366 * Don't allow any opens once the delete on close flag has been
370 if (GET_DELETE_ON_CLOSE_FLAG(share->share_mode)) {
371 DEBUG(5,("check_share_mode: Failing open on file %s as delete on close flag is set.\n",
373 unix_ERR_class = ERRDOS;
374 unix_ERR_code = ERRnoaccess;
379 * If delete access was requested and the existing share mode doesn't have
380 * ALLOW_SHARE_DELETE then deny.
383 if (GET_DELETE_ACCESS_REQUESTED(share_mode) && !GET_ALLOW_SHARE_DELETE(share->share_mode)) {
384 DEBUG(5,("check_share_mode: Failing open on file %s as delete access requested and allow share delete not set.\n",
386 unix_ERR_class = ERRDOS;
387 unix_ERR_code = ERRbadshare;
393 * The inverse of the above.
394 * If delete access was granted and the new share mode doesn't have
395 * ALLOW_SHARE_DELETE then deny.
398 if (GET_DELETE_ACCESS_REQUESTED(share->share_mode) && !GET_ALLOW_SHARE_DELETE(share_mode)) {
399 DEBUG(5,("check_share_mode: Failing open on file %s as delete access granted and allow share delete not requested.\n",
401 unix_ERR_class = ERRDOS;
402 unix_ERR_code = ERRbadshare;
408 int access_allowed = access_table(deny_mode,old_deny_mode,old_open_mode,
409 (share->pid == sys_getpid()),is_executable(fname));
411 if ((access_allowed == AFAIL) ||
412 (!fcbopen && (access_allowed == AREAD && *flags == O_RDWR)) ||
413 (access_allowed == AREAD && *flags != O_RDONLY) ||
414 (access_allowed == AWRITE && *flags != O_WRONLY)) {
416 DEBUG(2,("Share violation on file (%d,%d,%d,%d,%s,fcbopen = %d, flags = %d) = %d\n",
417 deny_mode,old_deny_mode,old_open_mode,
418 (int)share->pid,fname, fcbopen, *flags, access_allowed));
420 unix_ERR_class = ERRDOS;
421 unix_ERR_code = ERRbadshare;
426 if (access_allowed == AREAD)
429 if (access_allowed == AWRITE)
437 /****************************************************************************
438 Deal with open deny mode and oplock break processing.
439 Invarient: Share mode must be locked on entry and exit.
440 Returns -1 on error, or number of share modes on success (may be zero).
441 ****************************************************************************/
443 static int open_mode_check(connection_struct *conn, const char *fname, SMB_DEV_T dev,
444 SMB_INO_T inode, int share_mode, int *p_flags, int *p_oplock_request,
445 BOOL *p_all_current_opens_are_level_II)
449 int oplock_contention_count = 0;
450 share_mode_entry *old_shares = 0;
451 BOOL fcbopen = False;
454 if(GET_OPEN_MODE(share_mode) == DOS_OPEN_FCB)
457 num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
459 if(num_share_modes == 0)
463 * Check if the share modes will give us access.
467 share_mode_entry broken_entry;
469 broke_oplock = False;
470 *p_all_current_opens_are_level_II = True;
472 for(i = 0; i < num_share_modes; i++) {
473 share_mode_entry *share_entry = &old_shares[i];
476 * By observation of NetBench, oplocks are broken *before* share
477 * modes are checked. This allows a file to be closed by the client
478 * if the share mode would deny access and the client has an oplock.
479 * Check if someone has an oplock on this file. If so we must break
480 * it before continuing.
483 if((*p_oplock_request && EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type)) ||
484 (!*p_oplock_request && (share_entry->op_type != NO_OPLOCK))) {
488 DEBUG(5,("open_mode_check: oplock_request = %d, breaking oplock (%x) on file %s, \
489 dev = %x, inode = %.0f\n", *p_oplock_request, share_entry->op_type, fname, (unsigned int)dev, (double)inode));
491 /* Oplock break - unlock to request it. */
492 unlock_share_entry(conn, dev, inode);
494 opb_ret = request_oplock_break(share_entry, dev, inode);
497 lock_share_entry(conn, dev, inode);
499 if(opb_ret == False) {
500 free((char *)old_shares);
501 DEBUG(0,("open_mode_check: FAILED when breaking oplock (%x) on file %s, \
502 dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
504 unix_ERR_class = ERRDOS;
505 unix_ERR_code = ERRbadshare;
510 broken_entry = *share_entry;
513 } else if (!LEVEL_II_OPLOCK_TYPE(share_entry->op_type)) {
514 *p_all_current_opens_are_level_II = False;
517 /* someone else has a share lock on it, check to see
520 if(check_share_mode(share_entry, share_mode, fname, fcbopen, p_flags) == False) {
521 free((char *)old_shares);
529 free((char *)old_shares);
530 if (del_share_entry(dev, inode, &broken_entry, NULL) == -1) {
531 DEBUG(0,("open_mode_check: cannot delete entry when breaking oplock (%x) on file %s, \
532 dev = %x, inode = %.0f\n", broken_entry.op_type, fname, (unsigned int)dev, (double)inode));
534 unix_ERR_class = ERRDOS;
535 unix_ERR_code = ERRbadshare;
538 num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
539 oplock_contention_count++;
541 } while(broke_oplock);
544 free((char *)old_shares);
547 * Refuse to grant an oplock in case the contention limit is
548 * reached when going through the lock list multiple times.
551 if(oplock_contention_count >= lp_oplock_contention_limit(SNUM(conn))) {
552 *p_oplock_request = 0;
553 DEBUG(4,("open_mode_check: oplock contention = %d. Not granting oplock.\n",
554 oplock_contention_count ));
557 return num_share_modes;
560 /****************************************************************************
561 set a kernel flock on a file for NFS interoperability
562 this requires a patch to Linux
563 ****************************************************************************/
564 static void kernel_flock(files_struct *fsp, int deny_mode)
566 #if HAVE_KERNEL_SHARE_MODES
568 if (deny_mode == DENY_READ) kernel_mode = LOCK_MAND|LOCK_WRITE;
569 else if (deny_mode == DENY_WRITE) kernel_mode = LOCK_MAND|LOCK_READ;
570 else if (deny_mode == DENY_ALL) kernel_mode = LOCK_MAND;
571 if (kernel_mode) flock(fsp->fd, kernel_mode);
576 /****************************************************************************
577 Open a file with a share mode. On output from this open we are guarenteeing
579 ****************************************************************************/
580 files_struct *open_file_shared(connection_struct *conn,char *fname, SMB_STRUCT_STAT *psbuf,
581 int share_mode,int ofun, mode_t mode,int oplock_request, int *Access,int *action)
585 int deny_mode = GET_DENY_MODE(share_mode);
586 BOOL allow_share_delete = GET_ALLOW_SHARE_DELETE(share_mode);
587 BOOL delete_access_requested = GET_DELETE_ACCESS_REQUESTED(share_mode);
588 BOOL file_existed = VALID_STAT(*psbuf);
589 BOOL fcbopen = False;
592 int num_share_modes = 0;
593 BOOL all_current_opens_are_level_II = False;
594 BOOL fsp_open = False;
595 files_struct *fsp = NULL;
600 /* printers are handled completely differently. Most of the passed parameters are
602 *Access = DOS_OPEN_WRONLY;
603 *action = FILE_WAS_CREATED;
604 return print_fsp_open(conn);
607 fsp = file_new(conn);
611 DEBUG(10,("open_file_shared: fname = %s, share_mode = %x, ofun = %x, mode = %o, oplock request = %d\n",
612 fname, share_mode, ofun, (int)mode, oplock_request ));
614 if (!check_name(fname,conn)) {
619 /* ignore any oplock requests if oplocks are disabled */
620 if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break) {
624 /* this is for OS/2 EAs - try and say we don't support them */
625 if (strstr(fname,".+,;=[].")) {
626 unix_ERR_class = ERRDOS;
627 /* OS/2 Workplace shell fix may be main code stream in a later release. */
628 #if 1 /* OS2_WPS_FIX - Recent versions of OS/2 need this. */
629 unix_ERR_code = ERRcannotopen;
630 #else /* OS2_WPS_FIX */
631 unix_ERR_code = ERROR_EAS_NOT_SUPPORTED;
632 #endif /* OS2_WPS_FIX */
634 DEBUG(5,("open_file_shared: OS/2 EA's are not supported.\n"));
639 if ((GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL) && file_existed) {
640 DEBUG(5,("open_file_shared: create new requested for file %s and file already exists.\n",
647 if (GET_FILE_CREATE_DISPOSITION(ofun) == FILE_CREATE_IF_NOT_EXIST)
650 if (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_TRUNCATE)
653 if (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL)
656 /* note that we ignore the append flag as
657 append does not mean the same thing under dos and unix */
659 switch (GET_OPEN_MODE(share_mode)) {
660 case DOS_OPEN_WRONLY:
676 if (GET_FILE_SYNC_OPENMODE(share_mode)) {
681 if (flags != O_RDONLY && file_existed &&
682 (!CAN_WRITE(conn) || IS_DOS_READONLY(dos_mode(conn,fname,psbuf)))) {
684 DEBUG(5,("open_file_shared: read/write access requested for file %s on read only %s\n",
685 fname, !CAN_WRITE(conn) ? "share" : "file" ));
693 if (deny_mode > DENY_NONE && deny_mode!=DENY_FCB) {
694 DEBUG(2,("Invalid deny mode %d on file %s\n",deny_mode,fname));
703 inode = psbuf->st_ino;
705 lock_share_entry(conn, dev, inode);
707 num_share_modes = open_mode_check(conn, fname, dev, inode, share_mode,
708 &flags, &oplock_request, &all_current_opens_are_level_II);
709 if(num_share_modes == -1) {
712 * This next line is a subtlety we need for MS-Access. If a file open will
713 * fail due to share permissions and also for security (access)
714 * reasons, we need to return the access failed error, not the
715 * share error. This means we must attempt to open the file anyway
716 * in order to get the UNIX access error - even if we're going to
717 * fail the open for share reasons. This is bad, as we're burning
718 * another fd if there are existing locks but there's nothing else
719 * we can do. We also ensure we're not going to create or tuncate
720 * the file as we only want an access decision at this stage. JRA.
722 fsp_open = open_file(fsp,conn,fname,psbuf,flags|(flags2&~(O_TRUNC|O_CREAT)),mode);
724 DEBUG(4,("open_file_shared : share_mode deny - calling open_file with \
725 flags=0x%X flags2=0x%X mode=0%o returned %d\n",
726 flags,(flags2&~(O_TRUNC|O_CREAT)),(int)mode,(int)fsp_open ));
728 unlock_share_entry(conn, dev, inode);
736 * We exit this block with the share entry *locked*.....
740 DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
741 flags,flags2,(int)mode));
744 * open_file strips any O_TRUNC flags itself.
747 fsp_open = open_file(fsp,conn,fname,psbuf,flags|flags2,mode);
749 if (!fsp_open && (flags == O_RDWR) && (errno != ENOENT) && fcbopen) {
750 if((fsp_open = open_file(fsp,conn,fname,psbuf,O_RDONLY,mode)) == True)
756 unlock_share_entry(conn, dev, inode);
762 * Deal with the race condition where two smbd's detect the file doesn't
763 * exist and do the create at the same time. One of them will win and
764 * set a share mode, the other (ie. this one) should check if the
765 * requested share mode for this create is allowed.
770 lock_share_entry_fsp(fsp);
772 num_share_modes = open_mode_check(conn, fname, dev, inode, share_mode,
773 &flags, &oplock_request, &all_current_opens_are_level_II);
775 if(num_share_modes == -1) {
776 unlock_share_entry_fsp(fsp);
783 * If there are any share modes set then the file *did*
784 * exist. Ensure we return the correct value for action.
787 if (num_share_modes > 0)
791 * We exit this block with the share entry *locked*.....
795 /* note that we ignore failure for the following. It is
796 basically a hack for NFS, and NFS will never set one of
797 these only read them. Nobody but Samba can ever set a deny
798 mode and we have already checked our more authoritative
799 locking database for permission to set this deny mode. If
800 the kernel refuses the operations then the kernel is wrong */
801 kernel_flock(fsp, deny_mode);
804 * At this point onwards, we can guarentee that the share entry
805 * is locked, whether we created the file or not, and that the
806 * deny mode is compatible with all current opens.
810 * If requested, truncate the file.
813 if (flags2&O_TRUNC) {
815 * We are modifing the file after open - update the stat struct..
817 if ((truncate_unless_locked(conn,fsp) == -1) || (vfs_fstat(fsp,fsp->fd,psbuf)==-1)) {
818 unlock_share_entry_fsp(fsp);
827 open_mode = DOS_OPEN_RDONLY;
830 open_mode = DOS_OPEN_RDWR;
833 open_mode = DOS_OPEN_WRONLY;
837 fsp->share_mode = SET_DENY_MODE(deny_mode) |
838 SET_OPEN_MODE(open_mode) |
839 SET_ALLOW_SHARE_DELETE(allow_share_delete) |
840 SET_DELETE_ACCESS_REQUESTED(delete_access_requested);
842 DEBUG(10,("open_file_shared : share_mode = %x\n", fsp->share_mode ));
845 (*Access) = open_mode;
848 if (file_existed && !(flags2 & O_TRUNC))
849 *action = FILE_WAS_OPENED;
851 *action = FILE_WAS_CREATED;
852 if (file_existed && (flags2 & O_TRUNC))
853 *action = FILE_WAS_OVERWRITTEN;
857 * Setup the oplock info in both the shared memory and
861 if(oplock_request && (num_share_modes == 0) &&
862 !IS_VETO_OPLOCK_PATH(conn,fname) && set_file_oplock(fsp, oplock_request) ) {
863 port = global_oplock_port;
864 } else if (oplock_request && all_current_opens_are_level_II) {
865 port = global_oplock_port;
866 oplock_request = LEVEL_II_OPLOCK;
867 set_file_oplock(fsp, oplock_request);
873 set_share_mode(fsp, port, oplock_request);
875 unlock_share_entry_fsp(fsp);
877 conn->num_files_open++;
882 /****************************************************************************
883 Open a file for permissions read only. Return a pseudo file entry
884 with the 'stat_open' flag set
885 ****************************************************************************/
887 files_struct *open_file_stat(connection_struct *conn, char *fname,
888 SMB_STRUCT_STAT *psbuf, int smb_ofun, int *action)
890 extern struct current_user current_user;
891 files_struct *fsp = NULL;
893 if (!VALID_STAT(*psbuf)) {
894 DEBUG(0,("open_file_stat: unable to stat name = %s. Error was %s\n", fname, strerror(errno) ));
898 if(S_ISDIR(psbuf->st_mode)) {
899 DEBUG(0,("open_file_stat: %s is a directory !\n", fname ));
903 fsp = file_new(conn);
907 *action = FILE_WAS_OPENED;
909 DEBUG(5,("open_file_stat: opening file %s as a stat entry\n", fname));
912 * Setup the files_struct for it.
916 fsp->mode = psbuf->st_mode;
917 fsp->inode = psbuf->st_ino;
918 fsp->dev = psbuf->st_dev;
919 GetTimeOfDay(&fsp->open_time);
920 fsp->size = psbuf->st_size;
921 fsp->vuid = current_user.vuid;
923 fsp->can_lock = False;
924 fsp->can_read = False;
925 fsp->can_write = False;
927 fsp->print_file = False;
928 fsp->modified = False;
929 fsp->oplock_type = NO_OPLOCK;
930 fsp->sent_oplock_break = NO_BREAK_SENT;
931 fsp->is_directory = False;
932 fsp->stat_open = True;
933 fsp->directory_delete_on_close = False;
935 string_set(&fsp->fsp_name,fname);
936 fsp->wbmpx_ptr = NULL;
937 fsp->wcp = NULL; /* Write cache pointer. */
939 conn->num_files_open++;
944 /****************************************************************************
945 Open a file for for write to ensure that we can fchmod it.
946 ****************************************************************************/
948 files_struct *open_file_fchmod(connection_struct *conn, char *fname, SMB_STRUCT_STAT *psbuf)
950 files_struct *fsp = NULL;
953 if (!VALID_STAT(*psbuf))
956 fsp = file_new(conn);
960 fsp_open = open_file(fsp,conn,fname,psbuf,O_WRONLY,0);
963 * This is not a user visible file open.
964 * Don't set a share mode and don't increment
965 * the conn->num_files_open.
976 /****************************************************************************
977 Close the fchmod file fd - ensure no locks are lost.
978 ****************************************************************************/
980 int close_file_fchmod(files_struct *fsp)
982 int ret = fd_close(fsp->conn, fsp);
987 /****************************************************************************
988 Open a directory from an NT SMB call.
989 ****************************************************************************/
991 files_struct *open_directory(connection_struct *conn, char *fname,
992 SMB_STRUCT_STAT *psbuf, int smb_ofun, mode_t unixmode, int *action)
994 extern struct current_user current_user;
995 BOOL got_stat = False;
996 files_struct *fsp = file_new(conn);
1001 fsp->conn = conn; /* The vfs_fXXX() macros need this. */
1003 if (VALID_STAT(*psbuf))
1006 if (got_stat && (GET_FILE_OPEN_DISPOSITION(smb_ofun) == FILE_EXISTS_FAIL)) {
1008 errno = EEXIST; /* Setup so correct error is returned to client. */
1012 if (GET_FILE_CREATE_DISPOSITION(smb_ofun) == FILE_CREATE_IF_NOT_EXIST) {
1016 if(!S_ISDIR(psbuf->st_mode)) {
1017 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1022 *action = FILE_WAS_OPENED;
1027 * Try and create the directory.
1030 if(!CAN_WRITE(conn)) {
1031 DEBUG(2,("open_directory: failing create on read-only share\n"));
1037 if(vfs_mkdir(conn,fname, unix_mode(conn,aDIR, fname)) < 0) {
1038 DEBUG(0,("open_directory: unable to create %s. Error was %s\n",
1039 fname, strerror(errno) ));
1044 if(vfs_stat(conn,fname, psbuf) != 0) {
1049 *action = FILE_WAS_CREATED;
1055 * Don't create - just check that it *was* a directory.
1059 DEBUG(0,("open_directory: unable to stat name = %s. Error was %s\n",
1060 fname, strerror(errno) ));
1065 if(!S_ISDIR(psbuf->st_mode)) {
1066 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1071 *action = FILE_WAS_OPENED;
1074 DEBUG(5,("open_directory: opening directory %s\n", fname));
1077 * Setup the files_struct for it.
1081 fsp->mode = psbuf->st_mode;
1082 fsp->inode = psbuf->st_ino;
1083 fsp->dev = psbuf->st_dev;
1084 GetTimeOfDay(&fsp->open_time);
1085 fsp->size = psbuf->st_size;
1086 fsp->vuid = current_user.vuid;
1088 fsp->can_lock = True;
1089 fsp->can_read = False;
1090 fsp->can_write = False;
1091 fsp->share_mode = 0;
1092 fsp->print_file = False;
1093 fsp->modified = False;
1094 fsp->oplock_type = NO_OPLOCK;
1095 fsp->sent_oplock_break = NO_BREAK_SENT;
1096 fsp->is_directory = True;
1097 fsp->directory_delete_on_close = False;
1099 string_set(&fsp->fsp_name,fname);
1100 fsp->wbmpx_ptr = NULL;
1102 conn->num_files_open++;
1107 /*******************************************************************
1108 Check if the share mode on a file allows it to be deleted or unlinked.
1109 Return True if sharing doesn't prevent the operation.
1110 ********************************************************************/
1112 BOOL check_file_sharing(connection_struct *conn,char *fname, BOOL rename_op)
1116 share_mode_entry *old_shares = 0;
1117 int num_share_modes;
1118 SMB_STRUCT_STAT sbuf;
1119 pid_t pid = sys_getpid();
1123 if (vfs_stat(conn,fname,&sbuf) == -1)
1127 inode = sbuf.st_ino;
1129 lock_share_entry(conn, dev, inode);
1130 num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
1133 * Check if the share modes will give us access.
1136 if(num_share_modes != 0)
1143 broke_oplock = False;
1144 for(i = 0; i < num_share_modes; i++)
1146 share_mode_entry *share_entry = &old_shares[i];
1149 * Break oplocks before checking share modes. See comment in
1150 * open_file_shared for details.
1151 * Check if someone has an oplock on this file. If so we must
1152 * break it before continuing.
1154 if(BATCH_OPLOCK_TYPE(share_entry->op_type))
1159 /* JRA. Try removing this code to see if the new oplock changes
1160 fix the problem. I'm dubious, but Andrew is recommending we
1165 * It appears that the NT redirector may have a bug, in that
1166 * it tries to do an SMBmv on a file that it has open with a
1167 * batch oplock, and then fails to respond to the oplock break
1168 * request. This only seems to occur when the client is doing an
1169 * SMBmv to the smbd it is using - thus we try and detect this
1170 * condition by checking if the file being moved is open and oplocked by
1171 * this smbd process, and then not sending the oplock break in this
1172 * special case. If the file was open with a deny mode that
1173 * prevents the move the SMBmv will fail anyway with a share
1174 * violation error. JRA.
1176 if(rename_op && (share_entry->pid == pid))
1179 DEBUG(0,("check_file_sharing: NT redirector workaround - rename attempted on \
1180 batch oplocked file %s, dev = %x, inode = %.0f\n", fname, (unsigned int)dev, (double)inode));
1183 * This next line is a test that allows the deny-mode
1184 * processing to be skipped. This seems to be needed as
1185 * NT insists on the rename succeeding (in Office 9x no less !).
1186 * This should be removed as soon as (a) MS fix the redirector
1187 * bug or (b) NT SMB support in Samba makes NT not issue the
1188 * call (as is my fervent hope). JRA.
1196 DEBUG(5,("check_file_sharing: breaking oplock (%x) on file %s, \
1197 dev = %x, inode = %.0f\n", share_entry->op_type, fname, (unsigned int)dev, (double)inode));
1199 /* Oplock break.... */
1200 unlock_share_entry(conn, dev, inode);
1201 if(request_oplock_break(share_entry, dev, inode) == False)
1203 free((char *)old_shares);
1205 DEBUG(0,("check_file_sharing: FAILED when breaking oplock (%x) on file %s, \
1206 dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
1210 lock_share_entry(conn, dev, inode);
1211 broke_oplock = True;
1217 * If this is a delete request and ALLOW_SHARE_DELETE is set then allow
1218 * this to proceed. This takes precedence over share modes.
1221 if(!rename_op && GET_ALLOW_SHARE_DELETE(share_entry->share_mode))
1225 * Someone else has a share lock on it, check to see
1229 if ((GET_DENY_MODE(share_entry->share_mode) != DENY_DOS) ||
1230 (share_entry->pid != pid))
1237 free((char *)old_shares);
1238 num_share_modes = get_share_modes(conn, dev, inode, &old_shares);
1240 } while(broke_oplock);
1243 /* XXXX exactly what share mode combinations should be allowed for
1244 deleting/renaming? */
1246 * If we got here then either there were no share modes or
1247 * all share modes were DENY_DOS and the pid == getpid() or
1248 * delete access was requested and all share modes had the
1249 * ALLOW_SHARE_DELETE bit set (takes precedence over other
1257 unlock_share_entry(conn, dev, inode);
1258 if(old_shares != NULL)
1259 free((char *)old_shares);