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 current_user current_user;
26 extern userdom_struct current_user_info;
27 extern uint16 global_smbpid;
28 extern BOOL global_client_failed_oplock_break;
30 struct deferred_open_record {
31 BOOL delayed_for_oplocks;
36 /****************************************************************************
37 fd support routines - attempt to do a dos_open.
38 ****************************************************************************/
40 static int fd_open(struct connection_struct *conn,
47 if (!lp_symlinks(SNUM(conn))) {
52 fd = SMB_VFS_OPEN(conn,fname,flags,mode);
54 DEBUG(10,("fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s\n", fname,
55 flags, (int)mode, fd, (fd == -1) ? strerror(errno) : "" ));
60 /****************************************************************************
61 Close the file associated with a fsp.
62 ****************************************************************************/
64 int fd_close(struct connection_struct *conn,
67 if (fsp->fh->fd == -1) {
68 return 0; /* What we used to call a stat open. */
70 if (fsp->fh->ref_count > 1) {
71 return 0; /* Shared handle. Only close last reference. */
73 return fd_close_posix(conn, fsp);
77 /****************************************************************************
78 Check a filename for the pipe string.
79 ****************************************************************************/
81 static void check_for_pipe(const char *fname)
83 /* special case of pipe opens */
85 StrnCpy(s,fname,sizeof(s)-1);
87 if (strstr(s,"pipe/")) {
88 DEBUG(3,("Rejecting named pipe open for %s\n",fname));
89 set_saved_error_triple(ERRSRV, ERRaccess, NT_STATUS_ACCESS_DENIED);
93 /****************************************************************************
94 Change the ownership of a file to that of the parent directory.
95 Do this by fd if possible.
96 ****************************************************************************/
98 void change_owner_to_parent(connection_struct *conn,
101 SMB_STRUCT_STAT *psbuf)
103 const char *parent_path = parent_dirname(fname);
104 SMB_STRUCT_STAT parent_st;
107 ret = SMB_VFS_STAT(conn, parent_path, &parent_st);
109 DEBUG(0,("change_owner_to_parent: failed to stat parent "
110 "directory %s. Error was %s\n",
111 parent_path, strerror(errno) ));
115 if (fsp && fsp->fh->fd != -1) {
117 ret = SMB_VFS_FCHOWN(fsp, fsp->fh->fd, parent_st.st_uid, (gid_t)-1);
120 DEBUG(0,("change_owner_to_parent: failed to fchown "
121 "file %s to parent directory uid %u. Error "
123 (unsigned int)parent_st.st_uid,
127 DEBUG(10,("change_owner_to_parent: changed new file %s to "
128 "parent directory uid %u.\n", fname,
129 (unsigned int)parent_st.st_uid ));
132 /* We've already done an lstat into psbuf, and we know it's a
133 directory. If we can cd into the directory and the dev/ino
134 are the same then we can safely chown without races as
135 we're locking the directory in place by being in it. This
136 should work on any UNIX (thanks tridge :-). JRA.
140 SMB_STRUCT_STAT sbuf;
142 if (!vfs_GetWd(conn,saved_dir)) {
143 DEBUG(0,("change_owner_to_parent: failed to get "
144 "current working directory\n"));
148 /* Chdir into the new path. */
149 if (vfs_ChDir(conn, fname) == -1) {
150 DEBUG(0,("change_owner_to_parent: failed to change "
151 "current working directory to %s. Error "
152 "was %s\n", fname, strerror(errno) ));
156 if (SMB_VFS_STAT(conn,".",&sbuf) == -1) {
157 DEBUG(0,("change_owner_to_parent: failed to stat "
158 "directory '.' (%s) Error was %s\n",
159 fname, strerror(errno)));
163 /* Ensure we're pointing at the same place. */
164 if (sbuf.st_dev != psbuf->st_dev ||
165 sbuf.st_ino != psbuf->st_ino ||
166 sbuf.st_mode != psbuf->st_mode ) {
167 DEBUG(0,("change_owner_to_parent: "
168 "device/inode/mode on directory %s changed. "
169 "Refusing to chown !\n", fname ));
174 ret = SMB_VFS_CHOWN(conn, ".", parent_st.st_uid, (gid_t)-1);
177 DEBUG(10,("change_owner_to_parent: failed to chown "
178 "directory %s to parent directory uid %u. "
179 "Error was %s\n", fname,
180 (unsigned int)parent_st.st_uid, strerror(errno) ));
184 DEBUG(10,("change_owner_to_parent: changed ownership of new "
185 "directory %s to parent directory uid %u.\n",
186 fname, (unsigned int)parent_st.st_uid ));
190 vfs_ChDir(conn,saved_dir);
194 /****************************************************************************
196 ****************************************************************************/
198 static BOOL open_file(files_struct *fsp,
199 connection_struct *conn,
201 SMB_STRUCT_STAT *psbuf,
206 int accmode = (flags & O_ACCMODE);
207 int local_flags = flags;
208 BOOL file_existed = VALID_STAT(*psbuf);
213 /* Check permissions */
216 * This code was changed after seeing a client open request
217 * containing the open mode of (DENY_WRITE/read-only) with
218 * the 'create if not exist' bit set. The previous code
219 * would fail to open the file read only on a read-only share
220 * as it was checking the flags parameter directly against O_RDONLY,
221 * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
225 if (!CAN_WRITE(conn)) {
226 /* It's a read-only share - fail if we wanted to write. */
227 if(accmode != O_RDONLY) {
228 DEBUG(3,("Permission denied opening %s\n",fname));
229 check_for_pipe(fname);
231 } else if(flags & O_CREAT) {
232 /* We don't want to write - but we must make sure that
233 O_CREAT doesn't create the file if we have write
234 access into the directory.
237 local_flags &= ~O_CREAT;
242 * This little piece of insanity is inspired by the
243 * fact that an NT client can open a file for O_RDONLY,
244 * but set the create disposition to FILE_EXISTS_TRUNCATE.
245 * If the client *can* write to the file, then it expects to
246 * truncate the file, even though it is opening for readonly.
247 * Quicken uses this stupid trick in backup file creation...
248 * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
249 * for helping track this one down. It didn't bite us in 2.0.x
250 * as we always opened files read-write in that release. JRA.
253 if ((accmode == O_RDONLY) && ((flags & O_TRUNC) == O_TRUNC)) {
254 DEBUG(10,("open_file: truncate requested on read-only open "
255 "for file %s\n",fname ));
256 local_flags = (flags & ~O_ACCMODE)|O_RDWR;
259 if ((access_mask & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ||
260 (local_flags & O_CREAT) ||
261 ((local_flags & O_TRUNC) == O_TRUNC) ) {
264 * We can't actually truncate here as the file may be locked.
265 * open_file_shared will take care of the truncate later. JRA.
268 local_flags &= ~O_TRUNC;
270 #if defined(O_NONBLOCK) && defined(S_ISFIFO)
272 * We would block on opening a FIFO with no one else on the
273 * other end. Do what we used to do and add O_NONBLOCK to the
277 if (file_existed && S_ISFIFO(psbuf->st_mode)) {
278 local_flags |= O_NONBLOCK;
282 /* Don't create files with Microsoft wildcard characters. */
283 if ((local_flags & O_CREAT) && !file_existed &&
284 ms_has_wild(fname)) {
285 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_INVALID);
289 /* Actually do the open */
290 fsp->fh->fd = fd_open(conn, fname, local_flags, unx_mode);
291 if (fsp->fh->fd == -1) {
292 DEBUG(3,("Error opening file %s (%s) (local_flags=%d) "
294 fname,strerror(errno),local_flags,flags));
295 check_for_pipe(fname);
299 /* Inherit the ACL if the file was created. */
300 if ((local_flags & O_CREAT) && !file_existed) {
301 inherit_access_acl(conn, fname, unx_mode);
305 fsp->fh->fd = -1; /* What we used to call a stat open. */
311 if (fsp->fh->fd == -1) {
312 ret = SMB_VFS_STAT(conn, fname, psbuf);
314 ret = SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf);
315 /* If we have an fd, this stat should succeed. */
317 DEBUG(0,("Error doing fstat on open file %s "
318 "(%s)\n", fname,strerror(errno) ));
322 /* For a non-io open, this stat failing means file not found. JRA */
330 * POSIX allows read-only opens of directories. We don't
331 * want to do this (we use a different code path for this)
332 * so catch a directory open and return an EISDIR. JRA.
335 if(S_ISDIR(psbuf->st_mode)) {
341 fsp->mode = psbuf->st_mode;
342 fsp->inode = psbuf->st_ino;
343 fsp->dev = psbuf->st_dev;
344 fsp->vuid = current_user.vuid;
345 fsp->file_pid = global_smbpid;
346 fsp->can_lock = True;
347 fsp->can_read = (access_mask & (FILE_READ_DATA)) ? True : False;
348 if (!CAN_WRITE(conn)) {
349 fsp->can_write = False;
351 fsp->can_write = (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) ? True : False;
353 fsp->print_file = False;
354 fsp->modified = False;
355 fsp->sent_oplock_break = NO_BREAK_SENT;
356 fsp->is_directory = False;
357 fsp->is_stat = False;
358 if (conn->aio_write_behind_list &&
359 is_in_path(fname, conn->aio_write_behind_list, conn->case_sensitive)) {
360 fsp->aio_write_behind = True;
363 string_set(&fsp->fsp_name,fname);
364 fsp->wcp = NULL; /* Write cache pointer. */
366 DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
367 *current_user_info.smb_name ? current_user_info.smb_name : conn->user,fsp->fsp_name,
368 BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
369 conn->num_files_open + 1));
375 /*******************************************************************
376 Return True if the filename is one of the special executable types.
377 ********************************************************************/
379 static BOOL is_executable(const char *fname)
381 if ((fname = strrchr_m(fname,'.'))) {
382 if (strequal(fname,".com") ||
383 strequal(fname,".dll") ||
384 strequal(fname,".exe") ||
385 strequal(fname,".sym")) {
392 /****************************************************************************
393 Check if we can open a file with a share mode.
394 Returns True if conflict, False if not.
395 ****************************************************************************/
397 static BOOL share_conflict(struct share_mode_entry *entry,
401 DEBUG(10,("share_conflict: entry->access_mask = 0x%x, "
402 "entry->share_access = 0x%x, "
403 "entry->private_options = 0x%x\n",
404 (unsigned int)entry->access_mask,
405 (unsigned int)entry->share_access,
406 (unsigned int)entry->private_options));
408 DEBUG(10,("share_conflict: access_mask = 0x%x, share_access = 0x%x\n",
409 (unsigned int)access_mask, (unsigned int)share_access));
411 if ((entry->access_mask & (FILE_WRITE_DATA|
415 DELETE_ACCESS)) == 0) {
416 DEBUG(10,("share_conflict: No conflict due to "
417 "entry->access_mask = 0x%x\n",
418 (unsigned int)entry->access_mask ));
422 if ((access_mask & (FILE_WRITE_DATA|
426 DELETE_ACCESS)) == 0) {
427 DEBUG(10,("share_conflict: No conflict due to "
428 "access_mask = 0x%x\n",
429 (unsigned int)access_mask ));
433 #if 1 /* JRA TEST - Superdebug. */
434 #define CHECK_MASK(num, am, right, sa, share) \
435 DEBUG(10,("share_conflict: [%d] am (0x%x) & right (0x%x) = 0x%x\n", \
436 (unsigned int)(num), (unsigned int)(am), \
437 (unsigned int)(right), (unsigned int)(am)&(right) )); \
438 DEBUG(10,("share_conflict: [%d] sa (0x%x) & share (0x%x) = 0x%x\n", \
439 (unsigned int)(num), (unsigned int)(sa), \
440 (unsigned int)(share), (unsigned int)(sa)&(share) )); \
441 if (((am) & (right)) && !((sa) & (share))) { \
442 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
443 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
444 (unsigned int)(share) )); \
448 #define CHECK_MASK(num, am, right, sa, share) \
449 if (((am) & (right)) && !((sa) & (share))) { \
450 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
451 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
452 (unsigned int)(share) )); \
457 CHECK_MASK(1, entry->access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
458 share_access, FILE_SHARE_WRITE);
459 CHECK_MASK(2, access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
460 entry->share_access, FILE_SHARE_WRITE);
462 CHECK_MASK(3, entry->access_mask, FILE_READ_DATA | FILE_EXECUTE,
463 share_access, FILE_SHARE_READ);
464 CHECK_MASK(4, access_mask, FILE_READ_DATA | FILE_EXECUTE,
465 entry->share_access, FILE_SHARE_READ);
467 CHECK_MASK(5, entry->access_mask, DELETE_ACCESS,
468 share_access, FILE_SHARE_DELETE);
469 CHECK_MASK(6, access_mask, DELETE_ACCESS,
470 entry->share_access, FILE_SHARE_DELETE);
472 DEBUG(10,("share_conflict: No conflict.\n"));
476 #if defined(DEVELOPER)
477 static void validate_my_share_entries(int num,
478 struct share_mode_entry *share_entry)
482 if (!procid_is_me(&share_entry->pid)) {
486 if (is_deferred_open_entry(share_entry) &&
487 !open_was_deferred(share_entry->op_mid)) {
489 DEBUG(0, ("Got a deferred entry without a request: "
490 "PANIC: %s\n", share_mode_str(num, share_entry)));
494 if (!is_valid_share_mode_entry(share_entry)) {
498 fsp = file_find_dif(share_entry->dev, share_entry->inode,
499 share_entry->share_file_id);
501 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
502 share_mode_str(num, share_entry) ));
503 smb_panic("validate_my_share_entries: Cannot match a "
504 "share entry with an open file\n");
507 if (is_deferred_open_entry(share_entry) ||
508 is_unused_share_mode_entry(share_entry)) {
512 if ((share_entry->op_type == NO_OPLOCK) &&
513 (fsp->oplock_type == FAKE_LEVEL_II_OPLOCK)) {
514 /* Someone has already written to it, but I haven't yet
519 if (((uint16)fsp->oplock_type) != share_entry->op_type) {
528 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
529 share_mode_str(num, share_entry) ));
530 slprintf(str, sizeof(str)-1, "validate_my_share_entries: "
531 "file %s, oplock_type = 0x%x, op_type = 0x%x\n",
532 fsp->fsp_name, (unsigned int)fsp->oplock_type,
533 (unsigned int)share_entry->op_type );
539 static BOOL is_stat_open(uint32 access_mask)
541 return (access_mask &&
542 ((access_mask & ~(SYNCHRONIZE_ACCESS| FILE_READ_ATTRIBUTES|
543 FILE_WRITE_ATTRIBUTES))==0) &&
544 ((access_mask & (SYNCHRONIZE_ACCESS|FILE_READ_ATTRIBUTES|
545 FILE_WRITE_ATTRIBUTES)) != 0));
548 /****************************************************************************
549 Deal with share modes
550 Invarient: Share mode must be locked on entry and exit.
551 Returns -1 on error, or number of share modes on success (may be zero).
552 ****************************************************************************/
554 static NTSTATUS open_mode_check(connection_struct *conn,
556 struct share_mode_lock *lck,
559 uint32 create_options,
564 if(lck->num_share_modes == 0) {
568 *file_existed = True;
570 if (is_stat_open(access_mask)) {
571 /* Stat open that doesn't trigger oplock breaks or share mode
572 * checks... ! JRA. */
576 /* A delete on close prohibits everything */
578 if (lck->delete_on_close) {
579 return NT_STATUS_DELETE_PENDING;
583 * Check if the share modes will give us access.
586 #if defined(DEVELOPER)
587 for(i = 0; i < lck->num_share_modes; i++) {
588 validate_my_share_entries(i, &lck->share_modes[i]);
592 if (!lp_share_modes(SNUM(conn))) {
596 /* Now we check the share modes, after any oplock breaks. */
597 for(i = 0; i < lck->num_share_modes; i++) {
599 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
603 /* someone else has a share lock on it, check to see if we can
605 if (share_conflict(&lck->share_modes[i],
606 access_mask, share_access)) {
607 return NT_STATUS_SHARING_VIOLATION;
614 static BOOL is_delete_request(files_struct *fsp) {
615 return ((fsp->access_mask == DELETE_ACCESS) &&
616 (fsp->oplock_type == NO_OPLOCK));
620 * 1) No files open at all: Grant whatever the client wants.
622 * 2) Exclusive (or batch) oplock around: If the requested access is a delete
623 * request, break if the oplock around is a batch oplock. If it's another
624 * requested access type, break.
626 * 3) Only level2 around: Grant level2 and do nothing else.
629 static BOOL delay_for_oplocks(struct share_mode_lock *lck, files_struct *fsp)
632 struct share_mode_entry *exclusive = NULL;
633 BOOL delay_it = False;
634 BOOL have_level2 = False;
636 if (is_stat_open(fsp->access_mask)) {
637 fsp->oplock_type = NO_OPLOCK;
643 if (lck->num_share_modes == 0) {
644 /* No files open at all: Directly grant whatever the client
647 if (fsp->oplock_type == NO_OPLOCK) {
648 /* Store a level2 oplock, but don't tell the client */
649 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
654 for (i=0; i<lck->num_share_modes; i++) {
656 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
660 if (EXCLUSIVE_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
661 SMB_ASSERT(exclusive == NULL);
662 exclusive = &lck->share_modes[i];
665 if (lck->share_modes[i].op_type == LEVEL_II_OPLOCK) {
670 if (exclusive != NULL) { /* Found an exclusive oplock */
671 SMB_ASSERT(!have_level2);
672 delay_it = is_delete_request(fsp) ?
673 BATCH_OPLOCK_TYPE(exclusive->op_type) : True;
676 if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
677 /* We can at most grant level2 */
678 fsp->oplock_type = LEVEL_II_OPLOCK;
681 if ((fsp->oplock_type == NO_OPLOCK) && have_level2) {
682 /* Store a level2 oplock, but don't tell the client */
683 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
687 DEBUG(10, ("Sending break request to PID %s\n",
688 procid_str_static(&exclusive->pid)));
689 exclusive->op_mid = get_current_mid();
690 if (!message_send_pid(exclusive->pid, MSG_SMB_BREAK_REQUEST,
691 exclusive, sizeof(*exclusive), True)) {
692 DEBUG(3, ("Could not send oplock break message\n"));
700 static BOOL request_timed_out(struct timeval request_time,
701 struct timeval timeout)
703 struct timeval now, end_time;
705 end_time = timeval_sum(&request_time, &timeout);
706 return (timeval_compare(&end_time, &now) < 0);
709 /****************************************************************************
710 Handle the 1 second delay in returning a SHARING_VIOLATION error.
711 ****************************************************************************/
713 static void defer_open(struct share_mode_lock *lck,
714 struct timeval request_time,
715 struct timeval timeout,
716 struct deferred_open_record *state)
718 uint16 mid = get_current_mid();
723 for (i=0; i<lck->num_share_modes; i++) {
724 struct share_mode_entry *e = &lck->share_modes[i];
726 if (!is_deferred_open_entry(e)) {
730 if (procid_is_me(&e->pid) && (e->op_mid == mid)) {
731 DEBUG(0, ("Trying to defer an already deferred "
732 "request: mid=%d, exiting\n", mid));
733 exit_server("exiting");
737 /* End paranoia check */
739 DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred "
740 "open entry for mid %u\n",
741 (unsigned int)request_time.tv_sec,
742 (unsigned int)request_time.tv_usec,
745 if (!push_deferred_smb_message(mid, request_time, timeout,
746 (char *)state, sizeof(*state))) {
747 exit_server("push_deferred_smb_message failed\n");
749 add_deferred_open(lck, mid, request_time, state->dev, state->inode);
752 * Push the MID of this packet on the signing queue.
753 * We only do this once, the first time we push the packet
754 * onto the deferred open queue, as this has a side effect
755 * of incrementing the response sequence number.
758 srv_defer_sign_response(mid);
761 /****************************************************************************
762 Set a kernel flock on a file for NFS interoperability.
763 This requires a patch to Linux.
764 ****************************************************************************/
766 static void kernel_flock(files_struct *fsp, uint32 share_mode)
768 #if HAVE_KERNEL_SHARE_MODES
770 if (share_mode == FILE_SHARE_WRITE) {
771 kernel_mode = LOCK_MAND|LOCK_WRITE;
772 } else if (share_mode == FILE_SHARE_READ) {
773 kernel_mode = LOCK_MAND|LOCK_READ;
774 } else if (share_mode == FILE_SHARE_NONE) {
775 kernel_mode = LOCK_MAND;
778 flock(fsp->fh->fd, kernel_mode);
784 /****************************************************************************
785 On overwrite open ensure that the attributes match.
786 ****************************************************************************/
788 static BOOL open_match_attributes(connection_struct *conn,
792 mode_t existing_unx_mode,
794 mode_t *returned_unx_mode)
796 uint32 noarch_old_dos_attr, noarch_new_dos_attr;
798 noarch_old_dos_attr = (old_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
799 noarch_new_dos_attr = (new_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
801 if((noarch_old_dos_attr == 0 && noarch_new_dos_attr != 0) ||
802 (noarch_old_dos_attr != 0 && ((noarch_old_dos_attr & noarch_new_dos_attr) == noarch_old_dos_attr))) {
803 *returned_unx_mode = new_unx_mode;
805 *returned_unx_mode = (mode_t)0;
808 DEBUG(10,("open_match_attributes: file %s old_dos_attr = 0x%x, "
809 "existing_unx_mode = 0%o, new_dos_attr = 0x%x "
810 "returned_unx_mode = 0%o\n",
812 (unsigned int)old_dos_attr,
813 (unsigned int)existing_unx_mode,
814 (unsigned int)new_dos_attr,
815 (unsigned int)*returned_unx_mode ));
817 /* If we're mapping SYSTEM and HIDDEN ensure they match. */
818 if (lp_map_system(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
819 if ((old_dos_attr & FILE_ATTRIBUTE_SYSTEM) &&
820 !(new_dos_attr & FILE_ATTRIBUTE_SYSTEM)) {
824 if (lp_map_hidden(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
825 if ((old_dos_attr & FILE_ATTRIBUTE_HIDDEN) &&
826 !(new_dos_attr & FILE_ATTRIBUTE_HIDDEN)) {
833 /****************************************************************************
834 Special FCB or DOS processing in the case of a sharing violation.
835 Try and find a duplicated file handle.
836 ****************************************************************************/
838 static files_struct *fcb_or_dos_open(connection_struct *conn,
839 const char *fname, SMB_DEV_T dev,
843 uint32 create_options)
846 files_struct *dup_fsp;
848 DEBUG(5,("fcb_or_dos_open: attempting old open semantics for "
849 "file %s.\n", fname ));
851 for(fsp = file_find_di_first(dev, inode); fsp;
852 fsp = file_find_di_next(fsp)) {
854 DEBUG(10,("fcb_or_dos_open: checking file %s, fd = %d, "
855 "vuid = %u, file_pid = %u, private_options = 0x%x "
856 "access_mask = 0x%x\n", fsp->fsp_name,
857 fsp->fh->fd, (unsigned int)fsp->vuid,
858 (unsigned int)fsp->file_pid,
859 (unsigned int)fsp->fh->private_options,
860 (unsigned int)fsp->access_mask ));
862 if (fsp->fh->fd != -1 &&
863 fsp->vuid == current_user.vuid &&
864 fsp->file_pid == global_smbpid &&
865 (fsp->fh->private_options & (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS |
866 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) &&
867 (fsp->access_mask & FILE_WRITE_DATA) &&
868 strequal(fsp->fsp_name, fname)) {
869 DEBUG(10,("fcb_or_dos_open: file match\n"));
878 /* quite an insane set of semantics ... */
879 if (is_executable(fname) &&
880 (fsp->fh->private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS)) {
881 DEBUG(10,("fcb_or_dos_open: file fail due to is_executable.\n"));
885 /* We need to duplicate this fsp. */
886 dup_fsp = dup_file_fsp(fsp, access_mask, share_access, create_options);
894 /****************************************************************************
895 Open a file with a share mode - old openX method - map into NTCreate.
896 ****************************************************************************/
898 BOOL map_open_params_to_ntcreate(const char *fname, int deny_mode, int open_func,
899 uint32 *paccess_mask,
901 uint32 *pcreate_disposition,
902 uint32 *pcreate_options)
906 uint32 create_disposition;
907 uint32 create_options = 0;
909 DEBUG(10,("map_open_params_to_ntcreate: fname = %s, deny_mode = 0x%x, "
910 "open_func = 0x%x\n",
911 fname, (unsigned int)deny_mode, (unsigned int)open_func ));
913 /* Create the NT compatible access_mask. */
914 switch (GET_OPENX_MODE(deny_mode)) {
915 case DOS_OPEN_EXEC: /* Implies read-only - used to be FILE_READ_DATA */
916 case DOS_OPEN_RDONLY:
917 access_mask = FILE_GENERIC_READ;
919 case DOS_OPEN_WRONLY:
920 access_mask = FILE_GENERIC_WRITE;
924 access_mask = FILE_GENERIC_READ|FILE_GENERIC_WRITE;
927 DEBUG(10,("map_open_params_to_ntcreate: bad open mode = 0x%x\n",
928 (unsigned int)GET_OPENX_MODE(deny_mode)));
932 /* Create the NT compatible create_disposition. */
934 case OPENX_FILE_EXISTS_FAIL|OPENX_FILE_CREATE_IF_NOT_EXIST:
935 create_disposition = FILE_CREATE;
938 case OPENX_FILE_EXISTS_OPEN:
939 create_disposition = FILE_OPEN;
942 case OPENX_FILE_EXISTS_OPEN|OPENX_FILE_CREATE_IF_NOT_EXIST:
943 create_disposition = FILE_OPEN_IF;
946 case OPENX_FILE_EXISTS_TRUNCATE:
947 create_disposition = FILE_OVERWRITE;
950 case OPENX_FILE_EXISTS_TRUNCATE|OPENX_FILE_CREATE_IF_NOT_EXIST:
951 create_disposition = FILE_OVERWRITE_IF;
955 /* From samba4 - to be confirmed. */
956 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_EXEC) {
957 create_disposition = FILE_CREATE;
960 DEBUG(10,("map_open_params_to_ntcreate: bad "
961 "open_func 0x%x\n", (unsigned int)open_func));
965 /* Create the NT compatible share modes. */
966 switch (GET_DENY_MODE(deny_mode)) {
968 share_mode = FILE_SHARE_NONE;
972 share_mode = FILE_SHARE_READ;
976 share_mode = FILE_SHARE_WRITE;
980 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
984 create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
985 if (is_executable(fname)) {
986 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
988 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_RDONLY) {
989 share_mode = FILE_SHARE_READ;
991 share_mode = FILE_SHARE_NONE;
997 create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
998 share_mode = FILE_SHARE_NONE;
1002 DEBUG(10,("map_open_params_to_ntcreate: bad deny_mode 0x%x\n",
1003 (unsigned int)GET_DENY_MODE(deny_mode) ));
1007 DEBUG(10,("map_open_params_to_ntcreate: file %s, access_mask = 0x%x, "
1008 "share_mode = 0x%x, create_disposition = 0x%x, "
1009 "create_options = 0x%x\n",
1011 (unsigned int)access_mask,
1012 (unsigned int)share_mode,
1013 (unsigned int)create_disposition,
1014 (unsigned int)create_options ));
1017 *paccess_mask = access_mask;
1020 *pshare_mode = share_mode;
1022 if (pcreate_disposition) {
1023 *pcreate_disposition = create_disposition;
1025 if (pcreate_options) {
1026 *pcreate_options = create_options;
1033 /* Map generic permissions to file object specific permissions */
1035 struct generic_mapping file_generic_mapping = {
1038 FILE_GENERIC_EXECUTE,
1042 /****************************************************************************
1043 Open a file with a share mode.
1044 ****************************************************************************/
1046 files_struct *open_file_ntcreate(connection_struct *conn,
1048 SMB_STRUCT_STAT *psbuf,
1049 uint32 access_mask, /* access bits (FILE_READ_DATA etc.) */
1050 uint32 share_access, /* share constants (FILE_SHARE_READ etc). */
1051 uint32 create_disposition, /* FILE_OPEN_IF etc. */
1052 uint32 create_options, /* options such as delete on close. */
1053 uint32 new_dos_attributes, /* attributes used for new file. */
1054 int oplock_request, /* internal Samba oplock codes. */
1055 /* Information (FILE_EXISTS etc.) */
1060 BOOL file_existed = VALID_STAT(*psbuf);
1061 BOOL def_acl = False;
1062 BOOL internal_only_open = False;
1064 SMB_INO_T inode = 0;
1065 BOOL fsp_open = False;
1066 files_struct *fsp = NULL;
1067 mode_t new_unx_mode = (mode_t)0;
1068 mode_t unx_mode = (mode_t)0;
1070 uint32 existing_dos_attributes = 0;
1071 struct pending_message_list *pml = NULL;
1072 uint16 mid = get_current_mid();
1073 BOOL delayed_for_oplocks = False;
1074 struct timeval request_time = timeval_zero();
1075 struct share_mode_lock *lck = NULL;
1078 if (conn->printer) {
1080 * Printers are handled completely differently.
1081 * Most of the passed parameters are ignored.
1085 *pinfo = FILE_WAS_CREATED;
1088 DEBUG(10, ("open_file_ntcreate: printer open fname=%s\n", fname));
1090 return print_fsp_open(conn, fname);
1093 /* We add aARCH to this as this mode is only used if the file is
1095 unx_mode = unix_mode(conn, new_dos_attributes | aARCH,fname, True);
1097 DEBUG(10, ("open_file_ntcreate: fname=%s, dos_attrs=0x%x "
1098 "access_mask=0x%x share_access=0x%x "
1099 "create_disposition = 0x%x create_options=0x%x "
1100 "unix mode=0%o oplock_request=%d\n",
1101 fname, new_dos_attributes, access_mask, share_access,
1102 create_disposition, create_options, unx_mode,
1105 if (oplock_request == INTERNAL_OPEN_ONLY) {
1106 internal_only_open = True;
1110 if ((pml = get_open_deferred_message(mid)) != NULL) {
1111 struct deferred_open_record *state =
1112 (struct deferred_open_record *)pml->private_data.data;
1114 request_time = pml->request_time;
1115 delayed_for_oplocks = state->delayed_for_oplocks;
1117 /* There could be a race condition where the dev/inode pair
1118 has changed since we deferred the message. If so, just
1119 remove the deferred open entry and return sharing
1122 /* If the timeout value is non-zero, we need to just return
1123 sharing violation. Don't retry the open as we were not
1124 notified of a close and we don't want to trigger another
1125 spurious oplock break. */
1127 /* Now remove the deferred open entry under lock. */
1128 lck = get_share_mode_lock(NULL, state->dev, state->inode,
1131 DEBUG(0, ("could not get share mode lock\n"));
1133 del_deferred_open_entry(lck, mid);
1134 talloc_destroy(lck);
1137 /* Ensure we don't reprocess this message. */
1138 remove_deferred_open_smb_message(mid);
1141 if (!check_name(fname,conn)) {
1145 new_dos_attributes &= SAMBA_ATTRIBUTES_MASK;
1147 existing_dos_attributes = dos_mode(conn, fname, psbuf);
1150 /* ignore any oplock requests if oplocks are disabled */
1151 if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break ||
1152 IS_VETO_OPLOCK_PATH(conn, fname)) {
1156 /* this is for OS/2 long file names - say we don't support them */
1157 if (!lp_posix_pathnames() && strstr(fname,".+,;=[].")) {
1158 /* OS/2 Workplace shell fix may be main code stream in a later
1160 set_saved_error_triple(ERRDOS, ERRcannotopen,
1161 NT_STATUS_OBJECT_NAME_NOT_FOUND);
1162 DEBUG(5,("open_file_ntcreate: OS/2 long filenames are not "
1167 switch( create_disposition ) {
1169 * Currently we're using FILE_SUPERSEDE as the same as
1170 * FILE_OVERWRITE_IF but they really are
1171 * different. FILE_SUPERSEDE deletes an existing file
1172 * (requiring delete access) then recreates it.
1174 case FILE_SUPERSEDE:
1175 /* If file exists replace/overwrite. If file doesn't
1177 flags2 |= (O_CREAT | O_TRUNC);
1180 case FILE_OVERWRITE_IF:
1181 /* If file exists replace/overwrite. If file doesn't
1183 flags2 |= (O_CREAT | O_TRUNC);
1187 /* If file exists open. If file doesn't exist error. */
1188 if (!file_existed) {
1189 DEBUG(5,("open_file_ntcreate: FILE_OPEN "
1190 "requested for file %s and file "
1191 "doesn't exist.\n", fname ));
1192 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_NOT_FOUND);
1198 case FILE_OVERWRITE:
1199 /* If file exists overwrite. If file doesn't exist
1201 if (!file_existed) {
1202 DEBUG(5,("open_file_ntcreate: FILE_OVERWRITE "
1203 "requested for file %s and file "
1204 "doesn't exist.\n", fname ));
1205 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_NOT_FOUND);
1213 /* If file exists error. If file doesn't exist
1216 DEBUG(5,("open_file_ntcreate: FILE_CREATE "
1217 "requested for file %s and file "
1218 "already exists.\n", fname ));
1219 if (S_ISDIR(psbuf->st_mode)) {
1226 flags2 |= (O_CREAT|O_EXCL);
1230 /* If file exists open. If file doesn't exist
1236 set_saved_ntstatus(NT_STATUS_INVALID_PARAMETER);
1240 /* We only care about matching attributes on file exists and
1243 if (file_existed && ((create_disposition == FILE_OVERWRITE) ||
1244 (create_disposition == FILE_OVERWRITE_IF))) {
1245 if (!open_match_attributes(conn, fname,
1246 existing_dos_attributes,
1247 new_dos_attributes, psbuf->st_mode,
1248 unx_mode, &new_unx_mode)) {
1249 DEBUG(5,("open_file_ntcreate: attributes missmatch "
1250 "for file %s (%x %x) (0%o, 0%o)\n",
1251 fname, existing_dos_attributes,
1253 (unsigned int)psbuf->st_mode,
1254 (unsigned int)unx_mode ));
1260 /* This is a nasty hack - must fix... JRA. */
1261 if (access_mask == MAXIMUM_ALLOWED_ACCESS) {
1262 access_mask = FILE_GENERIC_ALL;
1266 * Convert GENERIC bits to specific bits.
1269 se_map_generic(&access_mask, &file_generic_mapping);
1271 DEBUG(10, ("open_file_ntcreate: fname=%s, after mapping "
1272 "access_mask=0x%x\n", fname, access_mask ));
1275 * Note that we ignore the append flag as append does not
1276 * mean the same thing under DOS and Unix.
1279 if (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) {
1286 * Currently we only look at FILE_WRITE_THROUGH for create options.
1290 if (create_options & FILE_WRITE_THROUGH) {
1295 if (!CAN_WRITE(conn)) {
1297 * We should really return a permission denied error if either
1298 * O_CREAT or O_TRUNC are set, but for compatibility with
1299 * older versions of Samba we just AND them out.
1301 flags2 &= ~(O_CREAT|O_TRUNC);
1305 * Ensure we can't write on a read-only share or file.
1308 if (flags != O_RDONLY && file_existed &&
1309 (!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_attributes))) {
1310 DEBUG(5,("open_file_ntcreate: write access requested for "
1311 "file %s on read only %s\n",
1312 fname, !CAN_WRITE(conn) ? "share" : "file" ));
1313 set_saved_ntstatus(NT_STATUS_ACCESS_DENIED);
1318 fsp = file_new(conn);
1323 fsp->dev = psbuf->st_dev;
1324 fsp->inode = psbuf->st_ino;
1325 fsp->share_access = share_access;
1326 fsp->fh->private_options = create_options;
1327 fsp->access_mask = access_mask;
1328 fsp->oplock_type = oplock_request;
1330 if (timeval_is_zero(&request_time)) {
1331 request_time = fsp->open_time;
1336 dev = psbuf->st_dev;
1337 inode = psbuf->st_ino;
1339 lck = get_share_mode_lock(NULL, dev, inode, fname);
1342 DEBUG(0, ("Could not get share mode lock\n"));
1343 set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1347 if (delay_for_oplocks(lck, fsp)) {
1348 struct deferred_open_record state;
1349 struct timeval timeout;
1351 if (delayed_for_oplocks) {
1352 DEBUG(0, ("Trying to delay for oplocks "
1354 exit_server("exiting");
1357 timeout = timeval_set(OPLOCK_BREAK_TIMEOUT*2, 0);
1359 /* Normally the smbd we asked should respond within
1360 * OPLOCK_BREAK_TIMEOUT seconds regardless of whether
1361 * the client did, give twice the timeout as a safety
1362 * measure here in case the other smbd is stuck
1363 * somewhere else. */
1365 state.delayed_for_oplocks = True;
1367 state.inode = inode;
1369 if (!request_timed_out(request_time, timeout)) {
1370 defer_open(lck, request_time, timeout,
1378 status = open_mode_check(conn, fname, lck,
1379 access_mask, share_access,
1380 create_options, &file_existed);
1382 if (NT_STATUS_EQUAL(status, NT_STATUS_DELETE_PENDING)) {
1383 /* DELETE_PENDING is not deferred for a second */
1384 set_saved_ntstatus(status);
1390 if (!NT_STATUS_IS_OK(status)) {
1392 SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION));
1394 /* Check if this can be done with the deny_dos and fcb
1396 if (create_options &
1397 (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS|
1398 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
1399 files_struct *fsp_dup;
1400 fsp_dup = fcb_or_dos_open(conn, fname, dev,
1409 *pinfo = FILE_WAS_OPENED;
1411 conn->num_files_open++;
1417 * This next line is a subtlety we need for
1418 * MS-Access. If a file open will fail due to share
1419 * permissions and also for security (access) reasons,
1420 * we need to return the access failed error, not the
1421 * share error. This means we must attempt to open the
1422 * file anyway in order to get the UNIX access error -
1423 * even if we're going to fail the open for share
1424 * reasons. This is bad, as we're burning another fd
1425 * if there are existing locks but there's nothing
1426 * else we can do. We also ensure we're not going to
1427 * create or tuncate the file as we only want an
1428 * access decision at this stage. JRA.
1431 fsp_open = open_file(fsp,conn,fname,psbuf,
1432 flags|(flags2&~(O_TRUNC|O_CREAT)),
1433 unx_mode,access_mask);
1435 DEBUG(4,("open_file_ntcreate : share_mode deny - "
1436 "calling open_file with flags=0x%X "
1437 "flags2=0x%X mode=0%o returned %d\n",
1438 flags, (flags2&~(O_TRUNC|O_CREAT)),
1439 (unsigned int)unx_mode, (int)fsp_open ));
1441 if (!fsp_open && errno) {
1442 /* Default error. */
1443 set_saved_ntstatus(NT_STATUS_ACCESS_DENIED);
1447 * If we're returning a share violation, ensure we
1448 * cope with the braindead 1 second delay.
1451 if (!internal_only_open &&
1452 lp_defer_sharing_violations()) {
1453 struct timeval timeout;
1454 struct deferred_open_record state;
1456 timeout = timeval_set(0, SHARING_VIOLATION_USEC_WAIT);
1458 state.delayed_for_oplocks = False;
1460 state.inode = inode;
1462 if (!request_timed_out(request_time,
1464 defer_open(lck, request_time, timeout,
1471 fd_close(conn, fsp);
1473 * We have detected a sharing violation here
1474 * so return the correct error code
1476 set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1483 * We exit this block with the share entry *locked*.....
1487 SMB_ASSERT(!file_existed || (lck != NULL));
1490 * Ensure we pay attention to default ACLs on directories if required.
1493 if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
1494 (def_acl = directory_has_default_acl(conn,
1495 parent_dirname(fname)))) {
1499 DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
1500 (unsigned int)flags, (unsigned int)flags2,
1501 (unsigned int)unx_mode));
1504 * open_file strips any O_TRUNC flags itself.
1507 fsp_open = open_file(fsp,conn,fname,psbuf,flags|flags2,unx_mode,
1510 if (!fsp_open && (flags2 & O_EXCL) && (errno == EEXIST)) {
1512 * Two smbd's tried to open exclusively, but only one of them
1519 if (!fsp_open && (flags == O_RDWR) && (errno != ENOENT)) {
1520 if((fsp_open = open_file(fsp,conn,fname,psbuf,
1521 O_RDONLY,unx_mode,access_mask)) == True) {
1534 if (!file_existed) {
1537 * Deal with the race condition where two smbd's detect the
1538 * file doesn't exist and do the create at the same time. One
1539 * of them will win and set a share mode, the other (ie. this
1540 * one) should check if the requested share mode for this
1541 * create is allowed.
1545 * Now the file exists and fsp is successfully opened,
1546 * fsp->dev and fsp->inode are valid and should replace the
1547 * dev=0,inode=0 from a non existent file. Spotted by
1548 * Nadav Danieli <nadavd@exanet.com>. JRA.
1554 lck = get_share_mode_lock(NULL, dev, inode, fname);
1557 DEBUG(0, ("Coult not get share mode lock\n"));
1558 fd_close(conn, fsp);
1560 set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1564 status = open_mode_check(conn, fname, lck,
1565 access_mask, share_access,
1566 create_options, &file_existed);
1568 if (!NT_STATUS_IS_OK(status)) {
1569 struct deferred_open_record state;
1571 fd_close(conn, fsp);
1574 state.delayed_for_oplocks = False;
1576 state.inode = inode;
1578 /* Do it all over again immediately. In the second
1579 * round we will find that the file existed and handle
1580 * the DELETE_PENDING and FCB cases correctly. No need
1581 * to duplicate the code here. Essentially this is a
1582 * "goto top of this function", but don't tell
1585 defer_open(lck, request_time, timeval_zero(),
1592 * We exit this block with the share entry *locked*.....
1596 SMB_ASSERT(lck != NULL);
1598 /* note that we ignore failure for the following. It is
1599 basically a hack for NFS, and NFS will never set one of
1600 these only read them. Nobody but Samba can ever set a deny
1601 mode and we have already checked our more authoritative
1602 locking database for permission to set this deny mode. If
1603 the kernel refuses the operations then the kernel is wrong */
1605 kernel_flock(fsp, share_access);
1608 * At this point onwards, we can guarentee that the share entry
1609 * is locked, whether we created the file or not, and that the
1610 * deny mode is compatible with all current opens.
1614 * If requested, truncate the file.
1617 if (flags2&O_TRUNC) {
1619 * We are modifing the file after open - update the stat
1622 if ((SMB_VFS_FTRUNCATE(fsp,fsp->fh->fd,0) == -1) ||
1623 (SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf)==-1)) {
1631 /* Record the options we were opened with. */
1632 fsp->share_access = share_access;
1633 fsp->fh->private_options = create_options;
1634 fsp->access_mask = access_mask;
1637 if (!(flags2 & O_TRUNC)) {
1638 info = FILE_WAS_OPENED;
1640 info = FILE_WAS_OVERWRITTEN;
1643 info = FILE_WAS_CREATED;
1644 /* Change the owner if required. */
1645 if (lp_inherit_owner(SNUM(conn))) {
1646 change_owner_to_parent(conn, fsp, fsp->fsp_name,
1656 * Setup the oplock info in both the shared memory and
1660 if ((fsp->oplock_type != NO_OPLOCK) &&
1661 (fsp->oplock_type != FAKE_LEVEL_II_OPLOCK)) {
1662 if (!set_file_oplock(fsp, fsp->oplock_type)) {
1663 /* Could not get the kernel oplock */
1664 fsp->oplock_type = NO_OPLOCK;
1667 set_share_mode(lck, fsp, 0, fsp->oplock_type);
1669 if (create_options & FILE_DELETE_ON_CLOSE) {
1670 uint32 dosattr= existing_dos_attributes;
1673 if (info == FILE_WAS_OVERWRITTEN || info == FILE_WAS_CREATED ||
1674 info == FILE_WAS_SUPERSEDED) {
1675 dosattr = new_dos_attributes;
1678 result = can_set_delete_on_close(fsp, True, dosattr);
1680 if (!NT_STATUS_IS_OK(result)) {
1681 /* Remember to delete the mode we just added. */
1682 del_share_mode(lck, fsp);
1686 set_saved_ntstatus(result);
1689 lck->delete_on_close = True;
1690 lck->modified = True;
1693 if (info == FILE_WAS_OVERWRITTEN || info == FILE_WAS_CREATED ||
1694 info == FILE_WAS_SUPERSEDED) {
1695 /* Files should be initially set as archive */
1696 if (lp_map_archive(SNUM(conn)) ||
1697 lp_store_dos_attributes(SNUM(conn))) {
1698 file_set_dosmode(conn, fname,
1699 new_dos_attributes | aARCH, NULL,
1705 * Take care of inherited ACLs on created files - if default ACL not
1709 if (!file_existed && !def_acl) {
1711 int saved_errno = errno; /* We might get ENOSYS in the next
1714 if (SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd, unx_mode) == -1
1715 && errno == ENOSYS) {
1716 errno = saved_errno; /* Ignore ENOSYS */
1719 } else if (new_unx_mode) {
1723 /* Attributes need changing. File already existed. */
1726 int saved_errno = errno; /* We might get ENOSYS in the
1728 ret = SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd,
1731 if (ret == -1 && errno == ENOSYS) {
1732 errno = saved_errno; /* Ignore ENOSYS */
1734 DEBUG(5, ("open_file_shared: failed to reset "
1735 "attributes of file %s to 0%o\n",
1736 fname, (unsigned int)new_unx_mode));
1737 ret = 0; /* Don't do the fchmod below. */
1742 (SMB_VFS_FCHMOD(fsp, fsp->fh->fd, new_unx_mode) == -1))
1743 DEBUG(5, ("open_file_shared: failed to reset "
1744 "attributes of file %s to 0%o\n",
1745 fname, (unsigned int)new_unx_mode));
1748 /* If this is a successful open, we must remove any deferred open
1750 del_deferred_open_entry(lck, mid);
1753 conn->num_files_open++;
1758 /****************************************************************************
1759 Open a file for for write to ensure that we can fchmod it.
1760 ****************************************************************************/
1762 files_struct *open_file_fchmod(connection_struct *conn, const char *fname,
1763 SMB_STRUCT_STAT *psbuf)
1765 files_struct *fsp = NULL;
1768 if (!VALID_STAT(*psbuf)) {
1772 fsp = file_new(conn);
1777 /* note! we must use a non-zero desired access or we don't get
1778 a real file descriptor. Oh what a twisted web we weave. */
1779 fsp_open = open_file(fsp,conn,fname,psbuf,O_WRONLY,0,FILE_WRITE_DATA);
1782 * This is not a user visible file open.
1783 * Don't set a share mode and don't increment
1784 * the conn->num_files_open.
1795 /****************************************************************************
1796 Close the fchmod file fd - ensure no locks are lost.
1797 ****************************************************************************/
1799 int close_file_fchmod(files_struct *fsp)
1801 int ret = fd_close(fsp->conn, fsp);
1806 /****************************************************************************
1807 Open a directory from an NT SMB call.
1808 ****************************************************************************/
1810 files_struct *open_directory(connection_struct *conn,
1812 SMB_STRUCT_STAT *psbuf,
1814 uint32 share_access,
1815 uint32 create_disposition,
1816 uint32 create_options,
1819 files_struct *fsp = NULL;
1820 BOOL dir_existed = VALID_STAT(*psbuf) ? True : False;
1821 BOOL create_dir = False;
1824 DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
1825 "share_access = 0x%x create_options = 0x%x, "
1826 "create_disposition = 0x%x\n",
1828 (unsigned int)access_mask,
1829 (unsigned int)share_access,
1830 (unsigned int)create_options,
1831 (unsigned int)create_disposition));
1833 if (is_ntfs_stream_name(fname)) {
1834 DEBUG(0,("open_directory: %s is a stream name!\n", fname ));
1835 set_saved_ntstatus(NT_STATUS_NOT_A_DIRECTORY);
1839 if (dir_existed && !S_ISDIR(psbuf->st_mode)) {
1840 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1841 set_saved_ntstatus(NT_STATUS_NOT_A_DIRECTORY);
1845 switch( create_disposition ) {
1847 /* If directory exists open. If directory doesn't
1850 DEBUG(5,("open_directory: FILE_OPEN requested "
1851 "for directory %s and it doesn't "
1852 "exist.\n", fname ));
1853 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_NOT_FOUND);
1856 info = FILE_WAS_OPENED;
1860 /* If directory exists error. If directory doesn't
1863 DEBUG(5,("open_directory: FILE_CREATE "
1864 "requested for directory %s and it "
1865 "already exists.\n", fname ));
1866 set_saved_error_triple(ERRDOS, ERRfilexists,
1867 NT_STATUS_OBJECT_NAME_COLLISION);
1871 info = FILE_WAS_CREATED;
1875 /* If directory exists open. If directory doesn't
1879 info = FILE_WAS_CREATED;
1881 info = FILE_WAS_OPENED;
1885 case FILE_SUPERSEDE:
1886 case FILE_OVERWRITE:
1887 case FILE_OVERWRITE_IF:
1889 DEBUG(5,("open_directory: invalid create_disposition "
1890 "0x%x for directory %s\n",
1891 (unsigned int)create_disposition, fname));
1893 set_saved_ntstatus(NT_STATUS_INVALID_PARAMETER);
1899 * Try and create the directory.
1902 /* We know bad_path is false as it's caught earlier. */
1904 NTSTATUS status = mkdir_internal(conn, fname, False);
1906 if (!NT_STATUS_IS_OK(status)) {
1907 DEBUG(2,("open_directory: unable to create %s. "
1908 "Error was %s\n", fname, strerror(errno) ));
1909 /* Ensure we return the correct NT status to the
1911 set_saved_error_triple(0, 0, status);
1915 /* Ensure we're checking for a symlink here.... */
1916 /* We don't want to get caught by a symlink racer. */
1918 if(SMB_VFS_LSTAT(conn,fname, psbuf) != 0) {
1922 if(!S_ISDIR(psbuf->st_mode)) {
1923 DEBUG(0,("open_directory: %s is not a directory !\n",
1929 fsp = file_new(conn);
1935 * Setup the files_struct for it.
1938 fsp->mode = psbuf->st_mode;
1939 fsp->inode = psbuf->st_ino;
1940 fsp->dev = psbuf->st_dev;
1941 fsp->vuid = current_user.vuid;
1942 fsp->file_pid = global_smbpid;
1943 fsp->can_lock = True;
1944 fsp->can_read = False;
1945 fsp->can_write = False;
1947 fsp->share_access = share_access;
1948 fsp->fh->private_options = create_options;
1949 fsp->access_mask = access_mask;
1951 fsp->print_file = False;
1952 fsp->modified = False;
1953 fsp->oplock_type = NO_OPLOCK;
1954 fsp->sent_oplock_break = NO_BREAK_SENT;
1955 fsp->is_directory = True;
1956 fsp->is_stat = False;
1957 string_set(&fsp->fsp_name,fname);
1959 if (create_options & FILE_DELETE_ON_CLOSE) {
1960 NTSTATUS status = can_set_delete_on_close(fsp, True, 0);
1961 if (!NT_STATUS_IS_OK(status)) {
1967 /* Change the owner if required. */
1968 if ((info == FILE_WAS_CREATED) && lp_inherit_owner(SNUM(conn))) {
1969 change_owner_to_parent(conn, fsp, fsp->fsp_name, psbuf);
1976 conn->num_files_open++;
1981 /****************************************************************************
1982 Open a pseudo-file (no locking checks - a 'stat' open).
1983 ****************************************************************************/
1985 files_struct *open_file_stat(connection_struct *conn, char *fname,
1986 SMB_STRUCT_STAT *psbuf)
1988 files_struct *fsp = NULL;
1990 if (!VALID_STAT(*psbuf))
1993 /* Can't 'stat' open directories. */
1994 if(S_ISDIR(psbuf->st_mode))
1997 fsp = file_new(conn);
2001 DEBUG(5,("open_file_stat: 'opening' file %s\n", fname));
2004 * Setup the files_struct for it.
2007 fsp->mode = psbuf->st_mode;
2008 fsp->inode = psbuf->st_ino;
2009 fsp->dev = psbuf->st_dev;
2010 fsp->vuid = current_user.vuid;
2011 fsp->file_pid = global_smbpid;
2012 fsp->can_lock = False;
2013 fsp->can_read = False;
2014 fsp->can_write = False;
2015 fsp->print_file = False;
2016 fsp->modified = False;
2017 fsp->oplock_type = NO_OPLOCK;
2018 fsp->sent_oplock_break = NO_BREAK_SENT;
2019 fsp->is_directory = False;
2020 fsp->is_stat = True;
2021 string_set(&fsp->fsp_name,fname);
2023 conn->num_files_open++;