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"
34 extern const struct generic_mapping file_generic_mapping
;
36 struct deferred_open_record
{
37 bool delayed_for_oplocks
;
42 /****************************************************************************
43 If the requester wanted DELETE_ACCESS and was rejected because
44 the file ACL didn't include DELETE_ACCESS, see if the parent ACL
46 ****************************************************************************/
48 static bool parent_override_delete(connection_struct
*conn
,
49 const struct smb_filename
*smb_fname
,
51 uint32_t rejected_mask
)
53 if ((access_mask
& DELETE_ACCESS
) &&
54 (rejected_mask
& DELETE_ACCESS
) &&
55 can_delete_file_in_directory(conn
, smb_fname
)) {
61 /****************************************************************************
62 Check if we have open rights.
63 ****************************************************************************/
65 NTSTATUS
smbd_check_access_rights(struct connection_struct
*conn
,
66 const struct smb_filename
*smb_fname
,
69 /* Check if we have rights to open. */
71 struct security_descriptor
*sd
= NULL
;
72 uint32_t rejected_share_access
;
73 uint32_t rejected_mask
= access_mask
;
75 rejected_share_access
= access_mask
& ~(conn
->share_access
);
77 if (rejected_share_access
) {
78 DEBUG(10, ("smbd_check_access_rights: rejected share access 0x%x "
80 (unsigned int)access_mask
,
81 smb_fname_str_dbg(smb_fname
),
82 (unsigned int)rejected_share_access
));
83 return NT_STATUS_ACCESS_DENIED
;
86 if (get_current_uid(conn
) == (uid_t
)0) {
87 /* I'm sorry sir, I didn't know you were root... */
88 DEBUG(10,("smbd_check_access_rights: root override "
89 "on %s. Granting 0x%x\n",
90 smb_fname_str_dbg(smb_fname
),
91 (unsigned int)access_mask
));
95 if ((access_mask
& DELETE_ACCESS
) && !lp_acl_check_permissions(SNUM(conn
))) {
96 DEBUG(10,("smbd_check_access_rights: not checking ACL "
97 "on DELETE_ACCESS on file %s. Granting 0x%x\n",
98 smb_fname_str_dbg(smb_fname
),
99 (unsigned int)access_mask
));
103 if (access_mask
== DELETE_ACCESS
&&
104 VALID_STAT(smb_fname
->st
) &&
105 S_ISLNK(smb_fname
->st
.st_ex_mode
)) {
106 /* We can always delete a symlink. */
107 DEBUG(10,("smbd_check_access_rights: not checking ACL "
108 "on DELETE_ACCESS on symlink %s.\n",
109 smb_fname_str_dbg(smb_fname
) ));
113 status
= SMB_VFS_GET_NT_ACL(conn
, smb_fname
->base_name
,
118 if (!NT_STATUS_IS_OK(status
)) {
119 DEBUG(10, ("smbd_check_access_rights: Could not get acl "
121 smb_fname_str_dbg(smb_fname
),
124 if (NT_STATUS_EQUAL(status
, NT_STATUS_ACCESS_DENIED
)) {
132 * Never test FILE_READ_ATTRIBUTES. se_file_access_check() also takes care of
133 * owner WRITE_DAC and READ_CONTROL.
135 status
= se_file_access_check(sd
,
136 get_current_nttok(conn
),
138 (access_mask
& ~FILE_READ_ATTRIBUTES
),
141 DEBUG(10,("smbd_check_access_rights: file %s requesting "
142 "0x%x returning 0x%x (%s)\n",
143 smb_fname_str_dbg(smb_fname
),
144 (unsigned int)access_mask
,
145 (unsigned int)rejected_mask
,
146 nt_errstr(status
) ));
148 if (!NT_STATUS_IS_OK(status
)) {
149 if (DEBUGLEVEL
>= 10) {
150 DEBUG(10,("smbd_check_access_rights: acl for %s is:\n",
151 smb_fname_str_dbg(smb_fname
) ));
152 NDR_PRINT_DEBUG(security_descriptor
, sd
);
158 if (NT_STATUS_IS_OK(status
) ||
159 !NT_STATUS_EQUAL(status
, NT_STATUS_ACCESS_DENIED
)) {
163 /* Here we know status == NT_STATUS_ACCESS_DENIED. */
167 if ((access_mask
& FILE_WRITE_ATTRIBUTES
) &&
168 (rejected_mask
& FILE_WRITE_ATTRIBUTES
) &&
169 !lp_store_dos_attributes(SNUM(conn
)) &&
170 (lp_map_readonly(SNUM(conn
)) ||
171 lp_map_archive(SNUM(conn
)) ||
172 lp_map_hidden(SNUM(conn
)) ||
173 lp_map_system(SNUM(conn
)))) {
174 rejected_mask
&= ~FILE_WRITE_ATTRIBUTES
;
176 DEBUG(10,("smbd_check_access_rights: "
178 "FILE_WRITE_ATTRIBUTES "
180 smb_fname_str_dbg(smb_fname
)));
183 if (parent_override_delete(conn
,
187 /* Were we trying to do an open
188 * for delete and didn't get DELETE
189 * access (only) ? Check if the
190 * directory allows DELETE_CHILD.
192 * http://blogs.msdn.com/oldnewthing/archive/2004/06/04/148426.aspx
195 rejected_mask
&= ~DELETE_ACCESS
;
197 DEBUG(10,("smbd_check_access_rights: "
201 smb_fname_str_dbg(smb_fname
)));
204 if (rejected_mask
!= 0) {
205 return NT_STATUS_ACCESS_DENIED
;
210 static NTSTATUS
check_parent_access(struct connection_struct
*conn
,
211 struct smb_filename
*smb_fname
,
212 uint32_t access_mask
)
215 char *parent_dir
= NULL
;
216 struct security_descriptor
*parent_sd
= NULL
;
217 uint32_t access_granted
= 0;
219 if (!parent_dirname(talloc_tos(),
220 smb_fname
->base_name
,
223 return NT_STATUS_NO_MEMORY
;
226 if (get_current_uid(conn
) == (uid_t
)0) {
227 /* I'm sorry sir, I didn't know you were root... */
228 DEBUG(10,("check_parent_access: root override "
229 "on %s. Granting 0x%x\n",
230 smb_fname_str_dbg(smb_fname
),
231 (unsigned int)access_mask
));
235 status
= SMB_VFS_GET_NT_ACL(conn
,
240 if (!NT_STATUS_IS_OK(status
)) {
241 DEBUG(5,("check_parent_access: SMB_VFS_GET_NT_ACL failed for "
242 "%s with error %s\n",
249 * Never test FILE_READ_ATTRIBUTES. se_file_access_check() also takes care of
250 * owner WRITE_DAC and READ_CONTROL.
252 status
= se_file_access_check(parent_sd
,
253 get_current_nttok(conn
),
255 (access_mask
& ~FILE_READ_ATTRIBUTES
),
257 if(!NT_STATUS_IS_OK(status
)) {
258 DEBUG(5,("check_parent_access: access check "
259 "on directory %s for "
260 "path %s for mask 0x%x returned (0x%x) %s\n",
262 smb_fname
->base_name
,
265 nt_errstr(status
) ));
272 /****************************************************************************
273 fd support routines - attempt to do a dos_open.
274 ****************************************************************************/
276 static NTSTATUS
fd_open(struct connection_struct
*conn
,
281 struct smb_filename
*smb_fname
= fsp
->fsp_name
;
282 NTSTATUS status
= NT_STATUS_OK
;
286 * Never follow symlinks on a POSIX client. The
287 * client should be doing this.
290 if (fsp
->posix_open
|| !lp_symlinks(SNUM(conn
))) {
295 fsp
->fh
->fd
= SMB_VFS_OPEN(conn
, smb_fname
, fsp
, flags
, mode
);
296 if (fsp
->fh
->fd
== -1) {
297 int posix_errno
= errno
;
299 #if defined(ENOTSUP) && defined(OSF1)
300 /* handle special Tru64 errno */
301 if (errno
== ENOTSUP
) {
306 /* fix broken NetBSD errno */
307 if (errno
== EFTYPE
) {
311 /* fix broken FreeBSD errno */
312 if (errno
== EMLINK
) {
315 #endif /* O_NOFOLLOW */
316 status
= map_nt_error_from_unix(posix_errno
);
317 if (errno
== EMFILE
) {
318 static time_t last_warned
= 0L;
320 if (time((time_t *) NULL
) > last_warned
) {
321 DEBUG(0,("Too many open files, unable "
322 "to open more! smbd's max "
324 lp_max_open_files()));
325 last_warned
= time((time_t *) NULL
);
331 DEBUG(10,("fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s\n",
332 smb_fname_str_dbg(smb_fname
), flags
, (int)mode
, fsp
->fh
->fd
,
333 (fsp
->fh
->fd
== -1) ? strerror(errno
) : "" ));
338 /****************************************************************************
339 Close the file associated with a fsp.
340 ****************************************************************************/
342 NTSTATUS
fd_close(files_struct
*fsp
)
349 if (fsp
->fh
->fd
== -1) {
350 return NT_STATUS_OK
; /* What we used to call a stat open. */
352 if (fsp
->fh
->ref_count
> 1) {
353 return NT_STATUS_OK
; /* Shared handle. Only close last reference. */
356 ret
= SMB_VFS_CLOSE(fsp
);
359 return map_nt_error_from_unix(errno
);
364 /****************************************************************************
365 Change the ownership of a file to that of the parent directory.
366 Do this by fd if possible.
367 ****************************************************************************/
369 void change_file_owner_to_parent(connection_struct
*conn
,
370 const char *inherit_from_dir
,
373 struct smb_filename
*smb_fname_parent
= NULL
;
377 status
= create_synthetic_smb_fname(talloc_tos(), inherit_from_dir
,
378 NULL
, NULL
, &smb_fname_parent
);
379 if (!NT_STATUS_IS_OK(status
)) {
383 ret
= SMB_VFS_STAT(conn
, smb_fname_parent
);
385 DEBUG(0,("change_file_owner_to_parent: failed to stat parent "
386 "directory %s. Error was %s\n",
387 smb_fname_str_dbg(smb_fname_parent
),
389 TALLOC_FREE(smb_fname_parent
);
393 if (smb_fname_parent
->st
.st_ex_uid
== fsp
->fsp_name
->st
.st_ex_uid
) {
394 /* Already this uid - no need to change. */
395 DEBUG(10,("change_file_owner_to_parent: file %s "
396 "is already owned by uid %d\n",
398 (int)fsp
->fsp_name
->st
.st_ex_uid
));
399 TALLOC_FREE(smb_fname_parent
);
404 ret
= SMB_VFS_FCHOWN(fsp
, smb_fname_parent
->st
.st_ex_uid
, (gid_t
)-1);
407 DEBUG(0,("change_file_owner_to_parent: failed to fchown "
408 "file %s to parent directory uid %u. Error "
409 "was %s\n", fsp_str_dbg(fsp
),
410 (unsigned int)smb_fname_parent
->st
.st_ex_uid
,
413 DEBUG(10,("change_file_owner_to_parent: changed new file %s to "
414 "parent directory uid %u.\n", fsp_str_dbg(fsp
),
415 (unsigned int)smb_fname_parent
->st
.st_ex_uid
));
416 /* Ensure the uid entry is updated. */
417 fsp
->fsp_name
->st
.st_ex_uid
= smb_fname_parent
->st
.st_ex_uid
;
420 TALLOC_FREE(smb_fname_parent
);
423 NTSTATUS
change_dir_owner_to_parent(connection_struct
*conn
,
424 const char *inherit_from_dir
,
426 SMB_STRUCT_STAT
*psbuf
)
428 struct smb_filename
*smb_fname_parent
= NULL
;
429 struct smb_filename
*smb_fname_cwd
= NULL
;
430 char *saved_dir
= NULL
;
431 TALLOC_CTX
*ctx
= talloc_tos();
432 NTSTATUS status
= NT_STATUS_OK
;
435 status
= create_synthetic_smb_fname(ctx
, inherit_from_dir
, NULL
, NULL
,
437 if (!NT_STATUS_IS_OK(status
)) {
441 ret
= SMB_VFS_STAT(conn
, smb_fname_parent
);
443 status
= map_nt_error_from_unix(errno
);
444 DEBUG(0,("change_dir_owner_to_parent: failed to stat parent "
445 "directory %s. Error was %s\n",
446 smb_fname_str_dbg(smb_fname_parent
),
451 /* We've already done an lstat into psbuf, and we know it's a
452 directory. If we can cd into the directory and the dev/ino
453 are the same then we can safely chown without races as
454 we're locking the directory in place by being in it. This
455 should work on any UNIX (thanks tridge :-). JRA.
458 saved_dir
= vfs_GetWd(ctx
,conn
);
460 status
= map_nt_error_from_unix(errno
);
461 DEBUG(0,("change_dir_owner_to_parent: failed to get "
462 "current working directory. Error was %s\n",
467 /* Chdir into the new path. */
468 if (vfs_ChDir(conn
, fname
) == -1) {
469 status
= map_nt_error_from_unix(errno
);
470 DEBUG(0,("change_dir_owner_to_parent: failed to change "
471 "current working directory to %s. Error "
472 "was %s\n", fname
, strerror(errno
) ));
476 status
= create_synthetic_smb_fname(ctx
, ".", NULL
, NULL
,
478 if (!NT_STATUS_IS_OK(status
)) {
482 ret
= SMB_VFS_STAT(conn
, smb_fname_cwd
);
484 status
= map_nt_error_from_unix(errno
);
485 DEBUG(0,("change_dir_owner_to_parent: failed to stat "
486 "directory '.' (%s) Error was %s\n",
487 fname
, strerror(errno
)));
491 /* Ensure we're pointing at the same place. */
492 if (smb_fname_cwd
->st
.st_ex_dev
!= psbuf
->st_ex_dev
||
493 smb_fname_cwd
->st
.st_ex_ino
!= psbuf
->st_ex_ino
) {
494 DEBUG(0,("change_dir_owner_to_parent: "
495 "device/inode on directory %s changed. "
496 "Refusing to chown !\n", fname
));
497 status
= NT_STATUS_ACCESS_DENIED
;
501 if (smb_fname_parent
->st
.st_ex_uid
== smb_fname_cwd
->st
.st_ex_uid
) {
502 /* Already this uid - no need to change. */
503 DEBUG(10,("change_dir_owner_to_parent: directory %s "
504 "is already owned by uid %d\n",
506 (int)smb_fname_cwd
->st
.st_ex_uid
));
507 status
= NT_STATUS_OK
;
512 ret
= SMB_VFS_LCHOWN(conn
, ".", smb_fname_parent
->st
.st_ex_uid
,
516 status
= map_nt_error_from_unix(errno
);
517 DEBUG(10,("change_dir_owner_to_parent: failed to chown "
518 "directory %s to parent directory uid %u. "
519 "Error was %s\n", fname
,
520 (unsigned int)smb_fname_parent
->st
.st_ex_uid
,
523 DEBUG(10,("change_dir_owner_to_parent: changed ownership of new "
524 "directory %s to parent directory uid %u.\n",
525 fname
, (unsigned int)smb_fname_parent
->st
.st_ex_uid
));
526 /* Ensure the uid entry is updated. */
527 psbuf
->st_ex_uid
= smb_fname_parent
->st
.st_ex_uid
;
531 vfs_ChDir(conn
,saved_dir
);
533 TALLOC_FREE(smb_fname_parent
);
534 TALLOC_FREE(smb_fname_cwd
);
538 /****************************************************************************
539 Open a file - returning a guaranteed ATOMIC indication of if the
540 file was created or not.
541 ****************************************************************************/
543 static NTSTATUS
fd_open_atomic(struct connection_struct
*conn
,
549 NTSTATUS status
= NT_STATUS_UNSUCCESSFUL
;
550 bool file_existed
= VALID_STAT(fsp
->fsp_name
->st
);
552 *file_created
= false;
554 if (!(flags
& O_CREAT
)) {
556 * We're not creating the file, just pass through.
558 return fd_open(conn
, fsp
, flags
, mode
);
561 if (flags
& O_EXCL
) {
563 * Fail if already exists, just pass through.
565 status
= fd_open(conn
, fsp
, flags
, mode
);
566 if (NT_STATUS_IS_OK(status
)) {
568 * Here we've opened with O_CREAT|O_EXCL
569 * and got success. We *know* we created
572 *file_created
= true;
578 * Now it gets tricky. We have O_CREAT, but not O_EXCL.
579 * To know absolutely if we created the file or not,
580 * we can never call O_CREAT without O_EXCL. So if
581 * we think the file existed, try without O_CREAT|O_EXCL.
582 * If we think the file didn't exist, try with
583 * O_CREAT|O_EXCL. Keep bouncing between these two
584 * requests until either the file is created, or
585 * opened. Either way, we keep going until we get
586 * a returnable result (error, or open/create).
590 int curr_flags
= flags
;
593 /* Just try open, do not create. */
594 curr_flags
&= ~(O_CREAT
);
595 status
= fd_open(conn
, fsp
, curr_flags
, mode
);
596 if (NT_STATUS_EQUAL(status
,
597 NT_STATUS_OBJECT_NAME_NOT_FOUND
)) {
599 * Someone deleted it in the meantime.
602 file_existed
= false;
603 DEBUG(10,("fd_open_atomic: file %s existed. "
605 smb_fname_str_dbg(fsp
->fsp_name
)));
609 /* Try create exclusively, fail if it exists. */
610 curr_flags
|= O_EXCL
;
611 status
= fd_open(conn
, fsp
, curr_flags
, mode
);
612 if (NT_STATUS_EQUAL(status
,
613 NT_STATUS_OBJECT_NAME_COLLISION
)) {
615 * Someone created it in the meantime.
616 * Retry without O_CREAT.
619 DEBUG(10,("fd_open_atomic: file %s "
620 "did not exist. Retry.\n",
621 smb_fname_str_dbg(fsp
->fsp_name
)));
624 if (NT_STATUS_IS_OK(status
)) {
626 * Here we've opened with O_CREAT|O_EXCL
627 * and got success. We *know* we created
630 *file_created
= true;
633 /* Create is done, or failed. */
639 /****************************************************************************
641 ****************************************************************************/
643 static NTSTATUS
open_file(files_struct
*fsp
,
644 connection_struct
*conn
,
645 struct smb_request
*req
,
646 const char *parent_dir
,
649 uint32 access_mask
, /* client requested access mask. */
650 uint32 open_access_mask
, /* what we're actually using in the open. */
651 bool *p_file_created
)
653 struct smb_filename
*smb_fname
= fsp
->fsp_name
;
654 NTSTATUS status
= NT_STATUS_OK
;
655 int accmode
= (flags
& O_ACCMODE
);
656 int local_flags
= flags
;
657 bool file_existed
= VALID_STAT(fsp
->fsp_name
->st
);
662 /* Check permissions */
665 * This code was changed after seeing a client open request
666 * containing the open mode of (DENY_WRITE/read-only) with
667 * the 'create if not exist' bit set. The previous code
668 * would fail to open the file read only on a read-only share
669 * as it was checking the flags parameter directly against O_RDONLY,
670 * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
674 if (!CAN_WRITE(conn
)) {
675 /* It's a read-only share - fail if we wanted to write. */
676 if(accmode
!= O_RDONLY
|| (flags
& O_TRUNC
) || (flags
& O_APPEND
)) {
677 DEBUG(3,("Permission denied opening %s\n",
678 smb_fname_str_dbg(smb_fname
)));
679 return NT_STATUS_ACCESS_DENIED
;
680 } else if(flags
& O_CREAT
) {
681 /* We don't want to write - but we must make sure that
682 O_CREAT doesn't create the file if we have write
683 access into the directory.
685 flags
&= ~(O_CREAT
|O_EXCL
);
686 local_flags
&= ~(O_CREAT
|O_EXCL
);
691 * This little piece of insanity is inspired by the
692 * fact that an NT client can open a file for O_RDONLY,
693 * but set the create disposition to FILE_EXISTS_TRUNCATE.
694 * If the client *can* write to the file, then it expects to
695 * truncate the file, even though it is opening for readonly.
696 * Quicken uses this stupid trick in backup file creation...
697 * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
698 * for helping track this one down. It didn't bite us in 2.0.x
699 * as we always opened files read-write in that release. JRA.
702 if ((accmode
== O_RDONLY
) && ((flags
& O_TRUNC
) == O_TRUNC
)) {
703 DEBUG(10,("open_file: truncate requested on read-only open "
704 "for file %s\n", smb_fname_str_dbg(smb_fname
)));
705 local_flags
= (flags
& ~O_ACCMODE
)|O_RDWR
;
708 if ((open_access_mask
& (FILE_READ_DATA
|FILE_WRITE_DATA
|FILE_APPEND_DATA
|FILE_EXECUTE
)) ||
709 (!file_existed
&& (local_flags
& O_CREAT
)) ||
710 ((local_flags
& O_TRUNC
) == O_TRUNC
) ) {
715 * We can't actually truncate here as the file may be locked.
716 * open_file_ntcreate will take care of the truncate later. JRA.
719 local_flags
&= ~O_TRUNC
;
721 #if defined(O_NONBLOCK) && defined(S_ISFIFO)
723 * We would block on opening a FIFO with no one else on the
724 * other end. Do what we used to do and add O_NONBLOCK to the
728 if (file_existed
&& S_ISFIFO(smb_fname
->st
.st_ex_mode
)) {
729 local_flags
|= O_NONBLOCK
;
733 /* Don't create files with Microsoft wildcard characters. */
736 * wildcard characters are allowed in stream names
737 * only test the basefilename
739 wild
= fsp
->base_fsp
->fsp_name
->base_name
;
741 wild
= smb_fname
->base_name
;
743 if ((local_flags
& O_CREAT
) && !file_existed
&&
745 return NT_STATUS_OBJECT_NAME_INVALID
;
748 /* Can we access this file ? */
749 if (!fsp
->base_fsp
) {
750 /* Only do this check on non-stream open. */
752 status
= smbd_check_access_rights(conn
,
755 } else if (local_flags
& O_CREAT
){
756 status
= check_parent_access(conn
,
760 /* File didn't exist and no O_CREAT. */
761 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
763 if (!NT_STATUS_IS_OK(status
)) {
764 DEBUG(10,("open_file: "
768 "smbd_check_access_rights" :
769 "check_parent_access",
770 smb_fname_str_dbg(smb_fname
),
771 nt_errstr(status
) ));
776 /* Actually do the open */
777 status
= fd_open_atomic(conn
, fsp
, local_flags
,
778 unx_mode
, p_file_created
);
779 if (!NT_STATUS_IS_OK(status
)) {
780 DEBUG(3,("Error opening file %s (%s) (local_flags=%d) "
781 "(flags=%d)\n", smb_fname_str_dbg(smb_fname
),
782 nt_errstr(status
),local_flags
,flags
));
786 ret
= SMB_VFS_FSTAT(fsp
, &smb_fname
->st
);
788 /* If we have an fd, this stat should succeed. */
789 DEBUG(0,("Error doing fstat on open file %s "
791 smb_fname_str_dbg(smb_fname
),
793 status
= map_nt_error_from_unix(errno
);
798 if (*p_file_created
) {
799 /* We created this file. */
801 bool need_re_stat
= false;
802 /* Do all inheritance work after we've
803 done a successful fstat call and filled
804 in the stat struct in fsp->fsp_name. */
806 /* Inherit the ACL if required */
807 if (lp_inherit_perms(SNUM(conn
))) {
808 inherit_access_posix_acl(conn
, parent_dir
,
809 smb_fname
->base_name
,
814 /* Change the owner if required. */
815 if (lp_inherit_owner(SNUM(conn
))) {
816 change_file_owner_to_parent(conn
, parent_dir
,
822 ret
= SMB_VFS_FSTAT(fsp
, &smb_fname
->st
);
823 /* If we have an fd, this stat should succeed. */
825 DEBUG(0,("Error doing fstat on open file %s "
827 smb_fname_str_dbg(smb_fname
),
832 notify_fname(conn
, NOTIFY_ACTION_ADDED
,
833 FILE_NOTIFY_CHANGE_FILE_NAME
,
834 smb_fname
->base_name
);
837 fsp
->fh
->fd
= -1; /* What we used to call a stat open. */
839 /* File must exist for a stat open. */
840 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
843 status
= smbd_check_access_rights(conn
,
847 if (NT_STATUS_EQUAL(status
, NT_STATUS_OBJECT_NAME_NOT_FOUND
) &&
849 S_ISLNK(smb_fname
->st
.st_ex_mode
)) {
850 /* This is a POSIX stat open for delete
851 * or rename on a symlink that points
853 DEBUG(10,("open_file: allowing POSIX "
854 "open on bad symlink %s\n",
855 smb_fname_str_dbg(smb_fname
)));
856 status
= NT_STATUS_OK
;
859 if (!NT_STATUS_IS_OK(status
)) {
860 DEBUG(10,("open_file: "
861 "smbd_check_access_rights on file "
863 smb_fname_str_dbg(smb_fname
),
864 nt_errstr(status
) ));
870 * POSIX allows read-only opens of directories. We don't
871 * want to do this (we use a different code path for this)
872 * so catch a directory open and return an EISDIR. JRA.
875 if(S_ISDIR(smb_fname
->st
.st_ex_mode
)) {
878 return NT_STATUS_FILE_IS_A_DIRECTORY
;
881 fsp
->file_id
= vfs_file_id_from_sbuf(conn
, &smb_fname
->st
);
882 fsp
->vuid
= req
? req
->vuid
: UID_FIELD_INVALID
;
883 fsp
->file_pid
= req
? req
->smbpid
: 0;
884 fsp
->can_lock
= True
;
885 fsp
->can_read
= ((access_mask
& FILE_READ_DATA
) != 0);
888 ((access_mask
& (FILE_WRITE_DATA
| FILE_APPEND_DATA
)) != 0);
889 fsp
->print_file
= NULL
;
890 fsp
->modified
= False
;
891 fsp
->sent_oplock_break
= NO_BREAK_SENT
;
892 fsp
->is_directory
= False
;
893 if (conn
->aio_write_behind_list
&&
894 is_in_path(smb_fname
->base_name
, conn
->aio_write_behind_list
,
895 conn
->case_sensitive
)) {
896 fsp
->aio_write_behind
= True
;
899 fsp
->wcp
= NULL
; /* Write cache pointer. */
901 DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
902 conn
->session_info
->unix_info
->unix_name
,
903 smb_fname_str_dbg(smb_fname
),
904 BOOLSTR(fsp
->can_read
), BOOLSTR(fsp
->can_write
),
905 conn
->num_files_open
));
911 /****************************************************************************
912 Check if we can open a file with a share mode.
913 Returns True if conflict, False if not.
914 ****************************************************************************/
916 static bool share_conflict(struct share_mode_entry
*entry
,
920 DEBUG(10,("share_conflict: entry->access_mask = 0x%x, "
921 "entry->share_access = 0x%x, "
922 "entry->private_options = 0x%x\n",
923 (unsigned int)entry
->access_mask
,
924 (unsigned int)entry
->share_access
,
925 (unsigned int)entry
->private_options
));
927 DEBUG(10,("share_conflict: access_mask = 0x%x, share_access = 0x%x\n",
928 (unsigned int)access_mask
, (unsigned int)share_access
));
930 if ((entry
->access_mask
& (FILE_WRITE_DATA
|
934 DELETE_ACCESS
)) == 0) {
935 DEBUG(10,("share_conflict: No conflict due to "
936 "entry->access_mask = 0x%x\n",
937 (unsigned int)entry
->access_mask
));
941 if ((access_mask
& (FILE_WRITE_DATA
|
945 DELETE_ACCESS
)) == 0) {
946 DEBUG(10,("share_conflict: No conflict due to "
947 "access_mask = 0x%x\n",
948 (unsigned int)access_mask
));
952 #if 1 /* JRA TEST - Superdebug. */
953 #define CHECK_MASK(num, am, right, sa, share) \
954 DEBUG(10,("share_conflict: [%d] am (0x%x) & right (0x%x) = 0x%x\n", \
955 (unsigned int)(num), (unsigned int)(am), \
956 (unsigned int)(right), (unsigned int)(am)&(right) )); \
957 DEBUG(10,("share_conflict: [%d] sa (0x%x) & share (0x%x) = 0x%x\n", \
958 (unsigned int)(num), (unsigned int)(sa), \
959 (unsigned int)(share), (unsigned int)(sa)&(share) )); \
960 if (((am) & (right)) && !((sa) & (share))) { \
961 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
962 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
963 (unsigned int)(share) )); \
967 #define CHECK_MASK(num, am, right, sa, share) \
968 if (((am) & (right)) && !((sa) & (share))) { \
969 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
970 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
971 (unsigned int)(share) )); \
976 CHECK_MASK(1, entry
->access_mask
, FILE_WRITE_DATA
| FILE_APPEND_DATA
,
977 share_access
, FILE_SHARE_WRITE
);
978 CHECK_MASK(2, access_mask
, FILE_WRITE_DATA
| FILE_APPEND_DATA
,
979 entry
->share_access
, FILE_SHARE_WRITE
);
981 CHECK_MASK(3, entry
->access_mask
, FILE_READ_DATA
| FILE_EXECUTE
,
982 share_access
, FILE_SHARE_READ
);
983 CHECK_MASK(4, access_mask
, FILE_READ_DATA
| FILE_EXECUTE
,
984 entry
->share_access
, FILE_SHARE_READ
);
986 CHECK_MASK(5, entry
->access_mask
, DELETE_ACCESS
,
987 share_access
, FILE_SHARE_DELETE
);
988 CHECK_MASK(6, access_mask
, DELETE_ACCESS
,
989 entry
->share_access
, FILE_SHARE_DELETE
);
991 DEBUG(10,("share_conflict: No conflict.\n"));
995 #if defined(DEVELOPER)
996 static void validate_my_share_entries(struct smbd_server_connection
*sconn
,
998 struct share_mode_entry
*share_entry
)
1000 struct server_id self
= messaging_server_id(sconn
->msg_ctx
);
1003 if (!serverid_equal(&self
, &share_entry
->pid
)) {
1007 if (is_deferred_open_entry(share_entry
) &&
1008 !open_was_deferred(sconn
, share_entry
->op_mid
)) {
1009 char *str
= talloc_asprintf(talloc_tos(),
1010 "Got a deferred entry without a request: "
1012 share_mode_str(talloc_tos(), num
, share_entry
));
1016 if (!is_valid_share_mode_entry(share_entry
)) {
1020 fsp
= file_find_dif(sconn
, share_entry
->id
,
1021 share_entry
->share_file_id
);
1023 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
1024 share_mode_str(talloc_tos(), num
, share_entry
) ));
1025 smb_panic("validate_my_share_entries: Cannot match a "
1026 "share entry with an open file\n");
1029 if (is_deferred_open_entry(share_entry
)) {
1033 if ((share_entry
->op_type
== NO_OPLOCK
) &&
1034 (fsp
->oplock_type
== FAKE_LEVEL_II_OPLOCK
)) {
1035 /* Someone has already written to it, but I haven't yet
1040 if (((uint16
)fsp
->oplock_type
) != share_entry
->op_type
) {
1049 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
1050 share_mode_str(talloc_tos(), num
, share_entry
) ));
1051 str
= talloc_asprintf(talloc_tos(),
1052 "validate_my_share_entries: "
1053 "file %s, oplock_type = 0x%x, op_type = 0x%x\n",
1054 fsp
->fsp_name
->base_name
,
1055 (unsigned int)fsp
->oplock_type
,
1056 (unsigned int)share_entry
->op_type
);
1062 bool is_stat_open(uint32 access_mask
)
1064 return (access_mask
&&
1065 ((access_mask
& ~(SYNCHRONIZE_ACCESS
| FILE_READ_ATTRIBUTES
|
1066 FILE_WRITE_ATTRIBUTES
))==0) &&
1067 ((access_mask
& (SYNCHRONIZE_ACCESS
|FILE_READ_ATTRIBUTES
|
1068 FILE_WRITE_ATTRIBUTES
)) != 0));
1071 /****************************************************************************
1072 Deal with share modes
1073 Invarient: Share mode must be locked on entry and exit.
1074 Returns -1 on error, or number of share modes on success (may be zero).
1075 ****************************************************************************/
1077 static NTSTATUS
open_mode_check(connection_struct
*conn
,
1078 struct share_mode_lock
*lck
,
1081 uint32 share_access
,
1082 uint32 create_options
,
1087 if(lck
->data
->num_share_modes
== 0) {
1088 return NT_STATUS_OK
;
1091 /* A delete on close prohibits everything */
1093 if (is_delete_on_close_set(lck
, name_hash
)) {
1095 * Check the delete on close token
1096 * is valid. It could have been left
1097 * after a server crash.
1099 for(i
= 0; i
< lck
->data
->num_share_modes
; i
++) {
1100 if (!share_mode_stale_pid(lck
->data
, i
)) {
1102 *file_existed
= true;
1104 return NT_STATUS_DELETE_PENDING
;
1107 return NT_STATUS_OK
;
1110 if (is_stat_open(access_mask
)) {
1111 /* Stat open that doesn't trigger oplock breaks or share mode
1112 * checks... ! JRA. */
1113 return NT_STATUS_OK
;
1117 * Check if the share modes will give us access.
1120 #if defined(DEVELOPER)
1121 for(i
= 0; i
< lck
->data
->num_share_modes
; i
++) {
1122 validate_my_share_entries(conn
->sconn
, i
,
1123 &lck
->data
->share_modes
[i
]);
1127 /* Now we check the share modes, after any oplock breaks. */
1128 for(i
= 0; i
< lck
->data
->num_share_modes
; i
++) {
1130 if (!is_valid_share_mode_entry(&lck
->data
->share_modes
[i
])) {
1134 /* someone else has a share lock on it, check to see if we can
1136 if (share_conflict(&lck
->data
->share_modes
[i
],
1137 access_mask
, share_access
)) {
1139 if (share_mode_stale_pid(lck
->data
, i
)) {
1143 *file_existed
= true;
1145 return NT_STATUS_SHARING_VIOLATION
;
1149 if (lck
->data
->num_share_modes
!= 0) {
1150 *file_existed
= true;
1153 return NT_STATUS_OK
;
1156 static bool is_delete_request(files_struct
*fsp
) {
1157 return ((fsp
->access_mask
== DELETE_ACCESS
) &&
1158 (fsp
->oplock_type
== NO_OPLOCK
));
1162 * Send a break message to the oplock holder and delay the open for
1166 static NTSTATUS
send_break_message(files_struct
*fsp
,
1167 struct share_mode_entry
*exclusive
,
1172 char msg
[MSG_SMB_SHARE_MODE_ENTRY_SIZE
];
1174 DEBUG(10, ("Sending break request to PID %s\n",
1175 procid_str_static(&exclusive
->pid
)));
1176 exclusive
->op_mid
= mid
;
1178 /* Create the message. */
1179 share_mode_entry_to_message(msg
, exclusive
);
1181 /* Add in the FORCE_OPLOCK_BREAK_TO_NONE bit in the message if set. We
1182 don't want this set in the share mode struct pointed to by lck. */
1184 if (oplock_request
& FORCE_OPLOCK_BREAK_TO_NONE
) {
1185 SSVAL(msg
,OP_BREAK_MSG_OP_TYPE_OFFSET
,
1186 exclusive
->op_type
| FORCE_OPLOCK_BREAK_TO_NONE
);
1189 status
= messaging_send_buf(fsp
->conn
->sconn
->msg_ctx
, exclusive
->pid
,
1190 MSG_SMB_BREAK_REQUEST
,
1192 MSG_SMB_SHARE_MODE_ENTRY_SIZE
);
1193 if (!NT_STATUS_IS_OK(status
)) {
1194 DEBUG(3, ("Could not send oplock break message: %s\n",
1195 nt_errstr(status
)));
1202 * Return share_mode_entry pointers for :
1203 * 1). Batch oplock entry.
1204 * 2). Batch or exclusive oplock entry (may be identical to #1).
1205 * bool have_level2_oplock
1206 * bool have_no_oplock.
1207 * Do internal consistency checks on the share mode for a file.
1210 static void find_oplock_types(files_struct
*fsp
,
1212 const struct share_mode_lock
*lck
,
1213 struct share_mode_entry
**pp_batch
,
1214 struct share_mode_entry
**pp_ex_or_batch
,
1216 bool *got_no_oplock
)
1221 *pp_ex_or_batch
= NULL
;
1222 *got_level2
= false;
1223 *got_no_oplock
= false;
1225 /* Ignore stat or internal opens, as is done in
1226 delay_for_batch_oplocks() and
1227 delay_for_exclusive_oplocks().
1229 if ((oplock_request
& INTERNAL_OPEN_ONLY
) || is_stat_open(fsp
->access_mask
)) {
1233 for (i
=0; i
<lck
->data
->num_share_modes
; i
++) {
1234 if (!is_valid_share_mode_entry(&lck
->data
->share_modes
[i
])) {
1238 if (lck
->data
->share_modes
[i
].op_type
== NO_OPLOCK
&&
1239 is_stat_open(lck
->data
->share_modes
[i
].access_mask
)) {
1240 /* We ignore stat opens in the table - they
1241 always have NO_OPLOCK and never get or
1242 cause breaks. JRA. */
1246 if (BATCH_OPLOCK_TYPE(lck
->data
->share_modes
[i
].op_type
)) {
1247 /* batch - can only be one. */
1248 if (share_mode_stale_pid(lck
->data
, i
)) {
1249 DEBUG(10, ("Found stale batch oplock\n"));
1252 if (*pp_ex_or_batch
|| *pp_batch
|| *got_level2
|| *got_no_oplock
) {
1253 smb_panic("Bad batch oplock entry.");
1255 *pp_batch
= &lck
->data
->share_modes
[i
];
1258 if (EXCLUSIVE_OPLOCK_TYPE(lck
->data
->share_modes
[i
].op_type
)) {
1259 if (share_mode_stale_pid(lck
->data
, i
)) {
1260 DEBUG(10, ("Found stale duplicate oplock\n"));
1263 /* Exclusive or batch - can only be one. */
1264 if (*pp_ex_or_batch
|| *got_level2
|| *got_no_oplock
) {
1265 smb_panic("Bad exclusive or batch oplock entry.");
1267 *pp_ex_or_batch
= &lck
->data
->share_modes
[i
];
1270 if (LEVEL_II_OPLOCK_TYPE(lck
->data
->share_modes
[i
].op_type
)) {
1271 if (*pp_batch
|| *pp_ex_or_batch
) {
1272 if (share_mode_stale_pid(lck
->data
, i
)) {
1273 DEBUG(10, ("Found stale LevelII "
1277 smb_panic("Bad levelII oplock entry.");
1282 if (lck
->data
->share_modes
[i
].op_type
== NO_OPLOCK
) {
1283 if (*pp_batch
|| *pp_ex_or_batch
) {
1284 if (share_mode_stale_pid(lck
->data
, i
)) {
1285 DEBUG(10, ("Found stale NO_OPLOCK "
1289 smb_panic("Bad no oplock entry.");
1291 *got_no_oplock
= true;
1296 static bool delay_for_batch_oplocks(files_struct
*fsp
,
1299 struct share_mode_entry
*batch_entry
)
1301 if ((oplock_request
& INTERNAL_OPEN_ONLY
) || is_stat_open(fsp
->access_mask
)) {
1304 if (batch_entry
== NULL
) {
1308 /* Found a batch oplock */
1309 send_break_message(fsp
, batch_entry
, mid
, oplock_request
);
1313 static bool delay_for_exclusive_oplocks(files_struct
*fsp
,
1316 struct share_mode_entry
*ex_entry
)
1320 if ((oplock_request
& INTERNAL_OPEN_ONLY
) || is_stat_open(fsp
->access_mask
)) {
1323 if (ex_entry
== NULL
) {
1327 /* Found an exclusive or batch oplock */
1329 delay_it
= is_delete_request(fsp
) ?
1330 BATCH_OPLOCK_TYPE(ex_entry
->op_type
) : true;
1336 send_break_message(fsp
, ex_entry
, mid
, oplock_request
);
1340 static bool file_has_brlocks(files_struct
*fsp
)
1342 struct byte_range_lock
*br_lck
;
1344 br_lck
= brl_get_locks_readonly(fsp
);
1348 return br_lck
->num_locks
> 0 ? true : false;
1351 static void grant_fsp_oplock_type(files_struct
*fsp
,
1353 bool got_level2_oplock
,
1354 bool got_a_none_oplock
)
1356 bool allow_level2
= (global_client_caps
& CAP_LEVEL_II_OPLOCKS
) &&
1357 lp_level2_oplocks(SNUM(fsp
->conn
));
1359 /* Start by granting what the client asked for,
1360 but ensure no SAMBA_PRIVATE bits can be set. */
1361 fsp
->oplock_type
= (oplock_request
& ~SAMBA_PRIVATE_OPLOCK_MASK
);
1363 if (oplock_request
& INTERNAL_OPEN_ONLY
) {
1364 /* No oplocks on internal open. */
1365 fsp
->oplock_type
= NO_OPLOCK
;
1366 DEBUG(10,("grant_fsp_oplock_type: oplock type 0x%x on file %s\n",
1367 fsp
->oplock_type
, fsp_str_dbg(fsp
)));
1371 if (lp_locking(fsp
->conn
->params
) && file_has_brlocks(fsp
)) {
1372 DEBUG(10,("grant_fsp_oplock_type: file %s has byte range locks\n",
1374 fsp
->oplock_type
= NO_OPLOCK
;
1377 if (is_stat_open(fsp
->access_mask
)) {
1378 /* Leave the value already set. */
1379 DEBUG(10,("grant_fsp_oplock_type: oplock type 0x%x on file %s\n",
1380 fsp
->oplock_type
, fsp_str_dbg(fsp
)));
1385 * Match what was requested (fsp->oplock_type) with
1386 * what was found in the existing share modes.
1389 if (got_a_none_oplock
) {
1390 fsp
->oplock_type
= NO_OPLOCK
;
1391 } else if (got_level2_oplock
) {
1392 if (fsp
->oplock_type
== NO_OPLOCK
||
1393 fsp
->oplock_type
== FAKE_LEVEL_II_OPLOCK
) {
1394 /* Store a level2 oplock, but don't tell the client */
1395 fsp
->oplock_type
= FAKE_LEVEL_II_OPLOCK
;
1397 fsp
->oplock_type
= LEVEL_II_OPLOCK
;
1400 /* All share_mode_entries are placeholders or deferred.
1401 * Silently upgrade to fake levelII if the client didn't
1402 * ask for an oplock. */
1403 if (fsp
->oplock_type
== NO_OPLOCK
) {
1404 /* Store a level2 oplock, but don't tell the client */
1405 fsp
->oplock_type
= FAKE_LEVEL_II_OPLOCK
;
1410 * Don't grant level2 to clients that don't want them
1411 * or if we've turned them off.
1413 if (fsp
->oplock_type
== LEVEL_II_OPLOCK
&& !allow_level2
) {
1414 fsp
->oplock_type
= FAKE_LEVEL_II_OPLOCK
;
1417 DEBUG(10,("grant_fsp_oplock_type: oplock type 0x%x on file %s\n",
1418 fsp
->oplock_type
, fsp_str_dbg(fsp
)));
1421 static bool request_timed_out(struct timeval request_time
,
1422 struct timeval timeout
)
1424 struct timeval now
, end_time
;
1426 end_time
= timeval_sum(&request_time
, &timeout
);
1427 return (timeval_compare(&end_time
, &now
) < 0);
1430 /****************************************************************************
1431 Handle the 1 second delay in returning a SHARING_VIOLATION error.
1432 ****************************************************************************/
1434 static void defer_open(struct share_mode_lock
*lck
,
1435 struct timeval request_time
,
1436 struct timeval timeout
,
1437 struct smb_request
*req
,
1438 struct deferred_open_record
*state
)
1440 struct server_id self
= messaging_server_id(req
->sconn
->msg_ctx
);
1442 /* Paranoia check */
1447 for (i
=0; i
<lck
->data
->num_share_modes
; i
++) {
1448 struct share_mode_entry
*e
= &lck
->data
->share_modes
[i
];
1450 if (is_deferred_open_entry(e
) &&
1451 serverid_equal(&self
, &e
->pid
) &&
1452 (e
->op_mid
== req
->mid
)) {
1453 DEBUG(0, ("Trying to defer an already deferred "
1454 "request: mid=%llu, exiting\n",
1455 (unsigned long long)req
->mid
));
1456 exit_server("attempt to defer a deferred request");
1461 /* End paranoia check */
1463 DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred "
1464 "open entry for mid %llu\n",
1465 (unsigned int)request_time
.tv_sec
,
1466 (unsigned int)request_time
.tv_usec
,
1467 (unsigned long long)req
->mid
));
1469 if (!push_deferred_open_message_smb(req
, request_time
, timeout
,
1470 state
->id
, (char *)state
, sizeof(*state
))) {
1471 exit_server("push_deferred_open_message_smb failed");
1474 add_deferred_open(lck
, req
->mid
, request_time
, self
, state
->id
);
1479 /****************************************************************************
1480 On overwrite open ensure that the attributes match.
1481 ****************************************************************************/
1483 bool open_match_attributes(connection_struct
*conn
,
1484 uint32 old_dos_attr
,
1485 uint32 new_dos_attr
,
1486 mode_t existing_unx_mode
,
1487 mode_t new_unx_mode
,
1488 mode_t
*returned_unx_mode
)
1490 uint32 noarch_old_dos_attr
, noarch_new_dos_attr
;
1492 noarch_old_dos_attr
= (old_dos_attr
& ~FILE_ATTRIBUTE_ARCHIVE
);
1493 noarch_new_dos_attr
= (new_dos_attr
& ~FILE_ATTRIBUTE_ARCHIVE
);
1495 if((noarch_old_dos_attr
== 0 && noarch_new_dos_attr
!= 0) ||
1496 (noarch_old_dos_attr
!= 0 && ((noarch_old_dos_attr
& noarch_new_dos_attr
) == noarch_old_dos_attr
))) {
1497 *returned_unx_mode
= new_unx_mode
;
1499 *returned_unx_mode
= (mode_t
)0;
1502 DEBUG(10,("open_match_attributes: old_dos_attr = 0x%x, "
1503 "existing_unx_mode = 0%o, new_dos_attr = 0x%x "
1504 "returned_unx_mode = 0%o\n",
1505 (unsigned int)old_dos_attr
,
1506 (unsigned int)existing_unx_mode
,
1507 (unsigned int)new_dos_attr
,
1508 (unsigned int)*returned_unx_mode
));
1510 /* If we're mapping SYSTEM and HIDDEN ensure they match. */
1511 if (lp_map_system(SNUM(conn
)) || lp_store_dos_attributes(SNUM(conn
))) {
1512 if ((old_dos_attr
& FILE_ATTRIBUTE_SYSTEM
) &&
1513 !(new_dos_attr
& FILE_ATTRIBUTE_SYSTEM
)) {
1517 if (lp_map_hidden(SNUM(conn
)) || lp_store_dos_attributes(SNUM(conn
))) {
1518 if ((old_dos_attr
& FILE_ATTRIBUTE_HIDDEN
) &&
1519 !(new_dos_attr
& FILE_ATTRIBUTE_HIDDEN
)) {
1526 /****************************************************************************
1527 Special FCB or DOS processing in the case of a sharing violation.
1528 Try and find a duplicated file handle.
1529 ****************************************************************************/
1531 static NTSTATUS
fcb_or_dos_open(struct smb_request
*req
,
1532 connection_struct
*conn
,
1533 files_struct
*fsp_to_dup_into
,
1534 const struct smb_filename
*smb_fname
,
1539 uint32 share_access
,
1540 uint32 create_options
)
1544 DEBUG(5,("fcb_or_dos_open: attempting old open semantics for "
1545 "file %s.\n", smb_fname_str_dbg(smb_fname
)));
1547 for(fsp
= file_find_di_first(conn
->sconn
, id
); fsp
;
1548 fsp
= file_find_di_next(fsp
)) {
1550 DEBUG(10,("fcb_or_dos_open: checking file %s, fd = %d, "
1551 "vuid = %llu, file_pid = %u, private_options = 0x%x "
1552 "access_mask = 0x%x\n", fsp_str_dbg(fsp
),
1553 fsp
->fh
->fd
, (unsigned long long)fsp
->vuid
,
1554 (unsigned int)fsp
->file_pid
,
1555 (unsigned int)fsp
->fh
->private_options
,
1556 (unsigned int)fsp
->access_mask
));
1558 if (fsp
->fh
->fd
!= -1 &&
1559 fsp
->vuid
== vuid
&&
1560 fsp
->file_pid
== file_pid
&&
1561 (fsp
->fh
->private_options
& (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS
|
1562 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB
)) &&
1563 (fsp
->access_mask
& FILE_WRITE_DATA
) &&
1564 strequal(fsp
->fsp_name
->base_name
, smb_fname
->base_name
) &&
1565 strequal(fsp
->fsp_name
->stream_name
,
1566 smb_fname
->stream_name
)) {
1567 DEBUG(10,("fcb_or_dos_open: file match\n"));
1573 return NT_STATUS_NOT_FOUND
;
1576 /* quite an insane set of semantics ... */
1577 if (is_executable(smb_fname
->base_name
) &&
1578 (fsp
->fh
->private_options
& NTCREATEX_OPTIONS_PRIVATE_DENY_DOS
)) {
1579 DEBUG(10,("fcb_or_dos_open: file fail due to is_executable.\n"));
1580 return NT_STATUS_INVALID_PARAMETER
;
1583 /* We need to duplicate this fsp. */
1584 return dup_file_fsp(req
, fsp
, access_mask
, share_access
,
1585 create_options
, fsp_to_dup_into
);
1588 static void schedule_defer_open(struct share_mode_lock
*lck
,
1589 struct timeval request_time
,
1590 struct smb_request
*req
)
1592 struct deferred_open_record state
;
1594 /* This is a relative time, added to the absolute
1595 request_time value to get the absolute timeout time.
1596 Note that if this is the second or greater time we enter
1597 this codepath for this particular request mid then
1598 request_time is left as the absolute time of the *first*
1599 time this request mid was processed. This is what allows
1600 the request to eventually time out. */
1602 struct timeval timeout
;
1604 /* Normally the smbd we asked should respond within
1605 * OPLOCK_BREAK_TIMEOUT seconds regardless of whether
1606 * the client did, give twice the timeout as a safety
1607 * measure here in case the other smbd is stuck
1608 * somewhere else. */
1610 timeout
= timeval_set(OPLOCK_BREAK_TIMEOUT
*2, 0);
1612 /* Nothing actually uses state.delayed_for_oplocks
1613 but it's handy to differentiate in debug messages
1614 between a 30 second delay due to oplock break, and
1615 a 1 second delay for share mode conflicts. */
1617 state
.delayed_for_oplocks
= True
;
1618 state
.async_open
= false;
1619 state
.id
= lck
->data
->id
;
1621 if (!request_timed_out(request_time
, timeout
)) {
1622 defer_open(lck
, request_time
, timeout
, req
, &state
);
1626 /****************************************************************************
1627 Reschedule an open call that went asynchronous.
1628 ****************************************************************************/
1630 static void schedule_async_open(struct timeval request_time
,
1631 struct smb_request
*req
)
1633 struct deferred_open_record state
;
1634 struct timeval timeout
;
1636 timeout
= timeval_set(20, 0);
1639 state
.delayed_for_oplocks
= false;
1640 state
.async_open
= true;
1642 if (!request_timed_out(request_time
, timeout
)) {
1643 defer_open(NULL
, request_time
, timeout
, req
, &state
);
1647 /****************************************************************************
1648 Work out what access_mask to use from what the client sent us.
1649 ****************************************************************************/
1651 static NTSTATUS
smbd_calculate_maximum_allowed_access(
1652 connection_struct
*conn
,
1653 const struct smb_filename
*smb_fname
,
1654 uint32_t *p_access_mask
)
1656 struct security_descriptor
*sd
;
1657 uint32_t access_granted
;
1660 if (get_current_uid(conn
) == (uid_t
)0) {
1661 *p_access_mask
|= FILE_GENERIC_ALL
;
1662 return NT_STATUS_OK
;
1665 status
= SMB_VFS_GET_NT_ACL(conn
, smb_fname
->base_name
,
1670 if (NT_STATUS_EQUAL(status
, NT_STATUS_OBJECT_NAME_NOT_FOUND
)) {
1672 * File did not exist
1674 *p_access_mask
= FILE_GENERIC_ALL
;
1675 return NT_STATUS_OK
;
1677 if (!NT_STATUS_IS_OK(status
)) {
1678 DEBUG(10,("smbd_calculate_access_mask: "
1679 "Could not get acl on file %s: %s\n",
1680 smb_fname_str_dbg(smb_fname
),
1681 nt_errstr(status
)));
1682 return NT_STATUS_ACCESS_DENIED
;
1686 * Never test FILE_READ_ATTRIBUTES. se_file_access_check()
1687 * also takes care of owner WRITE_DAC and READ_CONTROL.
1689 status
= se_file_access_check(sd
,
1690 get_current_nttok(conn
),
1692 (*p_access_mask
& ~FILE_READ_ATTRIBUTES
),
1697 if (!NT_STATUS_IS_OK(status
)) {
1698 DEBUG(10, ("smbd_calculate_access_mask: "
1699 "Access denied on file %s: "
1700 "when calculating maximum access\n",
1701 smb_fname_str_dbg(smb_fname
)));
1702 return NT_STATUS_ACCESS_DENIED
;
1704 *p_access_mask
= (access_granted
| FILE_READ_ATTRIBUTES
);
1705 return NT_STATUS_OK
;
1708 NTSTATUS
smbd_calculate_access_mask(connection_struct
*conn
,
1709 const struct smb_filename
*smb_fname
,
1710 uint32_t access_mask
,
1711 uint32_t *access_mask_out
)
1714 uint32_t orig_access_mask
= access_mask
;
1715 uint32_t rejected_share_access
;
1718 * Convert GENERIC bits to specific bits.
1721 se_map_generic(&access_mask
, &file_generic_mapping
);
1723 /* Calculate MAXIMUM_ALLOWED_ACCESS if requested. */
1724 if (access_mask
& MAXIMUM_ALLOWED_ACCESS
) {
1726 status
= smbd_calculate_maximum_allowed_access(
1727 conn
, smb_fname
, &access_mask
);
1729 if (!NT_STATUS_IS_OK(status
)) {
1733 access_mask
&= conn
->share_access
;
1736 rejected_share_access
= access_mask
& ~(conn
->share_access
);
1738 if (rejected_share_access
) {
1739 DEBUG(10, ("smbd_calculate_access_mask: Access denied on "
1740 "file %s: rejected by share access mask[0x%08X] "
1741 "orig[0x%08X] mapped[0x%08X] reject[0x%08X]\n",
1742 smb_fname_str_dbg(smb_fname
),
1744 orig_access_mask
, access_mask
,
1745 rejected_share_access
));
1746 return NT_STATUS_ACCESS_DENIED
;
1749 *access_mask_out
= access_mask
;
1750 return NT_STATUS_OK
;
1753 /****************************************************************************
1754 Remove the deferred open entry under lock.
1755 ****************************************************************************/
1757 void remove_deferred_open_entry(struct file_id id
, uint64_t mid
,
1758 struct server_id pid
)
1760 struct share_mode_lock
*lck
= get_existing_share_mode_lock(
1763 DEBUG(0, ("could not get share mode lock\n"));
1766 del_deferred_open_entry(lck
, mid
, pid
);
1770 /****************************************************************************
1771 Return true if this is a state pointer to an asynchronous create.
1772 ****************************************************************************/
1774 bool is_deferred_open_async(const void *ptr
)
1776 const struct deferred_open_record
*state
= (const struct deferred_open_record
*)ptr
;
1778 return state
->async_open
;
1781 /****************************************************************************
1782 Open a file with a share mode. Passed in an already created files_struct *.
1783 ****************************************************************************/
1785 static NTSTATUS
open_file_ntcreate(connection_struct
*conn
,
1786 struct smb_request
*req
,
1787 uint32 access_mask
, /* access bits (FILE_READ_DATA etc.) */
1788 uint32 share_access
, /* share constants (FILE_SHARE_READ etc) */
1789 uint32 create_disposition
, /* FILE_OPEN_IF etc. */
1790 uint32 create_options
, /* options such as delete on close. */
1791 uint32 new_dos_attributes
, /* attributes used for new file. */
1792 int oplock_request
, /* internal Samba oplock codes. */
1793 /* Information (FILE_EXISTS etc.) */
1794 uint32_t private_flags
, /* Samba specific flags. */
1798 struct smb_filename
*smb_fname
= fsp
->fsp_name
;
1801 bool file_existed
= VALID_STAT(smb_fname
->st
);
1802 bool def_acl
= False
;
1803 bool posix_open
= False
;
1804 bool new_file_created
= False
;
1805 bool clear_ads
= false;
1806 NTSTATUS fsp_open
= NT_STATUS_ACCESS_DENIED
;
1807 mode_t new_unx_mode
= (mode_t
)0;
1808 mode_t unx_mode
= (mode_t
)0;
1810 uint32 existing_dos_attributes
= 0;
1811 struct timeval request_time
= timeval_zero();
1812 struct share_mode_lock
*lck
= NULL
;
1813 uint32 open_access_mask
= access_mask
;
1816 SMB_STRUCT_STAT saved_stat
= smb_fname
->st
;
1818 if (conn
->printer
) {
1820 * Printers are handled completely differently.
1821 * Most of the passed parameters are ignored.
1825 *pinfo
= FILE_WAS_CREATED
;
1828 DEBUG(10, ("open_file_ntcreate: printer open fname=%s\n",
1829 smb_fname_str_dbg(smb_fname
)));
1832 DEBUG(0,("open_file_ntcreate: printer open without "
1833 "an SMB request!\n"));
1834 return NT_STATUS_INTERNAL_ERROR
;
1837 return print_spool_open(fsp
, smb_fname
->base_name
,
1841 if (!parent_dirname(talloc_tos(), smb_fname
->base_name
, &parent_dir
,
1843 return NT_STATUS_NO_MEMORY
;
1846 if (new_dos_attributes
& FILE_FLAG_POSIX_SEMANTICS
) {
1848 unx_mode
= (mode_t
)(new_dos_attributes
& ~FILE_FLAG_POSIX_SEMANTICS
);
1849 new_dos_attributes
= 0;
1851 /* Windows allows a new file to be created and
1852 silently removes a FILE_ATTRIBUTE_DIRECTORY
1853 sent by the client. Do the same. */
1855 new_dos_attributes
&= ~FILE_ATTRIBUTE_DIRECTORY
;
1857 /* We add FILE_ATTRIBUTE_ARCHIVE to this as this mode is only used if the file is
1859 unx_mode
= unix_mode(conn
, new_dos_attributes
| FILE_ATTRIBUTE_ARCHIVE
,
1860 smb_fname
, parent_dir
);
1863 DEBUG(10, ("open_file_ntcreate: fname=%s, dos_attrs=0x%x "
1864 "access_mask=0x%x share_access=0x%x "
1865 "create_disposition = 0x%x create_options=0x%x "
1866 "unix mode=0%o oplock_request=%d private_flags = 0x%x\n",
1867 smb_fname_str_dbg(smb_fname
), new_dos_attributes
,
1868 access_mask
, share_access
, create_disposition
,
1869 create_options
, (unsigned int)unx_mode
, oplock_request
,
1870 (unsigned int)private_flags
));
1872 if ((req
== NULL
) && ((oplock_request
& INTERNAL_OPEN_ONLY
) == 0)) {
1873 DEBUG(0, ("No smb request but not an internal only open!\n"));
1874 return NT_STATUS_INTERNAL_ERROR
;
1878 * Only non-internal opens can be deferred at all
1883 if (get_deferred_open_message_state(req
,
1886 /* Remember the absolute time of the original
1887 request with this mid. We'll use it later to
1888 see if this has timed out. */
1890 /* If it was an async create retry, the file
1893 if (is_deferred_open_async(ptr
)) {
1894 SET_STAT_INVALID(smb_fname
->st
);
1895 file_existed
= false;
1897 struct deferred_open_record
*state
= (struct deferred_open_record
*)ptr
;
1898 /* Remove the deferred open entry under lock. */
1899 remove_deferred_open_entry(
1900 state
->id
, req
->mid
,
1901 messaging_server_id(req
->sconn
->msg_ctx
));
1904 /* Ensure we don't reprocess this message. */
1905 remove_deferred_open_message_smb(req
->sconn
, req
->mid
);
1910 new_dos_attributes
&= SAMBA_ATTRIBUTES_MASK
;
1912 existing_dos_attributes
= dos_mode(conn
, smb_fname
);
1916 /* ignore any oplock requests if oplocks are disabled */
1917 if (!lp_oplocks(SNUM(conn
)) ||
1918 IS_VETO_OPLOCK_PATH(conn
, smb_fname
->base_name
)) {
1919 /* Mask off everything except the private Samba bits. */
1920 oplock_request
&= SAMBA_PRIVATE_OPLOCK_MASK
;
1923 /* this is for OS/2 long file names - say we don't support them */
1924 if (!lp_posix_pathnames() && strstr(smb_fname
->base_name
,".+,;=[].")) {
1925 /* OS/2 Workplace shell fix may be main code stream in a later
1927 DEBUG(5,("open_file_ntcreate: OS/2 long filenames are not "
1929 if (use_nt_status()) {
1930 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
1932 return NT_STATUS_DOS(ERRDOS
, ERRcannotopen
);
1935 switch( create_disposition
) {
1937 * Currently we're using FILE_SUPERSEDE as the same as
1938 * FILE_OVERWRITE_IF but they really are
1939 * different. FILE_SUPERSEDE deletes an existing file
1940 * (requiring delete access) then recreates it.
1942 case FILE_SUPERSEDE
:
1943 /* If file exists replace/overwrite. If file doesn't
1945 flags2
|= (O_CREAT
| O_TRUNC
);
1949 case FILE_OVERWRITE_IF
:
1950 /* If file exists replace/overwrite. If file doesn't
1952 flags2
|= (O_CREAT
| O_TRUNC
);
1957 /* If file exists open. If file doesn't exist error. */
1958 if (!file_existed
) {
1959 DEBUG(5,("open_file_ntcreate: FILE_OPEN "
1960 "requested for file %s and file "
1962 smb_fname_str_dbg(smb_fname
)));
1964 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
1968 case FILE_OVERWRITE
:
1969 /* If file exists overwrite. If file doesn't exist
1971 if (!file_existed
) {
1972 DEBUG(5,("open_file_ntcreate: FILE_OVERWRITE "
1973 "requested for file %s and file "
1975 smb_fname_str_dbg(smb_fname
) ));
1977 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
1984 /* If file exists error. If file doesn't exist
1987 DEBUG(5,("open_file_ntcreate: FILE_CREATE "
1988 "requested for file %s and file "
1989 "already exists.\n",
1990 smb_fname_str_dbg(smb_fname
)));
1991 if (S_ISDIR(smb_fname
->st
.st_ex_mode
)) {
1996 return map_nt_error_from_unix(errno
);
1998 flags2
|= (O_CREAT
|O_EXCL
);
2002 /* If file exists open. If file doesn't exist
2008 return NT_STATUS_INVALID_PARAMETER
;
2011 /* We only care about matching attributes on file exists and
2014 if (!posix_open
&& file_existed
&& ((create_disposition
== FILE_OVERWRITE
) ||
2015 (create_disposition
== FILE_OVERWRITE_IF
))) {
2016 if (!open_match_attributes(conn
, existing_dos_attributes
,
2018 smb_fname
->st
.st_ex_mode
,
2019 unx_mode
, &new_unx_mode
)) {
2020 DEBUG(5,("open_file_ntcreate: attributes missmatch "
2021 "for file %s (%x %x) (0%o, 0%o)\n",
2022 smb_fname_str_dbg(smb_fname
),
2023 existing_dos_attributes
,
2025 (unsigned int)smb_fname
->st
.st_ex_mode
,
2026 (unsigned int)unx_mode
));
2028 return NT_STATUS_ACCESS_DENIED
;
2032 status
= smbd_calculate_access_mask(conn
, smb_fname
,
2035 if (!NT_STATUS_IS_OK(status
)) {
2036 DEBUG(10, ("open_file_ntcreate: smbd_calculate_access_mask "
2037 "on file %s returned %s\n",
2038 smb_fname_str_dbg(smb_fname
), nt_errstr(status
)));
2042 open_access_mask
= access_mask
;
2044 if ((flags2
& O_TRUNC
) || (oplock_request
& FORCE_OPLOCK_BREAK_TO_NONE
)) {
2045 open_access_mask
|= FILE_WRITE_DATA
; /* This will cause oplock breaks. */
2048 DEBUG(10, ("open_file_ntcreate: fname=%s, after mapping "
2049 "access_mask=0x%x\n", smb_fname_str_dbg(smb_fname
),
2053 * Note that we ignore the append flag as append does not
2054 * mean the same thing under DOS and Unix.
2057 if ((access_mask
& (FILE_WRITE_DATA
| FILE_APPEND_DATA
)) ||
2058 (oplock_request
& FORCE_OPLOCK_BREAK_TO_NONE
)) {
2059 /* DENY_DOS opens are always underlying read-write on the
2060 file handle, no matter what the requested access mask
2062 if ((private_flags
& NTCREATEX_OPTIONS_PRIVATE_DENY_DOS
) ||
2063 access_mask
& (FILE_READ_ATTRIBUTES
|FILE_READ_DATA
|FILE_READ_EA
|FILE_EXECUTE
)) {
2073 * Currently we only look at FILE_WRITE_THROUGH for create options.
2077 if ((create_options
& FILE_WRITE_THROUGH
) && lp_strict_sync(SNUM(conn
))) {
2082 if (posix_open
&& (access_mask
& FILE_APPEND_DATA
)) {
2086 if (!posix_open
&& !CAN_WRITE(conn
)) {
2088 * We should really return a permission denied error if either
2089 * O_CREAT or O_TRUNC are set, but for compatibility with
2090 * older versions of Samba we just AND them out.
2092 flags2
&= ~(O_CREAT
|O_TRUNC
);
2096 * Ensure we can't write on a read-only share or file.
2099 if (flags
!= O_RDONLY
&& file_existed
&&
2100 (!CAN_WRITE(conn
) || IS_DOS_READONLY(existing_dos_attributes
))) {
2101 DEBUG(5,("open_file_ntcreate: write access requested for "
2102 "file %s on read only %s\n",
2103 smb_fname_str_dbg(smb_fname
),
2104 !CAN_WRITE(conn
) ? "share" : "file" ));
2106 return NT_STATUS_ACCESS_DENIED
;
2109 fsp
->file_id
= vfs_file_id_from_sbuf(conn
, &smb_fname
->st
);
2110 fsp
->share_access
= share_access
;
2111 fsp
->fh
->private_options
= private_flags
;
2112 fsp
->access_mask
= open_access_mask
; /* We change this to the
2113 * requested access_mask after
2114 * the open is done. */
2115 fsp
->posix_open
= posix_open
;
2117 /* Ensure no SAMBA_PRIVATE bits can be set. */
2118 fsp
->oplock_type
= (oplock_request
& ~SAMBA_PRIVATE_OPLOCK_MASK
);
2120 if (timeval_is_zero(&request_time
)) {
2121 request_time
= fsp
->open_time
;
2125 struct share_mode_entry
*batch_entry
= NULL
;
2126 struct share_mode_entry
*exclusive_entry
= NULL
;
2127 bool got_level2_oplock
= false;
2128 bool got_a_none_oplock
= false;
2131 struct timespec old_write_time
= smb_fname
->st
.st_ex_mtime
;
2132 id
= vfs_file_id_from_sbuf(conn
, &smb_fname
->st
);
2134 lck
= get_share_mode_lock(talloc_tos(), id
,
2136 smb_fname
, &old_write_time
);
2138 DEBUG(0, ("Could not get share mode lock\n"));
2139 return NT_STATUS_SHARING_VIOLATION
;
2142 /* Get the types we need to examine. */
2143 find_oplock_types(fsp
,
2149 &got_a_none_oplock
);
2151 /* First pass - send break only on batch oplocks. */
2152 if ((req
!= NULL
) &&
2153 delay_for_batch_oplocks(fsp
,
2157 schedule_defer_open(lck
, request_time
, req
);
2159 return NT_STATUS_SHARING_VIOLATION
;
2162 /* Use the client requested access mask here, not the one we
2164 status
= open_mode_check(conn
, lck
, fsp
->name_hash
,
2165 access_mask
, share_access
,
2166 create_options
, &file_existed
);
2168 if (NT_STATUS_IS_OK(status
)) {
2169 /* We might be going to allow this open. Check oplock
2171 /* Second pass - send break for both batch or
2172 * exclusive oplocks. */
2173 if ((req
!= NULL
) &&
2174 delay_for_exclusive_oplocks(
2179 schedule_defer_open(lck
, request_time
, req
);
2181 return NT_STATUS_SHARING_VIOLATION
;
2185 if (NT_STATUS_EQUAL(status
, NT_STATUS_DELETE_PENDING
)) {
2186 /* DELETE_PENDING is not deferred for a second */
2191 grant_fsp_oplock_type(fsp
,
2196 if (!NT_STATUS_IS_OK(status
)) {
2197 uint32 can_access_mask
;
2198 bool can_access
= True
;
2200 SMB_ASSERT(NT_STATUS_EQUAL(status
, NT_STATUS_SHARING_VIOLATION
));
2202 /* Check if this can be done with the deny_dos and fcb
2205 (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS
|
2206 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB
)) {
2208 DEBUG(0, ("DOS open without an SMB "
2211 return NT_STATUS_INTERNAL_ERROR
;
2214 /* Use the client requested access mask here,
2215 * not the one we open with. */
2216 status
= fcb_or_dos_open(req
,
2227 if (NT_STATUS_IS_OK(status
)) {
2230 *pinfo
= FILE_WAS_OPENED
;
2232 return NT_STATUS_OK
;
2237 * This next line is a subtlety we need for
2238 * MS-Access. If a file open will fail due to share
2239 * permissions and also for security (access) reasons,
2240 * we need to return the access failed error, not the
2241 * share error. We can't open the file due to kernel
2242 * oplock deadlock (it's possible we failed above on
2243 * the open_mode_check()) so use a userspace check.
2246 if (flags
& O_RDWR
) {
2247 can_access_mask
= FILE_READ_DATA
|FILE_WRITE_DATA
;
2248 } else if (flags
& O_WRONLY
) {
2249 can_access_mask
= FILE_WRITE_DATA
;
2251 can_access_mask
= FILE_READ_DATA
;
2254 if (((can_access_mask
& FILE_WRITE_DATA
) &&
2255 !CAN_WRITE(conn
)) ||
2256 !NT_STATUS_IS_OK(smbd_check_access_rights(conn
,
2257 smb_fname
, can_access_mask
))) {
2262 * If we're returning a share violation, ensure we
2263 * cope with the braindead 1 second delay.
2266 if (!(oplock_request
& INTERNAL_OPEN_ONLY
) &&
2267 lp_defer_sharing_violations()) {
2268 struct timeval timeout
;
2269 struct deferred_open_record state
;
2272 /* this is a hack to speed up torture tests
2274 timeout_usecs
= lp_parm_int(SNUM(conn
),
2275 "smbd","sharedelay",
2276 SHARING_VIOLATION_USEC_WAIT
);
2278 /* This is a relative time, added to the absolute
2279 request_time value to get the absolute timeout time.
2280 Note that if this is the second or greater time we enter
2281 this codepath for this particular request mid then
2282 request_time is left as the absolute time of the *first*
2283 time this request mid was processed. This is what allows
2284 the request to eventually time out. */
2286 timeout
= timeval_set(0, timeout_usecs
);
2288 /* Nothing actually uses state.delayed_for_oplocks
2289 but it's handy to differentiate in debug messages
2290 between a 30 second delay due to oplock break, and
2291 a 1 second delay for share mode conflicts. */
2293 state
.delayed_for_oplocks
= False
;
2294 state
.async_open
= false;
2298 && !request_timed_out(request_time
,
2300 defer_open(lck
, request_time
, timeout
,
2308 * We have detected a sharing violation here
2309 * so return the correct error code
2311 status
= NT_STATUS_SHARING_VIOLATION
;
2313 status
= NT_STATUS_ACCESS_DENIED
;
2319 * We exit this block with the share entry *locked*.....
2323 SMB_ASSERT(!file_existed
|| (lck
!= NULL
));
2326 * Ensure we pay attention to default ACLs on directories if required.
2329 if ((flags2
& O_CREAT
) && lp_inherit_acls(SNUM(conn
)) &&
2330 (def_acl
= directory_has_default_acl(conn
, parent_dir
))) {
2331 unx_mode
= (0777 & lp_create_mask(SNUM(conn
)));
2334 DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o, "
2335 "access_mask = 0x%x, open_access_mask = 0x%x\n",
2336 (unsigned int)flags
, (unsigned int)flags2
,
2337 (unsigned int)unx_mode
, (unsigned int)access_mask
,
2338 (unsigned int)open_access_mask
));
2341 * open_file strips any O_TRUNC flags itself.
2344 fsp_open
= open_file(fsp
, conn
, req
, parent_dir
,
2345 flags
|flags2
, unx_mode
, access_mask
,
2346 open_access_mask
, &new_file_created
);
2348 if (!NT_STATUS_IS_OK(fsp_open
)) {
2349 if (NT_STATUS_EQUAL(fsp_open
, NT_STATUS_RETRY
)) {
2350 schedule_async_open(request_time
, req
);
2356 if (file_existed
&& !check_same_dev_ino(&saved_stat
, &smb_fname
->st
)) {
2358 * The file did exist, but some other (local or NFS)
2359 * process either renamed/unlinked and re-created the
2360 * file with different dev/ino after we walked the path,
2361 * but before we did the open. We could retry the
2362 * open but it's a rare enough case it's easier to
2363 * just fail the open to prevent creating any problems
2364 * in the open file db having the wrong dev/ino key.
2368 DEBUG(1,("open_file_ntcreate: file %s - dev/ino mismatch. "
2369 "Old (dev=0x%llu, ino =0x%llu). "
2370 "New (dev=0x%llu, ino=0x%llu). Failing open "
2371 " with NT_STATUS_ACCESS_DENIED.\n",
2372 smb_fname_str_dbg(smb_fname
),
2373 (unsigned long long)saved_stat
.st_ex_dev
,
2374 (unsigned long long)saved_stat
.st_ex_ino
,
2375 (unsigned long long)smb_fname
->st
.st_ex_dev
,
2376 (unsigned long long)smb_fname
->st
.st_ex_ino
));
2377 return NT_STATUS_ACCESS_DENIED
;
2380 if (!file_existed
) {
2381 struct share_mode_entry
*batch_entry
= NULL
;
2382 struct share_mode_entry
*exclusive_entry
= NULL
;
2383 bool got_level2_oplock
= false;
2384 bool got_a_none_oplock
= false;
2385 struct timespec old_write_time
= smb_fname
->st
.st_ex_mtime
;
2388 * Deal with the race condition where two smbd's detect the
2389 * file doesn't exist and do the create at the same time. One
2390 * of them will win and set a share mode, the other (ie. this
2391 * one) should check if the requested share mode for this
2392 * create is allowed.
2396 * Now the file exists and fsp is successfully opened,
2397 * fsp->dev and fsp->inode are valid and should replace the
2398 * dev=0,inode=0 from a non existent file. Spotted by
2399 * Nadav Danieli <nadavd@exanet.com>. JRA.
2404 lck
= get_share_mode_lock(talloc_tos(), id
,
2406 smb_fname
, &old_write_time
);
2409 DEBUG(0, ("open_file_ntcreate: Could not get share "
2410 "mode lock for %s\n",
2411 smb_fname_str_dbg(smb_fname
)));
2413 return NT_STATUS_SHARING_VIOLATION
;
2416 /* Get the types we need to examine. */
2417 find_oplock_types(fsp
,
2423 &got_a_none_oplock
);
2425 /* First pass - send break only on batch oplocks. */
2426 if ((req
!= NULL
) &&
2427 delay_for_batch_oplocks(fsp
,
2431 schedule_defer_open(lck
, request_time
, req
);
2434 return NT_STATUS_SHARING_VIOLATION
;
2437 status
= open_mode_check(conn
, lck
, fsp
->name_hash
,
2438 access_mask
, share_access
,
2439 create_options
, &file_existed
);
2441 if (NT_STATUS_IS_OK(status
)) {
2442 /* We might be going to allow this open. Check oplock
2444 /* Second pass - send break for both batch or
2445 * exclusive oplocks. */
2446 if ((req
!= NULL
) &&
2447 delay_for_exclusive_oplocks(
2452 schedule_defer_open(lck
, request_time
, req
);
2455 return NT_STATUS_SHARING_VIOLATION
;
2459 if (!NT_STATUS_IS_OK(status
)) {
2460 struct deferred_open_record state
;
2462 state
.delayed_for_oplocks
= False
;
2463 state
.async_open
= false;
2466 /* Do it all over again immediately. In the second
2467 * round we will find that the file existed and handle
2468 * the DELETE_PENDING and FCB cases correctly. No need
2469 * to duplicate the code here. Essentially this is a
2470 * "goto top of this function", but don't tell
2474 defer_open(lck
, request_time
, timeval_zero(),
2482 grant_fsp_oplock_type(fsp
,
2488 * We exit this block with the share entry *locked*.....
2493 SMB_ASSERT(lck
!= NULL
);
2495 /* Delete streams if create_disposition requires it */
2496 if (!new_file_created
&& clear_ads
&&
2497 !is_ntfs_stream_smb_fname(smb_fname
)) {
2498 status
= delete_all_streams(conn
, smb_fname
->base_name
);
2499 if (!NT_STATUS_IS_OK(status
)) {
2506 /* note that we ignore failure for the following. It is
2507 basically a hack for NFS, and NFS will never set one of
2508 these only read them. Nobody but Samba can ever set a deny
2509 mode and we have already checked our more authoritative
2510 locking database for permission to set this deny mode. If
2511 the kernel refuses the operations then the kernel is wrong.
2512 note that GPFS supports it as well - jmcd */
2514 if (fsp
->fh
->fd
!= -1) {
2516 ret_flock
= SMB_VFS_KERNEL_FLOCK(fsp
, share_access
, access_mask
);
2517 if(ret_flock
== -1 ){
2522 return NT_STATUS_SHARING_VIOLATION
;
2527 * At this point onwards, we can guarentee that the share entry
2528 * is locked, whether we created the file or not, and that the
2529 * deny mode is compatible with all current opens.
2533 * If requested, truncate the file.
2536 if (!new_file_created
&& (flags2
&O_TRUNC
)) {
2538 * We are modifying the file after open - update the stat
2541 if ((SMB_VFS_FTRUNCATE(fsp
, 0) == -1) ||
2542 (SMB_VFS_FSTAT(fsp
, &smb_fname
->st
)==-1)) {
2543 status
= map_nt_error_from_unix(errno
);
2551 * According to Samba4, SEC_FILE_READ_ATTRIBUTE is always granted,
2552 * but we don't have to store this - just ignore it on access check.
2554 if (conn
->sconn
->using_smb2
) {
2556 * SMB2 doesn't return it (according to Microsoft tests).
2557 * Test Case: TestSuite_ScenarioNo009GrantedAccessTestS0
2558 * File created with access = 0x7 (Read, Write, Delete)
2559 * Query Info on file returns 0x87 (Read, Write, Delete, Read Attributes)
2561 fsp
->access_mask
= access_mask
;
2563 /* But SMB1 does. */
2564 fsp
->access_mask
= access_mask
| FILE_READ_ATTRIBUTES
;
2568 /* stat opens on existing files don't get oplocks. */
2569 if (is_stat_open(open_access_mask
)) {
2570 fsp
->oplock_type
= NO_OPLOCK
;
2574 if (new_file_created
) {
2575 info
= FILE_WAS_CREATED
;
2577 if (flags2
& O_TRUNC
) {
2578 info
= FILE_WAS_OVERWRITTEN
;
2580 info
= FILE_WAS_OPENED
;
2589 * Setup the oplock info in both the shared memory and
2593 status
= set_file_oplock(fsp
, fsp
->oplock_type
);
2594 if (!NT_STATUS_IS_OK(status
)) {
2596 * Could not get the kernel oplock or there are byte-range
2597 * locks on the file.
2599 fsp
->oplock_type
= NO_OPLOCK
;
2602 set_share_mode(lck
, fsp
, get_current_uid(conn
),
2606 /* Handle strange delete on close create semantics. */
2607 if (create_options
& FILE_DELETE_ON_CLOSE
) {
2609 status
= can_set_delete_on_close(fsp
, new_dos_attributes
);
2611 if (!NT_STATUS_IS_OK(status
)) {
2612 /* Remember to delete the mode we just added. */
2613 del_share_mode(lck
, fsp
);
2618 /* Note that here we set the *inital* delete on close flag,
2619 not the regular one. The magic gets handled in close. */
2620 fsp
->initial_delete_on_close
= True
;
2623 if (info
!= FILE_WAS_OPENED
) {
2624 /* Files should be initially set as archive */
2625 if (lp_map_archive(SNUM(conn
)) ||
2626 lp_store_dos_attributes(SNUM(conn
))) {
2628 if (file_set_dosmode(conn
, smb_fname
,
2629 new_dos_attributes
| FILE_ATTRIBUTE_ARCHIVE
,
2630 parent_dir
, true) == 0) {
2631 unx_mode
= smb_fname
->st
.st_ex_mode
;
2637 /* Determine sparse flag. */
2639 /* POSIX opens are sparse by default. */
2640 fsp
->is_sparse
= true;
2642 fsp
->is_sparse
= (file_existed
&&
2643 (existing_dos_attributes
& FILE_ATTRIBUTE_SPARSE
));
2647 * Take care of inherited ACLs on created files - if default ACL not
2651 if (!posix_open
&& new_file_created
&& !def_acl
) {
2653 int saved_errno
= errno
; /* We might get ENOSYS in the next
2656 if (SMB_VFS_FCHMOD_ACL(fsp
, unx_mode
) == -1 &&
2658 errno
= saved_errno
; /* Ignore ENOSYS */
2661 } else if (new_unx_mode
) {
2665 /* Attributes need changing. File already existed. */
2668 int saved_errno
= errno
; /* We might get ENOSYS in the
2670 ret
= SMB_VFS_FCHMOD_ACL(fsp
, new_unx_mode
);
2672 if (ret
== -1 && errno
== ENOSYS
) {
2673 errno
= saved_errno
; /* Ignore ENOSYS */
2675 DEBUG(5, ("open_file_ntcreate: reset "
2676 "attributes of file %s to 0%o\n",
2677 smb_fname_str_dbg(smb_fname
),
2678 (unsigned int)new_unx_mode
));
2679 ret
= 0; /* Don't do the fchmod below. */
2684 (SMB_VFS_FCHMOD(fsp
, new_unx_mode
) == -1))
2685 DEBUG(5, ("open_file_ntcreate: failed to reset "
2686 "attributes of file %s to 0%o\n",
2687 smb_fname_str_dbg(smb_fname
),
2688 (unsigned int)new_unx_mode
));
2691 /* If this is a successful open, we must remove any deferred open
2694 del_deferred_open_entry(lck
, req
->mid
,
2695 messaging_server_id(req
->sconn
->msg_ctx
));
2699 return NT_STATUS_OK
;
2703 /****************************************************************************
2704 Open a file for for write to ensure that we can fchmod it.
2705 ****************************************************************************/
2707 NTSTATUS
open_file_fchmod(connection_struct
*conn
,
2708 struct smb_filename
*smb_fname
,
2709 files_struct
**result
)
2711 if (!VALID_STAT(smb_fname
->st
)) {
2712 return NT_STATUS_INVALID_PARAMETER
;
2715 return SMB_VFS_CREATE_FILE(
2718 0, /* root_dir_fid */
2719 smb_fname
, /* fname */
2720 FILE_WRITE_DATA
, /* access_mask */
2721 (FILE_SHARE_READ
| FILE_SHARE_WRITE
| /* share_access */
2723 FILE_OPEN
, /* create_disposition*/
2724 0, /* create_options */
2725 0, /* file_attributes */
2726 INTERNAL_OPEN_ONLY
, /* oplock_request */
2727 0, /* allocation_size */
2728 0, /* private_flags */
2731 result
, /* result */
2735 static NTSTATUS
mkdir_internal(connection_struct
*conn
,
2736 struct smb_filename
*smb_dname
,
2737 uint32 file_attributes
)
2740 char *parent_dir
= NULL
;
2742 bool posix_open
= false;
2743 bool need_re_stat
= false;
2744 uint32_t access_mask
= SEC_DIR_ADD_SUBDIR
;
2746 if(access_mask
& ~(conn
->share_access
)) {
2747 DEBUG(5,("mkdir_internal: failing share access "
2748 "%s\n", lp_servicename(talloc_tos(), SNUM(conn
))));
2749 return NT_STATUS_ACCESS_DENIED
;
2752 if (!parent_dirname(talloc_tos(), smb_dname
->base_name
, &parent_dir
,
2754 return NT_STATUS_NO_MEMORY
;
2757 if (file_attributes
& FILE_FLAG_POSIX_SEMANTICS
) {
2759 mode
= (mode_t
)(file_attributes
& ~FILE_FLAG_POSIX_SEMANTICS
);
2761 mode
= unix_mode(conn
, FILE_ATTRIBUTE_DIRECTORY
, smb_dname
, parent_dir
);
2764 status
= check_parent_access(conn
,
2767 if(!NT_STATUS_IS_OK(status
)) {
2768 DEBUG(5,("mkdir_internal: check_parent_access "
2769 "on directory %s for path %s returned %s\n",
2771 smb_dname
->base_name
,
2772 nt_errstr(status
) ));
2776 if (SMB_VFS_MKDIR(conn
, smb_dname
->base_name
, mode
) != 0) {
2777 return map_nt_error_from_unix(errno
);
2780 /* Ensure we're checking for a symlink here.... */
2781 /* We don't want to get caught by a symlink racer. */
2783 if (SMB_VFS_LSTAT(conn
, smb_dname
) == -1) {
2784 DEBUG(2, ("Could not stat directory '%s' just created: %s\n",
2785 smb_fname_str_dbg(smb_dname
), strerror(errno
)));
2786 return map_nt_error_from_unix(errno
);
2789 if (!S_ISDIR(smb_dname
->st
.st_ex_mode
)) {
2790 DEBUG(0, ("Directory '%s' just created is not a directory !\n",
2791 smb_fname_str_dbg(smb_dname
)));
2792 return NT_STATUS_NOT_A_DIRECTORY
;
2795 if (lp_store_dos_attributes(SNUM(conn
))) {
2797 file_set_dosmode(conn
, smb_dname
,
2798 file_attributes
| FILE_ATTRIBUTE_DIRECTORY
,
2803 if (lp_inherit_perms(SNUM(conn
))) {
2804 inherit_access_posix_acl(conn
, parent_dir
,
2805 smb_dname
->base_name
, mode
);
2806 need_re_stat
= true;
2811 * Check if high bits should have been set,
2812 * then (if bits are missing): add them.
2813 * Consider bits automagically set by UNIX, i.e. SGID bit from parent
2816 if ((mode
& ~(S_IRWXU
|S_IRWXG
|S_IRWXO
)) &&
2817 (mode
& ~smb_dname
->st
.st_ex_mode
)) {
2818 SMB_VFS_CHMOD(conn
, smb_dname
->base_name
,
2819 (smb_dname
->st
.st_ex_mode
|
2820 (mode
& ~smb_dname
->st
.st_ex_mode
)));
2821 need_re_stat
= true;
2825 /* Change the owner if required. */
2826 if (lp_inherit_owner(SNUM(conn
))) {
2827 change_dir_owner_to_parent(conn
, parent_dir
,
2828 smb_dname
->base_name
,
2830 need_re_stat
= true;
2834 if (SMB_VFS_LSTAT(conn
, smb_dname
) == -1) {
2835 DEBUG(2, ("Could not stat directory '%s' just created: %s\n",
2836 smb_fname_str_dbg(smb_dname
), strerror(errno
)));
2837 return map_nt_error_from_unix(errno
);
2841 notify_fname(conn
, NOTIFY_ACTION_ADDED
, FILE_NOTIFY_CHANGE_DIR_NAME
,
2842 smb_dname
->base_name
);
2844 return NT_STATUS_OK
;
2847 /****************************************************************************
2848 Open a directory from an NT SMB call.
2849 ****************************************************************************/
2851 static NTSTATUS
open_directory(connection_struct
*conn
,
2852 struct smb_request
*req
,
2853 struct smb_filename
*smb_dname
,
2855 uint32 share_access
,
2856 uint32 create_disposition
,
2857 uint32 create_options
,
2858 uint32 file_attributes
,
2860 files_struct
**result
)
2862 files_struct
*fsp
= NULL
;
2863 bool dir_existed
= VALID_STAT(smb_dname
->st
) ? True
: False
;
2864 struct share_mode_lock
*lck
= NULL
;
2866 struct timespec mtimespec
;
2869 if (is_ntfs_stream_smb_fname(smb_dname
)) {
2870 DEBUG(2, ("open_directory: %s is a stream name!\n",
2871 smb_fname_str_dbg(smb_dname
)));
2872 return NT_STATUS_NOT_A_DIRECTORY
;
2875 if (!(file_attributes
& FILE_FLAG_POSIX_SEMANTICS
)) {
2876 /* Ensure we have a directory attribute. */
2877 file_attributes
|= FILE_ATTRIBUTE_DIRECTORY
;
2880 DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
2881 "share_access = 0x%x create_options = 0x%x, "
2882 "create_disposition = 0x%x, file_attributes = 0x%x\n",
2883 smb_fname_str_dbg(smb_dname
),
2884 (unsigned int)access_mask
,
2885 (unsigned int)share_access
,
2886 (unsigned int)create_options
,
2887 (unsigned int)create_disposition
,
2888 (unsigned int)file_attributes
));
2890 status
= smbd_calculate_access_mask(conn
, smb_dname
,
2891 access_mask
, &access_mask
);
2892 if (!NT_STATUS_IS_OK(status
)) {
2893 DEBUG(10, ("open_directory: smbd_calculate_access_mask "
2894 "on file %s returned %s\n",
2895 smb_fname_str_dbg(smb_dname
),
2896 nt_errstr(status
)));
2900 if ((access_mask
& SEC_FLAG_SYSTEM_SECURITY
) &&
2901 !security_token_has_privilege(get_current_nttok(conn
),
2902 SEC_PRIV_SECURITY
)) {
2903 DEBUG(10, ("open_directory: open on %s "
2904 "failed - SEC_FLAG_SYSTEM_SECURITY denied.\n",
2905 smb_fname_str_dbg(smb_dname
)));
2906 return NT_STATUS_PRIVILEGE_NOT_HELD
;
2909 switch( create_disposition
) {
2913 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
2916 info
= FILE_WAS_OPENED
;
2921 /* If directory exists error. If directory doesn't
2925 status
= NT_STATUS_OBJECT_NAME_COLLISION
;
2926 DEBUG(2, ("open_directory: unable to create "
2927 "%s. Error was %s\n",
2928 smb_fname_str_dbg(smb_dname
),
2929 nt_errstr(status
)));
2933 status
= mkdir_internal(conn
, smb_dname
,
2936 if (!NT_STATUS_IS_OK(status
)) {
2937 DEBUG(2, ("open_directory: unable to create "
2938 "%s. Error was %s\n",
2939 smb_fname_str_dbg(smb_dname
),
2940 nt_errstr(status
)));
2944 info
= FILE_WAS_CREATED
;
2949 * If directory exists open. If directory doesn't
2954 status
= NT_STATUS_OK
;
2955 info
= FILE_WAS_OPENED
;
2957 status
= mkdir_internal(conn
, smb_dname
,
2960 if (NT_STATUS_IS_OK(status
)) {
2961 info
= FILE_WAS_CREATED
;
2963 /* Cope with create race. */
2964 if (!NT_STATUS_EQUAL(status
,
2965 NT_STATUS_OBJECT_NAME_COLLISION
)) {
2966 DEBUG(2, ("open_directory: unable to create "
2967 "%s. Error was %s\n",
2968 smb_fname_str_dbg(smb_dname
),
2969 nt_errstr(status
)));
2972 info
= FILE_WAS_OPENED
;
2978 case FILE_SUPERSEDE
:
2979 case FILE_OVERWRITE
:
2980 case FILE_OVERWRITE_IF
:
2982 DEBUG(5,("open_directory: invalid create_disposition "
2983 "0x%x for directory %s\n",
2984 (unsigned int)create_disposition
,
2985 smb_fname_str_dbg(smb_dname
)));
2986 return NT_STATUS_INVALID_PARAMETER
;
2989 if(!S_ISDIR(smb_dname
->st
.st_ex_mode
)) {
2990 DEBUG(5,("open_directory: %s is not a directory !\n",
2991 smb_fname_str_dbg(smb_dname
)));
2992 return NT_STATUS_NOT_A_DIRECTORY
;
2995 if (info
== FILE_WAS_OPENED
) {
2996 status
= smbd_check_access_rights(conn
, smb_dname
, access_mask
);
2997 if (!NT_STATUS_IS_OK(status
)) {
2998 DEBUG(10, ("open_directory: smbd_check_access_rights on "
2999 "file %s failed with %s\n",
3000 smb_fname_str_dbg(smb_dname
),
3001 nt_errstr(status
)));
3006 status
= file_new(req
, conn
, &fsp
);
3007 if(!NT_STATUS_IS_OK(status
)) {
3012 * Setup the files_struct for it.
3015 fsp
->file_id
= vfs_file_id_from_sbuf(conn
, &smb_dname
->st
);
3016 fsp
->vuid
= req
? req
->vuid
: UID_FIELD_INVALID
;
3017 fsp
->file_pid
= req
? req
->smbpid
: 0;
3018 fsp
->can_lock
= False
;
3019 fsp
->can_read
= False
;
3020 fsp
->can_write
= False
;
3022 fsp
->share_access
= share_access
;
3023 fsp
->fh
->private_options
= 0;
3025 * According to Samba4, SEC_FILE_READ_ATTRIBUTE is always granted,
3027 fsp
->access_mask
= access_mask
| FILE_READ_ATTRIBUTES
;
3028 fsp
->print_file
= NULL
;
3029 fsp
->modified
= False
;
3030 fsp
->oplock_type
= NO_OPLOCK
;
3031 fsp
->sent_oplock_break
= NO_BREAK_SENT
;
3032 fsp
->is_directory
= True
;
3033 fsp
->posix_open
= (file_attributes
& FILE_FLAG_POSIX_SEMANTICS
) ? True
: False
;
3034 status
= fsp_set_smb_fname(fsp
, smb_dname
);
3035 if (!NT_STATUS_IS_OK(status
)) {
3036 file_free(req
, fsp
);
3040 mtimespec
= smb_dname
->st
.st_ex_mtime
;
3043 status
= fd_open(conn
, fsp
, O_RDONLY
|O_DIRECTORY
, 0);
3045 /* POSIX allows us to open a directory with O_RDONLY. */
3046 status
= fd_open(conn
, fsp
, O_RDONLY
, 0);
3048 if (!NT_STATUS_IS_OK(status
)) {
3049 DEBUG(5, ("open_directory: Could not open fd for "
3051 smb_fname_str_dbg(smb_dname
),
3052 nt_errstr(status
)));
3053 file_free(req
, fsp
);
3057 status
= vfs_stat_fsp(fsp
);
3058 if (!NT_STATUS_IS_OK(status
)) {
3060 file_free(req
, fsp
);
3064 /* Ensure there was no race condition. */
3065 if (!check_same_stat(&smb_dname
->st
, &fsp
->fsp_name
->st
)) {
3066 DEBUG(5,("open_directory: stat struct differs for "
3068 smb_fname_str_dbg(smb_dname
)));
3070 file_free(req
, fsp
);
3071 return NT_STATUS_ACCESS_DENIED
;
3074 lck
= get_share_mode_lock(talloc_tos(), fsp
->file_id
,
3075 conn
->connectpath
, smb_dname
,
3079 DEBUG(0, ("open_directory: Could not get share mode lock for "
3080 "%s\n", smb_fname_str_dbg(smb_dname
)));
3082 file_free(req
, fsp
);
3083 return NT_STATUS_SHARING_VIOLATION
;
3086 status
= open_mode_check(conn
, lck
, fsp
->name_hash
,
3087 access_mask
, share_access
,
3088 create_options
, &dir_existed
);
3090 if (!NT_STATUS_IS_OK(status
)) {
3093 file_free(req
, fsp
);
3097 set_share_mode(lck
, fsp
, get_current_uid(conn
),
3098 req
? req
->mid
: 0, NO_OPLOCK
);
3100 /* For directories the delete on close bit at open time seems
3101 always to be honored on close... See test 19 in Samba4 BASE-DELETE. */
3102 if (create_options
& FILE_DELETE_ON_CLOSE
) {
3103 status
= can_set_delete_on_close(fsp
, 0);
3104 if (!NT_STATUS_IS_OK(status
) && !NT_STATUS_EQUAL(status
, NT_STATUS_DIRECTORY_NOT_EMPTY
)) {
3107 file_free(req
, fsp
);
3111 if (NT_STATUS_IS_OK(status
)) {
3112 /* Note that here we set the *inital* delete on close flag,
3113 not the regular one. The magic gets handled in close. */
3114 fsp
->initial_delete_on_close
= True
;
3125 return NT_STATUS_OK
;
3128 NTSTATUS
create_directory(connection_struct
*conn
, struct smb_request
*req
,
3129 struct smb_filename
*smb_dname
)
3134 status
= SMB_VFS_CREATE_FILE(
3137 0, /* root_dir_fid */
3138 smb_dname
, /* fname */
3139 FILE_READ_ATTRIBUTES
, /* access_mask */
3140 FILE_SHARE_NONE
, /* share_access */
3141 FILE_CREATE
, /* create_disposition*/
3142 FILE_DIRECTORY_FILE
, /* create_options */
3143 FILE_ATTRIBUTE_DIRECTORY
, /* file_attributes */
3144 0, /* oplock_request */
3145 0, /* allocation_size */
3146 0, /* private_flags */
3152 if (NT_STATUS_IS_OK(status
)) {
3153 close_file(req
, fsp
, NORMAL_CLOSE
);
3159 /****************************************************************************
3160 Receive notification that one of our open files has been renamed by another
3162 ****************************************************************************/
3164 void msg_file_was_renamed(struct messaging_context
*msg
,
3167 struct server_id server_id
,
3171 char *frm
= (char *)data
->data
;
3173 const char *sharepath
;
3174 const char *base_name
;
3175 const char *stream_name
;
3176 struct smb_filename
*smb_fname
= NULL
;
3177 size_t sp_len
, bn_len
;
3179 struct smbd_server_connection
*sconn
=
3180 talloc_get_type_abort(private_data
,
3181 struct smbd_server_connection
);
3183 if (data
->data
== NULL
3184 || data
->length
< MSG_FILE_RENAMED_MIN_SIZE
+ 2) {
3185 DEBUG(0, ("msg_file_was_renamed: Got invalid msg len %d\n",
3186 (int)data
->length
));
3190 /* Unpack the message. */
3191 pull_file_id_24(frm
, &id
);
3192 sharepath
= &frm
[24];
3193 sp_len
= strlen(sharepath
);
3194 base_name
= sharepath
+ sp_len
+ 1;
3195 bn_len
= strlen(base_name
);
3196 stream_name
= sharepath
+ sp_len
+ 1 + bn_len
+ 1;
3198 /* stream_name must always be NULL if there is no stream. */
3199 if (stream_name
[0] == '\0') {
3203 status
= create_synthetic_smb_fname(talloc_tos(), base_name
,
3204 stream_name
, NULL
, &smb_fname
);
3205 if (!NT_STATUS_IS_OK(status
)) {
3209 DEBUG(10,("msg_file_was_renamed: Got rename message for sharepath %s, new name %s, "
3211 sharepath
, smb_fname_str_dbg(smb_fname
),
3212 file_id_string_tos(&id
)));
3214 for(fsp
= file_find_di_first(sconn
, id
); fsp
;
3215 fsp
= file_find_di_next(fsp
)) {
3216 if (memcmp(fsp
->conn
->connectpath
, sharepath
, sp_len
) == 0) {
3218 DEBUG(10,("msg_file_was_renamed: renaming file %s from %s -> %s\n",
3219 fsp_fnum_dbg(fsp
), fsp_str_dbg(fsp
),
3220 smb_fname_str_dbg(smb_fname
)));
3221 status
= fsp_set_smb_fname(fsp
, smb_fname
);
3222 if (!NT_STATUS_IS_OK(status
)) {
3227 /* Now we have the complete path we can work out if this is
3228 actually within this share and adjust newname accordingly. */
3229 DEBUG(10,("msg_file_was_renamed: share mismatch (sharepath %s "
3230 "not sharepath %s) "
3231 "%s from %s -> %s\n",
3232 fsp
->conn
->connectpath
,
3236 smb_fname_str_dbg(smb_fname
)));
3240 TALLOC_FREE(smb_fname
);
3245 * If a main file is opened for delete, all streams need to be checked for
3246 * !FILE_SHARE_DELETE. Do this by opening with DELETE_ACCESS.
3247 * If that works, delete them all by setting the delete on close and close.
3250 NTSTATUS
open_streams_for_delete(connection_struct
*conn
,
3253 struct stream_struct
*stream_info
= NULL
;
3254 files_struct
**streams
= NULL
;
3256 unsigned int num_streams
= 0;
3257 TALLOC_CTX
*frame
= talloc_stackframe();
3260 status
= vfs_streaminfo(conn
, NULL
, fname
, talloc_tos(),
3261 &num_streams
, &stream_info
);
3263 if (NT_STATUS_EQUAL(status
, NT_STATUS_NOT_IMPLEMENTED
)
3264 || NT_STATUS_EQUAL(status
, NT_STATUS_OBJECT_NAME_NOT_FOUND
)) {
3265 DEBUG(10, ("no streams around\n"));
3267 return NT_STATUS_OK
;
3270 if (!NT_STATUS_IS_OK(status
)) {
3271 DEBUG(10, ("vfs_streaminfo failed: %s\n",
3272 nt_errstr(status
)));
3276 DEBUG(10, ("open_streams_for_delete found %d streams\n",
3279 if (num_streams
== 0) {
3281 return NT_STATUS_OK
;
3284 streams
= talloc_array(talloc_tos(), files_struct
*, num_streams
);
3285 if (streams
== NULL
) {
3286 DEBUG(0, ("talloc failed\n"));
3287 status
= NT_STATUS_NO_MEMORY
;
3291 for (i
=0; i
<num_streams
; i
++) {
3292 struct smb_filename
*smb_fname
= NULL
;
3294 if (strequal(stream_info
[i
].name
, "::$DATA")) {
3299 status
= create_synthetic_smb_fname(talloc_tos(), fname
,
3300 stream_info
[i
].name
,
3302 if (!NT_STATUS_IS_OK(status
)) {
3306 if (SMB_VFS_STAT(conn
, smb_fname
) == -1) {
3307 DEBUG(10, ("Unable to stat stream: %s\n",
3308 smb_fname_str_dbg(smb_fname
)));
3311 status
= SMB_VFS_CREATE_FILE(
3314 0, /* root_dir_fid */
3315 smb_fname
, /* fname */
3316 DELETE_ACCESS
, /* access_mask */
3317 (FILE_SHARE_READ
| /* share_access */
3318 FILE_SHARE_WRITE
| FILE_SHARE_DELETE
),
3319 FILE_OPEN
, /* create_disposition*/
3320 0, /* create_options */
3321 FILE_ATTRIBUTE_NORMAL
, /* file_attributes */
3322 0, /* oplock_request */
3323 0, /* allocation_size */
3324 NTCREATEX_OPTIONS_PRIVATE_STREAM_DELETE
, /* private_flags */
3327 &streams
[i
], /* result */
3330 if (!NT_STATUS_IS_OK(status
)) {
3331 DEBUG(10, ("Could not open stream %s: %s\n",
3332 smb_fname_str_dbg(smb_fname
),
3333 nt_errstr(status
)));
3335 TALLOC_FREE(smb_fname
);
3338 TALLOC_FREE(smb_fname
);
3342 * don't touch the variable "status" beyond this point :-)
3345 for (i
-= 1 ; i
>= 0; i
--) {
3346 if (streams
[i
] == NULL
) {
3350 DEBUG(10, ("Closing stream # %d, %s\n", i
,
3351 fsp_str_dbg(streams
[i
])));
3352 close_file(NULL
, streams
[i
], NORMAL_CLOSE
);
3360 /*********************************************************************
3361 Create a default ACL by inheriting from the parent. If no inheritance
3362 from the parent available, don't set anything. This will leave the actual
3363 permissions the new file or directory already got from the filesystem
3364 as the NT ACL when read.
3365 *********************************************************************/
3367 static NTSTATUS
inherit_new_acl(files_struct
*fsp
)
3369 TALLOC_CTX
*ctx
= talloc_tos();
3370 char *parent_name
= NULL
;
3371 struct security_descriptor
*parent_desc
= NULL
;
3372 NTSTATUS status
= NT_STATUS_OK
;
3373 struct security_descriptor
*psd
= NULL
;
3374 struct dom_sid
*owner_sid
= NULL
;
3375 struct dom_sid
*group_sid
= NULL
;
3376 uint32_t security_info_sent
= (SECINFO_OWNER
| SECINFO_GROUP
| SECINFO_DACL
);
3377 bool inherit_owner
= lp_inherit_owner(SNUM(fsp
->conn
));
3378 bool inheritable_components
= false;
3381 if (!parent_dirname(ctx
, fsp
->fsp_name
->base_name
, &parent_name
, NULL
)) {
3382 return NT_STATUS_NO_MEMORY
;
3385 status
= SMB_VFS_GET_NT_ACL(fsp
->conn
,
3387 (SECINFO_OWNER
| SECINFO_GROUP
| SECINFO_DACL
),
3389 if (!NT_STATUS_IS_OK(status
)) {
3393 inheritable_components
= sd_has_inheritable_components(parent_desc
,
3396 if (!inheritable_components
&& !inherit_owner
) {
3397 /* Nothing to inherit and not setting owner. */
3398 return NT_STATUS_OK
;
3401 /* Create an inherited descriptor from the parent. */
3403 if (DEBUGLEVEL
>= 10) {
3404 DEBUG(10,("inherit_new_acl: parent acl for %s is:\n",
3405 fsp_str_dbg(fsp
) ));
3406 NDR_PRINT_DEBUG(security_descriptor
, parent_desc
);
3409 /* Inherit from parent descriptor if "inherit owner" set. */
3410 if (inherit_owner
) {
3411 owner_sid
= parent_desc
->owner_sid
;
3412 group_sid
= parent_desc
->group_sid
;
3415 if (owner_sid
== NULL
) {
3416 owner_sid
= &fsp
->conn
->session_info
->security_token
->sids
[PRIMARY_USER_SID_INDEX
];
3418 if (group_sid
== NULL
) {
3419 group_sid
= &fsp
->conn
->session_info
->security_token
->sids
[PRIMARY_GROUP_SID_INDEX
];
3422 status
= se_create_child_secdesc(ctx
,
3429 if (!NT_STATUS_IS_OK(status
)) {
3433 /* If inheritable_components == false,
3434 se_create_child_secdesc()
3435 creates a security desriptor with a NULL dacl
3436 entry, but with SEC_DESC_DACL_PRESENT. We need
3437 to remove that flag. */
3439 if (!inheritable_components
) {
3440 security_info_sent
&= ~SECINFO_DACL
;
3441 psd
->type
&= ~SEC_DESC_DACL_PRESENT
;
3444 if (DEBUGLEVEL
>= 10) {
3445 DEBUG(10,("inherit_new_acl: child acl for %s is:\n",
3446 fsp_str_dbg(fsp
) ));
3447 NDR_PRINT_DEBUG(security_descriptor
, psd
);
3450 if (inherit_owner
) {
3451 /* We need to be root to force this. */
3454 status
= SMB_VFS_FSET_NT_ACL(fsp
,
3457 if (inherit_owner
) {
3464 * Wrapper around open_file_ntcreate and open_directory
3467 static NTSTATUS
create_file_unixpath(connection_struct
*conn
,
3468 struct smb_request
*req
,
3469 struct smb_filename
*smb_fname
,
3470 uint32_t access_mask
,
3471 uint32_t share_access
,
3472 uint32_t create_disposition
,
3473 uint32_t create_options
,
3474 uint32_t file_attributes
,
3475 uint32_t oplock_request
,
3476 uint64_t allocation_size
,
3477 uint32_t private_flags
,
3478 struct security_descriptor
*sd
,
3479 struct ea_list
*ea_list
,
3481 files_struct
**result
,
3484 int info
= FILE_WAS_OPENED
;
3485 files_struct
*base_fsp
= NULL
;
3486 files_struct
*fsp
= NULL
;
3489 DEBUG(10,("create_file_unixpath: access_mask = 0x%x "
3490 "file_attributes = 0x%x, share_access = 0x%x, "
3491 "create_disposition = 0x%x create_options = 0x%x "
3492 "oplock_request = 0x%x private_flags = 0x%x "
3493 "ea_list = 0x%p, sd = 0x%p, "
3495 (unsigned int)access_mask
,
3496 (unsigned int)file_attributes
,
3497 (unsigned int)share_access
,
3498 (unsigned int)create_disposition
,
3499 (unsigned int)create_options
,
3500 (unsigned int)oplock_request
,
3501 (unsigned int)private_flags
,
3502 ea_list
, sd
, smb_fname_str_dbg(smb_fname
)));
3504 if (create_options
& FILE_OPEN_BY_FILE_ID
) {
3505 status
= NT_STATUS_NOT_SUPPORTED
;
3509 if (create_options
& NTCREATEX_OPTIONS_INVALID_PARAM_MASK
) {
3510 status
= NT_STATUS_INVALID_PARAMETER
;
3515 oplock_request
|= INTERNAL_OPEN_ONLY
;
3518 if ((conn
->fs_capabilities
& FILE_NAMED_STREAMS
)
3519 && (access_mask
& DELETE_ACCESS
)
3520 && !is_ntfs_stream_smb_fname(smb_fname
)) {
3522 * We can't open a file with DELETE access if any of the
3523 * streams is open without FILE_SHARE_DELETE
3525 status
= open_streams_for_delete(conn
, smb_fname
->base_name
);
3527 if (!NT_STATUS_IS_OK(status
)) {
3532 if ((access_mask
& SEC_FLAG_SYSTEM_SECURITY
) &&
3533 !security_token_has_privilege(get_current_nttok(conn
),
3534 SEC_PRIV_SECURITY
)) {
3535 DEBUG(10, ("create_file_unixpath: open on %s "
3536 "failed - SEC_FLAG_SYSTEM_SECURITY denied.\n",
3537 smb_fname_str_dbg(smb_fname
)));
3538 status
= NT_STATUS_PRIVILEGE_NOT_HELD
;
3542 if ((conn
->fs_capabilities
& FILE_NAMED_STREAMS
)
3543 && is_ntfs_stream_smb_fname(smb_fname
)
3544 && (!(private_flags
& NTCREATEX_OPTIONS_PRIVATE_STREAM_DELETE
))) {
3545 uint32 base_create_disposition
;
3546 struct smb_filename
*smb_fname_base
= NULL
;
3548 if (create_options
& FILE_DIRECTORY_FILE
) {
3549 status
= NT_STATUS_NOT_A_DIRECTORY
;
3553 switch (create_disposition
) {
3555 base_create_disposition
= FILE_OPEN
;
3558 base_create_disposition
= FILE_OPEN_IF
;
3562 /* Create an smb_filename with stream_name == NULL. */
3563 status
= create_synthetic_smb_fname(talloc_tos(),
3564 smb_fname
->base_name
,
3567 if (!NT_STATUS_IS_OK(status
)) {
3571 if (SMB_VFS_STAT(conn
, smb_fname_base
) == -1) {
3572 DEBUG(10, ("Unable to stat stream: %s\n",
3573 smb_fname_str_dbg(smb_fname_base
)));
3576 /* Open the base file. */
3577 status
= create_file_unixpath(conn
, NULL
, smb_fname_base
, 0,
3580 | FILE_SHARE_DELETE
,
3581 base_create_disposition
,
3582 0, 0, 0, 0, 0, NULL
, NULL
,
3584 TALLOC_FREE(smb_fname_base
);
3586 if (!NT_STATUS_IS_OK(status
)) {
3587 DEBUG(10, ("create_file_unixpath for base %s failed: "
3588 "%s\n", smb_fname
->base_name
,
3589 nt_errstr(status
)));
3592 /* we don't need to low level fd */
3597 * If it's a request for a directory open, deal with it separately.
3600 if (create_options
& FILE_DIRECTORY_FILE
) {
3602 if (create_options
& FILE_NON_DIRECTORY_FILE
) {
3603 status
= NT_STATUS_INVALID_PARAMETER
;
3607 /* Can't open a temp directory. IFS kit test. */
3608 if (!(file_attributes
& FILE_FLAG_POSIX_SEMANTICS
) &&
3609 (file_attributes
& FILE_ATTRIBUTE_TEMPORARY
)) {
3610 status
= NT_STATUS_INVALID_PARAMETER
;
3615 * We will get a create directory here if the Win32
3616 * app specified a security descriptor in the
3617 * CreateDirectory() call.
3621 status
= open_directory(
3622 conn
, req
, smb_fname
, access_mask
, share_access
,
3623 create_disposition
, create_options
, file_attributes
,
3628 * Ordinary file case.
3631 status
= file_new(req
, conn
, &fsp
);
3632 if(!NT_STATUS_IS_OK(status
)) {
3636 status
= fsp_set_smb_fname(fsp
, smb_fname
);
3637 if (!NT_STATUS_IS_OK(status
)) {
3642 * We're opening the stream element of a base_fsp
3643 * we already opened. Set up the base_fsp pointer.
3646 fsp
->base_fsp
= base_fsp
;
3649 if (allocation_size
) {
3650 fsp
->initial_allocation_size
= smb_roundup(fsp
->conn
,
3654 status
= open_file_ntcreate(conn
,
3666 if(!NT_STATUS_IS_OK(status
)) {
3667 file_free(req
, fsp
);
3671 if (NT_STATUS_EQUAL(status
, NT_STATUS_FILE_IS_A_DIRECTORY
)) {
3673 /* A stream open never opens a directory */
3676 status
= NT_STATUS_FILE_IS_A_DIRECTORY
;
3681 * Fail the open if it was explicitly a non-directory
3685 if (create_options
& FILE_NON_DIRECTORY_FILE
) {
3686 status
= NT_STATUS_FILE_IS_A_DIRECTORY
;
3691 status
= open_directory(
3692 conn
, req
, smb_fname
, access_mask
,
3693 share_access
, create_disposition
,
3694 create_options
, file_attributes
,
3699 if (!NT_STATUS_IS_OK(status
)) {
3703 fsp
->base_fsp
= base_fsp
;
3705 if ((ea_list
!= NULL
) &&
3706 ((info
== FILE_WAS_CREATED
) || (info
== FILE_WAS_OVERWRITTEN
))) {
3707 status
= set_ea(conn
, fsp
, fsp
->fsp_name
, ea_list
);
3708 if (!NT_STATUS_IS_OK(status
)) {
3713 if (!fsp
->is_directory
&& S_ISDIR(fsp
->fsp_name
->st
.st_ex_mode
)) {
3714 status
= NT_STATUS_ACCESS_DENIED
;
3718 /* Save the requested allocation size. */
3719 if ((info
== FILE_WAS_CREATED
) || (info
== FILE_WAS_OVERWRITTEN
)) {
3721 && (allocation_size
> fsp
->fsp_name
->st
.st_ex_size
)) {
3722 fsp
->initial_allocation_size
= smb_roundup(
3723 fsp
->conn
, allocation_size
);
3724 if (fsp
->is_directory
) {
3725 /* Can't set allocation size on a directory. */
3726 status
= NT_STATUS_ACCESS_DENIED
;
3729 if (vfs_allocate_file_space(
3730 fsp
, fsp
->initial_allocation_size
) == -1) {
3731 status
= NT_STATUS_DISK_FULL
;
3735 fsp
->initial_allocation_size
= smb_roundup(
3736 fsp
->conn
, (uint64_t)fsp
->fsp_name
->st
.st_ex_size
);
3739 fsp
->initial_allocation_size
= 0;
3742 if ((info
== FILE_WAS_CREATED
) && lp_nt_acl_support(SNUM(conn
)) &&
3743 fsp
->base_fsp
== NULL
) {
3746 * According to the MS documentation, the only time the security
3747 * descriptor is applied to the opened file is iff we *created* the
3748 * file; an existing file stays the same.
3750 * Also, it seems (from observation) that you can open the file with
3751 * any access mask but you can still write the sd. We need to override
3752 * the granted access before we call set_sd
3753 * Patch for bug #2242 from Tom Lackemann <cessnatomny@yahoo.com>.
3756 uint32_t sec_info_sent
;
3757 uint32_t saved_access_mask
= fsp
->access_mask
;
3759 sec_info_sent
= get_sec_info(sd
);
3761 fsp
->access_mask
= FILE_GENERIC_ALL
;
3763 if (sec_info_sent
& (SECINFO_OWNER
|
3767 status
= set_sd(fsp
, sd
, sec_info_sent
);
3770 fsp
->access_mask
= saved_access_mask
;
3772 if (!NT_STATUS_IS_OK(status
)) {
3775 } else if (lp_inherit_acls(SNUM(conn
))) {
3776 /* Inherit from parent. Errors here are not fatal. */
3777 status
= inherit_new_acl(fsp
);
3778 if (!NT_STATUS_IS_OK(status
)) {
3779 DEBUG(10,("inherit_new_acl: failed for %s with %s\n",
3781 nt_errstr(status
) ));
3786 DEBUG(10, ("create_file_unixpath: info=%d\n", info
));
3789 if (pinfo
!= NULL
) {
3793 smb_fname
->st
= fsp
->fsp_name
->st
;
3795 return NT_STATUS_OK
;
3798 DEBUG(10, ("create_file_unixpath: %s\n", nt_errstr(status
)));
3801 if (base_fsp
&& fsp
->base_fsp
== base_fsp
) {
3803 * The close_file below will close
3808 close_file(req
, fsp
, ERROR_CLOSE
);
3811 if (base_fsp
!= NULL
) {
3812 close_file(req
, base_fsp
, ERROR_CLOSE
);
3819 * Calculate the full path name given a relative fid.
3821 NTSTATUS
get_relative_fid_filename(connection_struct
*conn
,
3822 struct smb_request
*req
,
3823 uint16_t root_dir_fid
,
3824 const struct smb_filename
*smb_fname
,
3825 struct smb_filename
**smb_fname_out
)
3827 files_struct
*dir_fsp
;
3828 char *parent_fname
= NULL
;
3829 char *new_base_name
= NULL
;
3832 if (root_dir_fid
== 0 || !smb_fname
) {
3833 status
= NT_STATUS_INTERNAL_ERROR
;
3837 dir_fsp
= file_fsp(req
, root_dir_fid
);
3839 if (dir_fsp
== NULL
) {
3840 status
= NT_STATUS_INVALID_HANDLE
;
3844 if (is_ntfs_stream_smb_fname(dir_fsp
->fsp_name
)) {
3845 status
= NT_STATUS_INVALID_HANDLE
;
3849 if (!dir_fsp
->is_directory
) {
3852 * Check to see if this is a mac fork of some kind.
3855 if ((conn
->fs_capabilities
& FILE_NAMED_STREAMS
) &&
3856 is_ntfs_stream_smb_fname(smb_fname
)) {
3857 status
= NT_STATUS_OBJECT_PATH_NOT_FOUND
;
3862 we need to handle the case when we get a
3863 relative open relative to a file and the
3864 pathname is blank - this is a reopen!
3865 (hint from demyn plantenberg)
3868 status
= NT_STATUS_INVALID_HANDLE
;
3872 if (ISDOT(dir_fsp
->fsp_name
->base_name
)) {
3874 * We're at the toplevel dir, the final file name
3875 * must not contain ./, as this is filtered out
3876 * normally by srvstr_get_path and unix_convert
3877 * explicitly rejects paths containing ./.
3879 parent_fname
= talloc_strdup(talloc_tos(), "");
3880 if (parent_fname
== NULL
) {
3881 status
= NT_STATUS_NO_MEMORY
;
3885 size_t dir_name_len
= strlen(dir_fsp
->fsp_name
->base_name
);
3888 * Copy in the base directory name.
3891 parent_fname
= talloc_array(talloc_tos(), char,
3893 if (parent_fname
== NULL
) {
3894 status
= NT_STATUS_NO_MEMORY
;
3897 memcpy(parent_fname
, dir_fsp
->fsp_name
->base_name
,
3901 * Ensure it ends in a '/'.
3902 * We used TALLOC_SIZE +2 to add space for the '/'.
3906 && (parent_fname
[dir_name_len
-1] != '\\')
3907 && (parent_fname
[dir_name_len
-1] != '/')) {
3908 parent_fname
[dir_name_len
] = '/';
3909 parent_fname
[dir_name_len
+1] = '\0';
3913 new_base_name
= talloc_asprintf(talloc_tos(), "%s%s", parent_fname
,
3914 smb_fname
->base_name
);
3915 if (new_base_name
== NULL
) {
3916 status
= NT_STATUS_NO_MEMORY
;
3920 status
= filename_convert(req
,
3922 req
->flags2
& FLAGS2_DFS_PATHNAMES
,
3927 if (!NT_STATUS_IS_OK(status
)) {
3932 TALLOC_FREE(parent_fname
);
3933 TALLOC_FREE(new_base_name
);
3937 NTSTATUS
create_file_default(connection_struct
*conn
,
3938 struct smb_request
*req
,
3939 uint16_t root_dir_fid
,
3940 struct smb_filename
*smb_fname
,
3941 uint32_t access_mask
,
3942 uint32_t share_access
,
3943 uint32_t create_disposition
,
3944 uint32_t create_options
,
3945 uint32_t file_attributes
,
3946 uint32_t oplock_request
,
3947 uint64_t allocation_size
,
3948 uint32_t private_flags
,
3949 struct security_descriptor
*sd
,
3950 struct ea_list
*ea_list
,
3951 files_struct
**result
,
3954 int info
= FILE_WAS_OPENED
;
3955 files_struct
*fsp
= NULL
;
3957 bool stream_name
= false;
3959 DEBUG(10,("create_file: access_mask = 0x%x "
3960 "file_attributes = 0x%x, share_access = 0x%x, "
3961 "create_disposition = 0x%x create_options = 0x%x "
3962 "oplock_request = 0x%x "
3963 "private_flags = 0x%x "
3964 "root_dir_fid = 0x%x, ea_list = 0x%p, sd = 0x%p, "
3966 (unsigned int)access_mask
,
3967 (unsigned int)file_attributes
,
3968 (unsigned int)share_access
,
3969 (unsigned int)create_disposition
,
3970 (unsigned int)create_options
,
3971 (unsigned int)oplock_request
,
3972 (unsigned int)private_flags
,
3973 (unsigned int)root_dir_fid
,
3974 ea_list
, sd
, smb_fname_str_dbg(smb_fname
)));
3977 * Calculate the filename from the root_dir_if if necessary.
3980 if (root_dir_fid
!= 0) {
3981 struct smb_filename
*smb_fname_out
= NULL
;
3982 status
= get_relative_fid_filename(conn
, req
, root_dir_fid
,
3983 smb_fname
, &smb_fname_out
);
3984 if (!NT_STATUS_IS_OK(status
)) {
3987 smb_fname
= smb_fname_out
;
3991 * Check to see if this is a mac fork of some kind.
3994 stream_name
= is_ntfs_stream_smb_fname(smb_fname
);
3996 enum FAKE_FILE_TYPE fake_file_type
;
3998 fake_file_type
= is_fake_file(smb_fname
);
4000 if (fake_file_type
!= FAKE_FILE_TYPE_NONE
) {
4003 * Here we go! support for changing the disk quotas
4006 * We need to fake up to open this MAGIC QUOTA file
4007 * and return a valid FID.
4009 * w2k close this file directly after openening xp
4010 * also tries a QUERY_FILE_INFO on the file and then
4013 status
= open_fake_file(req
, conn
, req
->vuid
,
4014 fake_file_type
, smb_fname
,
4016 if (!NT_STATUS_IS_OK(status
)) {
4020 ZERO_STRUCT(smb_fname
->st
);
4024 if (!(conn
->fs_capabilities
& FILE_NAMED_STREAMS
)) {
4025 status
= NT_STATUS_OBJECT_NAME_NOT_FOUND
;
4030 if (is_ntfs_default_stream_smb_fname(smb_fname
)) {
4032 smb_fname
->stream_name
= NULL
;
4033 /* We have to handle this error here. */
4034 if (create_options
& FILE_DIRECTORY_FILE
) {
4035 status
= NT_STATUS_NOT_A_DIRECTORY
;
4038 if (lp_posix_pathnames()) {
4039 ret
= SMB_VFS_LSTAT(conn
, smb_fname
);
4041 ret
= SMB_VFS_STAT(conn
, smb_fname
);
4044 if (ret
== 0 && VALID_STAT_OF_DIR(smb_fname
->st
)) {
4045 status
= NT_STATUS_FILE_IS_A_DIRECTORY
;
4050 status
= create_file_unixpath(
4051 conn
, req
, smb_fname
, access_mask
, share_access
,
4052 create_disposition
, create_options
, file_attributes
,
4053 oplock_request
, allocation_size
, private_flags
,
4057 if (!NT_STATUS_IS_OK(status
)) {
4062 DEBUG(10, ("create_file: info=%d\n", info
));
4065 if (pinfo
!= NULL
) {
4068 return NT_STATUS_OK
;
4071 DEBUG(10, ("create_file: %s\n", nt_errstr(status
)));
4074 close_file(req
, fsp
, ERROR_CLOSE
);