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