2 Unix SMB/CIFS implementation.
3 file opening and share modes
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Jeremy Allison 2001-2004
6 Copyright (C) Volker Lendecke 2005
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 struct generic_mapping file_generic_mapping;
26 extern struct current_user current_user;
27 extern userdom_struct current_user_info;
28 extern uint16 global_smbpid;
29 extern BOOL global_client_failed_oplock_break;
31 struct deferred_open_record {
32 BOOL delayed_for_oplocks;
37 /****************************************************************************
38 fd support routines - attempt to do a dos_open.
39 ****************************************************************************/
41 static int fd_open(struct connection_struct *conn,
48 if (!lp_symlinks(SNUM(conn))) {
53 fd = SMB_VFS_OPEN(conn,fname,flags,mode);
55 DEBUG(10,("fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s\n", fname,
56 flags, (int)mode, fd, (fd == -1) ? strerror(errno) : "" ));
61 /****************************************************************************
62 Close the file associated with a fsp.
63 ****************************************************************************/
65 int fd_close(struct connection_struct *conn,
68 if (fsp->fh->fd == -1) {
69 return 0; /* What we used to call a stat open. */
71 if (fsp->fh->ref_count > 1) {
72 return 0; /* Shared handle. Only close last reference. */
74 return fd_close_posix(conn, fsp);
77 /****************************************************************************
78 Change the ownership of a file to that of the parent directory.
79 Do this by fd if possible.
80 ****************************************************************************/
82 void change_owner_to_parent(connection_struct *conn,
85 SMB_STRUCT_STAT *psbuf)
87 const char *parent_path = parent_dirname(fname);
88 SMB_STRUCT_STAT parent_st;
91 ret = SMB_VFS_STAT(conn, parent_path, &parent_st);
93 DEBUG(0,("change_owner_to_parent: failed to stat parent "
94 "directory %s. Error was %s\n",
95 parent_path, strerror(errno) ));
99 if (fsp && fsp->fh->fd != -1) {
101 ret = SMB_VFS_FCHOWN(fsp, fsp->fh->fd, parent_st.st_uid, (gid_t)-1);
104 DEBUG(0,("change_owner_to_parent: failed to fchown "
105 "file %s to parent directory uid %u. Error "
107 (unsigned int)parent_st.st_uid,
111 DEBUG(10,("change_owner_to_parent: changed new file %s to "
112 "parent directory uid %u.\n", fname,
113 (unsigned int)parent_st.st_uid ));
116 /* We've already done an lstat into psbuf, and we know it's a
117 directory. If we can cd into the directory and the dev/ino
118 are the same then we can safely chown without races as
119 we're locking the directory in place by being in it. This
120 should work on any UNIX (thanks tridge :-). JRA.
124 SMB_STRUCT_STAT sbuf;
126 if (!vfs_GetWd(conn,saved_dir)) {
127 DEBUG(0,("change_owner_to_parent: failed to get "
128 "current working directory\n"));
132 /* Chdir into the new path. */
133 if (vfs_ChDir(conn, fname) == -1) {
134 DEBUG(0,("change_owner_to_parent: failed to change "
135 "current working directory to %s. Error "
136 "was %s\n", fname, strerror(errno) ));
140 if (SMB_VFS_STAT(conn,".",&sbuf) == -1) {
141 DEBUG(0,("change_owner_to_parent: failed to stat "
142 "directory '.' (%s) Error was %s\n",
143 fname, strerror(errno)));
147 /* Ensure we're pointing at the same place. */
148 if (sbuf.st_dev != psbuf->st_dev ||
149 sbuf.st_ino != psbuf->st_ino ||
150 sbuf.st_mode != psbuf->st_mode ) {
151 DEBUG(0,("change_owner_to_parent: "
152 "device/inode/mode on directory %s changed. "
153 "Refusing to chown !\n", fname ));
158 ret = SMB_VFS_CHOWN(conn, ".", parent_st.st_uid, (gid_t)-1);
161 DEBUG(10,("change_owner_to_parent: failed to chown "
162 "directory %s to parent directory uid %u. "
163 "Error was %s\n", fname,
164 (unsigned int)parent_st.st_uid, strerror(errno) ));
168 DEBUG(10,("change_owner_to_parent: changed ownership of new "
169 "directory %s to parent directory uid %u.\n",
170 fname, (unsigned int)parent_st.st_uid ));
174 vfs_ChDir(conn,saved_dir);
178 /****************************************************************************
180 ****************************************************************************/
182 static BOOL open_file(files_struct *fsp,
183 connection_struct *conn,
185 SMB_STRUCT_STAT *psbuf,
190 int accmode = (flags & O_ACCMODE);
191 int local_flags = flags;
192 BOOL file_existed = VALID_STAT(*psbuf);
197 /* Check permissions */
200 * This code was changed after seeing a client open request
201 * containing the open mode of (DENY_WRITE/read-only) with
202 * the 'create if not exist' bit set. The previous code
203 * would fail to open the file read only on a read-only share
204 * as it was checking the flags parameter directly against O_RDONLY,
205 * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
209 if (!CAN_WRITE(conn)) {
210 /* It's a read-only share - fail if we wanted to write. */
211 if(accmode != O_RDONLY) {
212 DEBUG(3,("Permission denied opening %s\n",fname));
214 } else if(flags & O_CREAT) {
215 /* We don't want to write - but we must make sure that
216 O_CREAT doesn't create the file if we have write
217 access into the directory.
220 local_flags &= ~O_CREAT;
225 * This little piece of insanity is inspired by the
226 * fact that an NT client can open a file for O_RDONLY,
227 * but set the create disposition to FILE_EXISTS_TRUNCATE.
228 * If the client *can* write to the file, then it expects to
229 * truncate the file, even though it is opening for readonly.
230 * Quicken uses this stupid trick in backup file creation...
231 * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
232 * for helping track this one down. It didn't bite us in 2.0.x
233 * as we always opened files read-write in that release. JRA.
236 if ((accmode == O_RDONLY) && ((flags & O_TRUNC) == O_TRUNC)) {
237 DEBUG(10,("open_file: truncate requested on read-only open "
238 "for file %s\n",fname ));
239 local_flags = (flags & ~O_ACCMODE)|O_RDWR;
242 if ((access_mask & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ||
243 (local_flags & O_CREAT) ||
244 ((local_flags & O_TRUNC) == O_TRUNC) ) {
247 * We can't actually truncate here as the file may be locked.
248 * open_file_ntcreate will take care of the truncate later. JRA.
251 local_flags &= ~O_TRUNC;
253 #if defined(O_NONBLOCK) && defined(S_ISFIFO)
255 * We would block on opening a FIFO with no one else on the
256 * other end. Do what we used to do and add O_NONBLOCK to the
260 if (file_existed && S_ISFIFO(psbuf->st_mode)) {
261 local_flags |= O_NONBLOCK;
265 /* Don't create files with Microsoft wildcard characters. */
266 if ((local_flags & O_CREAT) && !file_existed &&
267 ms_has_wild(fname)) {
268 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_INVALID);
272 /* Actually do the open */
273 fsp->fh->fd = fd_open(conn, fname, local_flags, unx_mode);
274 if (fsp->fh->fd == -1) {
275 DEBUG(3,("Error opening file %s (%s) (local_flags=%d) "
277 fname,strerror(errno),local_flags,flags));
281 /* Inherit the ACL if the file was created. */
282 if ((local_flags & O_CREAT) && !file_existed) {
283 inherit_access_acl(conn, fname, unx_mode);
287 fsp->fh->fd = -1; /* What we used to call a stat open. */
293 if (fsp->fh->fd == -1) {
294 ret = SMB_VFS_STAT(conn, fname, psbuf);
296 ret = SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf);
297 /* If we have an fd, this stat should succeed. */
299 DEBUG(0,("Error doing fstat on open file %s "
300 "(%s)\n", fname,strerror(errno) ));
304 /* For a non-io open, this stat failing means file not found. JRA */
312 * POSIX allows read-only opens of directories. We don't
313 * want to do this (we use a different code path for this)
314 * so catch a directory open and return an EISDIR. JRA.
317 if(S_ISDIR(psbuf->st_mode)) {
323 fsp->mode = psbuf->st_mode;
324 fsp->inode = psbuf->st_ino;
325 fsp->dev = psbuf->st_dev;
326 fsp->vuid = current_user.vuid;
327 fsp->file_pid = global_smbpid;
328 fsp->can_lock = True;
329 fsp->can_read = (access_mask & (FILE_READ_DATA)) ? True : False;
330 if (!CAN_WRITE(conn)) {
331 fsp->can_write = False;
333 fsp->can_write = (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) ? True : False;
335 fsp->print_file = False;
336 fsp->modified = False;
337 fsp->sent_oplock_break = NO_BREAK_SENT;
338 fsp->is_directory = False;
339 fsp->is_stat = False;
340 if (conn->aio_write_behind_list &&
341 is_in_path(fname, conn->aio_write_behind_list, conn->case_sensitive)) {
342 fsp->aio_write_behind = True;
345 string_set(&fsp->fsp_name,fname);
346 fsp->wcp = NULL; /* Write cache pointer. */
348 DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
349 *current_user_info.smb_name ? current_user_info.smb_name : conn->user,fsp->fsp_name,
350 BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
351 conn->num_files_open + 1));
357 /*******************************************************************
358 Return True if the filename is one of the special executable types.
359 ********************************************************************/
361 static BOOL is_executable(const char *fname)
363 if ((fname = strrchr_m(fname,'.'))) {
364 if (strequal(fname,".com") ||
365 strequal(fname,".dll") ||
366 strequal(fname,".exe") ||
367 strequal(fname,".sym")) {
374 /****************************************************************************
375 Check if we can open a file with a share mode.
376 Returns True if conflict, False if not.
377 ****************************************************************************/
379 static BOOL share_conflict(struct share_mode_entry *entry,
383 DEBUG(10,("share_conflict: entry->access_mask = 0x%x, "
384 "entry->share_access = 0x%x, "
385 "entry->private_options = 0x%x\n",
386 (unsigned int)entry->access_mask,
387 (unsigned int)entry->share_access,
388 (unsigned int)entry->private_options));
390 DEBUG(10,("share_conflict: access_mask = 0x%x, share_access = 0x%x\n",
391 (unsigned int)access_mask, (unsigned int)share_access));
393 if ((entry->access_mask & (FILE_WRITE_DATA|
397 DELETE_ACCESS)) == 0) {
398 DEBUG(10,("share_conflict: No conflict due to "
399 "entry->access_mask = 0x%x\n",
400 (unsigned int)entry->access_mask ));
404 if ((access_mask & (FILE_WRITE_DATA|
408 DELETE_ACCESS)) == 0) {
409 DEBUG(10,("share_conflict: No conflict due to "
410 "access_mask = 0x%x\n",
411 (unsigned int)access_mask ));
415 #if 1 /* JRA TEST - Superdebug. */
416 #define CHECK_MASK(num, am, right, sa, share) \
417 DEBUG(10,("share_conflict: [%d] am (0x%x) & right (0x%x) = 0x%x\n", \
418 (unsigned int)(num), (unsigned int)(am), \
419 (unsigned int)(right), (unsigned int)(am)&(right) )); \
420 DEBUG(10,("share_conflict: [%d] sa (0x%x) & share (0x%x) = 0x%x\n", \
421 (unsigned int)(num), (unsigned int)(sa), \
422 (unsigned int)(share), (unsigned int)(sa)&(share) )); \
423 if (((am) & (right)) && !((sa) & (share))) { \
424 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
425 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
426 (unsigned int)(share) )); \
430 #define CHECK_MASK(num, am, right, sa, share) \
431 if (((am) & (right)) && !((sa) & (share))) { \
432 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
433 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
434 (unsigned int)(share) )); \
439 CHECK_MASK(1, entry->access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
440 share_access, FILE_SHARE_WRITE);
441 CHECK_MASK(2, access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
442 entry->share_access, FILE_SHARE_WRITE);
444 CHECK_MASK(3, entry->access_mask, FILE_READ_DATA | FILE_EXECUTE,
445 share_access, FILE_SHARE_READ);
446 CHECK_MASK(4, access_mask, FILE_READ_DATA | FILE_EXECUTE,
447 entry->share_access, FILE_SHARE_READ);
449 CHECK_MASK(5, entry->access_mask, DELETE_ACCESS,
450 share_access, FILE_SHARE_DELETE);
451 CHECK_MASK(6, access_mask, DELETE_ACCESS,
452 entry->share_access, FILE_SHARE_DELETE);
454 DEBUG(10,("share_conflict: No conflict.\n"));
458 #if defined(DEVELOPER)
459 static void validate_my_share_entries(int num,
460 struct share_mode_entry *share_entry)
464 if (!procid_is_me(&share_entry->pid)) {
468 if (is_deferred_open_entry(share_entry) &&
469 !open_was_deferred(share_entry->op_mid)) {
471 DEBUG(0, ("Got a deferred entry without a request: "
472 "PANIC: %s\n", share_mode_str(num, share_entry)));
476 if (!is_valid_share_mode_entry(share_entry)) {
480 fsp = file_find_dif(share_entry->dev, share_entry->inode,
481 share_entry->share_file_id);
483 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
484 share_mode_str(num, share_entry) ));
485 smb_panic("validate_my_share_entries: Cannot match a "
486 "share entry with an open file\n");
489 if (is_deferred_open_entry(share_entry) ||
490 is_unused_share_mode_entry(share_entry)) {
494 if ((share_entry->op_type == NO_OPLOCK) &&
495 (fsp->oplock_type == FAKE_LEVEL_II_OPLOCK)) {
496 /* Someone has already written to it, but I haven't yet
501 if (((uint16)fsp->oplock_type) != share_entry->op_type) {
510 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
511 share_mode_str(num, share_entry) ));
512 slprintf(str, sizeof(str)-1, "validate_my_share_entries: "
513 "file %s, oplock_type = 0x%x, op_type = 0x%x\n",
514 fsp->fsp_name, (unsigned int)fsp->oplock_type,
515 (unsigned int)share_entry->op_type );
521 static BOOL is_stat_open(uint32 access_mask)
523 return (access_mask &&
524 ((access_mask & ~(SYNCHRONIZE_ACCESS| FILE_READ_ATTRIBUTES|
525 FILE_WRITE_ATTRIBUTES))==0) &&
526 ((access_mask & (SYNCHRONIZE_ACCESS|FILE_READ_ATTRIBUTES|
527 FILE_WRITE_ATTRIBUTES)) != 0));
530 /****************************************************************************
531 Deal with share modes
532 Invarient: Share mode must be locked on entry and exit.
533 Returns -1 on error, or number of share modes on success (may be zero).
534 ****************************************************************************/
536 static NTSTATUS open_mode_check(connection_struct *conn,
538 struct share_mode_lock *lck,
541 uint32 create_options,
546 if(lck->num_share_modes == 0) {
550 *file_existed = True;
552 if (is_stat_open(access_mask)) {
553 /* Stat open that doesn't trigger oplock breaks or share mode
554 * checks... ! JRA. */
558 /* A delete on close prohibits everything */
560 if (lck->delete_on_close) {
561 return NT_STATUS_DELETE_PENDING;
565 * Check if the share modes will give us access.
568 #if defined(DEVELOPER)
569 for(i = 0; i < lck->num_share_modes; i++) {
570 validate_my_share_entries(i, &lck->share_modes[i]);
574 if (!lp_share_modes(SNUM(conn))) {
578 /* Now we check the share modes, after any oplock breaks. */
579 for(i = 0; i < lck->num_share_modes; i++) {
581 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
585 /* someone else has a share lock on it, check to see if we can
587 if (share_conflict(&lck->share_modes[i],
588 access_mask, share_access)) {
589 return NT_STATUS_SHARING_VIOLATION;
596 static BOOL is_delete_request(files_struct *fsp) {
597 return ((fsp->access_mask == DELETE_ACCESS) &&
598 (fsp->oplock_type == NO_OPLOCK));
602 * 1) No files open at all: Grant whatever the client wants.
604 * 2) Exclusive (or batch) oplock around: If the requested access is a delete
605 * request, break if the oplock around is a batch oplock. If it's another
606 * requested access type, break.
608 * 3) Only level2 around: Grant level2 and do nothing else.
611 static BOOL delay_for_oplocks(struct share_mode_lock *lck, files_struct *fsp, int pass_number)
614 struct share_mode_entry *exclusive = NULL;
615 BOOL valid_entry = False;
616 BOOL delay_it = False;
617 BOOL have_level2 = False;
619 if (is_stat_open(fsp->access_mask)) {
620 fsp->oplock_type = NO_OPLOCK;
624 for (i=0; i<lck->num_share_modes; i++) {
626 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
630 /* At least one entry is not an invalid or deferred entry. */
633 if (pass_number == 1) {
634 if (BATCH_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
635 SMB_ASSERT(exclusive == NULL);
636 exclusive = &lck->share_modes[i];
639 if (EXCLUSIVE_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
640 SMB_ASSERT(exclusive == NULL);
641 exclusive = &lck->share_modes[i];
645 if (lck->share_modes[i].op_type == LEVEL_II_OPLOCK) {
646 SMB_ASSERT(exclusive == NULL);
652 /* All entries are placeholders or deferred.
653 * Directly grant whatever the client wants. */
654 if (fsp->oplock_type == NO_OPLOCK) {
655 /* Store a level2 oplock, but don't tell the client */
656 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
661 if (exclusive != NULL) { /* Found an exclusive oplock */
662 SMB_ASSERT(!have_level2);
663 delay_it = is_delete_request(fsp) ?
664 BATCH_OPLOCK_TYPE(exclusive->op_type) : True;
667 if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
668 /* We can at most grant level2 as there are other
669 * level2 or NO_OPLOCK entries. */
670 fsp->oplock_type = LEVEL_II_OPLOCK;
673 if ((fsp->oplock_type == NO_OPLOCK) && have_level2) {
674 /* Store a level2 oplock, but don't tell the client */
675 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
680 char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
682 DEBUG(10, ("Sending break request to PID %s\n",
683 procid_str_static(&exclusive->pid)));
684 exclusive->op_mid = get_current_mid();
686 share_mode_entry_to_message(msg, exclusive);
689 ret = message_send_pid(exclusive->pid, MSG_SMB_BREAK_REQUEST,
690 msg, MSG_SMB_SHARE_MODE_ENTRY_SIZE, True);
693 DEBUG(3, ("Could not send oplock break message\n"));
701 static BOOL request_timed_out(struct timeval request_time,
702 struct timeval timeout)
704 struct timeval now, end_time;
706 end_time = timeval_sum(&request_time, &timeout);
707 return (timeval_compare(&end_time, &now) < 0);
710 /****************************************************************************
711 Handle the 1 second delay in returning a SHARING_VIOLATION error.
712 ****************************************************************************/
714 static void defer_open(struct share_mode_lock *lck,
715 struct timeval request_time,
716 struct timeval timeout,
717 struct deferred_open_record *state)
719 uint16 mid = get_current_mid();
724 for (i=0; i<lck->num_share_modes; i++) {
725 struct share_mode_entry *e = &lck->share_modes[i];
727 if (!is_deferred_open_entry(e)) {
731 if (procid_is_me(&e->pid) && (e->op_mid == mid)) {
732 DEBUG(0, ("Trying to defer an already deferred "
733 "request: mid=%d, exiting\n", mid));
734 exit_server("attempt to defer a deferred request");
738 /* End paranoia check */
740 DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred "
741 "open entry for mid %u\n",
742 (unsigned int)request_time.tv_sec,
743 (unsigned int)request_time.tv_usec,
746 if (!push_deferred_smb_message(mid, request_time, timeout,
747 (char *)state, sizeof(*state))) {
748 exit_server("push_deferred_smb_message failed");
750 add_deferred_open(lck, mid, request_time, state->dev, state->inode);
753 * Push the MID of this packet on the signing queue.
754 * We only do this once, the first time we push the packet
755 * onto the deferred open queue, as this has a side effect
756 * of incrementing the response sequence number.
759 srv_defer_sign_response(mid);
762 /****************************************************************************
763 Set a kernel flock on a file for NFS interoperability.
764 This requires a patch to Linux.
765 ****************************************************************************/
767 static void kernel_flock(files_struct *fsp, uint32 share_mode)
769 #if HAVE_KERNEL_SHARE_MODES
771 if (share_mode == FILE_SHARE_WRITE) {
772 kernel_mode = LOCK_MAND|LOCK_WRITE;
773 } else if (share_mode == FILE_SHARE_READ) {
774 kernel_mode = LOCK_MAND|LOCK_READ;
775 } else if (share_mode == FILE_SHARE_NONE) {
776 kernel_mode = LOCK_MAND;
779 flock(fsp->fh->fd, kernel_mode);
785 /****************************************************************************
786 On overwrite open ensure that the attributes match.
787 ****************************************************************************/
789 static BOOL open_match_attributes(connection_struct *conn,
793 mode_t existing_unx_mode,
795 mode_t *returned_unx_mode)
797 uint32 noarch_old_dos_attr, noarch_new_dos_attr;
799 noarch_old_dos_attr = (old_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
800 noarch_new_dos_attr = (new_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
802 if((noarch_old_dos_attr == 0 && noarch_new_dos_attr != 0) ||
803 (noarch_old_dos_attr != 0 && ((noarch_old_dos_attr & noarch_new_dos_attr) == noarch_old_dos_attr))) {
804 *returned_unx_mode = new_unx_mode;
806 *returned_unx_mode = (mode_t)0;
809 DEBUG(10,("open_match_attributes: file %s old_dos_attr = 0x%x, "
810 "existing_unx_mode = 0%o, new_dos_attr = 0x%x "
811 "returned_unx_mode = 0%o\n",
813 (unsigned int)old_dos_attr,
814 (unsigned int)existing_unx_mode,
815 (unsigned int)new_dos_attr,
816 (unsigned int)*returned_unx_mode ));
818 /* If we're mapping SYSTEM and HIDDEN ensure they match. */
819 if (lp_map_system(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
820 if ((old_dos_attr & FILE_ATTRIBUTE_SYSTEM) &&
821 !(new_dos_attr & FILE_ATTRIBUTE_SYSTEM)) {
825 if (lp_map_hidden(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
826 if ((old_dos_attr & FILE_ATTRIBUTE_HIDDEN) &&
827 !(new_dos_attr & FILE_ATTRIBUTE_HIDDEN)) {
834 /****************************************************************************
835 Special FCB or DOS processing in the case of a sharing violation.
836 Try and find a duplicated file handle.
837 ****************************************************************************/
839 static files_struct *fcb_or_dos_open(connection_struct *conn,
840 const char *fname, SMB_DEV_T dev,
844 uint32 create_options)
847 files_struct *dup_fsp;
849 DEBUG(5,("fcb_or_dos_open: attempting old open semantics for "
850 "file %s.\n", fname ));
852 for(fsp = file_find_di_first(dev, inode); fsp;
853 fsp = file_find_di_next(fsp)) {
855 DEBUG(10,("fcb_or_dos_open: checking file %s, fd = %d, "
856 "vuid = %u, file_pid = %u, private_options = 0x%x "
857 "access_mask = 0x%x\n", fsp->fsp_name,
858 fsp->fh->fd, (unsigned int)fsp->vuid,
859 (unsigned int)fsp->file_pid,
860 (unsigned int)fsp->fh->private_options,
861 (unsigned int)fsp->access_mask ));
863 if (fsp->fh->fd != -1 &&
864 fsp->vuid == current_user.vuid &&
865 fsp->file_pid == global_smbpid &&
866 (fsp->fh->private_options & (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS |
867 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) &&
868 (fsp->access_mask & FILE_WRITE_DATA) &&
869 strequal(fsp->fsp_name, fname)) {
870 DEBUG(10,("fcb_or_dos_open: file match\n"));
879 /* quite an insane set of semantics ... */
880 if (is_executable(fname) &&
881 (fsp->fh->private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS)) {
882 DEBUG(10,("fcb_or_dos_open: file fail due to is_executable.\n"));
886 /* We need to duplicate this fsp. */
887 dup_fsp = dup_file_fsp(fsp, access_mask, share_access, create_options);
895 /****************************************************************************
896 Open a file with a share mode - old openX method - map into NTCreate.
897 ****************************************************************************/
899 BOOL map_open_params_to_ntcreate(const char *fname, int deny_mode, int open_func,
900 uint32 *paccess_mask,
902 uint32 *pcreate_disposition,
903 uint32 *pcreate_options)
907 uint32 create_disposition;
908 uint32 create_options = 0;
910 DEBUG(10,("map_open_params_to_ntcreate: fname = %s, deny_mode = 0x%x, "
911 "open_func = 0x%x\n",
912 fname, (unsigned int)deny_mode, (unsigned int)open_func ));
914 /* Create the NT compatible access_mask. */
915 switch (GET_OPENX_MODE(deny_mode)) {
916 case DOS_OPEN_EXEC: /* Implies read-only - used to be FILE_READ_DATA */
917 case DOS_OPEN_RDONLY:
918 access_mask = FILE_GENERIC_READ;
920 case DOS_OPEN_WRONLY:
921 access_mask = FILE_GENERIC_WRITE;
925 access_mask = FILE_GENERIC_READ|FILE_GENERIC_WRITE;
928 DEBUG(10,("map_open_params_to_ntcreate: bad open mode = 0x%x\n",
929 (unsigned int)GET_OPENX_MODE(deny_mode)));
933 /* Create the NT compatible create_disposition. */
935 case OPENX_FILE_EXISTS_FAIL|OPENX_FILE_CREATE_IF_NOT_EXIST:
936 create_disposition = FILE_CREATE;
939 case OPENX_FILE_EXISTS_OPEN:
940 create_disposition = FILE_OPEN;
943 case OPENX_FILE_EXISTS_OPEN|OPENX_FILE_CREATE_IF_NOT_EXIST:
944 create_disposition = FILE_OPEN_IF;
947 case OPENX_FILE_EXISTS_TRUNCATE:
948 create_disposition = FILE_OVERWRITE;
951 case OPENX_FILE_EXISTS_TRUNCATE|OPENX_FILE_CREATE_IF_NOT_EXIST:
952 create_disposition = FILE_OVERWRITE_IF;
956 /* From samba4 - to be confirmed. */
957 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_EXEC) {
958 create_disposition = FILE_CREATE;
961 DEBUG(10,("map_open_params_to_ntcreate: bad "
962 "open_func 0x%x\n", (unsigned int)open_func));
966 /* Create the NT compatible share modes. */
967 switch (GET_DENY_MODE(deny_mode)) {
969 share_mode = FILE_SHARE_NONE;
973 share_mode = FILE_SHARE_READ;
977 share_mode = FILE_SHARE_WRITE;
981 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
985 create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
986 if (is_executable(fname)) {
987 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
989 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_RDONLY) {
990 share_mode = FILE_SHARE_READ;
992 share_mode = FILE_SHARE_NONE;
998 create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
999 share_mode = FILE_SHARE_NONE;
1003 DEBUG(10,("map_open_params_to_ntcreate: bad deny_mode 0x%x\n",
1004 (unsigned int)GET_DENY_MODE(deny_mode) ));
1008 DEBUG(10,("map_open_params_to_ntcreate: file %s, access_mask = 0x%x, "
1009 "share_mode = 0x%x, create_disposition = 0x%x, "
1010 "create_options = 0x%x\n",
1012 (unsigned int)access_mask,
1013 (unsigned int)share_mode,
1014 (unsigned int)create_disposition,
1015 (unsigned int)create_options ));
1018 *paccess_mask = access_mask;
1021 *pshare_mode = share_mode;
1023 if (pcreate_disposition) {
1024 *pcreate_disposition = create_disposition;
1026 if (pcreate_options) {
1027 *pcreate_options = create_options;
1034 static void schedule_defer_open(struct share_mode_lock *lck, struct timeval request_time)
1036 struct deferred_open_record state;
1038 /* This is a relative time, added to the absolute
1039 request_time value to get the absolute timeout time.
1040 Note that if this is the second or greater time we enter
1041 this codepath for this particular request mid then
1042 request_time is left as the absolute time of the *first*
1043 time this request mid was processed. This is what allows
1044 the request to eventually time out. */
1046 struct timeval timeout;
1048 /* Normally the smbd we asked should respond within
1049 * OPLOCK_BREAK_TIMEOUT seconds regardless of whether
1050 * the client did, give twice the timeout as a safety
1051 * measure here in case the other smbd is stuck
1052 * somewhere else. */
1054 timeout = timeval_set(OPLOCK_BREAK_TIMEOUT*2, 0);
1056 /* Nothing actually uses state.delayed_for_oplocks
1057 but it's handy to differentiate in debug messages
1058 between a 30 second delay due to oplock break, and
1059 a 1 second delay for share mode conflicts. */
1061 state.delayed_for_oplocks = True;
1062 state.dev = lck->dev;
1063 state.inode = lck->ino;
1065 if (!request_timed_out(request_time, timeout)) {
1066 defer_open(lck, request_time, timeout, &state);
1070 /****************************************************************************
1071 Open a file with a share mode.
1072 ****************************************************************************/
1074 files_struct *open_file_ntcreate(connection_struct *conn,
1076 SMB_STRUCT_STAT *psbuf,
1077 uint32 access_mask, /* access bits (FILE_READ_DATA etc.) */
1078 uint32 share_access, /* share constants (FILE_SHARE_READ etc). */
1079 uint32 create_disposition, /* FILE_OPEN_IF etc. */
1080 uint32 create_options, /* options such as delete on close. */
1081 uint32 new_dos_attributes, /* attributes used for new file. */
1082 int oplock_request, /* internal Samba oplock codes. */
1083 /* Information (FILE_EXISTS etc.) */
1088 BOOL file_existed = VALID_STAT(*psbuf);
1089 BOOL def_acl = False;
1090 BOOL internal_only_open = False;
1092 SMB_INO_T inode = 0;
1093 BOOL fsp_open = False;
1094 files_struct *fsp = NULL;
1095 mode_t new_unx_mode = (mode_t)0;
1096 mode_t unx_mode = (mode_t)0;
1098 uint32 existing_dos_attributes = 0;
1099 struct pending_message_list *pml = NULL;
1100 uint16 mid = get_current_mid();
1101 BOOL delayed_for_oplocks = False;
1102 struct timeval request_time = timeval_zero();
1103 struct share_mode_lock *lck = NULL;
1106 if (conn->printer) {
1108 * Printers are handled completely differently.
1109 * Most of the passed parameters are ignored.
1113 *pinfo = FILE_WAS_CREATED;
1116 DEBUG(10, ("open_file_ntcreate: printer open fname=%s\n", fname));
1118 return print_fsp_open(conn, fname);
1121 /* We add aARCH to this as this mode is only used if the file is
1123 unx_mode = unix_mode(conn, new_dos_attributes | aARCH,fname, True);
1125 DEBUG(10, ("open_file_ntcreate: fname=%s, dos_attrs=0x%x "
1126 "access_mask=0x%x share_access=0x%x "
1127 "create_disposition = 0x%x create_options=0x%x "
1128 "unix mode=0%o oplock_request=%d\n",
1129 fname, new_dos_attributes, access_mask, share_access,
1130 create_disposition, create_options, unx_mode,
1133 if (oplock_request == INTERNAL_OPEN_ONLY) {
1134 internal_only_open = True;
1138 if ((pml = get_open_deferred_message(mid)) != NULL) {
1139 struct deferred_open_record *state =
1140 (struct deferred_open_record *)pml->private_data.data;
1142 /* Remember the absolute time of the original
1143 request with this mid. We'll use it later to
1144 see if this has timed out. */
1146 request_time = pml->request_time;
1147 delayed_for_oplocks = state->delayed_for_oplocks;
1149 /* Remove the deferred open entry under lock. */
1150 lck = get_share_mode_lock(NULL, state->dev, state->inode, NULL, NULL);
1152 DEBUG(0, ("could not get share mode lock\n"));
1154 del_deferred_open_entry(lck, mid);
1158 /* Ensure we don't reprocess this message. */
1159 remove_deferred_open_smb_message(mid);
1162 if (!check_name(fname,conn)) {
1166 new_dos_attributes &= SAMBA_ATTRIBUTES_MASK;
1168 existing_dos_attributes = dos_mode(conn, fname, psbuf);
1171 /* ignore any oplock requests if oplocks are disabled */
1172 if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break ||
1173 IS_VETO_OPLOCK_PATH(conn, fname)) {
1177 /* this is for OS/2 long file names - say we don't support them */
1178 if (!lp_posix_pathnames() && strstr(fname,".+,;=[].")) {
1179 /* OS/2 Workplace shell fix may be main code stream in a later
1181 set_saved_error_triple(ERRDOS, ERRcannotopen,
1182 NT_STATUS_OBJECT_NAME_NOT_FOUND);
1183 DEBUG(5,("open_file_ntcreate: OS/2 long filenames are not "
1188 switch( create_disposition ) {
1190 * Currently we're using FILE_SUPERSEDE as the same as
1191 * FILE_OVERWRITE_IF but they really are
1192 * different. FILE_SUPERSEDE deletes an existing file
1193 * (requiring delete access) then recreates it.
1195 case FILE_SUPERSEDE:
1196 /* If file exists replace/overwrite. If file doesn't
1198 flags2 |= (O_CREAT | O_TRUNC);
1201 case FILE_OVERWRITE_IF:
1202 /* If file exists replace/overwrite. If file doesn't
1204 flags2 |= (O_CREAT | O_TRUNC);
1208 /* If file exists open. If file doesn't exist error. */
1209 if (!file_existed) {
1210 DEBUG(5,("open_file_ntcreate: FILE_OPEN "
1211 "requested for file %s and file "
1212 "doesn't exist.\n", fname ));
1213 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_NOT_FOUND);
1219 case FILE_OVERWRITE:
1220 /* If file exists overwrite. If file doesn't exist
1222 if (!file_existed) {
1223 DEBUG(5,("open_file_ntcreate: FILE_OVERWRITE "
1224 "requested for file %s and file "
1225 "doesn't exist.\n", fname ));
1226 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_NOT_FOUND);
1234 /* If file exists error. If file doesn't exist
1237 DEBUG(5,("open_file_ntcreate: FILE_CREATE "
1238 "requested for file %s and file "
1239 "already exists.\n", fname ));
1240 if (S_ISDIR(psbuf->st_mode)) {
1247 flags2 |= (O_CREAT|O_EXCL);
1251 /* If file exists open. If file doesn't exist
1257 set_saved_ntstatus(NT_STATUS_INVALID_PARAMETER);
1261 /* We only care about matching attributes on file exists and
1264 if (file_existed && ((create_disposition == FILE_OVERWRITE) ||
1265 (create_disposition == FILE_OVERWRITE_IF))) {
1266 if (!open_match_attributes(conn, fname,
1267 existing_dos_attributes,
1268 new_dos_attributes, psbuf->st_mode,
1269 unx_mode, &new_unx_mode)) {
1270 DEBUG(5,("open_file_ntcreate: attributes missmatch "
1271 "for file %s (%x %x) (0%o, 0%o)\n",
1272 fname, existing_dos_attributes,
1274 (unsigned int)psbuf->st_mode,
1275 (unsigned int)unx_mode ));
1281 /* This is a nasty hack - must fix... JRA. */
1282 if (access_mask == MAXIMUM_ALLOWED_ACCESS) {
1283 access_mask = FILE_GENERIC_ALL;
1287 * Convert GENERIC bits to specific bits.
1290 se_map_generic(&access_mask, &file_generic_mapping);
1292 DEBUG(10, ("open_file_ntcreate: fname=%s, after mapping "
1293 "access_mask=0x%x\n", fname, access_mask ));
1296 * Note that we ignore the append flag as append does not
1297 * mean the same thing under DOS and Unix.
1300 if (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) {
1307 * Currently we only look at FILE_WRITE_THROUGH for create options.
1311 if ((create_options & FILE_WRITE_THROUGH) && lp_strict_sync(SNUM(conn))) {
1316 if (!CAN_WRITE(conn)) {
1318 * We should really return a permission denied error if either
1319 * O_CREAT or O_TRUNC are set, but for compatibility with
1320 * older versions of Samba we just AND them out.
1322 flags2 &= ~(O_CREAT|O_TRUNC);
1326 * Ensure we can't write on a read-only share or file.
1329 if (flags != O_RDONLY && file_existed &&
1330 (!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_attributes))) {
1331 DEBUG(5,("open_file_ntcreate: write access requested for "
1332 "file %s on read only %s\n",
1333 fname, !CAN_WRITE(conn) ? "share" : "file" ));
1334 set_saved_ntstatus(NT_STATUS_ACCESS_DENIED);
1339 fsp = file_new(conn);
1344 fsp->dev = psbuf->st_dev;
1345 fsp->inode = psbuf->st_ino;
1346 fsp->share_access = share_access;
1347 fsp->fh->private_options = create_options;
1348 fsp->access_mask = access_mask;
1349 fsp->oplock_type = oplock_request;
1351 if (timeval_is_zero(&request_time)) {
1352 request_time = fsp->open_time;
1356 dev = psbuf->st_dev;
1357 inode = psbuf->st_ino;
1359 lck = get_share_mode_lock(NULL, dev, inode,
1364 DEBUG(0, ("Could not get share mode lock\n"));
1365 set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1369 /* First pass - send break only on batch oplocks. */
1370 if (delay_for_oplocks(lck, fsp, 1)) {
1371 schedule_defer_open(lck, request_time);
1376 status = open_mode_check(conn, fname, lck,
1377 access_mask, share_access,
1378 create_options, &file_existed);
1380 if (NT_STATUS_IS_OK(status)) {
1381 /* We might be going to allow this open. Check oplock status again. */
1382 /* Second pass - send break for both batch or exclusive oplocks. */
1383 if (delay_for_oplocks(lck, fsp, 2)) {
1384 schedule_defer_open(lck, request_time);
1390 if (NT_STATUS_EQUAL(status, NT_STATUS_DELETE_PENDING)) {
1391 /* DELETE_PENDING is not deferred for a second */
1392 set_saved_ntstatus(status);
1398 if (!NT_STATUS_IS_OK(status)) {
1400 SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION));
1402 /* Check if this can be done with the deny_dos and fcb
1404 if (create_options &
1405 (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS|
1406 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
1407 files_struct *fsp_dup;
1408 fsp_dup = fcb_or_dos_open(conn, fname, dev,
1417 *pinfo = FILE_WAS_OPENED;
1419 conn->num_files_open++;
1425 * This next line is a subtlety we need for
1426 * MS-Access. If a file open will fail due to share
1427 * permissions and also for security (access) reasons,
1428 * we need to return the access failed error, not the
1429 * share error. This means we must attempt to open the
1430 * file anyway in order to get the UNIX access error -
1431 * even if we're going to fail the open for share
1432 * reasons. This is bad, as we're burning another fd
1433 * if there are existing locks but there's nothing
1434 * else we can do. We also ensure we're not going to
1435 * create or tuncate the file as we only want an
1436 * access decision at this stage. JRA.
1439 fsp_open = open_file(fsp,conn,fname,psbuf,
1440 flags|(flags2&~(O_TRUNC|O_CREAT)),
1441 unx_mode,access_mask);
1443 DEBUG(4,("open_file_ntcreate : share_mode deny - "
1444 "calling open_file with flags=0x%X "
1445 "flags2=0x%X mode=0%o returned %d\n",
1446 flags, (flags2&~(O_TRUNC|O_CREAT)),
1447 (unsigned int)unx_mode, (int)fsp_open ));
1449 if (!fsp_open && errno) {
1450 /* Default error. */
1451 set_saved_ntstatus(NT_STATUS_ACCESS_DENIED);
1455 * If we're returning a share violation, ensure we
1456 * cope with the braindead 1 second delay.
1459 if (!internal_only_open &&
1460 lp_defer_sharing_violations()) {
1461 struct timeval timeout;
1462 struct deferred_open_record state;
1465 /* this is a hack to speed up torture tests
1467 timeout_usecs = lp_parm_int(conn->service,
1468 "smbd","sharedelay",
1469 SHARING_VIOLATION_USEC_WAIT);
1471 /* This is a relative time, added to the absolute
1472 request_time value to get the absolute timeout time.
1473 Note that if this is the second or greater time we enter
1474 this codepath for this particular request mid then
1475 request_time is left as the absolute time of the *first*
1476 time this request mid was processed. This is what allows
1477 the request to eventually time out. */
1479 timeout = timeval_set(0, timeout_usecs);
1481 /* Nothing actually uses state.delayed_for_oplocks
1482 but it's handy to differentiate in debug messages
1483 between a 30 second delay due to oplock break, and
1484 a 1 second delay for share mode conflicts. */
1486 state.delayed_for_oplocks = False;
1488 state.inode = inode;
1490 if (!request_timed_out(request_time,
1492 defer_open(lck, request_time, timeout,
1499 fd_close(conn, fsp);
1501 * We have detected a sharing violation here
1502 * so return the correct error code
1504 set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1511 * We exit this block with the share entry *locked*.....
1515 SMB_ASSERT(!file_existed || (lck != NULL));
1518 * Ensure we pay attention to default ACLs on directories if required.
1521 if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
1522 (def_acl = directory_has_default_acl(conn,
1523 parent_dirname(fname)))) {
1527 DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
1528 (unsigned int)flags, (unsigned int)flags2,
1529 (unsigned int)unx_mode));
1532 * open_file strips any O_TRUNC flags itself.
1535 fsp_open = open_file(fsp,conn,fname,psbuf,flags|flags2,unx_mode,
1546 if (!file_existed) {
1549 * Deal with the race condition where two smbd's detect the
1550 * file doesn't exist and do the create at the same time. One
1551 * of them will win and set a share mode, the other (ie. this
1552 * one) should check if the requested share mode for this
1553 * create is allowed.
1557 * Now the file exists and fsp is successfully opened,
1558 * fsp->dev and fsp->inode are valid and should replace the
1559 * dev=0,inode=0 from a non existent file. Spotted by
1560 * Nadav Danieli <nadavd@exanet.com>. JRA.
1566 lck = get_share_mode_lock(NULL, dev, inode,
1571 DEBUG(0, ("open_file_ntcreate: Could not get share mode lock for %s\n", fname));
1572 fd_close(conn, fsp);
1574 set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1578 status = open_mode_check(conn, fname, lck,
1579 access_mask, share_access,
1580 create_options, &file_existed);
1582 if (!NT_STATUS_IS_OK(status)) {
1583 struct deferred_open_record state;
1585 fd_close(conn, fsp);
1588 state.delayed_for_oplocks = False;
1590 state.inode = inode;
1592 /* Do it all over again immediately. In the second
1593 * round we will find that the file existed and handle
1594 * the DELETE_PENDING and FCB cases correctly. No need
1595 * to duplicate the code here. Essentially this is a
1596 * "goto top of this function", but don't tell
1599 defer_open(lck, request_time, timeval_zero(),
1606 * We exit this block with the share entry *locked*.....
1610 SMB_ASSERT(lck != NULL);
1612 /* note that we ignore failure for the following. It is
1613 basically a hack for NFS, and NFS will never set one of
1614 these only read them. Nobody but Samba can ever set a deny
1615 mode and we have already checked our more authoritative
1616 locking database for permission to set this deny mode. If
1617 the kernel refuses the operations then the kernel is wrong */
1619 kernel_flock(fsp, share_access);
1622 * At this point onwards, we can guarentee that the share entry
1623 * is locked, whether we created the file or not, and that the
1624 * deny mode is compatible with all current opens.
1628 * If requested, truncate the file.
1631 if (flags2&O_TRUNC) {
1633 * We are modifing the file after open - update the stat
1636 if ((SMB_VFS_FTRUNCATE(fsp,fsp->fh->fd,0) == -1) ||
1637 (SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf)==-1)) {
1645 /* Record the options we were opened with. */
1646 fsp->share_access = share_access;
1647 fsp->fh->private_options = create_options;
1648 fsp->access_mask = access_mask;
1651 if (!(flags2 & O_TRUNC)) {
1652 info = FILE_WAS_OPENED;
1654 info = FILE_WAS_OVERWRITTEN;
1657 info = FILE_WAS_CREATED;
1658 /* Change the owner if required. */
1659 if (lp_inherit_owner(SNUM(conn))) {
1660 change_owner_to_parent(conn, fsp, fsp->fsp_name,
1670 * Setup the oplock info in both the shared memory and
1674 if ((fsp->oplock_type != NO_OPLOCK) &&
1675 (fsp->oplock_type != FAKE_LEVEL_II_OPLOCK)) {
1676 if (!set_file_oplock(fsp, fsp->oplock_type)) {
1677 /* Could not get the kernel oplock */
1678 fsp->oplock_type = NO_OPLOCK;
1681 set_share_mode(lck, fsp, 0, fsp->oplock_type);
1683 if (info == FILE_WAS_OVERWRITTEN || info == FILE_WAS_CREATED ||
1684 info == FILE_WAS_SUPERSEDED) {
1686 /* Handle strange delete on close create semantics. */
1687 if (create_options & FILE_DELETE_ON_CLOSE) {
1688 NTSTATUS result = can_set_delete_on_close(fsp, True, new_dos_attributes);
1690 if (!NT_STATUS_IS_OK(result)) {
1691 /* Remember to delete the mode we just added. */
1692 del_share_mode(lck, fsp);
1696 set_saved_ntstatus(result);
1699 /* Note that here we set the *inital* delete on close flag,
1700 not the regular one. */
1701 set_delete_on_close_token(lck, ¤t_user.ut);
1702 lck->initial_delete_on_close = True;
1703 lck->modified = True;
1706 /* Files should be initially set as archive */
1707 if (lp_map_archive(SNUM(conn)) ||
1708 lp_store_dos_attributes(SNUM(conn))) {
1709 file_set_dosmode(conn, fname,
1710 new_dos_attributes | aARCH, NULL,
1716 * Take care of inherited ACLs on created files - if default ACL not
1720 if (!file_existed && !def_acl) {
1722 int saved_errno = errno; /* We might get ENOSYS in the next
1725 if (SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd, unx_mode) == -1
1726 && errno == ENOSYS) {
1727 errno = saved_errno; /* Ignore ENOSYS */
1730 } else if (new_unx_mode) {
1734 /* Attributes need changing. File already existed. */
1737 int saved_errno = errno; /* We might get ENOSYS in the
1739 ret = SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd,
1742 if (ret == -1 && errno == ENOSYS) {
1743 errno = saved_errno; /* Ignore ENOSYS */
1745 DEBUG(5, ("open_file_ntcreate: reset "
1746 "attributes of file %s to 0%o\n",
1747 fname, (unsigned int)new_unx_mode));
1748 ret = 0; /* Don't do the fchmod below. */
1753 (SMB_VFS_FCHMOD(fsp, fsp->fh->fd, new_unx_mode) == -1))
1754 DEBUG(5, ("open_file_ntcreate: failed to reset "
1755 "attributes of file %s to 0%o\n",
1756 fname, (unsigned int)new_unx_mode));
1759 /* If this is a successful open, we must remove any deferred open
1761 del_deferred_open_entry(lck, mid);
1764 conn->num_files_open++;
1769 /****************************************************************************
1770 Open a file for for write to ensure that we can fchmod it.
1771 ****************************************************************************/
1773 files_struct *open_file_fchmod(connection_struct *conn, const char *fname,
1774 SMB_STRUCT_STAT *psbuf)
1776 files_struct *fsp = NULL;
1779 if (!VALID_STAT(*psbuf)) {
1783 fsp = file_new(conn);
1788 /* note! we must use a non-zero desired access or we don't get
1789 a real file descriptor. Oh what a twisted web we weave. */
1790 fsp_open = open_file(fsp,conn,fname,psbuf,O_WRONLY,0,FILE_WRITE_DATA);
1793 * This is not a user visible file open.
1794 * Don't set a share mode and don't increment
1795 * the conn->num_files_open.
1806 /****************************************************************************
1807 Close the fchmod file fd - ensure no locks are lost.
1808 ****************************************************************************/
1810 int close_file_fchmod(files_struct *fsp)
1812 int ret = fd_close(fsp->conn, fsp);
1817 /****************************************************************************
1818 Open a directory from an NT SMB call.
1819 ****************************************************************************/
1821 files_struct *open_directory(connection_struct *conn,
1823 SMB_STRUCT_STAT *psbuf,
1825 uint32 share_access,
1826 uint32 create_disposition,
1827 uint32 create_options,
1830 files_struct *fsp = NULL;
1831 BOOL dir_existed = VALID_STAT(*psbuf) ? True : False;
1832 BOOL create_dir = False;
1833 struct share_mode_lock *lck = NULL;
1837 DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
1838 "share_access = 0x%x create_options = 0x%x, "
1839 "create_disposition = 0x%x\n",
1841 (unsigned int)access_mask,
1842 (unsigned int)share_access,
1843 (unsigned int)create_options,
1844 (unsigned int)create_disposition));
1846 if (is_ntfs_stream_name(fname)) {
1847 DEBUG(0,("open_directory: %s is a stream name!\n", fname ));
1848 set_saved_ntstatus(NT_STATUS_NOT_A_DIRECTORY);
1852 switch( create_disposition ) {
1854 /* If directory exists open. If directory doesn't
1857 DEBUG(5,("open_directory: FILE_OPEN requested "
1858 "for directory %s and it doesn't "
1859 "exist.\n", fname ));
1860 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_NOT_FOUND);
1863 info = FILE_WAS_OPENED;
1867 /* If directory exists error. If directory doesn't
1870 DEBUG(5,("open_directory: FILE_CREATE "
1871 "requested for directory %s and it "
1872 "already exists.\n", fname ));
1873 set_saved_error_triple(ERRDOS, ERRfilexists,
1874 NT_STATUS_OBJECT_NAME_COLLISION);
1878 info = FILE_WAS_CREATED;
1882 /* If directory exists open. If directory doesn't
1886 info = FILE_WAS_CREATED;
1888 info = FILE_WAS_OPENED;
1892 case FILE_SUPERSEDE:
1893 case FILE_OVERWRITE:
1894 case FILE_OVERWRITE_IF:
1896 DEBUG(5,("open_directory: invalid create_disposition "
1897 "0x%x for directory %s\n",
1898 (unsigned int)create_disposition, fname));
1900 set_saved_ntstatus(NT_STATUS_INVALID_PARAMETER);
1906 * Try and create the directory.
1909 /* We know bad_path is false as it's caught earlier. */
1911 status = mkdir_internal(conn, fname, False);
1913 if (!NT_STATUS_IS_OK(status)) {
1914 DEBUG(2,("open_directory: unable to create %s. "
1915 "Error was %s\n", fname, strerror(errno) ));
1916 /* Ensure we return the correct NT status to the
1918 set_saved_error_triple(0, 0, status);
1922 /* Ensure we're checking for a symlink here.... */
1923 /* We don't want to get caught by a symlink racer. */
1925 if(SMB_VFS_LSTAT(conn,fname, psbuf) != 0) {
1929 if(!S_ISDIR(psbuf->st_mode)) {
1930 DEBUG(0,("open_directory: %s is not a directory !\n",
1936 fsp = file_new(conn);
1942 * Setup the files_struct for it.
1945 fsp->mode = psbuf->st_mode;
1946 fsp->inode = psbuf->st_ino;
1947 fsp->dev = psbuf->st_dev;
1948 fsp->vuid = current_user.vuid;
1949 fsp->file_pid = global_smbpid;
1950 fsp->can_lock = True;
1951 fsp->can_read = False;
1952 fsp->can_write = False;
1954 fsp->share_access = share_access;
1955 fsp->fh->private_options = create_options;
1956 fsp->access_mask = access_mask;
1958 fsp->print_file = False;
1959 fsp->modified = False;
1960 fsp->oplock_type = NO_OPLOCK;
1961 fsp->sent_oplock_break = NO_BREAK_SENT;
1962 fsp->is_directory = True;
1963 fsp->is_stat = False;
1964 string_set(&fsp->fsp_name,fname);
1966 lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode,
1971 DEBUG(0, ("open_directory: Could not get share mode lock for %s\n", fname));
1973 set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1977 status = open_mode_check(conn, fname, lck,
1978 access_mask, share_access,
1979 create_options, &dir_existed);
1981 if (!NT_STATUS_IS_OK(status)) {
1982 set_saved_ntstatus(status);
1988 set_share_mode(lck, fsp, 0, NO_OPLOCK);
1990 /* For directories the delete on close bit at open time seems
1991 always to be honored on close... See test 19 in Samba4 BASE-DELETE. */
1992 if (create_options & FILE_DELETE_ON_CLOSE) {
1993 status = can_set_delete_on_close(fsp, True, 0);
1994 if (!NT_STATUS_IS_OK(status)) {
1995 set_saved_ntstatus(status);
2001 set_delete_on_close_token(lck, ¤t_user.ut);
2002 lck->initial_delete_on_close = True;
2003 lck->modified = True;
2008 /* Change the owner if required. */
2009 if ((info == FILE_WAS_CREATED) && lp_inherit_owner(SNUM(conn))) {
2010 change_owner_to_parent(conn, fsp, fsp->fsp_name, psbuf);
2017 conn->num_files_open++;
2022 /****************************************************************************
2023 Open a pseudo-file (no locking checks - a 'stat' open).
2024 ****************************************************************************/
2026 files_struct *open_file_stat(connection_struct *conn, char *fname,
2027 SMB_STRUCT_STAT *psbuf)
2029 files_struct *fsp = NULL;
2031 if (!VALID_STAT(*psbuf))
2034 /* Can't 'stat' open directories. */
2035 if(S_ISDIR(psbuf->st_mode))
2038 fsp = file_new(conn);
2042 DEBUG(5,("open_file_stat: 'opening' file %s\n", fname));
2045 * Setup the files_struct for it.
2048 fsp->mode = psbuf->st_mode;
2049 fsp->inode = psbuf->st_ino;
2050 fsp->dev = psbuf->st_dev;
2051 fsp->vuid = current_user.vuid;
2052 fsp->file_pid = global_smbpid;
2053 fsp->can_lock = False;
2054 fsp->can_read = False;
2055 fsp->can_write = False;
2056 fsp->print_file = False;
2057 fsp->modified = False;
2058 fsp->oplock_type = NO_OPLOCK;
2059 fsp->sent_oplock_break = NO_BREAK_SENT;
2060 fsp->is_directory = False;
2061 fsp->is_stat = True;
2062 string_set(&fsp->fsp_name,fname);
2064 conn->num_files_open++;
2069 /****************************************************************************
2070 Receive notification that one of our open files has been renamed by another
2072 ****************************************************************************/
2074 void msg_file_was_renamed(int msg_type, struct process_id src, void *buf, size_t len)
2077 char *frm = (char *)buf;
2080 const char *sharepath;
2081 const char *newname;
2084 if (buf == NULL || len < MSG_FILE_RENAMED_MIN_SIZE + 2) {
2085 DEBUG(0, ("msg_file_was_renamed: Got invalid msg len %d\n", (int)len));
2089 /* Unpack the message. */
2090 dev = DEV_T_VAL(frm,0);
2091 inode = INO_T_VAL(frm,8);
2092 sharepath = &frm[16];
2093 newname = sharepath + strlen(sharepath) + 1;
2094 sp_len = strlen(sharepath);
2096 DEBUG(10,("msg_file_was_renamed: Got rename message for sharepath %s, new name %s, "
2097 "dev %x, inode %.0f\n",
2098 sharepath, newname, (unsigned int)dev, (double)inode ));
2100 for(fsp = file_find_di_first(dev, inode); fsp; fsp = file_find_di_next(fsp)) {
2101 if (memcmp(fsp->conn->connectpath, sharepath, sp_len) == 0) {
2102 DEBUG(10,("msg_file_was_renamed: renaming file fnum %d from %s -> %s\n",
2103 fsp->fnum, fsp->fsp_name, newname ));
2104 string_set(&fsp->fsp_name, newname);
2107 /* Now we have the complete path we can work out if this is
2108 actually within this share and adjust newname accordingly. */
2109 DEBUG(10,("msg_file_was_renamed: share mismatch (sharepath %s "
2110 "not sharepath %s) "
2111 "fnum %d from %s -> %s\n",
2112 fsp->conn->connectpath,