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