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