source: trunk/server/source3/smbd/open.c@ 533

Last change on this file since 533 was 414, checked in by Herwig Bauernfeind, 16 years ago

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