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 3 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, see <http://www.gnu.org/licenses/>.
24 extern struct generic_mapping file_generic_mapping;
25 extern struct current_user current_user;
26 extern userdom_struct current_user_info;
27 extern BOOL global_client_failed_oplock_break;
29 struct deferred_open_record {
30 BOOL delayed_for_oplocks;
34 /****************************************************************************
35 fd support routines - attempt to do a dos_open.
36 ****************************************************************************/
38 static NTSTATUS fd_open(struct connection_struct *conn,
44 NTSTATUS status = NT_STATUS_OK;
48 * Never follow symlinks on a POSIX client. The
49 * client should be doing this.
52 if (fsp->posix_open || !lp_symlinks(SNUM(conn))) {
57 fsp->fh->fd = SMB_VFS_OPEN(conn,fname,fsp,flags,mode);
58 if (fsp->fh->fd == -1) {
59 status = map_nt_error_from_unix(errno);
62 DEBUG(10,("fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s\n",
63 fname, flags, (int)mode, fsp->fh->fd,
64 (fsp->fh->fd == -1) ? strerror(errno) : "" ));
69 /****************************************************************************
70 Close the file associated with a fsp.
71 ****************************************************************************/
73 NTSTATUS fd_close(struct connection_struct *conn, files_struct *fsp)
75 if (fsp->fh->fd == -1) {
76 return NT_STATUS_OK; /* What we used to call a stat open. */
78 if (fsp->fh->ref_count > 1) {
79 return NT_STATUS_OK; /* Shared handle. Only close last reference. */
81 return fd_close_posix(conn, fsp);
84 /****************************************************************************
85 Change the ownership of a file to that of the parent directory.
86 Do this by fd if possible.
87 ****************************************************************************/
89 static void change_file_owner_to_parent(connection_struct *conn,
90 const char *inherit_from_dir,
93 SMB_STRUCT_STAT parent_st;
96 ret = SMB_VFS_STAT(conn, inherit_from_dir, &parent_st);
98 DEBUG(0,("change_file_owner_to_parent: failed to stat parent "
99 "directory %s. Error was %s\n",
100 inherit_from_dir, strerror(errno) ));
105 ret = SMB_VFS_FCHOWN(fsp, fsp->fh->fd, parent_st.st_uid, (gid_t)-1);
108 DEBUG(0,("change_file_owner_to_parent: failed to fchown "
109 "file %s to parent directory uid %u. Error "
110 "was %s\n", fsp->fsp_name,
111 (unsigned int)parent_st.st_uid,
115 DEBUG(10,("change_file_owner_to_parent: changed new file %s to "
116 "parent directory uid %u.\n", fsp->fsp_name,
117 (unsigned int)parent_st.st_uid ));
120 static void change_dir_owner_to_parent(connection_struct *conn,
121 const char *inherit_from_dir,
123 SMB_STRUCT_STAT *psbuf)
126 SMB_STRUCT_STAT sbuf;
127 SMB_STRUCT_STAT parent_st;
130 ret = SMB_VFS_STAT(conn, inherit_from_dir, &parent_st);
132 DEBUG(0,("change_dir_owner_to_parent: failed to stat parent "
133 "directory %s. Error was %s\n",
134 inherit_from_dir, strerror(errno) ));
138 /* We've already done an lstat into psbuf, and we know it's a
139 directory. If we can cd into the directory and the dev/ino
140 are the same then we can safely chown without races as
141 we're locking the directory in place by being in it. This
142 should work on any UNIX (thanks tridge :-). JRA.
145 if (!vfs_GetWd(conn,saved_dir)) {
146 DEBUG(0,("change_dir_owner_to_parent: failed to get "
147 "current working directory\n"));
151 /* Chdir into the new path. */
152 if (vfs_ChDir(conn, fname) == -1) {
153 DEBUG(0,("change_dir_owner_to_parent: failed to change "
154 "current working directory to %s. Error "
155 "was %s\n", fname, strerror(errno) ));
159 if (SMB_VFS_STAT(conn,".",&sbuf) == -1) {
160 DEBUG(0,("change_dir_owner_to_parent: failed to stat "
161 "directory '.' (%s) Error was %s\n",
162 fname, strerror(errno)));
166 /* Ensure we're pointing at the same place. */
167 if (sbuf.st_dev != psbuf->st_dev ||
168 sbuf.st_ino != psbuf->st_ino ||
169 sbuf.st_mode != psbuf->st_mode ) {
170 DEBUG(0,("change_dir_owner_to_parent: "
171 "device/inode/mode on directory %s changed. "
172 "Refusing to chown !\n", fname ));
177 ret = SMB_VFS_CHOWN(conn, ".", parent_st.st_uid, (gid_t)-1);
180 DEBUG(10,("change_dir_owner_to_parent: failed to chown "
181 "directory %s to parent directory uid %u. "
182 "Error was %s\n", fname,
183 (unsigned int)parent_st.st_uid, strerror(errno) ));
187 DEBUG(10,("change_dir_owner_to_parent: changed ownership of new "
188 "directory %s to parent directory uid %u.\n",
189 fname, (unsigned int)parent_st.st_uid ));
193 vfs_ChDir(conn,saved_dir);
196 /****************************************************************************
198 ****************************************************************************/
200 static NTSTATUS open_file(files_struct *fsp,
201 connection_struct *conn,
202 struct smb_request *req,
203 const char *parent_dir,
206 SMB_STRUCT_STAT *psbuf,
209 uint32 access_mask, /* client requested access mask. */
210 uint32 open_access_mask) /* what we're actually using in the open. */
212 NTSTATUS status = NT_STATUS_OK;
213 int accmode = (flags & O_ACCMODE);
214 int local_flags = flags;
215 BOOL file_existed = VALID_STAT(*psbuf);
220 /* Check permissions */
223 * This code was changed after seeing a client open request
224 * containing the open mode of (DENY_WRITE/read-only) with
225 * the 'create if not exist' bit set. The previous code
226 * would fail to open the file read only on a read-only share
227 * as it was checking the flags parameter directly against O_RDONLY,
228 * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
232 if (!CAN_WRITE(conn)) {
233 /* It's a read-only share - fail if we wanted to write. */
234 if(accmode != O_RDONLY) {
235 DEBUG(3,("Permission denied opening %s\n", path));
236 return NT_STATUS_ACCESS_DENIED;
237 } else if(flags & O_CREAT) {
238 /* We don't want to write - but we must make sure that
239 O_CREAT doesn't create the file if we have write
240 access into the directory.
243 local_flags &= ~O_CREAT;
248 * This little piece of insanity is inspired by the
249 * fact that an NT client can open a file for O_RDONLY,
250 * but set the create disposition to FILE_EXISTS_TRUNCATE.
251 * If the client *can* write to the file, then it expects to
252 * truncate the file, even though it is opening for readonly.
253 * Quicken uses this stupid trick in backup file creation...
254 * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
255 * for helping track this one down. It didn't bite us in 2.0.x
256 * as we always opened files read-write in that release. JRA.
259 if ((accmode == O_RDONLY) && ((flags & O_TRUNC) == O_TRUNC)) {
260 DEBUG(10,("open_file: truncate requested on read-only open "
261 "for file %s\n", path));
262 local_flags = (flags & ~O_ACCMODE)|O_RDWR;
265 if ((open_access_mask & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ||
266 (!file_existed && (local_flags & O_CREAT)) ||
267 ((local_flags & O_TRUNC) == O_TRUNC) ) {
270 * We can't actually truncate here as the file may be locked.
271 * open_file_ntcreate will take care of the truncate later. JRA.
274 local_flags &= ~O_TRUNC;
276 #if defined(O_NONBLOCK) && defined(S_ISFIFO)
278 * We would block on opening a FIFO with no one else on the
279 * other end. Do what we used to do and add O_NONBLOCK to the
283 if (file_existed && S_ISFIFO(psbuf->st_mode)) {
284 local_flags |= O_NONBLOCK;
288 /* Don't create files with Microsoft wildcard characters. */
289 if ((local_flags & O_CREAT) && !file_existed &&
291 return NT_STATUS_OBJECT_NAME_INVALID;
294 /* Actually do the open */
295 status = fd_open(conn, path, fsp, local_flags, unx_mode);
296 if (!NT_STATUS_IS_OK(status)) {
297 DEBUG(3,("Error opening file %s (%s) (local_flags=%d) "
299 path,nt_errstr(status),local_flags,flags));
303 if ((local_flags & O_CREAT) && !file_existed) {
305 /* Inherit the ACL if required */
306 if (lp_inherit_perms(SNUM(conn))) {
307 inherit_access_acl(conn, parent_dir, path,
311 /* Change the owner if required. */
312 if (lp_inherit_owner(SNUM(conn))) {
313 change_file_owner_to_parent(conn, parent_dir,
317 notify_fname(conn, NOTIFY_ACTION_ADDED,
318 FILE_NOTIFY_CHANGE_FILE_NAME, path);
322 fsp->fh->fd = -1; /* What we used to call a stat open. */
328 if (fsp->fh->fd == -1) {
329 ret = SMB_VFS_STAT(conn, path, psbuf);
331 ret = SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf);
332 /* If we have an fd, this stat should succeed. */
334 DEBUG(0,("Error doing fstat on open file %s "
335 "(%s)\n", path,strerror(errno) ));
339 /* For a non-io open, this stat failing means file not found. JRA */
341 status = map_nt_error_from_unix(errno);
348 * POSIX allows read-only opens of directories. We don't
349 * want to do this (we use a different code path for this)
350 * so catch a directory open and return an EISDIR. JRA.
353 if(S_ISDIR(psbuf->st_mode)) {
356 return NT_STATUS_FILE_IS_A_DIRECTORY;
359 fsp->mode = psbuf->st_mode;
360 fsp->file_id = file_id_sbuf(psbuf);
361 fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
362 fsp->file_pid = req ? req->smbpid : 0;
363 fsp->can_lock = True;
364 fsp->can_read = (access_mask & (FILE_READ_DATA)) ? True : False;
365 if (!CAN_WRITE(conn)) {
366 fsp->can_write = False;
368 fsp->can_write = (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) ?
371 fsp->print_file = False;
372 fsp->modified = False;
373 fsp->sent_oplock_break = NO_BREAK_SENT;
374 fsp->is_directory = False;
375 fsp->is_stat = False;
377 string_set(&fsp->fsp_name, path);
378 fsp->wcp = NULL; /* Write cache pointer. */
380 DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
381 *current_user_info.smb_name ?
382 current_user_info.smb_name : conn->user,fsp->fsp_name,
383 BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
384 conn->num_files_open + 1));
390 /*******************************************************************
391 Return True if the filename is one of the special executable types.
392 ********************************************************************/
394 static BOOL is_executable(const char *fname)
396 if ((fname = strrchr_m(fname,'.'))) {
397 if (strequal(fname,".com") ||
398 strequal(fname,".dll") ||
399 strequal(fname,".exe") ||
400 strequal(fname,".sym")) {
407 /****************************************************************************
408 Check if we can open a file with a share mode.
409 Returns True if conflict, False if not.
410 ****************************************************************************/
412 static BOOL share_conflict(struct share_mode_entry *entry,
416 DEBUG(10,("share_conflict: entry->access_mask = 0x%x, "
417 "entry->share_access = 0x%x, "
418 "entry->private_options = 0x%x\n",
419 (unsigned int)entry->access_mask,
420 (unsigned int)entry->share_access,
421 (unsigned int)entry->private_options));
423 DEBUG(10,("share_conflict: access_mask = 0x%x, share_access = 0x%x\n",
424 (unsigned int)access_mask, (unsigned int)share_access));
426 if ((entry->access_mask & (FILE_WRITE_DATA|
430 DELETE_ACCESS)) == 0) {
431 DEBUG(10,("share_conflict: No conflict due to "
432 "entry->access_mask = 0x%x\n",
433 (unsigned int)entry->access_mask ));
437 if ((access_mask & (FILE_WRITE_DATA|
441 DELETE_ACCESS)) == 0) {
442 DEBUG(10,("share_conflict: No conflict due to "
443 "access_mask = 0x%x\n",
444 (unsigned int)access_mask ));
448 #if 1 /* JRA TEST - Superdebug. */
449 #define CHECK_MASK(num, am, right, sa, share) \
450 DEBUG(10,("share_conflict: [%d] am (0x%x) & right (0x%x) = 0x%x\n", \
451 (unsigned int)(num), (unsigned int)(am), \
452 (unsigned int)(right), (unsigned int)(am)&(right) )); \
453 DEBUG(10,("share_conflict: [%d] sa (0x%x) & share (0x%x) = 0x%x\n", \
454 (unsigned int)(num), (unsigned int)(sa), \
455 (unsigned int)(share), (unsigned int)(sa)&(share) )); \
456 if (((am) & (right)) && !((sa) & (share))) { \
457 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
458 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
459 (unsigned int)(share) )); \
463 #define CHECK_MASK(num, am, right, sa, share) \
464 if (((am) & (right)) && !((sa) & (share))) { \
465 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
466 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
467 (unsigned int)(share) )); \
472 CHECK_MASK(1, entry->access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
473 share_access, FILE_SHARE_WRITE);
474 CHECK_MASK(2, access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
475 entry->share_access, FILE_SHARE_WRITE);
477 CHECK_MASK(3, entry->access_mask, FILE_READ_DATA | FILE_EXECUTE,
478 share_access, FILE_SHARE_READ);
479 CHECK_MASK(4, access_mask, FILE_READ_DATA | FILE_EXECUTE,
480 entry->share_access, FILE_SHARE_READ);
482 CHECK_MASK(5, entry->access_mask, DELETE_ACCESS,
483 share_access, FILE_SHARE_DELETE);
484 CHECK_MASK(6, access_mask, DELETE_ACCESS,
485 entry->share_access, FILE_SHARE_DELETE);
487 DEBUG(10,("share_conflict: No conflict.\n"));
491 #if defined(DEVELOPER)
492 static void validate_my_share_entries(int num,
493 struct share_mode_entry *share_entry)
497 if (!procid_is_me(&share_entry->pid)) {
501 if (is_deferred_open_entry(share_entry) &&
502 !open_was_deferred(share_entry->op_mid)) {
504 pstr_sprintf(str, "Got a deferred entry without a request: "
505 "PANIC: %s\n", share_mode_str(num, share_entry));
509 if (!is_valid_share_mode_entry(share_entry)) {
513 fsp = file_find_dif(share_entry->id,
514 share_entry->share_file_id);
516 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
517 share_mode_str(num, share_entry) ));
518 smb_panic("validate_my_share_entries: Cannot match a "
519 "share entry with an open file\n");
522 if (is_deferred_open_entry(share_entry) ||
523 is_unused_share_mode_entry(share_entry)) {
527 if ((share_entry->op_type == NO_OPLOCK) &&
528 (fsp->oplock_type == FAKE_LEVEL_II_OPLOCK)) {
529 /* Someone has already written to it, but I haven't yet
534 if (((uint16)fsp->oplock_type) != share_entry->op_type) {
543 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
544 share_mode_str(num, share_entry) ));
545 slprintf(str, sizeof(str)-1, "validate_my_share_entries: "
546 "file %s, oplock_type = 0x%x, op_type = 0x%x\n",
547 fsp->fsp_name, (unsigned int)fsp->oplock_type,
548 (unsigned int)share_entry->op_type );
554 static BOOL is_stat_open(uint32 access_mask)
556 return (access_mask &&
557 ((access_mask & ~(SYNCHRONIZE_ACCESS| FILE_READ_ATTRIBUTES|
558 FILE_WRITE_ATTRIBUTES))==0) &&
559 ((access_mask & (SYNCHRONIZE_ACCESS|FILE_READ_ATTRIBUTES|
560 FILE_WRITE_ATTRIBUTES)) != 0));
563 /****************************************************************************
564 Deal with share modes
565 Invarient: Share mode must be locked on entry and exit.
566 Returns -1 on error, or number of share modes on success (may be zero).
567 ****************************************************************************/
569 static NTSTATUS open_mode_check(connection_struct *conn,
571 struct share_mode_lock *lck,
574 uint32 create_options,
579 if(lck->num_share_modes == 0) {
583 *file_existed = True;
585 if (is_stat_open(access_mask)) {
586 /* Stat open that doesn't trigger oplock breaks or share mode
587 * checks... ! JRA. */
591 /* A delete on close prohibits everything */
593 if (lck->delete_on_close) {
594 return NT_STATUS_DELETE_PENDING;
598 * Check if the share modes will give us access.
601 #if defined(DEVELOPER)
602 for(i = 0; i < lck->num_share_modes; i++) {
603 validate_my_share_entries(i, &lck->share_modes[i]);
607 if (!lp_share_modes(SNUM(conn))) {
611 /* Now we check the share modes, after any oplock breaks. */
612 for(i = 0; i < lck->num_share_modes; i++) {
614 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
618 /* someone else has a share lock on it, check to see if we can
620 if (share_conflict(&lck->share_modes[i],
621 access_mask, share_access)) {
622 return NT_STATUS_SHARING_VIOLATION;
629 static BOOL is_delete_request(files_struct *fsp) {
630 return ((fsp->access_mask == DELETE_ACCESS) &&
631 (fsp->oplock_type == NO_OPLOCK));
635 * 1) No files open at all or internal open: Grant whatever the client wants.
637 * 2) Exclusive (or batch) oplock around: If the requested access is a delete
638 * request, break if the oplock around is a batch oplock. If it's another
639 * requested access type, break.
641 * 3) Only level2 around: Grant level2 and do nothing else.
644 static BOOL delay_for_oplocks(struct share_mode_lock *lck,
651 struct share_mode_entry *exclusive = NULL;
652 BOOL valid_entry = False;
653 BOOL delay_it = False;
654 BOOL have_level2 = False;
656 char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
658 if (oplock_request & INTERNAL_OPEN_ONLY) {
659 fsp->oplock_type = NO_OPLOCK;
662 if ((oplock_request & INTERNAL_OPEN_ONLY) || is_stat_open(fsp->access_mask)) {
666 for (i=0; i<lck->num_share_modes; i++) {
668 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
672 /* At least one entry is not an invalid or deferred entry. */
675 if (pass_number == 1) {
676 if (BATCH_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
677 SMB_ASSERT(exclusive == NULL);
678 exclusive = &lck->share_modes[i];
681 if (EXCLUSIVE_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
682 SMB_ASSERT(exclusive == NULL);
683 exclusive = &lck->share_modes[i];
687 if (lck->share_modes[i].op_type == LEVEL_II_OPLOCK) {
688 SMB_ASSERT(exclusive == NULL);
694 /* All entries are placeholders or deferred.
695 * Directly grant whatever the client wants. */
696 if (fsp->oplock_type == NO_OPLOCK) {
697 /* Store a level2 oplock, but don't tell the client */
698 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
703 if (exclusive != NULL) { /* Found an exclusive oplock */
704 SMB_ASSERT(!have_level2);
705 delay_it = is_delete_request(fsp) ?
706 BATCH_OPLOCK_TYPE(exclusive->op_type) : True;
709 if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
710 /* We can at most grant level2 as there are other
711 * level2 or NO_OPLOCK entries. */
712 fsp->oplock_type = LEVEL_II_OPLOCK;
715 if ((fsp->oplock_type == NO_OPLOCK) && have_level2) {
716 /* Store a level2 oplock, but don't tell the client */
717 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
725 * Send a break message to the oplock holder and delay the open for
729 DEBUG(10, ("Sending break request to PID %s\n",
730 procid_str_static(&exclusive->pid)));
731 exclusive->op_mid = mid;
733 /* Create the message. */
734 share_mode_entry_to_message(msg, exclusive);
736 /* Add in the FORCE_OPLOCK_BREAK_TO_NONE bit in the message if set. We
737 don't want this set in the share mode struct pointed to by lck. */
739 if (oplock_request & FORCE_OPLOCK_BREAK_TO_NONE) {
740 SSVAL(msg,6,exclusive->op_type | FORCE_OPLOCK_BREAK_TO_NONE);
743 status = messaging_send_buf(smbd_messaging_context(), exclusive->pid,
744 MSG_SMB_BREAK_REQUEST,
746 MSG_SMB_SHARE_MODE_ENTRY_SIZE);
747 if (!NT_STATUS_IS_OK(status)) {
748 DEBUG(3, ("Could not send oplock break message: %s\n",
755 static BOOL request_timed_out(struct timeval request_time,
756 struct timeval timeout)
758 struct timeval now, end_time;
760 end_time = timeval_sum(&request_time, &timeout);
761 return (timeval_compare(&end_time, &now) < 0);
764 /****************************************************************************
765 Handle the 1 second delay in returning a SHARING_VIOLATION error.
766 ****************************************************************************/
768 static void defer_open(struct share_mode_lock *lck,
769 struct timeval request_time,
770 struct timeval timeout,
772 struct deferred_open_record *state)
778 for (i=0; i<lck->num_share_modes; i++) {
779 struct share_mode_entry *e = &lck->share_modes[i];
781 if (!is_deferred_open_entry(e)) {
785 if (procid_is_me(&e->pid) && (e->op_mid == mid)) {
786 DEBUG(0, ("Trying to defer an already deferred "
787 "request: mid=%d, exiting\n", mid));
788 exit_server("attempt to defer a deferred request");
792 /* End paranoia check */
794 DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred "
795 "open entry for mid %u\n",
796 (unsigned int)request_time.tv_sec,
797 (unsigned int)request_time.tv_usec,
800 if (!push_deferred_smb_message(mid, request_time, timeout,
801 (char *)state, sizeof(*state))) {
802 exit_server("push_deferred_smb_message failed");
804 add_deferred_open(lck, mid, request_time, state->id);
807 * Push the MID of this packet on the signing queue.
808 * We only do this once, the first time we push the packet
809 * onto the deferred open queue, as this has a side effect
810 * of incrementing the response sequence number.
813 srv_defer_sign_response(mid);
817 /****************************************************************************
818 On overwrite open ensure that the attributes match.
819 ****************************************************************************/
821 static BOOL open_match_attributes(connection_struct *conn,
825 mode_t existing_unx_mode,
827 mode_t *returned_unx_mode)
829 uint32 noarch_old_dos_attr, noarch_new_dos_attr;
831 noarch_old_dos_attr = (old_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
832 noarch_new_dos_attr = (new_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
834 if((noarch_old_dos_attr == 0 && noarch_new_dos_attr != 0) ||
835 (noarch_old_dos_attr != 0 && ((noarch_old_dos_attr & noarch_new_dos_attr) == noarch_old_dos_attr))) {
836 *returned_unx_mode = new_unx_mode;
838 *returned_unx_mode = (mode_t)0;
841 DEBUG(10,("open_match_attributes: file %s old_dos_attr = 0x%x, "
842 "existing_unx_mode = 0%o, new_dos_attr = 0x%x "
843 "returned_unx_mode = 0%o\n",
845 (unsigned int)old_dos_attr,
846 (unsigned int)existing_unx_mode,
847 (unsigned int)new_dos_attr,
848 (unsigned int)*returned_unx_mode ));
850 /* If we're mapping SYSTEM and HIDDEN ensure they match. */
851 if (lp_map_system(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
852 if ((old_dos_attr & FILE_ATTRIBUTE_SYSTEM) &&
853 !(new_dos_attr & FILE_ATTRIBUTE_SYSTEM)) {
857 if (lp_map_hidden(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
858 if ((old_dos_attr & FILE_ATTRIBUTE_HIDDEN) &&
859 !(new_dos_attr & FILE_ATTRIBUTE_HIDDEN)) {
866 /****************************************************************************
867 Special FCB or DOS processing in the case of a sharing violation.
868 Try and find a duplicated file handle.
869 ****************************************************************************/
871 static files_struct *fcb_or_dos_open(connection_struct *conn,
878 uint32 create_options)
881 files_struct *dup_fsp;
883 DEBUG(5,("fcb_or_dos_open: attempting old open semantics for "
884 "file %s.\n", fname ));
886 for(fsp = file_find_di_first(id); fsp;
887 fsp = file_find_di_next(fsp)) {
889 DEBUG(10,("fcb_or_dos_open: checking file %s, fd = %d, "
890 "vuid = %u, file_pid = %u, private_options = 0x%x "
891 "access_mask = 0x%x\n", fsp->fsp_name,
892 fsp->fh->fd, (unsigned int)fsp->vuid,
893 (unsigned int)fsp->file_pid,
894 (unsigned int)fsp->fh->private_options,
895 (unsigned int)fsp->access_mask ));
897 if (fsp->fh->fd != -1 &&
899 fsp->file_pid == file_pid &&
900 (fsp->fh->private_options & (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS |
901 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) &&
902 (fsp->access_mask & FILE_WRITE_DATA) &&
903 strequal(fsp->fsp_name, fname)) {
904 DEBUG(10,("fcb_or_dos_open: file match\n"));
913 /* quite an insane set of semantics ... */
914 if (is_executable(fname) &&
915 (fsp->fh->private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS)) {
916 DEBUG(10,("fcb_or_dos_open: file fail due to is_executable.\n"));
920 /* We need to duplicate this fsp. */
921 if (!NT_STATUS_IS_OK(dup_file_fsp(fsp, access_mask, share_access,
922 create_options, &dup_fsp))) {
929 /****************************************************************************
930 Open a file with a share mode - old openX method - map into NTCreate.
931 ****************************************************************************/
933 BOOL map_open_params_to_ntcreate(const char *fname, int deny_mode, int open_func,
934 uint32 *paccess_mask,
936 uint32 *pcreate_disposition,
937 uint32 *pcreate_options)
941 uint32 create_disposition;
942 uint32 create_options = 0;
944 DEBUG(10,("map_open_params_to_ntcreate: fname = %s, deny_mode = 0x%x, "
945 "open_func = 0x%x\n",
946 fname, (unsigned int)deny_mode, (unsigned int)open_func ));
948 /* Create the NT compatible access_mask. */
949 switch (GET_OPENX_MODE(deny_mode)) {
950 case DOS_OPEN_EXEC: /* Implies read-only - used to be FILE_READ_DATA */
951 case DOS_OPEN_RDONLY:
952 access_mask = FILE_GENERIC_READ;
954 case DOS_OPEN_WRONLY:
955 access_mask = FILE_GENERIC_WRITE;
959 access_mask = FILE_GENERIC_READ|FILE_GENERIC_WRITE;
962 DEBUG(10,("map_open_params_to_ntcreate: bad open mode = 0x%x\n",
963 (unsigned int)GET_OPENX_MODE(deny_mode)));
967 /* Create the NT compatible create_disposition. */
969 case OPENX_FILE_EXISTS_FAIL|OPENX_FILE_CREATE_IF_NOT_EXIST:
970 create_disposition = FILE_CREATE;
973 case OPENX_FILE_EXISTS_OPEN:
974 create_disposition = FILE_OPEN;
977 case OPENX_FILE_EXISTS_OPEN|OPENX_FILE_CREATE_IF_NOT_EXIST:
978 create_disposition = FILE_OPEN_IF;
981 case OPENX_FILE_EXISTS_TRUNCATE:
982 create_disposition = FILE_OVERWRITE;
985 case OPENX_FILE_EXISTS_TRUNCATE|OPENX_FILE_CREATE_IF_NOT_EXIST:
986 create_disposition = FILE_OVERWRITE_IF;
990 /* From samba4 - to be confirmed. */
991 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_EXEC) {
992 create_disposition = FILE_CREATE;
995 DEBUG(10,("map_open_params_to_ntcreate: bad "
996 "open_func 0x%x\n", (unsigned int)open_func));
1000 /* Create the NT compatible share modes. */
1001 switch (GET_DENY_MODE(deny_mode)) {
1003 share_mode = FILE_SHARE_NONE;
1007 share_mode = FILE_SHARE_READ;
1011 share_mode = FILE_SHARE_WRITE;
1015 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
1019 create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
1020 if (is_executable(fname)) {
1021 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
1023 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_RDONLY) {
1024 share_mode = FILE_SHARE_READ;
1026 share_mode = FILE_SHARE_NONE;
1032 create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
1033 share_mode = FILE_SHARE_NONE;
1037 DEBUG(10,("map_open_params_to_ntcreate: bad deny_mode 0x%x\n",
1038 (unsigned int)GET_DENY_MODE(deny_mode) ));
1042 DEBUG(10,("map_open_params_to_ntcreate: file %s, access_mask = 0x%x, "
1043 "share_mode = 0x%x, create_disposition = 0x%x, "
1044 "create_options = 0x%x\n",
1046 (unsigned int)access_mask,
1047 (unsigned int)share_mode,
1048 (unsigned int)create_disposition,
1049 (unsigned int)create_options ));
1052 *paccess_mask = access_mask;
1055 *pshare_mode = share_mode;
1057 if (pcreate_disposition) {
1058 *pcreate_disposition = create_disposition;
1060 if (pcreate_options) {
1061 *pcreate_options = create_options;
1068 static void schedule_defer_open(struct share_mode_lock *lck,
1069 struct timeval request_time,
1072 struct deferred_open_record state;
1074 /* This is a relative time, added to the absolute
1075 request_time value to get the absolute timeout time.
1076 Note that if this is the second or greater time we enter
1077 this codepath for this particular request mid then
1078 request_time is left as the absolute time of the *first*
1079 time this request mid was processed. This is what allows
1080 the request to eventually time out. */
1082 struct timeval timeout;
1084 /* Normally the smbd we asked should respond within
1085 * OPLOCK_BREAK_TIMEOUT seconds regardless of whether
1086 * the client did, give twice the timeout as a safety
1087 * measure here in case the other smbd is stuck
1088 * somewhere else. */
1090 timeout = timeval_set(OPLOCK_BREAK_TIMEOUT*2, 0);
1092 /* Nothing actually uses state.delayed_for_oplocks
1093 but it's handy to differentiate in debug messages
1094 between a 30 second delay due to oplock break, and
1095 a 1 second delay for share mode conflicts. */
1097 state.delayed_for_oplocks = True;
1100 if (!request_timed_out(request_time, timeout)) {
1101 defer_open(lck, request_time, timeout, mid, &state);
1105 /****************************************************************************
1106 Open a file with a share mode.
1107 ****************************************************************************/
1109 NTSTATUS open_file_ntcreate(connection_struct *conn,
1110 struct smb_request *req,
1112 SMB_STRUCT_STAT *psbuf,
1113 uint32 access_mask, /* access bits (FILE_READ_DATA etc.) */
1114 uint32 share_access, /* share constants (FILE_SHARE_READ etc) */
1115 uint32 create_disposition, /* FILE_OPEN_IF etc. */
1116 uint32 create_options, /* options such as delete on close. */
1117 uint32 new_dos_attributes, /* attributes used for new file. */
1118 int oplock_request, /* internal Samba oplock codes. */
1119 /* Information (FILE_EXISTS etc.) */
1121 files_struct **result)
1125 BOOL file_existed = VALID_STAT(*psbuf);
1126 BOOL def_acl = False;
1127 BOOL posix_open = False;
1128 BOOL new_file_created = False;
1130 NTSTATUS fsp_open = NT_STATUS_ACCESS_DENIED;
1131 files_struct *fsp = NULL;
1132 mode_t new_unx_mode = (mode_t)0;
1133 mode_t unx_mode = (mode_t)0;
1135 uint32 existing_dos_attributes = 0;
1136 struct pending_message_list *pml = NULL;
1137 struct timeval request_time = timeval_zero();
1138 struct share_mode_lock *lck = NULL;
1139 uint32 open_access_mask = access_mask;
1143 const char *newname;
1147 if (conn->printer) {
1149 * Printers are handled completely differently.
1150 * Most of the passed parameters are ignored.
1154 *pinfo = FILE_WAS_CREATED;
1157 DEBUG(10, ("open_file_ntcreate: printer open fname=%s\n", fname));
1159 return print_fsp_open(conn, fname, result);
1162 if (!parent_dirname_talloc(tmp_talloc_ctx(), fname, &parent_dir,
1164 return NT_STATUS_NO_MEMORY;
1167 if (new_dos_attributes & FILE_FLAG_POSIX_SEMANTICS) {
1169 unx_mode = (mode_t)(new_dos_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
1170 new_dos_attributes = 0;
1172 /* We add aARCH to this as this mode is only used if the file is
1174 unx_mode = unix_mode(conn, new_dos_attributes | aARCH, fname,
1178 DEBUG(10, ("open_file_ntcreate: fname=%s, dos_attrs=0x%x "
1179 "access_mask=0x%x share_access=0x%x "
1180 "create_disposition = 0x%x create_options=0x%x "
1181 "unix mode=0%o oplock_request=%d\n",
1182 fname, new_dos_attributes, access_mask, share_access,
1183 create_disposition, create_options, unx_mode,
1186 if ((req == NULL) && ((oplock_request & INTERNAL_OPEN_ONLY) == 0)) {
1187 DEBUG(0, ("No smb request but not an internal only open!\n"));
1188 return NT_STATUS_INTERNAL_ERROR;
1192 * Only non-internal opens can be deferred at all
1196 && ((pml = get_open_deferred_message(req->mid)) != NULL)) {
1197 struct deferred_open_record *state =
1198 (struct deferred_open_record *)pml->private_data.data;
1200 /* Remember the absolute time of the original
1201 request with this mid. We'll use it later to
1202 see if this has timed out. */
1204 request_time = pml->request_time;
1206 /* Remove the deferred open entry under lock. */
1207 lck = get_share_mode_lock(NULL, state->id, NULL, NULL);
1209 DEBUG(0, ("could not get share mode lock\n"));
1211 del_deferred_open_entry(lck, req->mid);
1215 /* Ensure we don't reprocess this message. */
1216 remove_deferred_open_smb_message(req->mid);
1219 status = check_name(conn, fname);
1220 if (!NT_STATUS_IS_OK(status)) {
1225 new_dos_attributes &= SAMBA_ATTRIBUTES_MASK;
1227 existing_dos_attributes = dos_mode(conn, fname, psbuf);
1231 /* ignore any oplock requests if oplocks are disabled */
1232 if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break ||
1233 IS_VETO_OPLOCK_PATH(conn, fname)) {
1234 /* Mask off everything except the private Samba bits. */
1235 oplock_request &= SAMBA_PRIVATE_OPLOCK_MASK;
1238 /* this is for OS/2 long file names - say we don't support them */
1239 if (!lp_posix_pathnames() && strstr(fname,".+,;=[].")) {
1240 /* OS/2 Workplace shell fix may be main code stream in a later
1242 DEBUG(5,("open_file_ntcreate: OS/2 long filenames are not "
1244 if (use_nt_status()) {
1245 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1247 return NT_STATUS_DOS(ERRDOS, ERRcannotopen);
1250 switch( create_disposition ) {
1252 * Currently we're using FILE_SUPERSEDE as the same as
1253 * FILE_OVERWRITE_IF but they really are
1254 * different. FILE_SUPERSEDE deletes an existing file
1255 * (requiring delete access) then recreates it.
1257 case FILE_SUPERSEDE:
1258 /* If file exists replace/overwrite. If file doesn't
1260 flags2 |= (O_CREAT | O_TRUNC);
1263 case FILE_OVERWRITE_IF:
1264 /* If file exists replace/overwrite. If file doesn't
1266 flags2 |= (O_CREAT | O_TRUNC);
1270 /* If file exists open. If file doesn't exist error. */
1271 if (!file_existed) {
1272 DEBUG(5,("open_file_ntcreate: FILE_OPEN "
1273 "requested for file %s and file "
1274 "doesn't exist.\n", fname ));
1276 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1280 case FILE_OVERWRITE:
1281 /* If file exists overwrite. If file doesn't exist
1283 if (!file_existed) {
1284 DEBUG(5,("open_file_ntcreate: FILE_OVERWRITE "
1285 "requested for file %s and file "
1286 "doesn't exist.\n", fname ));
1288 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1294 /* If file exists error. If file doesn't exist
1297 DEBUG(5,("open_file_ntcreate: FILE_CREATE "
1298 "requested for file %s and file "
1299 "already exists.\n", fname ));
1300 if (S_ISDIR(psbuf->st_mode)) {
1305 return map_nt_error_from_unix(errno);
1307 flags2 |= (O_CREAT|O_EXCL);
1311 /* If file exists open. If file doesn't exist
1317 return NT_STATUS_INVALID_PARAMETER;
1320 /* We only care about matching attributes on file exists and
1323 if (!posix_open && file_existed && ((create_disposition == FILE_OVERWRITE) ||
1324 (create_disposition == FILE_OVERWRITE_IF))) {
1325 if (!open_match_attributes(conn, fname,
1326 existing_dos_attributes,
1327 new_dos_attributes, psbuf->st_mode,
1328 unx_mode, &new_unx_mode)) {
1329 DEBUG(5,("open_file_ntcreate: attributes missmatch "
1330 "for file %s (%x %x) (0%o, 0%o)\n",
1331 fname, existing_dos_attributes,
1333 (unsigned int)psbuf->st_mode,
1334 (unsigned int)unx_mode ));
1336 return NT_STATUS_ACCESS_DENIED;
1340 /* This is a nasty hack - must fix... JRA. */
1341 if (access_mask == MAXIMUM_ALLOWED_ACCESS) {
1342 open_access_mask = access_mask = FILE_GENERIC_ALL;
1346 * Convert GENERIC bits to specific bits.
1349 se_map_generic(&access_mask, &file_generic_mapping);
1350 open_access_mask = access_mask;
1352 if (flags2 & O_TRUNC) {
1353 open_access_mask |= FILE_WRITE_DATA; /* This will cause oplock breaks. */
1356 DEBUG(10, ("open_file_ntcreate: fname=%s, after mapping "
1357 "access_mask=0x%x\n", fname, access_mask ));
1360 * Note that we ignore the append flag as append does not
1361 * mean the same thing under DOS and Unix.
1364 if (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) {
1365 /* DENY_DOS opens are always underlying read-write on the
1366 file handle, no matter what the requested access mask
1368 if ((create_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) ||
1369 access_mask & (FILE_READ_ATTRIBUTES|FILE_READ_DATA|FILE_READ_EA|FILE_EXECUTE)) {
1379 * Currently we only look at FILE_WRITE_THROUGH for create options.
1383 if ((create_options & FILE_WRITE_THROUGH) && lp_strict_sync(SNUM(conn))) {
1388 if (posix_open & (access_mask & FILE_APPEND_DATA)) {
1392 if (!posix_open && !CAN_WRITE(conn)) {
1394 * We should really return a permission denied error if either
1395 * O_CREAT or O_TRUNC are set, but for compatibility with
1396 * older versions of Samba we just AND them out.
1398 flags2 &= ~(O_CREAT|O_TRUNC);
1402 * Ensure we can't write on a read-only share or file.
1405 if (flags != O_RDONLY && file_existed &&
1406 (!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_attributes))) {
1407 DEBUG(5,("open_file_ntcreate: write access requested for "
1408 "file %s on read only %s\n",
1409 fname, !CAN_WRITE(conn) ? "share" : "file" ));
1411 return NT_STATUS_ACCESS_DENIED;
1414 status = file_new(conn, &fsp);
1415 if(!NT_STATUS_IS_OK(status)) {
1419 fsp->file_id = file_id_sbuf(psbuf);
1420 fsp->share_access = share_access;
1421 fsp->fh->private_options = create_options;
1422 fsp->access_mask = open_access_mask; /* We change this to the
1423 * requested access_mask after
1424 * the open is done. */
1425 fsp->posix_open = posix_open;
1427 /* Ensure no SAMBA_PRIVATE bits can be set. */
1428 fsp->oplock_type = (oplock_request & ~SAMBA_PRIVATE_OPLOCK_MASK);
1430 if (timeval_is_zero(&request_time)) {
1431 request_time = fsp->open_time;
1435 id = file_id_sbuf(psbuf);
1437 lck = get_share_mode_lock(NULL, id,
1443 DEBUG(0, ("Could not get share mode lock\n"));
1444 return NT_STATUS_SHARING_VIOLATION;
1447 /* First pass - send break only on batch oplocks. */
1449 && delay_for_oplocks(lck, fsp, req->mid, 1,
1451 schedule_defer_open(lck, request_time, req->mid);
1454 return NT_STATUS_SHARING_VIOLATION;
1457 /* Use the client requested access mask here, not the one we
1459 status = open_mode_check(conn, fname, lck,
1460 access_mask, share_access,
1461 create_options, &file_existed);
1463 if (NT_STATUS_IS_OK(status)) {
1464 /* We might be going to allow this open. Check oplock
1466 /* Second pass - send break for both batch or
1467 * exclusive oplocks. */
1469 && delay_for_oplocks(lck, fsp, req->mid, 2,
1471 schedule_defer_open(lck, request_time,
1475 return NT_STATUS_SHARING_VIOLATION;
1479 if (NT_STATUS_EQUAL(status, NT_STATUS_DELETE_PENDING)) {
1480 /* DELETE_PENDING is not deferred for a second */
1486 if (!NT_STATUS_IS_OK(status)) {
1487 uint32 can_access_mask;
1488 BOOL can_access = True;
1490 SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION));
1492 /* Check if this can be done with the deny_dos and fcb
1494 if (create_options &
1495 (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS|
1496 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
1497 files_struct *fsp_dup;
1500 DEBUG(0, ("DOS open without an SMB "
1504 return NT_STATUS_INTERNAL_ERROR;
1507 /* Use the client requested access mask here,
1508 * not the one we open with. */
1509 fsp_dup = fcb_or_dos_open(conn, fname, id,
1520 *pinfo = FILE_WAS_OPENED;
1522 conn->num_files_open++;
1524 return NT_STATUS_OK;
1529 * This next line is a subtlety we need for
1530 * MS-Access. If a file open will fail due to share
1531 * permissions and also for security (access) reasons,
1532 * we need to return the access failed error, not the
1533 * share error. We can't open the file due to kernel
1534 * oplock deadlock (it's possible we failed above on
1535 * the open_mode_check()) so use a userspace check.
1538 if (flags & O_RDWR) {
1539 can_access_mask = FILE_READ_DATA|FILE_WRITE_DATA;
1540 } else if (flags & O_WRONLY) {
1541 can_access_mask = FILE_WRITE_DATA;
1543 can_access_mask = FILE_READ_DATA;
1546 if (((can_access_mask & FILE_WRITE_DATA) && !CAN_WRITE(conn)) ||
1547 !can_access_file(conn,fname,psbuf,can_access_mask)) {
1552 * If we're returning a share violation, ensure we
1553 * cope with the braindead 1 second delay.
1556 if (!(oplock_request & INTERNAL_OPEN_ONLY) &&
1557 lp_defer_sharing_violations()) {
1558 struct timeval timeout;
1559 struct deferred_open_record state;
1562 /* this is a hack to speed up torture tests
1564 timeout_usecs = lp_parm_int(SNUM(conn),
1565 "smbd","sharedelay",
1566 SHARING_VIOLATION_USEC_WAIT);
1568 /* This is a relative time, added to the absolute
1569 request_time value to get the absolute timeout time.
1570 Note that if this is the second or greater time we enter
1571 this codepath for this particular request mid then
1572 request_time is left as the absolute time of the *first*
1573 time this request mid was processed. This is what allows
1574 the request to eventually time out. */
1576 timeout = timeval_set(0, timeout_usecs);
1578 /* Nothing actually uses state.delayed_for_oplocks
1579 but it's handy to differentiate in debug messages
1580 between a 30 second delay due to oplock break, and
1581 a 1 second delay for share mode conflicts. */
1583 state.delayed_for_oplocks = False;
1587 && !request_timed_out(request_time,
1589 defer_open(lck, request_time, timeout,
1597 * We have detected a sharing violation here
1598 * so return the correct error code
1600 status = NT_STATUS_SHARING_VIOLATION;
1602 status = NT_STATUS_ACCESS_DENIED;
1609 * We exit this block with the share entry *locked*.....
1613 SMB_ASSERT(!file_existed || (lck != NULL));
1616 * Ensure we pay attention to default ACLs on directories if required.
1619 if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
1620 (def_acl = directory_has_default_acl(conn, parent_dir))) {
1624 DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o, "
1625 "access_mask = 0x%x, open_access_mask = 0x%x\n",
1626 (unsigned int)flags, (unsigned int)flags2,
1627 (unsigned int)unx_mode, (unsigned int)access_mask,
1628 (unsigned int)open_access_mask));
1631 * open_file strips any O_TRUNC flags itself.
1634 fsp_open = open_file(fsp, conn, req, parent_dir, newname, fname, psbuf,
1635 flags|flags2, unx_mode, access_mask,
1638 if (!NT_STATUS_IS_OK(fsp_open)) {
1646 if (!file_existed) {
1649 * Deal with the race condition where two smbd's detect the
1650 * file doesn't exist and do the create at the same time. One
1651 * of them will win and set a share mode, the other (ie. this
1652 * one) should check if the requested share mode for this
1653 * create is allowed.
1657 * Now the file exists and fsp is successfully opened,
1658 * fsp->dev and fsp->inode are valid and should replace the
1659 * dev=0,inode=0 from a non existent file. Spotted by
1660 * Nadav Danieli <nadavd@exanet.com>. JRA.
1665 lck = get_share_mode_lock(NULL, id,
1670 DEBUG(0, ("open_file_ntcreate: Could not get share "
1671 "mode lock for %s\n", fname));
1672 fd_close(conn, fsp);
1674 return NT_STATUS_SHARING_VIOLATION;
1677 /* First pass - send break only on batch oplocks. */
1679 && delay_for_oplocks(lck, fsp, req->mid, 1,
1681 schedule_defer_open(lck, request_time, req->mid);
1683 fd_close(conn, fsp);
1685 return NT_STATUS_SHARING_VIOLATION;
1688 status = open_mode_check(conn, fname, lck,
1689 access_mask, share_access,
1690 create_options, &file_existed);
1692 if (NT_STATUS_IS_OK(status)) {
1693 /* We might be going to allow this open. Check oplock
1695 /* Second pass - send break for both batch or
1696 * exclusive oplocks. */
1698 && delay_for_oplocks(lck, fsp, req->mid, 2,
1700 schedule_defer_open(lck, request_time,
1703 fd_close(conn, fsp);
1705 return NT_STATUS_SHARING_VIOLATION;
1709 if (!NT_STATUS_IS_OK(status)) {
1710 struct deferred_open_record state;
1712 fd_close(conn, fsp);
1715 state.delayed_for_oplocks = False;
1718 /* Do it all over again immediately. In the second
1719 * round we will find that the file existed and handle
1720 * the DELETE_PENDING and FCB cases correctly. No need
1721 * to duplicate the code here. Essentially this is a
1722 * "goto top of this function", but don't tell
1726 defer_open(lck, request_time, timeval_zero(),
1734 * We exit this block with the share entry *locked*.....
1739 SMB_ASSERT(lck != NULL);
1741 /* note that we ignore failure for the following. It is
1742 basically a hack for NFS, and NFS will never set one of
1743 these only read them. Nobody but Samba can ever set a deny
1744 mode and we have already checked our more authoritative
1745 locking database for permission to set this deny mode. If
1746 the kernel refuses the operations then the kernel is wrong.
1747 note that GPFS supports it as well - jmcd */
1749 ret_flock = SMB_VFS_KERNEL_FLOCK(fsp, fsp->fh->fd, share_access);
1750 if(ret_flock == -1 ){
1753 fd_close(conn, fsp);
1756 return NT_STATUS_SHARING_VIOLATION;
1760 * At this point onwards, we can guarentee that the share entry
1761 * is locked, whether we created the file or not, and that the
1762 * deny mode is compatible with all current opens.
1766 * If requested, truncate the file.
1769 if (flags2&O_TRUNC) {
1771 * We are modifing the file after open - update the stat
1774 if ((SMB_VFS_FTRUNCATE(fsp,fsp->fh->fd,0) == -1) ||
1775 (SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf)==-1)) {
1776 status = map_nt_error_from_unix(errno);
1784 /* Record the options we were opened with. */
1785 fsp->share_access = share_access;
1786 fsp->fh->private_options = create_options;
1787 fsp->access_mask = access_mask;
1790 /* stat opens on existing files don't get oplocks. */
1791 if (is_stat_open(open_access_mask)) {
1792 fsp->oplock_type = NO_OPLOCK;
1795 if (!(flags2 & O_TRUNC)) {
1796 info = FILE_WAS_OPENED;
1798 info = FILE_WAS_OVERWRITTEN;
1801 info = FILE_WAS_CREATED;
1809 * Setup the oplock info in both the shared memory and
1813 if ((fsp->oplock_type != NO_OPLOCK) &&
1814 (fsp->oplock_type != FAKE_LEVEL_II_OPLOCK)) {
1815 if (!set_file_oplock(fsp, fsp->oplock_type)) {
1816 /* Could not get the kernel oplock */
1817 fsp->oplock_type = NO_OPLOCK;
1821 if (info == FILE_WAS_OVERWRITTEN || info == FILE_WAS_CREATED || info == FILE_WAS_SUPERSEDED) {
1822 new_file_created = True;
1825 set_share_mode(lck, fsp, current_user.ut.uid, 0, fsp->oplock_type, new_file_created);
1827 /* Handle strange delete on close create semantics. */
1828 if ((create_options & FILE_DELETE_ON_CLOSE) && can_set_initial_delete_on_close(lck)) {
1829 status = can_set_delete_on_close(fsp, True, new_dos_attributes);
1831 if (!NT_STATUS_IS_OK(status)) {
1832 /* Remember to delete the mode we just added. */
1833 del_share_mode(lck, fsp);
1839 /* Note that here we set the *inital* delete on close flag,
1840 not the regular one. The magic gets handled in close. */
1841 fsp->initial_delete_on_close = True;
1844 if (new_file_created) {
1845 /* Files should be initially set as archive */
1846 if (lp_map_archive(SNUM(conn)) ||
1847 lp_store_dos_attributes(SNUM(conn))) {
1849 file_set_dosmode(conn, fname,
1850 new_dos_attributes | aARCH, NULL,
1857 * Take care of inherited ACLs on created files - if default ACL not
1861 if (!posix_open && !file_existed && !def_acl) {
1863 int saved_errno = errno; /* We might get ENOSYS in the next
1866 if (SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd, unx_mode) == -1 &&
1868 errno = saved_errno; /* Ignore ENOSYS */
1871 } else if (new_unx_mode) {
1875 /* Attributes need changing. File already existed. */
1878 int saved_errno = errno; /* We might get ENOSYS in the
1880 ret = SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd,
1883 if (ret == -1 && errno == ENOSYS) {
1884 errno = saved_errno; /* Ignore ENOSYS */
1886 DEBUG(5, ("open_file_ntcreate: reset "
1887 "attributes of file %s to 0%o\n",
1888 fname, (unsigned int)new_unx_mode));
1889 ret = 0; /* Don't do the fchmod below. */
1894 (SMB_VFS_FCHMOD(fsp, fsp->fh->fd, new_unx_mode) == -1))
1895 DEBUG(5, ("open_file_ntcreate: failed to reset "
1896 "attributes of file %s to 0%o\n",
1897 fname, (unsigned int)new_unx_mode));
1900 /* If this is a successful open, we must remove any deferred open
1903 del_deferred_open_entry(lck, req->mid);
1907 conn->num_files_open++;
1910 return NT_STATUS_OK;
1913 /****************************************************************************
1914 Open a file for for write to ensure that we can fchmod it.
1915 ****************************************************************************/
1917 NTSTATUS open_file_fchmod(connection_struct *conn, const char *fname,
1918 SMB_STRUCT_STAT *psbuf, files_struct **result)
1920 files_struct *fsp = NULL;
1923 if (!VALID_STAT(*psbuf)) {
1924 return NT_STATUS_INVALID_PARAMETER;
1927 status = file_new(conn, &fsp);
1928 if(!NT_STATUS_IS_OK(status)) {
1932 /* note! we must use a non-zero desired access or we don't get
1933 a real file descriptor. Oh what a twisted web we weave. */
1934 status = open_file(fsp, conn, NULL, NULL, NULL, fname, psbuf, O_WRONLY,
1935 0, FILE_WRITE_DATA, FILE_WRITE_DATA);
1938 * This is not a user visible file open.
1939 * Don't set a share mode and don't increment
1940 * the conn->num_files_open.
1943 if (!NT_STATUS_IS_OK(status)) {
1949 return NT_STATUS_OK;
1952 /****************************************************************************
1953 Close the fchmod file fd - ensure no locks are lost.
1954 ****************************************************************************/
1956 NTSTATUS close_file_fchmod(files_struct *fsp)
1958 NTSTATUS status = fd_close(fsp->conn, fsp);
1963 static NTSTATUS mkdir_internal(connection_struct *conn,
1965 uint32 file_attributes,
1966 SMB_STRUCT_STAT *psbuf)
1970 const char *dirname;
1973 if(!CAN_WRITE(conn)) {
1974 DEBUG(5,("mkdir_internal: failing create on read-only share "
1975 "%s\n", lp_servicename(SNUM(conn))));
1976 return NT_STATUS_ACCESS_DENIED;
1979 status = check_name(conn, name);
1980 if (!NT_STATUS_IS_OK(status)) {
1984 if (!parent_dirname_talloc(tmp_talloc_ctx(), name, &parent_dir,
1986 return NT_STATUS_NO_MEMORY;
1989 if (file_attributes & FILE_FLAG_POSIX_SEMANTICS) {
1990 mode = (mode_t)(file_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
1992 mode = unix_mode(conn, aDIR, name, parent_dir);
1995 if (SMB_VFS_MKDIR(conn, name, mode) != 0) {
1996 return map_nt_error_from_unix(errno);
1999 /* Ensure we're checking for a symlink here.... */
2000 /* We don't want to get caught by a symlink racer. */
2002 if (SMB_VFS_LSTAT(conn, name, psbuf) == -1) {
2003 DEBUG(2, ("Could not stat directory '%s' just created: %s\n",
2004 name, strerror(errno)));
2005 return map_nt_error_from_unix(errno);
2008 if (!S_ISDIR(psbuf->st_mode)) {
2009 DEBUG(0, ("Directory just '%s' created is not a directory\n",
2011 return NT_STATUS_ACCESS_DENIED;
2014 if (lp_inherit_perms(SNUM(conn))) {
2015 inherit_access_acl(conn, parent_dir, name, mode);
2018 if (!(file_attributes & FILE_FLAG_POSIX_SEMANTICS)) {
2020 * Check if high bits should have been set,
2021 * then (if bits are missing): add them.
2022 * Consider bits automagically set by UNIX, i.e. SGID bit from parent
2025 if (mode & ~(S_IRWXU|S_IRWXG|S_IRWXO) && (mode & ~psbuf->st_mode)) {
2026 SMB_VFS_CHMOD(conn, name,
2027 psbuf->st_mode | (mode & ~psbuf->st_mode));
2031 /* Change the owner if required. */
2032 if (lp_inherit_owner(SNUM(conn))) {
2033 change_dir_owner_to_parent(conn, parent_dir, name, psbuf);
2036 notify_fname(conn, NOTIFY_ACTION_ADDED, FILE_NOTIFY_CHANGE_DIR_NAME,
2039 return NT_STATUS_OK;
2042 /****************************************************************************
2043 Open a directory from an NT SMB call.
2044 ****************************************************************************/
2046 NTSTATUS open_directory(connection_struct *conn,
2047 struct smb_request *req,
2049 SMB_STRUCT_STAT *psbuf,
2051 uint32 share_access,
2052 uint32 create_disposition,
2053 uint32 create_options,
2054 uint32 file_attributes,
2056 files_struct **result)
2058 files_struct *fsp = NULL;
2059 BOOL dir_existed = VALID_STAT(*psbuf) ? True : False;
2060 struct share_mode_lock *lck = NULL;
2064 DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
2065 "share_access = 0x%x create_options = 0x%x, "
2066 "create_disposition = 0x%x, file_attributes = 0x%x\n",
2068 (unsigned int)access_mask,
2069 (unsigned int)share_access,
2070 (unsigned int)create_options,
2071 (unsigned int)create_disposition,
2072 (unsigned int)file_attributes));
2074 if (is_ntfs_stream_name(fname)) {
2075 DEBUG(0,("open_directory: %s is a stream name!\n", fname ));
2076 return NT_STATUS_NOT_A_DIRECTORY;
2079 switch( create_disposition ) {
2082 info = FILE_WAS_OPENED;
2085 * We want to follow symlinks here.
2088 if (SMB_VFS_STAT(conn, fname, psbuf) != 0) {
2089 return map_nt_error_from_unix(errno);
2096 /* If directory exists error. If directory doesn't
2099 status = mkdir_internal(conn,
2104 if (!NT_STATUS_IS_OK(status)) {
2105 DEBUG(2, ("open_directory: unable to create "
2106 "%s. Error was %s\n", fname,
2107 nt_errstr(status)));
2111 info = FILE_WAS_CREATED;
2116 * If directory exists open. If directory doesn't
2120 status = mkdir_internal(conn,
2125 if (NT_STATUS_IS_OK(status)) {
2126 info = FILE_WAS_CREATED;
2129 if (NT_STATUS_EQUAL(status,
2130 NT_STATUS_OBJECT_NAME_COLLISION)) {
2131 info = FILE_WAS_OPENED;
2132 status = NT_STATUS_OK;
2137 case FILE_SUPERSEDE:
2138 case FILE_OVERWRITE:
2139 case FILE_OVERWRITE_IF:
2141 DEBUG(5,("open_directory: invalid create_disposition "
2142 "0x%x for directory %s\n",
2143 (unsigned int)create_disposition, fname));
2144 return NT_STATUS_INVALID_PARAMETER;
2147 if(!S_ISDIR(psbuf->st_mode)) {
2148 DEBUG(5,("open_directory: %s is not a directory !\n",
2150 return NT_STATUS_NOT_A_DIRECTORY;
2153 status = file_new(conn, &fsp);
2154 if(!NT_STATUS_IS_OK(status)) {
2159 * Setup the files_struct for it.
2162 fsp->mode = psbuf->st_mode;
2163 fsp->file_id = file_id_sbuf(psbuf);
2164 fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
2165 fsp->file_pid = req ? req->smbpid : 0;
2166 fsp->can_lock = False;
2167 fsp->can_read = False;
2168 fsp->can_write = False;
2170 fsp->share_access = share_access;
2171 fsp->fh->private_options = create_options;
2172 fsp->access_mask = access_mask;
2174 fsp->print_file = False;
2175 fsp->modified = False;
2176 fsp->oplock_type = NO_OPLOCK;
2177 fsp->sent_oplock_break = NO_BREAK_SENT;
2178 fsp->is_directory = True;
2179 fsp->is_stat = False;
2180 fsp->posix_open = (file_attributes & FILE_FLAG_POSIX_SEMANTICS) ? True : False;
2182 string_set(&fsp->fsp_name,fname);
2184 lck = get_share_mode_lock(NULL, fsp->file_id,
2189 DEBUG(0, ("open_directory: Could not get share mode lock for %s\n", fname));
2191 return NT_STATUS_SHARING_VIOLATION;
2194 status = open_mode_check(conn, fname, lck,
2195 access_mask, share_access,
2196 create_options, &dir_existed);
2198 if (!NT_STATUS_IS_OK(status)) {
2204 set_share_mode(lck, fsp, current_user.ut.uid, 0, NO_OPLOCK, True);
2206 /* For directories the delete on close bit at open time seems
2207 always to be honored on close... See test 19 in Samba4 BASE-DELETE. */
2208 if (create_options & FILE_DELETE_ON_CLOSE) {
2209 status = can_set_delete_on_close(fsp, True, 0);
2210 if (!NT_STATUS_IS_OK(status) && !NT_STATUS_EQUAL(status, NT_STATUS_DIRECTORY_NOT_EMPTY)) {
2216 if (NT_STATUS_IS_OK(status)) {
2217 /* Note that here we set the *inital* delete on close flag,
2218 not the regular one. The magic gets handled in close. */
2219 fsp->initial_delete_on_close = True;
2229 conn->num_files_open++;
2232 return NT_STATUS_OK;
2235 NTSTATUS create_directory(connection_struct *conn, const char *directory)
2238 SMB_STRUCT_STAT sbuf;
2241 SET_STAT_INVALID(sbuf);
2243 status = open_directory(conn, NULL, directory, &sbuf,
2244 FILE_READ_ATTRIBUTES, /* Just a stat open */
2245 FILE_SHARE_NONE, /* Ignored for stat opens */
2248 FILE_ATTRIBUTE_DIRECTORY,
2252 if (NT_STATUS_IS_OK(status)) {
2253 close_file(fsp, NORMAL_CLOSE);
2259 /****************************************************************************
2260 Open a pseudo-file (no locking checks - a 'stat' open).
2261 ****************************************************************************/
2263 NTSTATUS open_file_stat(connection_struct *conn, struct smb_request *req,
2264 const char *fname, SMB_STRUCT_STAT *psbuf,
2265 files_struct **result)
2267 files_struct *fsp = NULL;
2270 if (!VALID_STAT(*psbuf)) {
2271 return NT_STATUS_INVALID_PARAMETER;
2274 /* Can't 'stat' open directories. */
2275 if(S_ISDIR(psbuf->st_mode)) {
2276 return NT_STATUS_FILE_IS_A_DIRECTORY;
2279 status = file_new(conn, &fsp);
2280 if(!NT_STATUS_IS_OK(status)) {
2284 DEBUG(5,("open_file_stat: 'opening' file %s\n", fname));
2287 * Setup the files_struct for it.
2290 fsp->mode = psbuf->st_mode;
2291 fsp->file_id = file_id_sbuf(psbuf);
2292 fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
2293 fsp->file_pid = req ? req->smbpid : 0;
2294 fsp->can_lock = False;
2295 fsp->can_read = False;
2296 fsp->can_write = False;
2297 fsp->print_file = False;
2298 fsp->modified = False;
2299 fsp->oplock_type = NO_OPLOCK;
2300 fsp->sent_oplock_break = NO_BREAK_SENT;
2301 fsp->is_directory = False;
2302 fsp->is_stat = True;
2303 string_set(&fsp->fsp_name,fname);
2305 conn->num_files_open++;
2308 return NT_STATUS_OK;
2311 /****************************************************************************
2312 Receive notification that one of our open files has been renamed by another
2314 ****************************************************************************/
2316 void msg_file_was_renamed(struct messaging_context *msg,
2319 struct server_id server_id,
2323 char *frm = (char *)data->data;
2325 const char *sharepath;
2326 const char *newname;
2329 if (data->data == NULL
2330 || data->length < MSG_FILE_RENAMED_MIN_SIZE + 2) {
2331 DEBUG(0, ("msg_file_was_renamed: Got invalid msg len %d\n",
2332 (int)data->length));
2336 /* Unpack the message. */
2337 pull_file_id_16(frm, &id);
2338 sharepath = &frm[16];
2339 newname = sharepath + strlen(sharepath) + 1;
2340 sp_len = strlen(sharepath);
2342 DEBUG(10,("msg_file_was_renamed: Got rename message for sharepath %s, new name %s, "
2344 sharepath, newname, file_id_static_string(&id)));
2346 for(fsp = file_find_di_first(id); fsp; fsp = file_find_di_next(fsp)) {
2347 if (memcmp(fsp->conn->connectpath, sharepath, sp_len) == 0) {
2348 DEBUG(10,("msg_file_was_renamed: renaming file fnum %d from %s -> %s\n",
2349 fsp->fnum, fsp->fsp_name, newname ));
2350 string_set(&fsp->fsp_name, newname);
2353 /* Now we have the complete path we can work out if this is
2354 actually within this share and adjust newname accordingly. */
2355 DEBUG(10,("msg_file_was_renamed: share mismatch (sharepath %s "
2356 "not sharepath %s) "
2357 "fnum %d from %s -> %s\n",
2358 fsp->conn->connectpath,