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