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