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;
641 if (lck->num_share_modes == 0) {
642 /* No files open at all: Directly grant whatever the client
645 if (fsp->oplock_type == NO_OPLOCK) {
646 /* Store a level2 oplock, but don't tell the client */
647 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
652 for (i=0; i<lck->num_share_modes; i++) {
654 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
658 if (EXCLUSIVE_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
659 SMB_ASSERT(exclusive == NULL);
660 exclusive = &lck->share_modes[i];
663 if (lck->share_modes[i].op_type == LEVEL_II_OPLOCK) {
668 if (exclusive != NULL) { /* Found an exclusive oplock */
669 SMB_ASSERT(!have_level2);
670 delay_it = is_delete_request(fsp) ?
671 BATCH_OPLOCK_TYPE(exclusive->op_type) : True;
674 if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
675 /* We can at most grant level2 */
676 fsp->oplock_type = LEVEL_II_OPLOCK;
679 if ((fsp->oplock_type == NO_OPLOCK) && have_level2) {
680 /* Store a level2 oplock, but don't tell the client */
681 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
685 DEBUG(10, ("Sending break request to PID %s\n",
686 procid_str_static(&exclusive->pid)));
687 exclusive->op_mid = get_current_mid();
688 if (!message_send_pid(exclusive->pid, MSG_SMB_BREAK_REQUEST,
689 exclusive, sizeof(*exclusive), True)) {
690 DEBUG(3, ("Could not send oplock break message\n"));
698 static BOOL request_timed_out(struct timeval request_time,
699 struct timeval timeout)
701 struct timeval now, end_time;
703 end_time = timeval_sum(&request_time, &timeout);
704 return (timeval_compare(&end_time, &now) < 0);
707 /****************************************************************************
708 Handle the 1 second delay in returning a SHARING_VIOLATION error.
709 ****************************************************************************/
711 static void defer_open(struct share_mode_lock *lck,
712 struct timeval request_time,
713 struct timeval timeout,
714 struct deferred_open_record *state)
716 uint16 mid = get_current_mid();
721 for (i=0; i<lck->num_share_modes; i++) {
722 struct share_mode_entry *e = &lck->share_modes[i];
724 if (!is_deferred_open_entry(e)) {
728 if (procid_is_me(&e->pid) && (e->op_mid == mid)) {
729 DEBUG(0, ("Trying to defer an already deferred "
730 "request: mid=%d, exiting\n", mid));
731 exit_server("exiting");
735 /* End paranoia check */
737 DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred "
738 "open entry for mid %u\n",
739 (unsigned int)request_time.tv_sec,
740 (unsigned int)request_time.tv_usec,
743 if (!push_deferred_smb_message(mid, request_time, timeout,
744 (char *)state, sizeof(*state))) {
745 exit_server("push_deferred_smb_message failed\n");
747 add_deferred_open(lck, mid, request_time, state->dev, state->inode);
750 * Push the MID of this packet on the signing queue.
751 * We only do this once, the first time we push the packet
752 * onto the deferred open queue, as this has a side effect
753 * of incrementing the response sequence number.
756 srv_defer_sign_response(mid);
759 /****************************************************************************
760 Set a kernel flock on a file for NFS interoperability.
761 This requires a patch to Linux.
762 ****************************************************************************/
764 static void kernel_flock(files_struct *fsp, uint32 share_mode)
766 #if HAVE_KERNEL_SHARE_MODES
768 if (share_mode == FILE_SHARE_WRITE) {
769 kernel_mode = LOCK_MAND|LOCK_WRITE;
770 } else if (share_mode == FILE_SHARE_READ) {
771 kernel_mode = LOCK_MAND|LOCK_READ;
772 } else if (share_mode == FILE_SHARE_NONE) {
773 kernel_mode = LOCK_MAND;
776 flock(fsp->fh->fd, kernel_mode);
782 /****************************************************************************
783 On overwrite open ensure that the attributes match.
784 ****************************************************************************/
786 static BOOL open_match_attributes(connection_struct *conn,
790 mode_t existing_unx_mode,
792 mode_t *returned_unx_mode)
794 uint32 noarch_old_dos_attr, noarch_new_dos_attr;
796 noarch_old_dos_attr = (old_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
797 noarch_new_dos_attr = (new_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
799 if((noarch_old_dos_attr == 0 && noarch_new_dos_attr != 0) ||
800 (noarch_old_dos_attr != 0 && ((noarch_old_dos_attr & noarch_new_dos_attr) == noarch_old_dos_attr))) {
801 *returned_unx_mode = new_unx_mode;
803 *returned_unx_mode = (mode_t)0;
806 DEBUG(10,("open_match_attributes: file %s old_dos_attr = 0x%x, "
807 "existing_unx_mode = 0%o, new_dos_attr = 0x%x "
808 "returned_unx_mode = 0%o\n",
810 (unsigned int)old_dos_attr,
811 (unsigned int)existing_unx_mode,
812 (unsigned int)new_dos_attr,
813 (unsigned int)*returned_unx_mode ));
815 /* If we're mapping SYSTEM and HIDDEN ensure they match. */
816 if (lp_map_system(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
817 if ((old_dos_attr & FILE_ATTRIBUTE_SYSTEM) &&
818 !(new_dos_attr & FILE_ATTRIBUTE_SYSTEM)) {
822 if (lp_map_hidden(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
823 if ((old_dos_attr & FILE_ATTRIBUTE_HIDDEN) &&
824 !(new_dos_attr & FILE_ATTRIBUTE_HIDDEN)) {
831 /****************************************************************************
832 Special FCB or DOS processing in the case of a sharing violation.
833 Try and find a duplicated file handle.
834 ****************************************************************************/
836 static files_struct *fcb_or_dos_open(connection_struct *conn,
837 const char *fname, SMB_DEV_T dev,
841 uint32 create_options)
844 files_struct *dup_fsp;
846 DEBUG(5,("fcb_or_dos_open: attempting old open semantics for "
847 "file %s.\n", fname ));
849 for(fsp = file_find_di_first(dev, inode); fsp;
850 fsp = file_find_di_next(fsp)) {
852 DEBUG(10,("fcb_or_dos_open: checking file %s, fd = %d, "
853 "vuid = %u, file_pid = %u, private_options = 0x%x "
854 "access_mask = 0x%x\n", fsp->fsp_name,
855 fsp->fh->fd, (unsigned int)fsp->vuid,
856 (unsigned int)fsp->file_pid,
857 (unsigned int)fsp->fh->private_options,
858 (unsigned int)fsp->access_mask ));
860 if (fsp->fh->fd != -1 &&
861 fsp->vuid == current_user.vuid &&
862 fsp->file_pid == global_smbpid &&
863 (fsp->fh->private_options & (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS |
864 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) &&
865 (fsp->access_mask & FILE_WRITE_DATA) &&
866 strequal(fsp->fsp_name, fname)) {
867 DEBUG(10,("fcb_or_dos_open: file match\n"));
876 /* quite an insane set of semantics ... */
877 if (is_executable(fname) &&
878 (fsp->fh->private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS)) {
879 DEBUG(10,("fcb_or_dos_open: file fail due to is_executable.\n"));
883 /* We need to duplicate this fsp. */
884 dup_fsp = dup_file_fsp(fsp, access_mask, share_access, create_options);
892 /****************************************************************************
893 Open a file with a share mode - old openX method - map into NTCreate.
894 ****************************************************************************/
896 BOOL map_open_params_to_ntcreate(const char *fname, int deny_mode, int open_func,
897 uint32 *paccess_mask,
899 uint32 *pcreate_disposition,
900 uint32 *pcreate_options)
904 uint32 create_disposition;
905 uint32 create_options = 0;
907 DEBUG(10,("map_open_params_to_ntcreate: fname = %s, deny_mode = 0x%x, "
908 "open_func = 0x%x\n",
909 fname, (unsigned int)deny_mode, (unsigned int)open_func ));
911 /* Create the NT compatible access_mask. */
912 switch (GET_OPENX_MODE(deny_mode)) {
913 case DOS_OPEN_EXEC: /* Implies read-only - used to be FILE_READ_DATA */
914 case DOS_OPEN_RDONLY:
915 access_mask = FILE_GENERIC_READ;
917 case DOS_OPEN_WRONLY:
918 access_mask = FILE_GENERIC_WRITE;
922 access_mask = FILE_GENERIC_READ|FILE_GENERIC_WRITE;
925 DEBUG(10,("map_open_params_to_ntcreate: bad open mode = 0x%x\n",
926 (unsigned int)GET_OPENX_MODE(deny_mode)));
930 /* Create the NT compatible create_disposition. */
932 case OPENX_FILE_EXISTS_FAIL|OPENX_FILE_CREATE_IF_NOT_EXIST:
933 create_disposition = FILE_CREATE;
936 case OPENX_FILE_EXISTS_OPEN:
937 create_disposition = FILE_OPEN;
940 case OPENX_FILE_EXISTS_OPEN|OPENX_FILE_CREATE_IF_NOT_EXIST:
941 create_disposition = FILE_OPEN_IF;
944 case OPENX_FILE_EXISTS_TRUNCATE:
945 create_disposition = FILE_OVERWRITE;
948 case OPENX_FILE_EXISTS_TRUNCATE|OPENX_FILE_CREATE_IF_NOT_EXIST:
949 create_disposition = FILE_OVERWRITE_IF;
953 /* From samba4 - to be confirmed. */
954 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_EXEC) {
955 create_disposition = FILE_CREATE;
958 DEBUG(10,("map_open_params_to_ntcreate: bad "
959 "open_func 0x%x\n", (unsigned int)open_func));
963 /* Create the NT compatible share modes. */
964 switch (GET_DENY_MODE(deny_mode)) {
966 share_mode = FILE_SHARE_NONE;
970 share_mode = FILE_SHARE_READ;
974 share_mode = FILE_SHARE_WRITE;
978 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
982 create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
983 if (is_executable(fname)) {
984 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
986 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_RDONLY) {
987 share_mode = FILE_SHARE_READ;
989 share_mode = FILE_SHARE_NONE;
995 create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
996 share_mode = FILE_SHARE_NONE;
1000 DEBUG(10,("map_open_params_to_ntcreate: bad deny_mode 0x%x\n",
1001 (unsigned int)GET_DENY_MODE(deny_mode) ));
1005 DEBUG(10,("map_open_params_to_ntcreate: file %s, access_mask = 0x%x, "
1006 "share_mode = 0x%x, create_disposition = 0x%x, "
1007 "create_options = 0x%x\n",
1009 (unsigned int)access_mask,
1010 (unsigned int)share_mode,
1011 (unsigned int)create_disposition,
1012 (unsigned int)create_options ));
1015 *paccess_mask = access_mask;
1018 *pshare_mode = share_mode;
1020 if (pcreate_disposition) {
1021 *pcreate_disposition = create_disposition;
1023 if (pcreate_options) {
1024 *pcreate_options = create_options;
1031 /* Map generic permissions to file object specific permissions */
1033 struct generic_mapping file_generic_mapping = {
1036 FILE_GENERIC_EXECUTE,
1040 /****************************************************************************
1041 Open a file with a share mode.
1042 ****************************************************************************/
1044 files_struct *open_file_ntcreate(connection_struct *conn,
1046 SMB_STRUCT_STAT *psbuf,
1047 uint32 access_mask, /* access bits (FILE_READ_DATA etc.) */
1048 uint32 share_access, /* share constants (FILE_SHARE_READ etc). */
1049 uint32 create_disposition, /* FILE_OPEN_IF etc. */
1050 uint32 create_options, /* options such as delete on close. */
1051 uint32 new_dos_attributes, /* attributes used for new file. */
1052 int oplock_request, /* internal Samba oplock codes. */
1053 /* Information (FILE_EXISTS etc.) */
1058 BOOL file_existed = VALID_STAT(*psbuf);
1059 BOOL def_acl = False;
1060 BOOL internal_only_open = False;
1062 SMB_INO_T inode = 0;
1063 BOOL fsp_open = False;
1064 files_struct *fsp = NULL;
1065 mode_t new_unx_mode = (mode_t)0;
1066 mode_t unx_mode = (mode_t)0;
1068 uint32 existing_dos_attributes = 0;
1069 struct pending_message_list *pml = NULL;
1070 uint16 mid = get_current_mid();
1071 BOOL delayed_for_oplocks = False;
1072 struct timeval request_time = timeval_zero();
1073 struct share_mode_lock *lck = NULL;
1076 if (conn->printer) {
1078 * Printers are handled completely differently.
1079 * Most of the passed parameters are ignored.
1083 *pinfo = FILE_WAS_CREATED;
1086 DEBUG(10, ("open_file_ntcreate: printer open fname=%s\n", fname));
1088 return print_fsp_open(conn, fname);
1091 /* We add aARCH to this as this mode is only used if the file is
1093 unx_mode = unix_mode(conn, new_dos_attributes | aARCH,fname, True);
1095 DEBUG(10, ("open_file_ntcreate: fname=%s, dos_attrs=0x%x "
1096 "access_mask=0x%x share_access=0x%x "
1097 "create_disposition = 0x%x create_options=0x%x "
1098 "unix mode=0%o oplock_request=%d\n",
1099 fname, new_dos_attributes, access_mask, share_access,
1100 create_disposition, create_options, unx_mode,
1103 if (oplock_request == INTERNAL_OPEN_ONLY) {
1104 internal_only_open = True;
1108 if ((pml = get_open_deferred_message(mid)) != NULL) {
1109 struct deferred_open_record *state =
1110 (struct deferred_open_record *)pml->private_data.data;
1112 request_time = pml->request_time;
1113 delayed_for_oplocks = state->delayed_for_oplocks;
1115 /* There could be a race condition where the dev/inode pair
1116 has changed since we deferred the message. If so, just
1117 remove the deferred open entry and return sharing
1120 /* If the timeout value is non-zero, we need to just return
1121 sharing violation. Don't retry the open as we were not
1122 notified of a close and we don't want to trigger another
1123 spurious oplock break. */
1125 /* Now remove the deferred open entry under lock. */
1126 lck = get_share_mode_lock(NULL, state->dev, state->inode, NULL, NULL);
1128 DEBUG(0, ("could not get share mode lock\n"));
1130 del_deferred_open_entry(lck, mid);
1131 talloc_destroy(lck);
1134 /* Ensure we don't reprocess this message. */
1135 remove_deferred_open_smb_message(mid);
1138 if (!check_name(fname,conn)) {
1142 new_dos_attributes &= SAMBA_ATTRIBUTES_MASK;
1144 existing_dos_attributes = dos_mode(conn, fname, psbuf);
1147 /* ignore any oplock requests if oplocks are disabled */
1148 if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break ||
1149 IS_VETO_OPLOCK_PATH(conn, fname)) {
1153 /* this is for OS/2 long file names - say we don't support them */
1154 if (!lp_posix_pathnames() && strstr(fname,".+,;=[].")) {
1155 /* OS/2 Workplace shell fix may be main code stream in a later
1157 set_saved_error_triple(ERRDOS, ERRcannotopen,
1158 NT_STATUS_OBJECT_NAME_NOT_FOUND);
1159 DEBUG(5,("open_file_ntcreate: OS/2 long filenames are not "
1164 switch( create_disposition ) {
1166 * Currently we're using FILE_SUPERSEDE as the same as
1167 * FILE_OVERWRITE_IF but they really are
1168 * different. FILE_SUPERSEDE deletes an existing file
1169 * (requiring delete access) then recreates it.
1171 case FILE_SUPERSEDE:
1172 /* If file exists replace/overwrite. If file doesn't
1174 flags2 |= (O_CREAT | O_TRUNC);
1177 case FILE_OVERWRITE_IF:
1178 /* If file exists replace/overwrite. If file doesn't
1180 flags2 |= (O_CREAT | O_TRUNC);
1184 /* If file exists open. If file doesn't exist error. */
1185 if (!file_existed) {
1186 DEBUG(5,("open_file_ntcreate: FILE_OPEN "
1187 "requested for file %s and file "
1188 "doesn't exist.\n", fname ));
1189 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_NOT_FOUND);
1195 case FILE_OVERWRITE:
1196 /* If file exists overwrite. If file doesn't exist
1198 if (!file_existed) {
1199 DEBUG(5,("open_file_ntcreate: FILE_OVERWRITE "
1200 "requested for file %s and file "
1201 "doesn't exist.\n", fname ));
1202 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_NOT_FOUND);
1210 /* If file exists error. If file doesn't exist
1213 DEBUG(5,("open_file_ntcreate: FILE_CREATE "
1214 "requested for file %s and file "
1215 "already exists.\n", fname ));
1216 if (S_ISDIR(psbuf->st_mode)) {
1223 flags2 |= (O_CREAT|O_EXCL);
1227 /* If file exists open. If file doesn't exist
1233 set_saved_ntstatus(NT_STATUS_INVALID_PARAMETER);
1237 /* We only care about matching attributes on file exists and
1240 if (file_existed && ((create_disposition == FILE_OVERWRITE) ||
1241 (create_disposition == FILE_OVERWRITE_IF))) {
1242 if (!open_match_attributes(conn, fname,
1243 existing_dos_attributes,
1244 new_dos_attributes, psbuf->st_mode,
1245 unx_mode, &new_unx_mode)) {
1246 DEBUG(5,("open_file_ntcreate: attributes missmatch "
1247 "for file %s (%x %x) (0%o, 0%o)\n",
1248 fname, existing_dos_attributes,
1250 (unsigned int)psbuf->st_mode,
1251 (unsigned int)unx_mode ));
1257 /* This is a nasty hack - must fix... JRA. */
1258 if (access_mask == MAXIMUM_ALLOWED_ACCESS) {
1259 access_mask = FILE_GENERIC_ALL;
1263 * Convert GENERIC bits to specific bits.
1266 se_map_generic(&access_mask, &file_generic_mapping);
1268 DEBUG(10, ("open_file_ntcreate: fname=%s, after mapping "
1269 "access_mask=0x%x\n", fname, access_mask ));
1272 * Note that we ignore the append flag as append does not
1273 * mean the same thing under DOS and Unix.
1276 if (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) {
1283 * Currently we only look at FILE_WRITE_THROUGH for create options.
1287 if (create_options & FILE_WRITE_THROUGH) {
1292 if (!CAN_WRITE(conn)) {
1294 * We should really return a permission denied error if either
1295 * O_CREAT or O_TRUNC are set, but for compatibility with
1296 * older versions of Samba we just AND them out.
1298 flags2 &= ~(O_CREAT|O_TRUNC);
1302 * Ensure we can't write on a read-only share or file.
1305 if (flags != O_RDONLY && file_existed &&
1306 (!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_attributes))) {
1307 DEBUG(5,("open_file_ntcreate: write access requested for "
1308 "file %s on read only %s\n",
1309 fname, !CAN_WRITE(conn) ? "share" : "file" ));
1310 set_saved_ntstatus(NT_STATUS_ACCESS_DENIED);
1315 fsp = file_new(conn);
1320 fsp->dev = psbuf->st_dev;
1321 fsp->inode = psbuf->st_ino;
1322 fsp->share_access = share_access;
1323 fsp->fh->private_options = create_options;
1324 fsp->access_mask = access_mask;
1325 fsp->oplock_type = oplock_request;
1327 if (timeval_is_zero(&request_time)) {
1328 request_time = fsp->open_time;
1333 dev = psbuf->st_dev;
1334 inode = psbuf->st_ino;
1336 lck = get_share_mode_lock(NULL, dev, inode,
1341 DEBUG(0, ("Could not get share mode lock\n"));
1342 set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1346 if (delay_for_oplocks(lck, fsp)) {
1347 struct deferred_open_record state;
1348 struct timeval timeout;
1350 if (delayed_for_oplocks) {
1351 DEBUG(0, ("Trying to delay for oplocks "
1353 exit_server("exiting");
1356 timeout = timeval_set(OPLOCK_BREAK_TIMEOUT*2, 0);
1358 /* Normally the smbd we asked should respond within
1359 * OPLOCK_BREAK_TIMEOUT seconds regardless of whether
1360 * the client did, give twice the timeout as a safety
1361 * measure here in case the other smbd is stuck
1362 * somewhere else. */
1364 state.delayed_for_oplocks = True;
1366 state.inode = inode;
1368 if (!request_timed_out(request_time, timeout)) {
1369 defer_open(lck, request_time, timeout,
1377 status = open_mode_check(conn, fname, lck,
1378 access_mask, share_access,
1379 create_options, &file_existed);
1381 if (NT_STATUS_EQUAL(status, NT_STATUS_DELETE_PENDING)) {
1382 /* DELETE_PENDING is not deferred for a second */
1383 set_saved_ntstatus(status);
1389 if (!NT_STATUS_IS_OK(status)) {
1391 SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION));
1393 /* Check if this can be done with the deny_dos and fcb
1395 if (create_options &
1396 (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS|
1397 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
1398 files_struct *fsp_dup;
1399 fsp_dup = fcb_or_dos_open(conn, fname, dev,
1408 *pinfo = FILE_WAS_OPENED;
1410 conn->num_files_open++;
1416 * This next line is a subtlety we need for
1417 * MS-Access. If a file open will fail due to share
1418 * permissions and also for security (access) reasons,
1419 * we need to return the access failed error, not the
1420 * share error. This means we must attempt to open the
1421 * file anyway in order to get the UNIX access error -
1422 * even if we're going to fail the open for share
1423 * reasons. This is bad, as we're burning another fd
1424 * if there are existing locks but there's nothing
1425 * else we can do. We also ensure we're not going to
1426 * create or tuncate the file as we only want an
1427 * access decision at this stage. JRA.
1430 fsp_open = open_file(fsp,conn,fname,psbuf,
1431 flags|(flags2&~(O_TRUNC|O_CREAT)),
1432 unx_mode,access_mask);
1434 DEBUG(4,("open_file_ntcreate : share_mode deny - "
1435 "calling open_file with flags=0x%X "
1436 "flags2=0x%X mode=0%o returned %d\n",
1437 flags, (flags2&~(O_TRUNC|O_CREAT)),
1438 (unsigned int)unx_mode, (int)fsp_open ));
1440 if (!fsp_open && errno) {
1441 /* Default error. */
1442 set_saved_ntstatus(NT_STATUS_ACCESS_DENIED);
1446 * If we're returning a share violation, ensure we
1447 * cope with the braindead 1 second delay.
1450 if (!internal_only_open &&
1451 lp_defer_sharing_violations()) {
1452 struct timeval timeout;
1453 struct deferred_open_record state;
1455 timeout = timeval_set(0, SHARING_VIOLATION_USEC_WAIT);
1457 state.delayed_for_oplocks = False;
1459 state.inode = inode;
1461 if (!request_timed_out(request_time,
1463 defer_open(lck, request_time, timeout,
1470 fd_close(conn, fsp);
1472 * We have detected a sharing violation here
1473 * so return the correct error code
1475 set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1482 * We exit this block with the share entry *locked*.....
1486 SMB_ASSERT(!file_existed || (lck != NULL));
1489 * Ensure we pay attention to default ACLs on directories if required.
1492 if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
1493 (def_acl = directory_has_default_acl(conn,
1494 parent_dirname(fname)))) {
1498 DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
1499 (unsigned int)flags, (unsigned int)flags2,
1500 (unsigned int)unx_mode));
1503 * open_file strips any O_TRUNC flags itself.
1506 fsp_open = open_file(fsp,conn,fname,psbuf,flags|flags2,unx_mode,
1517 if (!file_existed) {
1520 * Deal with the race condition where two smbd's detect the
1521 * file doesn't exist and do the create at the same time. One
1522 * of them will win and set a share mode, the other (ie. this
1523 * one) should check if the requested share mode for this
1524 * create is allowed.
1528 * Now the file exists and fsp is successfully opened,
1529 * fsp->dev and fsp->inode are valid and should replace the
1530 * dev=0,inode=0 from a non existent file. Spotted by
1531 * Nadav Danieli <nadavd@exanet.com>. JRA.
1537 lck = get_share_mode_lock(NULL, dev, inode,
1542 DEBUG(0, ("open_file_ntcreate: Could not get share mode lock for %s\n", fname));
1543 fd_close(conn, fsp);
1545 set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1549 status = open_mode_check(conn, fname, lck,
1550 access_mask, share_access,
1551 create_options, &file_existed);
1553 if (!NT_STATUS_IS_OK(status)) {
1554 struct deferred_open_record state;
1556 fd_close(conn, fsp);
1559 state.delayed_for_oplocks = False;
1561 state.inode = inode;
1563 /* Do it all over again immediately. In the second
1564 * round we will find that the file existed and handle
1565 * the DELETE_PENDING and FCB cases correctly. No need
1566 * to duplicate the code here. Essentially this is a
1567 * "goto top of this function", but don't tell
1570 defer_open(lck, request_time, timeval_zero(),
1577 * We exit this block with the share entry *locked*.....
1581 SMB_ASSERT(lck != NULL);
1583 /* note that we ignore failure for the following. It is
1584 basically a hack for NFS, and NFS will never set one of
1585 these only read them. Nobody but Samba can ever set a deny
1586 mode and we have already checked our more authoritative
1587 locking database for permission to set this deny mode. If
1588 the kernel refuses the operations then the kernel is wrong */
1590 kernel_flock(fsp, share_access);
1593 * At this point onwards, we can guarentee that the share entry
1594 * is locked, whether we created the file or not, and that the
1595 * deny mode is compatible with all current opens.
1599 * If requested, truncate the file.
1602 if (flags2&O_TRUNC) {
1604 * We are modifing the file after open - update the stat
1607 if ((SMB_VFS_FTRUNCATE(fsp,fsp->fh->fd,0) == -1) ||
1608 (SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf)==-1)) {
1616 /* Record the options we were opened with. */
1617 fsp->share_access = share_access;
1618 fsp->fh->private_options = create_options;
1619 fsp->access_mask = access_mask;
1622 if (!(flags2 & O_TRUNC)) {
1623 info = FILE_WAS_OPENED;
1625 info = FILE_WAS_OVERWRITTEN;
1628 info = FILE_WAS_CREATED;
1629 /* Change the owner if required. */
1630 if (lp_inherit_owner(SNUM(conn))) {
1631 change_owner_to_parent(conn, fsp, fsp->fsp_name,
1641 * Setup the oplock info in both the shared memory and
1645 if ((fsp->oplock_type != NO_OPLOCK) &&
1646 (fsp->oplock_type != FAKE_LEVEL_II_OPLOCK)) {
1647 if (!set_file_oplock(fsp, fsp->oplock_type)) {
1648 /* Could not get the kernel oplock */
1649 fsp->oplock_type = NO_OPLOCK;
1652 set_share_mode(lck, fsp, 0, fsp->oplock_type);
1654 if (create_options & FILE_DELETE_ON_CLOSE) {
1655 uint32 dosattr= existing_dos_attributes;
1658 if (info == FILE_WAS_OVERWRITTEN || info == FILE_WAS_CREATED ||
1659 info == FILE_WAS_SUPERSEDED) {
1660 dosattr = new_dos_attributes;
1663 result = can_set_delete_on_close(fsp, True, dosattr);
1665 if (!NT_STATUS_IS_OK(result)) {
1666 /* Remember to delete the mode we just added. */
1667 del_share_mode(lck, fsp);
1671 set_saved_ntstatus(result);
1674 lck->delete_on_close = True;
1675 lck->modified = True;
1678 if (info == FILE_WAS_OVERWRITTEN || info == FILE_WAS_CREATED ||
1679 info == FILE_WAS_SUPERSEDED) {
1680 /* Files should be initially set as archive */
1681 if (lp_map_archive(SNUM(conn)) ||
1682 lp_store_dos_attributes(SNUM(conn))) {
1683 file_set_dosmode(conn, fname,
1684 new_dos_attributes | aARCH, NULL,
1690 * Take care of inherited ACLs on created files - if default ACL not
1694 if (!file_existed && !def_acl) {
1696 int saved_errno = errno; /* We might get ENOSYS in the next
1699 if (SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd, unx_mode) == -1
1700 && errno == ENOSYS) {
1701 errno = saved_errno; /* Ignore ENOSYS */
1704 } else if (new_unx_mode) {
1708 /* Attributes need changing. File already existed. */
1711 int saved_errno = errno; /* We might get ENOSYS in the
1713 ret = SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd,
1716 if (ret == -1 && errno == ENOSYS) {
1717 errno = saved_errno; /* Ignore ENOSYS */
1719 DEBUG(5, ("open_file_shared: reset "
1720 "attributes of file %s to 0%o\n",
1721 fname, (unsigned int)new_unx_mode));
1722 ret = 0; /* Don't do the fchmod below. */
1727 (SMB_VFS_FCHMOD(fsp, fsp->fh->fd, new_unx_mode) == -1))
1728 DEBUG(5, ("open_file_shared: failed to reset "
1729 "attributes of file %s to 0%o\n",
1730 fname, (unsigned int)new_unx_mode));
1733 /* If this is a successful open, we must remove any deferred open
1735 del_deferred_open_entry(lck, mid);
1738 conn->num_files_open++;
1743 /****************************************************************************
1744 Open a file for for write to ensure that we can fchmod it.
1745 ****************************************************************************/
1747 files_struct *open_file_fchmod(connection_struct *conn, const char *fname,
1748 SMB_STRUCT_STAT *psbuf)
1750 files_struct *fsp = NULL;
1753 if (!VALID_STAT(*psbuf)) {
1757 fsp = file_new(conn);
1762 /* note! we must use a non-zero desired access or we don't get
1763 a real file descriptor. Oh what a twisted web we weave. */
1764 fsp_open = open_file(fsp,conn,fname,psbuf,O_WRONLY,0,FILE_WRITE_DATA);
1767 * This is not a user visible file open.
1768 * Don't set a share mode and don't increment
1769 * the conn->num_files_open.
1780 /****************************************************************************
1781 Close the fchmod file fd - ensure no locks are lost.
1782 ****************************************************************************/
1784 int close_file_fchmod(files_struct *fsp)
1786 int ret = fd_close(fsp->conn, fsp);
1791 /****************************************************************************
1792 Open a directory from an NT SMB call.
1793 ****************************************************************************/
1795 files_struct *open_directory(connection_struct *conn,
1797 SMB_STRUCT_STAT *psbuf,
1799 uint32 share_access,
1800 uint32 create_disposition,
1801 uint32 create_options,
1804 files_struct *fsp = NULL;
1805 BOOL dir_existed = VALID_STAT(*psbuf) ? True : False;
1806 BOOL create_dir = False;
1807 struct share_mode_lock *lck = NULL;
1811 DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
1812 "share_access = 0x%x create_options = 0x%x, "
1813 "create_disposition = 0x%x\n",
1815 (unsigned int)access_mask,
1816 (unsigned int)share_access,
1817 (unsigned int)create_options,
1818 (unsigned int)create_disposition));
1820 if (is_ntfs_stream_name(fname)) {
1821 DEBUG(0,("open_directory: %s is a stream name!\n", fname ));
1822 set_saved_ntstatus(NT_STATUS_NOT_A_DIRECTORY);
1826 if (dir_existed && !S_ISDIR(psbuf->st_mode)) {
1827 DEBUG(0,("open_directory: %s is not a directory !\n", fname ));
1828 set_saved_ntstatus(NT_STATUS_NOT_A_DIRECTORY);
1832 switch( create_disposition ) {
1834 /* If directory exists open. If directory doesn't
1837 DEBUG(5,("open_directory: FILE_OPEN requested "
1838 "for directory %s and it doesn't "
1839 "exist.\n", fname ));
1840 set_saved_ntstatus(NT_STATUS_OBJECT_NAME_NOT_FOUND);
1843 info = FILE_WAS_OPENED;
1847 /* If directory exists error. If directory doesn't
1850 DEBUG(5,("open_directory: FILE_CREATE "
1851 "requested for directory %s and it "
1852 "already exists.\n", fname ));
1853 set_saved_error_triple(ERRDOS, ERRfilexists,
1854 NT_STATUS_OBJECT_NAME_COLLISION);
1858 info = FILE_WAS_CREATED;
1862 /* If directory exists open. If directory doesn't
1866 info = FILE_WAS_CREATED;
1868 info = FILE_WAS_OPENED;
1872 case FILE_SUPERSEDE:
1873 case FILE_OVERWRITE:
1874 case FILE_OVERWRITE_IF:
1876 DEBUG(5,("open_directory: invalid create_disposition "
1877 "0x%x for directory %s\n",
1878 (unsigned int)create_disposition, fname));
1880 set_saved_ntstatus(NT_STATUS_INVALID_PARAMETER);
1886 * Try and create the directory.
1889 /* We know bad_path is false as it's caught earlier. */
1891 status = mkdir_internal(conn, fname, False);
1893 if (!NT_STATUS_IS_OK(status)) {
1894 DEBUG(2,("open_directory: unable to create %s. "
1895 "Error was %s\n", fname, strerror(errno) ));
1896 /* Ensure we return the correct NT status to the
1898 set_saved_error_triple(0, 0, status);
1902 /* Ensure we're checking for a symlink here.... */
1903 /* We don't want to get caught by a symlink racer. */
1905 if(SMB_VFS_LSTAT(conn,fname, psbuf) != 0) {
1909 if(!S_ISDIR(psbuf->st_mode)) {
1910 DEBUG(0,("open_directory: %s is not a directory !\n",
1916 fsp = file_new(conn);
1922 * Setup the files_struct for it.
1925 fsp->mode = psbuf->st_mode;
1926 fsp->inode = psbuf->st_ino;
1927 fsp->dev = psbuf->st_dev;
1928 fsp->vuid = current_user.vuid;
1929 fsp->file_pid = global_smbpid;
1930 fsp->can_lock = True;
1931 fsp->can_read = False;
1932 fsp->can_write = False;
1934 fsp->share_access = share_access;
1935 fsp->fh->private_options = create_options;
1936 fsp->access_mask = access_mask;
1938 fsp->print_file = False;
1939 fsp->modified = False;
1940 fsp->oplock_type = NO_OPLOCK;
1941 fsp->sent_oplock_break = NO_BREAK_SENT;
1942 fsp->is_directory = True;
1943 fsp->is_stat = False;
1944 string_set(&fsp->fsp_name,fname);
1946 lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode,
1951 DEBUG(0, ("open_directory: Could not get share mode lock for %s\n", fname));
1953 set_saved_ntstatus(NT_STATUS_SHARING_VIOLATION);
1957 status = open_mode_check(conn, fname, lck,
1958 access_mask, share_access,
1959 create_options, &dir_existed);
1961 if (!NT_STATUS_IS_OK(status)) {
1962 set_saved_ntstatus(status);
1968 set_share_mode(lck, fsp, 0, NO_OPLOCK);
1970 if (create_options & FILE_DELETE_ON_CLOSE) {
1971 status = can_set_delete_on_close(fsp, True, 0);
1972 if (!NT_STATUS_IS_OK(status)) {
1973 set_saved_ntstatus(status);
1979 lck->delete_on_close = True;
1980 lck->modified = True;
1985 /* Change the owner if required. */
1986 if ((info == FILE_WAS_CREATED) && lp_inherit_owner(SNUM(conn))) {
1987 change_owner_to_parent(conn, fsp, fsp->fsp_name, psbuf);
1994 conn->num_files_open++;
1999 /****************************************************************************
2000 Open a pseudo-file (no locking checks - a 'stat' open).
2001 ****************************************************************************/
2003 files_struct *open_file_stat(connection_struct *conn, char *fname,
2004 SMB_STRUCT_STAT *psbuf)
2006 files_struct *fsp = NULL;
2008 if (!VALID_STAT(*psbuf))
2011 /* Can't 'stat' open directories. */
2012 if(S_ISDIR(psbuf->st_mode))
2015 fsp = file_new(conn);
2019 DEBUG(5,("open_file_stat: 'opening' file %s\n", fname));
2022 * Setup the files_struct for it.
2025 fsp->mode = psbuf->st_mode;
2026 fsp->inode = psbuf->st_ino;
2027 fsp->dev = psbuf->st_dev;
2028 fsp->vuid = current_user.vuid;
2029 fsp->file_pid = global_smbpid;
2030 fsp->can_lock = False;
2031 fsp->can_read = False;
2032 fsp->can_write = False;
2033 fsp->print_file = False;
2034 fsp->modified = False;
2035 fsp->oplock_type = NO_OPLOCK;
2036 fsp->sent_oplock_break = NO_BREAK_SENT;
2037 fsp->is_directory = False;
2038 fsp->is_stat = True;
2039 string_set(&fsp->fsp_name,fname);
2041 conn->num_files_open++;
2046 /****************************************************************************
2047 Receive notification that one of our open files has been renamed by another
2049 ****************************************************************************/
2051 void msg_file_was_renamed(int msg_type, struct process_id src, void *buf, size_t len)
2054 struct file_renamed_message *frm = (struct file_renamed_message *)buf;
2055 const char *sharepath;
2056 const char *newname;
2059 if (buf == NULL || len < sizeof(*frm)) {
2060 DEBUG(0, ("msg_file_was_renamed: Got invalid msg len %d\n", (int)len));
2064 sharepath = &frm->names[0];
2065 newname = sharepath + strlen(sharepath) + 1;
2066 sp_len = strlen(sharepath);
2068 DEBUG(10,("msg_file_was_renamed: Got rename message for sharepath %s, new name %s, "
2069 "dev %x, inode %.0f\n",
2070 sharepath, newname, (unsigned int)frm->dev, (double)frm->inode ));
2072 for(fsp = file_find_di_first(frm->dev, frm->inode); fsp; fsp = file_find_di_next(fsp)) {
2073 if (memcmp(fsp->conn->connectpath, sharepath, sp_len) == 0) {
2074 DEBUG(10,("msg_file_was_renamed: renaming file fnum %d from %s -> %s\n",
2075 fsp->fnum, fsp->fsp_name, newname ));
2076 string_set(&fsp->fsp_name, newname);
2079 /* Now we have the complete path we can work out if this is
2080 actually within this share and adjust newname accordingly. */
2081 DEBUG(10,("msg_file_was_renamed: share mismatch (sharepath %s "
2082 "not sharepath %s) "
2083 "fnum %d from %s -> %s\n",
2084 fsp->conn->connectpath,