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 or internal open: 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,
614 BOOL internal_only_open)
617 struct share_mode_entry *exclusive = NULL;
618 BOOL valid_entry = False;
619 BOOL delay_it = False;
620 BOOL have_level2 = False;
622 if (internal_only_open || is_stat_open(fsp->access_mask)) {
623 fsp->oplock_type = NO_OPLOCK;
627 for (i=0; i<lck->num_share_modes; i++) {
629 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
633 /* At least one entry is not an invalid or deferred entry. */
636 if (pass_number == 1) {
637 if (BATCH_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
638 SMB_ASSERT(exclusive == NULL);
639 exclusive = &lck->share_modes[i];
642 if (EXCLUSIVE_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
643 SMB_ASSERT(exclusive == NULL);
644 exclusive = &lck->share_modes[i];
648 if (lck->share_modes[i].op_type == LEVEL_II_OPLOCK) {
649 SMB_ASSERT(exclusive == NULL);
655 /* All entries are placeholders or deferred.
656 * Directly grant whatever the client wants. */
657 if (fsp->oplock_type == NO_OPLOCK) {
658 /* Store a level2 oplock, but don't tell the client */
659 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
664 if (exclusive != NULL) { /* Found an exclusive oplock */
665 SMB_ASSERT(!have_level2);
666 delay_it = is_delete_request(fsp) ?
667 BATCH_OPLOCK_TYPE(exclusive->op_type) : True;
670 if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
671 /* We can at most grant level2 as there are other
672 * level2 or NO_OPLOCK entries. */
673 fsp->oplock_type = LEVEL_II_OPLOCK;
676 if ((fsp->oplock_type == NO_OPLOCK) && have_level2) {
677 /* Store a level2 oplock, but don't tell the client */
678 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
683 char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
685 DEBUG(10, ("Sending break request to PID %s\n",
686 procid_str_static(&exclusive->pid)));
687 exclusive->op_mid = get_current_mid();
689 share_mode_entry_to_message(msg, exclusive);
692 ret = message_send_pid(exclusive->pid, MSG_SMB_BREAK_REQUEST,
693 msg, MSG_SMB_SHARE_MODE_ENTRY_SIZE, True);
696 DEBUG(3, ("Could not send oplock break message\n"));
704 static BOOL request_timed_out(struct timeval request_time,
705 struct timeval timeout)
707 struct timeval now, end_time;
709 end_time = timeval_sum(&request_time, &timeout);
710 return (timeval_compare(&end_time, &now) < 0);
713 /****************************************************************************
714 Handle the 1 second delay in returning a SHARING_VIOLATION error.
715 ****************************************************************************/
717 static void defer_open(struct share_mode_lock *lck,
718 struct timeval request_time,
719 struct timeval timeout,
720 struct deferred_open_record *state)
722 uint16 mid = get_current_mid();
727 for (i=0; i<lck->num_share_modes; i++) {
728 struct share_mode_entry *e = &lck->share_modes[i];
730 if (!is_deferred_open_entry(e)) {
734 if (procid_is_me(&e->pid) && (e->op_mid == mid)) {
735 DEBUG(0, ("Trying to defer an already deferred "
736 "request: mid=%d, exiting\n", mid));
737 exit_server("attempt to defer a deferred request");
741 /* End paranoia check */
743 DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred "
744 "open entry for mid %u\n",
745 (unsigned int)request_time.tv_sec,
746 (unsigned int)request_time.tv_usec,
749 if (!push_deferred_smb_message(mid, request_time, timeout,
750 (char *)state, sizeof(*state))) {
751 exit_server("push_deferred_smb_message failed");
753 add_deferred_open(lck, mid, request_time, state->dev, state->inode);
756 * Push the MID of this packet on the signing queue.
757 * We only do this once, the first time we push the packet
758 * onto the deferred open queue, as this has a side effect
759 * of incrementing the response sequence number.
762 srv_defer_sign_response(mid);
765 /****************************************************************************
766 Set a kernel flock on a file for NFS interoperability.
767 This requires a patch to Linux.
768 ****************************************************************************/
770 static void kernel_flock(files_struct *fsp, uint32 share_mode)
772 #if HAVE_KERNEL_SHARE_MODES
774 if (share_mode == FILE_SHARE_WRITE) {
775 kernel_mode = LOCK_MAND|LOCK_WRITE;
776 } else if (share_mode == FILE_SHARE_READ) {
777 kernel_mode = LOCK_MAND|LOCK_READ;
778 } else if (share_mode == FILE_SHARE_NONE) {
779 kernel_mode = LOCK_MAND;
782 flock(fsp->fh->fd, kernel_mode);
788 /****************************************************************************
789 On overwrite open ensure that the attributes match.
790 ****************************************************************************/
792 static BOOL open_match_attributes(connection_struct *conn,
796 mode_t existing_unx_mode,
798 mode_t *returned_unx_mode)
800 uint32 noarch_old_dos_attr, noarch_new_dos_attr;
802 noarch_old_dos_attr = (old_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
803 noarch_new_dos_attr = (new_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
805 if((noarch_old_dos_attr == 0 && noarch_new_dos_attr != 0) ||
806 (noarch_old_dos_attr != 0 && ((noarch_old_dos_attr & noarch_new_dos_attr) == noarch_old_dos_attr))) {
807 *returned_unx_mode = new_unx_mode;
809 *returned_unx_mode = (mode_t)0;
812 DEBUG(10,("open_match_attributes: file %s old_dos_attr = 0x%x, "
813 "existing_unx_mode = 0%o, new_dos_attr = 0x%x "
814 "returned_unx_mode = 0%o\n",
816 (unsigned int)old_dos_attr,
817 (unsigned int)existing_unx_mode,
818 (unsigned int)new_dos_attr,
819 (unsigned int)*returned_unx_mode ));
821 /* If we're mapping SYSTEM and HIDDEN ensure they match. */
822 if (lp_map_system(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
823 if ((old_dos_attr & FILE_ATTRIBUTE_SYSTEM) &&
824 !(new_dos_attr & FILE_ATTRIBUTE_SYSTEM)) {
828 if (lp_map_hidden(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
829 if ((old_dos_attr & FILE_ATTRIBUTE_HIDDEN) &&
830 !(new_dos_attr & FILE_ATTRIBUTE_HIDDEN)) {
837 /****************************************************************************
838 Special FCB or DOS processing in the case of a sharing violation.
839 Try and find a duplicated file handle.
840 ****************************************************************************/
842 static files_struct *fcb_or_dos_open(connection_struct *conn,
843 const char *fname, SMB_DEV_T dev,
847 uint32 create_options)
850 files_struct *dup_fsp;
852 DEBUG(5,("fcb_or_dos_open: attempting old open semantics for "
853 "file %s.\n", fname ));
855 for(fsp = file_find_di_first(dev, inode); fsp;
856 fsp = file_find_di_next(fsp)) {
858 DEBUG(10,("fcb_or_dos_open: checking file %s, fd = %d, "
859 "vuid = %u, file_pid = %u, private_options = 0x%x "
860 "access_mask = 0x%x\n", fsp->fsp_name,
861 fsp->fh->fd, (unsigned int)fsp->vuid,
862 (unsigned int)fsp->file_pid,
863 (unsigned int)fsp->fh->private_options,
864 (unsigned int)fsp->access_mask ));
866 if (fsp->fh->fd != -1 &&
867 fsp->vuid == current_user.vuid &&
868 fsp->file_pid == global_smbpid &&
869 (fsp->fh->private_options & (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS |
870 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) &&
871 (fsp->access_mask & FILE_WRITE_DATA) &&
872 strequal(fsp->fsp_name, fname)) {
873 DEBUG(10,("fcb_or_dos_open: file match\n"));
882 /* quite an insane set of semantics ... */
883 if (is_executable(fname) &&
884 (fsp->fh->private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS)) {
885 DEBUG(10,("fcb_or_dos_open: file fail due to is_executable.\n"));
889 /* We need to duplicate this fsp. */
890 dup_fsp = dup_file_fsp(fsp, access_mask, share_access, create_options);
898 /****************************************************************************
899 Open a file with a share mode - old openX method - map into NTCreate.
900 ****************************************************************************/
902 BOOL map_open_params_to_ntcreate(const char *fname, int deny_mode, int open_func,
903 uint32 *paccess_mask,
905 uint32 *pcreate_disposition,
906 uint32 *pcreate_options)
910 uint32 create_disposition;
911 uint32 create_options = 0;
913 DEBUG(10,("map_open_params_to_ntcreate: fname = %s, deny_mode = 0x%x, "
914 "open_func = 0x%x\n",
915 fname, (unsigned int)deny_mode, (unsigned int)open_func ));
917 /* Create the NT compatible access_mask. */
918 switch (GET_OPENX_MODE(deny_mode)) {
919 case DOS_OPEN_EXEC: /* Implies read-only - used to be FILE_READ_DATA */
920 case DOS_OPEN_RDONLY:
921 access_mask = FILE_GENERIC_READ;
923 case DOS_OPEN_WRONLY:
924 access_mask = FILE_GENERIC_WRITE;
928 access_mask = FILE_GENERIC_READ|FILE_GENERIC_WRITE;
931 DEBUG(10,("map_open_params_to_ntcreate: bad open mode = 0x%x\n",
932 (unsigned int)GET_OPENX_MODE(deny_mode)));
936 /* Create the NT compatible create_disposition. */
938 case OPENX_FILE_EXISTS_FAIL|OPENX_FILE_CREATE_IF_NOT_EXIST:
939 create_disposition = FILE_CREATE;
942 case OPENX_FILE_EXISTS_OPEN:
943 create_disposition = FILE_OPEN;
946 case OPENX_FILE_EXISTS_OPEN|OPENX_FILE_CREATE_IF_NOT_EXIST:
947 create_disposition = FILE_OPEN_IF;
950 case OPENX_FILE_EXISTS_TRUNCATE:
951 create_disposition = FILE_OVERWRITE;
954 case OPENX_FILE_EXISTS_TRUNCATE|OPENX_FILE_CREATE_IF_NOT_EXIST:
955 create_disposition = FILE_OVERWRITE_IF;
959 /* From samba4 - to be confirmed. */
960 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_EXEC) {
961 create_disposition = FILE_CREATE;
964 DEBUG(10,("map_open_params_to_ntcreate: bad "
965 "open_func 0x%x\n", (unsigned int)open_func));
969 /* Create the NT compatible share modes. */
970 switch (GET_DENY_MODE(deny_mode)) {
972 share_mode = FILE_SHARE_NONE;
976 share_mode = FILE_SHARE_READ;
980 share_mode = FILE_SHARE_WRITE;
984 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
988 create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
989 if (is_executable(fname)) {
990 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
992 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_RDONLY) {
993 share_mode = FILE_SHARE_READ;
995 share_mode = FILE_SHARE_NONE;
1001 create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
1002 share_mode = FILE_SHARE_NONE;
1006 DEBUG(10,("map_open_params_to_ntcreate: bad deny_mode 0x%x\n",
1007 (unsigned int)GET_DENY_MODE(deny_mode) ));
1011 DEBUG(10,("map_open_params_to_ntcreate: file %s, access_mask = 0x%x, "
1012 "share_mode = 0x%x, create_disposition = 0x%x, "
1013 "create_options = 0x%x\n",
1015 (unsigned int)access_mask,
1016 (unsigned int)share_mode,
1017 (unsigned int)create_disposition,
1018 (unsigned int)create_options ));
1021 *paccess_mask = access_mask;
1024 *pshare_mode = share_mode;
1026 if (pcreate_disposition) {
1027 *pcreate_disposition = create_disposition;
1029 if (pcreate_options) {
1030 *pcreate_options = create_options;
1037 static void schedule_defer_open(struct share_mode_lock *lck, struct timeval request_time)
1039 struct deferred_open_record state;
1041 /* This is a relative time, added to the absolute
1042 request_time value to get the absolute timeout time.
1043 Note that if this is the second or greater time we enter
1044 this codepath for this particular request mid then
1045 request_time is left as the absolute time of the *first*
1046 time this request mid was processed. This is what allows
1047 the request to eventually time out. */
1049 struct timeval timeout;
1051 /* Normally the smbd we asked should respond within
1052 * OPLOCK_BREAK_TIMEOUT seconds regardless of whether
1053 * the client did, give twice the timeout as a safety
1054 * measure here in case the other smbd is stuck
1055 * somewhere else. */
1057 timeout = timeval_set(OPLOCK_BREAK_TIMEOUT*2, 0);
1059 /* Nothing actually uses state.delayed_for_oplocks
1060 but it's handy to differentiate in debug messages
1061 between a 30 second delay due to oplock break, and
1062 a 1 second delay for share mode conflicts. */
1064 state.delayed_for_oplocks = True;
1065 state.dev = lck->dev;
1066 state.inode = lck->ino;
1068 if (!request_timed_out(request_time, timeout)) {
1069 defer_open(lck, request_time, timeout, &state);
1073 /****************************************************************************
1074 Open a file with a share mode.
1075 ****************************************************************************/
1077 files_struct *open_file_ntcreate(connection_struct *conn,
1079 SMB_STRUCT_STAT *psbuf,
1080 uint32 access_mask, /* access bits (FILE_READ_DATA etc.) */
1081 uint32 share_access, /* share constants (FILE_SHARE_READ etc). */
1082 uint32 create_disposition, /* FILE_OPEN_IF etc. */
1083 uint32 create_options, /* options such as delete on close. */
1084 uint32 new_dos_attributes, /* attributes used for new file. */
1085 int oplock_request, /* internal Samba oplock codes. */
1086 /* Information (FILE_EXISTS etc.) */
1091 BOOL file_existed = VALID_STAT(*psbuf);
1092 BOOL def_acl = False;
1093 BOOL internal_only_open = False;
1095 SMB_INO_T inode = 0;
1096 BOOL fsp_open = False;
1097 files_struct *fsp = NULL;
1098 mode_t new_unx_mode = (mode_t)0;
1099 mode_t unx_mode = (mode_t)0;
1101 uint32 existing_dos_attributes = 0;
1102 struct pending_message_list *pml = NULL;
1103 uint16 mid = get_current_mid();
1104 BOOL delayed_for_oplocks = False;
1105 struct timeval request_time = timeval_zero();
1106 struct share_mode_lock *lck = NULL;
1109 if (conn->printer) {
1111 * Printers are handled completely differently.
1112 * Most of the passed parameters are ignored.
1116 *pinfo = FILE_WAS_CREATED;
1119 DEBUG(10, ("open_file_ntcreate: printer open fname=%s\n", fname));
1121 return print_fsp_open(conn, fname);
1124 /* We add aARCH to this as this mode is only used if the file is
1126 unx_mode = unix_mode(conn, new_dos_attributes | aARCH,fname, True);
1128 DEBUG(10, ("open_file_ntcreate: fname=%s, dos_attrs=0x%x "
1129 "access_mask=0x%x share_access=0x%x "
1130 "create_disposition = 0x%x create_options=0x%x "
1131 "unix mode=0%o oplock_request=%d\n",
1132 fname, new_dos_attributes, access_mask, share_access,
1133 create_disposition, create_options, unx_mode,
1136 if (oplock_request == INTERNAL_OPEN_ONLY) {
1137 internal_only_open = True;
1141 if ((pml = get_open_deferred_message(mid)) != NULL) {
1142 struct deferred_open_record *state =
1143 (struct deferred_open_record *)pml->private_data.data;
1145 /* Remember the absolute time of the original
1146 request with this mid. We'll use it later to
1147 see if this has timed out. */
1149 request_time = pml->request_time;
1150 delayed_for_oplocks = state->delayed_for_oplocks;
1152 /* Remove the deferred open entry under lock. */
1153 lck = get_share_mode_lock(NULL, state->dev, state->inode, NULL, NULL);
1155 DEBUG(0, ("could not get share mode lock\n"));
1157 del_deferred_open_entry(lck, mid);
1161 /* Ensure we don't reprocess this message. */
1162 remove_deferred_open_smb_message(mid);
1165 if (!check_name(fname,conn)) {
1169 new_dos_attributes &= SAMBA_ATTRIBUTES_MASK;
1171 existing_dos_attributes = dos_mode(conn, fname, psbuf);
1174 /* ignore any oplock requests if oplocks are disabled */
1175 if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break ||
1176 IS_VETO_OPLOCK_PATH(conn, fname)) {
1180 /* this is for OS/2 long file names - say we don't support them */
1181 if (!lp_posix_pathnames() && strstr(fname,".+,;=[].")) {
1182 /* OS/2 Workplace shell fix may be main code stream in a later
1184 set_saved_error_triple(ERRDOS, ERRcannotopen,
1185 NT_STATUS_OBJECT_NAME_NOT_FOUND);
1186 DEBUG(5,("open_file_ntcreate: OS/2 long filenames are not "
1191 switch( create_disposition ) {
1193 * Currently we're using FILE_SUPERSEDE as the same as
1194 * FILE_OVERWRITE_IF but they really are
1195 * different. FILE_SUPERSEDE deletes an existing file
1196 * (requiring delete access) then recreates it.
1198 case FILE_SUPERSEDE:
1199 /* If file exists replace/overwrite. If file doesn't
1201 flags2 |= (O_CREAT | O_TRUNC);
1204 case FILE_OVERWRITE_IF:
1205 /* If file exists replace/overwrite. If file doesn't
1207 flags2 |= (O_CREAT | O_TRUNC);
1211 /* If file exists open. If file doesn't exist error. */
1212 if (!file_existed) {
1213 DEBUG(5,("open_file_ntcreate: FILE_OPEN "
1214 "requested for file %s and file "
1215 "doesn't exist.\n", fname ));
1216 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_NOT_FOUND);
1222 case FILE_OVERWRITE:
1223 /* If file exists overwrite. If file doesn't exist
1225 if (!file_existed) {
1226 DEBUG(5,("open_file_ntcreate: FILE_OVERWRITE "
1227 "requested for file %s and file "
1228 "doesn't exist.\n", fname ));
1229 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_NOT_FOUND);
1237 /* If file exists error. If file doesn't exist
1240 DEBUG(5,("open_file_ntcreate: FILE_CREATE "
1241 "requested for file %s and file "
1242 "already exists.\n", fname ));
1243 if (S_ISDIR(psbuf->st_mode)) {
1250 flags2 |= (O_CREAT|O_EXCL);
1254 /* If file exists open. If file doesn't exist
1260 set_saved_ntstatus(NT_STATUS_INVALID_PARAMETER);
1264 /* We only care about matching attributes on file exists and
1267 if (file_existed && ((create_disposition == FILE_OVERWRITE) ||
1268 (create_disposition == FILE_OVERWRITE_IF))) {
1269 if (!open_match_attributes(conn, fname,
1270 existing_dos_attributes,
1271 new_dos_attributes, psbuf->st_mode,
1272 unx_mode, &new_unx_mode)) {
1273 DEBUG(5,("open_file_ntcreate: attributes missmatch "
1274 "for file %s (%x %x) (0%o, 0%o)\n",
1275 fname, existing_dos_attributes,
1277 (unsigned int)psbuf->st_mode,
1278 (unsigned int)unx_mode ));
1284 /* This is a nasty hack - must fix... JRA. */
1285 if (access_mask == MAXIMUM_ALLOWED_ACCESS) {
1286 access_mask = FILE_GENERIC_ALL;
1290 * Convert GENERIC bits to specific bits.
1293 se_map_generic(&access_mask, &file_generic_mapping);
1295 DEBUG(10, ("open_file_ntcreate: fname=%s, after mapping "
1296 "access_mask=0x%x\n", fname, access_mask ));
1299 * Note that we ignore the append flag as append does not
1300 * mean the same thing under DOS and Unix.
1303 if (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) {
1310 * Currently we only look at FILE_WRITE_THROUGH for create options.
1314 if ((create_options & FILE_WRITE_THROUGH) && lp_strict_sync(SNUM(conn))) {
1319 if (!CAN_WRITE(conn)) {
1321 * We should really return a permission denied error if either
1322 * O_CREAT or O_TRUNC are set, but for compatibility with
1323 * older versions of Samba we just AND them out.
1325 flags2 &= ~(O_CREAT|O_TRUNC);
1329 * Ensure we can't write on a read-only share or file.
1332 if (flags != O_RDONLY && file_existed &&
1333 (!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_attributes))) {
1334 DEBUG(5,("open_file_ntcreate: write access requested for "
1335 "file %s on read only %s\n",
1336 fname, !CAN_WRITE(conn) ? "share" : "file" ));
1337 set_saved_ntstatus(NT_STATUS_ACCESS_DENIED);
1342 fsp = file_new(conn);
1347 fsp->dev = psbuf->st_dev;
1348 fsp->inode = psbuf->st_ino;
1349 fsp->share_access = share_access;
1350 fsp->fh->private_options = create_options;
1351 fsp->access_mask = access_mask;
1352 fsp->oplock_type = oplock_request;
1354 if (timeval_is_zero(&request_time)) {
1355 request_time = fsp->open_time;
1359 dev = psbuf->st_dev;
1360 inode = psbuf->st_ino;
1362 lck = get_share_mode_lock(NULL, dev, inode,
1367 DEBUG(0, ("Could not get share mode lock\n"));
1368 set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1372 /* First pass - send break only on batch oplocks. */
1373 if (delay_for_oplocks(lck, fsp, 1, internal_only_open)) {
1374 schedule_defer_open(lck, request_time);
1379 status = open_mode_check(conn, fname, lck,
1380 access_mask, share_access,
1381 create_options, &file_existed);
1383 if (NT_STATUS_IS_OK(status)) {
1384 /* We might be going to allow this open. Check oplock status again. */
1385 /* Second pass - send break for both batch or exclusive oplocks. */
1386 if (delay_for_oplocks(lck, fsp, 2, internal_only_open)) {
1387 schedule_defer_open(lck, request_time);
1393 if (NT_STATUS_EQUAL(status, NT_STATUS_DELETE_PENDING)) {
1394 /* DELETE_PENDING is not deferred for a second */
1395 set_saved_ntstatus(status);
1401 if (!NT_STATUS_IS_OK(status)) {
1403 SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION));
1405 /* Check if this can be done with the deny_dos and fcb
1407 if (create_options &
1408 (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS|
1409 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
1410 files_struct *fsp_dup;
1411 fsp_dup = fcb_or_dos_open(conn, fname, dev,
1420 *pinfo = FILE_WAS_OPENED;
1422 conn->num_files_open++;
1428 * This next line is a subtlety we need for
1429 * MS-Access. If a file open will fail due to share
1430 * permissions and also for security (access) reasons,
1431 * we need to return the access failed error, not the
1432 * share error. This means we must attempt to open the
1433 * file anyway in order to get the UNIX access error -
1434 * even if we're going to fail the open for share
1435 * reasons. This is bad, as we're burning another fd
1436 * if there are existing locks but there's nothing
1437 * else we can do. We also ensure we're not going to
1438 * create or tuncate the file as we only want an
1439 * access decision at this stage. JRA.
1442 fsp_open = open_file(fsp,conn,fname,psbuf,
1443 flags|(flags2&~(O_TRUNC|O_CREAT)),
1444 unx_mode,access_mask);
1446 DEBUG(4,("open_file_ntcreate : share_mode deny - "
1447 "calling open_file with flags=0x%X "
1448 "flags2=0x%X mode=0%o returned %d\n",
1449 flags, (flags2&~(O_TRUNC|O_CREAT)),
1450 (unsigned int)unx_mode, (int)fsp_open ));
1452 if (!fsp_open && errno) {
1453 /* Default error. */
1454 set_saved_ntstatus(NT_STATUS_ACCESS_DENIED);
1458 * If we're returning a share violation, ensure we
1459 * cope with the braindead 1 second delay.
1462 if (!internal_only_open &&
1463 lp_defer_sharing_violations()) {
1464 struct timeval timeout;
1465 struct deferred_open_record state;
1468 /* this is a hack to speed up torture tests
1470 timeout_usecs = lp_parm_int(conn->service,
1471 "smbd","sharedelay",
1472 SHARING_VIOLATION_USEC_WAIT);
1474 /* This is a relative time, added to the absolute
1475 request_time value to get the absolute timeout time.
1476 Note that if this is the second or greater time we enter
1477 this codepath for this particular request mid then
1478 request_time is left as the absolute time of the *first*
1479 time this request mid was processed. This is what allows
1480 the request to eventually time out. */
1482 timeout = timeval_set(0, timeout_usecs);
1484 /* Nothing actually uses state.delayed_for_oplocks
1485 but it's handy to differentiate in debug messages
1486 between a 30 second delay due to oplock break, and
1487 a 1 second delay for share mode conflicts. */
1489 state.delayed_for_oplocks = False;
1491 state.inode = inode;
1493 if (!request_timed_out(request_time,
1495 defer_open(lck, request_time, timeout,
1502 fd_close(conn, fsp);
1504 * We have detected a sharing violation here
1505 * so return the correct error code
1507 set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1514 * We exit this block with the share entry *locked*.....
1518 SMB_ASSERT(!file_existed || (lck != NULL));
1521 * Ensure we pay attention to default ACLs on directories if required.
1524 if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
1525 (def_acl = directory_has_default_acl(conn,
1526 parent_dirname(fname)))) {
1530 DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
1531 (unsigned int)flags, (unsigned int)flags2,
1532 (unsigned int)unx_mode));
1535 * open_file strips any O_TRUNC flags itself.
1538 fsp_open = open_file(fsp,conn,fname,psbuf,flags|flags2,unx_mode,
1549 if (!file_existed) {
1552 * Deal with the race condition where two smbd's detect the
1553 * file doesn't exist and do the create at the same time. One
1554 * of them will win and set a share mode, the other (ie. this
1555 * one) should check if the requested share mode for this
1556 * create is allowed.
1560 * Now the file exists and fsp is successfully opened,
1561 * fsp->dev and fsp->inode are valid and should replace the
1562 * dev=0,inode=0 from a non existent file. Spotted by
1563 * Nadav Danieli <nadavd@exanet.com>. JRA.
1569 lck = get_share_mode_lock(NULL, dev, inode,
1574 DEBUG(0, ("open_file_ntcreate: Could not get share mode lock for %s\n", fname));
1575 fd_close(conn, fsp);
1577 set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1581 status = open_mode_check(conn, fname, lck,
1582 access_mask, share_access,
1583 create_options, &file_existed);
1585 if (!NT_STATUS_IS_OK(status)) {
1586 struct deferred_open_record state;
1588 fd_close(conn, fsp);
1591 state.delayed_for_oplocks = False;
1593 state.inode = inode;
1595 /* Do it all over again immediately. In the second
1596 * round we will find that the file existed and handle
1597 * the DELETE_PENDING and FCB cases correctly. No need
1598 * to duplicate the code here. Essentially this is a
1599 * "goto top of this function", but don't tell
1602 defer_open(lck, request_time, timeval_zero(),
1609 * We exit this block with the share entry *locked*.....
1613 SMB_ASSERT(lck != NULL);
1615 /* note that we ignore failure for the following. It is
1616 basically a hack for NFS, and NFS will never set one of
1617 these only read them. Nobody but Samba can ever set a deny
1618 mode and we have already checked our more authoritative
1619 locking database for permission to set this deny mode. If
1620 the kernel refuses the operations then the kernel is wrong */
1622 kernel_flock(fsp, share_access);
1625 * At this point onwards, we can guarentee that the share entry
1626 * is locked, whether we created the file or not, and that the
1627 * deny mode is compatible with all current opens.
1631 * If requested, truncate the file.
1634 if (flags2&O_TRUNC) {
1636 * We are modifing the file after open - update the stat
1639 if ((SMB_VFS_FTRUNCATE(fsp,fsp->fh->fd,0) == -1) ||
1640 (SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf)==-1)) {
1648 /* Record the options we were opened with. */
1649 fsp->share_access = share_access;
1650 fsp->fh->private_options = create_options;
1651 fsp->access_mask = access_mask;
1654 if (!(flags2 & O_TRUNC)) {
1655 info = FILE_WAS_OPENED;
1657 info = FILE_WAS_OVERWRITTEN;
1660 info = FILE_WAS_CREATED;
1661 /* Change the owner if required. */
1662 if (lp_inherit_owner(SNUM(conn))) {
1663 change_owner_to_parent(conn, fsp, fsp->fsp_name,
1673 * Setup the oplock info in both the shared memory and
1677 if ((fsp->oplock_type != NO_OPLOCK) &&
1678 (fsp->oplock_type != FAKE_LEVEL_II_OPLOCK)) {
1679 if (!set_file_oplock(fsp, fsp->oplock_type)) {
1680 /* Could not get the kernel oplock */
1681 fsp->oplock_type = NO_OPLOCK;
1684 set_share_mode(lck, fsp, 0, fsp->oplock_type);
1686 if (info == FILE_WAS_OVERWRITTEN || info == FILE_WAS_CREATED ||
1687 info == FILE_WAS_SUPERSEDED) {
1689 /* Handle strange delete on close create semantics. */
1690 if (create_options & FILE_DELETE_ON_CLOSE) {
1691 NTSTATUS result = can_set_delete_on_close(fsp, True, new_dos_attributes);
1693 if (!NT_STATUS_IS_OK(result)) {
1694 /* Remember to delete the mode we just added. */
1695 del_share_mode(lck, fsp);
1699 set_saved_ntstatus(result);
1702 /* Note that here we set the *inital* delete on close flag,
1703 not the regular one. */
1704 set_delete_on_close_token(lck, ¤t_user.ut);
1705 lck->initial_delete_on_close = True;
1706 lck->modified = True;
1709 /* Files should be initially set as archive */
1710 if (lp_map_archive(SNUM(conn)) ||
1711 lp_store_dos_attributes(SNUM(conn))) {
1712 file_set_dosmode(conn, fname,
1713 new_dos_attributes | aARCH, NULL,
1719 * Take care of inherited ACLs on created files - if default ACL not
1723 if (!file_existed && !def_acl) {
1725 int saved_errno = errno; /* We might get ENOSYS in the next
1728 if (SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd, unx_mode) == -1
1729 && errno == ENOSYS) {
1730 errno = saved_errno; /* Ignore ENOSYS */
1733 } else if (new_unx_mode) {
1737 /* Attributes need changing. File already existed. */
1740 int saved_errno = errno; /* We might get ENOSYS in the
1742 ret = SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd,
1745 if (ret == -1 && errno == ENOSYS) {
1746 errno = saved_errno; /* Ignore ENOSYS */
1748 DEBUG(5, ("open_file_ntcreate: reset "
1749 "attributes of file %s to 0%o\n",
1750 fname, (unsigned int)new_unx_mode));
1751 ret = 0; /* Don't do the fchmod below. */
1756 (SMB_VFS_FCHMOD(fsp, fsp->fh->fd, new_unx_mode) == -1))
1757 DEBUG(5, ("open_file_ntcreate: failed to reset "
1758 "attributes of file %s to 0%o\n",
1759 fname, (unsigned int)new_unx_mode));
1762 /* If this is a successful open, we must remove any deferred open
1764 del_deferred_open_entry(lck, mid);
1767 conn->num_files_open++;
1772 /****************************************************************************
1773 Open a file for for write to ensure that we can fchmod it.
1774 ****************************************************************************/
1776 files_struct *open_file_fchmod(connection_struct *conn, const char *fname,
1777 SMB_STRUCT_STAT *psbuf)
1779 files_struct *fsp = NULL;
1782 if (!VALID_STAT(*psbuf)) {
1786 fsp = file_new(conn);
1791 /* note! we must use a non-zero desired access or we don't get
1792 a real file descriptor. Oh what a twisted web we weave. */
1793 fsp_open = open_file(fsp,conn,fname,psbuf,O_WRONLY,0,FILE_WRITE_DATA);
1796 * This is not a user visible file open.
1797 * Don't set a share mode and don't increment
1798 * the conn->num_files_open.
1809 /****************************************************************************
1810 Close the fchmod file fd - ensure no locks are lost.
1811 ****************************************************************************/
1813 int close_file_fchmod(files_struct *fsp)
1815 int ret = fd_close(fsp->conn, fsp);
1820 /****************************************************************************
1821 Open a directory from an NT SMB call.
1822 ****************************************************************************/
1824 files_struct *open_directory(connection_struct *conn,
1826 SMB_STRUCT_STAT *psbuf,
1828 uint32 share_access,
1829 uint32 create_disposition,
1830 uint32 create_options,
1833 files_struct *fsp = NULL;
1834 BOOL dir_existed = VALID_STAT(*psbuf) ? True : False;
1835 BOOL create_dir = False;
1836 struct share_mode_lock *lck = NULL;
1840 DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
1841 "share_access = 0x%x create_options = 0x%x, "
1842 "create_disposition = 0x%x\n",
1844 (unsigned int)access_mask,
1845 (unsigned int)share_access,
1846 (unsigned int)create_options,
1847 (unsigned int)create_disposition));
1849 if (is_ntfs_stream_name(fname)) {
1850 DEBUG(0,("open_directory: %s is a stream name!\n", fname ));
1851 set_saved_ntstatus(NT_STATUS_NOT_A_DIRECTORY);
1855 switch( create_disposition ) {
1857 /* If directory exists open. If directory doesn't
1860 DEBUG(5,("open_directory: FILE_OPEN requested "
1861 "for directory %s and it doesn't "
1862 "exist.\n", fname ));
1863 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_NOT_FOUND);
1866 info = FILE_WAS_OPENED;
1870 /* If directory exists error. If directory doesn't
1873 DEBUG(5,("open_directory: FILE_CREATE "
1874 "requested for directory %s and it "
1875 "already exists.\n", fname ));
1876 set_saved_error_triple(ERRDOS, ERRfilexists,
1877 NT_STATUS_OBJECT_NAME_COLLISION);
1881 info = FILE_WAS_CREATED;
1885 /* If directory exists open. If directory doesn't
1889 info = FILE_WAS_CREATED;
1891 info = FILE_WAS_OPENED;
1895 case FILE_SUPERSEDE:
1896 case FILE_OVERWRITE:
1897 case FILE_OVERWRITE_IF:
1899 DEBUG(5,("open_directory: invalid create_disposition "
1900 "0x%x for directory %s\n",
1901 (unsigned int)create_disposition, fname));
1903 set_saved_ntstatus(NT_STATUS_INVALID_PARAMETER);
1909 * Try and create the directory.
1912 /* We know bad_path is false as it's caught earlier. */
1914 status = mkdir_internal(conn, fname, False);
1916 if (!NT_STATUS_IS_OK(status)) {
1917 DEBUG(2,("open_directory: unable to create %s. "
1918 "Error was %s\n", fname, strerror(errno) ));
1919 /* Ensure we return the correct NT status to the
1921 set_saved_error_triple(0, 0, status);
1925 /* Ensure we're checking for a symlink here.... */
1926 /* We don't want to get caught by a symlink racer. */
1928 if(SMB_VFS_LSTAT(conn,fname, psbuf) != 0) {
1932 if(!S_ISDIR(psbuf->st_mode)) {
1933 DEBUG(0,("open_directory: %s is not a directory !\n",
1939 fsp = file_new(conn);
1945 * Setup the files_struct for it.
1948 fsp->mode = psbuf->st_mode;
1949 fsp->inode = psbuf->st_ino;
1950 fsp->dev = psbuf->st_dev;
1951 fsp->vuid = current_user.vuid;
1952 fsp->file_pid = global_smbpid;
1953 fsp->can_lock = True;
1954 fsp->can_read = False;
1955 fsp->can_write = False;
1957 fsp->share_access = share_access;
1958 fsp->fh->private_options = create_options;
1959 fsp->access_mask = access_mask;
1961 fsp->print_file = False;
1962 fsp->modified = False;
1963 fsp->oplock_type = NO_OPLOCK;
1964 fsp->sent_oplock_break = NO_BREAK_SENT;
1965 fsp->is_directory = True;
1966 fsp->is_stat = False;
1967 string_set(&fsp->fsp_name,fname);
1969 lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode,
1974 DEBUG(0, ("open_directory: Could not get share mode lock for %s\n", fname));
1976 set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1980 status = open_mode_check(conn, fname, lck,
1981 access_mask, share_access,
1982 create_options, &dir_existed);
1984 if (!NT_STATUS_IS_OK(status)) {
1985 set_saved_ntstatus(status);
1991 set_share_mode(lck, fsp, 0, NO_OPLOCK);
1993 /* For directories the delete on close bit at open time seems
1994 always to be honored on close... See test 19 in Samba4 BASE-DELETE. */
1995 if (create_options & FILE_DELETE_ON_CLOSE) {
1996 status = can_set_delete_on_close(fsp, True, 0);
1997 if (!NT_STATUS_IS_OK(status)) {
1998 set_saved_ntstatus(status);
2004 set_delete_on_close_token(lck, ¤t_user.ut);
2005 lck->initial_delete_on_close = True;
2006 lck->modified = True;
2011 /* Change the owner if required. */
2012 if ((info == FILE_WAS_CREATED) && lp_inherit_owner(SNUM(conn))) {
2013 change_owner_to_parent(conn, fsp, fsp->fsp_name, psbuf);
2020 conn->num_files_open++;
2025 /****************************************************************************
2026 Open a pseudo-file (no locking checks - a 'stat' open).
2027 ****************************************************************************/
2029 files_struct *open_file_stat(connection_struct *conn, char *fname,
2030 SMB_STRUCT_STAT *psbuf)
2032 files_struct *fsp = NULL;
2034 if (!VALID_STAT(*psbuf))
2037 /* Can't 'stat' open directories. */
2038 if(S_ISDIR(psbuf->st_mode))
2041 fsp = file_new(conn);
2045 DEBUG(5,("open_file_stat: 'opening' file %s\n", fname));
2048 * Setup the files_struct for it.
2051 fsp->mode = psbuf->st_mode;
2052 fsp->inode = psbuf->st_ino;
2053 fsp->dev = psbuf->st_dev;
2054 fsp->vuid = current_user.vuid;
2055 fsp->file_pid = global_smbpid;
2056 fsp->can_lock = False;
2057 fsp->can_read = False;
2058 fsp->can_write = False;
2059 fsp->print_file = False;
2060 fsp->modified = False;
2061 fsp->oplock_type = NO_OPLOCK;
2062 fsp->sent_oplock_break = NO_BREAK_SENT;
2063 fsp->is_directory = False;
2064 fsp->is_stat = True;
2065 string_set(&fsp->fsp_name,fname);
2067 conn->num_files_open++;
2072 /****************************************************************************
2073 Receive notification that one of our open files has been renamed by another
2075 ****************************************************************************/
2077 void msg_file_was_renamed(int msg_type, struct process_id src, void *buf, size_t len)
2080 char *frm = (char *)buf;
2083 const char *sharepath;
2084 const char *newname;
2087 if (buf == NULL || len < MSG_FILE_RENAMED_MIN_SIZE + 2) {
2088 DEBUG(0, ("msg_file_was_renamed: Got invalid msg len %d\n", (int)len));
2092 /* Unpack the message. */
2093 dev = DEV_T_VAL(frm,0);
2094 inode = INO_T_VAL(frm,8);
2095 sharepath = &frm[16];
2096 newname = sharepath + strlen(sharepath) + 1;
2097 sp_len = strlen(sharepath);
2099 DEBUG(10,("msg_file_was_renamed: Got rename message for sharepath %s, new name %s, "
2100 "dev %x, inode %.0f\n",
2101 sharepath, newname, (unsigned int)dev, (double)inode ));
2103 for(fsp = file_find_di_first(dev, inode); fsp; fsp = file_find_di_next(fsp)) {
2104 if (memcmp(fsp->conn->connectpath, sharepath, sp_len) == 0) {
2105 DEBUG(10,("msg_file_was_renamed: renaming file fnum %d from %s -> %s\n",
2106 fsp->fnum, fsp->fsp_name, newname ));
2107 string_set(&fsp->fsp_name, newname);
2110 /* Now we have the complete path we can work out if this is
2111 actually within this share and adjust newname accordingly. */
2112 DEBUG(10,("msg_file_was_renamed: share mismatch (sharepath %s "
2113 "not sharepath %s) "
2114 "fnum %d from %s -> %s\n",
2115 fsp->conn->connectpath,