2 Unix SMB/CIFS implementation.
3 file opening and share modes
4 Copyright (C) Andrew Tridgell 1992-1998
5 Copyright (C) Jeremy Allison 2001-2004
6 Copyright (C) Volker Lendecke 2005
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "system/filesys.h"
25 #include "smbd/smbd.h"
26 #include "smbd/globals.h"
27 #include "fake_file.h"
28 #include "../libcli/security/security.h"
29 #include "../librpc/gen_ndr/ndr_security.h"
30 #include "../librpc/gen_ndr/open_files.h"
31 #include "../librpc/gen_ndr/idmap.h"
32 #include "../librpc/gen_ndr/ioctl.h"
33 #include "passdb/lookup_sid.h"
37 #include "source3/lib/dbwrap/dbwrap_watch.h"
39 extern const struct generic_mapping file_generic_mapping
;
41 struct deferred_open_record
{
42 bool delayed_for_oplocks
;
47 /****************************************************************************
48 If the requester wanted DELETE_ACCESS and was rejected because
49 the file ACL didn't include DELETE_ACCESS, see if the parent ACL
51 ****************************************************************************/
53 static bool parent_override_delete(connection_struct
*conn
,
54 const struct smb_filename
*smb_fname
,
56 uint32_t rejected_mask
)
58 if ((access_mask
& DELETE_ACCESS
) &&
59 (rejected_mask
& DELETE_ACCESS
) &&
60 can_delete_file_in_directory(conn
, smb_fname
)) {
66 /****************************************************************************
67 Check if we have open rights.
68 ****************************************************************************/
70 NTSTATUS
smbd_check_access_rights(struct connection_struct
*conn
,
71 const struct smb_filename
*smb_fname
,
75 /* Check if we have rights to open. */
77 struct security_descriptor
*sd
= NULL
;
78 uint32_t rejected_share_access
;
79 uint32_t rejected_mask
= access_mask
;
80 uint32_t do_not_check_mask
= 0;
82 rejected_share_access
= access_mask
& ~(conn
->share_access
);
84 if (rejected_share_access
) {
85 DEBUG(10, ("smbd_check_access_rights: rejected share access 0x%x "
87 (unsigned int)access_mask
,
88 smb_fname_str_dbg(smb_fname
),
89 (unsigned int)rejected_share_access
));
90 return NT_STATUS_ACCESS_DENIED
;
93 if (!use_privs
&& get_current_uid(conn
) == (uid_t
)0) {
94 /* I'm sorry sir, I didn't know you were root... */
95 DEBUG(10,("smbd_check_access_rights: root override "
96 "on %s. Granting 0x%x\n",
97 smb_fname_str_dbg(smb_fname
),
98 (unsigned int)access_mask
));
102 if ((access_mask
& DELETE_ACCESS
) && !lp_acl_check_permissions(SNUM(conn
))) {
103 DEBUG(10,("smbd_check_access_rights: not checking ACL "
104 "on DELETE_ACCESS on file %s. Granting 0x%x\n",
105 smb_fname_str_dbg(smb_fname
),
106 (unsigned int)access_mask
));
110 if (access_mask
== DELETE_ACCESS
&&
111 VALID_STAT(smb_fname
->st
) &&
112 S_ISLNK(smb_fname
->st
.st_ex_mode
)) {
113 /* We can always delete a symlink. */
114 DEBUG(10,("smbd_check_access_rights: not checking ACL "
115 "on DELETE_ACCESS on symlink %s.\n",
116 smb_fname_str_dbg(smb_fname
) ));
120 status
= SMB_VFS_GET_NT_ACL(conn
, smb_fname
->base_name
,
123 SECINFO_DACL
), talloc_tos(), &sd
);
125 if (!NT_STATUS_IS_OK(status
)) {
126 DEBUG(10, ("smbd_check_access_rights: Could not get acl "
128 smb_fname_str_dbg(smb_fname
),
131 if (NT_STATUS_EQUAL(status
, NT_STATUS_ACCESS_DENIED
)) {
139 * If we can access the path to this file, by
140 * default we have FILE_READ_ATTRIBUTES from the
141 * containing directory. See the section:
142 * "Algorithm to Check Access to an Existing File"
145 * se_file_access_check() also takes care of
146 * owner WRITE_DAC and READ_CONTROL.
148 do_not_check_mask
= FILE_READ_ATTRIBUTES
;
151 * Samba 3.6 and earlier granted execute access even
152 * if the ACL did not contain execute rights.
153 * Samba 4.0 is more correct and checks it.
154 * The compatibilty mode allows to skip this check
155 * to smoothen upgrades.
157 if (lp_acl_allow_execute_always(SNUM(conn
))) {
158 do_not_check_mask
|= FILE_EXECUTE
;
161 status
= se_file_access_check(sd
,
162 get_current_nttok(conn
),
164 (access_mask
& ~do_not_check_mask
),
167 DEBUG(10,("smbd_check_access_rights: file %s requesting "
168 "0x%x returning 0x%x (%s)\n",
169 smb_fname_str_dbg(smb_fname
),
170 (unsigned int)access_mask
,
171 (unsigned int)rejected_mask
,
172 nt_errstr(status
) ));
174 if (!NT_STATUS_IS_OK(status
)) {
175 if (DEBUGLEVEL
>= 10) {
176 DEBUG(10,("smbd_check_access_rights: acl for %s is:\n",
177 smb_fname_str_dbg(smb_fname
) ));
178 NDR_PRINT_DEBUG(security_descriptor
, sd
);
184 if (NT_STATUS_IS_OK(status
) ||
185 !NT_STATUS_EQUAL(status
, NT_STATUS_ACCESS_DENIED
)) {
189 /* Here we know status == NT_STATUS_ACCESS_DENIED. */
193 if ((access_mask
& FILE_WRITE_ATTRIBUTES
) &&
194 (rejected_mask
& FILE_WRITE_ATTRIBUTES
) &&
195 !lp_store_dos_attributes(SNUM(conn
)) &&
196 (lp_map_readonly(SNUM(conn
)) ||
197 lp_map_archive(SNUM(conn
)) ||
198 lp_map_hidden(SNUM(conn
)) ||
199 lp_map_system(SNUM(conn
)))) {
200 rejected_mask
&= ~FILE_WRITE_ATTRIBUTES
;
202 DEBUG(10,("smbd_check_access_rights: "
204 "FILE_WRITE_ATTRIBUTES "
206 smb_fname_str_dbg(smb_fname
)));
209 if (parent_override_delete(conn
,
213 /* Were we trying to do an open
214 * for delete and didn't get DELETE
215 * access (only) ? Check if the
216 * directory allows DELETE_CHILD.
218 * http://blogs.msdn.com/oldnewthing/archive/2004/06/04/148426.aspx
221 rejected_mask
&= ~DELETE_ACCESS
;
223 DEBUG(10,("smbd_check_access_rights: "
227 smb_fname_str_dbg(smb_fname
)));
230 if (rejected_mask
!= 0) {
231 return NT_STATUS_ACCESS_DENIED
;
236 static NTSTATUS
check_parent_access(struct connection_struct
*conn
,
237 struct smb_filename
*smb_fname
,
238 uint32_t access_mask
)
241 char *parent_dir
= NULL
;
242 struct security_descriptor
*parent_sd
= NULL
;
243 uint32_t access_granted
= 0;
245 if (!parent_dirname(talloc_tos(),
246 smb_fname
->base_name
,
249 return NT_STATUS_NO_MEMORY
;
252 if (get_current_uid(conn
) == (uid_t
)0) {
253 /* I'm sorry sir, I didn't know you were root... */
254 DEBUG(10,("check_parent_access: root override "
255 "on %s. Granting 0x%x\n",
256 smb_fname_str_dbg(smb_fname
),
257 (unsigned int)access_mask
));
261 status
= SMB_VFS_GET_NT_ACL(conn
,
267 if (!NT_STATUS_IS_OK(status
)) {
268 DEBUG(5,("check_parent_access: SMB_VFS_GET_NT_ACL failed for "
269 "%s with error %s\n",
276 * If we can access the path to this file, by
277 * default we have FILE_READ_ATTRIBUTES from the
278 * containing directory. See the section:
279 * "Algorithm to Check Access to an Existing File"
282 * se_file_access_check() also takes care of
283 * owner WRITE_DAC and READ_CONTROL.
285 status
= se_file_access_check(parent_sd
,
286 get_current_nttok(conn
),
288 (access_mask
& ~FILE_READ_ATTRIBUTES
),
290 if(!NT_STATUS_IS_OK(status
)) {
291 DEBUG(5,("check_parent_access: access check "
292 "on directory %s for "
293 "path %s for mask 0x%x returned (0x%x) %s\n",
295 smb_fname
->base_name
,
298 nt_errstr(status
) ));
305 /****************************************************************************
306 Ensure when opening a base file for a stream open that we have permissions
307 to do so given the access mask on the base file.
308 ****************************************************************************/
310 static NTSTATUS
check_base_file_access(struct connection_struct
*conn
,
311 struct smb_filename
*smb_fname
,
312 uint32_t access_mask
)
316 status
= smbd_calculate_access_mask(conn
, smb_fname
,
320 if (!NT_STATUS_IS_OK(status
)) {
321 DEBUG(10, ("smbd_calculate_access_mask "
322 "on file %s returned %s\n",
323 smb_fname_str_dbg(smb_fname
),
328 if (access_mask
& (FILE_WRITE_DATA
|FILE_APPEND_DATA
)) {
330 if (!CAN_WRITE(conn
)) {
331 return NT_STATUS_ACCESS_DENIED
;
333 dosattrs
= dos_mode(conn
, smb_fname
);
334 if (IS_DOS_READONLY(dosattrs
)) {
335 return NT_STATUS_ACCESS_DENIED
;
339 return smbd_check_access_rights(conn
,
345 /****************************************************************************
346 fd support routines - attempt to do a dos_open.
347 ****************************************************************************/
349 NTSTATUS
fd_open(struct connection_struct
*conn
,
354 struct smb_filename
*smb_fname
= fsp
->fsp_name
;
355 NTSTATUS status
= NT_STATUS_OK
;
359 * Never follow symlinks on a POSIX client. The
360 * client should be doing this.
363 if (fsp
->posix_open
|| !lp_follow_symlinks(SNUM(conn
))) {
368 fsp
->fh
->fd
= SMB_VFS_OPEN(conn
, smb_fname
, fsp
, flags
, mode
);
369 if (fsp
->fh
->fd
== -1) {
370 int posix_errno
= errno
;
372 #if defined(ENOTSUP) && defined(OSF1)
373 /* handle special Tru64 errno */
374 if (errno
== ENOTSUP
) {
379 /* fix broken NetBSD errno */
380 if (errno
== EFTYPE
) {
384 /* fix broken FreeBSD errno */
385 if (errno
== EMLINK
) {
388 #endif /* O_NOFOLLOW */
389 status
= map_nt_error_from_unix(posix_errno
);
390 if (errno
== EMFILE
) {
391 static time_t last_warned
= 0L;
393 if (time((time_t *) NULL
) > last_warned
) {
394 DEBUG(0,("Too many open files, unable "
395 "to open more! smbd's max "
397 lp_max_open_files()));
398 last_warned
= time((time_t *) NULL
);
404 DEBUG(10,("fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s\n",
405 smb_fname_str_dbg(smb_fname
), flags
, (int)mode
, fsp
->fh
->fd
,
406 (fsp
->fh
->fd
== -1) ? strerror(errno
) : "" ));
411 /****************************************************************************
412 Close the file associated with a fsp.
413 ****************************************************************************/
415 NTSTATUS
fd_close(files_struct
*fsp
)
422 if (fsp
->fh
->fd
== -1) {
423 return NT_STATUS_OK
; /* What we used to call a stat open. */
425 if (fsp
->fh
->ref_count
> 1) {
426 return NT_STATUS_OK
; /* Shared handle. Only close last reference. */
429 ret
= SMB_VFS_CLOSE(fsp
);
432 return map_nt_error_from_unix(errno
);
437 /****************************************************************************
438 Change the ownership of a file to that of the parent directory.
439 Do this by fd if possible.
440 ****************************************************************************/
442 void change_file_owner_to_parent(connection_struct
*conn
,
443 const char *inherit_from_dir
,
446 struct smb_filename
*smb_fname_parent
;
449 smb_fname_parent
= synthetic_smb_fname(talloc_tos(), inherit_from_dir
,
451 if (smb_fname_parent
== NULL
) {
455 ret
= SMB_VFS_STAT(conn
, smb_fname_parent
);
457 DEBUG(0,("change_file_owner_to_parent: failed to stat parent "
458 "directory %s. Error was %s\n",
459 smb_fname_str_dbg(smb_fname_parent
),
461 TALLOC_FREE(smb_fname_parent
);
465 if (smb_fname_parent
->st
.st_ex_uid
== fsp
->fsp_name
->st
.st_ex_uid
) {
466 /* Already this uid - no need to change. */
467 DEBUG(10,("change_file_owner_to_parent: file %s "
468 "is already owned by uid %d\n",
470 (int)fsp
->fsp_name
->st
.st_ex_uid
));
471 TALLOC_FREE(smb_fname_parent
);
476 ret
= SMB_VFS_FCHOWN(fsp
, smb_fname_parent
->st
.st_ex_uid
, (gid_t
)-1);
479 DEBUG(0,("change_file_owner_to_parent: failed to fchown "
480 "file %s to parent directory uid %u. Error "
481 "was %s\n", fsp_str_dbg(fsp
),
482 (unsigned int)smb_fname_parent
->st
.st_ex_uid
,
485 DEBUG(10,("change_file_owner_to_parent: changed new file %s to "
486 "parent directory uid %u.\n", fsp_str_dbg(fsp
),
487 (unsigned int)smb_fname_parent
->st
.st_ex_uid
));
488 /* Ensure the uid entry is updated. */
489 fsp
->fsp_name
->st
.st_ex_uid
= smb_fname_parent
->st
.st_ex_uid
;
492 TALLOC_FREE(smb_fname_parent
);
495 NTSTATUS
change_dir_owner_to_parent(connection_struct
*conn
,
496 const char *inherit_from_dir
,
498 SMB_STRUCT_STAT
*psbuf
)
500 struct smb_filename
*smb_fname_parent
;
501 struct smb_filename
*smb_fname_cwd
= NULL
;
502 char *saved_dir
= NULL
;
503 TALLOC_CTX
*ctx
= talloc_tos();
504 NTSTATUS status
= NT_STATUS_OK
;
507 smb_fname_parent
= synthetic_smb_fname(ctx
, inherit_from_dir
,
509 if (smb_fname_parent
== NULL
) {
510 return NT_STATUS_NO_MEMORY
;
513 ret
= SMB_VFS_STAT(conn
, smb_fname_parent
);
515 status
= map_nt_error_from_unix(errno
);
516 DEBUG(0,("change_dir_owner_to_parent: failed to stat parent "
517 "directory %s. Error was %s\n",
518 smb_fname_str_dbg(smb_fname_parent
),
523 /* We've already done an lstat into psbuf, and we know it's a
524 directory. If we can cd into the directory and the dev/ino
525 are the same then we can safely chown without races as
526 we're locking the directory in place by being in it. This
527 should work on any UNIX (thanks tridge :-). JRA.
530 saved_dir
= vfs_GetWd(ctx
,conn
);
532 status
= map_nt_error_from_unix(errno
);
533 DEBUG(0,("change_dir_owner_to_parent: failed to get "
534 "current working directory. Error was %s\n",
539 /* Chdir into the new path. */
540 if (vfs_ChDir(conn
, fname
) == -1) {
541 status
= map_nt_error_from_unix(errno
);
542 DEBUG(0,("change_dir_owner_to_parent: failed to change "
543 "current working directory to %s. Error "
544 "was %s\n", fname
, strerror(errno
) ));
548 smb_fname_cwd
= synthetic_smb_fname(ctx
, ".", NULL
, NULL
);
549 if (smb_fname_cwd
== NULL
) {
550 status
= NT_STATUS_NO_MEMORY
;
554 ret
= SMB_VFS_STAT(conn
, smb_fname_cwd
);
556 status
= map_nt_error_from_unix(errno
);
557 DEBUG(0,("change_dir_owner_to_parent: failed to stat "
558 "directory '.' (%s) Error was %s\n",
559 fname
, strerror(errno
)));
563 /* Ensure we're pointing at the same place. */
564 if (smb_fname_cwd
->st
.st_ex_dev
!= psbuf
->st_ex_dev
||
565 smb_fname_cwd
->st
.st_ex_ino
!= psbuf
->st_ex_ino
) {
566 DEBUG(0,("change_dir_owner_to_parent: "
567 "device/inode on directory %s changed. "
568 "Refusing to chown !\n", fname
));
569 status
= NT_STATUS_ACCESS_DENIED
;
573 if (smb_fname_parent
->st
.st_ex_uid
== smb_fname_cwd
->st
.st_ex_uid
) {
574 /* Already this uid - no need to change. */
575 DEBUG(10,("change_dir_owner_to_parent: directory %s "
576 "is already owned by uid %d\n",
578 (int)smb_fname_cwd
->st
.st_ex_uid
));
579 status
= NT_STATUS_OK
;
584 ret
= SMB_VFS_LCHOWN(conn
, ".", smb_fname_parent
->st
.st_ex_uid
,
588 status
= map_nt_error_from_unix(errno
);
589 DEBUG(10,("change_dir_owner_to_parent: failed to chown "
590 "directory %s to parent directory uid %u. "
591 "Error was %s\n", fname
,
592 (unsigned int)smb_fname_parent
->st
.st_ex_uid
,
595 DEBUG(10,("change_dir_owner_to_parent: changed ownership of new "
596 "directory %s to parent directory uid %u.\n",
597 fname
, (unsigned int)smb_fname_parent
->st
.st_ex_uid
));
598 /* Ensure the uid entry is updated. */
599 psbuf
->st_ex_uid
= smb_fname_parent
->st
.st_ex_uid
;
603 vfs_ChDir(conn
,saved_dir
);
605 TALLOC_FREE(smb_fname_parent
);
606 TALLOC_FREE(smb_fname_cwd
);
610 /****************************************************************************
611 Open a file - returning a guaranteed ATOMIC indication of if the
612 file was created or not.
613 ****************************************************************************/
615 static NTSTATUS
fd_open_atomic(struct connection_struct
*conn
,
621 NTSTATUS status
= NT_STATUS_UNSUCCESSFUL
;
622 bool file_existed
= VALID_STAT(fsp
->fsp_name
->st
);
624 *file_created
= false;
626 if (!(flags
& O_CREAT
)) {
628 * We're not creating the file, just pass through.
630 return fd_open(conn
, fsp
, flags
, mode
);
633 if (flags
& O_EXCL
) {
635 * Fail if already exists, just pass through.
637 status
= fd_open(conn
, fsp
, flags
, mode
);
640 * Here we've opened with O_CREAT|O_EXCL. If that went
641 * NT_STATUS_OK, we *know* we created this file.
643 *file_created
= NT_STATUS_IS_OK(status
);
649 * Now it gets tricky. We have O_CREAT, but not O_EXCL.
650 * To know absolutely if we created the file or not,
651 * we can never call O_CREAT without O_EXCL. So if
652 * we think the file existed, try without O_CREAT|O_EXCL.
653 * If we think the file didn't exist, try with
654 * O_CREAT|O_EXCL. Keep bouncing between these two
655 * requests until either the file is created, or
656 * opened. Either way, we keep going until we get
657 * a returnable result (error, or open/create).
661 int curr_flags
= flags
;
664 /* Just try open, do not create. */
665 curr_flags
&= ~(O_CREAT
);
666 status
= fd_open(conn
, fsp
, curr_flags
, mode
);
667 if (NT_STATUS_EQUAL(status
,
668 NT_STATUS_OBJECT_NAME_NOT_FOUND
)) {
670 * Someone deleted it in the meantime.
673 file_existed
= false;
674 DEBUG(10,("fd_open_atomic: file %s existed. "
676 smb_fname_str_dbg(fsp
->fsp_name
)));
680 /* Try create exclusively, fail if it exists. */
681 curr_flags
|= O_EXCL
;
682 status
= fd_open(conn
, fsp
, curr_flags
, mode
);
683 if (NT_STATUS_EQUAL(status
,
684 NT_STATUS_OBJECT_NAME_COLLISION
)) {
686 * Someone created it in the meantime.
687 * Retry without O_CREAT.
690 DEBUG(10,("fd_open_atomic: file %s "
691 "did not exist. Retry.\n",
692 smb_fname_str_dbg(fsp
->fsp_name
)));
695 if (NT_STATUS_IS_OK(status
)) {
697 * Here we've opened with O_CREAT|O_EXCL
698 * and got success. We *know* we created
701 *file_created
= true;
704 /* Create is done, or failed. */
710 /****************************************************************************
712 ****************************************************************************/
714 static NTSTATUS
open_file(files_struct
*fsp
,
715 connection_struct
*conn
,
716 struct smb_request
*req
,
717 const char *parent_dir
,
720 uint32 access_mask
, /* client requested access mask. */
721 uint32 open_access_mask
, /* what we're actually using in the open. */
722 bool *p_file_created
)
724 struct smb_filename
*smb_fname
= fsp
->fsp_name
;
725 NTSTATUS status
= NT_STATUS_OK
;
726 int accmode
= (flags
& O_ACCMODE
);
727 int local_flags
= flags
;
728 bool file_existed
= VALID_STAT(fsp
->fsp_name
->st
);
733 /* Check permissions */
736 * This code was changed after seeing a client open request
737 * containing the open mode of (DENY_WRITE/read-only) with
738 * the 'create if not exist' bit set. The previous code
739 * would fail to open the file read only on a read-only share
740 * as it was checking the flags parameter directly against O_RDONLY,
741 * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
745 if (!CAN_WRITE(conn
)) {
746 /* It's a read-only share - fail if we wanted to write. */
747 if(accmode
!= O_RDONLY
|| (flags
& O_TRUNC
) || (flags
& O_APPEND
)) {
748 DEBUG(3,("Permission denied opening %s\n",
749 smb_fname_str_dbg(smb_fname
)));
750 return NT_STATUS_ACCESS_DENIED
;
752 if (flags
& O_CREAT
) {
753 /* We don't want to write - but we must make sure that
754 O_CREAT doesn't create the file if we have write
755 access into the directory.
757 flags
&= ~(O_CREAT
|O_EXCL
);
758 local_flags
&= ~(O_CREAT
|O_EXCL
);
763 * This little piece of insanity is inspired by the
764 * fact that an NT client can open a file for O_RDONLY,
765 * but set the create disposition to FILE_EXISTS_TRUNCATE.
766 * If the client *can* write to the file, then it expects to
767 * truncate the file, even though it is opening for readonly.
768 * Quicken uses this stupid trick in backup file creation...
769 * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
770 * for helping track this one down. It didn't bite us in 2.0.x
771 * as we always opened files read-write in that release. JRA.
774 if ((accmode
== O_RDONLY
) && ((flags
& O_TRUNC
) == O_TRUNC
)) {
775 DEBUG(10,("open_file: truncate requested on read-only open "
776 "for file %s\n", smb_fname_str_dbg(smb_fname
)));
777 local_flags
= (flags
& ~O_ACCMODE
)|O_RDWR
;
780 if ((open_access_mask
& (FILE_READ_DATA
|FILE_WRITE_DATA
|FILE_APPEND_DATA
|FILE_EXECUTE
)) ||
781 (!file_existed
&& (local_flags
& O_CREAT
)) ||
782 ((local_flags
& O_TRUNC
) == O_TRUNC
) ) {
786 #if defined(O_NONBLOCK) && defined(S_ISFIFO)
788 * We would block on opening a FIFO with no one else on the
789 * other end. Do what we used to do and add O_NONBLOCK to the
793 if (file_existed
&& S_ISFIFO(smb_fname
->st
.st_ex_mode
)) {
794 local_flags
&= ~O_TRUNC
; /* Can't truncate a FIFO. */
795 local_flags
|= O_NONBLOCK
;
799 /* Don't create files with Microsoft wildcard characters. */
802 * wildcard characters are allowed in stream names
803 * only test the basefilename
805 wild
= fsp
->base_fsp
->fsp_name
->base_name
;
807 wild
= smb_fname
->base_name
;
809 if ((local_flags
& O_CREAT
) && !file_existed
&&
811 return NT_STATUS_OBJECT_NAME_INVALID
;
814 /* Can we access this file ? */
815 if (!fsp
->base_fsp
) {
816 /* Only do this check on non-stream open. */
818 status
= smbd_check_access_rights(conn
,
822 } else if (local_flags
& O_CREAT
){
823 status
= check_parent_access(conn
,
827 /* File didn't exist and no O_CREAT. */
828 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
830 if (!NT_STATUS_IS_OK(status
)) {
831 DEBUG(10,("open_file: "
835 "smbd_check_access_rights" :
836 "check_parent_access",
837 smb_fname_str_dbg(smb_fname
),
838 nt_errstr(status
) ));
844 * Actually do the open - if O_TRUNC is needed handle it
845 * below under the share mode lock.
847 status
= fd_open_atomic(conn
, fsp
, local_flags
& ~O_TRUNC
,
848 unx_mode
, p_file_created
);
849 if (!NT_STATUS_IS_OK(status
)) {
850 DEBUG(3,("Error opening file %s (%s) (local_flags=%d) "
851 "(flags=%d)\n", smb_fname_str_dbg(smb_fname
),
852 nt_errstr(status
),local_flags
,flags
));
856 ret
= SMB_VFS_FSTAT(fsp
, &smb_fname
->st
);
858 /* If we have an fd, this stat should succeed. */
859 DEBUG(0,("Error doing fstat on open file %s "
861 smb_fname_str_dbg(smb_fname
),
863 status
= map_nt_error_from_unix(errno
);
868 if (*p_file_created
) {
869 /* We created this file. */
871 bool need_re_stat
= false;
872 /* Do all inheritance work after we've
873 done a successful fstat call and filled
874 in the stat struct in fsp->fsp_name. */
876 /* Inherit the ACL if required */
877 if (lp_inherit_permissions(SNUM(conn
))) {
878 inherit_access_posix_acl(conn
, parent_dir
,
879 smb_fname
->base_name
,
884 /* Change the owner if required. */
885 if (lp_inherit_owner(SNUM(conn
))) {
886 change_file_owner_to_parent(conn
, parent_dir
,
892 ret
= SMB_VFS_FSTAT(fsp
, &smb_fname
->st
);
893 /* If we have an fd, this stat should succeed. */
895 DEBUG(0,("Error doing fstat on open file %s "
897 smb_fname_str_dbg(smb_fname
),
902 notify_fname(conn
, NOTIFY_ACTION_ADDED
,
903 FILE_NOTIFY_CHANGE_FILE_NAME
,
904 smb_fname
->base_name
);
907 fsp
->fh
->fd
= -1; /* What we used to call a stat open. */
909 /* File must exist for a stat open. */
910 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
913 status
= smbd_check_access_rights(conn
,
918 if (NT_STATUS_EQUAL(status
, NT_STATUS_OBJECT_NAME_NOT_FOUND
) &&
920 S_ISLNK(smb_fname
->st
.st_ex_mode
)) {
921 /* This is a POSIX stat open for delete
922 * or rename on a symlink that points
924 DEBUG(10,("open_file: allowing POSIX "
925 "open on bad symlink %s\n",
926 smb_fname_str_dbg(smb_fname
)));
927 status
= NT_STATUS_OK
;
930 if (!NT_STATUS_IS_OK(status
)) {
931 DEBUG(10,("open_file: "
932 "smbd_check_access_rights on file "
934 smb_fname_str_dbg(smb_fname
),
935 nt_errstr(status
) ));
941 * POSIX allows read-only opens of directories. We don't
942 * want to do this (we use a different code path for this)
943 * so catch a directory open and return an EISDIR. JRA.
946 if(S_ISDIR(smb_fname
->st
.st_ex_mode
)) {
949 return NT_STATUS_FILE_IS_A_DIRECTORY
;
952 fsp
->file_id
= vfs_file_id_from_sbuf(conn
, &smb_fname
->st
);
953 fsp
->vuid
= req
? req
->vuid
: UID_FIELD_INVALID
;
954 fsp
->file_pid
= req
? req
->smbpid
: 0;
955 fsp
->can_lock
= True
;
956 fsp
->can_read
= ((access_mask
& FILE_READ_DATA
) != 0);
959 ((access_mask
& (FILE_WRITE_DATA
| FILE_APPEND_DATA
)) != 0);
960 fsp
->print_file
= NULL
;
961 fsp
->modified
= False
;
962 fsp
->sent_oplock_break
= NO_BREAK_SENT
;
963 fsp
->is_directory
= False
;
964 if (conn
->aio_write_behind_list
&&
965 is_in_path(smb_fname
->base_name
, conn
->aio_write_behind_list
,
966 conn
->case_sensitive
)) {
967 fsp
->aio_write_behind
= True
;
970 fsp
->wcp
= NULL
; /* Write cache pointer. */
972 DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
973 conn
->session_info
->unix_info
->unix_name
,
974 smb_fname_str_dbg(smb_fname
),
975 BOOLSTR(fsp
->can_read
), BOOLSTR(fsp
->can_write
),
976 conn
->num_files_open
));
982 /****************************************************************************
983 Check if we can open a file with a share mode.
984 Returns True if conflict, False if not.
985 ****************************************************************************/
987 static bool share_conflict(struct share_mode_entry
*entry
,
991 DEBUG(10,("share_conflict: entry->access_mask = 0x%x, "
992 "entry->share_access = 0x%x, "
993 "entry->private_options = 0x%x\n",
994 (unsigned int)entry
->access_mask
,
995 (unsigned int)entry
->share_access
,
996 (unsigned int)entry
->private_options
));
998 if (server_id_is_disconnected(&entry
->pid
)) {
1000 * note: cleanup should have been done by
1001 * delay_for_batch_oplocks()
1006 DEBUG(10,("share_conflict: access_mask = 0x%x, share_access = 0x%x\n",
1007 (unsigned int)access_mask
, (unsigned int)share_access
));
1009 if ((entry
->access_mask
& (FILE_WRITE_DATA
|
1013 DELETE_ACCESS
)) == 0) {
1014 DEBUG(10,("share_conflict: No conflict due to "
1015 "entry->access_mask = 0x%x\n",
1016 (unsigned int)entry
->access_mask
));
1020 if ((access_mask
& (FILE_WRITE_DATA
|
1024 DELETE_ACCESS
)) == 0) {
1025 DEBUG(10,("share_conflict: No conflict due to "
1026 "access_mask = 0x%x\n",
1027 (unsigned int)access_mask
));
1031 #if 1 /* JRA TEST - Superdebug. */
1032 #define CHECK_MASK(num, am, right, sa, share) \
1033 DEBUG(10,("share_conflict: [%d] am (0x%x) & right (0x%x) = 0x%x\n", \
1034 (unsigned int)(num), (unsigned int)(am), \
1035 (unsigned int)(right), (unsigned int)(am)&(right) )); \
1036 DEBUG(10,("share_conflict: [%d] sa (0x%x) & share (0x%x) = 0x%x\n", \
1037 (unsigned int)(num), (unsigned int)(sa), \
1038 (unsigned int)(share), (unsigned int)(sa)&(share) )); \
1039 if (((am) & (right)) && !((sa) & (share))) { \
1040 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
1041 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
1042 (unsigned int)(share) )); \
1046 #define CHECK_MASK(num, am, right, sa, share) \
1047 if (((am) & (right)) && !((sa) & (share))) { \
1048 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
1049 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
1050 (unsigned int)(share) )); \
1055 CHECK_MASK(1, entry
->access_mask
, FILE_WRITE_DATA
| FILE_APPEND_DATA
,
1056 share_access
, FILE_SHARE_WRITE
);
1057 CHECK_MASK(2, access_mask
, FILE_WRITE_DATA
| FILE_APPEND_DATA
,
1058 entry
->share_access
, FILE_SHARE_WRITE
);
1060 CHECK_MASK(3, entry
->access_mask
, FILE_READ_DATA
| FILE_EXECUTE
,
1061 share_access
, FILE_SHARE_READ
);
1062 CHECK_MASK(4, access_mask
, FILE_READ_DATA
| FILE_EXECUTE
,
1063 entry
->share_access
, FILE_SHARE_READ
);
1065 CHECK_MASK(5, entry
->access_mask
, DELETE_ACCESS
,
1066 share_access
, FILE_SHARE_DELETE
);
1067 CHECK_MASK(6, access_mask
, DELETE_ACCESS
,
1068 entry
->share_access
, FILE_SHARE_DELETE
);
1070 DEBUG(10,("share_conflict: No conflict.\n"));
1074 #if defined(DEVELOPER)
1075 static void validate_my_share_entries(struct smbd_server_connection
*sconn
,
1077 struct share_mode_entry
*share_entry
)
1079 struct server_id self
= messaging_server_id(sconn
->msg_ctx
);
1082 if (!serverid_equal(&self
, &share_entry
->pid
)) {
1086 if (share_entry
->share_file_id
== 0) {
1087 /* INTERNAL_OPEN_ONLY */
1091 if (!is_valid_share_mode_entry(share_entry
)) {
1095 fsp
= file_find_dif(sconn
, share_entry
->id
,
1096 share_entry
->share_file_id
);
1098 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
1099 share_mode_str(talloc_tos(), num
, share_entry
) ));
1100 smb_panic("validate_my_share_entries: Cannot match a "
1101 "share entry with an open file\n");
1104 if (((uint16
)fsp
->oplock_type
) != share_entry
->op_type
) {
1113 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
1114 share_mode_str(talloc_tos(), num
, share_entry
) ));
1115 str
= talloc_asprintf(talloc_tos(),
1116 "validate_my_share_entries: "
1117 "file %s, oplock_type = 0x%x, op_type = 0x%x\n",
1118 fsp
->fsp_name
->base_name
,
1119 (unsigned int)fsp
->oplock_type
,
1120 (unsigned int)share_entry
->op_type
);
1126 bool is_stat_open(uint32 access_mask
)
1128 const uint32_t stat_open_bits
=
1129 (SYNCHRONIZE_ACCESS
|
1130 FILE_READ_ATTRIBUTES
|
1131 FILE_WRITE_ATTRIBUTES
);
1133 return (((access_mask
& stat_open_bits
) != 0) &&
1134 ((access_mask
& ~stat_open_bits
) == 0));
1137 static bool has_delete_on_close(struct share_mode_lock
*lck
,
1140 struct share_mode_data
*d
= lck
->data
;
1143 if (d
->num_share_modes
== 0) {
1146 if (!is_delete_on_close_set(lck
, name_hash
)) {
1149 for (i
=0; i
<d
->num_share_modes
; i
++) {
1150 if (!share_mode_stale_pid(d
, i
)) {
1157 /****************************************************************************
1158 Deal with share modes
1159 Invariant: Share mode must be locked on entry and exit.
1160 Returns -1 on error, or number of share modes on success (may be zero).
1161 ****************************************************************************/
1163 static NTSTATUS
open_mode_check(connection_struct
*conn
,
1164 struct share_mode_lock
*lck
,
1166 uint32 share_access
)
1170 if(lck
->data
->num_share_modes
== 0) {
1171 return NT_STATUS_OK
;
1174 if (is_stat_open(access_mask
)) {
1175 /* Stat open that doesn't trigger oplock breaks or share mode
1176 * checks... ! JRA. */
1177 return NT_STATUS_OK
;
1181 * Check if the share modes will give us access.
1184 #if defined(DEVELOPER)
1185 for(i
= 0; i
< lck
->data
->num_share_modes
; i
++) {
1186 validate_my_share_entries(conn
->sconn
, i
,
1187 &lck
->data
->share_modes
[i
]);
1191 /* Now we check the share modes, after any oplock breaks. */
1192 for(i
= 0; i
< lck
->data
->num_share_modes
; i
++) {
1194 if (!is_valid_share_mode_entry(&lck
->data
->share_modes
[i
])) {
1198 /* someone else has a share lock on it, check to see if we can
1200 if (share_conflict(&lck
->data
->share_modes
[i
],
1201 access_mask
, share_access
)) {
1203 if (share_mode_stale_pid(lck
->data
, i
)) {
1207 return NT_STATUS_SHARING_VIOLATION
;
1211 return NT_STATUS_OK
;
1215 * Send a break message to the oplock holder and delay the open for
1219 static NTSTATUS
send_break_message(struct messaging_context
*msg_ctx
,
1220 const struct share_mode_entry
*exclusive
,
1224 char msg
[MSG_SMB_SHARE_MODE_ENTRY_SIZE
];
1226 DEBUG(10, ("Sending break request to PID %s\n",
1227 procid_str_static(&exclusive
->pid
)));
1229 /* Create the message. */
1230 share_mode_entry_to_message(msg
, exclusive
);
1232 /* Overload entry->op_type */
1233 SSVAL(msg
,OP_BREAK_MSG_OP_TYPE_OFFSET
, break_to
);
1235 status
= messaging_send_buf(msg_ctx
, exclusive
->pid
,
1236 MSG_SMB_BREAK_REQUEST
,
1237 (uint8
*)msg
, sizeof(msg
));
1238 if (!NT_STATUS_IS_OK(status
)) {
1239 DEBUG(3, ("Could not send oplock break message: %s\n",
1240 nt_errstr(status
)));
1247 * Do internal consistency checks on the share mode for a file.
1250 static bool validate_oplock_types(struct share_mode_lock
*lck
)
1252 struct share_mode_data
*d
= lck
->data
;
1254 bool ex_or_batch
= false;
1255 bool level2
= false;
1256 bool no_oplock
= false;
1257 uint32_t num_non_stat_opens
= 0;
1260 for (i
=0; i
<d
->num_share_modes
; i
++) {
1261 struct share_mode_entry
*e
= &d
->share_modes
[i
];
1263 if (!is_valid_share_mode_entry(e
)) {
1267 if (e
->op_type
== NO_OPLOCK
&& is_stat_open(e
->access_mask
)) {
1268 /* We ignore stat opens in the table - they
1269 always have NO_OPLOCK and never get or
1270 cause breaks. JRA. */
1274 num_non_stat_opens
+= 1;
1276 if (BATCH_OPLOCK_TYPE(e
->op_type
)) {
1277 /* batch - can only be one. */
1278 if (share_mode_stale_pid(d
, i
)) {
1279 DEBUG(10, ("Found stale batch oplock\n"));
1282 if (ex_or_batch
|| batch
|| level2
|| no_oplock
) {
1283 DEBUG(0, ("Bad batch oplock entry %u.",
1290 if (EXCLUSIVE_OPLOCK_TYPE(e
->op_type
)) {
1291 if (share_mode_stale_pid(d
, i
)) {
1292 DEBUG(10, ("Found stale duplicate oplock\n"));
1295 /* Exclusive or batch - can only be one. */
1296 if (ex_or_batch
|| level2
|| no_oplock
) {
1297 DEBUG(0, ("Bad exclusive or batch oplock "
1298 "entry %u.", (unsigned)i
));
1304 if (LEVEL_II_OPLOCK_TYPE(e
->op_type
)) {
1305 if (batch
|| ex_or_batch
) {
1306 if (share_mode_stale_pid(d
, i
)) {
1307 DEBUG(10, ("Found stale LevelII "
1311 DEBUG(0, ("Bad levelII oplock entry %u.",
1318 if (e
->op_type
== NO_OPLOCK
) {
1319 if (batch
|| ex_or_batch
) {
1320 if (share_mode_stale_pid(d
, i
)) {
1321 DEBUG(10, ("Found stale NO_OPLOCK "
1325 DEBUG(0, ("Bad no oplock entry %u.",
1333 remove_stale_share_mode_entries(d
);
1335 if ((batch
|| ex_or_batch
) && (num_non_stat_opens
!= 1)) {
1336 DEBUG(1, ("got batch (%d) or ex (%d) non-exclusively (%d)\n",
1337 (int)batch
, (int)ex_or_batch
,
1338 (int)d
->num_share_modes
));
1345 static bool delay_for_oplock(files_struct
*fsp
,
1347 struct share_mode_lock
*lck
,
1348 bool have_sharing_violation
,
1349 uint32_t create_disposition
)
1351 struct share_mode_data
*d
= lck
->data
;
1352 struct share_mode_entry
*entry
;
1353 uint32_t num_non_stat_opens
= 0;
1357 if ((oplock_request
& INTERNAL_OPEN_ONLY
) || is_stat_open(fsp
->access_mask
)) {
1360 for (i
=0; i
<d
->num_share_modes
; i
++) {
1361 struct share_mode_entry
*e
= &d
->share_modes
[i
];
1362 if (e
->op_type
== NO_OPLOCK
&& is_stat_open(e
->access_mask
)) {
1365 num_non_stat_opens
+= 1;
1368 * We found the a non-stat open, which in the exclusive/batch
1369 * case will be inspected further down.
1373 if (num_non_stat_opens
== 0) {
1375 * Nothing to wait for around
1379 if (num_non_stat_opens
!= 1) {
1381 * More than one open around. There can't be any exclusive or
1382 * batch left, this is all level2.
1387 if (server_id_is_disconnected(&entry
->pid
)) {
1390 * This could be achieved by sending a break message
1391 * to ourselves. Special considerations for files
1392 * with delete_on_close flag set!
1394 * For now we keep it simple and do not
1395 * allow delete on close for durable handles.
1400 switch (create_disposition
) {
1401 case FILE_SUPERSEDE
:
1402 case FILE_OVERWRITE_IF
:
1403 break_to
= NO_OPLOCK
;
1406 break_to
= LEVEL_II_OPLOCK
;
1410 if (have_sharing_violation
&& (entry
->op_type
& BATCH_OPLOCK
)) {
1411 if (share_mode_stale_pid(d
, 0)) {
1414 send_break_message(fsp
->conn
->sconn
->msg_ctx
, entry
, break_to
);
1417 if (have_sharing_violation
) {
1419 * Non-batch exclusive is not broken if we have a sharing
1424 if (LEVEL_II_OPLOCK_TYPE(entry
->op_type
) &&
1425 (break_to
== NO_OPLOCK
)) {
1426 if (share_mode_stale_pid(d
, 0)) {
1429 DEBUG(10, ("Asynchronously breaking level2 oplock for "
1430 "create_disposition=%u\n",
1431 (unsigned)create_disposition
));
1432 send_break_message(fsp
->conn
->sconn
->msg_ctx
, entry
, break_to
);
1435 if (!EXCLUSIVE_OPLOCK_TYPE(entry
->op_type
)) {
1437 * No break for NO_OPLOCK or LEVEL2_OPLOCK oplocks
1441 if (share_mode_stale_pid(d
, 0)) {
1445 send_break_message(fsp
->conn
->sconn
->msg_ctx
, entry
, break_to
);
1449 static bool file_has_brlocks(files_struct
*fsp
)
1451 struct byte_range_lock
*br_lck
;
1453 br_lck
= brl_get_locks_readonly(fsp
);
1457 return (brl_num_locks(br_lck
) > 0);
1460 static void grant_fsp_oplock_type(files_struct
*fsp
,
1461 struct share_mode_lock
*lck
,
1464 bool allow_level2
= (global_client_caps
& CAP_LEVEL_II_OPLOCKS
) &&
1465 lp_level2_oplocks(SNUM(fsp
->conn
));
1466 bool got_level2_oplock
, got_a_none_oplock
;
1469 /* Start by granting what the client asked for,
1470 but ensure no SAMBA_PRIVATE bits can be set. */
1471 fsp
->oplock_type
= (oplock_request
& ~SAMBA_PRIVATE_OPLOCK_MASK
);
1473 if (oplock_request
& INTERNAL_OPEN_ONLY
) {
1474 /* No oplocks on internal open. */
1475 fsp
->oplock_type
= NO_OPLOCK
;
1476 DEBUG(10,("grant_fsp_oplock_type: oplock type 0x%x on file %s\n",
1477 fsp
->oplock_type
, fsp_str_dbg(fsp
)));
1481 if (lp_locking(fsp
->conn
->params
) && file_has_brlocks(fsp
)) {
1482 DEBUG(10,("grant_fsp_oplock_type: file %s has byte range locks\n",
1484 fsp
->oplock_type
= NO_OPLOCK
;
1487 if (is_stat_open(fsp
->access_mask
)) {
1488 /* Leave the value already set. */
1489 DEBUG(10,("grant_fsp_oplock_type: oplock type 0x%x on file %s\n",
1490 fsp
->oplock_type
, fsp_str_dbg(fsp
)));
1494 got_level2_oplock
= false;
1495 got_a_none_oplock
= false;
1497 for (i
=0; i
<lck
->data
->num_share_modes
; i
++) {
1498 int op_type
= lck
->data
->share_modes
[i
].op_type
;
1500 if (LEVEL_II_OPLOCK_TYPE(op_type
)) {
1501 got_level2_oplock
= true;
1503 if (op_type
== NO_OPLOCK
) {
1504 got_a_none_oplock
= true;
1509 * Match what was requested (fsp->oplock_type) with
1510 * what was found in the existing share modes.
1513 if (got_level2_oplock
|| got_a_none_oplock
) {
1514 if (EXCLUSIVE_OPLOCK_TYPE(fsp
->oplock_type
)) {
1515 fsp
->oplock_type
= LEVEL_II_OPLOCK
;
1520 * Don't grant level2 to clients that don't want them
1521 * or if we've turned them off.
1523 if (fsp
->oplock_type
== LEVEL_II_OPLOCK
&& !allow_level2
) {
1524 fsp
->oplock_type
= NO_OPLOCK
;
1527 if (fsp
->oplock_type
== LEVEL_II_OPLOCK
&& !got_level2_oplock
) {
1529 * We're the first level2 oplock. Indicate that in brlock.tdb.
1531 struct byte_range_lock
*brl
;
1533 brl
= brl_get_locks(talloc_tos(), fsp
);
1535 brl_set_have_read_oplocks(brl
, true);
1540 DEBUG(10,("grant_fsp_oplock_type: oplock type 0x%x on file %s\n",
1541 fsp
->oplock_type
, fsp_str_dbg(fsp
)));
1544 static bool request_timed_out(struct timeval request_time
,
1545 struct timeval timeout
)
1547 struct timeval now
, end_time
;
1549 end_time
= timeval_sum(&request_time
, &timeout
);
1550 return (timeval_compare(&end_time
, &now
) < 0);
1553 struct defer_open_state
{
1554 struct smbd_server_connection
*sconn
;
1558 static void defer_open_done(struct tevent_req
*req
);
1560 /****************************************************************************
1561 Handle the 1 second delay in returning a SHARING_VIOLATION error.
1562 ****************************************************************************/
1564 static void defer_open(struct share_mode_lock
*lck
,
1565 struct timeval request_time
,
1566 struct timeval timeout
,
1567 struct smb_request
*req
,
1568 struct deferred_open_record
*state
)
1570 struct deferred_open_record
*open_rec
;
1572 DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred "
1573 "open entry for mid %llu\n",
1574 (unsigned int)request_time
.tv_sec
,
1575 (unsigned int)request_time
.tv_usec
,
1576 (unsigned long long)req
->mid
));
1578 open_rec
= talloc(NULL
, struct deferred_open_record
);
1579 if (open_rec
== NULL
) {
1581 exit_server("talloc failed");
1587 struct defer_open_state
*watch_state
;
1588 struct tevent_req
*watch_req
;
1591 watch_state
= talloc(open_rec
, struct defer_open_state
);
1592 if (watch_state
== NULL
) {
1593 exit_server("talloc failed");
1595 watch_state
->sconn
= req
->sconn
;
1596 watch_state
->mid
= req
->mid
;
1598 DEBUG(10, ("defering mid %llu\n",
1599 (unsigned long long)req
->mid
));
1601 watch_req
= dbwrap_record_watch_send(
1602 watch_state
, req
->sconn
->ev_ctx
, lck
->data
->record
,
1603 req
->sconn
->msg_ctx
);
1604 if (watch_req
== NULL
) {
1605 exit_server("Could not watch share mode record");
1607 tevent_req_set_callback(watch_req
, defer_open_done
,
1610 ret
= tevent_req_set_endtime(
1611 watch_req
, req
->sconn
->ev_ctx
,
1612 timeval_sum(&request_time
, &timeout
));
1616 if (!push_deferred_open_message_smb(req
, request_time
, timeout
,
1617 state
->id
, open_rec
)) {
1619 exit_server("push_deferred_open_message_smb failed");
1623 static void defer_open_done(struct tevent_req
*req
)
1625 struct defer_open_state
*state
= tevent_req_callback_data(
1626 req
, struct defer_open_state
);
1630 status
= dbwrap_record_watch_recv(req
, talloc_tos(), NULL
);
1632 if (!NT_STATUS_IS_OK(status
)) {
1633 DEBUG(5, ("dbwrap_record_watch_recv returned %s\n",
1634 nt_errstr(status
)));
1636 * Even if it failed, retry anyway. TODO: We need a way to
1637 * tell a re-scheduled open about that error.
1641 DEBUG(10, ("scheduling mid %llu\n", (unsigned long long)state
->mid
));
1643 ret
= schedule_deferred_open_message_smb(state
->sconn
, state
->mid
);
1649 /****************************************************************************
1650 On overwrite open ensure that the attributes match.
1651 ****************************************************************************/
1653 static bool open_match_attributes(connection_struct
*conn
,
1654 uint32 old_dos_attr
,
1655 uint32 new_dos_attr
,
1656 mode_t existing_unx_mode
,
1657 mode_t new_unx_mode
,
1658 mode_t
*returned_unx_mode
)
1660 uint32 noarch_old_dos_attr
, noarch_new_dos_attr
;
1662 noarch_old_dos_attr
= (old_dos_attr
& ~FILE_ATTRIBUTE_ARCHIVE
);
1663 noarch_new_dos_attr
= (new_dos_attr
& ~FILE_ATTRIBUTE_ARCHIVE
);
1665 if((noarch_old_dos_attr
== 0 && noarch_new_dos_attr
!= 0) ||
1666 (noarch_old_dos_attr
!= 0 && ((noarch_old_dos_attr
& noarch_new_dos_attr
) == noarch_old_dos_attr
))) {
1667 *returned_unx_mode
= new_unx_mode
;
1669 *returned_unx_mode
= (mode_t
)0;
1672 DEBUG(10,("open_match_attributes: old_dos_attr = 0x%x, "
1673 "existing_unx_mode = 0%o, new_dos_attr = 0x%x "
1674 "returned_unx_mode = 0%o\n",
1675 (unsigned int)old_dos_attr
,
1676 (unsigned int)existing_unx_mode
,
1677 (unsigned int)new_dos_attr
,
1678 (unsigned int)*returned_unx_mode
));
1680 /* If we're mapping SYSTEM and HIDDEN ensure they match. */
1681 if (lp_map_system(SNUM(conn
)) || lp_store_dos_attributes(SNUM(conn
))) {
1682 if ((old_dos_attr
& FILE_ATTRIBUTE_SYSTEM
) &&
1683 !(new_dos_attr
& FILE_ATTRIBUTE_SYSTEM
)) {
1687 if (lp_map_hidden(SNUM(conn
)) || lp_store_dos_attributes(SNUM(conn
))) {
1688 if ((old_dos_attr
& FILE_ATTRIBUTE_HIDDEN
) &&
1689 !(new_dos_attr
& FILE_ATTRIBUTE_HIDDEN
)) {
1696 /****************************************************************************
1697 Special FCB or DOS processing in the case of a sharing violation.
1698 Try and find a duplicated file handle.
1699 ****************************************************************************/
1701 static NTSTATUS
fcb_or_dos_open(struct smb_request
*req
,
1702 connection_struct
*conn
,
1703 files_struct
*fsp_to_dup_into
,
1704 const struct smb_filename
*smb_fname
,
1709 uint32 share_access
,
1710 uint32 create_options
)
1714 DEBUG(5,("fcb_or_dos_open: attempting old open semantics for "
1715 "file %s.\n", smb_fname_str_dbg(smb_fname
)));
1717 for(fsp
= file_find_di_first(conn
->sconn
, id
); fsp
;
1718 fsp
= file_find_di_next(fsp
)) {
1720 DEBUG(10,("fcb_or_dos_open: checking file %s, fd = %d, "
1721 "vuid = %llu, file_pid = %u, private_options = 0x%x "
1722 "access_mask = 0x%x\n", fsp_str_dbg(fsp
),
1723 fsp
->fh
->fd
, (unsigned long long)fsp
->vuid
,
1724 (unsigned int)fsp
->file_pid
,
1725 (unsigned int)fsp
->fh
->private_options
,
1726 (unsigned int)fsp
->access_mask
));
1728 if (fsp
!= fsp_to_dup_into
&&
1729 fsp
->fh
->fd
!= -1 &&
1730 fsp
->vuid
== vuid
&&
1731 fsp
->file_pid
== file_pid
&&
1732 (fsp
->fh
->private_options
& (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS
|
1733 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB
)) &&
1734 (fsp
->access_mask
& FILE_WRITE_DATA
) &&
1735 strequal(fsp
->fsp_name
->base_name
, smb_fname
->base_name
) &&
1736 strequal(fsp
->fsp_name
->stream_name
,
1737 smb_fname
->stream_name
)) {
1738 DEBUG(10,("fcb_or_dos_open: file match\n"));
1744 return NT_STATUS_NOT_FOUND
;
1747 /* quite an insane set of semantics ... */
1748 if (is_executable(smb_fname
->base_name
) &&
1749 (fsp
->fh
->private_options
& NTCREATEX_OPTIONS_PRIVATE_DENY_DOS
)) {
1750 DEBUG(10,("fcb_or_dos_open: file fail due to is_executable.\n"));
1751 return NT_STATUS_INVALID_PARAMETER
;
1754 /* We need to duplicate this fsp. */
1755 return dup_file_fsp(req
, fsp
, access_mask
, share_access
,
1756 create_options
, fsp_to_dup_into
);
1759 static void schedule_defer_open(struct share_mode_lock
*lck
,
1761 struct timeval request_time
,
1762 struct smb_request
*req
)
1764 struct deferred_open_record state
;
1766 /* This is a relative time, added to the absolute
1767 request_time value to get the absolute timeout time.
1768 Note that if this is the second or greater time we enter
1769 this codepath for this particular request mid then
1770 request_time is left as the absolute time of the *first*
1771 time this request mid was processed. This is what allows
1772 the request to eventually time out. */
1774 struct timeval timeout
;
1776 /* Normally the smbd we asked should respond within
1777 * OPLOCK_BREAK_TIMEOUT seconds regardless of whether
1778 * the client did, give twice the timeout as a safety
1779 * measure here in case the other smbd is stuck
1780 * somewhere else. */
1782 timeout
= timeval_set(OPLOCK_BREAK_TIMEOUT
*2, 0);
1784 /* Nothing actually uses state.delayed_for_oplocks
1785 but it's handy to differentiate in debug messages
1786 between a 30 second delay due to oplock break, and
1787 a 1 second delay for share mode conflicts. */
1789 state
.delayed_for_oplocks
= True
;
1790 state
.async_open
= false;
1793 if (!request_timed_out(request_time
, timeout
)) {
1794 defer_open(lck
, request_time
, timeout
, req
, &state
);
1798 /****************************************************************************
1799 Reschedule an open call that went asynchronous.
1800 ****************************************************************************/
1802 static void schedule_async_open(struct timeval request_time
,
1803 struct smb_request
*req
)
1805 struct deferred_open_record state
;
1806 struct timeval timeout
;
1808 timeout
= timeval_set(20, 0);
1811 state
.delayed_for_oplocks
= false;
1812 state
.async_open
= true;
1814 if (!request_timed_out(request_time
, timeout
)) {
1815 defer_open(NULL
, request_time
, timeout
, req
, &state
);
1819 /****************************************************************************
1820 Work out what access_mask to use from what the client sent us.
1821 ****************************************************************************/
1823 static NTSTATUS
smbd_calculate_maximum_allowed_access(
1824 connection_struct
*conn
,
1825 const struct smb_filename
*smb_fname
,
1827 uint32_t *p_access_mask
)
1829 struct security_descriptor
*sd
;
1830 uint32_t access_granted
;
1833 if (!use_privs
&& (get_current_uid(conn
) == (uid_t
)0)) {
1834 *p_access_mask
|= FILE_GENERIC_ALL
;
1835 return NT_STATUS_OK
;
1838 status
= SMB_VFS_GET_NT_ACL(conn
, smb_fname
->base_name
,
1844 if (NT_STATUS_EQUAL(status
, NT_STATUS_OBJECT_NAME_NOT_FOUND
)) {
1846 * File did not exist
1848 *p_access_mask
= FILE_GENERIC_ALL
;
1849 return NT_STATUS_OK
;
1851 if (!NT_STATUS_IS_OK(status
)) {
1852 DEBUG(10,("Could not get acl on file %s: %s\n",
1853 smb_fname_str_dbg(smb_fname
),
1854 nt_errstr(status
)));
1855 return NT_STATUS_ACCESS_DENIED
;
1859 * If we can access the path to this file, by
1860 * default we have FILE_READ_ATTRIBUTES from the
1861 * containing directory. See the section:
1862 * "Algorithm to Check Access to an Existing File"
1865 * se_file_access_check()
1866 * also takes care of owner WRITE_DAC and READ_CONTROL.
1868 status
= se_file_access_check(sd
,
1869 get_current_nttok(conn
),
1871 (*p_access_mask
& ~FILE_READ_ATTRIBUTES
),
1876 if (!NT_STATUS_IS_OK(status
)) {
1877 DEBUG(10, ("Access denied on file %s: "
1878 "when calculating maximum access\n",
1879 smb_fname_str_dbg(smb_fname
)));
1880 return NT_STATUS_ACCESS_DENIED
;
1882 *p_access_mask
= (access_granted
| FILE_READ_ATTRIBUTES
);
1884 if (!(access_granted
& DELETE_ACCESS
)) {
1885 if (can_delete_file_in_directory(conn
, smb_fname
)) {
1886 *p_access_mask
|= DELETE_ACCESS
;
1890 return NT_STATUS_OK
;
1893 NTSTATUS
smbd_calculate_access_mask(connection_struct
*conn
,
1894 const struct smb_filename
*smb_fname
,
1896 uint32_t access_mask
,
1897 uint32_t *access_mask_out
)
1900 uint32_t orig_access_mask
= access_mask
;
1901 uint32_t rejected_share_access
;
1904 * Convert GENERIC bits to specific bits.
1907 se_map_generic(&access_mask
, &file_generic_mapping
);
1909 /* Calculate MAXIMUM_ALLOWED_ACCESS if requested. */
1910 if (access_mask
& MAXIMUM_ALLOWED_ACCESS
) {
1912 status
= smbd_calculate_maximum_allowed_access(
1913 conn
, smb_fname
, use_privs
, &access_mask
);
1915 if (!NT_STATUS_IS_OK(status
)) {
1919 access_mask
&= conn
->share_access
;
1922 rejected_share_access
= access_mask
& ~(conn
->share_access
);
1924 if (rejected_share_access
) {
1925 DEBUG(10, ("smbd_calculate_access_mask: Access denied on "
1926 "file %s: rejected by share access mask[0x%08X] "
1927 "orig[0x%08X] mapped[0x%08X] reject[0x%08X]\n",
1928 smb_fname_str_dbg(smb_fname
),
1930 orig_access_mask
, access_mask
,
1931 rejected_share_access
));
1932 return NT_STATUS_ACCESS_DENIED
;
1935 *access_mask_out
= access_mask
;
1936 return NT_STATUS_OK
;
1939 /****************************************************************************
1940 Remove the deferred open entry under lock.
1941 ****************************************************************************/
1943 /****************************************************************************
1944 Return true if this is a state pointer to an asynchronous create.
1945 ****************************************************************************/
1947 bool is_deferred_open_async(const struct deferred_open_record
*rec
)
1949 return rec
->async_open
;
1952 static bool clear_ads(uint32_t create_disposition
)
1956 switch (create_disposition
) {
1957 case FILE_SUPERSEDE
:
1958 case FILE_OVERWRITE_IF
:
1959 case FILE_OVERWRITE
:
1968 static int disposition_to_open_flags(uint32_t create_disposition
)
1973 * Currently we're using FILE_SUPERSEDE as the same as
1974 * FILE_OVERWRITE_IF but they really are
1975 * different. FILE_SUPERSEDE deletes an existing file
1976 * (requiring delete access) then recreates it.
1979 switch (create_disposition
) {
1980 case FILE_SUPERSEDE
:
1981 case FILE_OVERWRITE_IF
:
1983 * If file exists replace/overwrite. If file doesn't
1986 ret
= O_CREAT
|O_TRUNC
;
1991 * If file exists open. If file doesn't exist error.
1996 case FILE_OVERWRITE
:
1998 * If file exists overwrite. If file doesn't exist
2006 * If file exists error. If file doesn't exist create.
2008 ret
= O_CREAT
|O_EXCL
;
2013 * If file exists open. If file doesn't exist create.
2021 static int calculate_open_access_flags(uint32_t access_mask
,
2023 uint32_t private_flags
)
2025 bool need_write
, need_read
;
2028 * Note that we ignore the append flag as append does not
2029 * mean the same thing under DOS and Unix.
2032 need_write
= (access_mask
& (FILE_WRITE_DATA
| FILE_APPEND_DATA
));
2037 /* DENY_DOS opens are always underlying read-write on the
2038 file handle, no matter what the requested access mask
2042 ((private_flags
& NTCREATEX_OPTIONS_PRIVATE_DENY_DOS
) ||
2043 access_mask
& (FILE_READ_ATTRIBUTES
|FILE_READ_DATA
|
2044 FILE_READ_EA
|FILE_EXECUTE
));
2052 /****************************************************************************
2053 Open a file with a share mode. Passed in an already created files_struct *.
2054 ****************************************************************************/
2056 static NTSTATUS
open_file_ntcreate(connection_struct
*conn
,
2057 struct smb_request
*req
,
2058 uint32 access_mask
, /* access bits (FILE_READ_DATA etc.) */
2059 uint32 share_access
, /* share constants (FILE_SHARE_READ etc) */
2060 uint32 create_disposition
, /* FILE_OPEN_IF etc. */
2061 uint32 create_options
, /* options such as delete on close. */
2062 uint32 new_dos_attributes
, /* attributes used for new file. */
2063 int oplock_request
, /* internal Samba oplock codes. */
2064 /* Information (FILE_EXISTS etc.) */
2065 uint32_t private_flags
, /* Samba specific flags. */
2069 struct smb_filename
*smb_fname
= fsp
->fsp_name
;
2072 bool file_existed
= VALID_STAT(smb_fname
->st
);
2073 bool def_acl
= False
;
2074 bool posix_open
= False
;
2075 bool new_file_created
= False
;
2076 bool first_open_attempt
= true;
2077 NTSTATUS fsp_open
= NT_STATUS_ACCESS_DENIED
;
2078 mode_t new_unx_mode
= (mode_t
)0;
2079 mode_t unx_mode
= (mode_t
)0;
2081 uint32 existing_dos_attributes
= 0;
2082 struct timeval request_time
= timeval_zero();
2083 struct share_mode_lock
*lck
= NULL
;
2084 uint32 open_access_mask
= access_mask
;
2087 SMB_STRUCT_STAT saved_stat
= smb_fname
->st
;
2088 struct timespec old_write_time
;
2091 if (conn
->printer
) {
2093 * Printers are handled completely differently.
2094 * Most of the passed parameters are ignored.
2098 *pinfo
= FILE_WAS_CREATED
;
2101 DEBUG(10, ("open_file_ntcreate: printer open fname=%s\n",
2102 smb_fname_str_dbg(smb_fname
)));
2105 DEBUG(0,("open_file_ntcreate: printer open without "
2106 "an SMB request!\n"));
2107 return NT_STATUS_INTERNAL_ERROR
;
2110 return print_spool_open(fsp
, smb_fname
->base_name
,
2114 if (!parent_dirname(talloc_tos(), smb_fname
->base_name
, &parent_dir
,
2116 return NT_STATUS_NO_MEMORY
;
2119 if (new_dos_attributes
& FILE_FLAG_POSIX_SEMANTICS
) {
2121 unx_mode
= (mode_t
)(new_dos_attributes
& ~FILE_FLAG_POSIX_SEMANTICS
);
2122 new_dos_attributes
= 0;
2124 /* Windows allows a new file to be created and
2125 silently removes a FILE_ATTRIBUTE_DIRECTORY
2126 sent by the client. Do the same. */
2128 new_dos_attributes
&= ~FILE_ATTRIBUTE_DIRECTORY
;
2130 /* We add FILE_ATTRIBUTE_ARCHIVE to this as this mode is only used if the file is
2132 unx_mode
= unix_mode(conn
, new_dos_attributes
| FILE_ATTRIBUTE_ARCHIVE
,
2133 smb_fname
, parent_dir
);
2136 DEBUG(10, ("open_file_ntcreate: fname=%s, dos_attrs=0x%x "
2137 "access_mask=0x%x share_access=0x%x "
2138 "create_disposition = 0x%x create_options=0x%x "
2139 "unix mode=0%o oplock_request=%d private_flags = 0x%x\n",
2140 smb_fname_str_dbg(smb_fname
), new_dos_attributes
,
2141 access_mask
, share_access
, create_disposition
,
2142 create_options
, (unsigned int)unx_mode
, oplock_request
,
2143 (unsigned int)private_flags
));
2146 /* Ensure req == NULL means INTERNAL_OPEN_ONLY */
2147 SMB_ASSERT(((oplock_request
& INTERNAL_OPEN_ONLY
) != 0));
2149 /* And req != NULL means no INTERNAL_OPEN_ONLY */
2150 SMB_ASSERT(((oplock_request
& INTERNAL_OPEN_ONLY
) == 0));
2154 * Only non-internal opens can be deferred at all
2158 struct deferred_open_record
*open_rec
;
2159 if (get_deferred_open_message_state(req
,
2162 /* Remember the absolute time of the original
2163 request with this mid. We'll use it later to
2164 see if this has timed out. */
2166 /* If it was an async create retry, the file
2169 if (is_deferred_open_async(open_rec
)) {
2170 SET_STAT_INVALID(smb_fname
->st
);
2171 file_existed
= false;
2174 /* Ensure we don't reprocess this message. */
2175 remove_deferred_open_message_smb(req
->sconn
, req
->mid
);
2177 first_open_attempt
= false;
2182 new_dos_attributes
&= SAMBA_ATTRIBUTES_MASK
;
2184 existing_dos_attributes
= dos_mode(conn
, smb_fname
);
2188 /* ignore any oplock requests if oplocks are disabled */
2189 if (!lp_oplocks(SNUM(conn
)) ||
2190 IS_VETO_OPLOCK_PATH(conn
, smb_fname
->base_name
)) {
2191 /* Mask off everything except the private Samba bits. */
2192 oplock_request
&= SAMBA_PRIVATE_OPLOCK_MASK
;
2195 /* this is for OS/2 long file names - say we don't support them */
2196 if (!lp_posix_pathnames() && strstr(smb_fname
->base_name
,".+,;=[].")) {
2197 /* OS/2 Workplace shell fix may be main code stream in a later
2199 DEBUG(5,("open_file_ntcreate: OS/2 long filenames are not "
2201 if (use_nt_status()) {
2202 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
2204 return NT_STATUS_DOS(ERRDOS
, ERRcannotopen
);
2207 switch( create_disposition
) {
2209 /* If file exists open. If file doesn't exist error. */
2210 if (!file_existed
) {
2211 DEBUG(5,("open_file_ntcreate: FILE_OPEN "
2212 "requested for file %s and file "
2214 smb_fname_str_dbg(smb_fname
)));
2216 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
2220 case FILE_OVERWRITE
:
2221 /* If file exists overwrite. If file doesn't exist
2223 if (!file_existed
) {
2224 DEBUG(5,("open_file_ntcreate: FILE_OVERWRITE "
2225 "requested for file %s and file "
2227 smb_fname_str_dbg(smb_fname
) ));
2229 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
2234 /* If file exists error. If file doesn't exist
2237 DEBUG(5,("open_file_ntcreate: FILE_CREATE "
2238 "requested for file %s and file "
2239 "already exists.\n",
2240 smb_fname_str_dbg(smb_fname
)));
2241 if (S_ISDIR(smb_fname
->st
.st_ex_mode
)) {
2246 return map_nt_error_from_unix(errno
);
2250 case FILE_SUPERSEDE
:
2251 case FILE_OVERWRITE_IF
:
2255 return NT_STATUS_INVALID_PARAMETER
;
2258 flags2
= disposition_to_open_flags(create_disposition
);
2260 /* We only care about matching attributes on file exists and
2263 if (!posix_open
&& file_existed
&&
2264 ((create_disposition
== FILE_OVERWRITE
) ||
2265 (create_disposition
== FILE_OVERWRITE_IF
))) {
2266 if (!open_match_attributes(conn
, existing_dos_attributes
,
2268 smb_fname
->st
.st_ex_mode
,
2269 unx_mode
, &new_unx_mode
)) {
2270 DEBUG(5,("open_file_ntcreate: attributes missmatch "
2271 "for file %s (%x %x) (0%o, 0%o)\n",
2272 smb_fname_str_dbg(smb_fname
),
2273 existing_dos_attributes
,
2275 (unsigned int)smb_fname
->st
.st_ex_mode
,
2276 (unsigned int)unx_mode
));
2278 return NT_STATUS_ACCESS_DENIED
;
2282 status
= smbd_calculate_access_mask(conn
, smb_fname
,
2286 if (!NT_STATUS_IS_OK(status
)) {
2287 DEBUG(10, ("open_file_ntcreate: smbd_calculate_access_mask "
2288 "on file %s returned %s\n",
2289 smb_fname_str_dbg(smb_fname
), nt_errstr(status
)));
2293 open_access_mask
= access_mask
;
2295 if (flags2
& O_TRUNC
) {
2296 open_access_mask
|= FILE_WRITE_DATA
; /* This will cause oplock breaks. */
2299 DEBUG(10, ("open_file_ntcreate: fname=%s, after mapping "
2300 "access_mask=0x%x\n", smb_fname_str_dbg(smb_fname
),
2304 * Note that we ignore the append flag as append does not
2305 * mean the same thing under DOS and Unix.
2308 flags
= calculate_open_access_flags(access_mask
, oplock_request
,
2312 * Currently we only look at FILE_WRITE_THROUGH for create options.
2316 if ((create_options
& FILE_WRITE_THROUGH
) && lp_strict_sync(SNUM(conn
))) {
2321 if (posix_open
&& (access_mask
& FILE_APPEND_DATA
)) {
2325 if (!posix_open
&& !CAN_WRITE(conn
)) {
2327 * We should really return a permission denied error if either
2328 * O_CREAT or O_TRUNC are set, but for compatibility with
2329 * older versions of Samba we just AND them out.
2331 flags2
&= ~(O_CREAT
|O_TRUNC
);
2334 if (first_open_attempt
&& lp_kernel_oplocks(SNUM(conn
))) {
2336 * With kernel oplocks the open breaking an oplock
2337 * blocks until the oplock holder has given up the
2338 * oplock or closed the file. We prevent this by first
2339 * trying to open the file with O_NONBLOCK (see "man
2340 * fcntl" on Linux). For the second try, triggered by
2341 * an oplock break response, we do not need this
2344 * This is true under the assumption that only Samba
2345 * requests kernel oplocks. Once someone else like
2346 * NFSv4 starts to use that API, we will have to
2347 * modify this by communicating with the NFSv4 server.
2349 flags2
|= O_NONBLOCK
;
2353 * Ensure we can't write on a read-only share or file.
2356 if (flags
!= O_RDONLY
&& file_existed
&&
2357 (!CAN_WRITE(conn
) || IS_DOS_READONLY(existing_dos_attributes
))) {
2358 DEBUG(5,("open_file_ntcreate: write access requested for "
2359 "file %s on read only %s\n",
2360 smb_fname_str_dbg(smb_fname
),
2361 !CAN_WRITE(conn
) ? "share" : "file" ));
2363 return NT_STATUS_ACCESS_DENIED
;
2366 fsp
->file_id
= vfs_file_id_from_sbuf(conn
, &smb_fname
->st
);
2367 fsp
->share_access
= share_access
;
2368 fsp
->fh
->private_options
= private_flags
;
2369 fsp
->access_mask
= open_access_mask
; /* We change this to the
2370 * requested access_mask after
2371 * the open is done. */
2372 fsp
->posix_open
= posix_open
;
2374 /* Ensure no SAMBA_PRIVATE bits can be set. */
2375 fsp
->oplock_type
= (oplock_request
& ~SAMBA_PRIVATE_OPLOCK_MASK
);
2377 if (timeval_is_zero(&request_time
)) {
2378 request_time
= fsp
->open_time
;
2382 * Ensure we pay attention to default ACLs on directories if required.
2385 if ((flags2
& O_CREAT
) && lp_inherit_acls(SNUM(conn
)) &&
2386 (def_acl
= directory_has_default_acl(conn
, parent_dir
))) {
2387 unx_mode
= (0777 & lp_create_mask(SNUM(conn
)));
2390 DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o, "
2391 "access_mask = 0x%x, open_access_mask = 0x%x\n",
2392 (unsigned int)flags
, (unsigned int)flags2
,
2393 (unsigned int)unx_mode
, (unsigned int)access_mask
,
2394 (unsigned int)open_access_mask
));
2396 fsp_open
= open_file(fsp
, conn
, req
, parent_dir
,
2397 flags
|flags2
, unx_mode
, access_mask
,
2398 open_access_mask
, &new_file_created
);
2400 if (NT_STATUS_EQUAL(fsp_open
, NT_STATUS_NETWORK_BUSY
)) {
2401 struct deferred_open_record state
;
2404 * EWOULDBLOCK/EAGAIN maps to NETWORK_BUSY.
2406 if (file_existed
&& S_ISFIFO(fsp
->fsp_name
->st
.st_ex_mode
)) {
2407 DEBUG(10, ("FIFO busy\n"));
2408 return NT_STATUS_NETWORK_BUSY
;
2411 DEBUG(10, ("Internal open busy\n"));
2412 return NT_STATUS_NETWORK_BUSY
;
2416 * From here on we assume this is an oplock break triggered
2419 lck
= get_existing_share_mode_lock(talloc_tos(), fsp
->file_id
);
2421 state
.delayed_for_oplocks
= false;
2422 state
.async_open
= false;
2423 state
.id
= fsp
->file_id
;
2424 defer_open(NULL
, request_time
, timeval_set(0, 0),
2426 DEBUG(10, ("No share mode lock found after "
2427 "EWOULDBLOCK, retrying sync\n"));
2428 return NT_STATUS_SHARING_VIOLATION
;
2431 if (!validate_oplock_types(lck
)) {
2432 smb_panic("validate_oplock_types failed");
2435 if (delay_for_oplock(fsp
, 0, lck
, false, create_disposition
)) {
2436 schedule_defer_open(lck
, fsp
->file_id
, request_time
, req
);
2438 DEBUG(10, ("Sent oplock break request to kernel "
2439 "oplock holder\n"));
2440 return NT_STATUS_SHARING_VIOLATION
;
2444 * No oplock from Samba around. Immediately retry with
2447 state
.delayed_for_oplocks
= false;
2448 state
.async_open
= false;
2449 state
.id
= fsp
->file_id
;
2450 defer_open(lck
, request_time
, timeval_set(0, 0), req
, &state
);
2452 DEBUG(10, ("No Samba oplock around after EWOULDBLOCK. "
2453 "Retrying sync\n"));
2454 return NT_STATUS_SHARING_VIOLATION
;
2457 if (!NT_STATUS_IS_OK(fsp_open
)) {
2458 if (NT_STATUS_EQUAL(fsp_open
, NT_STATUS_RETRY
)) {
2459 schedule_async_open(request_time
, req
);
2464 if (file_existed
&& !check_same_dev_ino(&saved_stat
, &smb_fname
->st
)) {
2466 * The file did exist, but some other (local or NFS)
2467 * process either renamed/unlinked and re-created the
2468 * file with different dev/ino after we walked the path,
2469 * but before we did the open. We could retry the
2470 * open but it's a rare enough case it's easier to
2471 * just fail the open to prevent creating any problems
2472 * in the open file db having the wrong dev/ino key.
2475 DEBUG(1,("open_file_ntcreate: file %s - dev/ino mismatch. "
2476 "Old (dev=0x%llu, ino =0x%llu). "
2477 "New (dev=0x%llu, ino=0x%llu). Failing open "
2478 " with NT_STATUS_ACCESS_DENIED.\n",
2479 smb_fname_str_dbg(smb_fname
),
2480 (unsigned long long)saved_stat
.st_ex_dev
,
2481 (unsigned long long)saved_stat
.st_ex_ino
,
2482 (unsigned long long)smb_fname
->st
.st_ex_dev
,
2483 (unsigned long long)smb_fname
->st
.st_ex_ino
));
2484 return NT_STATUS_ACCESS_DENIED
;
2487 old_write_time
= smb_fname
->st
.st_ex_mtime
;
2490 * Deal with the race condition where two smbd's detect the
2491 * file doesn't exist and do the create at the same time. One
2492 * of them will win and set a share mode, the other (ie. this
2493 * one) should check if the requested share mode for this
2494 * create is allowed.
2498 * Now the file exists and fsp is successfully opened,
2499 * fsp->dev and fsp->inode are valid and should replace the
2500 * dev=0,inode=0 from a non existent file. Spotted by
2501 * Nadav Danieli <nadavd@exanet.com>. JRA.
2506 lck
= get_share_mode_lock(talloc_tos(), id
,
2508 smb_fname
, &old_write_time
);
2511 DEBUG(0, ("open_file_ntcreate: Could not get share "
2512 "mode lock for %s\n",
2513 smb_fname_str_dbg(smb_fname
)));
2515 return NT_STATUS_SHARING_VIOLATION
;
2518 /* Get the types we need to examine. */
2519 if (!validate_oplock_types(lck
)) {
2520 smb_panic("validate_oplock_types failed");
2523 if (has_delete_on_close(lck
, fsp
->name_hash
)) {
2526 return NT_STATUS_DELETE_PENDING
;
2529 status
= open_mode_check(conn
, lck
,
2530 access_mask
, share_access
);
2532 if (NT_STATUS_EQUAL(status
, NT_STATUS_SHARING_VIOLATION
) ||
2533 (lck
->data
->num_share_modes
> 0)) {
2535 * This comes from ancient times out of open_mode_check. I
2536 * have no clue whether this is still necessary. I can't think
2537 * of a case where this would actually matter further down in
2538 * this function. I leave it here for further investigation
2541 file_existed
= true;
2544 if ((req
!= NULL
) &&
2546 fsp
, oplock_request
, lck
,
2547 NT_STATUS_EQUAL(status
, NT_STATUS_SHARING_VIOLATION
),
2548 create_disposition
)) {
2549 schedule_defer_open(lck
, fsp
->file_id
, request_time
, req
);
2552 return NT_STATUS_SHARING_VIOLATION
;
2555 if (!NT_STATUS_IS_OK(status
)) {
2556 uint32 can_access_mask
;
2557 bool can_access
= True
;
2559 SMB_ASSERT(NT_STATUS_EQUAL(status
, NT_STATUS_SHARING_VIOLATION
));
2561 /* Check if this can be done with the deny_dos and fcb
2564 (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS
|
2565 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB
)) {
2567 DEBUG(0, ("DOS open without an SMB "
2571 return NT_STATUS_INTERNAL_ERROR
;
2574 /* Use the client requested access mask here,
2575 * not the one we open with. */
2576 status
= fcb_or_dos_open(req
,
2587 if (NT_STATUS_IS_OK(status
)) {
2590 *pinfo
= FILE_WAS_OPENED
;
2592 return NT_STATUS_OK
;
2597 * This next line is a subtlety we need for
2598 * MS-Access. If a file open will fail due to share
2599 * permissions and also for security (access) reasons,
2600 * we need to return the access failed error, not the
2601 * share error. We can't open the file due to kernel
2602 * oplock deadlock (it's possible we failed above on
2603 * the open_mode_check()) so use a userspace check.
2606 if (flags
& O_RDWR
) {
2607 can_access_mask
= FILE_READ_DATA
|FILE_WRITE_DATA
;
2608 } else if (flags
& O_WRONLY
) {
2609 can_access_mask
= FILE_WRITE_DATA
;
2611 can_access_mask
= FILE_READ_DATA
;
2614 if (((can_access_mask
& FILE_WRITE_DATA
) &&
2615 !CAN_WRITE(conn
)) ||
2616 !NT_STATUS_IS_OK(smbd_check_access_rights(conn
,
2619 can_access_mask
))) {
2624 * If we're returning a share violation, ensure we
2625 * cope with the braindead 1 second delay (SMB1 only).
2628 if (!(oplock_request
& INTERNAL_OPEN_ONLY
) &&
2629 !conn
->sconn
->using_smb2
&&
2630 lp_defer_sharing_violations()) {
2631 struct timeval timeout
;
2632 struct deferred_open_record state
;
2635 /* this is a hack to speed up torture tests
2637 timeout_usecs
= lp_parm_int(SNUM(conn
),
2638 "smbd","sharedelay",
2639 SHARING_VIOLATION_USEC_WAIT
);
2641 /* This is a relative time, added to the absolute
2642 request_time value to get the absolute timeout time.
2643 Note that if this is the second or greater time we enter
2644 this codepath for this particular request mid then
2645 request_time is left as the absolute time of the *first*
2646 time this request mid was processed. This is what allows
2647 the request to eventually time out. */
2649 timeout
= timeval_set(0, timeout_usecs
);
2651 /* Nothing actually uses state.delayed_for_oplocks
2652 but it's handy to differentiate in debug messages
2653 between a 30 second delay due to oplock break, and
2654 a 1 second delay for share mode conflicts. */
2656 state
.delayed_for_oplocks
= False
;
2657 state
.async_open
= false;
2661 && !request_timed_out(request_time
,
2663 defer_open(lck
, request_time
, timeout
,
2672 * We have detected a sharing violation here
2673 * so return the correct error code
2675 status
= NT_STATUS_SHARING_VIOLATION
;
2677 status
= NT_STATUS_ACCESS_DENIED
;
2682 /* Should we atomically (to the client at least) truncate ? */
2683 if ((!new_file_created
) &&
2684 (flags2
& O_TRUNC
) &&
2685 (!S_ISFIFO(fsp
->fsp_name
->st
.st_ex_mode
))) {
2688 ret
= vfs_set_filelen(fsp
, 0);
2690 status
= map_nt_error_from_unix(errno
);
2697 grant_fsp_oplock_type(fsp
, lck
, oplock_request
);
2700 * We have the share entry *locked*.....
2703 /* Delete streams if create_disposition requires it */
2704 if (!new_file_created
&& clear_ads(create_disposition
) &&
2705 !is_ntfs_stream_smb_fname(smb_fname
)) {
2706 status
= delete_all_streams(conn
, smb_fname
->base_name
);
2707 if (!NT_STATUS_IS_OK(status
)) {
2714 /* note that we ignore failure for the following. It is
2715 basically a hack for NFS, and NFS will never set one of
2716 these only read them. Nobody but Samba can ever set a deny
2717 mode and we have already checked our more authoritative
2718 locking database for permission to set this deny mode. If
2719 the kernel refuses the operations then the kernel is wrong.
2720 note that GPFS supports it as well - jmcd */
2722 if (fsp
->fh
->fd
!= -1 && lp_kernel_share_modes(SNUM(conn
))) {
2724 ret_flock
= SMB_VFS_KERNEL_FLOCK(fsp
, share_access
, access_mask
);
2725 if(ret_flock
== -1 ){
2730 return NT_STATUS_SHARING_VIOLATION
;
2735 * At this point onwards, we can guarantee that the share entry
2736 * is locked, whether we created the file or not, and that the
2737 * deny mode is compatible with all current opens.
2741 * According to Samba4, SEC_FILE_READ_ATTRIBUTE is always granted,
2742 * but we don't have to store this - just ignore it on access check.
2744 if (conn
->sconn
->using_smb2
) {
2746 * SMB2 doesn't return it (according to Microsoft tests).
2747 * Test Case: TestSuite_ScenarioNo009GrantedAccessTestS0
2748 * File created with access = 0x7 (Read, Write, Delete)
2749 * Query Info on file returns 0x87 (Read, Write, Delete, Read Attributes)
2751 fsp
->access_mask
= access_mask
;
2753 /* But SMB1 does. */
2754 fsp
->access_mask
= access_mask
| FILE_READ_ATTRIBUTES
;
2758 /* stat opens on existing files don't get oplocks. */
2759 if (is_stat_open(open_access_mask
)) {
2760 fsp
->oplock_type
= NO_OPLOCK
;
2764 if (new_file_created
) {
2765 info
= FILE_WAS_CREATED
;
2767 if (flags2
& O_TRUNC
) {
2768 info
= FILE_WAS_OVERWRITTEN
;
2770 info
= FILE_WAS_OPENED
;
2779 * Setup the oplock info in both the shared memory and
2783 status
= set_file_oplock(fsp
);
2784 if (!NT_STATUS_IS_OK(status
)) {
2786 * Could not get the kernel oplock
2788 fsp
->oplock_type
= NO_OPLOCK
;
2791 if (!set_share_mode(lck
, fsp
, get_current_uid(conn
),
2793 fsp
->oplock_type
)) {
2796 return NT_STATUS_NO_MEMORY
;
2799 /* Handle strange delete on close create semantics. */
2800 if (create_options
& FILE_DELETE_ON_CLOSE
) {
2802 status
= can_set_delete_on_close(fsp
, new_dos_attributes
);
2804 if (!NT_STATUS_IS_OK(status
)) {
2805 /* Remember to delete the mode we just added. */
2806 del_share_mode(lck
, fsp
);
2811 /* Note that here we set the *inital* delete on close flag,
2812 not the regular one. The magic gets handled in close. */
2813 fsp
->initial_delete_on_close
= True
;
2816 if (info
!= FILE_WAS_OPENED
) {
2817 /* Files should be initially set as archive */
2818 if (lp_map_archive(SNUM(conn
)) ||
2819 lp_store_dos_attributes(SNUM(conn
))) {
2821 if (file_set_dosmode(conn
, smb_fname
,
2822 new_dos_attributes
| FILE_ATTRIBUTE_ARCHIVE
,
2823 parent_dir
, true) == 0) {
2824 unx_mode
= smb_fname
->st
.st_ex_mode
;
2830 /* Determine sparse flag. */
2832 /* POSIX opens are sparse by default. */
2833 fsp
->is_sparse
= true;
2835 fsp
->is_sparse
= (file_existed
&&
2836 (existing_dos_attributes
& FILE_ATTRIBUTE_SPARSE
));
2840 * Take care of inherited ACLs on created files - if default ACL not
2844 if (!posix_open
&& new_file_created
&& !def_acl
) {
2846 int saved_errno
= errno
; /* We might get ENOSYS in the next
2849 if (SMB_VFS_FCHMOD_ACL(fsp
, unx_mode
) == -1 &&
2851 errno
= saved_errno
; /* Ignore ENOSYS */
2854 } else if (new_unx_mode
) {
2858 /* Attributes need changing. File already existed. */
2861 int saved_errno
= errno
; /* We might get ENOSYS in the
2863 ret
= SMB_VFS_FCHMOD_ACL(fsp
, new_unx_mode
);
2865 if (ret
== -1 && errno
== ENOSYS
) {
2866 errno
= saved_errno
; /* Ignore ENOSYS */
2868 DEBUG(5, ("open_file_ntcreate: reset "
2869 "attributes of file %s to 0%o\n",
2870 smb_fname_str_dbg(smb_fname
),
2871 (unsigned int)new_unx_mode
));
2872 ret
= 0; /* Don't do the fchmod below. */
2877 (SMB_VFS_FCHMOD(fsp
, new_unx_mode
) == -1))
2878 DEBUG(5, ("open_file_ntcreate: failed to reset "
2879 "attributes of file %s to 0%o\n",
2880 smb_fname_str_dbg(smb_fname
),
2881 (unsigned int)new_unx_mode
));
2886 * Deal with other opens having a modified write time.
2888 struct timespec write_time
= get_share_mode_write_time(lck
);
2890 if (!null_timespec(write_time
)) {
2891 update_stat_ex_mtime(&fsp
->fsp_name
->st
, write_time
);
2897 return NT_STATUS_OK
;
2900 static NTSTATUS
mkdir_internal(connection_struct
*conn
,
2901 struct smb_filename
*smb_dname
,
2902 uint32 file_attributes
)
2905 char *parent_dir
= NULL
;
2907 bool posix_open
= false;
2908 bool need_re_stat
= false;
2909 uint32_t access_mask
= SEC_DIR_ADD_SUBDIR
;
2911 if (!CAN_WRITE(conn
) || (access_mask
& ~(conn
->share_access
))) {
2912 DEBUG(5,("mkdir_internal: failing share access "
2913 "%s\n", lp_servicename(talloc_tos(), SNUM(conn
))));
2914 return NT_STATUS_ACCESS_DENIED
;
2917 if (!parent_dirname(talloc_tos(), smb_dname
->base_name
, &parent_dir
,
2919 return NT_STATUS_NO_MEMORY
;
2922 if (file_attributes
& FILE_FLAG_POSIX_SEMANTICS
) {
2924 mode
= (mode_t
)(file_attributes
& ~FILE_FLAG_POSIX_SEMANTICS
);
2926 mode
= unix_mode(conn
, FILE_ATTRIBUTE_DIRECTORY
, smb_dname
, parent_dir
);
2929 status
= check_parent_access(conn
,
2932 if(!NT_STATUS_IS_OK(status
)) {
2933 DEBUG(5,("mkdir_internal: check_parent_access "
2934 "on directory %s for path %s returned %s\n",
2936 smb_dname
->base_name
,
2937 nt_errstr(status
) ));
2941 if (SMB_VFS_MKDIR(conn
, smb_dname
->base_name
, mode
) != 0) {
2942 return map_nt_error_from_unix(errno
);
2945 /* Ensure we're checking for a symlink here.... */
2946 /* We don't want to get caught by a symlink racer. */
2948 if (SMB_VFS_LSTAT(conn
, smb_dname
) == -1) {
2949 DEBUG(2, ("Could not stat directory '%s' just created: %s\n",
2950 smb_fname_str_dbg(smb_dname
), strerror(errno
)));
2951 return map_nt_error_from_unix(errno
);
2954 if (!S_ISDIR(smb_dname
->st
.st_ex_mode
)) {
2955 DEBUG(0, ("Directory '%s' just created is not a directory !\n",
2956 smb_fname_str_dbg(smb_dname
)));
2957 return NT_STATUS_NOT_A_DIRECTORY
;
2960 if (lp_store_dos_attributes(SNUM(conn
))) {
2962 file_set_dosmode(conn
, smb_dname
,
2963 file_attributes
| FILE_ATTRIBUTE_DIRECTORY
,
2968 if (lp_inherit_permissions(SNUM(conn
))) {
2969 inherit_access_posix_acl(conn
, parent_dir
,
2970 smb_dname
->base_name
, mode
);
2971 need_re_stat
= true;
2976 * Check if high bits should have been set,
2977 * then (if bits are missing): add them.
2978 * Consider bits automagically set by UNIX, i.e. SGID bit from parent
2981 if ((mode
& ~(S_IRWXU
|S_IRWXG
|S_IRWXO
)) &&
2982 (mode
& ~smb_dname
->st
.st_ex_mode
)) {
2983 SMB_VFS_CHMOD(conn
, smb_dname
->base_name
,
2984 (smb_dname
->st
.st_ex_mode
|
2985 (mode
& ~smb_dname
->st
.st_ex_mode
)));
2986 need_re_stat
= true;
2990 /* Change the owner if required. */
2991 if (lp_inherit_owner(SNUM(conn
))) {
2992 change_dir_owner_to_parent(conn
, parent_dir
,
2993 smb_dname
->base_name
,
2995 need_re_stat
= true;
2999 if (SMB_VFS_LSTAT(conn
, smb_dname
) == -1) {
3000 DEBUG(2, ("Could not stat directory '%s' just created: %s\n",
3001 smb_fname_str_dbg(smb_dname
), strerror(errno
)));
3002 return map_nt_error_from_unix(errno
);
3006 notify_fname(conn
, NOTIFY_ACTION_ADDED
, FILE_NOTIFY_CHANGE_DIR_NAME
,
3007 smb_dname
->base_name
);
3009 return NT_STATUS_OK
;
3012 /****************************************************************************
3013 Open a directory from an NT SMB call.
3014 ****************************************************************************/
3016 static NTSTATUS
open_directory(connection_struct
*conn
,
3017 struct smb_request
*req
,
3018 struct smb_filename
*smb_dname
,
3020 uint32 share_access
,
3021 uint32 create_disposition
,
3022 uint32 create_options
,
3023 uint32 file_attributes
,
3025 files_struct
**result
)
3027 files_struct
*fsp
= NULL
;
3028 bool dir_existed
= VALID_STAT(smb_dname
->st
) ? True
: False
;
3029 struct share_mode_lock
*lck
= NULL
;
3031 struct timespec mtimespec
;
3034 if (is_ntfs_stream_smb_fname(smb_dname
)) {
3035 DEBUG(2, ("open_directory: %s is a stream name!\n",
3036 smb_fname_str_dbg(smb_dname
)));
3037 return NT_STATUS_NOT_A_DIRECTORY
;
3040 if (!(file_attributes
& FILE_FLAG_POSIX_SEMANTICS
)) {
3041 /* Ensure we have a directory attribute. */
3042 file_attributes
|= FILE_ATTRIBUTE_DIRECTORY
;
3045 DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
3046 "share_access = 0x%x create_options = 0x%x, "
3047 "create_disposition = 0x%x, file_attributes = 0x%x\n",
3048 smb_fname_str_dbg(smb_dname
),
3049 (unsigned int)access_mask
,
3050 (unsigned int)share_access
,
3051 (unsigned int)create_options
,
3052 (unsigned int)create_disposition
,
3053 (unsigned int)file_attributes
));
3055 status
= smbd_calculate_access_mask(conn
, smb_dname
, false,
3056 access_mask
, &access_mask
);
3057 if (!NT_STATUS_IS_OK(status
)) {
3058 DEBUG(10, ("open_directory: smbd_calculate_access_mask "
3059 "on file %s returned %s\n",
3060 smb_fname_str_dbg(smb_dname
),
3061 nt_errstr(status
)));
3065 if ((access_mask
& SEC_FLAG_SYSTEM_SECURITY
) &&
3066 !security_token_has_privilege(get_current_nttok(conn
),
3067 SEC_PRIV_SECURITY
)) {
3068 DEBUG(10, ("open_directory: open on %s "
3069 "failed - SEC_FLAG_SYSTEM_SECURITY denied.\n",
3070 smb_fname_str_dbg(smb_dname
)));
3071 return NT_STATUS_PRIVILEGE_NOT_HELD
;
3074 switch( create_disposition
) {
3078 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
3081 info
= FILE_WAS_OPENED
;
3086 /* If directory exists error. If directory doesn't
3090 status
= NT_STATUS_OBJECT_NAME_COLLISION
;
3091 DEBUG(2, ("open_directory: unable to create "
3092 "%s. Error was %s\n",
3093 smb_fname_str_dbg(smb_dname
),
3094 nt_errstr(status
)));
3098 status
= mkdir_internal(conn
, smb_dname
,
3101 if (!NT_STATUS_IS_OK(status
)) {
3102 DEBUG(2, ("open_directory: unable to create "
3103 "%s. Error was %s\n",
3104 smb_fname_str_dbg(smb_dname
),
3105 nt_errstr(status
)));
3109 info
= FILE_WAS_CREATED
;
3114 * If directory exists open. If directory doesn't
3119 status
= NT_STATUS_OK
;
3120 info
= FILE_WAS_OPENED
;
3122 status
= mkdir_internal(conn
, smb_dname
,
3125 if (NT_STATUS_IS_OK(status
)) {
3126 info
= FILE_WAS_CREATED
;
3128 /* Cope with create race. */
3129 if (!NT_STATUS_EQUAL(status
,
3130 NT_STATUS_OBJECT_NAME_COLLISION
)) {
3131 DEBUG(2, ("open_directory: unable to create "
3132 "%s. Error was %s\n",
3133 smb_fname_str_dbg(smb_dname
),
3134 nt_errstr(status
)));
3137 info
= FILE_WAS_OPENED
;
3143 case FILE_SUPERSEDE
:
3144 case FILE_OVERWRITE
:
3145 case FILE_OVERWRITE_IF
:
3147 DEBUG(5,("open_directory: invalid create_disposition "
3148 "0x%x for directory %s\n",
3149 (unsigned int)create_disposition
,
3150 smb_fname_str_dbg(smb_dname
)));
3151 return NT_STATUS_INVALID_PARAMETER
;
3154 if(!S_ISDIR(smb_dname
->st
.st_ex_mode
)) {
3155 DEBUG(5,("open_directory: %s is not a directory !\n",
3156 smb_fname_str_dbg(smb_dname
)));
3157 return NT_STATUS_NOT_A_DIRECTORY
;
3160 if (info
== FILE_WAS_OPENED
) {
3161 status
= smbd_check_access_rights(conn
,
3165 if (!NT_STATUS_IS_OK(status
)) {
3166 DEBUG(10, ("open_directory: smbd_check_access_rights on "
3167 "file %s failed with %s\n",
3168 smb_fname_str_dbg(smb_dname
),
3169 nt_errstr(status
)));
3174 status
= file_new(req
, conn
, &fsp
);
3175 if(!NT_STATUS_IS_OK(status
)) {
3180 * Setup the files_struct for it.
3183 fsp
->file_id
= vfs_file_id_from_sbuf(conn
, &smb_dname
->st
);
3184 fsp
->vuid
= req
? req
->vuid
: UID_FIELD_INVALID
;
3185 fsp
->file_pid
= req
? req
->smbpid
: 0;
3186 fsp
->can_lock
= False
;
3187 fsp
->can_read
= False
;
3188 fsp
->can_write
= False
;
3190 fsp
->share_access
= share_access
;
3191 fsp
->fh
->private_options
= 0;
3193 * According to Samba4, SEC_FILE_READ_ATTRIBUTE is always granted,
3195 fsp
->access_mask
= access_mask
| FILE_READ_ATTRIBUTES
;
3196 fsp
->print_file
= NULL
;
3197 fsp
->modified
= False
;
3198 fsp
->oplock_type
= NO_OPLOCK
;
3199 fsp
->sent_oplock_break
= NO_BREAK_SENT
;
3200 fsp
->is_directory
= True
;
3201 fsp
->posix_open
= (file_attributes
& FILE_FLAG_POSIX_SEMANTICS
) ? True
: False
;
3202 status
= fsp_set_smb_fname(fsp
, smb_dname
);
3203 if (!NT_STATUS_IS_OK(status
)) {
3204 file_free(req
, fsp
);
3208 /* Don't store old timestamps for directory
3209 handles in the internal database. We don't
3210 update them in there if new objects
3211 are creaded in the directory. Currently
3212 we only update timestamps on file writes.
3215 ZERO_STRUCT(mtimespec
);
3217 if (access_mask
& (FILE_LIST_DIRECTORY
|
3219 FILE_ADD_SUBDIRECTORY
|
3222 FILE_DELETE_CHILD
)) {
3224 status
= fd_open(conn
, fsp
, O_RDONLY
|O_DIRECTORY
, 0);
3226 /* POSIX allows us to open a directory with O_RDONLY. */
3227 status
= fd_open(conn
, fsp
, O_RDONLY
, 0);
3229 if (!NT_STATUS_IS_OK(status
)) {
3230 DEBUG(5, ("open_directory: Could not open fd for "
3232 smb_fname_str_dbg(smb_dname
),
3233 nt_errstr(status
)));
3234 file_free(req
, fsp
);
3239 DEBUG(10, ("Not opening Directory %s\n",
3240 smb_fname_str_dbg(smb_dname
)));
3243 status
= vfs_stat_fsp(fsp
);
3244 if (!NT_STATUS_IS_OK(status
)) {
3246 file_free(req
, fsp
);
3250 /* Ensure there was no race condition. */
3251 if (!check_same_stat(&smb_dname
->st
, &fsp
->fsp_name
->st
)) {
3252 DEBUG(5,("open_directory: stat struct differs for "
3254 smb_fname_str_dbg(smb_dname
)));
3256 file_free(req
, fsp
);
3257 return NT_STATUS_ACCESS_DENIED
;
3260 lck
= get_share_mode_lock(talloc_tos(), fsp
->file_id
,
3261 conn
->connectpath
, smb_dname
,
3265 DEBUG(0, ("open_directory: Could not get share mode lock for "
3266 "%s\n", smb_fname_str_dbg(smb_dname
)));
3268 file_free(req
, fsp
);
3269 return NT_STATUS_SHARING_VIOLATION
;
3272 if (has_delete_on_close(lck
, fsp
->name_hash
)) {
3275 file_free(req
, fsp
);
3276 return NT_STATUS_DELETE_PENDING
;
3279 status
= open_mode_check(conn
, lck
,
3280 access_mask
, share_access
);
3282 if (!NT_STATUS_IS_OK(status
)) {
3285 file_free(req
, fsp
);
3289 if (!set_share_mode(lck
, fsp
, get_current_uid(conn
),
3290 req
? req
->mid
: 0, NO_OPLOCK
)) {
3293 file_free(req
, fsp
);
3294 return NT_STATUS_NO_MEMORY
;
3297 /* For directories the delete on close bit at open time seems
3298 always to be honored on close... See test 19 in Samba4 BASE-DELETE. */
3299 if (create_options
& FILE_DELETE_ON_CLOSE
) {
3300 status
= can_set_delete_on_close(fsp
, 0);
3301 if (!NT_STATUS_IS_OK(status
) && !NT_STATUS_EQUAL(status
, NT_STATUS_DIRECTORY_NOT_EMPTY
)) {
3302 del_share_mode(lck
, fsp
);
3305 file_free(req
, fsp
);
3309 if (NT_STATUS_IS_OK(status
)) {
3310 /* Note that here we set the *inital* delete on close flag,
3311 not the regular one. The magic gets handled in close. */
3312 fsp
->initial_delete_on_close
= True
;
3318 * Deal with other opens having a modified write time. Is this
3319 * possible for directories?
3321 struct timespec write_time
= get_share_mode_write_time(lck
);
3323 if (!null_timespec(write_time
)) {
3324 update_stat_ex_mtime(&fsp
->fsp_name
->st
, write_time
);
3335 return NT_STATUS_OK
;
3338 NTSTATUS
create_directory(connection_struct
*conn
, struct smb_request
*req
,
3339 struct smb_filename
*smb_dname
)
3344 status
= SMB_VFS_CREATE_FILE(
3347 0, /* root_dir_fid */
3348 smb_dname
, /* fname */
3349 FILE_READ_ATTRIBUTES
, /* access_mask */
3350 FILE_SHARE_NONE
, /* share_access */
3351 FILE_CREATE
, /* create_disposition*/
3352 FILE_DIRECTORY_FILE
, /* create_options */
3353 FILE_ATTRIBUTE_DIRECTORY
, /* file_attributes */
3354 0, /* oplock_request */
3355 0, /* allocation_size */
3356 0, /* private_flags */
3362 if (NT_STATUS_IS_OK(status
)) {
3363 close_file(req
, fsp
, NORMAL_CLOSE
);
3369 /****************************************************************************
3370 Receive notification that one of our open files has been renamed by another
3372 ****************************************************************************/
3374 void msg_file_was_renamed(struct messaging_context
*msg
,
3377 struct server_id server_id
,
3381 char *frm
= (char *)data
->data
;
3383 const char *sharepath
;
3384 const char *base_name
;
3385 const char *stream_name
;
3386 struct smb_filename
*smb_fname
= NULL
;
3387 size_t sp_len
, bn_len
;
3389 struct smbd_server_connection
*sconn
=
3390 talloc_get_type_abort(private_data
,
3391 struct smbd_server_connection
);
3393 if (data
->data
== NULL
3394 || data
->length
< MSG_FILE_RENAMED_MIN_SIZE
+ 2) {
3395 DEBUG(0, ("msg_file_was_renamed: Got invalid msg len %d\n",
3396 (int)data
->length
));
3400 /* Unpack the message. */
3401 pull_file_id_24(frm
, &id
);
3402 sharepath
= &frm
[24];
3403 sp_len
= strlen(sharepath
);
3404 base_name
= sharepath
+ sp_len
+ 1;
3405 bn_len
= strlen(base_name
);
3406 stream_name
= sharepath
+ sp_len
+ 1 + bn_len
+ 1;
3408 /* stream_name must always be NULL if there is no stream. */
3409 if (stream_name
[0] == '\0') {
3413 smb_fname
= synthetic_smb_fname(talloc_tos(), base_name
,
3415 if (smb_fname
== NULL
) {
3419 DEBUG(10,("msg_file_was_renamed: Got rename message for sharepath %s, new name %s, "
3421 sharepath
, smb_fname_str_dbg(smb_fname
),
3422 file_id_string_tos(&id
)));
3424 for(fsp
= file_find_di_first(sconn
, id
); fsp
;
3425 fsp
= file_find_di_next(fsp
)) {
3426 if (memcmp(fsp
->conn
->connectpath
, sharepath
, sp_len
) == 0) {
3428 DEBUG(10,("msg_file_was_renamed: renaming file %s from %s -> %s\n",
3429 fsp_fnum_dbg(fsp
), fsp_str_dbg(fsp
),
3430 smb_fname_str_dbg(smb_fname
)));
3431 status
= fsp_set_smb_fname(fsp
, smb_fname
);
3432 if (!NT_STATUS_IS_OK(status
)) {
3437 /* Now we have the complete path we can work out if this is
3438 actually within this share and adjust newname accordingly. */
3439 DEBUG(10,("msg_file_was_renamed: share mismatch (sharepath %s "
3440 "not sharepath %s) "
3441 "%s from %s -> %s\n",
3442 fsp
->conn
->connectpath
,
3446 smb_fname_str_dbg(smb_fname
)));
3450 TALLOC_FREE(smb_fname
);
3455 * If a main file is opened for delete, all streams need to be checked for
3456 * !FILE_SHARE_DELETE. Do this by opening with DELETE_ACCESS.
3457 * If that works, delete them all by setting the delete on close and close.
3460 NTSTATUS
open_streams_for_delete(connection_struct
*conn
,
3463 struct stream_struct
*stream_info
= NULL
;
3464 files_struct
**streams
= NULL
;
3466 unsigned int num_streams
= 0;
3467 TALLOC_CTX
*frame
= talloc_stackframe();
3470 status
= vfs_streaminfo(conn
, NULL
, fname
, talloc_tos(),
3471 &num_streams
, &stream_info
);
3473 if (NT_STATUS_EQUAL(status
, NT_STATUS_NOT_IMPLEMENTED
)
3474 || NT_STATUS_EQUAL(status
, NT_STATUS_OBJECT_NAME_NOT_FOUND
)) {
3475 DEBUG(10, ("no streams around\n"));
3477 return NT_STATUS_OK
;
3480 if (!NT_STATUS_IS_OK(status
)) {
3481 DEBUG(10, ("vfs_streaminfo failed: %s\n",
3482 nt_errstr(status
)));
3486 DEBUG(10, ("open_streams_for_delete found %d streams\n",
3489 if (num_streams
== 0) {
3491 return NT_STATUS_OK
;
3494 streams
= talloc_array(talloc_tos(), files_struct
*, num_streams
);
3495 if (streams
== NULL
) {
3496 DEBUG(0, ("talloc failed\n"));
3497 status
= NT_STATUS_NO_MEMORY
;
3501 for (i
=0; i
<num_streams
; i
++) {
3502 struct smb_filename
*smb_fname
;
3504 if (strequal(stream_info
[i
].name
, "::$DATA")) {
3509 smb_fname
= synthetic_smb_fname(
3510 talloc_tos(), fname
, stream_info
[i
].name
, NULL
);
3511 if (smb_fname
== NULL
) {
3512 status
= NT_STATUS_NO_MEMORY
;
3516 if (SMB_VFS_STAT(conn
, smb_fname
) == -1) {
3517 DEBUG(10, ("Unable to stat stream: %s\n",
3518 smb_fname_str_dbg(smb_fname
)));
3521 status
= SMB_VFS_CREATE_FILE(
3524 0, /* root_dir_fid */
3525 smb_fname
, /* fname */
3526 DELETE_ACCESS
, /* access_mask */
3527 (FILE_SHARE_READ
| /* share_access */
3528 FILE_SHARE_WRITE
| FILE_SHARE_DELETE
),
3529 FILE_OPEN
, /* create_disposition*/
3530 0, /* create_options */
3531 FILE_ATTRIBUTE_NORMAL
, /* file_attributes */
3532 0, /* oplock_request */
3533 0, /* allocation_size */
3534 NTCREATEX_OPTIONS_PRIVATE_STREAM_DELETE
, /* private_flags */
3537 &streams
[i
], /* result */
3540 if (!NT_STATUS_IS_OK(status
)) {
3541 DEBUG(10, ("Could not open stream %s: %s\n",
3542 smb_fname_str_dbg(smb_fname
),
3543 nt_errstr(status
)));
3545 TALLOC_FREE(smb_fname
);
3548 TALLOC_FREE(smb_fname
);
3552 * don't touch the variable "status" beyond this point :-)
3555 for (i
-= 1 ; i
>= 0; i
--) {
3556 if (streams
[i
] == NULL
) {
3560 DEBUG(10, ("Closing stream # %d, %s\n", i
,
3561 fsp_str_dbg(streams
[i
])));
3562 close_file(NULL
, streams
[i
], NORMAL_CLOSE
);
3570 /*********************************************************************
3571 Create a default ACL by inheriting from the parent. If no inheritance
3572 from the parent available, don't set anything. This will leave the actual
3573 permissions the new file or directory already got from the filesystem
3574 as the NT ACL when read.
3575 *********************************************************************/
3577 static NTSTATUS
inherit_new_acl(files_struct
*fsp
)
3579 TALLOC_CTX
*frame
= talloc_stackframe();
3580 char *parent_name
= NULL
;
3581 struct security_descriptor
*parent_desc
= NULL
;
3582 NTSTATUS status
= NT_STATUS_OK
;
3583 struct security_descriptor
*psd
= NULL
;
3584 const struct dom_sid
*owner_sid
= NULL
;
3585 const struct dom_sid
*group_sid
= NULL
;
3586 uint32_t security_info_sent
= (SECINFO_OWNER
| SECINFO_GROUP
| SECINFO_DACL
);
3587 struct security_token
*token
= fsp
->conn
->session_info
->security_token
;
3588 bool inherit_owner
= lp_inherit_owner(SNUM(fsp
->conn
));
3589 bool inheritable_components
= false;
3590 bool try_builtin_administrators
= false;
3591 const struct dom_sid
*BA_U_sid
= NULL
;
3592 const struct dom_sid
*BA_G_sid
= NULL
;
3593 bool try_system
= false;
3594 const struct dom_sid
*SY_U_sid
= NULL
;
3595 const struct dom_sid
*SY_G_sid
= NULL
;
3598 if (!parent_dirname(frame
, fsp
->fsp_name
->base_name
, &parent_name
, NULL
)) {
3600 return NT_STATUS_NO_MEMORY
;
3603 status
= SMB_VFS_GET_NT_ACL(fsp
->conn
,
3605 (SECINFO_OWNER
| SECINFO_GROUP
| SECINFO_DACL
),
3608 if (!NT_STATUS_IS_OK(status
)) {
3613 inheritable_components
= sd_has_inheritable_components(parent_desc
,
3616 if (!inheritable_components
&& !inherit_owner
) {
3618 /* Nothing to inherit and not setting owner. */
3619 return NT_STATUS_OK
;
3622 /* Create an inherited descriptor from the parent. */
3624 if (DEBUGLEVEL
>= 10) {
3625 DEBUG(10,("inherit_new_acl: parent acl for %s is:\n",
3626 fsp_str_dbg(fsp
) ));
3627 NDR_PRINT_DEBUG(security_descriptor
, parent_desc
);
3630 /* Inherit from parent descriptor if "inherit owner" set. */
3631 if (inherit_owner
) {
3632 owner_sid
= parent_desc
->owner_sid
;
3633 group_sid
= parent_desc
->group_sid
;
3636 if (owner_sid
== NULL
) {
3637 if (security_token_has_builtin_administrators(token
)) {
3638 try_builtin_administrators
= true;
3639 } else if (security_token_is_system(token
)) {
3640 try_builtin_administrators
= true;
3645 if (group_sid
== NULL
&&
3646 token
->num_sids
== PRIMARY_GROUP_SID_INDEX
)
3648 if (security_token_is_system(token
)) {
3649 try_builtin_administrators
= true;
3654 if (try_builtin_administrators
) {
3659 ok
= sids_to_unixids(&global_sid_Builtin_Administrators
, 1, &ids
);
3663 BA_U_sid
= &global_sid_Builtin_Administrators
;
3664 BA_G_sid
= &global_sid_Builtin_Administrators
;
3667 BA_U_sid
= &global_sid_Builtin_Administrators
;
3670 BA_G_sid
= &global_sid_Builtin_Administrators
;
3683 ok
= sids_to_unixids(&global_sid_System
, 1, &ids
);
3687 SY_U_sid
= &global_sid_System
;
3688 SY_G_sid
= &global_sid_System
;
3691 SY_U_sid
= &global_sid_System
;
3694 SY_G_sid
= &global_sid_System
;
3702 if (owner_sid
== NULL
) {
3703 owner_sid
= BA_U_sid
;
3706 if (owner_sid
== NULL
) {
3707 owner_sid
= SY_U_sid
;
3710 if (group_sid
== NULL
) {
3711 group_sid
= SY_G_sid
;
3714 if (try_system
&& group_sid
== NULL
) {
3715 group_sid
= BA_G_sid
;
3718 if (owner_sid
== NULL
) {
3719 owner_sid
= &token
->sids
[PRIMARY_USER_SID_INDEX
];
3721 if (group_sid
== NULL
) {
3722 if (token
->num_sids
== PRIMARY_GROUP_SID_INDEX
) {
3723 group_sid
= &token
->sids
[PRIMARY_USER_SID_INDEX
];
3725 group_sid
= &token
->sids
[PRIMARY_GROUP_SID_INDEX
];
3729 status
= se_create_child_secdesc(frame
,
3736 if (!NT_STATUS_IS_OK(status
)) {
3741 /* If inheritable_components == false,
3742 se_create_child_secdesc()
3743 creates a security desriptor with a NULL dacl
3744 entry, but with SEC_DESC_DACL_PRESENT. We need
3745 to remove that flag. */
3747 if (!inheritable_components
) {
3748 security_info_sent
&= ~SECINFO_DACL
;
3749 psd
->type
&= ~SEC_DESC_DACL_PRESENT
;
3752 if (DEBUGLEVEL
>= 10) {
3753 DEBUG(10,("inherit_new_acl: child acl for %s is:\n",
3754 fsp_str_dbg(fsp
) ));
3755 NDR_PRINT_DEBUG(security_descriptor
, psd
);
3758 if (inherit_owner
) {
3759 /* We need to be root to force this. */
3762 status
= SMB_VFS_FSET_NT_ACL(fsp
,
3765 if (inherit_owner
) {
3773 * Wrapper around open_file_ntcreate and open_directory
3776 static NTSTATUS
create_file_unixpath(connection_struct
*conn
,
3777 struct smb_request
*req
,
3778 struct smb_filename
*smb_fname
,
3779 uint32_t access_mask
,
3780 uint32_t share_access
,
3781 uint32_t create_disposition
,
3782 uint32_t create_options
,
3783 uint32_t file_attributes
,
3784 uint32_t oplock_request
,
3785 uint64_t allocation_size
,
3786 uint32_t private_flags
,
3787 struct security_descriptor
*sd
,
3788 struct ea_list
*ea_list
,
3790 files_struct
**result
,
3793 int info
= FILE_WAS_OPENED
;
3794 files_struct
*base_fsp
= NULL
;
3795 files_struct
*fsp
= NULL
;
3798 DEBUG(10,("create_file_unixpath: access_mask = 0x%x "
3799 "file_attributes = 0x%x, share_access = 0x%x, "
3800 "create_disposition = 0x%x create_options = 0x%x "
3801 "oplock_request = 0x%x private_flags = 0x%x "
3802 "ea_list = 0x%p, sd = 0x%p, "
3804 (unsigned int)access_mask
,
3805 (unsigned int)file_attributes
,
3806 (unsigned int)share_access
,
3807 (unsigned int)create_disposition
,
3808 (unsigned int)create_options
,
3809 (unsigned int)oplock_request
,
3810 (unsigned int)private_flags
,
3811 ea_list
, sd
, smb_fname_str_dbg(smb_fname
)));
3813 if (create_options
& FILE_OPEN_BY_FILE_ID
) {
3814 status
= NT_STATUS_NOT_SUPPORTED
;
3818 if (create_options
& NTCREATEX_OPTIONS_INVALID_PARAM_MASK
) {
3819 status
= NT_STATUS_INVALID_PARAMETER
;
3824 oplock_request
|= INTERNAL_OPEN_ONLY
;
3827 if ((conn
->fs_capabilities
& FILE_NAMED_STREAMS
)
3828 && (access_mask
& DELETE_ACCESS
)
3829 && !is_ntfs_stream_smb_fname(smb_fname
)) {
3831 * We can't open a file with DELETE access if any of the
3832 * streams is open without FILE_SHARE_DELETE
3834 status
= open_streams_for_delete(conn
, smb_fname
->base_name
);
3836 if (!NT_STATUS_IS_OK(status
)) {
3841 if ((access_mask
& SEC_FLAG_SYSTEM_SECURITY
) &&
3842 !security_token_has_privilege(get_current_nttok(conn
),
3843 SEC_PRIV_SECURITY
)) {
3844 DEBUG(10, ("create_file_unixpath: open on %s "
3845 "failed - SEC_FLAG_SYSTEM_SECURITY denied.\n",
3846 smb_fname_str_dbg(smb_fname
)));
3847 status
= NT_STATUS_PRIVILEGE_NOT_HELD
;
3851 if ((conn
->fs_capabilities
& FILE_NAMED_STREAMS
)
3852 && is_ntfs_stream_smb_fname(smb_fname
)
3853 && (!(private_flags
& NTCREATEX_OPTIONS_PRIVATE_STREAM_DELETE
))) {
3854 uint32 base_create_disposition
;
3855 struct smb_filename
*smb_fname_base
= NULL
;
3857 if (create_options
& FILE_DIRECTORY_FILE
) {
3858 status
= NT_STATUS_NOT_A_DIRECTORY
;
3862 switch (create_disposition
) {
3864 base_create_disposition
= FILE_OPEN
;
3867 base_create_disposition
= FILE_OPEN_IF
;
3871 /* Create an smb_filename with stream_name == NULL. */
3872 smb_fname_base
= synthetic_smb_fname(talloc_tos(),
3873 smb_fname
->base_name
,
3875 if (smb_fname_base
== NULL
) {
3876 status
= NT_STATUS_NO_MEMORY
;
3880 if (SMB_VFS_STAT(conn
, smb_fname_base
) == -1) {
3881 DEBUG(10, ("Unable to stat stream: %s\n",
3882 smb_fname_str_dbg(smb_fname_base
)));
3885 * https://bugzilla.samba.org/show_bug.cgi?id=10229
3886 * We need to check if the requested access mask
3887 * could be used to open the underlying file (if
3888 * it existed), as we're passing in zero for the
3889 * access mask to the base filename.
3891 status
= check_base_file_access(conn
,
3895 if (!NT_STATUS_IS_OK(status
)) {
3896 DEBUG(10, ("Permission check "
3897 "for base %s failed: "
3898 "%s\n", smb_fname
->base_name
,
3899 nt_errstr(status
)));
3904 /* Open the base file. */
3905 status
= create_file_unixpath(conn
, NULL
, smb_fname_base
, 0,
3908 | FILE_SHARE_DELETE
,
3909 base_create_disposition
,
3910 0, 0, 0, 0, 0, NULL
, NULL
,
3912 TALLOC_FREE(smb_fname_base
);
3914 if (!NT_STATUS_IS_OK(status
)) {
3915 DEBUG(10, ("create_file_unixpath for base %s failed: "
3916 "%s\n", smb_fname
->base_name
,
3917 nt_errstr(status
)));
3920 /* we don't need to low level fd */
3925 * If it's a request for a directory open, deal with it separately.
3928 if (create_options
& FILE_DIRECTORY_FILE
) {
3930 if (create_options
& FILE_NON_DIRECTORY_FILE
) {
3931 status
= NT_STATUS_INVALID_PARAMETER
;
3935 /* Can't open a temp directory. IFS kit test. */
3936 if (!(file_attributes
& FILE_FLAG_POSIX_SEMANTICS
) &&
3937 (file_attributes
& FILE_ATTRIBUTE_TEMPORARY
)) {
3938 status
= NT_STATUS_INVALID_PARAMETER
;
3943 * We will get a create directory here if the Win32
3944 * app specified a security descriptor in the
3945 * CreateDirectory() call.
3949 status
= open_directory(
3950 conn
, req
, smb_fname
, access_mask
, share_access
,
3951 create_disposition
, create_options
, file_attributes
,
3956 * Ordinary file case.
3959 status
= file_new(req
, conn
, &fsp
);
3960 if(!NT_STATUS_IS_OK(status
)) {
3964 status
= fsp_set_smb_fname(fsp
, smb_fname
);
3965 if (!NT_STATUS_IS_OK(status
)) {
3971 * We're opening the stream element of a
3972 * base_fsp we already opened. Set up the
3975 fsp
->base_fsp
= base_fsp
;
3978 if (allocation_size
) {
3979 fsp
->initial_allocation_size
= smb_roundup(fsp
->conn
,
3983 status
= open_file_ntcreate(conn
,
3995 if(!NT_STATUS_IS_OK(status
)) {
3996 file_free(req
, fsp
);
4000 if (NT_STATUS_EQUAL(status
, NT_STATUS_FILE_IS_A_DIRECTORY
)) {
4002 /* A stream open never opens a directory */
4005 status
= NT_STATUS_FILE_IS_A_DIRECTORY
;
4010 * Fail the open if it was explicitly a non-directory
4014 if (create_options
& FILE_NON_DIRECTORY_FILE
) {
4015 status
= NT_STATUS_FILE_IS_A_DIRECTORY
;
4020 status
= open_directory(
4021 conn
, req
, smb_fname
, access_mask
,
4022 share_access
, create_disposition
,
4023 create_options
, file_attributes
,
4028 if (!NT_STATUS_IS_OK(status
)) {
4032 fsp
->base_fsp
= base_fsp
;
4034 if ((ea_list
!= NULL
) &&
4035 ((info
== FILE_WAS_CREATED
) || (info
== FILE_WAS_OVERWRITTEN
))) {
4036 status
= set_ea(conn
, fsp
, fsp
->fsp_name
, ea_list
);
4037 if (!NT_STATUS_IS_OK(status
)) {
4042 if (!fsp
->is_directory
&& S_ISDIR(fsp
->fsp_name
->st
.st_ex_mode
)) {
4043 status
= NT_STATUS_ACCESS_DENIED
;
4047 /* Save the requested allocation size. */
4048 if ((info
== FILE_WAS_CREATED
) || (info
== FILE_WAS_OVERWRITTEN
)) {
4050 && (allocation_size
> fsp
->fsp_name
->st
.st_ex_size
)) {
4051 fsp
->initial_allocation_size
= smb_roundup(
4052 fsp
->conn
, allocation_size
);
4053 if (fsp
->is_directory
) {
4054 /* Can't set allocation size on a directory. */
4055 status
= NT_STATUS_ACCESS_DENIED
;
4058 if (vfs_allocate_file_space(
4059 fsp
, fsp
->initial_allocation_size
) == -1) {
4060 status
= NT_STATUS_DISK_FULL
;
4064 fsp
->initial_allocation_size
= smb_roundup(
4065 fsp
->conn
, (uint64_t)fsp
->fsp_name
->st
.st_ex_size
);
4068 fsp
->initial_allocation_size
= 0;
4071 if ((info
== FILE_WAS_CREATED
) && lp_nt_acl_support(SNUM(conn
)) &&
4072 fsp
->base_fsp
== NULL
) {
4075 * According to the MS documentation, the only time the security
4076 * descriptor is applied to the opened file is iff we *created* the
4077 * file; an existing file stays the same.
4079 * Also, it seems (from observation) that you can open the file with
4080 * any access mask but you can still write the sd. We need to override
4081 * the granted access before we call set_sd
4082 * Patch for bug #2242 from Tom Lackemann <cessnatomny@yahoo.com>.
4085 uint32_t sec_info_sent
;
4086 uint32_t saved_access_mask
= fsp
->access_mask
;
4088 sec_info_sent
= get_sec_info(sd
);
4090 fsp
->access_mask
= FILE_GENERIC_ALL
;
4092 if (sec_info_sent
& (SECINFO_OWNER
|
4096 status
= set_sd(fsp
, sd
, sec_info_sent
);
4099 fsp
->access_mask
= saved_access_mask
;
4101 if (!NT_STATUS_IS_OK(status
)) {
4104 } else if (lp_inherit_acls(SNUM(conn
))) {
4105 /* Inherit from parent. Errors here are not fatal. */
4106 status
= inherit_new_acl(fsp
);
4107 if (!NT_STATUS_IS_OK(status
)) {
4108 DEBUG(10,("inherit_new_acl: failed for %s with %s\n",
4110 nt_errstr(status
) ));
4115 if ((conn
->fs_capabilities
& FILE_FILE_COMPRESSION
)
4116 && (create_options
& FILE_NO_COMPRESSION
)
4117 && (info
== FILE_WAS_CREATED
)) {
4118 status
= SMB_VFS_SET_COMPRESSION(conn
, fsp
, fsp
,
4119 COMPRESSION_FORMAT_NONE
);
4120 if (!NT_STATUS_IS_OK(status
)) {
4121 DEBUG(1, ("failed to disable compression: %s\n",
4122 nt_errstr(status
)));
4126 DEBUG(10, ("create_file_unixpath: info=%d\n", info
));
4129 if (pinfo
!= NULL
) {
4133 smb_fname
->st
= fsp
->fsp_name
->st
;
4135 return NT_STATUS_OK
;
4138 DEBUG(10, ("create_file_unixpath: %s\n", nt_errstr(status
)));
4141 if (base_fsp
&& fsp
->base_fsp
== base_fsp
) {
4143 * The close_file below will close
4148 close_file(req
, fsp
, ERROR_CLOSE
);
4151 if (base_fsp
!= NULL
) {
4152 close_file(req
, base_fsp
, ERROR_CLOSE
);
4159 * Calculate the full path name given a relative fid.
4161 NTSTATUS
get_relative_fid_filename(connection_struct
*conn
,
4162 struct smb_request
*req
,
4163 uint16_t root_dir_fid
,
4164 const struct smb_filename
*smb_fname
,
4165 struct smb_filename
**smb_fname_out
)
4167 files_struct
*dir_fsp
;
4168 char *parent_fname
= NULL
;
4169 char *new_base_name
= NULL
;
4172 if (root_dir_fid
== 0 || !smb_fname
) {
4173 status
= NT_STATUS_INTERNAL_ERROR
;
4177 dir_fsp
= file_fsp(req
, root_dir_fid
);
4179 if (dir_fsp
== NULL
) {
4180 status
= NT_STATUS_INVALID_HANDLE
;
4184 if (is_ntfs_stream_smb_fname(dir_fsp
->fsp_name
)) {
4185 status
= NT_STATUS_INVALID_HANDLE
;
4189 if (!dir_fsp
->is_directory
) {
4192 * Check to see if this is a mac fork of some kind.
4195 if ((conn
->fs_capabilities
& FILE_NAMED_STREAMS
) &&
4196 is_ntfs_stream_smb_fname(smb_fname
)) {
4197 status
= NT_STATUS_OBJECT_PATH_NOT_FOUND
;
4202 we need to handle the case when we get a
4203 relative open relative to a file and the
4204 pathname is blank - this is a reopen!
4205 (hint from demyn plantenberg)
4208 status
= NT_STATUS_INVALID_HANDLE
;
4212 if (ISDOT(dir_fsp
->fsp_name
->base_name
)) {
4214 * We're at the toplevel dir, the final file name
4215 * must not contain ./, as this is filtered out
4216 * normally by srvstr_get_path and unix_convert
4217 * explicitly rejects paths containing ./.
4219 parent_fname
= talloc_strdup(talloc_tos(), "");
4220 if (parent_fname
== NULL
) {
4221 status
= NT_STATUS_NO_MEMORY
;
4225 size_t dir_name_len
= strlen(dir_fsp
->fsp_name
->base_name
);
4228 * Copy in the base directory name.
4231 parent_fname
= talloc_array(talloc_tos(), char,
4233 if (parent_fname
== NULL
) {
4234 status
= NT_STATUS_NO_MEMORY
;
4237 memcpy(parent_fname
, dir_fsp
->fsp_name
->base_name
,
4241 * Ensure it ends in a '/'.
4242 * We used TALLOC_SIZE +2 to add space for the '/'.
4246 && (parent_fname
[dir_name_len
-1] != '\\')
4247 && (parent_fname
[dir_name_len
-1] != '/')) {
4248 parent_fname
[dir_name_len
] = '/';
4249 parent_fname
[dir_name_len
+1] = '\0';
4253 new_base_name
= talloc_asprintf(talloc_tos(), "%s%s", parent_fname
,
4254 smb_fname
->base_name
);
4255 if (new_base_name
== NULL
) {
4256 status
= NT_STATUS_NO_MEMORY
;
4260 status
= filename_convert(req
,
4262 req
->flags2
& FLAGS2_DFS_PATHNAMES
,
4267 if (!NT_STATUS_IS_OK(status
)) {
4272 TALLOC_FREE(parent_fname
);
4273 TALLOC_FREE(new_base_name
);
4277 NTSTATUS
create_file_default(connection_struct
*conn
,
4278 struct smb_request
*req
,
4279 uint16_t root_dir_fid
,
4280 struct smb_filename
*smb_fname
,
4281 uint32_t access_mask
,
4282 uint32_t share_access
,
4283 uint32_t create_disposition
,
4284 uint32_t create_options
,
4285 uint32_t file_attributes
,
4286 uint32_t oplock_request
,
4287 uint64_t allocation_size
,
4288 uint32_t private_flags
,
4289 struct security_descriptor
*sd
,
4290 struct ea_list
*ea_list
,
4291 files_struct
**result
,
4294 int info
= FILE_WAS_OPENED
;
4295 files_struct
*fsp
= NULL
;
4297 bool stream_name
= false;
4299 DEBUG(10,("create_file: access_mask = 0x%x "
4300 "file_attributes = 0x%x, share_access = 0x%x, "
4301 "create_disposition = 0x%x create_options = 0x%x "
4302 "oplock_request = 0x%x "
4303 "private_flags = 0x%x "
4304 "root_dir_fid = 0x%x, ea_list = 0x%p, sd = 0x%p, "
4306 (unsigned int)access_mask
,
4307 (unsigned int)file_attributes
,
4308 (unsigned int)share_access
,
4309 (unsigned int)create_disposition
,
4310 (unsigned int)create_options
,
4311 (unsigned int)oplock_request
,
4312 (unsigned int)private_flags
,
4313 (unsigned int)root_dir_fid
,
4314 ea_list
, sd
, smb_fname_str_dbg(smb_fname
)));
4317 * Calculate the filename from the root_dir_if if necessary.
4320 if (root_dir_fid
!= 0) {
4321 struct smb_filename
*smb_fname_out
= NULL
;
4322 status
= get_relative_fid_filename(conn
, req
, root_dir_fid
,
4323 smb_fname
, &smb_fname_out
);
4324 if (!NT_STATUS_IS_OK(status
)) {
4327 smb_fname
= smb_fname_out
;
4331 * Check to see if this is a mac fork of some kind.
4334 stream_name
= is_ntfs_stream_smb_fname(smb_fname
);
4336 enum FAKE_FILE_TYPE fake_file_type
;
4338 fake_file_type
= is_fake_file(smb_fname
);
4340 if (fake_file_type
!= FAKE_FILE_TYPE_NONE
) {
4343 * Here we go! support for changing the disk quotas
4346 * We need to fake up to open this MAGIC QUOTA file
4347 * and return a valid FID.
4349 * w2k close this file directly after openening xp
4350 * also tries a QUERY_FILE_INFO on the file and then
4353 status
= open_fake_file(req
, conn
, req
->vuid
,
4354 fake_file_type
, smb_fname
,
4356 if (!NT_STATUS_IS_OK(status
)) {
4360 ZERO_STRUCT(smb_fname
->st
);
4364 if (!(conn
->fs_capabilities
& FILE_NAMED_STREAMS
)) {
4365 status
= NT_STATUS_OBJECT_NAME_NOT_FOUND
;
4370 if (is_ntfs_default_stream_smb_fname(smb_fname
)) {
4372 smb_fname
->stream_name
= NULL
;
4373 /* We have to handle this error here. */
4374 if (create_options
& FILE_DIRECTORY_FILE
) {
4375 status
= NT_STATUS_NOT_A_DIRECTORY
;
4378 if (lp_posix_pathnames()) {
4379 ret
= SMB_VFS_LSTAT(conn
, smb_fname
);
4381 ret
= SMB_VFS_STAT(conn
, smb_fname
);
4384 if (ret
== 0 && VALID_STAT_OF_DIR(smb_fname
->st
)) {
4385 status
= NT_STATUS_FILE_IS_A_DIRECTORY
;
4390 status
= create_file_unixpath(
4391 conn
, req
, smb_fname
, access_mask
, share_access
,
4392 create_disposition
, create_options
, file_attributes
,
4393 oplock_request
, allocation_size
, private_flags
,
4397 if (!NT_STATUS_IS_OK(status
)) {
4402 DEBUG(10, ("create_file: info=%d\n", info
));
4405 if (pinfo
!= NULL
) {
4408 return NT_STATUS_OK
;
4411 DEBUG(10, ("create_file: %s\n", nt_errstr(status
)));
4414 close_file(req
, fsp
, ERROR_CLOSE
);