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