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