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