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 BOOL fd_open(struct connection_struct *conn,
50 if (!lp_symlinks(SNUM(conn))) {
55 fsp->fh->fd = SMB_VFS_OPEN(conn,fname,fsp,flags,mode);
58 DEBUG(10,("fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s\n",
59 fname, flags, (int)mode, fsp->fh->fd,
60 (fsp->fh->fd == -1) ? strerror(errno) : "" ));
63 return fsp->fh->fd != -1;
66 /****************************************************************************
67 Close the file associated with a fsp.
68 ****************************************************************************/
70 int fd_close(struct connection_struct *conn,
73 if (fsp->fh->fd == -1) {
74 return 0; /* What we used to call a stat open. */
76 if (fsp->fh->ref_count > 1) {
77 return 0; /* Shared handle. Only close last reference. */
79 return fd_close_posix(conn, fsp);
82 /****************************************************************************
83 Change the ownership of a file to that of the parent directory.
84 Do this by fd if possible.
85 ****************************************************************************/
87 void change_owner_to_parent(connection_struct *conn,
90 SMB_STRUCT_STAT *psbuf)
92 const char *parent_path = parent_dirname(fname);
93 SMB_STRUCT_STAT parent_st;
96 ret = SMB_VFS_STAT(conn, parent_path, &parent_st);
98 DEBUG(0,("change_owner_to_parent: failed to stat parent "
99 "directory %s. Error was %s\n",
100 parent_path, strerror(errno) ));
104 if (fsp && fsp->fh->fd != -1) {
106 ret = SMB_VFS_FCHOWN(fsp, fsp->fh->fd, parent_st.st_uid, (gid_t)-1);
109 DEBUG(0,("change_owner_to_parent: failed to fchown "
110 "file %s to parent directory uid %u. Error "
112 (unsigned int)parent_st.st_uid,
116 DEBUG(10,("change_owner_to_parent: changed new file %s to "
117 "parent directory uid %u.\n", fname,
118 (unsigned int)parent_st.st_uid ));
121 /* We've already done an lstat into psbuf, and we know it's a
122 directory. If we can cd into the directory and the dev/ino
123 are the same then we can safely chown without races as
124 we're locking the directory in place by being in it. This
125 should work on any UNIX (thanks tridge :-). JRA.
129 SMB_STRUCT_STAT sbuf;
131 if (!vfs_GetWd(conn,saved_dir)) {
132 DEBUG(0,("change_owner_to_parent: failed to get "
133 "current working directory\n"));
137 /* Chdir into the new path. */
138 if (vfs_ChDir(conn, fname) == -1) {
139 DEBUG(0,("change_owner_to_parent: failed to change "
140 "current working directory to %s. Error "
141 "was %s\n", fname, strerror(errno) ));
145 if (SMB_VFS_STAT(conn,".",&sbuf) == -1) {
146 DEBUG(0,("change_owner_to_parent: failed to stat "
147 "directory '.' (%s) Error was %s\n",
148 fname, strerror(errno)));
152 /* Ensure we're pointing at the same place. */
153 if (sbuf.st_dev != psbuf->st_dev ||
154 sbuf.st_ino != psbuf->st_ino ||
155 sbuf.st_mode != psbuf->st_mode ) {
156 DEBUG(0,("change_owner_to_parent: "
157 "device/inode/mode on directory %s changed. "
158 "Refusing to chown !\n", fname ));
163 ret = SMB_VFS_CHOWN(conn, ".", parent_st.st_uid, (gid_t)-1);
166 DEBUG(10,("change_owner_to_parent: failed to chown "
167 "directory %s to parent directory uid %u. "
168 "Error was %s\n", fname,
169 (unsigned int)parent_st.st_uid, strerror(errno) ));
173 DEBUG(10,("change_owner_to_parent: changed ownership of new "
174 "directory %s to parent directory uid %u.\n",
175 fname, (unsigned int)parent_st.st_uid ));
179 vfs_ChDir(conn,saved_dir);
183 /****************************************************************************
185 ****************************************************************************/
187 static NTSTATUS open_file(files_struct *fsp,
188 connection_struct *conn,
190 SMB_STRUCT_STAT *psbuf,
195 int accmode = (flags & O_ACCMODE);
196 int local_flags = flags;
197 BOOL file_existed = VALID_STAT(*psbuf);
202 /* Check permissions */
205 * This code was changed after seeing a client open request
206 * containing the open mode of (DENY_WRITE/read-only) with
207 * the 'create if not exist' bit set. The previous code
208 * would fail to open the file read only on a read-only share
209 * as it was checking the flags parameter directly against O_RDONLY,
210 * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
214 if (!CAN_WRITE(conn)) {
215 /* It's a read-only share - fail if we wanted to write. */
216 if(accmode != O_RDONLY) {
217 DEBUG(3,("Permission denied opening %s\n",fname));
218 return NT_STATUS_ACCESS_DENIED;
219 } else if(flags & O_CREAT) {
220 /* We don't want to write - but we must make sure that
221 O_CREAT doesn't create the file if we have write
222 access into the directory.
225 local_flags &= ~O_CREAT;
230 * This little piece of insanity is inspired by the
231 * fact that an NT client can open a file for O_RDONLY,
232 * but set the create disposition to FILE_EXISTS_TRUNCATE.
233 * If the client *can* write to the file, then it expects to
234 * truncate the file, even though it is opening for readonly.
235 * Quicken uses this stupid trick in backup file creation...
236 * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
237 * for helping track this one down. It didn't bite us in 2.0.x
238 * as we always opened files read-write in that release. JRA.
241 if ((accmode == O_RDONLY) && ((flags & O_TRUNC) == O_TRUNC)) {
242 DEBUG(10,("open_file: truncate requested on read-only open "
243 "for file %s\n",fname ));
244 local_flags = (flags & ~O_ACCMODE)|O_RDWR;
247 if ((access_mask & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ||
248 (!file_existed && (local_flags & O_CREAT)) ||
249 ((local_flags & O_TRUNC) == O_TRUNC) ) {
252 * We can't actually truncate here as the file may be locked.
253 * open_file_ntcreate will take care of the truncate later. JRA.
256 local_flags &= ~O_TRUNC;
258 #if defined(O_NONBLOCK) && defined(S_ISFIFO)
260 * We would block on opening a FIFO with no one else on the
261 * other end. Do what we used to do and add O_NONBLOCK to the
265 if (file_existed && S_ISFIFO(psbuf->st_mode)) {
266 local_flags |= O_NONBLOCK;
270 /* Don't create files with Microsoft wildcard characters. */
271 if ((local_flags & O_CREAT) && !file_existed &&
272 ms_has_wild(fname)) {
273 return NT_STATUS_OBJECT_NAME_INVALID;
276 /* Actually do the open */
277 if (!fd_open(conn, fname, fsp, local_flags, unx_mode)) {
278 DEBUG(3,("Error opening file %s (%s) (local_flags=%d) "
280 fname,strerror(errno),local_flags,flags));
281 return map_nt_error_from_unix(errno);
284 /* Inherit the ACL if the file was created. */
285 if ((local_flags & O_CREAT) && !file_existed) {
286 inherit_access_acl(conn, fname, unx_mode);
290 fsp->fh->fd = -1; /* What we used to call a stat open. */
296 if (fsp->fh->fd == -1) {
297 ret = SMB_VFS_STAT(conn, fname, psbuf);
299 ret = SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf);
300 /* If we have an fd, this stat should succeed. */
302 DEBUG(0,("Error doing fstat on open file %s "
303 "(%s)\n", fname,strerror(errno) ));
307 /* For a non-io open, this stat failing means file not found. JRA */
309 NTSTATUS status = map_nt_error_from_unix(errno);
316 * POSIX allows read-only opens of directories. We don't
317 * want to do this (we use a different code path for this)
318 * so catch a directory open and return an EISDIR. JRA.
321 if(S_ISDIR(psbuf->st_mode)) {
324 return NT_STATUS_FILE_IS_A_DIRECTORY;
327 fsp->mode = psbuf->st_mode;
328 fsp->inode = psbuf->st_ino;
329 fsp->dev = psbuf->st_dev;
330 fsp->vuid = current_user.vuid;
331 fsp->file_pid = global_smbpid;
332 fsp->can_lock = True;
333 fsp->can_read = (access_mask & (FILE_READ_DATA)) ? True : False;
334 if (!CAN_WRITE(conn)) {
335 fsp->can_write = False;
337 fsp->can_write = (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) ? True : False;
339 fsp->print_file = False;
340 fsp->modified = False;
341 fsp->sent_oplock_break = NO_BREAK_SENT;
342 fsp->is_directory = False;
343 fsp->is_stat = False;
344 if (conn->aio_write_behind_list &&
345 is_in_path(fname, conn->aio_write_behind_list, conn->case_sensitive)) {
346 fsp->aio_write_behind = True;
349 string_set(&fsp->fsp_name,fname);
350 fsp->wcp = NULL; /* Write cache pointer. */
352 DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
353 *current_user_info.smb_name ? current_user_info.smb_name : conn->user,fsp->fsp_name,
354 BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
355 conn->num_files_open + 1));
361 /*******************************************************************
362 Return True if the filename is one of the special executable types.
363 ********************************************************************/
365 static BOOL is_executable(const char *fname)
367 if ((fname = strrchr_m(fname,'.'))) {
368 if (strequal(fname,".com") ||
369 strequal(fname,".dll") ||
370 strequal(fname,".exe") ||
371 strequal(fname,".sym")) {
378 /****************************************************************************
379 Check if we can open a file with a share mode.
380 Returns True if conflict, False if not.
381 ****************************************************************************/
383 static BOOL share_conflict(struct share_mode_entry *entry,
387 DEBUG(10,("share_conflict: entry->access_mask = 0x%x, "
388 "entry->share_access = 0x%x, "
389 "entry->private_options = 0x%x\n",
390 (unsigned int)entry->access_mask,
391 (unsigned int)entry->share_access,
392 (unsigned int)entry->private_options));
394 DEBUG(10,("share_conflict: access_mask = 0x%x, share_access = 0x%x\n",
395 (unsigned int)access_mask, (unsigned int)share_access));
397 if ((entry->access_mask & (FILE_WRITE_DATA|
401 DELETE_ACCESS)) == 0) {
402 DEBUG(10,("share_conflict: No conflict due to "
403 "entry->access_mask = 0x%x\n",
404 (unsigned int)entry->access_mask ));
408 if ((access_mask & (FILE_WRITE_DATA|
412 DELETE_ACCESS)) == 0) {
413 DEBUG(10,("share_conflict: No conflict due to "
414 "access_mask = 0x%x\n",
415 (unsigned int)access_mask ));
419 #if 1 /* JRA TEST - Superdebug. */
420 #define CHECK_MASK(num, am, right, sa, share) \
421 DEBUG(10,("share_conflict: [%d] am (0x%x) & right (0x%x) = 0x%x\n", \
422 (unsigned int)(num), (unsigned int)(am), \
423 (unsigned int)(right), (unsigned int)(am)&(right) )); \
424 DEBUG(10,("share_conflict: [%d] sa (0x%x) & share (0x%x) = 0x%x\n", \
425 (unsigned int)(num), (unsigned int)(sa), \
426 (unsigned int)(share), (unsigned int)(sa)&(share) )); \
427 if (((am) & (right)) && !((sa) & (share))) { \
428 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
429 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
430 (unsigned int)(share) )); \
434 #define CHECK_MASK(num, am, right, sa, share) \
435 if (((am) & (right)) && !((sa) & (share))) { \
436 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
437 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
438 (unsigned int)(share) )); \
443 CHECK_MASK(1, entry->access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
444 share_access, FILE_SHARE_WRITE);
445 CHECK_MASK(2, access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
446 entry->share_access, FILE_SHARE_WRITE);
448 CHECK_MASK(3, entry->access_mask, FILE_READ_DATA | FILE_EXECUTE,
449 share_access, FILE_SHARE_READ);
450 CHECK_MASK(4, access_mask, FILE_READ_DATA | FILE_EXECUTE,
451 entry->share_access, FILE_SHARE_READ);
453 CHECK_MASK(5, entry->access_mask, DELETE_ACCESS,
454 share_access, FILE_SHARE_DELETE);
455 CHECK_MASK(6, access_mask, DELETE_ACCESS,
456 entry->share_access, FILE_SHARE_DELETE);
458 DEBUG(10,("share_conflict: No conflict.\n"));
462 #if defined(DEVELOPER)
463 static void validate_my_share_entries(int num,
464 struct share_mode_entry *share_entry)
468 if (!procid_is_me(&share_entry->pid)) {
472 if (is_deferred_open_entry(share_entry) &&
473 !open_was_deferred(share_entry->op_mid)) {
475 DEBUG(0, ("Got a deferred entry without a request: "
476 "PANIC: %s\n", share_mode_str(num, share_entry)));
480 if (!is_valid_share_mode_entry(share_entry)) {
484 fsp = file_find_dif(share_entry->dev, share_entry->inode,
485 share_entry->share_file_id);
487 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
488 share_mode_str(num, share_entry) ));
489 smb_panic("validate_my_share_entries: Cannot match a "
490 "share entry with an open file\n");
493 if (is_deferred_open_entry(share_entry) ||
494 is_unused_share_mode_entry(share_entry)) {
498 if ((share_entry->op_type == NO_OPLOCK) &&
499 (fsp->oplock_type == FAKE_LEVEL_II_OPLOCK)) {
500 /* Someone has already written to it, but I haven't yet
505 if (((uint16)fsp->oplock_type) != share_entry->op_type) {
514 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
515 share_mode_str(num, share_entry) ));
516 slprintf(str, sizeof(str)-1, "validate_my_share_entries: "
517 "file %s, oplock_type = 0x%x, op_type = 0x%x\n",
518 fsp->fsp_name, (unsigned int)fsp->oplock_type,
519 (unsigned int)share_entry->op_type );
525 static BOOL is_stat_open(uint32 access_mask)
527 return (access_mask &&
528 ((access_mask & ~(SYNCHRONIZE_ACCESS| FILE_READ_ATTRIBUTES|
529 FILE_WRITE_ATTRIBUTES))==0) &&
530 ((access_mask & (SYNCHRONIZE_ACCESS|FILE_READ_ATTRIBUTES|
531 FILE_WRITE_ATTRIBUTES)) != 0));
534 /****************************************************************************
535 Deal with share modes
536 Invarient: Share mode must be locked on entry and exit.
537 Returns -1 on error, or number of share modes on success (may be zero).
538 ****************************************************************************/
540 static NTSTATUS open_mode_check(connection_struct *conn,
542 struct share_mode_lock *lck,
545 uint32 create_options,
550 if(lck->num_share_modes == 0) {
554 *file_existed = True;
556 if (is_stat_open(access_mask)) {
557 /* Stat open that doesn't trigger oplock breaks or share mode
558 * checks... ! JRA. */
562 /* A delete on close prohibits everything */
564 if (lck->delete_on_close) {
565 return NT_STATUS_DELETE_PENDING;
569 * Check if the share modes will give us access.
572 #if defined(DEVELOPER)
573 for(i = 0; i < lck->num_share_modes; i++) {
574 validate_my_share_entries(i, &lck->share_modes[i]);
578 if (!lp_share_modes(SNUM(conn))) {
582 /* Now we check the share modes, after any oplock breaks. */
583 for(i = 0; i < lck->num_share_modes; i++) {
585 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
589 /* someone else has a share lock on it, check to see if we can
591 if (share_conflict(&lck->share_modes[i],
592 access_mask, share_access)) {
593 return NT_STATUS_SHARING_VIOLATION;
600 static BOOL is_delete_request(files_struct *fsp) {
601 return ((fsp->access_mask == DELETE_ACCESS) &&
602 (fsp->oplock_type == NO_OPLOCK));
606 * 1) No files open at all or internal open: Grant whatever the client wants.
608 * 2) Exclusive (or batch) oplock around: If the requested access is a delete
609 * request, break if the oplock around is a batch oplock. If it's another
610 * requested access type, break.
612 * 3) Only level2 around: Grant level2 and do nothing else.
615 static BOOL delay_for_oplocks(struct share_mode_lock *lck,
621 struct share_mode_entry *exclusive = NULL;
622 BOOL valid_entry = False;
623 BOOL delay_it = False;
624 BOOL have_level2 = False;
626 if (oplock_request & INTERNAL_OPEN_ONLY) {
627 fsp->oplock_type = NO_OPLOCK;
630 if ((oplock_request & INTERNAL_OPEN_ONLY) || is_stat_open(fsp->access_mask)) {
634 for (i=0; i<lck->num_share_modes; i++) {
636 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
640 /* At least one entry is not an invalid or deferred entry. */
643 if (pass_number == 1) {
644 if (BATCH_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
645 SMB_ASSERT(exclusive == NULL);
646 exclusive = &lck->share_modes[i];
649 if (EXCLUSIVE_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
650 SMB_ASSERT(exclusive == NULL);
651 exclusive = &lck->share_modes[i];
655 if (lck->share_modes[i].op_type == LEVEL_II_OPLOCK) {
656 SMB_ASSERT(exclusive == NULL);
662 /* All entries are placeholders or deferred.
663 * Directly grant whatever the client wants. */
664 if (fsp->oplock_type == NO_OPLOCK) {
665 /* Store a level2 oplock, but don't tell the client */
666 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
671 if (exclusive != NULL) { /* Found an exclusive oplock */
672 SMB_ASSERT(!have_level2);
673 delay_it = is_delete_request(fsp) ?
674 BATCH_OPLOCK_TYPE(exclusive->op_type) : True;
677 if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
678 /* We can at most grant level2 as there are other
679 * level2 or NO_OPLOCK entries. */
680 fsp->oplock_type = LEVEL_II_OPLOCK;
683 if ((fsp->oplock_type == NO_OPLOCK) && have_level2) {
684 /* Store a level2 oplock, but don't tell the client */
685 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
690 char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
692 DEBUG(10, ("Sending break request to PID %s\n",
693 procid_str_static(&exclusive->pid)));
694 exclusive->op_mid = get_current_mid();
696 /* Create the message. */
697 share_mode_entry_to_message(msg, exclusive);
699 /* Add in the FORCE_OPLOCK_BREAK_TO_NONE bit in the message if set. We don't
700 want this set in the share mode struct pointed to by lck. */
702 if (oplock_request & FORCE_OPLOCK_BREAK_TO_NONE) {
703 SSVAL(msg,6,exclusive->op_type | FORCE_OPLOCK_BREAK_TO_NONE);
707 ret = message_send_pid(exclusive->pid, MSG_SMB_BREAK_REQUEST,
708 msg, MSG_SMB_SHARE_MODE_ENTRY_SIZE, True);
711 DEBUG(3, ("Could not send oplock break message\n"));
718 static BOOL request_timed_out(struct timeval request_time,
719 struct timeval timeout)
721 struct timeval now, end_time;
723 end_time = timeval_sum(&request_time, &timeout);
724 return (timeval_compare(&end_time, &now) < 0);
727 /****************************************************************************
728 Handle the 1 second delay in returning a SHARING_VIOLATION error.
729 ****************************************************************************/
731 static void defer_open(struct share_mode_lock *lck,
732 struct timeval request_time,
733 struct timeval timeout,
734 struct deferred_open_record *state)
736 uint16 mid = get_current_mid();
741 for (i=0; i<lck->num_share_modes; i++) {
742 struct share_mode_entry *e = &lck->share_modes[i];
744 if (!is_deferred_open_entry(e)) {
748 if (procid_is_me(&e->pid) && (e->op_mid == mid)) {
749 DEBUG(0, ("Trying to defer an already deferred "
750 "request: mid=%d, exiting\n", mid));
751 exit_server("attempt to defer a deferred request");
755 /* End paranoia check */
757 DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred "
758 "open entry for mid %u\n",
759 (unsigned int)request_time.tv_sec,
760 (unsigned int)request_time.tv_usec,
763 if (!push_deferred_smb_message(mid, request_time, timeout,
764 (char *)state, sizeof(*state))) {
765 exit_server("push_deferred_smb_message failed");
767 add_deferred_open(lck, mid, request_time, state->dev, state->inode);
770 * Push the MID of this packet on the signing queue.
771 * We only do this once, the first time we push the packet
772 * onto the deferred open queue, as this has a side effect
773 * of incrementing the response sequence number.
776 srv_defer_sign_response(mid);
779 /****************************************************************************
780 Set a kernel flock on a file for NFS interoperability.
781 This requires a patch to Linux.
782 ****************************************************************************/
784 static void kernel_flock(files_struct *fsp, uint32 share_mode)
786 #if HAVE_KERNEL_SHARE_MODES
788 if (share_mode == FILE_SHARE_WRITE) {
789 kernel_mode = LOCK_MAND|LOCK_WRITE;
790 } else if (share_mode == FILE_SHARE_READ) {
791 kernel_mode = LOCK_MAND|LOCK_READ;
792 } else if (share_mode == FILE_SHARE_NONE) {
793 kernel_mode = LOCK_MAND;
796 flock(fsp->fh->fd, kernel_mode);
802 /****************************************************************************
803 On overwrite open ensure that the attributes match.
804 ****************************************************************************/
806 static BOOL open_match_attributes(connection_struct *conn,
810 mode_t existing_unx_mode,
812 mode_t *returned_unx_mode)
814 uint32 noarch_old_dos_attr, noarch_new_dos_attr;
816 noarch_old_dos_attr = (old_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
817 noarch_new_dos_attr = (new_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
819 if((noarch_old_dos_attr == 0 && noarch_new_dos_attr != 0) ||
820 (noarch_old_dos_attr != 0 && ((noarch_old_dos_attr & noarch_new_dos_attr) == noarch_old_dos_attr))) {
821 *returned_unx_mode = new_unx_mode;
823 *returned_unx_mode = (mode_t)0;
826 DEBUG(10,("open_match_attributes: file %s old_dos_attr = 0x%x, "
827 "existing_unx_mode = 0%o, new_dos_attr = 0x%x "
828 "returned_unx_mode = 0%o\n",
830 (unsigned int)old_dos_attr,
831 (unsigned int)existing_unx_mode,
832 (unsigned int)new_dos_attr,
833 (unsigned int)*returned_unx_mode ));
835 /* If we're mapping SYSTEM and HIDDEN ensure they match. */
836 if (lp_map_system(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
837 if ((old_dos_attr & FILE_ATTRIBUTE_SYSTEM) &&
838 !(new_dos_attr & FILE_ATTRIBUTE_SYSTEM)) {
842 if (lp_map_hidden(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
843 if ((old_dos_attr & FILE_ATTRIBUTE_HIDDEN) &&
844 !(new_dos_attr & FILE_ATTRIBUTE_HIDDEN)) {
851 /****************************************************************************
852 Special FCB or DOS processing in the case of a sharing violation.
853 Try and find a duplicated file handle.
854 ****************************************************************************/
856 static files_struct *fcb_or_dos_open(connection_struct *conn,
857 const char *fname, SMB_DEV_T dev,
861 uint32 create_options)
864 files_struct *dup_fsp;
866 DEBUG(5,("fcb_or_dos_open: attempting old open semantics for "
867 "file %s.\n", fname ));
869 for(fsp = file_find_di_first(dev, inode); fsp;
870 fsp = file_find_di_next(fsp)) {
872 DEBUG(10,("fcb_or_dos_open: checking file %s, fd = %d, "
873 "vuid = %u, file_pid = %u, private_options = 0x%x "
874 "access_mask = 0x%x\n", fsp->fsp_name,
875 fsp->fh->fd, (unsigned int)fsp->vuid,
876 (unsigned int)fsp->file_pid,
877 (unsigned int)fsp->fh->private_options,
878 (unsigned int)fsp->access_mask ));
880 if (fsp->fh->fd != -1 &&
881 fsp->vuid == current_user.vuid &&
882 fsp->file_pid == global_smbpid &&
883 (fsp->fh->private_options & (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS |
884 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) &&
885 (fsp->access_mask & FILE_WRITE_DATA) &&
886 strequal(fsp->fsp_name, fname)) {
887 DEBUG(10,("fcb_or_dos_open: file match\n"));
896 /* quite an insane set of semantics ... */
897 if (is_executable(fname) &&
898 (fsp->fh->private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS)) {
899 DEBUG(10,("fcb_or_dos_open: file fail due to is_executable.\n"));
903 /* We need to duplicate this fsp. */
904 if (!NT_STATUS_IS_OK(dup_file_fsp(fsp, access_mask, share_access,
905 create_options, &dup_fsp))) {
912 /****************************************************************************
913 Open a file with a share mode - old openX method - map into NTCreate.
914 ****************************************************************************/
916 BOOL map_open_params_to_ntcreate(const char *fname, int deny_mode, int open_func,
917 uint32 *paccess_mask,
919 uint32 *pcreate_disposition,
920 uint32 *pcreate_options)
924 uint32 create_disposition;
925 uint32 create_options = 0;
927 DEBUG(10,("map_open_params_to_ntcreate: fname = %s, deny_mode = 0x%x, "
928 "open_func = 0x%x\n",
929 fname, (unsigned int)deny_mode, (unsigned int)open_func ));
931 /* Create the NT compatible access_mask. */
932 switch (GET_OPENX_MODE(deny_mode)) {
933 case DOS_OPEN_EXEC: /* Implies read-only - used to be FILE_READ_DATA */
934 case DOS_OPEN_RDONLY:
935 access_mask = FILE_GENERIC_READ;
937 case DOS_OPEN_WRONLY:
938 access_mask = FILE_GENERIC_WRITE;
942 access_mask = FILE_GENERIC_READ|FILE_GENERIC_WRITE;
945 DEBUG(10,("map_open_params_to_ntcreate: bad open mode = 0x%x\n",
946 (unsigned int)GET_OPENX_MODE(deny_mode)));
950 /* Create the NT compatible create_disposition. */
952 case OPENX_FILE_EXISTS_FAIL|OPENX_FILE_CREATE_IF_NOT_EXIST:
953 create_disposition = FILE_CREATE;
956 case OPENX_FILE_EXISTS_OPEN:
957 create_disposition = FILE_OPEN;
960 case OPENX_FILE_EXISTS_OPEN|OPENX_FILE_CREATE_IF_NOT_EXIST:
961 create_disposition = FILE_OPEN_IF;
964 case OPENX_FILE_EXISTS_TRUNCATE:
965 create_disposition = FILE_OVERWRITE;
968 case OPENX_FILE_EXISTS_TRUNCATE|OPENX_FILE_CREATE_IF_NOT_EXIST:
969 create_disposition = FILE_OVERWRITE_IF;
973 /* From samba4 - to be confirmed. */
974 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_EXEC) {
975 create_disposition = FILE_CREATE;
978 DEBUG(10,("map_open_params_to_ntcreate: bad "
979 "open_func 0x%x\n", (unsigned int)open_func));
983 /* Create the NT compatible share modes. */
984 switch (GET_DENY_MODE(deny_mode)) {
986 share_mode = FILE_SHARE_NONE;
990 share_mode = FILE_SHARE_READ;
994 share_mode = FILE_SHARE_WRITE;
998 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
1002 create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
1003 if (is_executable(fname)) {
1004 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
1006 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_RDONLY) {
1007 share_mode = FILE_SHARE_READ;
1009 share_mode = FILE_SHARE_NONE;
1015 create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
1016 share_mode = FILE_SHARE_NONE;
1020 DEBUG(10,("map_open_params_to_ntcreate: bad deny_mode 0x%x\n",
1021 (unsigned int)GET_DENY_MODE(deny_mode) ));
1025 DEBUG(10,("map_open_params_to_ntcreate: file %s, access_mask = 0x%x, "
1026 "share_mode = 0x%x, create_disposition = 0x%x, "
1027 "create_options = 0x%x\n",
1029 (unsigned int)access_mask,
1030 (unsigned int)share_mode,
1031 (unsigned int)create_disposition,
1032 (unsigned int)create_options ));
1035 *paccess_mask = access_mask;
1038 *pshare_mode = share_mode;
1040 if (pcreate_disposition) {
1041 *pcreate_disposition = create_disposition;
1043 if (pcreate_options) {
1044 *pcreate_options = create_options;
1051 static void schedule_defer_open(struct share_mode_lock *lck, struct timeval request_time)
1053 struct deferred_open_record state;
1055 /* This is a relative time, added to the absolute
1056 request_time value to get the absolute timeout time.
1057 Note that if this is the second or greater time we enter
1058 this codepath for this particular request mid then
1059 request_time is left as the absolute time of the *first*
1060 time this request mid was processed. This is what allows
1061 the request to eventually time out. */
1063 struct timeval timeout;
1065 /* Normally the smbd we asked should respond within
1066 * OPLOCK_BREAK_TIMEOUT seconds regardless of whether
1067 * the client did, give twice the timeout as a safety
1068 * measure here in case the other smbd is stuck
1069 * somewhere else. */
1071 timeout = timeval_set(OPLOCK_BREAK_TIMEOUT*2, 0);
1073 /* Nothing actually uses state.delayed_for_oplocks
1074 but it's handy to differentiate in debug messages
1075 between a 30 second delay due to oplock break, and
1076 a 1 second delay for share mode conflicts. */
1078 state.delayed_for_oplocks = True;
1079 state.dev = lck->dev;
1080 state.inode = lck->ino;
1082 if (!request_timed_out(request_time, timeout)) {
1083 defer_open(lck, request_time, timeout, &state);
1087 /****************************************************************************
1088 Open a file with a share mode.
1089 ****************************************************************************/
1091 NTSTATUS open_file_ntcreate(connection_struct *conn,
1093 SMB_STRUCT_STAT *psbuf,
1094 uint32 access_mask, /* access bits (FILE_READ_DATA etc.) */
1095 uint32 share_access, /* share constants (FILE_SHARE_READ etc). */
1096 uint32 create_disposition, /* FILE_OPEN_IF etc. */
1097 uint32 create_options, /* options such as delete on close. */
1098 uint32 new_dos_attributes, /* attributes used for new file. */
1099 int oplock_request, /* internal Samba oplock codes. */
1100 /* Information (FILE_EXISTS etc.) */
1102 files_struct **result)
1106 BOOL file_existed = VALID_STAT(*psbuf);
1107 BOOL def_acl = False;
1109 SMB_INO_T inode = 0;
1110 NTSTATUS fsp_open = NT_STATUS_ACCESS_DENIED;
1111 files_struct *fsp = NULL;
1112 mode_t new_unx_mode = (mode_t)0;
1113 mode_t unx_mode = (mode_t)0;
1115 uint32 existing_dos_attributes = 0;
1116 struct pending_message_list *pml = NULL;
1117 uint16 mid = get_current_mid();
1118 struct timeval request_time = timeval_zero();
1119 struct share_mode_lock *lck = NULL;
1122 if (conn->printer) {
1124 * Printers are handled completely differently.
1125 * Most of the passed parameters are ignored.
1129 *pinfo = FILE_WAS_CREATED;
1132 DEBUG(10, ("open_file_ntcreate: printer open fname=%s\n", fname));
1134 return print_fsp_open(conn, fname, &fsp);
1137 /* We add aARCH to this as this mode is only used if the file is
1139 unx_mode = unix_mode(conn, new_dos_attributes | aARCH,fname, True);
1141 DEBUG(10, ("open_file_ntcreate: fname=%s, dos_attrs=0x%x "
1142 "access_mask=0x%x share_access=0x%x "
1143 "create_disposition = 0x%x create_options=0x%x "
1144 "unix mode=0%o oplock_request=%d\n",
1145 fname, new_dos_attributes, access_mask, share_access,
1146 create_disposition, create_options, unx_mode,
1149 if ((pml = get_open_deferred_message(mid)) != NULL) {
1150 struct deferred_open_record *state =
1151 (struct deferred_open_record *)pml->private_data.data;
1153 /* Remember the absolute time of the original
1154 request with this mid. We'll use it later to
1155 see if this has timed out. */
1157 request_time = pml->request_time;
1159 /* Remove the deferred open entry under lock. */
1160 lck = get_share_mode_lock(NULL, state->dev, state->inode, NULL, NULL);
1162 DEBUG(0, ("could not get share mode lock\n"));
1164 del_deferred_open_entry(lck, mid);
1168 /* Ensure we don't reprocess this message. */
1169 remove_deferred_open_smb_message(mid);
1172 if (!check_name(fname,conn)) {
1173 return map_nt_error_from_unix(errno);
1176 new_dos_attributes &= SAMBA_ATTRIBUTES_MASK;
1178 existing_dos_attributes = dos_mode(conn, fname, psbuf);
1181 /* ignore any oplock requests if oplocks are disabled */
1182 if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break ||
1183 IS_VETO_OPLOCK_PATH(conn, fname)) {
1184 /* Mask off everything except the private Samba bits. */
1185 oplock_request &= SAMBA_PRIVATE_OPLOCK_MASK;
1188 /* this is for OS/2 long file names - say we don't support them */
1189 if (!lp_posix_pathnames() && strstr(fname,".+,;=[].")) {
1190 /* OS/2 Workplace shell fix may be main code stream in a later
1192 DEBUG(5,("open_file_ntcreate: OS/2 long filenames are not "
1194 if (use_nt_status()) {
1195 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1197 return NT_STATUS_DOS(ERRDOS, ERRcannotopen);
1200 switch( create_disposition ) {
1202 * Currently we're using FILE_SUPERSEDE as the same as
1203 * FILE_OVERWRITE_IF but they really are
1204 * different. FILE_SUPERSEDE deletes an existing file
1205 * (requiring delete access) then recreates it.
1207 case FILE_SUPERSEDE:
1208 /* If file exists replace/overwrite. If file doesn't
1210 flags2 |= (O_CREAT | O_TRUNC);
1213 case FILE_OVERWRITE_IF:
1214 /* If file exists replace/overwrite. If file doesn't
1216 flags2 |= (O_CREAT | O_TRUNC);
1220 /* If file exists open. If file doesn't exist error. */
1221 if (!file_existed) {
1222 DEBUG(5,("open_file_ntcreate: FILE_OPEN "
1223 "requested for file %s and file "
1224 "doesn't exist.\n", fname ));
1226 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1230 case FILE_OVERWRITE:
1231 /* If file exists overwrite. If file doesn't exist
1233 if (!file_existed) {
1234 DEBUG(5,("open_file_ntcreate: FILE_OVERWRITE "
1235 "requested for file %s and file "
1236 "doesn't exist.\n", fname ));
1238 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1244 /* If file exists error. If file doesn't exist
1247 DEBUG(5,("open_file_ntcreate: FILE_CREATE "
1248 "requested for file %s and file "
1249 "already exists.\n", fname ));
1250 if (S_ISDIR(psbuf->st_mode)) {
1255 return map_nt_error_from_unix(errno);
1257 flags2 |= (O_CREAT|O_EXCL);
1261 /* If file exists open. If file doesn't exist
1267 return NT_STATUS_INVALID_PARAMETER;
1270 /* We only care about matching attributes on file exists and
1273 if (file_existed && ((create_disposition == FILE_OVERWRITE) ||
1274 (create_disposition == FILE_OVERWRITE_IF))) {
1275 if (!open_match_attributes(conn, fname,
1276 existing_dos_attributes,
1277 new_dos_attributes, psbuf->st_mode,
1278 unx_mode, &new_unx_mode)) {
1279 DEBUG(5,("open_file_ntcreate: attributes missmatch "
1280 "for file %s (%x %x) (0%o, 0%o)\n",
1281 fname, existing_dos_attributes,
1283 (unsigned int)psbuf->st_mode,
1284 (unsigned int)unx_mode ));
1286 return NT_STATUS_ACCESS_DENIED;
1290 /* This is a nasty hack - must fix... JRA. */
1291 if (access_mask == MAXIMUM_ALLOWED_ACCESS) {
1292 access_mask = FILE_GENERIC_ALL;
1296 * Convert GENERIC bits to specific bits.
1299 se_map_generic(&access_mask, &file_generic_mapping);
1301 DEBUG(10, ("open_file_ntcreate: fname=%s, after mapping "
1302 "access_mask=0x%x\n", fname, access_mask ));
1305 * Note that we ignore the append flag as append does not
1306 * mean the same thing under DOS and Unix.
1309 if (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) {
1316 * Currently we only look at FILE_WRITE_THROUGH for create options.
1320 if ((create_options & FILE_WRITE_THROUGH) && lp_strict_sync(SNUM(conn))) {
1325 if (!CAN_WRITE(conn)) {
1327 * We should really return a permission denied error if either
1328 * O_CREAT or O_TRUNC are set, but for compatibility with
1329 * older versions of Samba we just AND them out.
1331 flags2 &= ~(O_CREAT|O_TRUNC);
1335 * Ensure we can't write on a read-only share or file.
1338 if (flags != O_RDONLY && file_existed &&
1339 (!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_attributes))) {
1340 DEBUG(5,("open_file_ntcreate: write access requested for "
1341 "file %s on read only %s\n",
1342 fname, !CAN_WRITE(conn) ? "share" : "file" ));
1344 return NT_STATUS_ACCESS_DENIED;
1347 status = file_new(conn, &fsp);
1348 if(!NT_STATUS_IS_OK(status)) {
1352 fsp->dev = psbuf->st_dev;
1353 fsp->inode = psbuf->st_ino;
1354 fsp->share_access = share_access;
1355 fsp->fh->private_options = create_options;
1356 fsp->access_mask = access_mask;
1357 /* Ensure no SAMBA_PRIVATE bits can be set. */
1358 fsp->oplock_type = (oplock_request & ~SAMBA_PRIVATE_OPLOCK_MASK);
1360 if (timeval_is_zero(&request_time)) {
1361 request_time = fsp->open_time;
1365 dev = psbuf->st_dev;
1366 inode = psbuf->st_ino;
1368 lck = get_share_mode_lock(NULL, dev, inode,
1374 DEBUG(0, ("Could not get share mode lock\n"));
1375 return NT_STATUS_SHARING_VIOLATION;
1378 /* First pass - send break only on batch oplocks. */
1379 if (delay_for_oplocks(lck, fsp, 1, oplock_request)) {
1380 schedule_defer_open(lck, request_time);
1383 return NT_STATUS_SHARING_VIOLATION;
1386 status = open_mode_check(conn, fname, lck,
1387 access_mask, share_access,
1388 create_options, &file_existed);
1390 if (NT_STATUS_IS_OK(status)) {
1391 /* We might be going to allow this open. Check oplock status again. */
1392 /* Second pass - send break for both batch or exclusive oplocks. */
1393 if (delay_for_oplocks(lck, fsp, 2, oplock_request)) {
1394 schedule_defer_open(lck, request_time);
1397 return NT_STATUS_SHARING_VIOLATION;
1401 if (NT_STATUS_EQUAL(status, NT_STATUS_DELETE_PENDING)) {
1402 /* DELETE_PENDING is not deferred for a second */
1408 if (!NT_STATUS_IS_OK(status)) {
1409 uint32 can_access_mask;
1410 BOOL can_access = True;
1412 SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION));
1414 /* Check if this can be done with the deny_dos and fcb
1416 if (create_options &
1417 (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS|
1418 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
1419 files_struct *fsp_dup;
1420 fsp_dup = fcb_or_dos_open(conn, fname, dev,
1429 *pinfo = FILE_WAS_OPENED;
1431 conn->num_files_open++;
1433 return NT_STATUS_OK;
1438 * This next line is a subtlety we need for
1439 * MS-Access. If a file open will fail due to share
1440 * permissions and also for security (access) reasons,
1441 * we need to return the access failed error, not the
1442 * share error. We can't open the file due to kernel
1443 * oplock deadlock (it's possible we failed above on
1444 * the open_mode_check()) so use a userspace check.
1447 if (flags & O_RDWR) {
1448 can_access_mask = FILE_READ_DATA|FILE_WRITE_DATA;
1450 can_access_mask = FILE_READ_DATA;
1453 if (((flags & O_RDWR) && !CAN_WRITE(conn)) ||
1454 !can_access_file(conn,fname,psbuf,can_access_mask)) {
1459 * If we're returning a share violation, ensure we
1460 * cope with the braindead 1 second delay.
1463 if (!(oplock_request & INTERNAL_OPEN_ONLY) &&
1464 lp_defer_sharing_violations()) {
1465 struct timeval timeout;
1466 struct deferred_open_record state;
1469 /* this is a hack to speed up torture tests
1471 timeout_usecs = lp_parm_int(SNUM(conn),
1472 "smbd","sharedelay",
1473 SHARING_VIOLATION_USEC_WAIT);
1475 /* This is a relative time, added to the absolute
1476 request_time value to get the absolute timeout time.
1477 Note that if this is the second or greater time we enter
1478 this codepath for this particular request mid then
1479 request_time is left as the absolute time of the *first*
1480 time this request mid was processed. This is what allows
1481 the request to eventually time out. */
1483 timeout = timeval_set(0, timeout_usecs);
1485 /* Nothing actually uses state.delayed_for_oplocks
1486 but it's handy to differentiate in debug messages
1487 between a 30 second delay due to oplock break, and
1488 a 1 second delay for share mode conflicts. */
1490 state.delayed_for_oplocks = False;
1492 state.inode = inode;
1494 if (!request_timed_out(request_time,
1496 defer_open(lck, request_time, timeout,
1504 * We have detected a sharing violation here
1505 * so return the correct error code
1507 status = NT_STATUS_SHARING_VIOLATION;
1509 status = NT_STATUS_ACCESS_DENIED;
1516 * We exit this block with the share entry *locked*.....
1520 SMB_ASSERT(!file_existed || (lck != NULL));
1523 * Ensure we pay attention to default ACLs on directories if required.
1526 if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
1527 (def_acl = directory_has_default_acl(conn,
1528 parent_dirname(fname)))) {
1532 DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
1533 (unsigned int)flags, (unsigned int)flags2,
1534 (unsigned int)unx_mode));
1536 /* Drop the lock before doing any real file access. Allows kernel
1537 oplock breaks to be processed. Handle any races after the open
1538 call when we re-acquire the lock. */
1545 * open_file strips any O_TRUNC flags itself.
1548 fsp_open = open_file(fsp,conn,fname,psbuf,flags|flags2,unx_mode,
1551 if (!NT_STATUS_IS_OK(fsp_open)) {
1557 * Deal with the race condition where two smbd's detect the
1558 * file doesn't exist and do the create at the same time. One
1559 * of them will win and set a share mode, the other (ie. this
1560 * one) should check if the requested share mode for this
1561 * create is allowed.
1565 * Now the file exists and fsp is successfully opened,
1566 * fsp->dev and fsp->inode are valid and should replace the
1567 * dev=0,inode=0 from a non existent file. Spotted by
1568 * Nadav Danieli <nadavd@exanet.com>. JRA.
1574 lck = get_share_mode_lock(NULL, dev, inode,
1579 DEBUG(0, ("open_file_ntcreate: Could not get share mode lock for %s\n", fname));
1580 fd_close(conn, fsp);
1582 return NT_STATUS_SHARING_VIOLATION;
1586 * The share entry is again *locked*.....
1589 /* First pass - send break only on batch oplocks. */
1590 if (delay_for_oplocks(lck, fsp, 1, oplock_request)) {
1591 schedule_defer_open(lck, request_time);
1592 fd_close(conn, fsp);
1595 return NT_STATUS_SHARING_VIOLATION;
1598 status = open_mode_check(conn, fname, lck,
1599 access_mask, share_access,
1600 create_options, &file_existed);
1602 if (NT_STATUS_IS_OK(status)) {
1603 /* We might be going to allow this open. Check oplock status again. */
1604 /* Second pass - send break for both batch or exclusive oplocks. */
1605 if (delay_for_oplocks(lck, fsp, 2, oplock_request)) {
1606 schedule_defer_open(lck, request_time);
1607 fd_close(conn, fsp);
1610 return NT_STATUS_SHARING_VIOLATION;
1614 if (NT_STATUS_EQUAL(status, NT_STATUS_DELETE_PENDING)) {
1615 /* DELETE_PENDING is not deferred for a second */
1616 fd_close(conn, fsp);
1622 if (!NT_STATUS_IS_OK(status)) {
1623 struct deferred_open_record state;
1625 fd_close(conn, fsp);
1628 state.delayed_for_oplocks = False;
1630 state.inode = inode;
1632 /* Do it all over again immediately. In the second
1633 * round we will find that the file existed and handle
1634 * the DELETE_PENDING and FCB cases correctly. No need
1635 * to duplicate the code here. Essentially this is a
1636 * "goto top of this function", but don't tell
1639 defer_open(lck, request_time, timeval_zero(),
1645 /* note that we ignore failure for the following. It is
1646 basically a hack for NFS, and NFS will never set one of
1647 these only read them. Nobody but Samba can ever set a deny
1648 mode and we have already checked our more authoritative
1649 locking database for permission to set this deny mode. If
1650 the kernel refuses the operations then the kernel is wrong */
1652 kernel_flock(fsp, share_access);
1655 * At this point onwards, we can guarentee that the share entry
1656 * is locked, whether we created the file or not, and that the
1657 * deny mode is compatible with all current opens.
1661 * If requested, truncate the file.
1664 if (flags2&O_TRUNC) {
1666 * We are modifing the file after open - update the stat
1669 if ((SMB_VFS_FTRUNCATE(fsp,fsp->fh->fd,0) == -1) ||
1670 (SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf)==-1)) {
1671 status = map_nt_error_from_unix(errno);
1679 /* Record the options we were opened with. */
1680 fsp->share_access = share_access;
1681 fsp->fh->private_options = create_options;
1682 fsp->access_mask = access_mask;
1685 /* stat opens on existing files don't get oplocks. */
1686 if (is_stat_open(fsp->access_mask)) {
1687 fsp->oplock_type = NO_OPLOCK;
1690 if (!(flags2 & O_TRUNC)) {
1691 info = FILE_WAS_OPENED;
1693 info = FILE_WAS_OVERWRITTEN;
1696 info = FILE_WAS_CREATED;
1697 /* Change the owner if required. */
1698 if (lp_inherit_owner(SNUM(conn))) {
1699 change_owner_to_parent(conn, fsp, fsp->fsp_name,
1709 * Setup the oplock info in both the shared memory and
1713 if ((fsp->oplock_type != NO_OPLOCK) &&
1714 (fsp->oplock_type != FAKE_LEVEL_II_OPLOCK)) {
1715 if (!set_file_oplock(fsp, fsp->oplock_type)) {
1716 /* Could not get the kernel oplock */
1717 fsp->oplock_type = NO_OPLOCK;
1720 set_share_mode(lck, fsp, current_user.ut.uid, 0, fsp->oplock_type);
1722 if (info == FILE_WAS_OVERWRITTEN || info == FILE_WAS_CREATED ||
1723 info == FILE_WAS_SUPERSEDED) {
1725 /* Handle strange delete on close create semantics. */
1726 if (create_options & FILE_DELETE_ON_CLOSE) {
1727 status = can_set_delete_on_close(fsp, True, new_dos_attributes);
1729 if (!NT_STATUS_IS_OK(status)) {
1730 /* Remember to delete the mode we just added. */
1731 del_share_mode(lck, fsp);
1737 /* Note that here we set the *inital* delete on close flag,
1738 not the regular one. */
1739 set_delete_on_close_token(lck, ¤t_user.ut);
1740 lck->initial_delete_on_close = True;
1741 lck->modified = True;
1744 /* Files should be initially set as archive */
1745 if (lp_map_archive(SNUM(conn)) ||
1746 lp_store_dos_attributes(SNUM(conn))) {
1747 file_set_dosmode(conn, fname,
1748 new_dos_attributes | aARCH, NULL,
1754 * Take care of inherited ACLs on created files - if default ACL not
1758 if (!file_existed && !def_acl) {
1760 int saved_errno = errno; /* We might get ENOSYS in the next
1763 if (SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd, unx_mode) == -1
1764 && errno == ENOSYS) {
1765 errno = saved_errno; /* Ignore ENOSYS */
1768 } else if (new_unx_mode) {
1772 /* Attributes need changing. File already existed. */
1775 int saved_errno = errno; /* We might get ENOSYS in the
1777 ret = SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd,
1780 if (ret == -1 && errno == ENOSYS) {
1781 errno = saved_errno; /* Ignore ENOSYS */
1783 DEBUG(5, ("open_file_ntcreate: reset "
1784 "attributes of file %s to 0%o\n",
1785 fname, (unsigned int)new_unx_mode));
1786 ret = 0; /* Don't do the fchmod below. */
1791 (SMB_VFS_FCHMOD(fsp, fsp->fh->fd, new_unx_mode) == -1))
1792 DEBUG(5, ("open_file_ntcreate: failed to reset "
1793 "attributes of file %s to 0%o\n",
1794 fname, (unsigned int)new_unx_mode));
1797 /* If this is a successful open, we must remove any deferred open
1799 del_deferred_open_entry(lck, mid);
1802 conn->num_files_open++;
1805 return NT_STATUS_OK;
1808 /****************************************************************************
1809 Open a file for for write to ensure that we can fchmod it.
1810 ****************************************************************************/
1812 NTSTATUS open_file_fchmod(connection_struct *conn, const char *fname,
1813 SMB_STRUCT_STAT *psbuf, files_struct **result)
1815 files_struct *fsp = NULL;
1818 if (!VALID_STAT(*psbuf)) {
1819 return NT_STATUS_INVALID_PARAMETER;
1822 status = file_new(conn, &fsp);
1823 if(!NT_STATUS_IS_OK(status)) {
1827 /* note! we must use a non-zero desired access or we don't get
1828 a real file descriptor. Oh what a twisted web we weave. */
1829 status = open_file(fsp,conn,fname,psbuf,O_WRONLY,0,FILE_WRITE_DATA);
1832 * This is not a user visible file open.
1833 * Don't set a share mode and don't increment
1834 * the conn->num_files_open.
1837 if (!NT_STATUS_IS_OK(status)) {
1843 return NT_STATUS_OK;
1846 /****************************************************************************
1847 Close the fchmod file fd - ensure no locks are lost.
1848 ****************************************************************************/
1850 int close_file_fchmod(files_struct *fsp)
1852 int ret = fd_close(fsp->conn, fsp);
1857 /****************************************************************************
1858 Open a directory from an NT SMB call.
1859 ****************************************************************************/
1861 NTSTATUS open_directory(connection_struct *conn,
1863 SMB_STRUCT_STAT *psbuf,
1865 uint32 share_access,
1866 uint32 create_disposition,
1867 uint32 create_options,
1869 files_struct **result)
1871 files_struct *fsp = NULL;
1872 BOOL dir_existed = VALID_STAT(*psbuf) ? True : False;
1873 BOOL create_dir = False;
1874 struct share_mode_lock *lck = NULL;
1878 DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
1879 "share_access = 0x%x create_options = 0x%x, "
1880 "create_disposition = 0x%x\n",
1882 (unsigned int)access_mask,
1883 (unsigned int)share_access,
1884 (unsigned int)create_options,
1885 (unsigned int)create_disposition));
1887 if (is_ntfs_stream_name(fname)) {
1888 DEBUG(0,("open_directory: %s is a stream name!\n", fname ));
1889 return NT_STATUS_NOT_A_DIRECTORY;
1892 switch( create_disposition ) {
1894 /* If directory exists open. If directory doesn't
1897 DEBUG(5,("open_directory: FILE_OPEN requested "
1898 "for directory %s and it doesn't "
1899 "exist.\n", fname ));
1900 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1902 info = FILE_WAS_OPENED;
1906 /* If directory exists error. If directory doesn't
1909 DEBUG(5,("open_directory: FILE_CREATE "
1910 "requested for directory %s and it "
1911 "already exists.\n", fname ));
1912 if (use_nt_status()) {
1913 return NT_STATUS_OBJECT_NAME_COLLISION;
1915 return NT_STATUS_DOS(ERRDOS,
1920 info = FILE_WAS_CREATED;
1924 /* If directory exists open. If directory doesn't
1928 info = FILE_WAS_CREATED;
1930 info = FILE_WAS_OPENED;
1934 case FILE_SUPERSEDE:
1935 case FILE_OVERWRITE:
1936 case FILE_OVERWRITE_IF:
1938 DEBUG(5,("open_directory: invalid create_disposition "
1939 "0x%x for directory %s\n",
1940 (unsigned int)create_disposition, fname));
1941 return NT_STATUS_INVALID_PARAMETER;
1946 * Try and create the directory.
1949 /* We know bad_path is false as it's caught earlier. */
1951 status = mkdir_internal(conn, fname, False);
1953 if (!NT_STATUS_IS_OK(status)) {
1954 DEBUG(2,("open_directory: unable to create %s. "
1955 "Error was %s\n", fname, strerror(errno) ));
1956 /* Ensure we return the correct NT status to the
1961 /* Ensure we're checking for a symlink here.... */
1962 /* We don't want to get caught by a symlink racer. */
1964 if(SMB_VFS_LSTAT(conn,fname, psbuf) != 0) {
1965 return map_nt_error_from_unix(errno);
1968 if(!S_ISDIR(psbuf->st_mode)) {
1969 DEBUG(0,("open_directory: %s is not a directory !\n",
1971 return NT_STATUS_NOT_A_DIRECTORY;
1975 status = file_new(conn, &fsp);
1976 if(!NT_STATUS_IS_OK(status)) {
1981 * Setup the files_struct for it.
1984 fsp->mode = psbuf->st_mode;
1985 fsp->inode = psbuf->st_ino;
1986 fsp->dev = psbuf->st_dev;
1987 fsp->vuid = current_user.vuid;
1988 fsp->file_pid = global_smbpid;
1989 fsp->can_lock = False;
1990 fsp->can_read = False;
1991 fsp->can_write = False;
1993 fsp->share_access = share_access;
1994 fsp->fh->private_options = create_options;
1995 fsp->access_mask = access_mask;
1997 fsp->print_file = False;
1998 fsp->modified = False;
1999 fsp->oplock_type = NO_OPLOCK;
2000 fsp->sent_oplock_break = NO_BREAK_SENT;
2001 fsp->is_directory = True;
2002 fsp->is_stat = False;
2003 string_set(&fsp->fsp_name,fname);
2005 lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode,
2010 DEBUG(0, ("open_directory: Could not get share mode lock for %s\n", fname));
2012 return NT_STATUS_SHARING_VIOLATION;
2015 status = open_mode_check(conn, fname, lck,
2016 access_mask, share_access,
2017 create_options, &dir_existed);
2019 if (!NT_STATUS_IS_OK(status)) {
2025 set_share_mode(lck, fsp, current_user.ut.uid, 0, NO_OPLOCK);
2027 /* For directories the delete on close bit at open time seems
2028 always to be honored on close... See test 19 in Samba4 BASE-DELETE. */
2029 if (create_options & FILE_DELETE_ON_CLOSE) {
2030 status = can_set_delete_on_close(fsp, True, 0);
2031 if (!NT_STATUS_IS_OK(status)) {
2037 set_delete_on_close_token(lck, ¤t_user.ut);
2038 lck->initial_delete_on_close = True;
2039 lck->modified = True;
2044 /* Change the owner if required. */
2045 if ((info == FILE_WAS_CREATED) && lp_inherit_owner(SNUM(conn))) {
2046 change_owner_to_parent(conn, fsp, fsp->fsp_name, psbuf);
2053 conn->num_files_open++;
2056 return NT_STATUS_OK;
2059 /****************************************************************************
2060 Open a pseudo-file (no locking checks - a 'stat' open).
2061 ****************************************************************************/
2063 NTSTATUS open_file_stat(connection_struct *conn, char *fname,
2064 SMB_STRUCT_STAT *psbuf, files_struct **result)
2066 files_struct *fsp = NULL;
2069 if (!VALID_STAT(*psbuf)) {
2070 return NT_STATUS_INVALID_PARAMETER;
2073 /* Can't 'stat' open directories. */
2074 if(S_ISDIR(psbuf->st_mode)) {
2075 return NT_STATUS_FILE_IS_A_DIRECTORY;
2078 status = file_new(conn, &fsp);
2079 if(!NT_STATUS_IS_OK(status)) {
2083 DEBUG(5,("open_file_stat: 'opening' file %s\n", fname));
2086 * Setup the files_struct for it.
2089 fsp->mode = psbuf->st_mode;
2090 fsp->inode = psbuf->st_ino;
2091 fsp->dev = psbuf->st_dev;
2092 fsp->vuid = current_user.vuid;
2093 fsp->file_pid = global_smbpid;
2094 fsp->can_lock = False;
2095 fsp->can_read = False;
2096 fsp->can_write = False;
2097 fsp->print_file = False;
2098 fsp->modified = False;
2099 fsp->oplock_type = NO_OPLOCK;
2100 fsp->sent_oplock_break = NO_BREAK_SENT;
2101 fsp->is_directory = False;
2102 fsp->is_stat = True;
2103 string_set(&fsp->fsp_name,fname);
2105 conn->num_files_open++;
2108 return NT_STATUS_OK;
2111 /****************************************************************************
2112 Receive notification that one of our open files has been renamed by another
2114 ****************************************************************************/
2116 void msg_file_was_renamed(int msg_type, struct process_id src, void *buf, size_t len)
2119 char *frm = (char *)buf;
2122 const char *sharepath;
2123 const char *newname;
2126 if (buf == NULL || len < MSG_FILE_RENAMED_MIN_SIZE + 2) {
2127 DEBUG(0, ("msg_file_was_renamed: Got invalid msg len %d\n", (int)len));
2131 /* Unpack the message. */
2132 dev = DEV_T_VAL(frm,0);
2133 inode = INO_T_VAL(frm,8);
2134 sharepath = &frm[16];
2135 newname = sharepath + strlen(sharepath) + 1;
2136 sp_len = strlen(sharepath);
2138 DEBUG(10,("msg_file_was_renamed: Got rename message for sharepath %s, new name %s, "
2139 "dev %x, inode %.0f\n",
2140 sharepath, newname, (unsigned int)dev, (double)inode ));
2142 for(fsp = file_find_di_first(dev, inode); fsp; fsp = file_find_di_next(fsp)) {
2143 if (memcmp(fsp->conn->connectpath, sharepath, sp_len) == 0) {
2144 DEBUG(10,("msg_file_was_renamed: renaming file fnum %d from %s -> %s\n",
2145 fsp->fnum, fsp->fsp_name, newname ));
2146 string_set(&fsp->fsp_name, newname);
2149 /* Now we have the complete path we can work out if this is
2150 actually within this share and adjust newname accordingly. */
2151 DEBUG(10,("msg_file_was_renamed: share mismatch (sharepath %s "
2152 "not sharepath %s) "
2153 "fnum %d from %s -> %s\n",
2154 fsp->conn->connectpath,