?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Convert dbwrap_trans_delete to NTSTATUS
[Samba.git] / source / smbd / open.c
blob0cc48c4f1c36842633b87424be38a6669f25b68f
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 3 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, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23
24 extern const struct generic_mapping file_generic_mapping;
25 extern struct current_user current_user;
26 extern userdom_struct current_user_info;
27 extern bool global_client_failed_oplock_break;
28
29 struct deferred_open_record {
30 bool delayed_for_oplocks;
31 struct file_id id;
32 };
33
34 /****************************************************************************
35 fd support routines - attempt to do a dos_open.
36 ****************************************************************************/
37
38 static NTSTATUS fd_open(struct connection_struct *conn,
39 const char *fname,
40 files_struct *fsp,
41 int flags,
42 mode_t mode)
43 {
44 NTSTATUS status = NT_STATUS_OK;
45
46 #ifdef O_NOFOLLOW
47 /*
48 * Never follow symlinks on a POSIX client. The
49 * client should be doing this.
50 */
51
52 if (fsp->posix_open || !lp_symlinks(SNUM(conn))) {
53 flags |= O_NOFOLLOW;
54 }
55 #endif
56
57 fsp->fh->fd = SMB_VFS_OPEN(conn,fname,fsp,flags,mode);
58 if (fsp->fh->fd == -1) {
59 status = map_nt_error_from_unix(errno);
60 }
61
62 DEBUG(10,("fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s\n",
63 fname, flags, (int)mode, fsp->fh->fd,
64 (fsp->fh->fd == -1) ? strerror(errno) : "" ));
65
66 return status;
67 }
68
69 /****************************************************************************
70 Close the file associated with a fsp.
71 ****************************************************************************/
72
73 NTSTATUS fd_close(files_struct *fsp)
74 {
75 if (fsp->fh->fd == -1) {
76 return NT_STATUS_OK; /* What we used to call a stat open. */
77 }
78 if (fsp->fh->ref_count > 1) {
79 return NT_STATUS_OK; /* Shared handle. Only close last reference. */
80 }
81 return fd_close_posix(fsp);
82 }
83
84 /****************************************************************************
85 Change the ownership of a file to that of the parent directory.
86 Do this by fd if possible.
87 ****************************************************************************/
88
89 static void change_file_owner_to_parent(connection_struct *conn,
90 const char *inherit_from_dir,
91 files_struct *fsp)
92 {
93 SMB_STRUCT_STAT parent_st;
94 int ret;
95
96 ret = SMB_VFS_STAT(conn, inherit_from_dir, &parent_st);
97 if (ret == -1) {
98 DEBUG(0,("change_file_owner_to_parent: failed to stat parent "
99 "directory %s. Error was %s\n",
100 inherit_from_dir, strerror(errno) ));
101 return;
102 }
103
104 become_root();
105 ret = SMB_VFS_FCHOWN(fsp, parent_st.st_uid, (gid_t)-1);
106 unbecome_root();
107 if (ret == -1) {
108 DEBUG(0,("change_file_owner_to_parent: failed to fchown "
109 "file %s to parent directory uid %u. Error "
110 "was %s\n", fsp->fsp_name,
111 (unsigned int)parent_st.st_uid,
112 strerror(errno) ));
113 }
114
115 DEBUG(10,("change_file_owner_to_parent: changed new file %s to "
116 "parent directory uid %u.\n", fsp->fsp_name,
117 (unsigned int)parent_st.st_uid ));
118 }
119
120 static NTSTATUS change_dir_owner_to_parent(connection_struct *conn,
121 const char *inherit_from_dir,
122 const char *fname,
123 SMB_STRUCT_STAT *psbuf)
124 {
125 char *saved_dir = NULL;
126 SMB_STRUCT_STAT sbuf;
127 SMB_STRUCT_STAT parent_st;
128 TALLOC_CTX *ctx = talloc_tos();
129 NTSTATUS status = NT_STATUS_OK;
130 int ret;
131
132 ret = SMB_VFS_STAT(conn, inherit_from_dir, &parent_st);
133 if (ret == -1) {
134 status = map_nt_error_from_unix(errno);
135 DEBUG(0,("change_dir_owner_to_parent: failed to stat parent "
136 "directory %s. Error was %s\n",
137 inherit_from_dir, strerror(errno) ));
138 return status;
139 }
140
141 /* We've already done an lstat into psbuf, and we know it's a
142 directory. If we can cd into the directory and the dev/ino
143 are the same then we can safely chown without races as
144 we're locking the directory in place by being in it. This
145 should work on any UNIX (thanks tridge :-). JRA.
146 */
147
148 saved_dir = vfs_GetWd(ctx,conn);
149 if (!saved_dir) {
150 status = map_nt_error_from_unix(errno);
151 DEBUG(0,("change_dir_owner_to_parent: failed to get "
152 "current working directory. Error was %s\n",
153 strerror(errno)));
154 return status;
155 }
156
157 /* Chdir into the new path. */
158 if (vfs_ChDir(conn, fname) == -1) {
159 status = map_nt_error_from_unix(errno);
160 DEBUG(0,("change_dir_owner_to_parent: failed to change "
161 "current working directory to %s. Error "
162 "was %s\n", fname, strerror(errno) ));
163 goto out;
164 }
165
166 if (SMB_VFS_STAT(conn,".",&sbuf) == -1) {
167 status = map_nt_error_from_unix(errno);
168 DEBUG(0,("change_dir_owner_to_parent: failed to stat "
169 "directory '.' (%s) Error was %s\n",
170 fname, strerror(errno)));
171 goto out;
172 }
173
174 /* Ensure we're pointing at the same place. */
175 if (sbuf.st_dev != psbuf->st_dev ||
176 sbuf.st_ino != psbuf->st_ino ||
177 sbuf.st_mode != psbuf->st_mode ) {
178 DEBUG(0,("change_dir_owner_to_parent: "
179 "device/inode/mode on directory %s changed. "
180 "Refusing to chown !\n", fname ));
181 status = NT_STATUS_ACCESS_DENIED;
182 goto out;
183 }
184
185 become_root();
186 ret = SMB_VFS_CHOWN(conn, ".", parent_st.st_uid, (gid_t)-1);
187 unbecome_root();
188 if (ret == -1) {
189 status = map_nt_error_from_unix(errno);
190 DEBUG(10,("change_dir_owner_to_parent: failed to chown "
191 "directory %s to parent directory uid %u. "
192 "Error was %s\n", fname,
193 (unsigned int)parent_st.st_uid, strerror(errno) ));
194 goto out;
195 }
196
197 DEBUG(10,("change_dir_owner_to_parent: changed ownership of new "
198 "directory %s to parent directory uid %u.\n",
199 fname, (unsigned int)parent_st.st_uid ));
200
201 out:
202
203 vfs_ChDir(conn,saved_dir);
204 return status;
205 }
206
207 /****************************************************************************
208 Open a file.
209 ****************************************************************************/
210
211 static NTSTATUS open_file(files_struct *fsp,
212 connection_struct *conn,
213 struct smb_request *req,
214 const char *parent_dir,
215 const char *name,
216 const char *path,
217 SMB_STRUCT_STAT *psbuf,
218 int flags,
219 mode_t unx_mode,
220 uint32 access_mask, /* client requested access mask. */
221 uint32 open_access_mask) /* what we're actually using in the open. */
222 {
223 NTSTATUS status = NT_STATUS_OK;
224 int accmode = (flags & O_ACCMODE);
225 int local_flags = flags;
226 bool file_existed = VALID_STAT(*psbuf);
227
228 fsp->fh->fd = -1;
229 errno = EPERM;
230
231 /* Check permissions */
232
233 /*
234 * This code was changed after seeing a client open request
235 * containing the open mode of (DENY_WRITE/read-only) with
236 * the 'create if not exist' bit set. The previous code
237 * would fail to open the file read only on a read-only share
238 * as it was checking the flags parameter directly against O_RDONLY,
239 * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
240 * JRA.
241 */
242
243 if (!CAN_WRITE(conn)) {
244 /* It's a read-only share - fail if we wanted to write. */
245 if(accmode != O_RDONLY) {
246 DEBUG(3,("Permission denied opening %s\n", path));
247 return NT_STATUS_ACCESS_DENIED;
248 } else if(flags & O_CREAT) {
249 /* We don't want to write - but we must make sure that
250 O_CREAT doesn't create the file if we have write
251 access into the directory.
252 */
253 flags &= ~O_CREAT;
254 local_flags &= ~O_CREAT;
255 }
256 }
257
258 /*
259 * This little piece of insanity is inspired by the
260 * fact that an NT client can open a file for O_RDONLY,
261 * but set the create disposition to FILE_EXISTS_TRUNCATE.
262 * If the client *can* write to the file, then it expects to
263 * truncate the file, even though it is opening for readonly.
264 * Quicken uses this stupid trick in backup file creation...
265 * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
266 * for helping track this one down. It didn't bite us in 2.0.x
267 * as we always opened files read-write in that release. JRA.
268 */
269
270 if ((accmode == O_RDONLY) && ((flags & O_TRUNC) == O_TRUNC)) {
271 DEBUG(10,("open_file: truncate requested on read-only open "
272 "for file %s\n", path));
273 local_flags = (flags & ~O_ACCMODE)|O_RDWR;
274 }
275
276 if ((open_access_mask & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ||
277 (!file_existed && (local_flags & O_CREAT)) ||
278 ((local_flags & O_TRUNC) == O_TRUNC) ) {
279
280 /*
281 * We can't actually truncate here as the file may be locked.
282 * open_file_ntcreate will take care of the truncate later. JRA.
283 */
284
285 local_flags &= ~O_TRUNC;
286
287 #if defined(O_NONBLOCK) && defined(S_ISFIFO)
288 /*
289 * We would block on opening a FIFO with no one else on the
290 * other end. Do what we used to do and add O_NONBLOCK to the
291 * open flags. JRA.
292 */
293
294 if (file_existed && S_ISFIFO(psbuf->st_mode)) {
295 local_flags |= O_NONBLOCK;
296 }
297 #endif
298
299 /* Don't create files with Microsoft wildcard characters. */
300 if ((local_flags & O_CREAT) && !file_existed &&
301 ms_has_wild(path)) {
302 return NT_STATUS_OBJECT_NAME_INVALID;
303 }
304
305 /* Actually do the open */
306 status = fd_open(conn, path, fsp, local_flags, unx_mode);
307 if (!NT_STATUS_IS_OK(status)) {
308 DEBUG(3,("Error opening file %s (%s) (local_flags=%d) "
309 "(flags=%d)\n",
310 path,nt_errstr(status),local_flags,flags));
311 return status;
312 }
313
314 if ((local_flags & O_CREAT) && !file_existed) {
315
316 /* Inherit the ACL if required */
317 if (lp_inherit_perms(SNUM(conn))) {
318 inherit_access_acl(conn, parent_dir, path,
319 unx_mode);
320 }
321
322 /* Change the owner if required. */
323 if (lp_inherit_owner(SNUM(conn))) {
324 change_file_owner_to_parent(conn, parent_dir,
325 fsp);
326 }
327
328 notify_fname(conn, NOTIFY_ACTION_ADDED,
329 FILE_NOTIFY_CHANGE_FILE_NAME, path);
330 }
331
332 } else {
333 fsp->fh->fd = -1; /* What we used to call a stat open. */
334 }
335
336 if (!file_existed) {
337 int ret;
338
339 if (fsp->fh->fd == -1) {
340 ret = SMB_VFS_STAT(conn, path, psbuf);
341 } else {
342 ret = SMB_VFS_FSTAT(fsp, psbuf);
343 /* If we have an fd, this stat should succeed. */
344 if (ret == -1) {
345 DEBUG(0,("Error doing fstat on open file %s "
346 "(%s)\n", path,strerror(errno) ));
347 }
348 }
349
350 /* For a non-io open, this stat failing means file not found. JRA */
351 if (ret == -1) {
352 status = map_nt_error_from_unix(errno);
353 fd_close(fsp);
354 return status;
355 }
356 }
357
358 /*
359 * POSIX allows read-only opens of directories. We don't
360 * want to do this (we use a different code path for this)
361 * so catch a directory open and return an EISDIR. JRA.
362 */
363
364 if(S_ISDIR(psbuf->st_mode)) {
365 fd_close(fsp);
366 errno = EISDIR;
367 return NT_STATUS_FILE_IS_A_DIRECTORY;
368 }
369
370 fsp->mode = psbuf->st_mode;
371 fsp->file_id = vfs_file_id_from_sbuf(conn, psbuf);
372 fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
373 fsp->file_pid = req ? req->smbpid : 0;
374 fsp->can_lock = True;
375 fsp->can_read = (access_mask & (FILE_READ_DATA)) ? True : False;
376 if (!CAN_WRITE(conn)) {
377 fsp->can_write = False;
378 } else {
379 fsp->can_write = (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) ?
380 True : False;
381 }
382 fsp->print_file = False;
383 fsp->modified = False;
384 fsp->sent_oplock_break = NO_BREAK_SENT;
385 fsp->is_directory = False;
386 fsp->is_stat = False;
387 if (conn->aio_write_behind_list &&
388 is_in_path(path, conn->aio_write_behind_list, conn->case_sensitive)) {
389 fsp->aio_write_behind = True;
390 }
391
392 string_set(&fsp->fsp_name, path);
393 fsp->wcp = NULL; /* Write cache pointer. */
394
395 DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
396 *current_user_info.smb_name ?
397 current_user_info.smb_name : conn->user,fsp->fsp_name,
398 BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
399 conn->num_files_open + 1));
400
401 errno = 0;
402 return NT_STATUS_OK;
403 }
404
405 /*******************************************************************
406 Return True if the filename is one of the special executable types.
407 ********************************************************************/
408
409 static bool is_executable(const char *fname)
410 {
411 if ((fname = strrchr_m(fname,'.'))) {
412 if (strequal(fname,".com") ||
413 strequal(fname,".dll") ||
414 strequal(fname,".exe") ||
415 strequal(fname,".sym")) {
416 return True;
417 }
418 }
419 return False;
420 }
421
422 /****************************************************************************
423 Check if we can open a file with a share mode.
424 Returns True if conflict, False if not.
425 ****************************************************************************/
426
427 static bool share_conflict(struct share_mode_entry *entry,
428 uint32 access_mask,
429 uint32 share_access)
430 {
431 DEBUG(10,("share_conflict: entry->access_mask = 0x%x, "
432 "entry->share_access = 0x%x, "
433 "entry->private_options = 0x%x\n",
434 (unsigned int)entry->access_mask,
435 (unsigned int)entry->share_access,
436 (unsigned int)entry->private_options));
437
438 DEBUG(10,("share_conflict: access_mask = 0x%x, share_access = 0x%x\n",
439 (unsigned int)access_mask, (unsigned int)share_access));
440
441 if ((entry->access_mask & (FILE_WRITE_DATA|
442 FILE_APPEND_DATA|
443 FILE_READ_DATA|
444 FILE_EXECUTE|
445 DELETE_ACCESS)) == 0) {
446 DEBUG(10,("share_conflict: No conflict due to "
447 "entry->access_mask = 0x%x\n",
448 (unsigned int)entry->access_mask ));
449 return False;
450 }
451
452 if ((access_mask & (FILE_WRITE_DATA|
453 FILE_APPEND_DATA|
454 FILE_READ_DATA|
455 FILE_EXECUTE|
456 DELETE_ACCESS)) == 0) {
457 DEBUG(10,("share_conflict: No conflict due to "
458 "access_mask = 0x%x\n",
459 (unsigned int)access_mask ));
460 return False;
461 }
462
463 #if 1 /* JRA TEST - Superdebug. */
464 #define CHECK_MASK(num, am, right, sa, share) \
465 DEBUG(10,("share_conflict: [%d] am (0x%x) & right (0x%x) = 0x%x\n", \
466 (unsigned int)(num), (unsigned int)(am), \
467 (unsigned int)(right), (unsigned int)(am)&(right) )); \
468 DEBUG(10,("share_conflict: [%d] sa (0x%x) & share (0x%x) = 0x%x\n", \
469 (unsigned int)(num), (unsigned int)(sa), \
470 (unsigned int)(share), (unsigned int)(sa)&(share) )); \
471 if (((am) & (right)) && !((sa) & (share))) { \
472 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
473 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
474 (unsigned int)(share) )); \
475 return True; \
476 }
477 #else
478 #define CHECK_MASK(num, am, right, sa, share) \
479 if (((am) & (right)) && !((sa) & (share))) { \
480 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
481 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
482 (unsigned int)(share) )); \
483 return True; \
484 }
485 #endif
486
487 CHECK_MASK(1, entry->access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
488 share_access, FILE_SHARE_WRITE);
489 CHECK_MASK(2, access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
490 entry->share_access, FILE_SHARE_WRITE);
491
492 CHECK_MASK(3, entry->access_mask, FILE_READ_DATA | FILE_EXECUTE,
493 share_access, FILE_SHARE_READ);
494 CHECK_MASK(4, access_mask, FILE_READ_DATA | FILE_EXECUTE,
495 entry->share_access, FILE_SHARE_READ);
496
497 CHECK_MASK(5, entry->access_mask, DELETE_ACCESS,
498 share_access, FILE_SHARE_DELETE);
499 CHECK_MASK(6, access_mask, DELETE_ACCESS,
500 entry->share_access, FILE_SHARE_DELETE);
501
502 DEBUG(10,("share_conflict: No conflict.\n"));
503 return False;
504 }
505
506 #if defined(DEVELOPER)
507 static void validate_my_share_entries(int num,
508 struct share_mode_entry *share_entry)
509 {
510 files_struct *fsp;
511
512 if (!procid_is_me(&share_entry->pid)) {
513 return;
514 }
515
516 if (is_deferred_open_entry(share_entry) &&
517 !open_was_deferred(share_entry->op_mid)) {
518 char *str = talloc_asprintf(talloc_tos(),
519 "Got a deferred entry without a request: "
520 "PANIC: %s\n",
521 share_mode_str(talloc_tos(), num, share_entry));
522 smb_panic(str);
523 }
524
525 if (!is_valid_share_mode_entry(share_entry)) {
526 return;
527 }
528
529 fsp = file_find_dif(share_entry->id,
530 share_entry->share_file_id);
531 if (!fsp) {
532 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
533 share_mode_str(talloc_tos(), num, share_entry) ));
534 smb_panic("validate_my_share_entries: Cannot match a "
535 "share entry with an open file\n");
536 }
537
538 if (is_deferred_open_entry(share_entry) ||
539 is_unused_share_mode_entry(share_entry)) {
540 goto panic;
541 }
542
543 if ((share_entry->op_type == NO_OPLOCK) &&
544 (fsp->oplock_type == FAKE_LEVEL_II_OPLOCK)) {
545 /* Someone has already written to it, but I haven't yet
546 * noticed */
547 return;
548 }
549
550 if (((uint16)fsp->oplock_type) != share_entry->op_type) {
551 goto panic;
552 }
553
554 return;
555
556 panic:
557 {
558 char *str;
559 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
560 share_mode_str(talloc_tos(), num, share_entry) ));
561 str = talloc_asprintf(talloc_tos(),
562 "validate_my_share_entries: "
563 "file %s, oplock_type = 0x%x, op_type = 0x%x\n",
564 fsp->fsp_name, (unsigned int)fsp->oplock_type,
565 (unsigned int)share_entry->op_type );
566 smb_panic(str);
567 }
568 }
569 #endif
570
571 static bool is_stat_open(uint32 access_mask)
572 {
573 return (access_mask &&
574 ((access_mask & ~(SYNCHRONIZE_ACCESS| FILE_READ_ATTRIBUTES|
575 FILE_WRITE_ATTRIBUTES))==0) &&
576 ((access_mask & (SYNCHRONIZE_ACCESS|FILE_READ_ATTRIBUTES|
577 FILE_WRITE_ATTRIBUTES)) != 0));
578 }
579
580 /****************************************************************************
581 Deal with share modes
582 Invarient: Share mode must be locked on entry and exit.
583 Returns -1 on error, or number of share modes on success (may be zero).
584 ****************************************************************************/
585
586 static NTSTATUS open_mode_check(connection_struct *conn,
587 const char *fname,
588 struct share_mode_lock *lck,
589 uint32 access_mask,
590 uint32 share_access,
591 uint32 create_options,
592 bool *file_existed)
593 {
594 int i;
595
596 if(lck->num_share_modes == 0) {
597 return NT_STATUS_OK;
598 }
599
600 *file_existed = True;
601
602 /* A delete on close prohibits everything */
603
604 if (lck->delete_on_close) {
605 return NT_STATUS_DELETE_PENDING;
606 }
607
608 if (is_stat_open(access_mask)) {
609 /* Stat open that doesn't trigger oplock breaks or share mode
610 * checks... ! JRA. */
611 return NT_STATUS_OK;
612 }
613
614 /*
615 * Check if the share modes will give us access.
616 */
617
618 #if defined(DEVELOPER)
619 for(i = 0; i < lck->num_share_modes; i++) {
620 validate_my_share_entries(i, &lck->share_modes[i]);
621 }
622 #endif
623
624 if (!lp_share_modes(SNUM(conn))) {
625 return NT_STATUS_OK;
626 }
627
628 /* Now we check the share modes, after any oplock breaks. */
629 for(i = 0; i < lck->num_share_modes; i++) {
630
631 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
632 continue;
633 }
634
635 /* someone else has a share lock on it, check to see if we can
636 * too */
637 if (share_conflict(&lck->share_modes[i],
638 access_mask, share_access)) {
639 return NT_STATUS_SHARING_VIOLATION;
640 }
641 }
642
643 return NT_STATUS_OK;
644 }
645
646 static bool is_delete_request(files_struct *fsp) {
647 return ((fsp->access_mask == DELETE_ACCESS) &&
648 (fsp->oplock_type == NO_OPLOCK));
649 }
650
651 /*
652 * 1) No files open at all or internal open: Grant whatever the client wants.
653 *
654 * 2) Exclusive (or batch) oplock around: If the requested access is a delete
655 * request, break if the oplock around is a batch oplock. If it's another
656 * requested access type, break.
657 *
658 * 3) Only level2 around: Grant level2 and do nothing else.
659 */
660
661 static bool delay_for_oplocks(struct share_mode_lock *lck,
662 files_struct *fsp,
663 uint16 mid,
664 int pass_number,
665 int oplock_request)
666 {
667 int i;
668 struct share_mode_entry *exclusive = NULL;
669 bool valid_entry = False;
670 bool delay_it = False;
671 bool have_level2 = False;
672 NTSTATUS status;
673 char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
674
675 if (oplock_request & INTERNAL_OPEN_ONLY) {
676 fsp->oplock_type = NO_OPLOCK;
677 }
678
679 if ((oplock_request & INTERNAL_OPEN_ONLY) || is_stat_open(fsp->access_mask)) {
680 return False;
681 }
682
683 for (i=0; i<lck->num_share_modes; i++) {
684
685 if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
686 continue;
687 }
688
689 /* At least one entry is not an invalid or deferred entry. */
690 valid_entry = True;
691
692 if (pass_number == 1) {
693 if (BATCH_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
694 SMB_ASSERT(exclusive == NULL);
695 exclusive = &lck->share_modes[i];
696 }
697 } else {
698 if (EXCLUSIVE_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
699 SMB_ASSERT(exclusive == NULL);
700 exclusive = &lck->share_modes[i];
701 }
702 }
703
704 if (lck->share_modes[i].op_type == LEVEL_II_OPLOCK) {
705 SMB_ASSERT(exclusive == NULL);
706 have_level2 = True;
707 }
708 }
709
710 if (!valid_entry) {
711 /* All entries are placeholders or deferred.
712 * Directly grant whatever the client wants. */
713 if (fsp->oplock_type == NO_OPLOCK) {
714 /* Store a level2 oplock, but don't tell the client */
715 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
716 }
717 return False;
718 }
719
720 if (exclusive != NULL) { /* Found an exclusive oplock */
721 SMB_ASSERT(!have_level2);
722 delay_it = is_delete_request(fsp) ?
723 BATCH_OPLOCK_TYPE(exclusive->op_type) : True;
724 }
725
726 if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
727 /* We can at most grant level2 as there are other
728 * level2 or NO_OPLOCK entries. */
729 fsp->oplock_type = LEVEL_II_OPLOCK;
730 }
731
732 if ((fsp->oplock_type == NO_OPLOCK) && have_level2) {
733 /* Store a level2 oplock, but don't tell the client */
734 fsp->oplock_type = FAKE_LEVEL_II_OPLOCK;
735 }
736
737 if (!delay_it) {
738 return False;
739 }
740
741 /*
742 * Send a break message to the oplock holder and delay the open for
743 * our client.
744 */
745
746 DEBUG(10, ("Sending break request to PID %s\n",
747 procid_str_static(&exclusive->pid)));
748 exclusive->op_mid = mid;
749
750 /* Create the message. */
751 share_mode_entry_to_message(msg, exclusive);
752
753 /* Add in the FORCE_OPLOCK_BREAK_TO_NONE bit in the message if set. We
754 don't want this set in the share mode struct pointed to by lck. */
755
756 if (oplock_request & FORCE_OPLOCK_BREAK_TO_NONE) {
757 SSVAL(msg,6,exclusive->op_type | FORCE_OPLOCK_BREAK_TO_NONE);
758 }
759
760 status = messaging_send_buf(smbd_messaging_context(), exclusive->pid,
761 MSG_SMB_BREAK_REQUEST,
762 (uint8 *)msg,
763 MSG_SMB_SHARE_MODE_ENTRY_SIZE);
764 if (!NT_STATUS_IS_OK(status)) {
765 DEBUG(3, ("Could not send oplock break message: %s\n",
766 nt_errstr(status)));
767 }
768
769 return True;
770 }
771
772 static bool request_timed_out(struct timeval request_time,
773 struct timeval timeout)
774 {
775 struct timeval now, end_time;
776 GetTimeOfDay(&now);
777 end_time = timeval_sum(&request_time, &timeout);
778 return (timeval_compare(&end_time, &now) < 0);
779 }
780
781 /****************************************************************************
782 Handle the 1 second delay in returning a SHARING_VIOLATION error.
783 ****************************************************************************/
784
785 static void defer_open(struct share_mode_lock *lck,
786 struct timeval request_time,
787 struct timeval timeout,
788 struct smb_request *req,
789 struct deferred_open_record *state)
790 {
791 int i;
792
793 /* Paranoia check */
794
795 for (i=0; i<lck->num_share_modes; i++) {
796 struct share_mode_entry *e = &lck->share_modes[i];
797
798 if (!is_deferred_open_entry(e)) {
799 continue;
800 }
801
802 if (procid_is_me(&e->pid) && (e->op_mid == req->mid)) {
803 DEBUG(0, ("Trying to defer an already deferred "
804 "request: mid=%d, exiting\n", req->mid));
805 exit_server("attempt to defer a deferred request");
806 }
807 }
808
809 /* End paranoia check */
810
811 DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred "
812 "open entry for mid %u\n",
813 (unsigned int)request_time.tv_sec,
814 (unsigned int)request_time.tv_usec,
815 (unsigned int)req->mid));
816
817 if (!push_deferred_smb_message(req, request_time, timeout,
818 (char *)state, sizeof(*state))) {
819 exit_server("push_deferred_smb_message failed");
820 }
821 add_deferred_open(lck, req->mid, request_time, state->id);
822
823 /*
824 * Push the MID of this packet on the signing queue.
825 * We only do this once, the first time we push the packet
826 * onto the deferred open queue, as this has a side effect
827 * of incrementing the response sequence number.
828 */
829
830 srv_defer_sign_response(req->mid);
831 }
832
833
834 /****************************************************************************
835 On overwrite open ensure that the attributes match.
836 ****************************************************************************/
837
838 static bool open_match_attributes(connection_struct *conn,
839 const char *path,
840 uint32 old_dos_attr,
841 uint32 new_dos_attr,
842 mode_t existing_unx_mode,
843 mode_t new_unx_mode,
844 mode_t *returned_unx_mode)
845 {
846 uint32 noarch_old_dos_attr, noarch_new_dos_attr;
847
848 noarch_old_dos_attr = (old_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
849 noarch_new_dos_attr = (new_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
850
851 if((noarch_old_dos_attr == 0 && noarch_new_dos_attr != 0) ||
852 (noarch_old_dos_attr != 0 && ((noarch_old_dos_attr & noarch_new_dos_attr) == noarch_old_dos_attr))) {
853 *returned_unx_mode = new_unx_mode;
854 } else {
855 *returned_unx_mode = (mode_t)0;
856 }
857
858 DEBUG(10,("open_match_attributes: file %s old_dos_attr = 0x%x, "
859 "existing_unx_mode = 0%o, new_dos_attr = 0x%x "
860 "returned_unx_mode = 0%o\n",
861 path,
862 (unsigned int)old_dos_attr,
863 (unsigned int)existing_unx_mode,
864 (unsigned int)new_dos_attr,
865 (unsigned int)*returned_unx_mode ));
866
867 /* If we're mapping SYSTEM and HIDDEN ensure they match. */
868 if (lp_map_system(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
869 if ((old_dos_attr & FILE_ATTRIBUTE_SYSTEM) &&
870 !(new_dos_attr & FILE_ATTRIBUTE_SYSTEM)) {
871 return False;
872 }
873 }
874 if (lp_map_hidden(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
875 if ((old_dos_attr & FILE_ATTRIBUTE_HIDDEN) &&
876 !(new_dos_attr & FILE_ATTRIBUTE_HIDDEN)) {
877 return False;
878 }
879 }
880 return True;
881 }
882
883 /****************************************************************************
884 Special FCB or DOS processing in the case of a sharing violation.
885 Try and find a duplicated file handle.
886 ****************************************************************************/
887
888 static files_struct *fcb_or_dos_open(connection_struct *conn,
889 const char *fname,
890 struct file_id id,
891 uint16 file_pid,
892 uint16 vuid,
893 uint32 access_mask,
894 uint32 share_access,
895 uint32 create_options)
896 {
897 files_struct *fsp;
898 files_struct *dup_fsp;
899
900 DEBUG(5,("fcb_or_dos_open: attempting old open semantics for "
901 "file %s.\n", fname ));
902
903 for(fsp = file_find_di_first(id); fsp;
904 fsp = file_find_di_next(fsp)) {
905
906 DEBUG(10,("fcb_or_dos_open: checking file %s, fd = %d, "
907 "vuid = %u, file_pid = %u, private_options = 0x%x "
908 "access_mask = 0x%x\n", fsp->fsp_name,
909 fsp->fh->fd, (unsigned int)fsp->vuid,
910 (unsigned int)fsp->file_pid,
911 (unsigned int)fsp->fh->private_options,
912 (unsigned int)fsp->access_mask ));
913
914 if (fsp->fh->fd != -1 &&
915 fsp->vuid == vuid &&
916 fsp->file_pid == file_pid &&
917 (fsp->fh->private_options & (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS |
918 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) &&
919 (fsp->access_mask & FILE_WRITE_DATA) &&
920 strequal(fsp->fsp_name, fname)) {
921 DEBUG(10,("fcb_or_dos_open: file match\n"));
922 break;
923 }
924 }
925
926 if (!fsp) {
927 return NULL;
928 }
929
930 /* quite an insane set of semantics ... */
931 if (is_executable(fname) &&
932 (fsp->fh->private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS)) {
933 DEBUG(10,("fcb_or_dos_open: file fail due to is_executable.\n"));
934 return NULL;
935 }
936
937 /* We need to duplicate this fsp. */
938 if (!NT_STATUS_IS_OK(dup_file_fsp(fsp, access_mask, share_access,
939 create_options, &dup_fsp))) {
940 return NULL;
941 }
942
943 return dup_fsp;
944 }
945
946 /****************************************************************************
947 Open a file with a share mode - old openX method - map into NTCreate.
948 ****************************************************************************/
949
950 bool map_open_params_to_ntcreate(const char *fname, int deny_mode, int open_func,
951 uint32 *paccess_mask,
952 uint32 *pshare_mode,
953 uint32 *pcreate_disposition,
954 uint32 *pcreate_options)
955 {
956 uint32 access_mask;
957 uint32 share_mode;
958 uint32 create_disposition;
959 uint32 create_options = 0;
960
961 DEBUG(10,("map_open_params_to_ntcreate: fname = %s, deny_mode = 0x%x, "
962 "open_func = 0x%x\n",
963 fname, (unsigned int)deny_mode, (unsigned int)open_func ));
964
965 /* Create the NT compatible access_mask. */
966 switch (GET_OPENX_MODE(deny_mode)) {
967 case DOS_OPEN_EXEC: /* Implies read-only - used to be FILE_READ_DATA */
968 case DOS_OPEN_RDONLY:
969 access_mask = FILE_GENERIC_READ;
970 break;
971 case DOS_OPEN_WRONLY:
972 access_mask = FILE_GENERIC_WRITE;
973 break;
974 case DOS_OPEN_RDWR:
975 case DOS_OPEN_FCB:
976 access_mask = FILE_GENERIC_READ|FILE_GENERIC_WRITE;
977 break;
978 default:
979 DEBUG(10,("map_open_params_to_ntcreate: bad open mode = 0x%x\n",
980 (unsigned int)GET_OPENX_MODE(deny_mode)));
981 return False;
982 }
983
984 /* Create the NT compatible create_disposition. */
985 switch (open_func) {
986 case OPENX_FILE_EXISTS_FAIL|OPENX_FILE_CREATE_IF_NOT_EXIST:
987 create_disposition = FILE_CREATE;
988 break;
989
990 case OPENX_FILE_EXISTS_OPEN:
991 create_disposition = FILE_OPEN;
992 break;
993
994 case OPENX_FILE_EXISTS_OPEN|OPENX_FILE_CREATE_IF_NOT_EXIST:
995 create_disposition = FILE_OPEN_IF;
996 break;
997
998 case OPENX_FILE_EXISTS_TRUNCATE:
999 create_disposition = FILE_OVERWRITE;
1000 break;
1001
1002 case OPENX_FILE_EXISTS_TRUNCATE|OPENX_FILE_CREATE_IF_NOT_EXIST:
1003 create_disposition = FILE_OVERWRITE_IF;
1004 break;
1005
1006 default:
1007 /* From samba4 - to be confirmed. */
1008 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_EXEC) {
1009 create_disposition = FILE_CREATE;
1010 break;
1011 }
1012 DEBUG(10,("map_open_params_to_ntcreate: bad "
1013 "open_func 0x%x\n", (unsigned int)open_func));
1014 return False;
1015 }
1016
1017 /* Create the NT compatible share modes. */
1018 switch (GET_DENY_MODE(deny_mode)) {
1019 case DENY_ALL:
1020 share_mode = FILE_SHARE_NONE;
1021 break;
1022
1023 case DENY_WRITE:
1024 share_mode = FILE_SHARE_READ;
1025 break;
1026
1027 case DENY_READ:
1028 share_mode = FILE_SHARE_WRITE;
1029 break;
1030
1031 case DENY_NONE:
1032 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
1033 break;
1034
1035 case DENY_DOS:
1036 create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_DOS;
1037 if (is_executable(fname)) {
1038 share_mode = FILE_SHARE_READ|FILE_SHARE_WRITE;
1039 } else {
1040 if (GET_OPENX_MODE(deny_mode) == DOS_OPEN_RDONLY) {
1041 share_mode = FILE_SHARE_READ;
1042 } else {
1043 share_mode = FILE_SHARE_NONE;
1044 }
1045 }
1046 break;
1047
1048 case DENY_FCB:
1049 create_options |= NTCREATEX_OPTIONS_PRIVATE_DENY_FCB;
1050 share_mode = FILE_SHARE_NONE;
1051 break;
1052
1053 default:
1054 DEBUG(10,("map_open_params_to_ntcreate: bad deny_mode 0x%x\n",
1055 (unsigned int)GET_DENY_MODE(deny_mode) ));
1056 return False;
1057 }
1058
1059 DEBUG(10,("map_open_params_to_ntcreate: file %s, access_mask = 0x%x, "
1060 "share_mode = 0x%x, create_disposition = 0x%x, "
1061 "create_options = 0x%x\n",
1062 fname,
1063 (unsigned int)access_mask,
1064 (unsigned int)share_mode,
1065 (unsigned int)create_disposition,
1066 (unsigned int)create_options ));
1067
1068 if (paccess_mask) {
1069 *paccess_mask = access_mask;
1070 }
1071 if (pshare_mode) {
1072 *pshare_mode = share_mode;
1073 }
1074 if (pcreate_disposition) {
1075 *pcreate_disposition = create_disposition;
1076 }
1077 if (pcreate_options) {
1078 *pcreate_options = create_options;
1079 }
1080
1081 return True;
1082
1083 }
1084
1085 static void schedule_defer_open(struct share_mode_lock *lck,
1086 struct timeval request_time,
1087 struct smb_request *req)
1088 {
1089 struct deferred_open_record state;
1090
1091 /* This is a relative time, added to the absolute
1092 request_time value to get the absolute timeout time.
1093 Note that if this is the second or greater time we enter
1094 this codepath for this particular request mid then
1095 request_time is left as the absolute time of the *first*
1096 time this request mid was processed. This is what allows
1097 the request to eventually time out. */
1098
1099 struct timeval timeout;
1100
1101 /* Normally the smbd we asked should respond within
1102 * OPLOCK_BREAK_TIMEOUT seconds regardless of whether
1103 * the client did, give twice the timeout as a safety
1104 * measure here in case the other smbd is stuck
1105 * somewhere else. */
1106
1107 timeout = timeval_set(OPLOCK_BREAK_TIMEOUT*2, 0);
1108
1109 /* Nothing actually uses state.delayed_for_oplocks
1110 but it's handy to differentiate in debug messages
1111 between a 30 second delay due to oplock break, and
1112 a 1 second delay for share mode conflicts. */
1113
1114 state.delayed_for_oplocks = True;
1115 state.id = lck->id;
1116
1117 if (!request_timed_out(request_time, timeout)) {
1118 defer_open(lck, request_time, timeout, req, &state);
1119 }
1120 }
1121
1122 /****************************************************************************
1123 Open a file with a share mode.
1124 ****************************************************************************/
1125
1126 NTSTATUS open_file_ntcreate(connection_struct *conn,
1127 struct smb_request *req,
1128 const char *fname,
1129 SMB_STRUCT_STAT *psbuf,
1130 uint32 access_mask, /* access bits (FILE_READ_DATA etc.) */
1131 uint32 share_access, /* share constants (FILE_SHARE_READ etc) */
1132 uint32 create_disposition, /* FILE_OPEN_IF etc. */
1133 uint32 create_options, /* options such as delete on close. */
1134 uint32 new_dos_attributes, /* attributes used for new file. */
1135 int oplock_request, /* internal Samba oplock codes. */
1136 /* Information (FILE_EXISTS etc.) */
1137 int *pinfo,
1138 files_struct **result)
1139 {
1140 int flags=0;
1141 int flags2=0;
1142 bool file_existed = VALID_STAT(*psbuf);
1143 bool def_acl = False;
1144 bool posix_open = False;
1145 bool new_file_created = False;
1146 struct file_id id;
1147 NTSTATUS fsp_open = NT_STATUS_ACCESS_DENIED;
1148 files_struct *fsp = NULL;
1149 mode_t new_unx_mode = (mode_t)0;
1150 mode_t unx_mode = (mode_t)0;
1151 int info;
1152 uint32 existing_dos_attributes = 0;
1153 struct pending_message_list *pml = NULL;
1154 struct timeval request_time = timeval_zero();
1155 struct share_mode_lock *lck = NULL;
1156 uint32 open_access_mask = access_mask;
1157 NTSTATUS status;
1158 int ret_flock;
1159 char *parent_dir;
1160 const char *newname;
1161
1162 ZERO_STRUCT(id);
1163
1164 if (conn->printer) {
1165 /*
1166 * Printers are handled completely differently.
1167 * Most of the passed parameters are ignored.
1168 */
1169
1170 if (pinfo) {
1171 *pinfo = FILE_WAS_CREATED;
1172 }
1173
1174 DEBUG(10, ("open_file_ntcreate: printer open fname=%s\n", fname));
1175
1176 return print_fsp_open(conn, fname, result);
1177 }
1178
1179 if (!parent_dirname_talloc(talloc_tos(), fname, &parent_dir,
1180 &newname)) {
1181 return NT_STATUS_NO_MEMORY;
1182 }
1183
1184 if (new_dos_attributes & FILE_FLAG_POSIX_SEMANTICS) {
1185 posix_open = True;
1186 unx_mode = (mode_t)(new_dos_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
1187 new_dos_attributes = 0;
1188 } else {
1189 /* We add aARCH to this as this mode is only used if the file is
1190 * created new. */
1191 unx_mode = unix_mode(conn, new_dos_attributes | aARCH, fname,
1192 parent_dir);
1193 }
1194
1195 DEBUG(10, ("open_file_ntcreate: fname=%s, dos_attrs=0x%x "
1196 "access_mask=0x%x share_access=0x%x "
1197 "create_disposition = 0x%x create_options=0x%x "
1198 "unix mode=0%o oplock_request=%d\n",
1199 fname, new_dos_attributes, access_mask, share_access,
1200 create_disposition, create_options, unx_mode,
1201 oplock_request));
1202
1203 if ((req == NULL) && ((oplock_request & INTERNAL_OPEN_ONLY) == 0)) {
1204 DEBUG(0, ("No smb request but not an internal only open!\n"));
1205 return NT_STATUS_INTERNAL_ERROR;
1206 }
1207
1208 /*
1209 * Only non-internal opens can be deferred at all
1210 */
1211
1212 if ((req != NULL)
1213 && ((pml = get_open_deferred_message(req->mid)) != NULL)) {
1214 struct deferred_open_record *state =
1215 (struct deferred_open_record *)pml->private_data.data;
1216
1217 /* Remember the absolute time of the original
1218 request with this mid. We'll use it later to
1219 see if this has timed out. */
1220
1221 request_time = pml->request_time;
1222
1223 /* Remove the deferred open entry under lock. */
1224 lck = get_share_mode_lock(talloc_tos(), state->id, NULL, NULL);
1225 if (lck == NULL) {
1226 DEBUG(0, ("could not get share mode lock\n"));
1227 } else {
1228 del_deferred_open_entry(lck, req->mid);
1229 TALLOC_FREE(lck);
1230 }
1231
1232 /* Ensure we don't reprocess this message. */
1233 remove_deferred_open_smb_message(req->mid);
1234 }
1235
1236 status = check_name(conn, fname);
1237 if (!NT_STATUS_IS_OK(status)) {
1238 return status;
1239 }
1240
1241 if (!posix_open) {
1242 new_dos_attributes &= SAMBA_ATTRIBUTES_MASK;
1243 if (file_existed) {
1244 existing_dos_attributes = dos_mode(conn, fname, psbuf);
1245 }
1246 }
1247
1248 /* ignore any oplock requests if oplocks are disabled */
1249 if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break ||
1250 IS_VETO_OPLOCK_PATH(conn, fname)) {
1251 /* Mask off everything except the private Samba bits. */
1252 oplock_request &= SAMBA_PRIVATE_OPLOCK_MASK;
1253 }
1254
1255 /* this is for OS/2 long file names - say we don't support them */
1256 if (!lp_posix_pathnames() && strstr(fname,".+,;=[].")) {
1257 /* OS/2 Workplace shell fix may be main code stream in a later
1258 * release. */
1259 DEBUG(5,("open_file_ntcreate: OS/2 long filenames are not "
1260 "supported.\n"));
1261 if (use_nt_status()) {
1262 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1263 }
1264 return NT_STATUS_DOS(ERRDOS, ERRcannotopen);
1265 }
1266
1267 switch( create_disposition ) {
1268 /*
1269 * Currently we're using FILE_SUPERSEDE as the same as
1270 * FILE_OVERWRITE_IF but they really are
1271 * different. FILE_SUPERSEDE deletes an existing file
1272 * (requiring delete access) then recreates it.
1273 */
1274 case FILE_SUPERSEDE:
1275 /* If file exists replace/overwrite. If file doesn't
1276 * exist create. */
1277 flags2 |= (O_CREAT | O_TRUNC);
1278 break;
1279
1280 case FILE_OVERWRITE_IF:
1281 /* If file exists replace/overwrite. If file doesn't
1282 * exist create. */
1283 flags2 |= (O_CREAT | O_TRUNC);
1284 break;
1285
1286 case FILE_OPEN:
1287 /* If file exists open. If file doesn't exist error. */
1288 if (!file_existed) {
1289 DEBUG(5,("open_file_ntcreate: FILE_OPEN "
1290 "requested for file %s and file "
1291 "doesn't exist.\n", fname ));
1292 errno = ENOENT;
1293 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1294 }
1295 break;
1296
1297 case FILE_OVERWRITE:
1298 /* If file exists overwrite. If file doesn't exist
1299 * error. */
1300 if (!file_existed) {
1301 DEBUG(5,("open_file_ntcreate: FILE_OVERWRITE "
1302 "requested for file %s and file "
1303 "doesn't exist.\n", fname ));
1304 errno = ENOENT;
1305 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1306 }
1307 flags2 |= O_TRUNC;
1308 break;
1309
1310 case FILE_CREATE:
1311 /* If file exists error. If file doesn't exist
1312 * create. */
1313 if (file_existed) {
1314 DEBUG(5,("open_file_ntcreate: FILE_CREATE "
1315 "requested for file %s and file "
1316 "already exists.\n", fname ));
1317 if (S_ISDIR(psbuf->st_mode)) {
1318 errno = EISDIR;
1319 } else {
1320 errno = EEXIST;
1321 }
1322 return map_nt_error_from_unix(errno);
1323 }
1324 flags2 |= (O_CREAT|O_EXCL);
1325 break;
1326
1327 case FILE_OPEN_IF:
1328 /* If file exists open. If file doesn't exist
1329 * create. */
1330 flags2 |= O_CREAT;
1331 break;
1332
1333 default:
1334 return NT_STATUS_INVALID_PARAMETER;
1335 }
1336
1337 /* We only care about matching attributes on file exists and
1338 * overwrite. */
1339
1340 if (!posix_open && file_existed && ((create_disposition == FILE_OVERWRITE) ||
1341 (create_disposition == FILE_OVERWRITE_IF))) {
1342 if (!open_match_attributes(conn, fname,
1343 existing_dos_attributes,
1344 new_dos_attributes, psbuf->st_mode,
1345 unx_mode, &new_unx_mode)) {
1346 DEBUG(5,("open_file_ntcreate: attributes missmatch "
1347 "for file %s (%x %x) (0%o, 0%o)\n",
1348 fname, existing_dos_attributes,
1349 new_dos_attributes,
1350 (unsigned int)psbuf->st_mode,
1351 (unsigned int)unx_mode ));
1352 errno = EACCES;
1353 return NT_STATUS_ACCESS_DENIED;
1354 }
1355 }
1356
1357 /* This is a nasty hack - must fix... JRA. */
1358 if (access_mask == MAXIMUM_ALLOWED_ACCESS) {
1359 open_access_mask = access_mask = FILE_GENERIC_ALL;
1360 }
1361
1362 /*
1363 * Convert GENERIC bits to specific bits.
1364 */
1365
1366 se_map_generic(&access_mask, &file_generic_mapping);
1367 open_access_mask = access_mask;
1368
1369 if ((flags2 & O_TRUNC) || (oplock_request & FORCE_OPLOCK_BREAK_TO_NONE)) {
1370 open_access_mask |= FILE_WRITE_DATA; /* This will cause oplock breaks. */
1371 }
1372
1373 DEBUG(10, ("open_file_ntcreate: fname=%s, after mapping "
1374 "access_mask=0x%x\n", fname, access_mask ));
1375
1376 /*
1377 * Note that we ignore the append flag as append does not
1378 * mean the same thing under DOS and Unix.
1379 */
1380
1381 if ((access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) ||
1382 (oplock_request & FORCE_OPLOCK_BREAK_TO_NONE)) {
1383 /* DENY_DOS opens are always underlying read-write on the
1384 file handle, no matter what the requested access mask
1385 says. */
1386 if ((create_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) ||
1387 access_mask & (FILE_READ_ATTRIBUTES|FILE_READ_DATA|FILE_READ_EA|FILE_EXECUTE)) {
1388 flags = O_RDWR;
1389 } else {
1390 flags = O_WRONLY;
1391 }
1392 } else {
1393 flags = O_RDONLY;
1394 }
1395
1396 /*
1397 * Currently we only look at FILE_WRITE_THROUGH for create options.
1398 */
1399
1400 #if defined(O_SYNC)
1401 if ((create_options & FILE_WRITE_THROUGH) && lp_strict_sync(SNUM(conn))) {
1402 flags2 |= O_SYNC;
1403 }
1404 #endif /* O_SYNC */
1405
1406 if (posix_open && (access_mask & FILE_APPEND_DATA)) {
1407 flags2 |= O_APPEND;
1408 }
1409
1410 if (!posix_open && !CAN_WRITE(conn)) {
1411 /*
1412 * We should really return a permission denied error if either
1413 * O_CREAT or O_TRUNC are set, but for compatibility with
1414 * older versions of Samba we just AND them out.
1415 */
1416 flags2 &= ~(O_CREAT|O_TRUNC);
1417 }
1418
1419 /*
1420 * Ensure we can't write on a read-only share or file.
1421 */
1422
1423 if (flags != O_RDONLY && file_existed &&
1424 (!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_attributes))) {
1425 DEBUG(5,("open_file_ntcreate: write access requested for "
1426 "file %s on read only %s\n",
1427 fname, !CAN_WRITE(conn) ? "share" : "file" ));
1428 errno = EACCES;
1429 return NT_STATUS_ACCESS_DENIED;
1430 }
1431
1432 status = file_new(conn, &fsp);
1433 if(!NT_STATUS_IS_OK(status)) {
1434 return status;
1435 }
1436
1437 fsp->file_id = vfs_file_id_from_sbuf(conn, psbuf);
1438 fsp->share_access = share_access;
1439 fsp->fh->private_options = create_options;
1440 fsp->access_mask = open_access_mask; /* We change this to the
1441 * requested access_mask after
1442 * the open is done. */
1443 fsp->posix_open = posix_open;
1444
1445 /* Ensure no SAMBA_PRIVATE bits can be set. */
1446 fsp->oplock_type = (oplock_request & ~SAMBA_PRIVATE_OPLOCK_MASK);
1447
1448 if (timeval_is_zero(&request_time)) {
1449 request_time = fsp->open_time;
1450 }
1451
1452 if (file_existed) {
1453 id = vfs_file_id_from_sbuf(conn, psbuf);
1454
1455 lck = get_share_mode_lock(talloc_tos(), id,
1456 conn->connectpath,
1457 fname);
1458
1459 if (lck == NULL) {
1460 file_free(fsp);
1461 DEBUG(0, ("Could not get share mode lock\n"));
1462 return NT_STATUS_SHARING_VIOLATION;
1463 }
1464
1465 /* First pass - send break only on batch oplocks. */
1466 if ((req != NULL)
1467 && delay_for_oplocks(lck, fsp, req->mid, 1,
1468 oplock_request)) {
1469 schedule_defer_open(lck, request_time, req);
1470 TALLOC_FREE(lck);
1471 file_free(fsp);
1472 return NT_STATUS_SHARING_VIOLATION;
1473 }
1474
1475 /* Use the client requested access mask here, not the one we
1476 * open with. */
1477 status = open_mode_check(conn, fname, lck,
1478 access_mask, share_access,
1479 create_options, &file_existed);
1480
1481 if (NT_STATUS_IS_OK(status)) {
1482 /* We might be going to allow this open. Check oplock
1483 * status again. */
1484 /* Second pass - send break for both batch or
1485 * exclusive oplocks. */
1486 if ((req != NULL)
1487 && delay_for_oplocks(lck, fsp, req->mid, 2,
1488 oplock_request)) {
1489 schedule_defer_open(lck, request_time, req);
1490 TALLOC_FREE(lck);
1491 file_free(fsp);
1492 return NT_STATUS_SHARING_VIOLATION;
1493 }
1494 }
1495
1496 if (NT_STATUS_EQUAL(status, NT_STATUS_DELETE_PENDING)) {
1497 /* DELETE_PENDING is not deferred for a second */
1498 TALLOC_FREE(lck);
1499 file_free(fsp);
1500 return status;
1501 }
1502
1503 if (!NT_STATUS_IS_OK(status)) {
1504 uint32 can_access_mask;
1505 bool can_access = True;
1506
1507 SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION));
1508
1509 /* Check if this can be done with the deny_dos and fcb
1510 * calls. */
1511 if (create_options &
1512 (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS|
1513 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
1514 files_struct *fsp_dup;
1515
1516 if (req == NULL) {
1517 DEBUG(0, ("DOS open without an SMB "
1518 "request!\n"));
1519 TALLOC_FREE(lck);
1520 file_free(fsp);
1521 return NT_STATUS_INTERNAL_ERROR;
1522 }
1523
1524 /* Use the client requested access mask here,
1525 * not the one we open with. */
1526 fsp_dup = fcb_or_dos_open(conn, fname, id,
1527 req->smbpid,
1528 req->vuid,
1529 access_mask,
1530 share_access,
1531 create_options);
1532
1533 if (fsp_dup) {
1534 TALLOC_FREE(lck);
1535 file_free(fsp);
1536 if (pinfo) {
1537 *pinfo = FILE_WAS_OPENED;
1538 }
1539 conn->num_files_open++;
1540 *result = fsp_dup;
1541 return NT_STATUS_OK;
1542 }
1543 }
1544
1545 /*
1546 * This next line is a subtlety we need for
1547 * MS-Access. If a file open will fail due to share
1548 * permissions and also for security (access) reasons,
1549 * we need to return the access failed error, not the
1550 * share error. We can't open the file due to kernel
1551 * oplock deadlock (it's possible we failed above on
1552 * the open_mode_check()) so use a userspace check.
1553 */
1554
1555 if (flags & O_RDWR) {
1556 can_access_mask = FILE_READ_DATA|FILE_WRITE_DATA;
1557 } else if (flags & O_WRONLY) {
1558 can_access_mask = FILE_WRITE_DATA;
1559 } else {
1560 can_access_mask = FILE_READ_DATA;
1561 }
1562
1563 if (((can_access_mask & FILE_WRITE_DATA) && !CAN_WRITE(conn)) ||
1564 !can_access_file(conn,fname,psbuf,can_access_mask)) {
1565 can_access = False;
1566 }
1567
1568 /*
1569 * If we're returning a share violation, ensure we
1570 * cope with the braindead 1 second delay.
1571 */
1572
1573 if (!(oplock_request & INTERNAL_OPEN_ONLY) &&
1574 lp_defer_sharing_violations()) {
1575 struct timeval timeout;
1576 struct deferred_open_record state;
1577 int timeout_usecs;
1578
1579 /* this is a hack to speed up torture tests
1580 in 'make test' */
1581 timeout_usecs = lp_parm_int(SNUM(conn),
1582 "smbd","sharedelay",
1583 SHARING_VIOLATION_USEC_WAIT);
1584
1585 /* This is a relative time, added to the absolute
1586 request_time value to get the absolute timeout time.
1587 Note that if this is the second or greater time we enter
1588 this codepath for this particular request mid then
1589 request_time is left as the absolute time of the *first*
1590 time this request mid was processed. This is what allows
1591 the request to eventually time out. */
1592
1593 timeout = timeval_set(0, timeout_usecs);
1594
1595 /* Nothing actually uses state.delayed_for_oplocks
1596 but it's handy to differentiate in debug messages
1597 between a 30 second delay due to oplock break, and
1598 a 1 second delay for share mode conflicts. */
1599
1600 state.delayed_for_oplocks = False;
1601 state.id = id;
1602
1603 if ((req != NULL)
1604 && !request_timed_out(request_time,
1605 timeout)) {
1606 defer_open(lck, request_time, timeout,
1607 req, &state);
1608 }
1609 }
1610
1611 TALLOC_FREE(lck);
1612 if (can_access) {
1613 /*
1614 * We have detected a sharing violation here
1615 * so return the correct error code
1616 */
1617 status = NT_STATUS_SHARING_VIOLATION;
1618 } else {
1619 status = NT_STATUS_ACCESS_DENIED;
1620 }
1621 file_free(fsp);
1622 return status;
1623 }
1624
1625 /*
1626 * We exit this block with the share entry *locked*.....
1627 */
1628 }
1629
1630 SMB_ASSERT(!file_existed || (lck != NULL));
1631
1632 /*
1633 * Ensure we pay attention to default ACLs on directories if required.
1634 */
1635
1636 if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
1637 (def_acl = directory_has_default_acl(conn, parent_dir))) {
1638 unx_mode = 0777;
1639 }
1640
1641 DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o, "
1642 "access_mask = 0x%x, open_access_mask = 0x%x\n",
1643 (unsigned int)flags, (unsigned int)flags2,
1644 (unsigned int)unx_mode, (unsigned int)access_mask,
1645 (unsigned int)open_access_mask));
1646
1647 /*
1648 * open_file strips any O_TRUNC flags itself.
1649 */
1650
1651 fsp_open = open_file(fsp, conn, req, parent_dir, newname, fname, psbuf,
1652 flags|flags2, unx_mode, access_mask,
1653 open_access_mask);
1654
1655 if (!NT_STATUS_IS_OK(fsp_open)) {
1656 if (lck != NULL) {
1657 TALLOC_FREE(lck);
1658 }
1659 file_free(fsp);
1660 return fsp_open;
1661 }
1662
1663 if (!file_existed) {
1664
1665 /*
1666 * Deal with the race condition where two smbd's detect the
1667 * file doesn't exist and do the create at the same time. One
1668 * of them will win and set a share mode, the other (ie. this
1669 * one) should check if the requested share mode for this
1670 * create is allowed.
1671 */
1672
1673 /*
1674 * Now the file exists and fsp is successfully opened,
1675 * fsp->dev and fsp->inode are valid and should replace the
1676 * dev=0,inode=0 from a non existent file. Spotted by
1677 * Nadav Danieli <nadavd@exanet.com>. JRA.
1678 */
1679
1680 id = fsp->file_id;
1681
1682 lck = get_share_mode_lock(talloc_tos(), id,
1683 conn->connectpath,
1684 fname);
1685
1686 if (lck == NULL) {
1687 DEBUG(0, ("open_file_ntcreate: Could not get share "
1688 "mode lock for %s\n", fname));
1689 fd_close(fsp);
1690 file_free(fsp);
1691 return NT_STATUS_SHARING_VIOLATION;
1692 }
1693
1694 /* First pass - send break only on batch oplocks. */
1695 if ((req != NULL)
1696 && delay_for_oplocks(lck, fsp, req->mid, 1,
1697 oplock_request)) {
1698 schedule_defer_open(lck, request_time, req);
1699 TALLOC_FREE(lck);
1700 fd_close(fsp);
1701 file_free(fsp);
1702 return NT_STATUS_SHARING_VIOLATION;
1703 }
1704
1705 status = open_mode_check(conn, fname, lck,
1706 access_mask, share_access,
1707 create_options, &file_existed);
1708
1709 if (NT_STATUS_IS_OK(status)) {
1710 /* We might be going to allow this open. Check oplock
1711 * status again. */
1712 /* Second pass - send break for both batch or
1713 * exclusive oplocks. */
1714 if ((req != NULL)
1715 && delay_for_oplocks(lck, fsp, req->mid, 2,
1716 oplock_request)) {
1717 schedule_defer_open(lck, request_time, req);
1718 TALLOC_FREE(lck);
1719 fd_close(fsp);
1720 file_free(fsp);
1721 return NT_STATUS_SHARING_VIOLATION;
1722 }
1723 }
1724
1725 if (!NT_STATUS_IS_OK(status)) {
1726 struct deferred_open_record state;
1727
1728 fd_close(fsp);
1729 file_free(fsp);
1730
1731 state.delayed_for_oplocks = False;
1732 state.id = id;
1733
1734 /* Do it all over again immediately. In the second
1735 * round we will find that the file existed and handle
1736 * the DELETE_PENDING and FCB cases correctly. No need
1737 * to duplicate the code here. Essentially this is a
1738 * "goto top of this function", but don't tell
1739 * anybody... */
1740
1741 if (req != NULL) {
1742 defer_open(lck, request_time, timeval_zero(),
1743 req, &state);
1744 }
1745 TALLOC_FREE(lck);
1746 return status;
1747 }
1748
1749 /*
1750 * We exit this block with the share entry *locked*.....
1751 */
1752
1753 }
1754
1755 SMB_ASSERT(lck != NULL);
1756
1757 /* note that we ignore failure for the following. It is
1758 basically a hack for NFS, and NFS will never set one of
1759 these only read them. Nobody but Samba can ever set a deny
1760 mode and we have already checked our more authoritative
1761 locking database for permission to set this deny mode. If
1762 the kernel refuses the operations then the kernel is wrong.
1763 note that GPFS supports it as well - jmcd */
1764
1765 if (fsp->fh->fd != -1) {
1766 ret_flock = SMB_VFS_KERNEL_FLOCK(fsp, share_access);
1767 if(ret_flock == -1 ){
1768
1769 TALLOC_FREE(lck);
1770 fd_close(fsp);
1771 file_free(fsp);
1772
1773 return NT_STATUS_SHARING_VIOLATION;
1774 }
1775 }
1776
1777 /*
1778 * At this point onwards, we can guarentee that the share entry
1779 * is locked, whether we created the file or not, and that the
1780 * deny mode is compatible with all current opens.
1781 */
1782
1783 /*
1784 * If requested, truncate the file.
1785 */
1786
1787 if (flags2&O_TRUNC) {
1788 /*
1789 * We are modifing the file after open - update the stat
1790 * struct..
1791 */
1792 if ((SMB_VFS_FTRUNCATE(fsp, 0) == -1) ||
1793 (SMB_VFS_FSTAT(fsp, psbuf)==-1)) {
1794 status = map_nt_error_from_unix(errno);
1795 TALLOC_FREE(lck);
1796 fd_close(fsp);
1797 file_free(fsp);
1798 return status;
1799 }
1800 }
1801
1802 /* Record the options we were opened with. */
1803 fsp->share_access = share_access;
1804 fsp->fh->private_options = create_options;
1805 fsp->access_mask = access_mask;
1806
1807 if (file_existed) {
1808 /* stat opens on existing files don't get oplocks. */
1809 if (is_stat_open(open_access_mask)) {
1810 fsp->oplock_type = NO_OPLOCK;
1811 }
1812
1813 if (!(flags2 & O_TRUNC)) {
1814 info = FILE_WAS_OPENED;
1815 } else {
1816 info = FILE_WAS_OVERWRITTEN;
1817 }
1818 } else {
1819 info = FILE_WAS_CREATED;
1820 }
1821
1822 if (pinfo) {
1823 *pinfo = info;
1824 }
1825
1826 /*
1827 * Setup the oplock info in both the shared memory and
1828 * file structs.
1829 */
1830
1831 if ((fsp->oplock_type != NO_OPLOCK) &&
1832 (fsp->oplock_type != FAKE_LEVEL_II_OPLOCK)) {
1833 if (!set_file_oplock(fsp, fsp->oplock_type)) {
1834 /* Could not get the kernel oplock */
1835 fsp->oplock_type = NO_OPLOCK;
1836 }
1837 }
1838
1839 if (info == FILE_WAS_OVERWRITTEN || info == FILE_WAS_CREATED || info == FILE_WAS_SUPERSEDED) {
1840 new_file_created = True;
1841 }
1842
1843 set_share_mode(lck, fsp, current_user.ut.uid, 0, fsp->oplock_type, new_file_created);
1844
1845 /* Handle strange delete on close create semantics. */
1846 if ((create_options & FILE_DELETE_ON_CLOSE)
1847 && (is_ntfs_stream_name(fname)
1848 || can_set_initial_delete_on_close(lck))) {
1849 status = can_set_delete_on_close(fsp, True, new_dos_attributes);
1850
1851 if (!NT_STATUS_IS_OK(status)) {
1852 /* Remember to delete the mode we just added. */
1853 del_share_mode(lck, fsp);
1854 TALLOC_FREE(lck);
1855 fd_close(fsp);
1856 file_free(fsp);
1857 return status;
1858 }
1859 /* Note that here we set the *inital* delete on close flag,
1860 not the regular one. The magic gets handled in close. */
1861 fsp->initial_delete_on_close = True;
1862 }
1863
1864 if (new_file_created) {
1865 /* Files should be initially set as archive */
1866 if (lp_map_archive(SNUM(conn)) ||
1867 lp_store_dos_attributes(SNUM(conn))) {
1868 if (!posix_open) {
1869 SMB_STRUCT_STAT tmp_sbuf;
1870 SET_STAT_INVALID(tmp_sbuf);
1871 if (file_set_dosmode(
1872 conn, fname,
1873 new_dos_attributes | aARCH,
1874 &tmp_sbuf, parent_dir,
1875 true) == 0) {
1876 unx_mode = tmp_sbuf.st_mode;
1877 }
1878 }
1879 }
1880 }
1881
1882 /*
1883 * Take care of inherited ACLs on created files - if default ACL not
1884 * selected.
1885 */
1886
1887 if (!posix_open && !file_existed && !def_acl) {
1888
1889 int saved_errno = errno; /* We might get ENOSYS in the next
1890 * call.. */
1891
1892 if (SMB_VFS_FCHMOD_ACL(fsp, unx_mode) == -1 &&
1893 errno == ENOSYS) {
1894 errno = saved_errno; /* Ignore ENOSYS */
1895 }
1896
1897 } else if (new_unx_mode) {
1898
1899 int ret = -1;
1900
1901 /* Attributes need changing. File already existed. */
1902
1903 {
1904 int saved_errno = errno; /* We might get ENOSYS in the
1905 * next call.. */
1906 ret = SMB_VFS_FCHMOD_ACL(fsp, new_unx_mode);
1907
1908 if (ret == -1 && errno == ENOSYS) {
1909 errno = saved_errno; /* Ignore ENOSYS */
1910 } else {
1911 DEBUG(5, ("open_file_ntcreate: reset "
1912 "attributes of file %s to 0%o\n",
1913 fname, (unsigned int)new_unx_mode));
1914 ret = 0; /* Don't do the fchmod below. */
1915 }
1916 }
1917
1918 if ((ret == -1) &&
1919 (SMB_VFS_FCHMOD(fsp, new_unx_mode) == -1))
1920 DEBUG(5, ("open_file_ntcreate: failed to reset "
1921 "attributes of file %s to 0%o\n",
1922 fname, (unsigned int)new_unx_mode));
1923 }
1924
1925 /* If this is a successful open, we must remove any deferred open
1926 * records. */
1927 if (req != NULL) {
1928 del_deferred_open_entry(lck, req->mid);
1929 }
1930 TALLOC_FREE(lck);
1931
1932 conn->num_files_open++;
1933
1934 *result = fsp;
1935 return NT_STATUS_OK;
1936 }
1937
1938 /****************************************************************************
1939 Open a file for for write to ensure that we can fchmod it.
1940 ****************************************************************************/
1941
1942 NTSTATUS open_file_fchmod(connection_struct *conn, const char *fname,
1943 SMB_STRUCT_STAT *psbuf, files_struct **result)
1944 {
1945 files_struct *fsp = NULL;
1946 NTSTATUS status;
1947
1948 if (!VALID_STAT(*psbuf)) {
1949 return NT_STATUS_INVALID_PARAMETER;
1950 }
1951
1952 status = file_new(conn, &fsp);
1953 if(!NT_STATUS_IS_OK(status)) {
1954 return status;
1955 }
1956
1957 /* note! we must use a non-zero desired access or we don't get
1958 a real file descriptor. Oh what a twisted web we weave. */
1959 status = open_file(fsp, conn, NULL, NULL, NULL, fname, psbuf, O_WRONLY,
1960 0, FILE_WRITE_DATA, FILE_WRITE_DATA);
1961
1962 /*
1963 * This is not a user visible file open.
1964 * Don't set a share mode and don't increment
1965 * the conn->num_files_open.
1966 */
1967
1968 if (!NT_STATUS_IS_OK(status)) {
1969 file_free(fsp);
1970 return status;
1971 }
1972
1973 *result = fsp;
1974 return NT_STATUS_OK;
1975 }
1976
1977 /****************************************************************************
1978 Close the fchmod file fd - ensure no locks are lost.
1979 ****************************************************************************/
1980
1981 NTSTATUS close_file_fchmod(files_struct *fsp)
1982 {
1983 NTSTATUS status = fd_close(fsp);
1984 file_free(fsp);
1985 return status;
1986 }
1987
1988 static NTSTATUS mkdir_internal(connection_struct *conn,
1989 const char *name,
1990 uint32 file_attributes,
1991 SMB_STRUCT_STAT *psbuf)
1992 {
1993 mode_t mode;
1994 char *parent_dir;
1995 const char *dirname;
1996 NTSTATUS status;
1997 bool posix_open = false;
1998
1999 if(!CAN_WRITE(conn)) {
2000 DEBUG(5,("mkdir_internal: failing create on read-only share "
2001 "%s\n", lp_servicename(SNUM(conn))));
2002 return NT_STATUS_ACCESS_DENIED;
2003 }
2004
2005 status = check_name(conn, name);
2006 if (!NT_STATUS_IS_OK(status)) {
2007 return status;
2008 }
2009
2010 if (!parent_dirname_talloc(talloc_tos(), name, &parent_dir,
2011 &dirname)) {
2012 return NT_STATUS_NO_MEMORY;
2013 }
2014
2015 if (file_attributes & FILE_FLAG_POSIX_SEMANTICS) {
2016 posix_open = true;
2017 mode = (mode_t)(file_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
2018 } else {
2019 mode = unix_mode(conn, aDIR, name, parent_dir);
2020 }
2021
2022 if (SMB_VFS_MKDIR(conn, name, mode) != 0) {
2023 return map_nt_error_from_unix(errno);
2024 }
2025
2026 /* Ensure we're checking for a symlink here.... */
2027 /* We don't want to get caught by a symlink racer. */
2028
2029 if (SMB_VFS_LSTAT(conn, name, psbuf) == -1) {
2030 DEBUG(2, ("Could not stat directory '%s' just created: %s\n",
2031 name, strerror(errno)));
2032 return map_nt_error_from_unix(errno);
2033 }
2034
2035 if (!S_ISDIR(psbuf->st_mode)) {
2036 DEBUG(0, ("Directory just '%s' created is not a directory\n",
2037 name));
2038 return NT_STATUS_ACCESS_DENIED;
2039 }
2040
2041 if (lp_store_dos_attributes(SNUM(conn))) {
2042 if (!posix_open) {
2043 file_set_dosmode(conn, name,
2044 file_attributes | aDIR, NULL,
2045 parent_dir,
2046 true);
2047 }
2048 }
2049
2050 if (lp_inherit_perms(SNUM(conn))) {
2051 inherit_access_acl(conn, parent_dir, name, mode);
2052 }
2053
2054 if (!(file_attributes & FILE_FLAG_POSIX_SEMANTICS)) {
2055 /*
2056 * Check if high bits should have been set,
2057 * then (if bits are missing): add them.
2058 * Consider bits automagically set by UNIX, i.e. SGID bit from parent
2059 * dir.
2060 */
2061 if (mode & ~(S_IRWXU|S_IRWXG|S_IRWXO) && (mode & ~psbuf->st_mode)) {
2062 SMB_VFS_CHMOD(conn, name,
2063 psbuf->st_mode | (mode & ~psbuf->st_mode));
2064 }
2065 }
2066
2067 /* Change the owner if required. */
2068 if (lp_inherit_owner(SNUM(conn))) {
2069 change_dir_owner_to_parent(conn, parent_dir, name, psbuf);
2070 }
2071
2072 notify_fname(conn, NOTIFY_ACTION_ADDED, FILE_NOTIFY_CHANGE_DIR_NAME,
2073 name);
2074
2075 return NT_STATUS_OK;
2076 }
2077
2078 /****************************************************************************
2079 Open a directory from an NT SMB call.
2080 ****************************************************************************/
2081
2082 NTSTATUS open_directory(connection_struct *conn,
2083 struct smb_request *req,
2084 const char *fname,
2085 SMB_STRUCT_STAT *psbuf,
2086 uint32 access_mask,
2087 uint32 share_access,
2088 uint32 create_disposition,
2089 uint32 create_options,
2090 uint32 file_attributes,
2091 int *pinfo,
2092 files_struct **result)
2093 {
2094 files_struct *fsp = NULL;
2095 bool dir_existed = VALID_STAT(*psbuf) ? True : False;
2096 struct share_mode_lock *lck = NULL;
2097 NTSTATUS status;
2098 int info = 0;
2099
2100 DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
2101 "share_access = 0x%x create_options = 0x%x, "
2102 "create_disposition = 0x%x, file_attributes = 0x%x\n",
2103 fname,
2104 (unsigned int)access_mask,
2105 (unsigned int)share_access,
2106 (unsigned int)create_options,
2107 (unsigned int)create_disposition,
2108 (unsigned int)file_attributes));
2109
2110 if (!(file_attributes & FILE_FLAG_POSIX_SEMANTICS) && is_ntfs_stream_name(fname)) {
2111 DEBUG(2, ("open_directory: %s is a stream name!\n", fname));
2112 return NT_STATUS_NOT_A_DIRECTORY;
2113 }
2114
2115 switch( create_disposition ) {
2116 case FILE_OPEN:
2117
2118 info = FILE_WAS_OPENED;
2119
2120 /*
2121 * We want to follow symlinks here.
2122 */
2123
2124 if (SMB_VFS_STAT(conn, fname, psbuf) != 0) {
2125 return map_nt_error_from_unix(errno);
2126 }
2127
2128 break;
2129
2130 case FILE_CREATE:
2131
2132 /* If directory exists error. If directory doesn't
2133 * exist create. */
2134
2135 status = mkdir_internal(conn,
2136 fname,
2137 file_attributes,
2138 psbuf);
2139
2140 if (!NT_STATUS_IS_OK(status)) {
2141 DEBUG(2, ("open_directory: unable to create "
2142 "%s. Error was %s\n", fname,
2143 nt_errstr(status)));
2144 return status;
2145 }
2146
2147 info = FILE_WAS_CREATED;
2148 break;
2149
2150 case FILE_OPEN_IF:
2151 /*
2152 * If directory exists open. If directory doesn't
2153 * exist create.
2154 */
2155
2156 status = mkdir_internal(conn,
2157 fname,
2158 file_attributes,
2159 psbuf);
2160
2161 if (NT_STATUS_IS_OK(status)) {
2162 info = FILE_WAS_CREATED;
2163 }
2164
2165 if (NT_STATUS_EQUAL(status,
2166 NT_STATUS_OBJECT_NAME_COLLISION)) {
2167 info = FILE_WAS_OPENED;
2168 status = NT_STATUS_OK;
2169 }
2170
2171 break;
2172
2173 case FILE_SUPERSEDE:
2174 case FILE_OVERWRITE:
2175 case FILE_OVERWRITE_IF:
2176 default:
2177 DEBUG(5,("open_directory: invalid create_disposition "
2178 "0x%x for directory %s\n",
2179 (unsigned int)create_disposition, fname));
2180 return NT_STATUS_INVALID_PARAMETER;
2181 }
2182
2183 if(!S_ISDIR(psbuf->st_mode)) {
2184 DEBUG(5,("open_directory: %s is not a directory !\n",
2185 fname ));
2186 return NT_STATUS_NOT_A_DIRECTORY;
2187 }
2188
2189 status = file_new(conn, &fsp);
2190 if(!NT_STATUS_IS_OK(status)) {
2191 return status;
2192 }
2193
2194 /*
2195 * Setup the files_struct for it.
2196 */
2197
2198 fsp->mode = psbuf->st_mode;
2199 fsp->file_id = vfs_file_id_from_sbuf(conn, psbuf);
2200 fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
2201 fsp->file_pid = req ? req->smbpid : 0;
2202 fsp->can_lock = False;
2203 fsp->can_read = False;
2204 fsp->can_write = False;
2205
2206 fsp->share_access = share_access;
2207 fsp->fh->private_options = create_options;
2208 fsp->access_mask = access_mask;
2209
2210 fsp->print_file = False;
2211 fsp->modified = False;
2212 fsp->oplock_type = NO_OPLOCK;
2213 fsp->sent_oplock_break = NO_BREAK_SENT;
2214 fsp->is_directory = True;
2215 fsp->is_stat = False;
2216 fsp->posix_open = (file_attributes & FILE_FLAG_POSIX_SEMANTICS) ? True : False;
2217
2218 string_set(&fsp->fsp_name,fname);
2219
2220 lck = get_share_mode_lock(talloc_tos(), fsp->file_id,
2221 conn->connectpath,
2222 fname);
2223
2224 if (lck == NULL) {
2225 DEBUG(0, ("open_directory: Could not get share mode lock for %s\n", fname));
2226 file_free(fsp);
2227 return NT_STATUS_SHARING_VIOLATION;
2228 }
2229
2230 status = open_mode_check(conn, fname, lck,
2231 access_mask, share_access,
2232 create_options, &dir_existed);
2233
2234 if (!NT_STATUS_IS_OK(status)) {
2235 TALLOC_FREE(lck);
2236 file_free(fsp);
2237 return status;
2238 }
2239
2240 set_share_mode(lck, fsp, current_user.ut.uid, 0, NO_OPLOCK, True);
2241
2242 /* For directories the delete on close bit at open time seems
2243 always to be honored on close... See test 19 in Samba4 BASE-DELETE. */
2244 if (create_options & FILE_DELETE_ON_CLOSE) {
2245 status = can_set_delete_on_close(fsp, True, 0);
2246 if (!NT_STATUS_IS_OK(status) && !NT_STATUS_EQUAL(status, NT_STATUS_DIRECTORY_NOT_EMPTY)) {
2247 TALLOC_FREE(lck);
2248 file_free(fsp);
2249 return status;
2250 }
2251
2252 if (NT_STATUS_IS_OK(status)) {
2253 /* Note that here we set the *inital* delete on close flag,
2254 not the regular one. The magic gets handled in close. */
2255 fsp->initial_delete_on_close = True;
2256 }
2257 }
2258
2259 TALLOC_FREE(lck);
2260
2261 if (pinfo) {
2262 *pinfo = info;
2263 }
2264
2265 conn->num_files_open++;
2266
2267 *result = fsp;
2268 return NT_STATUS_OK;
2269 }
2270
2271 NTSTATUS create_directory(connection_struct *conn, struct smb_request *req, const char *directory)
2272 {
2273 NTSTATUS status;
2274 SMB_STRUCT_STAT sbuf;
2275 files_struct *fsp;
2276
2277 SET_STAT_INVALID(sbuf);
2278
2279 status = open_directory(conn, req, directory, &sbuf,
2280 FILE_READ_ATTRIBUTES, /* Just a stat open */
2281 FILE_SHARE_NONE, /* Ignored for stat opens */
2282 FILE_CREATE,
2283 0,
2284 FILE_ATTRIBUTE_DIRECTORY,
2285 NULL,
2286 &fsp);
2287
2288 if (NT_STATUS_IS_OK(status)) {
2289 close_file(fsp, NORMAL_CLOSE);
2290 }
2291
2292 return status;
2293 }
2294
2295 /****************************************************************************
2296 Open a pseudo-file (no locking checks - a 'stat' open).
2297 ****************************************************************************/
2298
2299 NTSTATUS open_file_stat(connection_struct *conn, struct smb_request *req,
2300 const char *fname, SMB_STRUCT_STAT *psbuf,
2301 files_struct **result)
2302 {
2303 files_struct *fsp = NULL;
2304 NTSTATUS status;
2305
2306 if (!VALID_STAT(*psbuf)) {
2307 return NT_STATUS_INVALID_PARAMETER;
2308 }
2309
2310 /* Can't 'stat' open directories. */
2311 if(S_ISDIR(psbuf->st_mode)) {
2312 return NT_STATUS_FILE_IS_A_DIRECTORY;
2313 }
2314
2315 status = file_new(conn, &fsp);
2316 if(!NT_STATUS_IS_OK(status)) {
2317 return status;
2318 }
2319
2320 DEBUG(5,("open_file_stat: 'opening' file %s\n", fname));
2321
2322 /*
2323 * Setup the files_struct for it.
2324 */
2325
2326 fsp->mode = psbuf->st_mode;
2327 fsp->file_id = vfs_file_id_from_sbuf(conn, psbuf);
2328 fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
2329 fsp->file_pid = req ? req->smbpid : 0;
2330 fsp->can_lock = False;
2331 fsp->can_read = False;
2332 fsp->can_write = False;
2333 fsp->print_file = False;
2334 fsp->modified = False;
2335 fsp->oplock_type = NO_OPLOCK;
2336 fsp->sent_oplock_break = NO_BREAK_SENT;
2337 fsp->is_directory = False;
2338 fsp->is_stat = True;
2339 string_set(&fsp->fsp_name,fname);
2340
2341 conn->num_files_open++;
2342
2343 *result = fsp;
2344 return NT_STATUS_OK;
2345 }
2346
2347 /****************************************************************************
2348 Receive notification that one of our open files has been renamed by another
2349 smbd process.
2350 ****************************************************************************/
2351
2352 void msg_file_was_renamed(struct messaging_context *msg,
2353 void *private_data,
2354 uint32_t msg_type,
2355 struct server_id server_id,
2356 DATA_BLOB *data)
2357 {
2358 files_struct *fsp;
2359 char *frm = (char *)data->data;
2360 struct file_id id;
2361 const char *sharepath;
2362 const char *newname;
2363 size_t sp_len;
2364
2365 if (data->data == NULL
2366 || data->length < MSG_FILE_RENAMED_MIN_SIZE + 2) {
2367 DEBUG(0, ("msg_file_was_renamed: Got invalid msg len %d\n",
2368 (int)data->length));
2369 return;
2370 }
2371
2372 /* Unpack the message. */
2373 pull_file_id_16(frm, &id);
2374 sharepath = &frm[16];
2375 newname = sharepath + strlen(sharepath) + 1;
2376 sp_len = strlen(sharepath);
2377
2378 DEBUG(10,("msg_file_was_renamed: Got rename message for sharepath %s, new name %s, "
2379 "file_id %s\n",
2380 sharepath, newname, file_id_string_tos(&id)));
2381
2382 for(fsp = file_find_di_first(id); fsp; fsp = file_find_di_next(fsp)) {
2383 if (memcmp(fsp->conn->connectpath, sharepath, sp_len) == 0) {
2384 DEBUG(10,("msg_file_was_renamed: renaming file fnum %d from %s -> %s\n",
2385 fsp->fnum, fsp->fsp_name, newname ));
2386 string_set(&fsp->fsp_name, newname);
2387 } else {
2388 /* TODO. JRA. */
2389 /* Now we have the complete path we can work out if this is
2390 actually within this share and adjust newname accordingly. */
2391 DEBUG(10,("msg_file_was_renamed: share mismatch (sharepath %s "
2392 "not sharepath %s) "
2393 "fnum %d from %s -> %s\n",
2394 fsp->conn->connectpath,
2395 sharepath,
2396 fsp->fnum,
2397 fsp->fsp_name,
2398 newname ));
2399 }
2400 }
2401 }
2402
2403 struct case_semantics_state {
2404 connection_struct *conn;
2405 bool case_sensitive;
2406 bool case_preserve;
2407 bool short_case_preserve;
2408 };
2409
2410 /****************************************************************************
2411 Restore case semantics.
2412 ****************************************************************************/
2413 static int restore_case_semantics(struct case_semantics_state *state)
2414 {
2415 state->conn->case_sensitive = state->case_sensitive;
2416 state->conn->case_preserve = state->case_preserve;
2417 state->conn->short_case_preserve = state->short_case_preserve;
2418 return 0;
2419 }
2420
2421 /****************************************************************************
2422 Save case semantics.
2423 ****************************************************************************/
2424 static struct case_semantics_state *set_posix_case_semantics(TALLOC_CTX *mem_ctx,
2425 connection_struct *conn)
2426 {
2427 struct case_semantics_state *result;
2428
2429 if (!(result = talloc(mem_ctx, struct case_semantics_state))) {
2430 DEBUG(0, ("talloc failed\n"));
2431 return NULL;
2432 }
2433
2434 result->conn = conn;
2435 result->case_sensitive = conn->case_sensitive;
2436 result->case_preserve = conn->case_preserve;
2437 result->short_case_preserve = conn->short_case_preserve;
2438
2439 /* Set to POSIX. */
2440 conn->case_sensitive = True;
2441 conn->case_preserve = True;
2442 conn->short_case_preserve = True;
2443
2444 talloc_set_destructor(result, restore_case_semantics);
2445
2446 return result;
2447 }
2448
2449 /*
2450 * If a main file is opened for delete, all streams need to be checked for
2451 * !FILE_SHARE_DELETE. Do this by opening with DELETE_ACCESS.
2452 * If that works, delete them all by setting the delete on close and close.
2453 */
2454
2455 static NTSTATUS open_streams_for_delete(connection_struct *conn,
2456 const char *fname)
2457 {
2458 struct stream_struct *stream_info;
2459 files_struct **streams;
2460 int i;
2461 unsigned int num_streams;
2462 TALLOC_CTX *frame = talloc_stackframe();
2463 NTSTATUS status;
2464
2465 status = SMB_VFS_STREAMINFO(conn, NULL, fname, talloc_tos(),
2466 &num_streams, &stream_info);
2467
2468 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)
2469 || NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
2470 DEBUG(10, ("no streams around\n"));
2471 TALLOC_FREE(frame);
2472 return NT_STATUS_OK;
2473 }
2474
2475 if (!NT_STATUS_IS_OK(status)) {
2476 DEBUG(10, ("SMB_VFS_STREAMINFO failed: %s\n",
2477 nt_errstr(status)));
2478 goto fail;
2479 }
2480
2481 DEBUG(10, ("open_streams_for_delete found %d streams\n",
2482 num_streams));
2483
2484 if (num_streams == 0) {
2485 TALLOC_FREE(frame);
2486 return NT_STATUS_OK;
2487 }
2488
2489 streams = TALLOC_ARRAY(talloc_tos(), files_struct *, num_streams);
2490 if (streams == NULL) {
2491 DEBUG(0, ("talloc failed\n"));
2492 status = NT_STATUS_NO_MEMORY;
2493 goto fail;
2494 }
2495
2496 for (i=0; i<num_streams; i++) {
2497 char *streamname;
2498
2499 if (strequal(stream_info[i].name, "::$DATA")) {
2500 streams[i] = NULL;
2501 continue;
2502 }
2503
2504 streamname = talloc_asprintf(talloc_tos(), "%s%s", fname,
2505 stream_info[i].name);
2506
2507 if (streamname == NULL) {
2508 DEBUG(0, ("talloc_aprintf failed\n"));
2509 status = NT_STATUS_NO_MEMORY;
2510 goto fail;
2511 }
2512
2513 status = create_file_unixpath
2514 (conn, /* conn */
2515 NULL, /* req */
2516 streamname, /* fname */
2517 DELETE_ACCESS, /* access_mask */
2518 FILE_SHARE_READ | FILE_SHARE_WRITE
2519 | FILE_SHARE_DELETE, /* share_access */
2520 FILE_OPEN, /* create_disposition*/
2521 NTCREATEX_OPTIONS_PRIVATE_STREAM_DELETE, /* create_options */
2522 FILE_ATTRIBUTE_NORMAL, /* file_attributes */
2523 0, /* oplock_request */
2524 0, /* allocation_size */
2525 NULL, /* sd */
2526 NULL, /* ea_list */
2527 &streams[i], /* result */
2528 NULL, /* pinfo */
2529 NULL); /* psbuf */
2530
2531 TALLOC_FREE(streamname);
2532
2533 if (!NT_STATUS_IS_OK(status)) {
2534 DEBUG(10, ("Could not open stream %s: %s\n",
2535 streamname, nt_errstr(status)));
2536 break;
2537 }
2538 }
2539
2540 /*
2541 * don't touch the variable "status" beyond this point :-)
2542 */
2543
2544 for (i -= 1 ; i >= 0; i--) {
2545 if (streams[i] == NULL) {
2546 continue;
2547 }
2548
2549 DEBUG(10, ("Closing stream # %d, %s\n", i,
2550 streams[i]->fsp_name));
2551 close_file(streams[i], NORMAL_CLOSE);
2552 }
2553
2554 fail:
2555 TALLOC_FREE(frame);
2556 return status;
2557 }
2558
2559 /*
2560 * Wrapper around open_file_ntcreate and open_directory
2561 */
2562
2563 NTSTATUS create_file_unixpath(connection_struct *conn,
2564 struct smb_request *req,
2565 const char *fname,
2566 uint32_t access_mask,
2567 uint32_t share_access,
2568 uint32_t create_disposition,
2569 uint32_t create_options,
2570 uint32_t file_attributes,
2571 uint32_t oplock_request,
2572 SMB_BIG_UINT allocation_size,
2573 struct security_descriptor *sd,
2574 struct ea_list *ea_list,
2575
2576 files_struct **result,
2577 int *pinfo,
2578 SMB_STRUCT_STAT *psbuf)
2579 {
2580 SMB_STRUCT_STAT sbuf;
2581 int info = FILE_WAS_OPENED;
2582 files_struct *base_fsp = NULL;
2583 files_struct *fsp = NULL;
2584 NTSTATUS status;
2585
2586 DEBUG(10,("create_file_unixpath: access_mask = 0x%x "
2587 "file_attributes = 0x%x, share_access = 0x%x, "
2588 "create_disposition = 0x%x create_options = 0x%x "
2589 "oplock_request = 0x%x ea_list = 0x%p, sd = 0x%p, "
2590 "fname = %s\n",
2591 (unsigned int)access_mask,
2592 (unsigned int)file_attributes,
2593 (unsigned int)share_access,
2594 (unsigned int)create_disposition,
2595 (unsigned int)create_options,
2596 (unsigned int)oplock_request,
2597 ea_list, sd, fname));
2598
2599 if (create_options & FILE_OPEN_BY_FILE_ID) {
2600 status = NT_STATUS_NOT_SUPPORTED;
2601 goto fail;
2602 }
2603
2604 if (req == NULL) {
2605 oplock_request |= INTERNAL_OPEN_ONLY;
2606 }
2607
2608 if (psbuf != NULL) {
2609 sbuf = *psbuf;
2610 }
2611 else {
2612 if (SMB_VFS_STAT(conn, fname, &sbuf) == -1) {
2613 SET_STAT_INVALID(sbuf);
2614 }
2615 }
2616
2617 if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
2618 && (access_mask & DELETE_ACCESS)
2619 && !is_ntfs_stream_name(fname)) {
2620 /*
2621 * We can't open a file with DELETE access if any of the
2622 * streams is open without FILE_SHARE_DELETE
2623 */
2624 status = open_streams_for_delete(conn, fname);
2625
2626 if (!NT_STATUS_IS_OK(status)) {
2627 goto fail;
2628 }
2629 }
2630
2631 /* This is the correct thing to do (check every time) but can_delete
2632 * is expensive (it may have to read the parent directory
2633 * permissions). So for now we're not doing it unless we have a strong
2634 * hint the client is really going to delete this file. If the client
2635 * is forcing FILE_CREATE let the filesystem take care of the
2636 * permissions. */
2637
2638 /* Setting FILE_SHARE_DELETE is the hint. */
2639
2640 if (lp_acl_check_permissions(SNUM(conn))
2641 && (create_disposition != FILE_CREATE)
2642 && (share_access & FILE_SHARE_DELETE)
2643 && (access_mask & DELETE_ACCESS)
2644 && (((dos_mode(conn, fname, &sbuf) & FILE_ATTRIBUTE_READONLY)
2645 && !lp_delete_readonly(SNUM(conn)))
2646 || !can_delete_file_in_directory(conn, fname))) {
2647 status = NT_STATUS_ACCESS_DENIED;
2648 goto fail;
2649 }
2650
2651 #if 0
2652 /* We need to support SeSecurityPrivilege for this. */
2653 if ((access_mask & SEC_RIGHT_SYSTEM_SECURITY) &&
2654 !user_has_privileges(current_user.nt_user_token,
2655 &se_security)) {
2656 status = NT_STATUS_PRIVILEGE_NOT_HELD;
2657 goto fail;
2658 }
2659 #endif
2660
2661 if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
2662 && is_ntfs_stream_name(fname)
2663 && (!(create_options & NTCREATEX_OPTIONS_PRIVATE_STREAM_DELETE))) {
2664 char *base;
2665 uint32 base_create_disposition;
2666
2667 if (create_options & FILE_DIRECTORY_FILE) {
2668 status = NT_STATUS_NOT_A_DIRECTORY;
2669 goto fail;
2670 }
2671
2672 status = split_ntfs_stream_name(talloc_tos(), fname,
2673 &base, NULL);
2674 if (!NT_STATUS_IS_OK(status)) {
2675 DEBUG(10, ("create_file_unixpath: "
2676 "split_ntfs_stream_name failed: %s\n",
2677 nt_errstr(status)));
2678 goto fail;
2679 }
2680
2681 SMB_ASSERT(!is_ntfs_stream_name(base)); /* paranoia.. */
2682
2683 switch (create_disposition) {
2684 case FILE_OPEN:
2685 base_create_disposition = FILE_OPEN;
2686 break;
2687 default:
2688 base_create_disposition = FILE_OPEN_IF;
2689 break;
2690 }
2691
2692 status = create_file_unixpath(conn, NULL, base, 0,
2693 FILE_SHARE_READ
2694 | FILE_SHARE_WRITE
2695 | FILE_SHARE_DELETE,
2696 base_create_disposition,
2697 0, 0, 0, 0, NULL, NULL,
2698 &base_fsp, NULL, NULL);
2699 if (!NT_STATUS_IS_OK(status)) {
2700 DEBUG(10, ("create_file_unixpath for base %s failed: "
2701 "%s\n", base, nt_errstr(status)));
2702 goto fail;
2703 }
2704 }
2705
2706 /*
2707 * If it's a request for a directory open, deal with it separately.
2708 */
2709
2710 if (create_options & FILE_DIRECTORY_FILE) {
2711
2712 if (create_options & FILE_NON_DIRECTORY_FILE) {
2713 status = NT_STATUS_INVALID_PARAMETER;
2714 goto fail;
2715 }
2716
2717 /* Can't open a temp directory. IFS kit test. */
2718 if (file_attributes & FILE_ATTRIBUTE_TEMPORARY) {
2719 status = NT_STATUS_INVALID_PARAMETER;
2720 goto fail;
2721 }
2722
2723 /*
2724 * We will get a create directory here if the Win32
2725 * app specified a security descriptor in the
2726 * CreateDirectory() call.
2727 */
2728
2729 oplock_request = 0;
2730 status = open_directory(
2731 conn, req, fname, &sbuf, access_mask, share_access,
2732 create_disposition, create_options, file_attributes,
2733 &info, &fsp);
2734 } else {
2735
2736 /*
2737 * Ordinary file case.
2738 */
2739
2740 status = open_file_ntcreate(
2741 conn, req, fname, &sbuf, access_mask, share_access,
2742 create_disposition, create_options, file_attributes,
2743 oplock_request, &info, &fsp);
2744
2745 if (NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) {
2746
2747 /*
2748 * Fail the open if it was explicitly a non-directory
2749 * file.
2750 */
2751
2752 if (create_options & FILE_NON_DIRECTORY_FILE) {
2753 status = NT_STATUS_FILE_IS_A_DIRECTORY;
2754 goto fail;
2755 }
2756
2757 oplock_request = 0;
2758 status = open_directory(
2759 conn, req, fname, &sbuf, access_mask,
2760 share_access, create_disposition,
2761 create_options, file_attributes,
2762 &info, &fsp);
2763 }
2764 }
2765
2766 if (!NT_STATUS_IS_OK(status)) {
2767 goto fail;
2768 }
2769
2770 /*
2771 * According to the MS documentation, the only time the security
2772 * descriptor is applied to the opened file is iff we *created* the
2773 * file; an existing file stays the same.
2774 *
2775 * Also, it seems (from observation) that you can open the file with
2776 * any access mask but you can still write the sd. We need to override
2777 * the granted access before we call set_sd
2778 * Patch for bug #2242 from Tom Lackemann <cessnatomny@yahoo.com>.
2779 */
2780
2781 if ((sd != NULL) && (info == FILE_WAS_CREATED)
2782 && lp_nt_acl_support(SNUM(conn))) {
2783
2784 uint32_t sec_info_sent = ALL_SECURITY_INFORMATION;
2785 uint32_t saved_access_mask = fsp->access_mask;
2786
2787 if (sd->owner_sid == NULL) {
2788 sec_info_sent &= ~OWNER_SECURITY_INFORMATION;
2789 }
2790 if (sd->group_sid == NULL) {
2791 sec_info_sent &= ~GROUP_SECURITY_INFORMATION;
2792 }
2793 if (sd->sacl == NULL) {
2794 sec_info_sent &= ~SACL_SECURITY_INFORMATION;
2795 }
2796 if (sd->dacl == NULL) {
2797 sec_info_sent &= ~DACL_SECURITY_INFORMATION;
2798 }
2799
2800 fsp->access_mask = FILE_GENERIC_ALL;
2801
2802 status = SMB_VFS_FSET_NT_ACL(fsp, sec_info_sent, sd);
2803
2804 fsp->access_mask = saved_access_mask;
2805
2806 if (!NT_STATUS_IS_OK(status)) {
2807 goto fail;
2808 }
2809 }
2810
2811 if ((ea_list != NULL) && (info == FILE_WAS_CREATED)) {
2812 status = set_ea(conn, fsp, fname, ea_list);
2813 if (!NT_STATUS_IS_OK(status)) {
2814 goto fail;
2815 }
2816 }
2817
2818 if (!fsp->is_directory && S_ISDIR(sbuf.st_mode)) {
2819 status = NT_STATUS_ACCESS_DENIED;
2820 goto fail;
2821 }
2822
2823 /* Save the requested allocation size. */
2824 if ((info == FILE_WAS_CREATED) || (info == FILE_WAS_OVERWRITTEN)) {
2825 if (allocation_size
2826 && (allocation_size > sbuf.st_size)) {
2827 fsp->initial_allocation_size = smb_roundup(
2828 fsp->conn, allocation_size);
2829 if (fsp->is_directory) {
2830 /* Can't set allocation size on a directory. */
2831 status = NT_STATUS_ACCESS_DENIED;
2832 goto fail;
2833 }
2834 if (vfs_allocate_file_space(
2835 fsp, fsp->initial_allocation_size) == -1) {
2836 status = NT_STATUS_DISK_FULL;
2837 goto fail;
2838 }
2839 } else {
2840 fsp->initial_allocation_size = smb_roundup(
2841 fsp->conn, (SMB_BIG_UINT)sbuf.st_size);
2842 }
2843 }
2844
2845 DEBUG(10, ("create_file_unixpath: info=%d\n", info));
2846
2847 /*
2848 * Set fsp->base_fsp late enough that we can't "goto fail" anymore. In
2849 * the fail: branch we call close_file(fsp, ERROR_CLOSE) which would
2850 * also close fsp->base_fsp which we have to also do explicitly in
2851 * this routine here, as not in all "goto fail:" we have the fsp set
2852 * up already to be initialized with the base_fsp.
2853 */
2854
2855 fsp->base_fsp = base_fsp;
2856
2857 *result = fsp;
2858 if (pinfo != NULL) {
2859 *pinfo = info;
2860 }
2861 if (psbuf != NULL) {
2862 if ((fsp->fh == NULL) || (fsp->fh->fd == -1)) {
2863 *psbuf = sbuf;
2864 }
2865 else {
2866 SMB_VFS_FSTAT(fsp, psbuf);
2867 }
2868 }
2869 return NT_STATUS_OK;
2870
2871 fail:
2872 DEBUG(10, ("create_file_unixpath: %s\n", nt_errstr(status)));
2873
2874 if (fsp != NULL) {
2875 close_file(fsp, ERROR_CLOSE);
2876 fsp = NULL;
2877 }
2878 if (base_fsp != NULL) {
2879 close_file(base_fsp, ERROR_CLOSE);
2880 base_fsp = NULL;
2881 }
2882 return status;
2883 }
2884
2885 NTSTATUS create_file(connection_struct *conn,
2886 struct smb_request *req,
2887 uint16_t root_dir_fid,
2888 const char *fname,
2889 uint32_t access_mask,
2890 uint32_t share_access,
2891 uint32_t create_disposition,
2892 uint32_t create_options,
2893 uint32_t file_attributes,
2894 uint32_t oplock_request,
2895 SMB_BIG_UINT allocation_size,
2896 struct security_descriptor *sd,
2897 struct ea_list *ea_list,
2898
2899 files_struct **result,
2900 int *pinfo,
2901 SMB_STRUCT_STAT *psbuf)
2902 {
2903 struct case_semantics_state *case_state = NULL;
2904 SMB_STRUCT_STAT sbuf;
2905 int info = FILE_WAS_OPENED;
2906 files_struct *fsp = NULL;
2907 NTSTATUS status;
2908
2909 DEBUG(10,("create_file: access_mask = 0x%x "
2910 "file_attributes = 0x%x, share_access = 0x%x, "
2911 "create_disposition = 0x%x create_options = 0x%x "
2912 "oplock_request = 0x%x "
2913 "root_dir_fid = 0x%x, ea_list = 0x%p, sd = 0x%p, "
2914 "fname = %s\n",
2915 (unsigned int)access_mask,
2916 (unsigned int)file_attributes,
2917 (unsigned int)share_access,
2918 (unsigned int)create_disposition,
2919 (unsigned int)create_options,
2920 (unsigned int)oplock_request,
2921 (unsigned int)root_dir_fid,
2922 ea_list, sd, fname));
2923
2924 /*
2925 * Get the file name.
2926 */
2927
2928 if (root_dir_fid != 0) {
2929 /*
2930 * This filename is relative to a directory fid.
2931 */
2932 char *parent_fname = NULL;
2933 files_struct *dir_fsp = file_fsp(root_dir_fid);
2934
2935 if (dir_fsp == NULL) {
2936 status = NT_STATUS_INVALID_HANDLE;
2937 goto fail;
2938 }
2939
2940 if (!dir_fsp->is_directory) {
2941
2942 /*
2943 * Check to see if this is a mac fork of some kind.
2944 */
2945
2946 if (is_ntfs_stream_name(fname)) {
2947 status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
2948 goto fail;
2949 }
2950
2951 /*
2952 we need to handle the case when we get a
2953 relative open relative to a file and the
2954 pathname is blank - this is a reopen!
2955 (hint from demyn plantenberg)
2956 */
2957
2958 status = NT_STATUS_INVALID_HANDLE;
2959 goto fail;
2960 }
2961
2962 if (ISDOT(dir_fsp->fsp_name)) {
2963 /*
2964 * We're at the toplevel dir, the final file name
2965 * must not contain ./, as this is filtered out
2966 * normally by srvstr_get_path and unix_convert
2967 * explicitly rejects paths containing ./.
2968 */
2969 parent_fname = talloc_strdup(talloc_tos(), "");
2970 if (parent_fname == NULL) {
2971 status = NT_STATUS_NO_MEMORY;
2972 goto fail;
2973 }
2974 } else {
2975 size_t dir_name_len = strlen(dir_fsp->fsp_name);
2976
2977 /*
2978 * Copy in the base directory name.
2979 */
2980
2981 parent_fname = TALLOC_ARRAY(talloc_tos(), char,
2982 dir_name_len+2);
2983 if (parent_fname == NULL) {
2984 status = NT_STATUS_NO_MEMORY;
2985 goto fail;
2986 }
2987 memcpy(parent_fname, dir_fsp->fsp_name,
2988 dir_name_len+1);
2989
2990 /*
2991 * Ensure it ends in a '/'.
2992 * We used TALLOC_SIZE +2 to add space for the '/'.
2993 */
2994
2995 if(dir_name_len
2996 && (parent_fname[dir_name_len-1] != '\\')
2997 && (parent_fname[dir_name_len-1] != '/')) {
2998 parent_fname[dir_name_len] = '/';
2999 parent_fname[dir_name_len+1] = '\0';
3000 }
3001 }
3002
3003 fname = talloc_asprintf(talloc_tos(), "%s%s", parent_fname,
3004 fname);
3005 if (fname == NULL) {
3006 status = NT_STATUS_NO_MEMORY;
3007 goto fail;
3008 }
3009 }
3010
3011 /*
3012 * Check to see if this is a mac fork of some kind.
3013 */
3014
3015 if (is_ntfs_stream_name(fname)) {
3016 enum FAKE_FILE_TYPE fake_file_type;
3017
3018 fake_file_type = is_fake_file(fname);
3019
3020 if (fake_file_type != FAKE_FILE_TYPE_NONE) {
3021
3022 /*
3023 * Here we go! support for changing the disk quotas
3024 * --metze
3025 *
3026 * We need to fake up to open this MAGIC QUOTA file
3027 * and return a valid FID.
3028 *
3029 * w2k close this file directly after openening xp
3030 * also tries a QUERY_FILE_INFO on the file and then
3031 * close it
3032 */
3033 status = open_fake_file(conn, fake_file_type, fname,
3034 access_mask, &fsp);
3035 if (!NT_STATUS_IS_OK(status)) {
3036 goto fail;
3037 }
3038
3039 ZERO_STRUCT(sbuf);
3040 goto done;
3041 }
3042 }
3043
3044 if ((req != NULL) && (req->flags2 & FLAGS2_DFS_PATHNAMES)) {
3045 char *resolved_fname;
3046
3047 status = resolve_dfspath(talloc_tos(), conn, true, fname,
3048 &resolved_fname);
3049
3050 if (!NT_STATUS_IS_OK(status)) {
3051 /*
3052 * For PATH_NOT_COVERED we had
3053 * reply_botherror(req, NT_STATUS_PATH_NOT_COVERED,
3054 * ERRSRV, ERRbadpath);
3055 * Need to fix in callers
3056 */
3057 goto fail;
3058 }
3059 fname = resolved_fname;
3060 }
3061
3062 /*
3063 * Check if POSIX semantics are wanted.
3064 */
3065
3066 if (file_attributes & FILE_FLAG_POSIX_SEMANTICS) {
3067 case_state = set_posix_case_semantics(talloc_tos(), conn);
3068 file_attributes &= ~FILE_FLAG_POSIX_SEMANTICS;
3069 }
3070
3071 {
3072 char *converted_fname;
3073
3074 SET_STAT_INVALID(sbuf);
3075
3076 status = unix_convert(talloc_tos(), conn, fname, False,
3077 &converted_fname, NULL, &sbuf);
3078 if (!NT_STATUS_IS_OK(status)) {
3079 goto fail;
3080 }
3081 fname = converted_fname;
3082 }
3083
3084 TALLOC_FREE(case_state);
3085
3086 /* All file access must go through check_name() */
3087
3088 status = check_name(conn, fname);
3089 if (!NT_STATUS_IS_OK(status)) {
3090 goto fail;
3091 }
3092
3093 status = create_file_unixpath(
3094 conn, req, fname, access_mask, share_access,
3095 create_disposition, create_options, file_attributes,
3096 oplock_request, allocation_size, sd, ea_list,
3097 &fsp, &info, &sbuf);
3098
3099 if (!NT_STATUS_IS_OK(status)) {
3100 goto fail;
3101 }
3102
3103 done:
3104 DEBUG(10, ("create_file: info=%d\n", info));
3105
3106 *result = fsp;
3107 if (pinfo != NULL) {
3108 *pinfo = info;
3109 }
3110 if (psbuf != NULL) {
3111 *psbuf = sbuf;
3112 }
3113 return NT_STATUS_OK;
3114
3115 fail:
3116 DEBUG(10, ("create_file: %s\n", nt_errstr(status)));
3117
3118 if (fsp != NULL) {
3119 close_file(fsp, ERROR_CLOSE);
3120 fsp = NULL;
3121 }
3122 return status;
3123 }
Samba GIT mirror