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