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