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