?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r22868: Replace some message_send_pid calls with messaging_send_pid calls. More
[Samba/bb.git] / source3 / smbd / open.c
blob35dc13d86c4ade068bcf7d6c4b2a4c8dc10f472c
1 /*
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
7
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.
12
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.
17
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.
21 */
22
23 #include "includes.h"
24
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;
30
31 struct deferred_open_record {
32 BOOL delayed_for_oplocks;
33 SMB_DEV_T dev;
34 SMB_INO_T inode;
35 };
36
37 /****************************************************************************
38 fd support routines - attempt to do a dos_open.
39 ****************************************************************************/
40
41 static NTSTATUS fd_open(struct connection_struct *conn,
42 const char *fname,
43 files_struct *fsp,
44 int flags,
45 mode_t mode)
46 {
47 NTSTATUS status = NT_STATUS_OK;
48
49 #ifdef O_NOFOLLOW
50 if (!lp_symlinks(SNUM(conn))) {
51 flags |= O_NOFOLLOW;
52 }
53 #endif
54
55 fsp->fh->fd = SMB_VFS_OPEN(conn,fname,fsp,flags,mode);
56 if (fsp->fh->fd == -1) {
57 status = map_nt_error_from_unix(errno);
58 }
59
60 DEBUG(10,("fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s\n",
61 fname, flags, (int)mode, fsp->fh->fd,
62 (fsp->fh->fd == -1) ? strerror(errno) : "" ));
63
64 return status;
65 }
66
67 /****************************************************************************
68 Close the file associated with a fsp.
69 ****************************************************************************/
70
71 NTSTATUS fd_close(struct connection_struct *conn, files_struct *fsp)
72 {
73 if (fsp->fh->fd == -1) {
74 return NT_STATUS_OK; /* What we used to call a stat open. */
75 }
76 if (fsp->fh->ref_count > 1) {
77 return NT_STATUS_OK; /* Shared handle. Only close last reference. */
78 }
79 return fd_close_posix(conn, fsp);
80 }
81
82 /****************************************************************************
83 Change the ownership of a file to that of the parent directory.
84 Do this by fd if possible.
85 ****************************************************************************/
86
87 static void change_file_owner_to_parent(connection_struct *conn,
88 const char *inherit_from_dir,
89 files_struct *fsp)
90 {
91 SMB_STRUCT_STAT parent_st;
92 int ret;
93
94 ret = SMB_VFS_STAT(conn, inherit_from_dir, &parent_st);
95 if (ret == -1) {
96 DEBUG(0,("change_file_owner_to_parent: failed to stat parent "
97 "directory %s. Error was %s\n",
98 inherit_from_dir, strerror(errno) ));
99 return;
100 }
101
102 become_root();
103 ret = SMB_VFS_FCHOWN(fsp, fsp->fh->fd, parent_st.st_uid, (gid_t)-1);
104 unbecome_root();
105 if (ret == -1) {
106 DEBUG(0,("change_file_owner_to_parent: failed to fchown "
107 "file %s to parent directory uid %u. Error "
108 "was %s\n", fsp->fsp_name,
109 (unsigned int)parent_st.st_uid,
110 strerror(errno) ));
111 }
112
113 DEBUG(10,("change_file_owner_to_parent: changed new file %s to "
114 "parent directory uid %u.\n", fsp->fsp_name,
115 (unsigned int)parent_st.st_uid ));
116 }
117
118 static void change_dir_owner_to_parent(connection_struct *conn,
119 const char *inherit_from_dir,
120 const char *fname,
121 SMB_STRUCT_STAT *psbuf)
122 {
123 pstring saved_dir;
124 SMB_STRUCT_STAT sbuf;
125 SMB_STRUCT_STAT parent_st;
126 int ret;
127
128 ret = SMB_VFS_STAT(conn, inherit_from_dir, &parent_st);
129 if (ret == -1) {
130 DEBUG(0,("change_dir_owner_to_parent: failed to stat parent "
131 "directory %s. Error was %s\n",
132 inherit_from_dir, strerror(errno) ));
133 return;
134 }
135
136 /* We've already done an lstat into psbuf, and we know it's a
137 directory. If we can cd into the directory and the dev/ino
138 are the same then we can safely chown without races as
139 we're locking the directory in place by being in it. This
140 should work on any UNIX (thanks tridge :-). JRA.
141 */
142
143 if (!vfs_GetWd(conn,saved_dir)) {
144 DEBUG(0,("change_dir_owner_to_parent: failed to get "
145 "current working directory\n"));
146 return;
147 }
148
149 /* Chdir into the new path. */
150 if (vfs_ChDir(conn, fname) == -1) {
151 DEBUG(0,("change_dir_owner_to_parent: failed to change "
152 "current working directory to %s. Error "
153 "was %s\n", fname, strerror(errno) ));
154 goto out;
155 }
156
157 if (SMB_VFS_STAT(conn,".",&sbuf) == -1) {
158 DEBUG(0,("change_dir_owner_to_parent: failed to stat "
159 "directory '.' (%s) Error was %s\n",
160 fname, strerror(errno)));
161 goto out;
162 }
163
164 /* Ensure we're pointing at the same place. */
165 if (sbuf.st_dev != psbuf->st_dev ||
166 sbuf.st_ino != psbuf->st_ino ||
167 sbuf.st_mode != psbuf->st_mode ) {
168 DEBUG(0,("change_dir_owner_to_parent: "
169 "device/inode/mode on directory %s changed. "
170 "Refusing to chown !\n", fname ));
171 goto out;
172 }
173
174 become_root();
175 ret = SMB_VFS_CHOWN(conn, ".", parent_st.st_uid, (gid_t)-1);
176 unbecome_root();
177 if (ret == -1) {
178 DEBUG(10,("change_dir_owner_to_parent: failed to chown "
179 "directory %s to parent directory uid %u. "
180 "Error was %s\n", fname,
181 (unsigned int)parent_st.st_uid, strerror(errno) ));
182 goto out;
183 }
184
185 DEBUG(10,("change_dir_owner_to_parent: changed ownership of new "
186 "directory %s to parent directory uid %u.\n",
187 fname, (unsigned int)parent_st.st_uid ));
188
189 out:
190
191 vfs_ChDir(conn,saved_dir);
192 }
193
194 /****************************************************************************
195 Open a file.
196 ****************************************************************************/
197
198 static NTSTATUS open_file(files_struct *fsp,
199 connection_struct *conn,
200 const char *parent_dir,
201 const char *name,
202 const char *path,
203 SMB_STRUCT_STAT *psbuf,
204 int flags,
205 mode_t unx_mode,
206 uint32 access_mask, /* client requested access mask. */
207 uint32 open_access_mask) /* what we're actually using in the open. */
208 {
209 NTSTATUS status = NT_STATUS_OK;
210 int accmode = (flags & O_ACCMODE);
211 int local_flags = flags;
212 BOOL file_existed = VALID_STAT(*psbuf);
213
214 fsp->fh->fd = -1;
215 errno = EPERM;
216
217 /* Check permissions */
218
219 /*
220 * This code was changed after seeing a client open request
221 * containing the open mode of (DENY_WRITE/read-only) with
222 * the 'create if not exist' bit set. The previous code
223 * would fail to open the file read only on a read-only share
224 * as it was checking the flags parameter directly against O_RDONLY,
225 * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
226 * JRA.
227 */
228
229 if (!CAN_WRITE(conn)) {
230 /* It's a read-only share - fail if we wanted to write. */
231 if(accmode != O_RDONLY) {
232 DEBUG(3,("Permission denied opening %s\n", path));
233 return NT_STATUS_ACCESS_DENIED;
234 } else if(flags & O_CREAT) {
235 /* We don't want to write - but we must make sure that
236 O_CREAT doesn't create the file if we have write
237 access into the directory.
238 */
239 flags &= ~O_CREAT;
240 local_flags &= ~O_CREAT;
241 }
242 }
243
244 /*
245 * This little piece of insanity is inspired by the
246 * fact that an NT client can open a file for O_RDONLY,
247 * but set the create disposition to FILE_EXISTS_TRUNCATE.
248 * If the client *can* write to the file, then it expects to
249 * truncate the file, even though it is opening for readonly.
250 * Quicken uses this stupid trick in backup file creation...
251 * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
252 * for helping track this one down. It didn't bite us in 2.0.x
253 * as we always opened files read-write in that release. JRA.
254 */
255
256 if ((accmode == O_RDONLY) && ((flags & O_TRUNC) == O_TRUNC)) {
257 DEBUG(10,("open_file: truncate requested on read-only open "
258 "for file %s\n", path));
259 local_flags = (flags & ~O_ACCMODE)|O_RDWR;
260 }
261
262 if ((open_access_mask & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ||
263 (!file_existed && (local_flags & O_CREAT)) ||
264 ((local_flags & O_TRUNC) == O_TRUNC) ) {
265
266 /*
267 * We can't actually truncate here as the file may be locked.
268 * open_file_ntcreate will take care of the truncate later. JRA.
269 */
270
271 local_flags &= ~O_TRUNC;
272
273 #if defined(O_NONBLOCK) && defined(S_ISFIFO)
274 /*
275 * We would block on opening a FIFO with no one else on the
276 * other end. Do what we used to do and add O_NONBLOCK to the
277 * open flags. JRA.
278 */
279
280 if (file_existed && S_ISFIFO(psbuf->st_mode)) {
281 local_flags |= O_NONBLOCK;
282 }
283 #endif
284
285 /* Don't create files with Microsoft wildcard characters. */
286 if ((local_flags & O_CREAT) && !file_existed &&
287 ms_has_wild(path)) {
288 return NT_STATUS_OBJECT_NAME_INVALID;
289 }
290
291 /* Actually do the open */
292 status = fd_open(conn, path, fsp, local_flags, unx_mode);
293 if (!NT_STATUS_IS_OK(status)) {
294 DEBUG(3,("Error opening file %s (%s) (local_flags=%d) "
295 "(flags=%d)\n",
296 path,nt_errstr(status),local_flags,flags));
297 return status;
298 }
299
300 if ((local_flags & O_CREAT) && !file_existed) {
301
302 /* Inherit the ACL if required */
303 if (lp_inherit_perms(SNUM(conn))) {
304 inherit_access_acl(conn, parent_dir, path,
305 unx_mode);
306 }
307
308 /* Change the owner if required. */
309 if (lp_inherit_owner(SNUM(conn))) {
310 change_file_owner_to_parent(conn, parent_dir,
311 fsp);
312 }
313
314 notify_fname(conn, NOTIFY_ACTION_ADDED,
315 FILE_NOTIFY_CHANGE_FILE_NAME, path);
316 }
317
318 } else {
319 fsp->fh->fd = -1; /* What we used to call a stat open. */
320 }
321
322 if (!file_existed) {
323 int ret;
324
325 if (fsp->fh->fd == -1) {
326 ret = SMB_VFS_STAT(conn, path, psbuf);
327 } else {
328 ret = SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf);
329 /* If we have an fd, this stat should succeed. */
330 if (ret == -1) {
331 DEBUG(0,("Error doing fstat on open file %s "
332 "(%s)\n", path,strerror(errno) ));
333 }
334 }
335
336 /* For a non-io open, this stat failing means file not found. JRA */
337 if (ret == -1) {
338 status = map_nt_error_from_unix(errno);
339 fd_close(conn, fsp);
340 return status;
341 }
342 }
343
344 /*
345 * POSIX allows read-only opens of directories. We don't
346 * want to do this (we use a different code path for this)
347 * so catch a directory open and return an EISDIR. JRA.
348 */
349
350 if(S_ISDIR(psbuf->st_mode)) {
351 fd_close(conn, fsp);
352 errno = EISDIR;
353 return NT_STATUS_FILE_IS_A_DIRECTORY;
354 }
355
356 fsp->mode = psbuf->st_mode;
357 fsp->inode = psbuf->st_ino;
358 fsp->dev = psbuf->st_dev;
359 fsp->vuid = current_user.vuid;
360 fsp->file_pid = global_smbpid;
361 fsp->can_lock = True;
362 fsp->can_read = (access_mask & (FILE_READ_DATA)) ? True : False;
363 if (!CAN_WRITE(conn)) {
364 fsp->can_write = False;
365 } else {
366 fsp->can_write = (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) ?
367 True : False;
368 }
369 fsp->print_file = False;
370 fsp->modified = False;
371 fsp->sent_oplock_break = NO_BREAK_SENT;
372 fsp->is_directory = False;
373 fsp->is_stat = False;
374
375 string_set(&fsp->fsp_name, path);
376 fsp->wcp = NULL; /* Write cache pointer. */
377
378 DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
379 *current_user_info.smb_name ?
380 current_user_info.smb_name : conn->user,fsp->fsp_name,
381 BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
382 conn->num_files_open + 1));
383
384 errno = 0;
385 return NT_STATUS_OK;
386 }
387
388 /*******************************************************************
389 Return True if the filename is one of the special executable types.
390 ********************************************************************/
391
392 static BOOL is_executable(const char *fname)
393 {
394 if ((fname = strrchr_m(fname,'.'))) {
395 if (strequal(fname,".com") ||
396 strequal(fname,".dll") ||
397 strequal(fname,".exe") ||
398 strequal(fname,".sym")) {
399 return True;
400 }
401 }
402 return False;
403 }
404
405 /****************************************************************************
406 Check if we can open a file with a share mode.
407 Returns True if conflict, False if not.
408 ****************************************************************************/
409
410 static BOOL share_conflict(struct share_mode_entry *entry,
411 uint32 access_mask,
412 uint32 share_access)
413 {
414 DEBUG(10,("share_conflict: entry->access_mask = 0x%x, "
415 "entry->share_access = 0x%x, "
416 "entry->private_options = 0x%x\n",
417 (unsigned int)entry->access_mask,
418 (unsigned int)entry->share_access,
419 (unsigned int)entry->private_options));
420
421 DEBUG(10,("share_conflict: access_mask = 0x%x, share_access = 0x%x\n",
422 (unsigned int)access_mask, (unsigned int)share_access));
423
424 if ((entry->access_mask & (FILE_WRITE_DATA|
425 FILE_APPEND_DATA|
426 FILE_READ_DATA|
427 FILE_EXECUTE|
428 DELETE_ACCESS)) == 0) {
429 DEBUG(10,("share_conflict: No conflict due to "
430 "entry->access_mask = 0x%x\n",
431 (unsigned int)entry->access_mask ));
432 return False;
433 }
434
435 if ((access_mask & (FILE_WRITE_DATA|
436 FILE_APPEND_DATA|
437 FILE_READ_DATA|
438 FILE_EXECUTE|
439 DELETE_ACCESS)) == 0) {
440 DEBUG(10,("share_conflict: No conflict due to "
441 "access_mask = 0x%x\n",
442 (unsigned int)access_mask ));
443 return False;
444 }
445
446 #if 1 /* JRA TEST - Superdebug. */
447 #define CHECK_MASK(num, am, right, sa, share) \
448 DEBUG(10,("share_conflict: [%d] am (0x%x) & right (0x%x) = 0x%x\n", \
449 (unsigned int)(num), (unsigned int)(am), \
450 (unsigned int)(right), (unsigned int)(am)&(right) )); \
451 DEBUG(10,("share_conflict: [%d] sa (0x%x) & share (0x%x) = 0x%x\n", \
452 (unsigned int)(num), (unsigned int)(sa), \
453 (unsigned int)(share), (unsigned int)(sa)&(share) )); \
454 if (((am) & (right)) && !((sa) & (share))) { \
455 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
456 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
457 (unsigned int)(share) )); \
458 return True; \
459 }
460 #else
461 #define CHECK_MASK(num, am, right, sa, share) \
462 if (((am) & (right)) && !((sa) & (share))) { \
463 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
464 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
465 (unsigned int)(share) )); \
466 return True; \
467 }
468 #endif
469
470 CHECK_MASK(1, entry->access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
471 share_access, FILE_SHARE_WRITE);
472 CHECK_MASK(2, access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
473 entry->share_access, FILE_SHARE_WRITE);
474
475 CHECK_MASK(3, entry->access_mask, FILE_READ_DATA | FILE_EXECUTE,
476 share_access, FILE_SHARE_READ);
477 CHECK_MASK(4, access_mask, FILE_READ_DATA | FILE_EXECUTE,
478 entry->share_access, FILE_SHARE_READ);
479
480 CHECK_MASK(5, entry->access_mask, DELETE_ACCESS,
481 share_access, FILE_SHARE_DELETE);
482 CHECK_MASK(6, access_mask, DELETE_ACCESS,
483 entry->share_access, FILE_SHARE_DELETE);
484
485 DEBUG(10,("share_conflict: No conflict.\n"));
486 return False;
487 }
488
489 #if defined(DEVELOPER)
490 static void validate_my_share_entries(int num,
491 struct share_mode_entry *share_entry)
492 {
493 files_struct *fsp;
494
495 if (!procid_is_me(&share_entry->pid)) {
496 return;
497 }
498
499 if (is_deferred_open_entry(share_entry) &&
500 !open_was_deferred(share_entry->op_mid)) {
501 pstring str;
502 pstr_sprintf(str, "Got a deferred entry without a request: "
503 "PANIC: %s\n", share_mode_str(num, share_entry));
504 smb_panic(str);
505 }
506
507 if (!is_valid_share_mode_entry(share_entry)) {
508 return;
509 }
510
511 fsp = file_find_dif(share_entry->dev, share_entry->inode,
512 share_entry->share_file_id);
513 if (!fsp) {
514 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
515 share_mode_str(num, share_entry) ));
516 smb_panic("validate_my_share_entries: Cannot match a "
517 "share entry with an open file\n");
518 }
519
520 if (is_deferred_open_entry(share_entry) ||
521 is_unused_share_mode_entry(share_entry)) {
522 goto panic;
523 }
524
525 if ((share_entry->op_type == NO_OPLOCK) &&
526 (fsp->oplock_type == FAKE_LEVEL_II_OPLOCK)) {
527 /* Someone has already written to it, but I haven't yet
528 * noticed */
529 return;
530 }
531
532 if (((uint16)fsp->oplock_type) != share_entry->op_type) {
533 goto panic;
534 }
535
536 return;
537
538 panic:
539 {
540 pstring str;
541 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
542 share_mode_str(num, share_entry) ));
543 slprintf(str, sizeof(str)-1, "validate_my_share_entries: "
544 "file %s, oplock_type = 0x%x, op_type = 0x%x\n",
545 fsp->fsp_name, (unsigned int)fsp->oplock_type,
546 (unsigned int)share_entry->op_type );
547 smb_panic(str);
548 }
549 }
550 #endif
551
552 static BOOL is_stat_open(uint32 access_mask)
553 {
554 return (access_mask &&
555 ((access_mask & ~(SYNCHRONIZE_ACCESS| FILE_READ_ATTRIBUTES|
556 FILE_WRITE_ATTRIBUTES))==0) &&
557 ((access_mask & (SYNCHRONIZE_ACCESS|FILE_READ_ATTRIBUTES|
558 FILE_WRITE_ATTRIBUTES)) != 0));
559 }
560
561 /****************************************************************************
562 Deal with share modes
563 Invarient: Share mode must be locked on entry and exit.
564 Returns -1 on error, or number of share modes on success (may be zero).
565 ****************************************************************************/
566
567 static NTSTATUS open_mode_check(connection_struct *conn,
568 const char *fname,
569 struct share_mode_lock *lck,
570 uint32 access_mask,
571 uint32 share_access,
572 uint32 create_options,
573 BOOL *file_existed)
574 {
575 int i;
576
577 if(lck->num_share_modes == 0) {
578 return NT_STATUS_OK;
579 }
580
581 *file_existed = True;
582
583 if (is_stat_open(access_mask)) {
584 /* Stat open that doesn't trigger oplock breaks or share mode
585 * checks... ! JRA. */
586 return NT_STATUS_OK;
587 }
588
589 /* A delete on close prohibits everything */
590
591 if (lck->delete_on_close) {
592 return NT_STATUS_DELETE_PENDING;
593 }
594
595 /*
596 * Check if the share modes will give us access.
597 */
598
599 #if defined(DEVELOPER)
600 for(i = 0; i < lck->num_share_modes; i++) {
601 validate_my_share_entries(i, &lck->share_modes[i]);
602 }
603 #endif
604
605 if (!lp_share_modes(SNUM(conn))) {
606 return NT_STATUS_OK;
607 }
608
609 /* Now we check the share modes, after any oplock breaks. */
610 for(i = 0; i < lck->num_share_modes; i++) {
611
612 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
613 continue;
614 }
615
616 /* someone else has a share lock on it, check to see if we can
617 * too */
618 if (share_conflict(&lck->share_modes[i],
619 access_mask, share_access)) {
620 return NT_STATUS_SHARING_VIOLATION;
621 }
622 }
623
624 return NT_STATUS_OK;
625 }
626
627 static BOOL is_delete_request(files_struct *fsp) {
628 return ((fsp->access_mask == DELETE_ACCESS) &&
629 (fsp->oplock_type == NO_OPLOCK));
630 }
631
632 /*
633 * 1) No files open at all or internal open: Grant whatever the client wants.
634 *
635 * 2) Exclusive (or batch) oplock around: If the requested access is a delete
636 * request, break if the oplock around is a batch oplock. If it's another
637 * requested access type, break.
638 *
639 * 3) Only level2 around: Grant level2 and do nothing else.
640 */
641
642 static BOOL delay_for_oplocks(struct share_mode_lock *lck,
643 files_struct *fsp,
644 int pass_number,
645 int oplock_request)
646 {
647 int i;
648 struct share_mode_entry *exclusive = NULL;
649 BOOL valid_entry = False;
650 BOOL delay_it = False;
651 BOOL have_level2 = False;
652 NTSTATUS status;
653 char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
654
655 if (oplock_request & INTERNAL_OPEN_ONLY) {
656 fsp->oplock_type = NO_OPLOCK;
657 }
658
659 if ((oplock_request & INTERNAL_OPEN_ONLY) || is_stat_open(fsp->access_mask)) {
660 return False;
661 }
662
663 for (i=0; i<lck->num_share_modes; i++) {
664
665 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
666 continue;
667 }
668
669 /* At least one entry is not an invalid or deferred entry. */
670 valid_entry = True;
671
672 if (pass_number == 1) {
673 if (BATCH_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
674 SMB_ASSERT(exclusive == NULL);
675 exclusive = &lck->share_modes[i];
676 }
677 } else {
678 if (EXCLUSIVE_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
679 SMB_ASSERT(exclusive == NULL);
680 exclusive = &lck->share_modes[i];
681 }
682 }
683
684 if (lck->share_modes[i].op_type == LEVEL_II_OPLOCK) {
685 SMB_ASSERT(exclusive == NULL);
686 have_level2 = True;
687 }
688 }
689
690 if (!valid_entry) {
691 /* All entries are placeholders or deferred.
692 * Directly grant whatever the client wants. */
693 if (fsp->oplock_type == NO_OPLOCK) {
694 /* Store a level2 oplock, but don't tell the client */
695 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
696 }
697 return False;
698 }
699
700 if (exclusive != NULL) { /* Found an exclusive oplock */
701 SMB_ASSERT(!have_level2);
702 delay_it = is_delete_request(fsp) ?
703 BATCH_OPLOCK_TYPE(exclusive->op_type) : True;
704 }
705
706 if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
707 /* We can at most grant level2 as there are other
708 * level2 or NO_OPLOCK entries. */
709 fsp->oplock_type = LEVEL_II_OPLOCK;
710 }
711
712 if ((fsp->oplock_type == NO_OPLOCK) && have_level2) {
713 /* Store a level2 oplock, but don't tell the client */
714 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
715 }
716
717 if (!delay_it) {
718 return False;
719 }
720
721 /*
722 * Send a break message to the oplock holder and delay the open for
723 * our client.
724 */
725
726 DEBUG(10, ("Sending break request to PID %s\n",
727 procid_str_static(&exclusive->pid)));
728 exclusive->op_mid = get_current_mid();
729
730 /* Create the message. */
731 share_mode_entry_to_message(msg, exclusive);
732
733 /* Add in the FORCE_OPLOCK_BREAK_TO_NONE bit in the message if set. We
734 don't want this set in the share mode struct pointed to by lck. */
735
736 if (oplock_request & FORCE_OPLOCK_BREAK_TO_NONE) {
737 SSVAL(msg,6,exclusive->op_type | FORCE_OPLOCK_BREAK_TO_NONE);
738 }
739
740 status = messaging_send_buf(smbd_messaging_context(), exclusive->pid,
741 MSG_SMB_BREAK_REQUEST,
742 (uint8 *)msg,
743 MSG_SMB_SHARE_MODE_ENTRY_SIZE);
744 if (!NT_STATUS_IS_OK(status)) {
745 DEBUG(3, ("Could not send oplock break message: %s\n",
746 nt_errstr(status)));
747 }
748
749 return True;
750 }
751
752 static BOOL request_timed_out(struct timeval request_time,
753 struct timeval timeout)
754 {
755 struct timeval now, end_time;
756 GetTimeOfDay(&now);
757 end_time = timeval_sum(&request_time, &timeout);
758 return (timeval_compare(&end_time, &now) < 0);
759 }
760
761 /****************************************************************************
762 Handle the 1 second delay in returning a SHARING_VIOLATION error.
763 ****************************************************************************/
764
765 static void defer_open(struct share_mode_lock *lck,
766 struct timeval request_time,
767 struct timeval timeout,
768 struct deferred_open_record *state)
769 {
770 uint16 mid = get_current_mid();
771 int i;
772
773 /* Paranoia check */
774
775 for (i=0; i<lck->num_share_modes; i++) {
776 struct share_mode_entry *e = &lck->share_modes[i];
777
778 if (!is_deferred_open_entry(e)) {
779 continue;
780 }
781
782 if (procid_is_me(&e->pid) && (e->op_mid == mid)) {
783 DEBUG(0, ("Trying to defer an already deferred "
784 "request: mid=%d, exiting\n", mid));
785 exit_server("attempt to defer a deferred request");
786 }
787 }
788
789 /* End paranoia check */
790
791 DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred "
792 "open entry for mid %u\n",
793 (unsigned int)request_time.tv_sec,
794 (unsigned int)request_time.tv_usec,
795 (unsigned int)mid));
796
797 if (!push_deferred_smb_message(mid, request_time, timeout,
798 (char *)state, sizeof(*state))) {
799 exit_server("push_deferred_smb_message failed");
800 }
801 add_deferred_open(lck, mid, request_time, state->dev, state->inode);
802
803 /*
804 * Push the MID of this packet on the signing queue.
805 * We only do this once, the first time we push the packet
806 * onto the deferred open queue, as this has a side effect
807 * of incrementing the response sequence number.
808 */
809
810 srv_defer_sign_response(mid);
811 }
812
813
814 /****************************************************************************
815 On overwrite open ensure that the attributes match.
816 ****************************************************************************/
817
818 static BOOL open_match_attributes(connection_struct *conn,
819 const char *path,
820 uint32 old_dos_attr,
821 uint32 new_dos_attr,
822 mode_t existing_unx_mode,
823 mode_t new_unx_mode,
824 mode_t *returned_unx_mode)
825 {
826 uint32 noarch_old_dos_attr, noarch_new_dos_attr;
827
828 noarch_old_dos_attr = (old_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
829 noarch_new_dos_attr = (new_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
830
831 if((noarch_old_dos_attr == 0 && noarch_new_dos_attr != 0) ||
832 (noarch_old_dos_attr != 0 && ((noarch_old_dos_attr & noarch_new_dos_attr) == noarch_old_dos_attr))) {
833 *returned_unx_mode = new_unx_mode;
834 } else {
835 *returned_unx_mode = (mode_t)0;
836 }
837
838 DEBUG(10,("open_match_attributes: file %s old_dos_attr = 0x%x, "
839 "existing_unx_mode = 0%o, new_dos_attr = 0x%x "
840 "returned_unx_mode = 0%o\n",
841 path,
842 (unsigned int)old_dos_attr,
843 (unsigned int)existing_unx_mode,
844 (unsigned int)new_dos_attr,
845 (unsigned int)*returned_unx_mode ));
846
847 /* If we're mapping SYSTEM and HIDDEN ensure they match. */
848 if (lp_map_system(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
849 if ((old_dos_attr & FILE_ATTRIBUTE_SYSTEM) &&
850 !(new_dos_attr & FILE_ATTRIBUTE_SYSTEM)) {
851 return False;
852 }
853 }
854 if (lp_map_hidden(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
855 if ((old_dos_attr & FILE_ATTRIBUTE_HIDDEN) &&
856 !(new_dos_attr & FILE_ATTRIBUTE_HIDDEN)) {
857 return False;
858 }
859 }
860 return True;
861 }
862
863 /****************************************************************************
864 Special FCB or DOS processing in the case of a sharing violation.
865 Try and find a duplicated file handle.
866 ****************************************************************************/
867
868 static files_struct *fcb_or_dos_open(connection_struct *conn,
869 const char *fname, SMB_DEV_T dev,
870 SMB_INO_T inode,
871 uint32 access_mask,
872 uint32 share_access,
873 uint32 create_options)
874 {
875 files_struct *fsp;
876 files_struct *dup_fsp;
877
878 DEBUG(5,("fcb_or_dos_open: attempting old open semantics for "
879 "file %s.\n", fname ));
880
881 for(fsp = file_find_di_first(dev, inode); fsp;
882 fsp = file_find_di_next(fsp)) {
883
884 DEBUG(10,("fcb_or_dos_open: checking file %s, fd = %d, "
885 "vuid = %u, file_pid = %u, private_options = 0x%x "
886 "access_mask = 0x%x\n", fsp->fsp_name,
887 fsp->fh->fd, (unsigned int)fsp->vuid,
888 (unsigned int)fsp->file_pid,
889 (unsigned int)fsp->fh->private_options,
890 (unsigned int)fsp->access_mask ));
891
892 if (fsp->fh->fd != -1 &&
893 fsp->vuid == current_user.vuid &&
894 fsp->file_pid == global_smbpid &&
895 (fsp->fh->private_options & (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS |
896 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) &&
897 (fsp->access_mask & FILE_WRITE_DATA) &&
898 strequal(fsp->fsp_name, fname)) {
899 DEBUG(10,("fcb_or_dos_open: file match\n"));
900 break;
901 }
902 }
903
904 if (!fsp) {
905 return NULL;
906 }
907
908 /* quite an insane set of semantics ... */
909 if (is_executable(fname) &&
910 (fsp->fh->private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS)) {
911 DEBUG(10,("fcb_or_dos_open: file fail due to is_executable.\n"));
912 return NULL;
913 }
914
915 /* We need to duplicate this fsp. */
916 if (!NT_STATUS_IS_OK(dup_file_fsp(fsp, access_mask, share_access,
917 create_options, &dup_fsp))) {
918 return NULL;
919 }
920
921 return dup_fsp;
922 }
923
924 /****************************************************************************
925 Open a file with a share mode - old openX method - map into NTCreate.
926 ****************************************************************************/
927
928 BOOL map_open_params_to_ntcreate(const char *fname, int deny_mode, int open_func,
929 uint32 *paccess_mask,
930 uint32 *pshare_mode,
931 uint32 *pcreate_disposition,
932 uint32 *pcreate_options)
933 {
934 uint32 access_mask;
935 uint32 share_mode;
936 uint32 create_disposition;
937 uint32 create_options = 0;
938
939 DEBUG(10,("map_open_params_to_ntcreate: fname = %s, deny_mode = 0x%x, "
940 "open_func = 0x%x\n",
941 fname, (unsigned int)deny_mode, (unsigned int)open_func ));
942
943 /* Create the NT compatible access_mask. */
944 switch (GET_OPENX_MODE(deny_mode)) {
945 case DOS_OPEN_EXEC: /* Implies read-only - used to be FILE_READ_DATA */
946 case DOS_OPEN_RDONLY:
947 access_mask = FILE_GENERIC_READ;
948 break;
949 case DOS_OPEN_WRONLY:
950 access_mask = FILE_GENERIC_WRITE;
951 break;
952 case DOS_OPEN_RDWR:
953 case DOS_OPEN_FCB:
954 access_mask = FILE_GENERIC_READ|FILE_GENERIC_WRITE;
955 break;
956 default:
957 DEBUG(10,("map_open_params_to_ntcreate: bad open mode = 0x%x\n",
958 (unsigned int)GET_OPENX_MODE(deny_mode)));
959 return False;
960 }
961
962 /* Create the NT compatible create_disposition. */
963 switch (open_func) {
964 case OPENX_FILE_EXISTS_FAIL|OPENX_FILE_CREATE_IF_NOT_EXIST:
965 create_disposition = FILE_CREATE;
966 break;
967
968 case OPENX_FILE_EXISTS_OPEN:
969 create_disposition = FILE_OPEN;
970 break;
971
972 case OPENX_FILE_EXISTS_OPEN|OPENX_FILE_CREATE_IF_NOT_EXIST:
973 create_disposition = FILE_OPEN_IF;
974 break;
975
976 case OPENX_FILE_EXISTS_TRUNCATE:
977 create_disposition = FILE_OVERWRITE;
978 break;
979
980 case OPENX_FILE_EXISTS_TRUNCATE|OPENX_FILE_CREATE_IF_NOT_EXIST:
981 create_disposition = FILE_OVERWRITE_IF;
982 break;
983
984 default:
985 /* From samba4 - to be confirmed. */
986 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_EXEC) {
987 create_disposition = FILE_CREATE;
988 break;
989 }
990 DEBUG(10,("map_open_params_to_ntcreate: bad "
991 "open_func 0x%x\n", (unsigned int)open_func));
992 return False;
993 }
994
995 /* Create the NT compatible share modes. */
996 switch (GET_DENY_MODE(deny_mode)) {
997 case DENY_ALL:
998 share_mode = FILE_SHARE_NONE;
999 break;
1000
1001 case DENY_WRITE:
1002 share_mode = FILE_SHARE_READ;
1003 break;
1004
1005 case DENY_READ:
1006 share_mode = FILE_SHARE_WRITE;
1007 break;
1008
1009 case DENY_NONE:
1010 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
1011 break;
1012
1013 case DENY_DOS:
1014 create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
1015 if (is_executable(fname)) {
1016 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
1017 } else {
1018 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_RDONLY) {
1019 share_mode = FILE_SHARE_READ;
1020 } else {
1021 share_mode = FILE_SHARE_NONE;
1022 }
1023 }
1024 break;
1025
1026 case DENY_FCB:
1027 create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
1028 share_mode = FILE_SHARE_NONE;
1029 break;
1030
1031 default:
1032 DEBUG(10,("map_open_params_to_ntcreate: bad deny_mode 0x%x\n",
1033 (unsigned int)GET_DENY_MODE(deny_mode) ));
1034 return False;
1035 }
1036
1037 DEBUG(10,("map_open_params_to_ntcreate: file %s, access_mask = 0x%x, "
1038 "share_mode = 0x%x, create_disposition = 0x%x, "
1039 "create_options = 0x%x\n",
1040 fname,
1041 (unsigned int)access_mask,
1042 (unsigned int)share_mode,
1043 (unsigned int)create_disposition,
1044 (unsigned int)create_options ));
1045
1046 if (paccess_mask) {
1047 *paccess_mask = access_mask;
1048 }
1049 if (pshare_mode) {
1050 *pshare_mode = share_mode;
1051 }
1052 if (pcreate_disposition) {
1053 *pcreate_disposition = create_disposition;
1054 }
1055 if (pcreate_options) {
1056 *pcreate_options = create_options;
1057 }
1058
1059 return True;
1060
1061 }
1062
1063 static void schedule_defer_open(struct share_mode_lock *lck, struct timeval request_time)
1064 {
1065 struct deferred_open_record state;
1066
1067 /* This is a relative time, added to the absolute
1068 request_time value to get the absolute timeout time.
1069 Note that if this is the second or greater time we enter
1070 this codepath for this particular request mid then
1071 request_time is left as the absolute time of the *first*
1072 time this request mid was processed. This is what allows
1073 the request to eventually time out. */
1074
1075 struct timeval timeout;
1076
1077 /* Normally the smbd we asked should respond within
1078 * OPLOCK_BREAK_TIMEOUT seconds regardless of whether
1079 * the client did, give twice the timeout as a safety
1080 * measure here in case the other smbd is stuck
1081 * somewhere else. */
1082
1083 timeout = timeval_set(OPLOCK_BREAK_TIMEOUT*2, 0);
1084
1085 /* Nothing actually uses state.delayed_for_oplocks
1086 but it's handy to differentiate in debug messages
1087 between a 30 second delay due to oplock break, and
1088 a 1 second delay for share mode conflicts. */
1089
1090 state.delayed_for_oplocks = True;
1091 state.dev = lck->dev;
1092 state.inode = lck->ino;
1093
1094 if (!request_timed_out(request_time, timeout)) {
1095 defer_open(lck, request_time, timeout, &state);
1096 }
1097 }
1098
1099 /****************************************************************************
1100 Open a file with a share mode.
1101 ****************************************************************************/
1102
1103 NTSTATUS open_file_ntcreate(connection_struct *conn,
1104 const char *fname,
1105 SMB_STRUCT_STAT *psbuf,
1106 uint32 access_mask, /* access bits (FILE_READ_DATA etc.) */
1107 uint32 share_access, /* share constants (FILE_SHARE_READ etc) */
1108 uint32 create_disposition, /* FILE_OPEN_IF etc. */
1109 uint32 create_options, /* options such as delete on close. */
1110 uint32 new_dos_attributes, /* attributes used for new file. */
1111 int oplock_request, /* internal Samba oplock codes. */
1112 /* Information (FILE_EXISTS etc.) */
1113 int *pinfo,
1114 files_struct **result)
1115 {
1116 int flags=0;
1117 int flags2=0;
1118 BOOL file_existed = VALID_STAT(*psbuf);
1119 BOOL def_acl = False;
1120 BOOL posix_open = False;
1121 SMB_DEV_T dev = 0;
1122 SMB_INO_T inode = 0;
1123 NTSTATUS fsp_open = NT_STATUS_ACCESS_DENIED;
1124 files_struct *fsp = NULL;
1125 mode_t new_unx_mode = (mode_t)0;
1126 mode_t unx_mode = (mode_t)0;
1127 int info;
1128 uint32 existing_dos_attributes = 0;
1129 struct pending_message_list *pml = NULL;
1130 uint16 mid = get_current_mid();
1131 struct timeval request_time = timeval_zero();
1132 struct share_mode_lock *lck = NULL;
1133 uint32 open_access_mask = access_mask;
1134 NTSTATUS status;
1135 int ret_flock;
1136 char *parent_dir;
1137 const char *newname;
1138
1139 if (conn->printer) {
1140 /*
1141 * Printers are handled completely differently.
1142 * Most of the passed parameters are ignored.
1143 */
1144
1145 if (pinfo) {
1146 *pinfo = FILE_WAS_CREATED;
1147 }
1148
1149 DEBUG(10, ("open_file_ntcreate: printer open fname=%s\n", fname));
1150
1151 return print_fsp_open(conn, fname, result);
1152 }
1153
1154 if (!parent_dirname_talloc(tmp_talloc_ctx(), fname, &parent_dir,
1155 &newname)) {
1156 return NT_STATUS_NO_MEMORY;
1157 }
1158
1159 if (new_dos_attributes & FILE_FLAG_POSIX_SEMANTICS) {
1160 posix_open = True;
1161 unx_mode = (mode_t)(new_dos_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
1162 new_dos_attributes = 0;
1163 } else {
1164 /* We add aARCH to this as this mode is only used if the file is
1165 * created new. */
1166 unx_mode = unix_mode(conn, new_dos_attributes | aARCH, fname,
1167 parent_dir);
1168 }
1169
1170 DEBUG(10, ("open_file_ntcreate: fname=%s, dos_attrs=0x%x "
1171 "access_mask=0x%x share_access=0x%x "
1172 "create_disposition = 0x%x create_options=0x%x "
1173 "unix mode=0%o oplock_request=%d\n",
1174 fname, new_dos_attributes, access_mask, share_access,
1175 create_disposition, create_options, unx_mode,
1176 oplock_request));
1177
1178 if ((pml = get_open_deferred_message(mid)) != NULL) {
1179 struct deferred_open_record *state =
1180 (struct deferred_open_record *)pml->private_data.data;
1181
1182 /* Remember the absolute time of the original
1183 request with this mid. We'll use it later to
1184 see if this has timed out. */
1185
1186 request_time = pml->request_time;
1187
1188 /* Remove the deferred open entry under lock. */
1189 lck = get_share_mode_lock(NULL, state->dev, state->inode, NULL, NULL);
1190 if (lck == NULL) {
1191 DEBUG(0, ("could not get share mode lock\n"));
1192 } else {
1193 del_deferred_open_entry(lck, mid);
1194 TALLOC_FREE(lck);
1195 }
1196
1197 /* Ensure we don't reprocess this message. */
1198 remove_deferred_open_smb_message(mid);
1199 }
1200
1201 status = check_name(conn, fname);
1202 if (!NT_STATUS_IS_OK(status)) {
1203 return status;
1204 }
1205
1206 if (!posix_open) {
1207 new_dos_attributes &= SAMBA_ATTRIBUTES_MASK;
1208 if (file_existed) {
1209 existing_dos_attributes = dos_mode(conn, fname, psbuf);
1210 }
1211 }
1212
1213 /* ignore any oplock requests if oplocks are disabled */
1214 if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break ||
1215 IS_VETO_OPLOCK_PATH(conn, fname)) {
1216 /* Mask off everything except the private Samba bits. */
1217 oplock_request &= SAMBA_PRIVATE_OPLOCK_MASK;
1218 }
1219
1220 /* this is for OS/2 long file names - say we don't support them */
1221 if (!lp_posix_pathnames() && strstr(fname,".+,;=[].")) {
1222 /* OS/2 Workplace shell fix may be main code stream in a later
1223 * release. */
1224 DEBUG(5,("open_file_ntcreate: OS/2 long filenames are not "
1225 "supported.\n"));
1226 if (use_nt_status()) {
1227 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1228 }
1229 return NT_STATUS_DOS(ERRDOS, ERRcannotopen);
1230 }
1231
1232 switch( create_disposition ) {
1233 /*
1234 * Currently we're using FILE_SUPERSEDE as the same as
1235 * FILE_OVERWRITE_IF but they really are
1236 * different. FILE_SUPERSEDE deletes an existing file
1237 * (requiring delete access) then recreates it.
1238 */
1239 case FILE_SUPERSEDE:
1240 /* If file exists replace/overwrite. If file doesn't
1241 * exist create. */
1242 flags2 |= (O_CREAT | O_TRUNC);
1243 break;
1244
1245 case FILE_OVERWRITE_IF:
1246 /* If file exists replace/overwrite. If file doesn't
1247 * exist create. */
1248 flags2 |= (O_CREAT | O_TRUNC);
1249 break;
1250
1251 case FILE_OPEN:
1252 /* If file exists open. If file doesn't exist error. */
1253 if (!file_existed) {
1254 DEBUG(5,("open_file_ntcreate: FILE_OPEN "
1255 "requested for file %s and file "
1256 "doesn't exist.\n", fname ));
1257 errno = ENOENT;
1258 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1259 }
1260 break;
1261
1262 case FILE_OVERWRITE:
1263 /* If file exists overwrite. If file doesn't exist
1264 * error. */
1265 if (!file_existed) {
1266 DEBUG(5,("open_file_ntcreate: FILE_OVERWRITE "
1267 "requested for file %s and file "
1268 "doesn't exist.\n", fname ));
1269 errno = ENOENT;
1270 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1271 }
1272 flags2 |= O_TRUNC;
1273 break;
1274
1275 case FILE_CREATE:
1276 /* If file exists error. If file doesn't exist
1277 * create. */
1278 if (file_existed) {
1279 DEBUG(5,("open_file_ntcreate: FILE_CREATE "
1280 "requested for file %s and file "
1281 "already exists.\n", fname ));
1282 if (S_ISDIR(psbuf->st_mode)) {
1283 errno = EISDIR;
1284 } else {
1285 errno = EEXIST;
1286 }
1287 return map_nt_error_from_unix(errno);
1288 }
1289 flags2 |= (O_CREAT|O_EXCL);
1290 break;
1291
1292 case FILE_OPEN_IF:
1293 /* If file exists open. If file doesn't exist
1294 * create. */
1295 flags2 |= O_CREAT;
1296 break;
1297
1298 default:
1299 return NT_STATUS_INVALID_PARAMETER;
1300 }
1301
1302 /* We only care about matching attributes on file exists and
1303 * overwrite. */
1304
1305 if (!posix_open && file_existed && ((create_disposition == FILE_OVERWRITE) ||
1306 (create_disposition == FILE_OVERWRITE_IF))) {
1307 if (!open_match_attributes(conn, fname,
1308 existing_dos_attributes,
1309 new_dos_attributes, psbuf->st_mode,
1310 unx_mode, &new_unx_mode)) {
1311 DEBUG(5,("open_file_ntcreate: attributes missmatch "
1312 "for file %s (%x %x) (0%o, 0%o)\n",
1313 fname, existing_dos_attributes,
1314 new_dos_attributes,
1315 (unsigned int)psbuf->st_mode,
1316 (unsigned int)unx_mode ));
1317 errno = EACCES;
1318 return NT_STATUS_ACCESS_DENIED;
1319 }
1320 }
1321
1322 /* This is a nasty hack - must fix... JRA. */
1323 if (access_mask == MAXIMUM_ALLOWED_ACCESS) {
1324 open_access_mask = access_mask = FILE_GENERIC_ALL;
1325 }
1326
1327 /*
1328 * Convert GENERIC bits to specific bits.
1329 */
1330
1331 se_map_generic(&access_mask, &file_generic_mapping);
1332 open_access_mask = access_mask;
1333
1334 if (flags2 & O_TRUNC) {
1335 open_access_mask |= FILE_WRITE_DATA; /* This will cause oplock breaks. */
1336 }
1337
1338 DEBUG(10, ("open_file_ntcreate: fname=%s, after mapping "
1339 "access_mask=0x%x\n", fname, access_mask ));
1340
1341 /*
1342 * Note that we ignore the append flag as append does not
1343 * mean the same thing under DOS and Unix.
1344 */
1345
1346 if (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) {
1347 /* DENY_DOS opens are always underlying read-write on the
1348 file handle, no matter what the requested access mask
1349 says. */
1350 if ((create_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) ||
1351 access_mask & (FILE_READ_ATTRIBUTES|FILE_READ_DATA|FILE_READ_EA|FILE_EXECUTE)) {
1352 flags = O_RDWR;
1353 } else {
1354 flags = O_WRONLY;
1355 }
1356 } else {
1357 flags = O_RDONLY;
1358 }
1359
1360 /*
1361 * Currently we only look at FILE_WRITE_THROUGH for create options.
1362 */
1363
1364 #if defined(O_SYNC)
1365 if ((create_options & FILE_WRITE_THROUGH) && lp_strict_sync(SNUM(conn))) {
1366 flags2 |= O_SYNC;
1367 }
1368 #endif /* O_SYNC */
1369
1370 if (posix_open & (access_mask & FILE_APPEND_DATA)) {
1371 flags2 |= O_APPEND;
1372 }
1373
1374 if (!posix_open && !CAN_WRITE(conn)) {
1375 /*
1376 * We should really return a permission denied error if either
1377 * O_CREAT or O_TRUNC are set, but for compatibility with
1378 * older versions of Samba we just AND them out.
1379 */
1380 flags2 &= ~(O_CREAT|O_TRUNC);
1381 }
1382
1383 /*
1384 * Ensure we can't write on a read-only share or file.
1385 */
1386
1387 if (flags != O_RDONLY && file_existed &&
1388 (!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_attributes))) {
1389 DEBUG(5,("open_file_ntcreate: write access requested for "
1390 "file %s on read only %s\n",
1391 fname, !CAN_WRITE(conn) ? "share" : "file" ));
1392 errno = EACCES;
1393 return NT_STATUS_ACCESS_DENIED;
1394 }
1395
1396 status = file_new(conn, &fsp);
1397 if(!NT_STATUS_IS_OK(status)) {
1398 return status;
1399 }
1400
1401 fsp->dev = psbuf->st_dev;
1402 fsp->inode = psbuf->st_ino;
1403 fsp->share_access = share_access;
1404 fsp->fh->private_options = create_options;
1405 fsp->access_mask = open_access_mask; /* We change this to the
1406 * requested access_mask after
1407 * the open is done. */
1408 fsp->posix_open = posix_open;
1409
1410 /* Ensure no SAMBA_PRIVATE bits can be set. */
1411 fsp->oplock_type = (oplock_request & ~SAMBA_PRIVATE_OPLOCK_MASK);
1412
1413 if (timeval_is_zero(&request_time)) {
1414 request_time = fsp->open_time;
1415 }
1416
1417 if (file_existed) {
1418 dev = psbuf->st_dev;
1419 inode = psbuf->st_ino;
1420
1421 lck = get_share_mode_lock(NULL, dev, inode,
1422 conn->connectpath,
1423 fname);
1424
1425 if (lck == NULL) {
1426 file_free(fsp);
1427 DEBUG(0, ("Could not get share mode lock\n"));
1428 return NT_STATUS_SHARING_VIOLATION;
1429 }
1430
1431 /* First pass - send break only on batch oplocks. */
1432 if (delay_for_oplocks(lck, fsp, 1, oplock_request)) {
1433 schedule_defer_open(lck, request_time);
1434 TALLOC_FREE(lck);
1435 file_free(fsp);
1436 return NT_STATUS_SHARING_VIOLATION;
1437 }
1438
1439 /* Use the client requested access mask here, not the one we
1440 * open with. */
1441 status = open_mode_check(conn, fname, lck,
1442 access_mask, share_access,
1443 create_options, &file_existed);
1444
1445 if (NT_STATUS_IS_OK(status)) {
1446 /* We might be going to allow this open. Check oplock
1447 * status again. */
1448 /* Second pass - send break for both batch or
1449 * exclusive oplocks. */
1450 if (delay_for_oplocks(lck, fsp, 2, oplock_request)) {
1451 schedule_defer_open(lck, request_time);
1452 TALLOC_FREE(lck);
1453 file_free(fsp);
1454 return NT_STATUS_SHARING_VIOLATION;
1455 }
1456 }
1457
1458 if (NT_STATUS_EQUAL(status, NT_STATUS_DELETE_PENDING)) {
1459 /* DELETE_PENDING is not deferred for a second */
1460 TALLOC_FREE(lck);
1461 file_free(fsp);
1462 return status;
1463 }
1464
1465 if (!NT_STATUS_IS_OK(status)) {
1466 uint32 can_access_mask;
1467 BOOL can_access = True;
1468
1469 SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION));
1470
1471 /* Check if this can be done with the deny_dos and fcb
1472 * calls. */
1473 if (create_options &
1474 (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS|
1475 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
1476 files_struct *fsp_dup;
1477
1478 /* Use the client requested access mask here,
1479 * not the one we open with. */
1480 fsp_dup = fcb_or_dos_open(conn, fname, dev,
1481 inode, access_mask,
1482 share_access,
1483 create_options);
1484
1485 if (fsp_dup) {
1486 TALLOC_FREE(lck);
1487 file_free(fsp);
1488 if (pinfo) {
1489 *pinfo = FILE_WAS_OPENED;
1490 }
1491 conn->num_files_open++;
1492 *result = fsp_dup;
1493 return NT_STATUS_OK;
1494 }
1495 }
1496
1497 /*
1498 * This next line is a subtlety we need for
1499 * MS-Access. If a file open will fail due to share
1500 * permissions and also for security (access) reasons,
1501 * we need to return the access failed error, not the
1502 * share error. We can't open the file due to kernel
1503 * oplock deadlock (it's possible we failed above on
1504 * the open_mode_check()) so use a userspace check.
1505 */
1506
1507 if (flags & O_RDWR) {
1508 can_access_mask = FILE_READ_DATA|FILE_WRITE_DATA;
1509 } else if (flags & O_WRONLY) {
1510 can_access_mask = FILE_WRITE_DATA;
1511 } else {
1512 can_access_mask = FILE_READ_DATA;
1513 }
1514
1515 if (((can_access_mask & FILE_WRITE_DATA) && !CAN_WRITE(conn)) ||
1516 !can_access_file(conn,fname,psbuf,can_access_mask)) {
1517 can_access = False;
1518 }
1519
1520 /*
1521 * If we're returning a share violation, ensure we
1522 * cope with the braindead 1 second delay.
1523 */
1524
1525 if (!(oplock_request & INTERNAL_OPEN_ONLY) &&
1526 lp_defer_sharing_violations()) {
1527 struct timeval timeout;
1528 struct deferred_open_record state;
1529 int timeout_usecs;
1530
1531 /* this is a hack to speed up torture tests
1532 in 'make test' */
1533 timeout_usecs = lp_parm_int(SNUM(conn),
1534 "smbd","sharedelay",
1535 SHARING_VIOLATION_USEC_WAIT);
1536
1537 /* This is a relative time, added to the absolute
1538 request_time value to get the absolute timeout time.
1539 Note that if this is the second or greater time we enter
1540 this codepath for this particular request mid then
1541 request_time is left as the absolute time of the *first*
1542 time this request mid was processed. This is what allows
1543 the request to eventually time out. */
1544
1545 timeout = timeval_set(0, timeout_usecs);
1546
1547 /* Nothing actually uses state.delayed_for_oplocks
1548 but it's handy to differentiate in debug messages
1549 between a 30 second delay due to oplock break, and
1550 a 1 second delay for share mode conflicts. */
1551
1552 state.delayed_for_oplocks = False;
1553 state.dev = dev;
1554 state.inode = inode;
1555
1556 if (!request_timed_out(request_time,
1557 timeout)) {
1558 defer_open(lck, request_time, timeout,
1559 &state);
1560 }
1561 }
1562
1563 TALLOC_FREE(lck);
1564 if (can_access) {
1565 /*
1566 * We have detected a sharing violation here
1567 * so return the correct error code
1568 */
1569 status = NT_STATUS_SHARING_VIOLATION;
1570 } else {
1571 status = NT_STATUS_ACCESS_DENIED;
1572 }
1573 file_free(fsp);
1574 return status;
1575 }
1576
1577 /*
1578 * We exit this block with the share entry *locked*.....
1579 */
1580 }
1581
1582 SMB_ASSERT(!file_existed || (lck != NULL));
1583
1584 /*
1585 * Ensure we pay attention to default ACLs on directories if required.
1586 */
1587
1588 if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
1589 (def_acl = directory_has_default_acl(conn, parent_dir))) {
1590 unx_mode = 0777;
1591 }
1592
1593 DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o, "
1594 "access_mask = 0x%x, open_access_mask = 0x%x\n",
1595 (unsigned int)flags, (unsigned int)flags2,
1596 (unsigned int)unx_mode, (unsigned int)access_mask,
1597 (unsigned int)open_access_mask));
1598
1599 /*
1600 * open_file strips any O_TRUNC flags itself.
1601 */
1602
1603 fsp_open = open_file(fsp, conn, parent_dir, newname, fname, psbuf,
1604 flags|flags2, unx_mode, access_mask,
1605 open_access_mask);
1606
1607 if (!NT_STATUS_IS_OK(fsp_open)) {
1608 if (lck != NULL) {
1609 TALLOC_FREE(lck);
1610 }
1611 file_free(fsp);
1612 return fsp_open;
1613 }
1614
1615 if (!file_existed) {
1616
1617 /*
1618 * Deal with the race condition where two smbd's detect the
1619 * file doesn't exist and do the create at the same time. One
1620 * of them will win and set a share mode, the other (ie. this
1621 * one) should check if the requested share mode for this
1622 * create is allowed.
1623 */
1624
1625 /*
1626 * Now the file exists and fsp is successfully opened,
1627 * fsp->dev and fsp->inode are valid and should replace the
1628 * dev=0,inode=0 from a non existent file. Spotted by
1629 * Nadav Danieli <nadavd@exanet.com>. JRA.
1630 */
1631
1632 dev = fsp->dev;
1633 inode = fsp->inode;
1634
1635 lck = get_share_mode_lock(NULL, dev, inode,
1636 conn->connectpath,
1637 fname);
1638
1639 if (lck == NULL) {
1640 DEBUG(0, ("open_file_ntcreate: Could not get share "
1641 "mode lock for %s\n", fname));
1642 fd_close(conn, fsp);
1643 file_free(fsp);
1644 return NT_STATUS_SHARING_VIOLATION;
1645 }
1646
1647 status = open_mode_check(conn, fname, lck,
1648 access_mask, share_access,
1649 create_options, &file_existed);
1650
1651 if (!NT_STATUS_IS_OK(status)) {
1652 struct deferred_open_record state;
1653
1654 fd_close(conn, fsp);
1655 file_free(fsp);
1656
1657 state.delayed_for_oplocks = False;
1658 state.dev = dev;
1659 state.inode = inode;
1660
1661 /* Do it all over again immediately. In the second
1662 * round we will find that the file existed and handle
1663 * the DELETE_PENDING and FCB cases correctly. No need
1664 * to duplicate the code here. Essentially this is a
1665 * "goto top of this function", but don't tell
1666 * anybody... */
1667
1668 defer_open(lck, request_time, timeval_zero(),
1669 &state);
1670 TALLOC_FREE(lck);
1671 return status;
1672 }
1673
1674 /*
1675 * We exit this block with the share entry *locked*.....
1676 */
1677
1678 }
1679
1680 SMB_ASSERT(lck != NULL);
1681
1682 /* note that we ignore failure for the following. It is
1683 basically a hack for NFS, and NFS will never set one of
1684 these only read them. Nobody but Samba can ever set a deny
1685 mode and we have already checked our more authoritative
1686 locking database for permission to set this deny mode. If
1687 the kernel refuses the operations then the kernel is wrong.
1688 note that GPFS supports it as well - jmcd */
1689
1690 ret_flock = SMB_VFS_KERNEL_FLOCK(fsp, fsp->fh->fd, share_access);
1691 if(ret_flock == -1 ){
1692
1693 TALLOC_FREE(lck);
1694 fd_close(conn, fsp);
1695 file_free(fsp);
1696
1697 return NT_STATUS_SHARING_VIOLATION;
1698 }
1699
1700 /*
1701 * At this point onwards, we can guarentee that the share entry
1702 * is locked, whether we created the file or not, and that the
1703 * deny mode is compatible with all current opens.
1704 */
1705
1706 /*
1707 * If requested, truncate the file.
1708 */
1709
1710 if (flags2&O_TRUNC) {
1711 /*
1712 * We are modifing the file after open - update the stat
1713 * struct..
1714 */
1715 if ((SMB_VFS_FTRUNCATE(fsp,fsp->fh->fd,0) == -1) ||
1716 (SMB_VFS_FSTAT(fsp,fsp->fh->fd,psbuf)==-1)) {
1717 status = map_nt_error_from_unix(errno);
1718 TALLOC_FREE(lck);
1719 fd_close(conn,fsp);
1720 file_free(fsp);
1721 return status;
1722 }
1723 }
1724
1725 /* Record the options we were opened with. */
1726 fsp->share_access = share_access;
1727 fsp->fh->private_options = create_options;
1728 fsp->access_mask = access_mask;
1729
1730 if (file_existed) {
1731 /* stat opens on existing files don't get oplocks. */
1732 if (is_stat_open(open_access_mask)) {
1733 fsp->oplock_type = NO_OPLOCK;
1734 }
1735
1736 if (!(flags2 & O_TRUNC)) {
1737 info = FILE_WAS_OPENED;
1738 } else {
1739 info = FILE_WAS_OVERWRITTEN;
1740 }
1741 } else {
1742 info = FILE_WAS_CREATED;
1743 }
1744
1745 if (pinfo) {
1746 *pinfo = info;
1747 }
1748
1749 /*
1750 * Setup the oplock info in both the shared memory and
1751 * file structs.
1752 */
1753
1754 if ((fsp->oplock_type != NO_OPLOCK) &&
1755 (fsp->oplock_type != FAKE_LEVEL_II_OPLOCK)) {
1756 if (!set_file_oplock(fsp, fsp->oplock_type)) {
1757 /* Could not get the kernel oplock */
1758 fsp->oplock_type = NO_OPLOCK;
1759 }
1760 }
1761 set_share_mode(lck, fsp, current_user.ut.uid, 0, fsp->oplock_type);
1762
1763 if (info == FILE_WAS_OVERWRITTEN || info == FILE_WAS_CREATED ||
1764 info == FILE_WAS_SUPERSEDED) {
1765
1766 /* Handle strange delete on close create semantics. */
1767 if (create_options & FILE_DELETE_ON_CLOSE) {
1768 status = can_set_delete_on_close(fsp, True, new_dos_attributes);
1769
1770 if (!NT_STATUS_IS_OK(status)) {
1771 /* Remember to delete the mode we just added. */
1772 del_share_mode(lck, fsp);
1773 TALLOC_FREE(lck);
1774 fd_close(conn,fsp);
1775 file_free(fsp);
1776 return status;
1777 }
1778 /* Note that here we set the *inital* delete on close flag,
1779 not the regular one. The magic gets handled in close. */
1780 fsp->initial_delete_on_close = True;
1781 }
1782
1783 /* Files should be initially set as archive */
1784 if (lp_map_archive(SNUM(conn)) ||
1785 lp_store_dos_attributes(SNUM(conn))) {
1786 if (!posix_open) {
1787 file_set_dosmode(conn, fname,
1788 new_dos_attributes | aARCH, NULL,
1789 parent_dir);
1790 }
1791 }
1792 }
1793
1794 /*
1795 * Take care of inherited ACLs on created files - if default ACL not
1796 * selected.
1797 */
1798
1799 if (!posix_open && !file_existed && !def_acl) {
1800
1801 int saved_errno = errno; /* We might get ENOSYS in the next
1802 * call.. */
1803
1804 if (SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd, unx_mode) == -1 &&
1805 errno == ENOSYS) {
1806 errno = saved_errno; /* Ignore ENOSYS */
1807 }
1808
1809 } else if (new_unx_mode) {
1810
1811 int ret = -1;
1812
1813 /* Attributes need changing. File already existed. */
1814
1815 {
1816 int saved_errno = errno; /* We might get ENOSYS in the
1817 * next call.. */
1818 ret = SMB_VFS_FCHMOD_ACL(fsp, fsp->fh->fd,
1819 new_unx_mode);
1820
1821 if (ret == -1 && errno == ENOSYS) {
1822 errno = saved_errno; /* Ignore ENOSYS */
1823 } else {
1824 DEBUG(5, ("open_file_ntcreate: reset "
1825 "attributes of file %s to 0%o\n",
1826 fname, (unsigned int)new_unx_mode));
1827 ret = 0; /* Don't do the fchmod below. */
1828 }
1829 }
1830
1831 if ((ret == -1) &&
1832 (SMB_VFS_FCHMOD(fsp, fsp->fh->fd, new_unx_mode) == -1))
1833 DEBUG(5, ("open_file_ntcreate: failed to reset "
1834 "attributes of file %s to 0%o\n",
1835 fname, (unsigned int)new_unx_mode));
1836 }
1837
1838 /* If this is a successful open, we must remove any deferred open
1839 * records. */
1840 del_deferred_open_entry(lck, mid);
1841 TALLOC_FREE(lck);
1842
1843 conn->num_files_open++;
1844
1845 *result = fsp;
1846 return NT_STATUS_OK;
1847 }
1848
1849 /****************************************************************************
1850 Open a file for for write to ensure that we can fchmod it.
1851 ****************************************************************************/
1852
1853 NTSTATUS open_file_fchmod(connection_struct *conn, const char *fname,
1854 SMB_STRUCT_STAT *psbuf, files_struct **result)
1855 {
1856 files_struct *fsp = NULL;
1857 NTSTATUS status;
1858
1859 if (!VALID_STAT(*psbuf)) {
1860 return NT_STATUS_INVALID_PARAMETER;
1861 }
1862
1863 status = file_new(conn, &fsp);
1864 if(!NT_STATUS_IS_OK(status)) {
1865 return status;
1866 }
1867
1868 /* note! we must use a non-zero desired access or we don't get
1869 a real file descriptor. Oh what a twisted web we weave. */
1870 status = open_file(fsp, conn, NULL, NULL, fname, psbuf, O_WRONLY, 0,
1871 FILE_WRITE_DATA, FILE_WRITE_DATA);
1872
1873 /*
1874 * This is not a user visible file open.
1875 * Don't set a share mode and don't increment
1876 * the conn->num_files_open.
1877 */
1878
1879 if (!NT_STATUS_IS_OK(status)) {
1880 file_free(fsp);
1881 return status;
1882 }
1883
1884 *result = fsp;
1885 return NT_STATUS_OK;
1886 }
1887
1888 /****************************************************************************
1889 Close the fchmod file fd - ensure no locks are lost.
1890 ****************************************************************************/
1891
1892 NTSTATUS close_file_fchmod(files_struct *fsp)
1893 {
1894 NTSTATUS status = fd_close(fsp->conn, fsp);
1895 file_free(fsp);
1896 return status;
1897 }
1898
1899 static NTSTATUS mkdir_internal(connection_struct *conn,
1900 const char *name,
1901 uint32 file_attributes,
1902 SMB_STRUCT_STAT *psbuf)
1903 {
1904 mode_t mode;
1905 char *parent_dir;
1906 const char *dirname;
1907 NTSTATUS status;
1908
1909 if(!CAN_WRITE(conn)) {
1910 DEBUG(5,("mkdir_internal: failing create on read-only share "
1911 "%s\n", lp_servicename(SNUM(conn))));
1912 return NT_STATUS_ACCESS_DENIED;
1913 }
1914
1915 status = check_name(conn, name);
1916 if (!NT_STATUS_IS_OK(status)) {
1917 return status;
1918 }
1919
1920 if (!parent_dirname_talloc(tmp_talloc_ctx(), name, &parent_dir,
1921 &dirname)) {
1922 return NT_STATUS_NO_MEMORY;
1923 }
1924
1925 if (file_attributes & FILE_FLAG_POSIX_SEMANTICS) {
1926 mode = (mode_t)(file_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
1927 } else {
1928 mode = unix_mode(conn, aDIR, name, parent_dir);
1929 }
1930
1931 if (SMB_VFS_MKDIR(conn, name, mode) != 0) {
1932 return map_nt_error_from_unix(errno);
1933 }
1934
1935 /* Ensure we're checking for a symlink here.... */
1936 /* We don't want to get caught by a symlink racer. */
1937
1938 if (SMB_VFS_LSTAT(conn, name, psbuf) == -1) {
1939 DEBUG(2, ("Could not stat directory '%s' just created: %s\n",
1940 name, strerror(errno)));
1941 return map_nt_error_from_unix(errno);
1942 }
1943
1944 if (!S_ISDIR(psbuf->st_mode)) {
1945 DEBUG(0, ("Directory just '%s' created is not a directory\n",
1946 name));
1947 return NT_STATUS_ACCESS_DENIED;
1948 }
1949
1950 if (lp_inherit_perms(SNUM(conn))) {
1951 inherit_access_acl(conn, parent_dir, name, mode);
1952 }
1953
1954 if (!(file_attributes & FILE_FLAG_POSIX_SEMANTICS)) {
1955 /*
1956 * Check if high bits should have been set,
1957 * then (if bits are missing): add them.
1958 * Consider bits automagically set by UNIX, i.e. SGID bit from parent
1959 * dir.
1960 */
1961 if (mode & ~(S_IRWXU|S_IRWXG|S_IRWXO) && (mode & ~psbuf->st_mode)) {
1962 SMB_VFS_CHMOD(conn, name,
1963 psbuf->st_mode | (mode & ~psbuf->st_mode));
1964 }
1965 }
1966
1967 /* Change the owner if required. */
1968 if (lp_inherit_owner(SNUM(conn))) {
1969 change_dir_owner_to_parent(conn, parent_dir, name, psbuf);
1970 }
1971
1972 notify_fname(conn, NOTIFY_ACTION_ADDED, FILE_NOTIFY_CHANGE_DIR_NAME,
1973 name);
1974
1975 return NT_STATUS_OK;
1976 }
1977
1978 /****************************************************************************
1979 Open a directory from an NT SMB call.
1980 ****************************************************************************/
1981
1982 NTSTATUS open_directory(connection_struct *conn,
1983 const char *fname,
1984 SMB_STRUCT_STAT *psbuf,
1985 uint32 access_mask,
1986 uint32 share_access,
1987 uint32 create_disposition,
1988 uint32 create_options,
1989 uint32 file_attributes,
1990 int *pinfo,
1991 files_struct **result)
1992 {
1993 files_struct *fsp = NULL;
1994 BOOL dir_existed = VALID_STAT(*psbuf) ? True : False;
1995 struct share_mode_lock *lck = NULL;
1996 NTSTATUS status;
1997 int info = 0;
1998
1999 DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
2000 "share_access = 0x%x create_options = 0x%x, "
2001 "create_disposition = 0x%x, file_attributes = 0x%x\n",
2002 fname,
2003 (unsigned int)access_mask,
2004 (unsigned int)share_access,
2005 (unsigned int)create_options,
2006 (unsigned int)create_disposition,
2007 (unsigned int)file_attributes));
2008
2009 if (is_ntfs_stream_name(fname)) {
2010 DEBUG(0,("open_directory: %s is a stream name!\n", fname ));
2011 return NT_STATUS_NOT_A_DIRECTORY;
2012 }
2013
2014 switch( create_disposition ) {
2015 case FILE_OPEN:
2016
2017 info = FILE_WAS_OPENED;
2018
2019 /*
2020 * We want to follow symlinks here.
2021 */
2022
2023 if (SMB_VFS_STAT(conn, fname, psbuf) != 0) {
2024 return map_nt_error_from_unix(errno);
2025 }
2026
2027 break;
2028
2029 case FILE_CREATE:
2030
2031 /* If directory exists error. If directory doesn't
2032 * exist create. */
2033
2034 status = mkdir_internal(conn,
2035 fname,
2036 file_attributes,
2037 psbuf);
2038
2039 if (!NT_STATUS_IS_OK(status)) {
2040 DEBUG(2, ("open_directory: unable to create "
2041 "%s. Error was %s\n", fname,
2042 nt_errstr(status)));
2043 return status;
2044 }
2045
2046 info = FILE_WAS_CREATED;
2047 break;
2048
2049 case FILE_OPEN_IF:
2050 /*
2051 * If directory exists open. If directory doesn't
2052 * exist create.
2053 */
2054
2055 status = mkdir_internal(conn,
2056 fname,
2057 file_attributes,
2058 psbuf);
2059
2060 if (NT_STATUS_IS_OK(status)) {
2061 info = FILE_WAS_CREATED;
2062 }
2063
2064 if (NT_STATUS_EQUAL(status,
2065 NT_STATUS_OBJECT_NAME_COLLISION)) {
2066 info = FILE_WAS_OPENED;
2067 status = NT_STATUS_OK;
2068 }
2069
2070 break;
2071
2072 case FILE_SUPERSEDE:
2073 case FILE_OVERWRITE:
2074 case FILE_OVERWRITE_IF:
2075 default:
2076 DEBUG(5,("open_directory: invalid create_disposition "
2077 "0x%x for directory %s\n",
2078 (unsigned int)create_disposition, fname));
2079 return NT_STATUS_INVALID_PARAMETER;
2080 }
2081
2082 if(!S_ISDIR(psbuf->st_mode)) {
2083 DEBUG(5,("open_directory: %s is not a directory !\n",
2084 fname ));
2085 return NT_STATUS_NOT_A_DIRECTORY;
2086 }
2087
2088 status = file_new(conn, &fsp);
2089 if(!NT_STATUS_IS_OK(status)) {
2090 return status;
2091 }
2092
2093 /*
2094 * Setup the files_struct for it.
2095 */
2096
2097 fsp->mode = psbuf->st_mode;
2098 fsp->inode = psbuf->st_ino;
2099 fsp->dev = psbuf->st_dev;
2100 fsp->vuid = current_user.vuid;
2101 fsp->file_pid = global_smbpid;
2102 fsp->can_lock = False;
2103 fsp->can_read = False;
2104 fsp->can_write = False;
2105
2106 fsp->share_access = share_access;
2107 fsp->fh->private_options = create_options;
2108 fsp->access_mask = access_mask;
2109
2110 fsp->print_file = False;
2111 fsp->modified = False;
2112 fsp->oplock_type = NO_OPLOCK;
2113 fsp->sent_oplock_break = NO_BREAK_SENT;
2114 fsp->is_directory = True;
2115 fsp->is_stat = False;
2116 fsp->posix_open = (file_attributes & FILE_FLAG_POSIX_SEMANTICS) ? True : False;
2117
2118 string_set(&fsp->fsp_name,fname);
2119
2120 lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode,
2121 conn->connectpath,
2122 fname);
2123
2124 if (lck == NULL) {
2125 DEBUG(0, ("open_directory: Could not get share mode lock for %s\n", fname));
2126 file_free(fsp);
2127 return NT_STATUS_SHARING_VIOLATION;
2128 }
2129
2130 status = open_mode_check(conn, fname, lck,
2131 access_mask, share_access,
2132 create_options, &dir_existed);
2133
2134 if (!NT_STATUS_IS_OK(status)) {
2135 TALLOC_FREE(lck);
2136 file_free(fsp);
2137 return status;
2138 }
2139
2140 set_share_mode(lck, fsp, current_user.ut.uid, 0, NO_OPLOCK);
2141
2142 /* For directories the delete on close bit at open time seems
2143 always to be honored on close... See test 19 in Samba4 BASE-DELETE. */
2144 if (create_options & FILE_DELETE_ON_CLOSE) {
2145 status = can_set_delete_on_close(fsp, True, 0);
2146 if (!NT_STATUS_IS_OK(status) && !NT_STATUS_EQUAL(status, NT_STATUS_DIRECTORY_NOT_EMPTY)) {
2147 TALLOC_FREE(lck);
2148 file_free(fsp);
2149 return status;
2150 }
2151
2152 if (NT_STATUS_IS_OK(status)) {
2153 /* Note that here we set the *inital* delete on close flag,
2154 not the regular one. The magic gets handled in close. */
2155 fsp->initial_delete_on_close = True;
2156 }
2157 }
2158
2159 TALLOC_FREE(lck);
2160
2161 if (pinfo) {
2162 *pinfo = info;
2163 }
2164
2165 conn->num_files_open++;
2166
2167 *result = fsp;
2168 return NT_STATUS_OK;
2169 }
2170
2171 NTSTATUS create_directory(connection_struct *conn, const char *directory)
2172 {
2173 NTSTATUS status;
2174 SMB_STRUCT_STAT sbuf;
2175 files_struct *fsp;
2176
2177 SET_STAT_INVALID(sbuf);
2178
2179 status = open_directory(conn, directory, &sbuf,
2180 FILE_READ_ATTRIBUTES, /* Just a stat open */
2181 FILE_SHARE_NONE, /* Ignored for stat opens */
2182 FILE_CREATE,
2183 0,
2184 FILE_ATTRIBUTE_DIRECTORY,
2185 NULL,
2186 &fsp);
2187
2188 if (NT_STATUS_IS_OK(status)) {
2189 close_file(fsp, NORMAL_CLOSE);
2190 }
2191
2192 return status;
2193 }
2194
2195 /****************************************************************************
2196 Open a pseudo-file (no locking checks - a 'stat' open).
2197 ****************************************************************************/
2198
2199 NTSTATUS open_file_stat(connection_struct *conn, const char *fname,
2200 SMB_STRUCT_STAT *psbuf, files_struct **result)
2201 {
2202 files_struct *fsp = NULL;
2203 NTSTATUS status;
2204
2205 if (!VALID_STAT(*psbuf)) {
2206 return NT_STATUS_INVALID_PARAMETER;
2207 }
2208
2209 /* Can't 'stat' open directories. */
2210 if(S_ISDIR(psbuf->st_mode)) {
2211 return NT_STATUS_FILE_IS_A_DIRECTORY;
2212 }
2213
2214 status = file_new(conn, &fsp);
2215 if(!NT_STATUS_IS_OK(status)) {
2216 return status;
2217 }
2218
2219 DEBUG(5,("open_file_stat: 'opening' file %s\n", fname));
2220
2221 /*
2222 * Setup the files_struct for it.
2223 */
2224
2225 fsp->mode = psbuf->st_mode;
2226 fsp->inode = psbuf->st_ino;
2227 fsp->dev = psbuf->st_dev;
2228 fsp->vuid = current_user.vuid;
2229 fsp->file_pid = global_smbpid;
2230 fsp->can_lock = False;
2231 fsp->can_read = False;
2232 fsp->can_write = False;
2233 fsp->print_file = False;
2234 fsp->modified = False;
2235 fsp->oplock_type = NO_OPLOCK;
2236 fsp->sent_oplock_break = NO_BREAK_SENT;
2237 fsp->is_directory = False;
2238 fsp->is_stat = True;
2239 string_set(&fsp->fsp_name,fname);
2240
2241 conn->num_files_open++;
2242
2243 *result = fsp;
2244 return NT_STATUS_OK;
2245 }
2246
2247 /****************************************************************************
2248 Receive notification that one of our open files has been renamed by another
2249 smbd process.
2250 ****************************************************************************/
2251
2252 void msg_file_was_renamed(int msg_type, struct server_id src,
2253 void *buf, size_t len, void *private_data)
2254 {
2255 files_struct *fsp;
2256 char *frm = (char *)buf;
2257 SMB_DEV_T dev;
2258 SMB_INO_T inode;
2259 const char *sharepath;
2260 const char *newname;
2261 size_t sp_len;
2262
2263 if (buf == NULL || len < MSG_FILE_RENAMED_MIN_SIZE + 2) {
2264 DEBUG(0, ("msg_file_was_renamed: Got invalid msg len %d\n", (int)len));
2265 return;
2266 }
2267
2268 /* Unpack the message. */
2269 dev = DEV_T_VAL(frm,0);
2270 inode = INO_T_VAL(frm,8);
2271 sharepath = &frm[16];
2272 newname = sharepath + strlen(sharepath) + 1;
2273 sp_len = strlen(sharepath);
2274
2275 DEBUG(10,("msg_file_was_renamed: Got rename message for sharepath %s, new name %s, "
2276 "dev %x, inode %.0f\n",
2277 sharepath, newname, (unsigned int)dev, (double)inode ));
2278
2279 for(fsp = file_find_di_first(dev, inode); fsp; fsp = file_find_di_next(fsp)) {
2280 if (memcmp(fsp->conn->connectpath, sharepath, sp_len) == 0) {
2281 DEBUG(10,("msg_file_was_renamed: renaming file fnum %d from %s -> %s\n",
2282 fsp->fnum, fsp->fsp_name, newname ));
2283 string_set(&fsp->fsp_name, newname);
2284 } else {
2285 /* TODO. JRA. */
2286 /* Now we have the complete path we can work out if this is
2287 actually within this share and adjust newname accordingly. */
2288 DEBUG(10,("msg_file_was_renamed: share mismatch (sharepath %s "
2289 "not sharepath %s) "
2290 "fnum %d from %s -> %s\n",
2291 fsp->conn->connectpath,
2292 sharepath,
2293 fsp->fnum,
2294 fsp->fsp_name,
2295 newname ));
2296 }
2297 }
2298 }