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