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