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 pstring sesssetup_user;
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_attempt_open(char *fname, int flags, mode_t mode)
36 int fd = dos_open(fname,flags,mode);
38 /* Fix for files ending in '.' */
39 if((fd == -1) && (errno == ENOENT) &&
40 (strchr(fname,'.')==NULL))
43 fd = dos_open(fname,flags,mode);
46 #if (defined(ENAMETOOLONG) && defined(HAVE_PATHCONF))
47 if ((fd == -1) && (errno == ENAMETOOLONG))
50 char *p = strrchr(fname, '/');
52 if (p == fname) /* name is "/xxx" */
54 max_len = pathconf("/", _PC_NAME_MAX);
57 else if ((p == NULL) || (p == fname))
60 max_len = pathconf(".", _PC_NAME_MAX);
65 max_len = pathconf(fname, _PC_NAME_MAX);
69 if (strlen(p) > max_len)
71 char tmp = p[max_len];
74 if ((fd = dos_open(fname,flags,mode)) == -1)
82 /****************************************************************************
83 Cache a uid_t currently with this file open. This is an optimization only
84 used when multiple sessionsetup's have been done to one smbd.
85 ****************************************************************************/
87 void fd_add_to_uid_cache(file_fd_struct *fd_ptr, uid_t u)
89 if(fd_ptr->uid_cache_count >= sizeof(fd_ptr->uid_users_cache)/sizeof(uid_t))
91 fd_ptr->uid_users_cache[fd_ptr->uid_cache_count++] = u;
94 /****************************************************************************
95 Remove a uid_t that currently has this file open. This is an optimization only
96 used when multiple sessionsetup's have been done to one smbd.
97 ****************************************************************************/
99 static void fd_remove_from_uid_cache(file_fd_struct *fd_ptr, uid_t u)
102 for(i = 0; i < fd_ptr->uid_cache_count; i++)
103 if(fd_ptr->uid_users_cache[i] == u) {
104 if(i < (fd_ptr->uid_cache_count-1))
105 memmove((char *)&fd_ptr->uid_users_cache[i], (char *)&fd_ptr->uid_users_cache[i+1],
106 sizeof(uid_t)*(fd_ptr->uid_cache_count-1-i) );
107 fd_ptr->uid_cache_count--;
112 /****************************************************************************
113 Check if a uid_t that currently has this file open is present. This is an
114 optimization only used when multiple sessionsetup's have been done to one smbd.
115 ****************************************************************************/
117 static BOOL fd_is_in_uid_cache(file_fd_struct *fd_ptr, uid_t u)
120 for(i = 0; i < fd_ptr->uid_cache_count; i++)
121 if(fd_ptr->uid_users_cache[i] == u)
126 /****************************************************************************
127 fd support routines - attempt to re-open an already open fd as O_RDWR.
128 Save the already open fd (we cannot close due to POSIX file locking braindamage.
129 ****************************************************************************/
131 static void fd_attempt_reopen(char *fname, mode_t mode, file_fd_struct *fd_ptr)
133 int fd = dos_open( fname, O_RDWR, mode);
138 if(fd_ptr->real_open_flags == O_RDONLY)
139 fd_ptr->fd_readonly = fd_ptr->fd;
140 if(fd_ptr->real_open_flags == O_WRONLY)
141 fd_ptr->fd_writeonly = fd_ptr->fd;
144 fd_ptr->real_open_flags = O_RDWR;
147 /****************************************************************************
148 fd support routines - attempt to close the file referenced by this fd.
149 Decrements the ref_count and returns it.
150 ****************************************************************************/
152 uint16 fd_attempt_close(file_fd_struct *fd_ptr, int *err_ret)
154 extern struct current_user current_user;
155 uint16 ret_ref = fd_ptr->ref_count;
159 DEBUG(3,("fd_attempt_close fd = %d, dev = %x, inode = %.0f, open_flags = %d, ref_count = %d.\n",
160 fd_ptr->fd, (unsigned int)fd_ptr->dev, (double)fd_ptr->inode,
161 fd_ptr->real_open_flags,
164 SMB_ASSERT(fd_ptr->ref_count != 0);
167 ret_ref = fd_ptr->ref_count;
169 if(fd_ptr->ref_count == 0) {
171 if(fd_ptr->fd != -1) {
172 if(close(fd_ptr->fd) < 0)
176 if(fd_ptr->fd_readonly != -1) {
177 if(close(fd_ptr->fd_readonly) < 0) {
183 if(fd_ptr->fd_writeonly != -1) {
184 if( close(fd_ptr->fd_writeonly) < 0) {
191 * Delete this fd_ptr.
195 fd_remove_from_uid_cache(fd_ptr, (uid_t)current_user.uid);
201 /****************************************************************************
202 fd support routines - check that current user has permissions
203 to open this file. Used when uid not found in optimization cache.
204 This is really ugly code, as due to POSIX locking braindamage we must
205 fork and then attempt to open the file, and return success or failure
207 ****************************************************************************/
209 static BOOL check_access_allowed_for_current_user( char *fname, int accmode )
214 * We need to temporarily stop CatchChild from eating
215 * SIGCLD signals as it also eats the exit status code. JRA.
218 CatchChildLeaveStatus();
220 if((child_pid = fork()) < 0) {
221 DEBUG(0,("check_access_allowed_for_current_user: fork failed.\n"));
233 while ((wpid = sys_waitpid(child_pid, &status_code, 0)) < 0) {
238 DEBUG(0,("check_access_allowed_for_current_user: The process \
239 is no longer waiting ! Error = %s\n", strerror(errno) ));
245 * Go back to ignoring children.
249 if (child_pid != wpid) {
250 DEBUG(0,("check_access_allowed_for_current_user: We were waiting for the wrong process ID\n"));
253 #if defined(WIFEXITED) && defined(WEXITSTATUS)
254 if (WIFEXITED(status_code) == 0) {
255 DEBUG(0,("check_access_allowed_for_current_user: The process exited while we were waiting\n"));
258 if (WEXITSTATUS(status_code) != 0) {
259 DEBUG(9,("check_access_allowed_for_current_user: The status of the process exiting was %d. Returning access denied.\n", status_code));
262 #else /* defined(WIFEXITED) && defined(WEXITSTATUS) */
263 if(status_code != 0) {
264 DEBUG(9,("check_access_allowed_for_current_user: The status of the process exiting was %d. Returning access denied.\n", status_code));
267 #endif /* defined(WIFEXITED) && defined(WEXITSTATUS) */
270 * Success - the child could open the file.
272 DEBUG(9,("check_access_allowed_for_current_user: The status of the process exiting was %d. Returning access allowed.\n", status_code));
279 DEBUG(9,("check_access_allowed_for_current_user: Child - attempting to open %s with mode %d.\n", fname, accmode ));
280 if((fd = fd_attempt_open( fname, accmode, 0)) < 0) {
285 DEBUG(9,("check_access_allowed_for_current_user: Child - returning ok.\n"));
292 /****************************************************************************
293 check a filename for the pipe string
294 ****************************************************************************/
296 static void check_for_pipe(char *fname)
298 /* special case of pipe opens */
300 StrnCpy(s,fname,sizeof(s)-1);
302 if (strstr(s,"pipe/")) {
303 DEBUG(3,("Rejecting named pipe open for %s\n",fname));
304 unix_ERR_class = ERRSRV;
305 unix_ERR_code = ERRaccess;
309 /****************************************************************************
311 ****************************************************************************/
313 static void open_file(files_struct *fsp,connection_struct *conn,
314 char *fname1,int flags,mode_t mode, SMB_STRUCT_STAT *sbuf)
316 extern struct current_user current_user;
318 SMB_STRUCT_STAT statbuf;
319 file_fd_struct *fd_ptr;
320 int accmode = (flags & O_ACCMODE);
324 fsp->oplock_type = NO_OPLOCK;
327 pstrcpy(fname,fname1);
329 /* check permissions */
332 * This code was changed after seeing a client open request
333 * containing the open mode of (DENY_WRITE/read-only) with
334 * the 'create if not exist' bit set. The previous code
335 * would fail to open the file read only on a read-only share
336 * as it was checking the flags parameter directly against O_RDONLY,
337 * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
341 if (!CAN_WRITE(conn) && !conn->printer) {
342 /* It's a read-only share - fail if we wanted to write. */
343 if(accmode != O_RDONLY) {
344 DEBUG(3,("Permission denied opening %s\n",fname));
345 check_for_pipe(fname);
347 } else if(flags & O_CREAT) {
348 /* We don't want to write - but we must make sure that O_CREAT
349 doesn't create the file if we have write access into the
356 /* this handles a bug in Win95 - it doesn't say to create the file when it
359 flags |= (O_CREAT|O_EXCL);
363 if (flags == O_WRONLY)
364 DEBUG(3,("Bug in client? Set O_WRONLY without O_CREAT\n"));
368 * Ensure we have a valid struct stat so we can search the
372 if(dos_stat(fname, &statbuf) < 0) {
373 if(errno != ENOENT) {
374 DEBUG(3,("Error doing stat on file %s (%s)\n",
375 fname,strerror(errno)));
377 check_for_pipe(fname);
387 * Check to see if we have this file already
388 * open. If we do, just use the already open fd and increment the
389 * reference count (fd_get_already_open increments the ref_count).
391 if((fd_ptr = fd_get_already_open(sbuf))!= 0) {
393 * File was already open.
397 * Check it wasn't open for exclusive use.
399 if((flags & O_CREAT) && (flags & O_EXCL)) {
406 * Ensure that the user attempting to open
407 * this file has permissions to do so, if
408 * the user who originally opened the file wasn't
409 * the same as the current user.
412 if(!fd_is_in_uid_cache(fd_ptr, (uid_t)current_user.uid)) {
413 if(!check_access_allowed_for_current_user( fname, accmode )) {
414 /* Error - permission denied. */
415 DEBUG(3,("Permission denied opening file %s (flags=%d, accmode = %d)\n",
416 fname, flags, accmode));
417 /* Ensure the ref_count is decremented. */
419 fd_remove_from_uid_cache(fd_ptr, (uid_t)current_user.uid);
425 fd_add_to_uid_cache(fd_ptr, (uid_t)current_user.uid);
428 * If not opened O_RDWR try
429 * and do that here - a chmod may have been done
430 * between the last open and now.
432 if(fd_ptr->real_open_flags != O_RDWR)
433 fd_attempt_reopen(fname, mode, fd_ptr);
436 * Ensure that if we wanted write access
437 * it has been opened for write, and if we wanted read it
440 if(((accmode == O_WRONLY) && (fd_ptr->real_open_flags == O_RDONLY)) ||
441 ((accmode == O_RDONLY) && (fd_ptr->real_open_flags == O_WRONLY)) ||
442 ((accmode == O_RDWR) && (fd_ptr->real_open_flags != O_RDWR))) {
443 DEBUG(3,("Error opening (already open for flags=%d) file %s (%s) (flags=%d)\n",
444 fd_ptr->real_open_flags, fname,strerror(EACCES),flags));
445 check_for_pipe(fname);
446 fd_remove_from_uid_cache(fd_ptr, (uid_t)current_user.uid);
453 /* We need to allocate a new file_fd_struct (this increments the
455 if((fd_ptr = fd_get_new()) == 0)
458 * Whatever the requested flags, attempt read/write access,
459 * as we don't know what flags future file opens may require.
460 * If this fails, try again with the required flags.
461 * Even if we open read/write when only read access was
462 * requested the setting of the can_write flag in
463 * the file_struct will protect us from errant
464 * write requests. We never need to worry about O_APPEND
465 * as this is not set anywhere in Samba.
467 fd_ptr->real_open_flags = O_RDWR;
468 /* Set the flags as needed without the read/write modes. */
469 open_flags = flags & ~(O_RDWR|O_WRONLY|O_RDONLY);
470 fd_ptr->fd = fd_attempt_open(fname, open_flags|O_RDWR, mode);
472 * On some systems opening a file for R/W access on a read only
473 * filesystems sets errno to EROFS.
476 if((fd_ptr->fd == -1) && ((errno == EACCES) || (errno == EROFS))) {
478 if((fd_ptr->fd == -1) && (errno == EACCES)) {
480 if(accmode != O_RDWR) {
481 fd_ptr->fd = fd_attempt_open(fname, open_flags|accmode, mode);
482 fd_ptr->real_open_flags = accmode;
487 if ((fd_ptr->fd >=0) &&
488 conn->printer && lp_minprintspace(SNUM(conn))) {
490 SMB_BIG_UINT dum1,dum2,dum3;
492 pstrcpy(dname,fname);
493 p = strrchr(dname,'/');
495 if (sys_disk_free(dname,False,&dum1,&dum2,&dum3) < (SMB_BIG_UINT)lp_minprintspace(SNUM(conn))) {
497 if(fd_attempt_close(fd_ptr, &err) == 0)
508 DEBUG(3,("Error opening file %s (%s) (flags=%d)\n",
509 fname,strerror(errno),flags));
510 /* Ensure the ref_count is decremented. */
511 fd_attempt_close(fd_ptr,&err);
512 check_for_pipe(fname);
520 if(sys_fstat(fd_ptr->fd, &statbuf) == -1) {
522 /* Error - backout !! */
523 DEBUG(3,("Error doing fstat on fd %d, file %s (%s)\n",
524 fd_ptr->fd, fname,strerror(errno)));
525 /* Ensure the ref_count is decremented. */
526 fd_attempt_close(fd_ptr,&err);
532 /* Set the correct entries in fd_ptr. */
533 fd_ptr->dev = sbuf->st_dev;
534 fd_ptr->inode = sbuf->st_ino;
536 fsp->fd_ptr = fd_ptr;
537 conn->num_files_open++;
538 fsp->mode = sbuf->st_mode;
539 GetTimeOfDay(&fsp->open_time);
540 fsp->vuid = current_user.vuid;
544 fsp->can_lock = True;
545 fsp->can_read = ((flags & O_WRONLY)==0);
546 fsp->can_write = ((flags & (O_WRONLY|O_RDWR))!=0);
548 fsp->print_file = conn->printer;
549 fsp->modified = False;
550 fsp->oplock_type = NO_OPLOCK;
551 fsp->sent_oplock_break = NO_BREAK_SENT;
552 fsp->is_directory = False;
553 fsp->stat_open = False;
554 fsp->directory_delete_on_close = False;
557 * Note that the file name here is the *untranslated* name
558 * ie. it is still in the DOS codepage sent from the client.
559 * All use of this filename will pass though the sys_xxxx
560 * functions which will do the dos_to_unix translation before
561 * mapping into a UNIX filename. JRA.
563 string_set(&fsp->fsp_name,fname);
564 fsp->wbmpx_ptr = NULL;
565 fsp->wcp = NULL; /* Write cache pointer. */
568 * If the printer is marked as postscript output a leading
569 * file identifier to ensure the file is treated as a raw
571 * This has a similar effect as CtrlD=0 in WIN.INI file.
572 * tim@fsg.com 09/06/94
574 if (fsp->print_file && lp_postscript(SNUM(conn)) && fsp->can_write) {
575 DEBUG(3,("Writing postscript line\n"));
576 write_file(fsp,"%!\n",-1,3);
579 DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
580 *sesssetup_user ? sesssetup_user : conn->user,fsp->fsp_name,
581 BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
582 conn->num_files_open));
587 /****************************************************************************
589 Helper for open_file_shared.
590 Truncate a file after checking locking; close file if locked.
591 **************************************************************************/
593 static void truncate_unless_locked(files_struct *fsp, connection_struct *conn, int token,
597 SMB_OFF_T mask2 = ((SMB_OFF_T)0x3) << (SMB_OFF_T_BITS-4);
598 SMB_OFF_T mask = (mask2<<2);
600 if (is_locked(fsp,conn,~mask,0,F_WRLCK)){
601 /* If share modes are in force for this connection we
602 have the share entry locked. Unlock it before closing. */
603 if (*share_locked && lp_share_modes(SNUM(conn)))
604 unlock_share_entry( conn, fsp->fd_ptr->dev,
605 fsp->fd_ptr->inode, token);
606 close_file(fsp,False);
607 /* Share mode no longer locked. */
608 *share_locked = False;
610 unix_ERR_class = ERRDOS;
611 unix_ERR_code = ERRlock;
613 sys_ftruncate(fsp->fd_ptr->fd,0);
618 enum {AFAIL,AREAD,AWRITE,AALL};
620 /*******************************************************************
621 reproduce the share mode access table
622 ********************************************************************/
624 static int access_table(int new_deny,int old_deny,int old_mode,
625 pid_t share_pid,char *fname)
627 if (new_deny == DENY_ALL || old_deny == DENY_ALL) return(AFAIL);
629 if (new_deny == DENY_DOS || old_deny == DENY_DOS) {
630 pid_t pid = getpid();
631 if (old_deny == new_deny && share_pid == pid)
634 if (old_mode == 0) return(AREAD);
636 /* the new smbpub.zip spec says that if the file extension is
637 .com, .dll, .exe or .sym then allow the open. I will force
638 it to read-only as this seems sensible although the spec is
639 a little unclear on this. */
640 if ((fname = strrchr(fname,'.'))) {
641 if (strequal(fname,".com") ||
642 strequal(fname,".dll") ||
643 strequal(fname,".exe") ||
644 strequal(fname,".sym"))
654 if (old_deny==DENY_WRITE && old_mode==0) return(AREAD);
655 if (old_deny==DENY_READ && old_mode==0) return(AWRITE);
656 if (old_deny==DENY_NONE && old_mode==0) return(AALL);
659 if (old_deny==DENY_WRITE && old_mode==1) return(AREAD);
660 if (old_deny==DENY_READ && old_mode==1) return(AWRITE);
661 if (old_deny==DENY_NONE && old_mode==1) return(AALL);
664 if (old_deny==DENY_WRITE) return(AREAD);
665 if (old_deny==DENY_READ) return(AWRITE);
666 if (old_deny==DENY_NONE) return(AALL);
672 /****************************************************************************
673 check if we can open a file with a share mode
674 ****************************************************************************/
676 static int check_share_mode( share_mode_entry *share, int deny_mode,
678 BOOL fcbopen, int *flags)
680 int old_open_mode = GET_OPEN_MODE(share->share_mode);
681 int old_deny_mode = GET_DENY_MODE(share->share_mode);
684 * Don't allow any open once the delete on close flag has been
688 if(GET_DELETE_ON_CLOSE_FLAG(share->share_mode))
690 DEBUG(5,("check_share_mode: Failing open on file %s as delete on close flag is set.\n",
692 unix_ERR_class = ERRDOS;
693 unix_ERR_code = ERRnoaccess;
697 if (old_deny_mode > 4 || old_open_mode > 2)
699 DEBUG(0,("Invalid share mode found (%d,%d,%d) on file %s\n",
700 deny_mode,old_deny_mode,old_open_mode,fname));
702 unix_ERR_class = ERRDOS;
703 unix_ERR_code = ERRbadshare;
709 int access_allowed = access_table(deny_mode,old_deny_mode,old_open_mode,
712 if ((access_allowed == AFAIL) ||
713 (!fcbopen && (access_allowed == AREAD && *flags == O_RDWR)) ||
714 (access_allowed == AREAD && *flags == O_WRONLY) ||
715 (access_allowed == AWRITE && *flags == O_RDONLY))
717 DEBUG(2,("Share violation on file (%d,%d,%d,%d,%s,fcbopen = %d, flags = %d) = %d\n",
718 deny_mode,old_deny_mode,old_open_mode,
719 (int)share->pid,fname, fcbopen, *flags, access_allowed));
721 unix_ERR_class = ERRDOS;
722 unix_ERR_code = ERRbadshare;
727 if (access_allowed == AREAD)
730 if (access_allowed == AWRITE)
738 /****************************************************************************
739 open a file with a share mode
740 ****************************************************************************/
742 void open_file_shared(files_struct *fsp,connection_struct *conn,char *fname,int share_mode,int ofun,
743 mode_t mode,int oplock_request, int *Access,int *action)
747 int deny_mode = GET_DENY_MODE(share_mode);
748 BOOL allow_share_delete = GET_ALLOW_SHARE_DELETE(share_mode);
749 SMB_STRUCT_STAT sbuf;
750 BOOL file_existed = dos_file_exist(fname,&sbuf);
751 BOOL share_locked = False;
752 BOOL fcbopen = False;
756 int num_share_modes = 0;
757 int oplock_contention_count = 0;
758 BOOL all_current_opens_are_level_II = False;
762 DEBUG(10,("open_file_shared: fname = %s, share_mode = %x, ofun = %x, mode = %o, oplock request = %d\n",
763 fname, share_mode, ofun, (int)mode, oplock_request ));
766 /* ignore any oplock requests if oplocks are disabled */
767 if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break) {
771 /* this is for OS/2 EAs - try and say we don't support them */
772 if (strstr(fname,".+,;=[]."))
774 unix_ERR_class = ERRDOS;
775 /* OS/2 Workplace shell fix may be main code stream in a later release. */
776 #if 1 /* OS2_WPS_FIX - Recent versions of OS/2 need this. */
777 unix_ERR_code = ERRcannotopen;
778 #else /* OS2_WPS_FIX */
779 unix_ERR_code = ERROR_EAS_NOT_SUPPORTED;
780 #endif /* OS2_WPS_FIX */
782 DEBUG(5,("open_file_shared: OS/2 EA's are not supported.\n"));
786 if ((GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL) && file_existed)
788 DEBUG(5,("open_file_shared: create new requested for file %s and file already exists.\n",
794 if (GET_FILE_CREATE_DISPOSITION(ofun) == FILE_CREATE_IF_NOT_EXIST)
797 if (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_TRUNCATE)
800 if (GET_FILE_OPEN_DISPOSITION(ofun) == FILE_EXISTS_FAIL)
803 /* note that we ignore the append flag as
804 append does not mean the same thing under dos and unix */
806 switch (GET_OPEN_MODE(share_mode))
808 case DOS_OPEN_WRONLY:
824 if (GET_FILE_SYNC_OPENMODE(share_mode)) {
829 if (flags != O_RDONLY && file_existed &&
830 (!CAN_WRITE(conn) || IS_DOS_READONLY(dos_mode(conn,fname,&sbuf))))
834 DEBUG(5,("open_file_shared: read/write access requested for file %s on read only %s\n",
835 fname, !CAN_WRITE(conn) ? "share" : "file" ));
842 if (deny_mode > DENY_NONE && deny_mode!=DENY_FCB)
844 DEBUG(2,("Invalid deny mode %d on file %s\n",deny_mode,fname));
849 if (deny_mode == DENY_FCB)
850 deny_mode = DENY_DOS;
852 if (lp_share_modes(SNUM(conn)))
855 share_mode_entry *old_shares = 0;
861 lock_share_entry(conn, dev, inode, &token);
863 num_share_modes = get_share_modes(conn, token, dev, inode, &old_shares);
867 * Check if the share modes will give us access.
870 if(share_locked && (num_share_modes != 0))
877 broke_oplock = False;
878 all_current_opens_are_level_II = True;
880 for(i = 0; i < num_share_modes; i++)
882 share_mode_entry *share_entry = &old_shares[i];
885 * By observation of NetBench, oplocks are broken *before* share
886 * modes are checked. This allows a file to be closed by the client
887 * if the share mode would deny access and the client has an oplock.
888 * Check if someone has an oplock on this file. If so we must break
889 * it before continuing.
891 if((oplock_request && EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type)) ||
892 (!oplock_request && (share_entry->op_type != NO_OPLOCK)))
895 DEBUG(5,("open_file_shared: breaking oplock (%x) on file %s, \
896 dev = %x, inode = %.0f\n", share_entry->op_type, fname, (unsigned int)dev, (double)inode));
898 /* Oplock break.... */
899 unlock_share_entry(conn, dev, inode, token);
900 if(request_oplock_break(share_entry, dev, inode) == False)
902 free((char *)old_shares);
904 DEBUG(0,("open_file_shared: FAILED when breaking oplock (%x) on file %s, \
905 dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
908 unix_ERR_class = ERRDOS;
909 unix_ERR_code = ERRbadshare;
912 lock_share_entry(conn, dev, inode, &token);
914 all_current_opens_are_level_II = False;
916 } else if (!LEVEL_II_OPLOCK_TYPE(share_entry->op_type)) {
917 all_current_opens_are_level_II = False;
920 /* someone else has a share lock on it, check to see
922 if(check_share_mode(share_entry, deny_mode, fname, fcbopen, &flags) == False)
924 free((char *)old_shares);
925 unlock_share_entry(conn, dev, inode, token);
934 free((char *)old_shares);
935 num_share_modes = get_share_modes(conn, token, dev, inode, &old_shares);
936 oplock_contention_count++;
938 } while(broke_oplock);
942 free((char *)old_shares);
946 * Refuse to grant an oplock in case the contention limit is
947 * reached when going through the lock list multiple times.
950 if(oplock_contention_count >= lp_oplock_contention_limit(SNUM(conn)))
953 DEBUG(4,("open_file_shared: oplock contention = %d. Not granting oplock.\n",
954 oplock_contention_count ));
957 DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
958 flags,flags2,(int)mode));
960 open_file(fsp,conn,fname,flags|(flags2&~(O_TRUNC)),mode,file_existed ? &sbuf : 0);
961 if (!fsp->open && flags==O_RDWR && errno!=ENOENT && fcbopen)
964 open_file(fsp,conn,fname,flags,mode,file_existed ? &sbuf : 0 );
971 if((share_locked == False) && lp_share_modes(SNUM(conn)))
973 /* We created the file - thus we must now lock the share entry before creating it. */
974 dev = fsp->fd_ptr->dev;
975 inode = fsp->fd_ptr->inode;
976 lock_share_entry(conn, dev, inode, &token);
983 open_mode = DOS_OPEN_RDONLY;
986 open_mode = DOS_OPEN_RDWR;
989 open_mode = DOS_OPEN_WRONLY;
993 fsp->share_mode = SET_DENY_MODE(deny_mode) |
994 SET_OPEN_MODE(open_mode) |
995 SET_ALLOW_SHARE_DELETE(allow_share_delete);
998 (*Access) = open_mode;
1002 if (file_existed && !(flags2 & O_TRUNC)) *action = FILE_WAS_OPENED;
1003 if (!file_existed) *action = FILE_WAS_CREATED;
1004 if (file_existed && (flags2 & O_TRUNC)) *action = FILE_WAS_OVERWRITTEN;
1006 /* We must create the share mode entry before truncate as
1007 truncate can fail due to locking and have to close the
1008 file (which expects the share_mode_entry to be there).
1010 if (lp_share_modes(SNUM(conn)))
1015 * Setup the oplock info in both the shared memory and
1019 if(oplock_request && (num_share_modes == 0) &&
1020 !IS_VETO_OPLOCK_PATH(conn,fname) && set_file_oplock(fsp, oplock_request) ) {
1021 port = global_oplock_port;
1022 } else if (oplock_request && all_current_opens_are_level_II) {
1023 port = global_oplock_port;
1024 oplock_request = LEVEL_II_OPLOCK;
1025 set_file_oplock(fsp, oplock_request);
1031 set_share_mode(token, fsp, port, oplock_request);
1034 if ((flags2&O_TRUNC) && file_existed)
1035 truncate_unless_locked(fsp,conn,token,&share_locked);
1038 if (share_locked && lp_share_modes(SNUM(conn)))
1039 unlock_share_entry( conn, dev, inode, token);
1042 /****************************************************************************
1043 Open a file for permissions read only. Return a pseudo file entry
1044 with the 'stat_open' flag set and a fd_ptr of NULL.
1045 ****************************************************************************/
1047 int open_file_stat(files_struct *fsp,connection_struct *conn,
1048 char *fname, int smb_ofun, SMB_STRUCT_STAT *pst, int *action)
1050 extern struct current_user current_user;
1052 if(dos_stat(fname, pst) < 0) {
1053 DEBUG(0,("open_file_stat: unable to stat name = %s. Error was %s\n",
1054 fname, strerror(errno) ));
1058 if(S_ISDIR(pst->st_mode)) {
1059 DEBUG(0,("open_file_stat: %s is a directory !\n", fname ));
1063 *action = FILE_WAS_OPENED;
1065 DEBUG(5,("open_file_stat: opening file %s as a stat entry\n", fname));
1068 * Setup the files_struct for it.
1072 conn->num_files_open++;
1074 GetTimeOfDay(&fsp->open_time);
1075 fsp->vuid = current_user.vuid;
1079 fsp->can_lock = False;
1080 fsp->can_read = False;
1081 fsp->can_write = False;
1082 fsp->share_mode = 0;
1083 fsp->print_file = False;
1084 fsp->modified = False;
1085 fsp->oplock_type = NO_OPLOCK;
1086 fsp->sent_oplock_break = NO_BREAK_SENT;
1087 fsp->is_directory = False;
1088 fsp->stat_open = True;
1089 fsp->directory_delete_on_close = False;
1092 * Note that the file name here is the *untranslated* name
1093 * ie. it is still in the DOS codepage sent from the client.
1094 * All use of this filename will pass though the sys_xxxx
1095 * functions which will do the dos_to_unix translation before
1096 * mapping into a UNIX filename. JRA.
1098 string_set(&fsp->fsp_name,fname);
1099 fsp->wbmpx_ptr = NULL;
1100 fsp->wcp = NULL; /* Write cache pointer. */
1105 /****************************************************************************
1106 Open a directory from an NT SMB call.
1107 ****************************************************************************/
1109 int open_directory(files_struct *fsp,connection_struct *conn,
1110 char *fname, int smb_ofun, mode_t unixmode, int *action)
1112 extern struct current_user current_user;
1114 BOOL got_stat = False;
1116 if(dos_stat(fname, &st) == 0) {
1120 if (got_stat && (GET_FILE_OPEN_DISPOSITION(smb_ofun) == FILE_EXISTS_FAIL)) {
1121 errno = EEXIST; /* Setup so correct error is returned to client. */
1125 if (GET_FILE_CREATE_DISPOSITION(smb_ofun) == FILE_CREATE_IF_NOT_EXIST) {
1129 if(!S_ISDIR(st.st_mode)) {
1130 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1134 *action = FILE_WAS_OPENED;
1139 * Try and create the directory.
1142 if(!CAN_WRITE(conn)) {
1143 DEBUG(2,("open_directory: failing create on read-only share\n"));
1148 if(dos_mkdir(fname, unix_mode(conn,aDIR)) < 0) {
1149 DEBUG(0,("open_directory: unable to create %s. Error was %s\n",
1150 fname, strerror(errno) ));
1153 *action = FILE_WAS_CREATED;
1159 * Don't create - just check that it *was* a directory.
1163 DEBUG(0,("open_directory: unable to stat name = %s. Error was %s\n",
1164 fname, strerror(errno) ));
1168 if(!S_ISDIR(st.st_mode)) {
1169 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1173 *action = FILE_WAS_OPENED;
1176 DEBUG(5,("open_directory: opening directory %s\n",
1180 * Setup the files_struct for it.
1184 conn->num_files_open++;
1186 GetTimeOfDay(&fsp->open_time);
1187 fsp->vuid = current_user.vuid;
1191 fsp->can_lock = True;
1192 fsp->can_read = False;
1193 fsp->can_write = False;
1194 fsp->share_mode = 0;
1195 fsp->print_file = False;
1196 fsp->modified = False;
1197 fsp->oplock_type = NO_OPLOCK;
1198 fsp->sent_oplock_break = NO_BREAK_SENT;
1199 fsp->is_directory = True;
1200 fsp->directory_delete_on_close = False;
1203 * Note that the file name here is the *untranslated* name
1204 * ie. it is still in the DOS codepage sent from the client.
1205 * All use of this filename will pass though the sys_xxxx
1206 * functions which will do the dos_to_unix translation before
1207 * mapping into a UNIX filename. JRA.
1209 string_set(&fsp->fsp_name,fname);
1210 fsp->wbmpx_ptr = NULL;
1215 /*******************************************************************
1216 Check if the share mode on a file allows it to be deleted or unlinked.
1217 Return True if sharing doesn't prevent the operation.
1218 ********************************************************************/
1220 BOOL check_file_sharing(connection_struct *conn,char *fname, BOOL rename_op)
1224 share_mode_entry *old_shares = 0;
1225 int num_share_modes;
1226 SMB_STRUCT_STAT sbuf;
1228 pid_t pid = getpid();
1232 if(!lp_share_modes(SNUM(conn)))
1235 if (dos_stat(fname,&sbuf) == -1) return(True);
1238 inode = sbuf.st_ino;
1240 lock_share_entry(conn, dev, inode, &token);
1241 num_share_modes = get_share_modes(conn, token, dev, inode, &old_shares);
1244 * Check if the share modes will give us access.
1247 if(num_share_modes != 0)
1254 broke_oplock = False;
1255 for(i = 0; i < num_share_modes; i++)
1257 share_mode_entry *share_entry = &old_shares[i];
1260 * Break oplocks before checking share modes. See comment in
1261 * open_file_shared for details.
1262 * Check if someone has an oplock on this file. If so we must
1263 * break it before continuing.
1265 if(BATCH_OPLOCK_TYPE(share_entry->op_type))
1270 /* JRA. Try removing this code to see if the new oplock changes
1271 fix the problem. I'm dubious, but Andrew is recommending we
1276 * It appears that the NT redirector may have a bug, in that
1277 * it tries to do an SMBmv on a file that it has open with a
1278 * batch oplock, and then fails to respond to the oplock break
1279 * request. This only seems to occur when the client is doing an
1280 * SMBmv to the smbd it is using - thus we try and detect this
1281 * condition by checking if the file being moved is open and oplocked by
1282 * this smbd process, and then not sending the oplock break in this
1283 * special case. If the file was open with a deny mode that
1284 * prevents the move the SMBmv will fail anyway with a share
1285 * violation error. JRA.
1287 if(rename_op && (share_entry->pid == pid))
1290 DEBUG(0,("check_file_sharing: NT redirector workaround - rename attempted on \
1291 batch oplocked file %s, dev = %x, inode = %.0f\n", fname, (unsigned int)dev, (double)inode));
1294 * This next line is a test that allows the deny-mode
1295 * processing to be skipped. This seems to be needed as
1296 * NT insists on the rename succeeding (in Office 9x no less !).
1297 * This should be removed as soon as (a) MS fix the redirector
1298 * bug or (b) NT SMB support in Samba makes NT not issue the
1299 * call (as is my fervent hope). JRA.
1307 DEBUG(5,("check_file_sharing: breaking oplock (%x) on file %s, \
1308 dev = %x, inode = %.0f\n", share_entry->op_type, fname, (unsigned int)dev, (double)inode));
1310 /* Oplock break.... */
1311 unlock_share_entry(conn, dev, inode, token);
1312 if(request_oplock_break(share_entry, dev, inode) == False)
1314 free((char *)old_shares);
1316 DEBUG(0,("check_file_sharing: FAILED when breaking oplock (%x) on file %s, \
1317 dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
1321 lock_share_entry(conn, dev, inode, &token);
1322 broke_oplock = True;
1328 * If this is a delete request and ALLOW_SHARE_DELETE is set then allow
1329 * this to proceed. This takes precedence over share modes.
1332 if(!rename_op && GET_ALLOW_SHARE_DELETE(share_entry->share_mode))
1336 * Someone else has a share lock on it, check to see
1340 if ((GET_DENY_MODE(share_entry->share_mode) != DENY_DOS) || (share_entry->pid != pid))
1347 free((char *)old_shares);
1348 num_share_modes = get_share_modes(conn, token, dev, inode, &old_shares);
1350 } while(broke_oplock);
1353 /* XXXX exactly what share mode combinations should be allowed for
1354 deleting/renaming? */
1356 * If we got here then either there were no share modes or
1357 * all share modes were DENY_DOS and the pid == getpid() or
1358 * delete access was requested and all share modes had the
1359 * ALLOW_SHARE_DELETE bit set (takes precedence over other
1367 unlock_share_entry(conn, dev, inode, token);
1368 if(old_shares != NULL)
1369 free((char *)old_shares);