2
Unix SMB/CIFS implementation.
3
file opening and share modes
4
Copyright (C) Andrew Tridgell 1992-1998
5
Copyright (C) Jeremy Allison 2001-2004
6
Copyright (C) Volker Lendecke 2005
8
This program is free software; you can redistribute it and/or modify
9
it under the terms of the GNU General Public License as published by
10
the Free Software Foundation; either version 2 of the License, or
11
(at your option) any later version.
13
This program is distributed in the hope that it will be useful,
14
but WITHOUT ANY WARRANTY; without even the implied warranty of
15
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16
GNU General Public License for more details.
18
You should have received a copy of the GNU General Public License
19
along with this program; if not, write to the Free Software
20
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25
extern struct generic_mapping file_generic_mapping;
26
extern struct current_user current_user;
27
extern userdom_struct current_user_info;
28
extern uint16 global_smbpid;
29
extern BOOL global_client_failed_oplock_break;
31
struct deferred_open_record {
32
BOOL delayed_for_oplocks;
37
/****************************************************************************
38
fd support routines - attempt to do a dos_open.
39
****************************************************************************/
41
static BOOL fd_open(struct connection_struct *conn,
50
if (!lp_symlinks(SNUM(conn))) {
55
fsp->fh->fd = SMB_VFS_OPEN(conn,fname,fsp,flags,mode);
58
DEBUG(10,("fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s\n",
59
fname, flags, (int)mode, fsp->fh->fd,
60
(fsp->fh->fd == -1) ? strerror(errno) : "" ));
63
return fsp->fh->fd != -1;
66
/****************************************************************************
67
Close the file associated with a fsp.
68
****************************************************************************/
70
int fd_close(struct connection_struct *conn,
73
if (fsp->fh->fd == -1) {
74
return 0; /* What we used to call a stat open. */
76
if (fsp->fh->ref_count > 1) {
77
return 0; /* Shared handle. Only close last reference. */
79
return fd_close_posix(conn, fsp);
82
/****************************************************************************
83
Change the ownership of a file to that of the parent directory.
84
Do this by fd if possible.
85
****************************************************************************/
87
void change_owner_to_parent(connection_struct *conn,
90
SMB_STRUCT_STAT *psbuf)
92
const char *parent_path = parent_dirname(fname);
93
SMB_STRUCT_STAT parent_st;
96
ret = SMB_VFS_STAT(conn, parent_path, &parent_st);
98
DEBUG(0,("change_owner_to_parent: failed to stat parent "
99
"directory %s. Error was %s\n",
100
parent_path, strerror(errno) ));
104
if (fsp && fsp->fh->fd != -1) {
106
ret = SMB_VFS_FCHOWN(fsp, fsp->fh->fd, parent_st.st_uid, (gid_t)-1);
109
DEBUG(0,("change_owner_to_parent: failed to fchown "
110
"file %s to parent directory uid %u. Error "
112
(unsigned int)parent_st.st_uid,
116
DEBUG(10,("change_owner_to_parent: changed new file %s to "
117
"parent directory uid %u.\n", fname,
118
(unsigned int)parent_st.st_uid ));
121
/* We've already done an lstat into psbuf, and we know it's a
122
directory. If we can cd into the directory and the dev/ino
123
are the same then we can safely chown without races as
124
we're locking the directory in place by being in it. This
125
should work on any UNIX (thanks tridge :-). JRA.
129
SMB_STRUCT_STAT sbuf;
131
if (!vfs_GetWd(conn,saved_dir)) {
132
DEBUG(0,("change_owner_to_parent: failed to get "
133
"current working directory\n"));
137
/* Chdir into the new path. */
138
if (vfs_ChDir(conn, fname) == -1) {
139
DEBUG(0,("change_owner_to_parent: failed to change "
140
"current working directory to %s. Error "
141
"was %s\n", fname, strerror(errno) ));
145
if (SMB_VFS_STAT(conn,".",&sbuf) == -1) {
146
DEBUG(0,("change_owner_to_parent: failed to stat "
147
"directory '.' (%s) Error was %s\n",
148
fname, strerror(errno)));
152
/* Ensure we're pointing at the same place. */
153
if (sbuf.st_dev != psbuf->st_dev ||
154
sbuf.st_ino != psbuf->st_ino ||
155
sbuf.st_mode != psbuf->st_mode ) {
156
DEBUG(0,("change_owner_to_parent: "
157
"device/inode/mode on directory %s changed. "
158
"Refusing to chown !\n", fname ));
163
ret = SMB_VFS_CHOWN(conn, ".", parent_st.st_uid, (gid_t)-1);
166
DEBUG(10,("change_owner_to_parent: failed to chown "
167
"directory %s to parent directory uid %u. "
168
"Error was %s\n", fname,
169
(unsigned int)parent_st.st_uid, strerror(errno) ));
173
DEBUG(10,("change_owner_to_parent: changed ownership of new "
174
"directory %s to parent directory uid %u.\n",
175
fname, (unsigned int)parent_st.st_uid ));
179
vfs_ChDir(conn,saved_dir);
183
/****************************************************************************
185
****************************************************************************/
187
static NTSTATUS open_file(files_struct *fsp,
188
connection_struct *conn,
190
SMB_STRUCT_STAT *psbuf,
195
int accmode = (flags & O_ACCMODE);
196
int local_flags = flags;
197
BOOL file_existed = VALID_STAT(*psbuf);
202
/* Check permissions */
205
* This code was changed after seeing a client open request
206
* containing the open mode of (DENY_WRITE/read-only) with
207
* the 'create if not exist' bit set. The previous code
208
* would fail to open the file read only on a read-only share
209
* as it was checking the flags parameter directly against O_RDONLY,
210
* this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
214
if (!CAN_WRITE(conn)) {
215
/* It's a read-only share - fail if we wanted to write. */
216
if(accmode != O_RDONLY) {
217
DEBUG(3,("Permission denied opening %s\n",fname));
218
return NT_STATUS_ACCESS_DENIED;
219
} else if(flags & O_CREAT) {
220
/* We don't want to write - but we must make sure that
221
O_CREAT doesn't create the file if we have write
222
access into the directory.
225
local_flags &= ~O_CREAT;
230
* This little piece of insanity is inspired by the
231
* fact that an NT client can open a file for O_RDONLY,
232
* but set the create disposition to FILE_EXISTS_TRUNCATE.
233
* If the client *can* write to the file, then it expects to
234
* truncate the file, even though it is opening for readonly.
235
* Quicken uses this stupid trick in backup file creation...
236
* Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
237
* for helping track this one down. It didn't bite us in 2.0.x
238
* as we always opened files read-write in that release. JRA.
241
if ((accmode == O_RDONLY) && ((flags & O_TRUNC) == O_TRUNC)) {
242
DEBUG(10,("open_file: truncate requested on read-only open "
243
"for file %s\n",fname ));
244
local_flags = (flags & ~O_ACCMODE)|O_RDWR;
247
if ((access_mask & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ||
248
(local_flags & O_CREAT) ||
249
((local_flags & O_TRUNC) == O_TRUNC) ) {
252
* We can't actually truncate here as the file may be locked.
253
* open_file_ntcreate will take care of the truncate later. JRA.
256
local_flags &= ~O_TRUNC;
258
#if defined(O_NONBLOCK) && defined(S_ISFIFO)
260
* We would block on opening a FIFO with no one else on the
261
* other end. Do what we used to do and add O_NONBLOCK to the
265
if (file_existed && S_ISFIFO(psbuf->st_mode)) {
266
local_flags |= O_NONBLOCK;
270
/* Don't create files with Microsoft wildcard characters. */
271
if ((local_flags & O_CREAT) && !file_existed &&
272
ms_has_wild(fname)) {
273
return NT_STATUS_OBJECT_NAME_INVALID;
276
/* Actually do the open */
277
if (!fd_open(conn, fname, fsp, local_flags, unx_mode)) {
278
DEBUG(3,("Error opening file %s (%s) (local_flags=%d) "
280
fname,strerror(errno),local_flags,flags));
281
return map_nt_error_from_unix(errno);
284
/* Inherit the ACL if the file was created. */
285
if ((local_flags & O_CREAT) && !file_existed) {
286
inherit_access_acl(conn, fname, unx_mode);
290
fsp->fh->fd = -1; /* What we used to call a stat open. */
296
if (fsp->fh->fd == -1) {
297
ret = SMB_VFS_STAT(conn, fname, psbuf);
299
ret = SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf);
300
/* If we have an fd, this stat should succeed. */
302
DEBUG(0,("Error doing fstat on open file %s "
303
"(%s)\n", fname,strerror(errno) ));
307
/* For a non-io open, this stat failing means file not found. JRA */
309
NTSTATUS status = map_nt_error_from_unix(errno);
316
* POSIX allows read-only opens of directories. We don't
317
* want to do this (we use a different code path for this)
318
* so catch a directory open and return an EISDIR. JRA.
321
if(S_ISDIR(psbuf->st_mode)) {
324
return NT_STATUS_FILE_IS_A_DIRECTORY;
327
fsp->mode = psbuf->st_mode;
328
fsp->inode = psbuf->st_ino;
329
fsp->dev = psbuf->st_dev;
330
fsp->vuid = current_user.vuid;
331
fsp->file_pid = global_smbpid;
332
fsp->can_lock = True;
333
fsp->can_read = (access_mask & (FILE_READ_DATA)) ? True : False;
334
if (!CAN_WRITE(conn)) {
335
fsp->can_write = False;
337
fsp->can_write = (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) ? True : False;
339
fsp->print_file = False;
340
fsp->modified = False;
341
fsp->sent_oplock_break = NO_BREAK_SENT;
342
fsp->is_directory = False;
343
fsp->is_stat = False;
344
if (conn->aio_write_behind_list &&
345
is_in_path(fname, conn->aio_write_behind_list, conn->case_sensitive)) {
346
fsp->aio_write_behind = True;
349
string_set(&fsp->fsp_name,fname);
350
fsp->wcp = NULL; /* Write cache pointer. */
352
DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
353
*current_user_info.smb_name ? current_user_info.smb_name : conn->user,fsp->fsp_name,
354
BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
355
conn->num_files_open + 1));
361
/*******************************************************************
362
Return True if the filename is one of the special executable types.
363
********************************************************************/
365
static BOOL is_executable(const char *fname)
367
if ((fname = strrchr_m(fname,'.'))) {
368
if (strequal(fname,".com") ||
369
strequal(fname,".dll") ||
370
strequal(fname,".exe") ||
371
strequal(fname,".sym")) {
378
/****************************************************************************
379
Check if we can open a file with a share mode.
380
Returns True if conflict, False if not.
381
****************************************************************************/
383
static BOOL share_conflict(struct share_mode_entry *entry,
387
DEBUG(10,("share_conflict: entry->access_mask = 0x%x, "
388
"entry->share_access = 0x%x, "
389
"entry->private_options = 0x%x\n",
390
(unsigned int)entry->access_mask,
391
(unsigned int)entry->share_access,
392
(unsigned int)entry->private_options));
394
DEBUG(10,("share_conflict: access_mask = 0x%x, share_access = 0x%x\n",
395
(unsigned int)access_mask, (unsigned int)share_access));
397
if ((entry->access_mask & (FILE_WRITE_DATA|
401
DELETE_ACCESS)) == 0) {
402
DEBUG(10,("share_conflict: No conflict due to "
403
"entry->access_mask = 0x%x\n",
404
(unsigned int)entry->access_mask ));
408
if ((access_mask & (FILE_WRITE_DATA|
412
DELETE_ACCESS)) == 0) {
413
DEBUG(10,("share_conflict: No conflict due to "
414
"access_mask = 0x%x\n",
415
(unsigned int)access_mask ));
419
#if 1 /* JRA TEST - Superdebug. */
420
#define CHECK_MASK(num, am, right, sa, share) \
421
DEBUG(10,("share_conflict: [%d] am (0x%x) & right (0x%x) = 0x%x\n", \
422
(unsigned int)(num), (unsigned int)(am), \
423
(unsigned int)(right), (unsigned int)(am)&(right) )); \
424
DEBUG(10,("share_conflict: [%d] sa (0x%x) & share (0x%x) = 0x%x\n", \
425
(unsigned int)(num), (unsigned int)(sa), \
426
(unsigned int)(share), (unsigned int)(sa)&(share) )); \
427
if (((am) & (right)) && !((sa) & (share))) { \
428
DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
429
sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
430
(unsigned int)(share) )); \
434
#define CHECK_MASK(num, am, right, sa, share) \
435
if (((am) & (right)) && !((sa) & (share))) { \
436
DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
437
sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
438
(unsigned int)(share) )); \
443
CHECK_MASK(1, entry->access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
444
share_access, FILE_SHARE_WRITE);
445
CHECK_MASK(2, access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
446
entry->share_access, FILE_SHARE_WRITE);
448
CHECK_MASK(3, entry->access_mask, FILE_READ_DATA | FILE_EXECUTE,
449
share_access, FILE_SHARE_READ);
450
CHECK_MASK(4, access_mask, FILE_READ_DATA | FILE_EXECUTE,
451
entry->share_access, FILE_SHARE_READ);
453
CHECK_MASK(5, entry->access_mask, DELETE_ACCESS,
454
share_access, FILE_SHARE_DELETE);
455
CHECK_MASK(6, access_mask, DELETE_ACCESS,
456
entry->share_access, FILE_SHARE_DELETE);
458
DEBUG(10,("share_conflict: No conflict.\n"));
462
#if defined(DEVELOPER)
463
static void validate_my_share_entries(int num,
464
struct share_mode_entry *share_entry)
468
if (!procid_is_me(&share_entry->pid)) {
472
if (is_deferred_open_entry(share_entry) &&
473
!open_was_deferred(share_entry->op_mid)) {
475
DEBUG(0, ("Got a deferred entry without a request: "
476
"PANIC: %s\n", share_mode_str(num, share_entry)));
480
if (!is_valid_share_mode_entry(share_entry)) {
484
fsp = file_find_dif(share_entry->dev, share_entry->inode,
485
share_entry->share_file_id);
487
DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
488
share_mode_str(num, share_entry) ));
489
smb_panic("validate_my_share_entries: Cannot match a "
490
"share entry with an open file\n");
493
if (is_deferred_open_entry(share_entry) ||
494
is_unused_share_mode_entry(share_entry)) {
498
if ((share_entry->op_type == NO_OPLOCK) &&
499
(fsp->oplock_type == FAKE_LEVEL_II_OPLOCK)) {
500
/* Someone has already written to it, but I haven't yet
505
if (((uint16)fsp->oplock_type) != share_entry->op_type) {
514
DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
515
share_mode_str(num, share_entry) ));
516
slprintf(str, sizeof(str)-1, "validate_my_share_entries: "
517
"file %s, oplock_type = 0x%x, op_type = 0x%x\n",
518
fsp->fsp_name, (unsigned int)fsp->oplock_type,
519
(unsigned int)share_entry->op_type );
525
static BOOL is_stat_open(uint32 access_mask)
527
return (access_mask &&
528
((access_mask & ~(SYNCHRONIZE_ACCESS| FILE_READ_ATTRIBUTES|
529
FILE_WRITE_ATTRIBUTES))==0) &&
530
((access_mask & (SYNCHRONIZE_ACCESS|FILE_READ_ATTRIBUTES|
531
FILE_WRITE_ATTRIBUTES)) != 0));
534
/****************************************************************************
535
Deal with share modes
536
Invarient: Share mode must be locked on entry and exit.
537
Returns -1 on error, or number of share modes on success (may be zero).
538
****************************************************************************/
540
static NTSTATUS open_mode_check(connection_struct *conn,
542
struct share_mode_lock *lck,
545
uint32 create_options,
550
if(lck->num_share_modes == 0) {
554
*file_existed = True;
556
if (is_stat_open(access_mask)) {
557
/* Stat open that doesn't trigger oplock breaks or share mode
558
* checks... ! JRA. */
562
/* A delete on close prohibits everything */
564
if (lck->delete_on_close) {
565
return NT_STATUS_DELETE_PENDING;
569
* Check if the share modes will give us access.
572
#if defined(DEVELOPER)
573
for(i = 0; i < lck->num_share_modes; i++) {
574
validate_my_share_entries(i, &lck->share_modes[i]);
578
if (!lp_share_modes(SNUM(conn))) {
582
/* Now we check the share modes, after any oplock breaks. */
583
for(i = 0; i < lck->num_share_modes; i++) {
585
if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
589
/* someone else has a share lock on it, check to see if we can
591
if (share_conflict(&lck->share_modes[i],
592
access_mask, share_access)) {
593
return NT_STATUS_SHARING_VIOLATION;
600
static BOOL is_delete_request(files_struct *fsp) {
601
return ((fsp->access_mask == DELETE_ACCESS) &&
602
(fsp->oplock_type == NO_OPLOCK));
606
* 1) No files open at all or internal open: Grant whatever the client wants.
608
* 2) Exclusive (or batch) oplock around: If the requested access is a delete
609
* request, break if the oplock around is a batch oplock. If it's another
610
* requested access type, break.
612
* 3) Only level2 around: Grant level2 and do nothing else.
615
static BOOL delay_for_oplocks(struct share_mode_lock *lck,
621
struct share_mode_entry *exclusive = NULL;
622
BOOL valid_entry = False;
623
BOOL delay_it = False;
624
BOOL have_level2 = False;
626
if ((oplock_request & INTERNAL_OPEN_ONLY) || is_stat_open(fsp->access_mask)) {
627
fsp->oplock_type = NO_OPLOCK;
631
for (i=0; i<lck->num_share_modes; i++) {
633
if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
637
/* At least one entry is not an invalid or deferred entry. */
640
if (pass_number == 1) {
641
if (BATCH_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
642
SMB_ASSERT(exclusive == NULL);
643
exclusive = &lck->share_modes[i];
646
if (EXCLUSIVE_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
647
SMB_ASSERT(exclusive == NULL);
648
exclusive = &lck->share_modes[i];
652
if (lck->share_modes[i].op_type == LEVEL_II_OPLOCK) {
653
SMB_ASSERT(exclusive == NULL);
659
/* All entries are placeholders or deferred.
660
* Directly grant whatever the client wants. */
661
if (fsp->oplock_type == NO_OPLOCK) {
662
/* Store a level2 oplock, but don't tell the client */
663
fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
668
if (exclusive != NULL) { /* Found an exclusive oplock */
669
SMB_ASSERT(!have_level2);
670
delay_it = is_delete_request(fsp) ?
671
BATCH_OPLOCK_TYPE(exclusive->op_type) : True;
674
if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
675
/* We can at most grant level2 as there are other
676
* level2 or NO_OPLOCK entries. */
677
fsp->oplock_type = LEVEL_II_OPLOCK;
680
if ((fsp->oplock_type == NO_OPLOCK) && have_level2) {
681
/* Store a level2 oplock, but don't tell the client */
682
fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
687
char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
689
DEBUG(10, ("Sending break request to PID %s\n",
690
procid_str_static(&exclusive->pid)));
691
exclusive->op_mid = get_current_mid();
693
/* Create the message. */
694
share_mode_entry_to_message(msg, exclusive);
696
/* Add in the FORCE_OPLOCK_BREAK_TO_NONE bit in the message if set. We don't
697
want this set in the share mode struct pointed to by lck. */
699
if (oplock_request & FORCE_OPLOCK_BREAK_TO_NONE) {
700
SSVAL(msg,6,exclusive->op_type | FORCE_OPLOCK_BREAK_TO_NONE);
704
ret = message_send_pid(exclusive->pid, MSG_SMB_BREAK_REQUEST,
705
msg, MSG_SMB_SHARE_MODE_ENTRY_SIZE, True);
708
DEBUG(3, ("Could not send oplock break message\n"));
715
static BOOL request_timed_out(struct timeval request_time,
716
struct timeval timeout)
718
struct timeval now, end_time;
720
end_time = timeval_sum(&request_time, &timeout);
721
return (timeval_compare(&end_time, &now) < 0);
724
/****************************************************************************
725
Handle the 1 second delay in returning a SHARING_VIOLATION error.
726
****************************************************************************/
728
static void defer_open(struct share_mode_lock *lck,
729
struct timeval request_time,
730
struct timeval timeout,
731
struct deferred_open_record *state)
733
uint16 mid = get_current_mid();
738
for (i=0; i<lck->num_share_modes; i++) {
739
struct share_mode_entry *e = &lck->share_modes[i];
741
if (!is_deferred_open_entry(e)) {
745
if (procid_is_me(&e->pid) && (e->op_mid == mid)) {
746
DEBUG(0, ("Trying to defer an already deferred "
747
"request: mid=%d, exiting\n", mid));
748
exit_server("attempt to defer a deferred request");
752
/* End paranoia check */
754
DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred "
755
"open entry for mid %u\n",
756
(unsigned int)request_time.tv_sec,
757
(unsigned int)request_time.tv_usec,
760
if (!push_deferred_smb_message(mid, request_time, timeout,
761
(char *)state, sizeof(*state))) {
762
exit_server("push_deferred_smb_message failed");
764
add_deferred_open(lck, mid, request_time, state->dev, state->inode);
767
* Push the MID of this packet on the signing queue.
768
* We only do this once, the first time we push the packet
769
* onto the deferred open queue, as this has a side effect
770
* of incrementing the response sequence number.
773
srv_defer_sign_response(mid);
776
/****************************************************************************
777
Set a kernel flock on a file for NFS interoperability.
778
This requires a patch to Linux.
779
****************************************************************************/
781
static void kernel_flock(files_struct *fsp, uint32 share_mode)
783
#if HAVE_KERNEL_SHARE_MODES
785
if (share_mode == FILE_SHARE_WRITE) {
786
kernel_mode = LOCK_MAND|LOCK_WRITE;
787
} else if (share_mode == FILE_SHARE_READ) {
788
kernel_mode = LOCK_MAND|LOCK_READ;
789
} else if (share_mode == FILE_SHARE_NONE) {
790
kernel_mode = LOCK_MAND;
793
flock(fsp->fh->fd, kernel_mode);
799
/****************************************************************************
800
On overwrite open ensure that the attributes match.
801
****************************************************************************/
803
static BOOL open_match_attributes(connection_struct *conn,
807
mode_t existing_unx_mode,
809
mode_t *returned_unx_mode)
811
uint32 noarch_old_dos_attr, noarch_new_dos_attr;
813
noarch_old_dos_attr = (old_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
814
noarch_new_dos_attr = (new_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
816
if((noarch_old_dos_attr == 0 && noarch_new_dos_attr != 0) ||
817
(noarch_old_dos_attr != 0 && ((noarch_old_dos_attr & noarch_new_dos_attr) == noarch_old_dos_attr))) {
818
*returned_unx_mode = new_unx_mode;
820
*returned_unx_mode = (mode_t)0;
823
DEBUG(10,("open_match_attributes: file %s old_dos_attr = 0x%x, "
824
"existing_unx_mode = 0%o, new_dos_attr = 0x%x "
825
"returned_unx_mode = 0%o\n",
827
(unsigned int)old_dos_attr,
828
(unsigned int)existing_unx_mode,
829
(unsigned int)new_dos_attr,
830
(unsigned int)*returned_unx_mode ));
832
/* If we're mapping SYSTEM and HIDDEN ensure they match. */
833
if (lp_map_system(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
834
if ((old_dos_attr & FILE_ATTRIBUTE_SYSTEM) &&
835
!(new_dos_attr & FILE_ATTRIBUTE_SYSTEM)) {
839
if (lp_map_hidden(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
840
if ((old_dos_attr & FILE_ATTRIBUTE_HIDDEN) &&
841
!(new_dos_attr & FILE_ATTRIBUTE_HIDDEN)) {
848
/****************************************************************************
849
Special FCB or DOS processing in the case of a sharing violation.
850
Try and find a duplicated file handle.
851
****************************************************************************/
853
static files_struct *fcb_or_dos_open(connection_struct *conn,
854
const char *fname, SMB_DEV_T dev,
858
uint32 create_options)
861
files_struct *dup_fsp;
863
DEBUG(5,("fcb_or_dos_open: attempting old open semantics for "
864
"file %s.\n", fname ));
866
for(fsp = file_find_di_first(dev, inode); fsp;
867
fsp = file_find_di_next(fsp)) {
869
DEBUG(10,("fcb_or_dos_open: checking file %s, fd = %d, "
870
"vuid = %u, file_pid = %u, private_options = 0x%x "
871
"access_mask = 0x%x\n", fsp->fsp_name,
872
fsp->fh->fd, (unsigned int)fsp->vuid,
873
(unsigned int)fsp->file_pid,
874
(unsigned int)fsp->fh->private_options,
875
(unsigned int)fsp->access_mask ));
877
if (fsp->fh->fd != -1 &&
878
fsp->vuid == current_user.vuid &&
879
fsp->file_pid == global_smbpid &&
880
(fsp->fh->private_options & (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS |
881
NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) &&
882
(fsp->access_mask & FILE_WRITE_DATA) &&
883
strequal(fsp->fsp_name, fname)) {
884
DEBUG(10,("fcb_or_dos_open: file match\n"));
893
/* quite an insane set of semantics ... */
894
if (is_executable(fname) &&
895
(fsp->fh->private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS)) {
896
DEBUG(10,("fcb_or_dos_open: file fail due to is_executable.\n"));
900
/* We need to duplicate this fsp. */
901
if (!NT_STATUS_IS_OK(dup_file_fsp(fsp, access_mask, share_access,
902
create_options, &dup_fsp))) {
909
/****************************************************************************
910
Open a file with a share mode - old openX method - map into NTCreate.
911
****************************************************************************/
913
BOOL map_open_params_to_ntcreate(const char *fname, int deny_mode, int open_func,
914
uint32 *paccess_mask,
916
uint32 *pcreate_disposition,
917
uint32 *pcreate_options)
921
uint32 create_disposition;
922
uint32 create_options = 0;
924
DEBUG(10,("map_open_params_to_ntcreate: fname = %s, deny_mode = 0x%x, "
925
"open_func = 0x%x\n",
926
fname, (unsigned int)deny_mode, (unsigned int)open_func ));
928
/* Create the NT compatible access_mask. */
929
switch (GET_OPENX_MODE(deny_mode)) {
930
case DOS_OPEN_EXEC: /* Implies read-only - used to be FILE_READ_DATA */
931
case DOS_OPEN_RDONLY:
932
access_mask = FILE_GENERIC_READ;
934
case DOS_OPEN_WRONLY:
935
access_mask = FILE_GENERIC_WRITE;
939
access_mask = FILE_GENERIC_READ|FILE_GENERIC_WRITE;
942
DEBUG(10,("map_open_params_to_ntcreate: bad open mode = 0x%x\n",
943
(unsigned int)GET_OPENX_MODE(deny_mode)));
947
/* Create the NT compatible create_disposition. */
949
case OPENX_FILE_EXISTS_FAIL|OPENX_FILE_CREATE_IF_NOT_EXIST:
950
create_disposition = FILE_CREATE;
953
case OPENX_FILE_EXISTS_OPEN:
954
create_disposition = FILE_OPEN;
957
case OPENX_FILE_EXISTS_OPEN|OPENX_FILE_CREATE_IF_NOT_EXIST:
958
create_disposition = FILE_OPEN_IF;
961
case OPENX_FILE_EXISTS_TRUNCATE:
962
create_disposition = FILE_OVERWRITE;
965
case OPENX_FILE_EXISTS_TRUNCATE|OPENX_FILE_CREATE_IF_NOT_EXIST:
966
create_disposition = FILE_OVERWRITE_IF;
970
/* From samba4 - to be confirmed. */
971
if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_EXEC) {
972
create_disposition = FILE_CREATE;
975
DEBUG(10,("map_open_params_to_ntcreate: bad "
976
"open_func 0x%x\n", (unsigned int)open_func));
980
/* Create the NT compatible share modes. */
981
switch (GET_DENY_MODE(deny_mode)) {
983
share_mode = FILE_SHARE_NONE;
987
share_mode = FILE_SHARE_READ;
991
share_mode = FILE_SHARE_WRITE;
995
share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
999
create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
1000
if (is_executable(fname)) {
1001
share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
1003
if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_RDONLY) {
1004
share_mode = FILE_SHARE_READ;
1006
share_mode = FILE_SHARE_NONE;
1012
create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
1013
share_mode = FILE_SHARE_NONE;
1017
DEBUG(10,("map_open_params_to_ntcreate: bad deny_mode 0x%x\n",
1018
(unsigned int)GET_DENY_MODE(deny_mode) ));
1022
DEBUG(10,("map_open_params_to_ntcreate: file %s, access_mask = 0x%x, "
1023
"share_mode = 0x%x, create_disposition = 0x%x, "
1024
"create_options = 0x%x\n",
1026
(unsigned int)access_mask,
1027
(unsigned int)share_mode,
1028
(unsigned int)create_disposition,
1029
(unsigned int)create_options ));
1032
*paccess_mask = access_mask;
1035
*pshare_mode = share_mode;
1037
if (pcreate_disposition) {
1038
*pcreate_disposition = create_disposition;
1040
if (pcreate_options) {
1041
*pcreate_options = create_options;
1048
static void schedule_defer_open(struct share_mode_lock *lck, struct timeval request_time)
1050
struct deferred_open_record state;
1052
/* This is a relative time, added to the absolute
1053
request_time value to get the absolute timeout time.
1054
Note that if this is the second or greater time we enter
1055
this codepath for this particular request mid then
1056
request_time is left as the absolute time of the *first*
1057
time this request mid was processed. This is what allows
1058
the request to eventually time out. */
1060
struct timeval timeout;
1062
/* Normally the smbd we asked should respond within
1063
* OPLOCK_BREAK_TIMEOUT seconds regardless of whether
1064
* the client did, give twice the timeout as a safety
1065
* measure here in case the other smbd is stuck
1066
* somewhere else. */
1068
timeout = timeval_set(OPLOCK_BREAK_TIMEOUT*2, 0);
1070
/* Nothing actually uses state.delayed_for_oplocks
1071
but it's handy to differentiate in debug messages
1072
between a 30 second delay due to oplock break, and
1073
a 1 second delay for share mode conflicts. */
1075
state.delayed_for_oplocks = True;
1076
state.dev = lck->dev;
1077
state.inode = lck->ino;
1079
if (!request_timed_out(request_time, timeout)) {
1080
defer_open(lck, request_time, timeout, &state);
1084
/****************************************************************************
1085
Open a file with a share mode.
1086
****************************************************************************/
1088
NTSTATUS open_file_ntcreate(connection_struct *conn,
1090
SMB_STRUCT_STAT *psbuf,
1091
uint32 access_mask, /* access bits (FILE_READ_DATA etc.) */
1092
uint32 share_access, /* share constants (FILE_SHARE_READ etc). */
1093
uint32 create_disposition, /* FILE_OPEN_IF etc. */
1094
uint32 create_options, /* options such as delete on close. */
1095
uint32 new_dos_attributes, /* attributes used for new file. */
1096
int oplock_request, /* internal Samba oplock codes. */
1097
/* Information (FILE_EXISTS etc.) */
1099
files_struct **result)
1103
BOOL file_existed = VALID_STAT(*psbuf);
1104
BOOL def_acl = False;
1106
SMB_INO_T inode = 0;
1107
NTSTATUS fsp_open = NT_STATUS_ACCESS_DENIED;
1108
files_struct *fsp = NULL;
1109
mode_t new_unx_mode = (mode_t)0;
1110
mode_t unx_mode = (mode_t)0;
1112
uint32 existing_dos_attributes = 0;
1113
struct pending_message_list *pml = NULL;
1114
uint16 mid = get_current_mid();
1115
struct timeval request_time = timeval_zero();
1116
struct share_mode_lock *lck = NULL;
1119
if (conn->printer) {
1121
* Printers are handled completely differently.
1122
* Most of the passed parameters are ignored.
1126
*pinfo = FILE_WAS_CREATED;
1129
DEBUG(10, ("open_file_ntcreate: printer open fname=%s\n", fname));
1131
return print_fsp_open(conn, fname, &fsp);
1134
/* We add aARCH to this as this mode is only used if the file is
1136
unx_mode = unix_mode(conn, new_dos_attributes | aARCH,fname, True);
1138
DEBUG(10, ("open_file_ntcreate: fname=%s, dos_attrs=0x%x "
1139
"access_mask=0x%x share_access=0x%x "
1140
"create_disposition = 0x%x create_options=0x%x "
1141
"unix mode=0%o oplock_request=%d\n",
1142
fname, new_dos_attributes, access_mask, share_access,
1143
create_disposition, create_options, unx_mode,
1146
if ((pml = get_open_deferred_message(mid)) != NULL) {
1147
struct deferred_open_record *state =
1148
(struct deferred_open_record *)pml->private_data.data;
1150
/* Remember the absolute time of the original
1151
request with this mid. We'll use it later to
1152
see if this has timed out. */
1154
request_time = pml->request_time;
1156
/* Remove the deferred open entry under lock. */
1157
lck = get_share_mode_lock(NULL, state->dev, state->inode, NULL, NULL);
1159
DEBUG(0, ("could not get share mode lock\n"));
1161
del_deferred_open_entry(lck, mid);
1165
/* Ensure we don't reprocess this message. */
1166
remove_deferred_open_smb_message(mid);
1169
if (!check_name(fname,conn)) {
1170
return map_nt_error_from_unix(errno);
1173
new_dos_attributes &= SAMBA_ATTRIBUTES_MASK;
1175
existing_dos_attributes = dos_mode(conn, fname, psbuf);
1178
/* ignore any oplock requests if oplocks are disabled */
1179
if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break ||
1180
IS_VETO_OPLOCK_PATH(conn, fname)) {
1181
/* Mask off everything except the private Samba bits. */
1182
oplock_request &= SAMBA_PRIVATE_OPLOCK_MASK;
1185
/* this is for OS/2 long file names - say we don't support them */
1186
if (!lp_posix_pathnames() && strstr(fname,".+,;=[].")) {
1187
/* OS/2 Workplace shell fix may be main code stream in a later
1189
DEBUG(5,("open_file_ntcreate: OS/2 long filenames are not "
1191
if (use_nt_status()) {
1192
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1194
return NT_STATUS_DOS(ERRDOS, ERRcannotopen);
1197
switch( create_disposition ) {
1199
* Currently we're using FILE_SUPERSEDE as the same as
1200
* FILE_OVERWRITE_IF but they really are
1201
* different. FILE_SUPERSEDE deletes an existing file
1202
* (requiring delete access) then recreates it.
1204
case FILE_SUPERSEDE:
1205
/* If file exists replace/overwrite. If file doesn't
1207
flags2 |= (O_CREAT | O_TRUNC);
1210
case FILE_OVERWRITE_IF:
1211
/* If file exists replace/overwrite. If file doesn't
1213
flags2 |= (O_CREAT | O_TRUNC);
1217
/* If file exists open. If file doesn't exist error. */
1218
if (!file_existed) {
1219
DEBUG(5,("open_file_ntcreate: FILE_OPEN "
1220
"requested for file %s and file "
1221
"doesn't exist.\n", fname ));
1223
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1227
case FILE_OVERWRITE:
1228
/* If file exists overwrite. If file doesn't exist
1230
if (!file_existed) {
1231
DEBUG(5,("open_file_ntcreate: FILE_OVERWRITE "
1232
"requested for file %s and file "
1233
"doesn't exist.\n", fname ));
1235
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1241
/* If file exists error. If file doesn't exist
1244
DEBUG(5,("open_file_ntcreate: FILE_CREATE "
1245
"requested for file %s and file "
1246
"already exists.\n", fname ));
1247
if (S_ISDIR(psbuf->st_mode)) {
1252
return map_nt_error_from_unix(errno);
1254
flags2 |= (O_CREAT|O_EXCL);
1258
/* If file exists open. If file doesn't exist
1264
return NT_STATUS_INVALID_PARAMETER;
1267
/* We only care about matching attributes on file exists and
1270
if (file_existed && ((create_disposition == FILE_OVERWRITE) ||
1271
(create_disposition == FILE_OVERWRITE_IF))) {
1272
if (!open_match_attributes(conn, fname,
1273
existing_dos_attributes,
1274
new_dos_attributes, psbuf->st_mode,
1275
unx_mode, &new_unx_mode)) {
1276
DEBUG(5,("open_file_ntcreate: attributes missmatch "
1277
"for file %s (%x %x) (0%o, 0%o)\n",
1278
fname, existing_dos_attributes,
1280
(unsigned int)psbuf->st_mode,
1281
(unsigned int)unx_mode ));
1283
return NT_STATUS_ACCESS_DENIED;
1287
/* This is a nasty hack - must fix... JRA. */
1288
if (access_mask == MAXIMUM_ALLOWED_ACCESS) {
1289
access_mask = FILE_GENERIC_ALL;
1293
* Convert GENERIC bits to specific bits.
1296
se_map_generic(&access_mask, &file_generic_mapping);
1298
DEBUG(10, ("open_file_ntcreate: fname=%s, after mapping "
1299
"access_mask=0x%x\n", fname, access_mask ));
1302
* Note that we ignore the append flag as append does not
1303
* mean the same thing under DOS and Unix.
1306
if (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) {
1313
* Currently we only look at FILE_WRITE_THROUGH for create options.
1317
if ((create_options & FILE_WRITE_THROUGH) && lp_strict_sync(SNUM(conn))) {
1322
if (!CAN_WRITE(conn)) {
1324
* We should really return a permission denied error if either
1325
* O_CREAT or O_TRUNC are set, but for compatibility with
1326
* older versions of Samba we just AND them out.
1328
flags2 &= ~(O_CREAT|O_TRUNC);
1332
* Ensure we can't write on a read-only share or file.
1335
if (flags != O_RDONLY && file_existed &&
1336
(!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_attributes))) {
1337
DEBUG(5,("open_file_ntcreate: write access requested for "
1338
"file %s on read only %s\n",
1339
fname, !CAN_WRITE(conn) ? "share" : "file" ));
1341
return NT_STATUS_ACCESS_DENIED;
1344
status = file_new(conn, &fsp);
1345
if(!NT_STATUS_IS_OK(status)) {
1349
fsp->dev = psbuf->st_dev;
1350
fsp->inode = psbuf->st_ino;
1351
fsp->share_access = share_access;
1352
fsp->fh->private_options = create_options;
1353
fsp->access_mask = access_mask;
1354
/* Ensure no SAMBA_PRIVATE bits can be set. */
1355
fsp->oplock_type = (oplock_request & ~SAMBA_PRIVATE_OPLOCK_MASK);
1357
if (timeval_is_zero(&request_time)) {
1358
request_time = fsp->open_time;
1362
dev = psbuf->st_dev;
1363
inode = psbuf->st_ino;
1365
lck = get_share_mode_lock(NULL, dev, inode,
1371
DEBUG(0, ("Could not get share mode lock\n"));
1372
return NT_STATUS_SHARING_VIOLATION;
1375
/* First pass - send break only on batch oplocks. */
1376
if (delay_for_oplocks(lck, fsp, 1, oplock_request)) {
1377
schedule_defer_open(lck, request_time);
1380
return NT_STATUS_SHARING_VIOLATION;
1383
status = open_mode_check(conn, fname, lck,
1384
access_mask, share_access,
1385
create_options, &file_existed);
1387
if (NT_STATUS_IS_OK(status)) {
1388
/* We might be going to allow this open. Check oplock status again. */
1389
/* Second pass - send break for both batch or exclusive oplocks. */
1390
if (delay_for_oplocks(lck, fsp, 2, oplock_request)) {
1391
schedule_defer_open(lck, request_time);
1394
return NT_STATUS_SHARING_VIOLATION;
1398
if (NT_STATUS_EQUAL(status, NT_STATUS_DELETE_PENDING)) {
1399
/* DELETE_PENDING is not deferred for a second */
1405
if (!NT_STATUS_IS_OK(status)) {
1407
SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION));
1409
/* Check if this can be done with the deny_dos and fcb
1411
if (create_options &
1412
(NTCREATEX_OPTIONS_PRIVATE_DENY_DOS|
1413
NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
1414
files_struct *fsp_dup;
1415
fsp_dup = fcb_or_dos_open(conn, fname, dev,
1424
*pinfo = FILE_WAS_OPENED;
1426
conn->num_files_open++;
1428
return NT_STATUS_OK;
1433
* This next line is a subtlety we need for
1434
* MS-Access. If a file open will fail due to share
1435
* permissions and also for security (access) reasons,
1436
* we need to return the access failed error, not the
1437
* share error. This means we must attempt to open the
1438
* file anyway in order to get the UNIX access error -
1439
* even if we're going to fail the open for share
1440
* reasons. This is bad, as we're burning another fd
1441
* if there are existing locks but there's nothing
1442
* else we can do. We also ensure we're not going to
1443
* create or tuncate the file as we only want an
1444
* access decision at this stage. JRA.
1447
fsp_open = open_file(fsp,conn,fname,psbuf,
1448
flags|(flags2&~(O_TRUNC|O_CREAT)),
1449
unx_mode,access_mask);
1451
DEBUG(4,("open_file_ntcreate : share_mode deny - "
1452
"calling open_file with flags=0x%X "
1453
"flags2=0x%X mode=0%o returned %s\n",
1454
flags, (flags2&~(O_TRUNC|O_CREAT)),
1455
(unsigned int)unx_mode, nt_errstr(fsp_open)));
1457
if (!NT_STATUS_IS_OK(fsp_open) && errno) {
1458
/* Default error. */
1459
status = NT_STATUS_ACCESS_DENIED;
1463
* If we're returning a share violation, ensure we
1464
* cope with the braindead 1 second delay.
1467
if (!(oplock_request & INTERNAL_OPEN_ONLY) &&
1468
lp_defer_sharing_violations()) {
1469
struct timeval timeout;
1470
struct deferred_open_record state;
1473
/* this is a hack to speed up torture tests
1475
timeout_usecs = lp_parm_int(SNUM(conn),
1476
"smbd","sharedelay",
1477
SHARING_VIOLATION_USEC_WAIT);
1479
/* This is a relative time, added to the absolute
1480
request_time value to get the absolute timeout time.
1481
Note that if this is the second or greater time we enter
1482
this codepath for this particular request mid then
1483
request_time is left as the absolute time of the *first*
1484
time this request mid was processed. This is what allows
1485
the request to eventually time out. */
1487
timeout = timeval_set(0, timeout_usecs);
1489
/* Nothing actually uses state.delayed_for_oplocks
1490
but it's handy to differentiate in debug messages
1491
between a 30 second delay due to oplock break, and
1492
a 1 second delay for share mode conflicts. */
1494
state.delayed_for_oplocks = False;
1496
state.inode = inode;
1498
if (!request_timed_out(request_time,
1500
defer_open(lck, request_time, timeout,
1506
if (NT_STATUS_IS_OK(fsp_open)) {
1507
fd_close(conn, fsp);
1509
* We have detected a sharing violation here
1510
* so return the correct error code
1512
status = NT_STATUS_SHARING_VIOLATION;
1519
* We exit this block with the share entry *locked*.....
1523
SMB_ASSERT(!file_existed || (lck != NULL));
1526
* Ensure we pay attention to default ACLs on directories if required.
1529
if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
1530
(def_acl = directory_has_default_acl(conn,
1531
parent_dirname(fname)))) {
1535
DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o\n",
1536
(unsigned int)flags, (unsigned int)flags2,
1537
(unsigned int)unx_mode));
1540
* open_file strips any O_TRUNC flags itself.
1543
fsp_open = open_file(fsp,conn,fname,psbuf,flags|flags2,unx_mode,
1546
if (!NT_STATUS_IS_OK(fsp_open)) {
1554
if (!file_existed) {
1557
* Deal with the race condition where two smbd's detect the
1558
* file doesn't exist and do the create at the same time. One
1559
* of them will win and set a share mode, the other (ie. this
1560
* one) should check if the requested share mode for this
1561
* create is allowed.
1565
* Now the file exists and fsp is successfully opened,
1566
* fsp->dev and fsp->inode are valid and should replace the
1567
* dev=0,inode=0 from a non existent file. Spotted by
1568
* Nadav Danieli <nadavd@exanet.com>. JRA.
1574
lck = get_share_mode_lock(NULL, dev, inode,
1579
DEBUG(0, ("open_file_ntcreate: Could not get share mode lock for %s\n", fname));
1580
fd_close(conn, fsp);
1582
return NT_STATUS_SHARING_VIOLATION;
1585
status = open_mode_check(conn, fname, lck,
1586
access_mask, share_access,
1587
create_options, &file_existed);
1589
if (!NT_STATUS_IS_OK(status)) {
1590
struct deferred_open_record state;
1592
fd_close(conn, fsp);
1595
state.delayed_for_oplocks = False;
1597
state.inode = inode;
1599
/* Do it all over again immediately. In the second
1600
* round we will find that the file existed and handle
1601
* the DELETE_PENDING and FCB cases correctly. No need
1602
* to duplicate the code here. Essentially this is a
1603
* "goto top of this function", but don't tell
1606
defer_open(lck, request_time, timeval_zero(),
1613
* We exit this block with the share entry *locked*.....
1617
SMB_ASSERT(lck != NULL);
1619
/* note that we ignore failure for the following. It is
1620
basically a hack for NFS, and NFS will never set one of
1621
these only read them. Nobody but Samba can ever set a deny
1622
mode and we have already checked our more authoritative
1623
locking database for permission to set this deny mode. If
1624
the kernel refuses the operations then the kernel is wrong */
1626
kernel_flock(fsp, share_access);
1629
* At this point onwards, we can guarentee that the share entry
1630
* is locked, whether we created the file or not, and that the
1631
* deny mode is compatible with all current opens.
1635
* If requested, truncate the file.
1638
if (flags2&O_TRUNC) {
1640
* We are modifing the file after open - update the stat
1643
if ((SMB_VFS_FTRUNCATE(fsp,fsp->fh->fd,0) == -1) ||
1644
(SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf)==-1)) {
1645
status = map_nt_error_from_unix(errno);
1653
/* Record the options we were opened with. */
1654
fsp->share_access = share_access;
1655
fsp->fh->private_options = create_options;
1656
fsp->access_mask = access_mask;
1659
if (!(flags2 & O_TRUNC)) {
1660
info = FILE_WAS_OPENED;
1662
info = FILE_WAS_OVERWRITTEN;
1665
info = FILE_WAS_CREATED;
1666
/* Change the owner if required. */
1667
if (lp_inherit_owner(SNUM(conn))) {
1668
change_owner_to_parent(conn, fsp, fsp->fsp_name,
1678
* Setup the oplock info in both the shared memory and
1682
if ((fsp->oplock_type != NO_OPLOCK) &&
1683
(fsp->oplock_type != FAKE_LEVEL_II_OPLOCK)) {
1684
if (!set_file_oplock(fsp, fsp->oplock_type)) {
1685
/* Could not get the kernel oplock */
1686
fsp->oplock_type = NO_OPLOCK;
1689
set_share_mode(lck, fsp, current_user.ut.uid, 0, fsp->oplock_type);
1691
if (info == FILE_WAS_OVERWRITTEN || info == FILE_WAS_CREATED ||
1692
info == FILE_WAS_SUPERSEDED) {
1694
/* Handle strange delete on close create semantics. */
1695
if (create_options & FILE_DELETE_ON_CLOSE) {
1696
status = can_set_delete_on_close(fsp, True, new_dos_attributes);
1698
if (!NT_STATUS_IS_OK(status)) {
1699
/* Remember to delete the mode we just added. */
1700
del_share_mode(lck, fsp);
1706
/* Note that here we set the *inital* delete on close flag,
1707
not the regular one. */
1708
set_delete_on_close_token(lck, ¤t_user.ut);
1709
lck->initial_delete_on_close = True;
1710
lck->modified = True;
1713
/* Files should be initially set as archive */
1714
if (lp_map_archive(SNUM(conn)) ||
1715
lp_store_dos_attributes(SNUM(conn))) {
1716
file_set_dosmode(conn, fname,
1717
new_dos_attributes | aARCH, NULL,
1723
* Take care of inherited ACLs on created files - if default ACL not
1727
if (!file_existed && !def_acl) {
1729
int saved_errno = errno; /* We might get ENOSYS in the next
1732
if (SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd, unx_mode) == -1
1733
&& errno == ENOSYS) {
1734
errno = saved_errno; /* Ignore ENOSYS */
1737
} else if (new_unx_mode) {
1741
/* Attributes need changing. File already existed. */
1744
int saved_errno = errno; /* We might get ENOSYS in the
1746
ret = SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd,
1749
if (ret == -1 && errno == ENOSYS) {
1750
errno = saved_errno; /* Ignore ENOSYS */
1752
DEBUG(5, ("open_file_ntcreate: reset "
1753
"attributes of file %s to 0%o\n",
1754
fname, (unsigned int)new_unx_mode));
1755
ret = 0; /* Don't do the fchmod below. */
1760
(SMB_VFS_FCHMOD(fsp, fsp->fh->fd, new_unx_mode) == -1))
1761
DEBUG(5, ("open_file_ntcreate: failed to reset "
1762
"attributes of file %s to 0%o\n",
1763
fname, (unsigned int)new_unx_mode));
1766
/* If this is a successful open, we must remove any deferred open
1768
del_deferred_open_entry(lck, mid);
1771
conn->num_files_open++;
1774
return NT_STATUS_OK;
1777
/****************************************************************************
1778
Open a file for for write to ensure that we can fchmod it.
1779
****************************************************************************/
1781
NTSTATUS open_file_fchmod(connection_struct *conn, const char *fname,
1782
SMB_STRUCT_STAT *psbuf, files_struct **result)
1784
files_struct *fsp = NULL;
1787
if (!VALID_STAT(*psbuf)) {
1788
return NT_STATUS_INVALID_PARAMETER;
1791
status = file_new(conn, &fsp);
1792
if(!NT_STATUS_IS_OK(status)) {
1796
/* note! we must use a non-zero desired access or we don't get
1797
a real file descriptor. Oh what a twisted web we weave. */
1798
status = open_file(fsp,conn,fname,psbuf,O_WRONLY,0,FILE_WRITE_DATA);
1801
* This is not a user visible file open.
1802
* Don't set a share mode and don't increment
1803
* the conn->num_files_open.
1806
if (!NT_STATUS_IS_OK(status)) {
1812
return NT_STATUS_OK;
1815
/****************************************************************************
1816
Close the fchmod file fd - ensure no locks are lost.
1817
****************************************************************************/
1819
int close_file_fchmod(files_struct *fsp)
1821
int ret = fd_close(fsp->conn, fsp);
1826
/****************************************************************************
1827
Open a directory from an NT SMB call.
1828
****************************************************************************/
1830
NTSTATUS open_directory(connection_struct *conn,
1832
SMB_STRUCT_STAT *psbuf,
1834
uint32 share_access,
1835
uint32 create_disposition,
1836
uint32 create_options,
1838
files_struct **result)
1840
files_struct *fsp = NULL;
1841
BOOL dir_existed = VALID_STAT(*psbuf) ? True : False;
1842
BOOL create_dir = False;
1843
struct share_mode_lock *lck = NULL;
1847
DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
1848
"share_access = 0x%x create_options = 0x%x, "
1849
"create_disposition = 0x%x\n",
1851
(unsigned int)access_mask,
1852
(unsigned int)share_access,
1853
(unsigned int)create_options,
1854
(unsigned int)create_disposition));
1856
if (is_ntfs_stream_name(fname)) {
1857
DEBUG(0,("open_directory: %s is a stream name!\n", fname ));
1858
return NT_STATUS_NOT_A_DIRECTORY;
1861
switch( create_disposition ) {
1863
/* If directory exists open. If directory doesn't
1866
DEBUG(5,("open_directory: FILE_OPEN requested "
1867
"for directory %s and it doesn't "
1868
"exist.\n", fname ));
1869
return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1871
info = FILE_WAS_OPENED;
1875
/* If directory exists error. If directory doesn't
1878
DEBUG(5,("open_directory: FILE_CREATE "
1879
"requested for directory %s and it "
1880
"already exists.\n", fname ));
1881
if (use_nt_status()) {
1882
return NT_STATUS_OBJECT_NAME_COLLISION;
1884
return NT_STATUS_DOS(ERRDOS,
1889
info = FILE_WAS_CREATED;
1893
/* If directory exists open. If directory doesn't
1897
info = FILE_WAS_CREATED;
1899
info = FILE_WAS_OPENED;
1903
case FILE_SUPERSEDE:
1904
case FILE_OVERWRITE:
1905
case FILE_OVERWRITE_IF:
1907
DEBUG(5,("open_directory: invalid create_disposition "
1908
"0x%x for directory %s\n",
1909
(unsigned int)create_disposition, fname));
1910
return NT_STATUS_INVALID_PARAMETER;
1915
* Try and create the directory.
1918
/* We know bad_path is false as it's caught earlier. */
1920
status = mkdir_internal(conn, fname, False);
1922
if (!NT_STATUS_IS_OK(status)) {
1923
DEBUG(2,("open_directory: unable to create %s. "
1924
"Error was %s\n", fname, strerror(errno) ));
1925
/* Ensure we return the correct NT status to the
1930
/* Ensure we're checking for a symlink here.... */
1931
/* We don't want to get caught by a symlink racer. */
1933
if(SMB_VFS_LSTAT(conn,fname, psbuf) != 0) {
1934
return map_nt_error_from_unix(errno);
1937
if(!S_ISDIR(psbuf->st_mode)) {
1938
DEBUG(0,("open_directory: %s is not a directory !\n",
1940
return NT_STATUS_NOT_A_DIRECTORY;
1944
status = file_new(conn, &fsp);
1945
if(!NT_STATUS_IS_OK(status)) {
1950
* Setup the files_struct for it.
1953
fsp->mode = psbuf->st_mode;
1954
fsp->inode = psbuf->st_ino;
1955
fsp->dev = psbuf->st_dev;
1956
fsp->vuid = current_user.vuid;
1957
fsp->file_pid = global_smbpid;
1958
fsp->can_lock = False;
1959
fsp->can_read = False;
1960
fsp->can_write = False;
1962
fsp->share_access = share_access;
1963
fsp->fh->private_options = create_options;
1964
fsp->access_mask = access_mask;
1966
fsp->print_file = False;
1967
fsp->modified = False;
1968
fsp->oplock_type = NO_OPLOCK;
1969
fsp->sent_oplock_break = NO_BREAK_SENT;
1970
fsp->is_directory = True;
1971
fsp->is_stat = False;
1972
string_set(&fsp->fsp_name,fname);
1974
lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode,
1979
DEBUG(0, ("open_directory: Could not get share mode lock for %s\n", fname));
1981
return NT_STATUS_SHARING_VIOLATION;
1984
status = open_mode_check(conn, fname, lck,
1985
access_mask, share_access,
1986
create_options, &dir_existed);
1988
if (!NT_STATUS_IS_OK(status)) {
1994
set_share_mode(lck, fsp, current_user.ut.uid, 0, NO_OPLOCK);
1996
/* For directories the delete on close bit at open time seems
1997
always to be honored on close... See test 19 in Samba4 BASE-DELETE. */
1998
if (create_options & FILE_DELETE_ON_CLOSE) {
1999
status = can_set_delete_on_close(fsp, True, 0);
2000
if (!NT_STATUS_IS_OK(status)) {
2006
set_delete_on_close_token(lck, ¤t_user.ut);
2007
lck->initial_delete_on_close = True;
2008
lck->modified = True;
2013
/* Change the owner if required. */
2014
if ((info == FILE_WAS_CREATED) && lp_inherit_owner(SNUM(conn))) {
2015
change_owner_to_parent(conn, fsp, fsp->fsp_name, psbuf);
2022
conn->num_files_open++;
2025
return NT_STATUS_OK;
2028
/****************************************************************************
2029
Open a pseudo-file (no locking checks - a 'stat' open).
2030
****************************************************************************/
2032
NTSTATUS open_file_stat(connection_struct *conn, char *fname,
2033
SMB_STRUCT_STAT *psbuf, files_struct **result)
2035
files_struct *fsp = NULL;
2038
if (!VALID_STAT(*psbuf)) {
2039
return NT_STATUS_INVALID_PARAMETER;
2042
/* Can't 'stat' open directories. */
2043
if(S_ISDIR(psbuf->st_mode)) {
2044
return NT_STATUS_FILE_IS_A_DIRECTORY;
2047
status = file_new(conn, &fsp);
2048
if(!NT_STATUS_IS_OK(status)) {
2052
DEBUG(5,("open_file_stat: 'opening' file %s\n", fname));
2055
* Setup the files_struct for it.
2058
fsp->mode = psbuf->st_mode;
2059
fsp->inode = psbuf->st_ino;
2060
fsp->dev = psbuf->st_dev;
2061
fsp->vuid = current_user.vuid;
2062
fsp->file_pid = global_smbpid;
2063
fsp->can_lock = False;
2064
fsp->can_read = False;
2065
fsp->can_write = False;
2066
fsp->print_file = False;
2067
fsp->modified = False;
2068
fsp->oplock_type = NO_OPLOCK;
2069
fsp->sent_oplock_break = NO_BREAK_SENT;
2070
fsp->is_directory = False;
2071
fsp->is_stat = True;
2072
string_set(&fsp->fsp_name,fname);
2074
conn->num_files_open++;
2077
return NT_STATUS_OK;
2080
/****************************************************************************
2081
Receive notification that one of our open files has been renamed by another
2083
****************************************************************************/
2085
void msg_file_was_renamed(int msg_type, struct process_id src, void *buf, size_t len)
2088
char *frm = (char *)buf;
2091
const char *sharepath;
2092
const char *newname;
2095
if (buf == NULL || len < MSG_FILE_RENAMED_MIN_SIZE + 2) {
2096
DEBUG(0, ("msg_file_was_renamed: Got invalid msg len %d\n", (int)len));
2100
/* Unpack the message. */
2101
dev = DEV_T_VAL(frm,0);
2102
inode = INO_T_VAL(frm,8);
2103
sharepath = &frm[16];
2104
newname = sharepath + strlen(sharepath) + 1;
2105
sp_len = strlen(sharepath);
2107
DEBUG(10,("msg_file_was_renamed: Got rename message for sharepath %s, new name %s, "
2108
"dev %x, inode %.0f\n",
2109
sharepath, newname, (unsigned int)dev, (double)inode ));
2111
for(fsp = file_find_di_first(dev, inode); fsp; fsp = file_find_di_next(fsp)) {
2112
if (memcmp(fsp->conn->connectpath, sharepath, sp_len) == 0) {
2113
DEBUG(10,("msg_file_was_renamed: renaming file fnum %d from %s -> %s\n",
2114
fsp->fnum, fsp->fsp_name, newname ));
2115
string_set(&fsp->fsp_name, newname);
2118
/* Now we have the complete path we can work out if this is
2119
actually within this share and adjust newname accordingly. */
2120
DEBUG(10,("msg_file_was_renamed: share mismatch (sharepath %s "
2121
"not sharepath %s) "
2122
"fnum %d from %s -> %s\n",
2123
fsp->conn->connectpath,
added
removed
source/smbd/open.c
