?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3:vfs: add create tags to SMB_VFS_CREATEFILE
[Samba.git] / source3 / smbd / open.c
blobc6b67f4ae6864d0544b7a489fa44b0cdceed615f
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 "system/filesys.h"
24 #include "printing.h"
25 #include "smbd/smbd.h"
26 #include "smbd/globals.h"
27 #include "fake_file.h"
28 #include "../libcli/security/security.h"
29 #include "../librpc/gen_ndr/ndr_security.h"
30 #include "../librpc/gen_ndr/open_files.h"
31 #include "../librpc/gen_ndr/idmap.h"
32 #include "../librpc/gen_ndr/ioctl.h"
33 #include "passdb/lookup_sid.h"
34 #include "auth.h"
35 #include "serverid.h"
36 #include "messages.h"
37 #include "source3/lib/dbwrap/dbwrap_watch.h"
38 #include "locking/leases_db.h"
39
40 extern const struct generic_mapping file_generic_mapping;
41
42 struct deferred_open_record {
43 bool delayed_for_oplocks;
44 bool async_open;
45 struct file_id id;
46 };
47
48 /****************************************************************************
49 If the requester wanted DELETE_ACCESS and was rejected because
50 the file ACL didn't include DELETE_ACCESS, see if the parent ACL
51 overrides this.
52 ****************************************************************************/
53
54 static bool parent_override_delete(connection_struct *conn,
55 const struct smb_filename *smb_fname,
56 uint32_t access_mask,
57 uint32_t rejected_mask)
58 {
59 if ((access_mask & DELETE_ACCESS) &&
60 (rejected_mask & DELETE_ACCESS) &&
61 can_delete_file_in_directory(conn, smb_fname)) {
62 return true;
63 }
64 return false;
65 }
66
67 /****************************************************************************
68 Check if we have open rights.
69 ****************************************************************************/
70
71 NTSTATUS smbd_check_access_rights(struct connection_struct *conn,
72 const struct smb_filename *smb_fname,
73 bool use_privs,
74 uint32_t access_mask)
75 {
76 /* Check if we have rights to open. */
77 NTSTATUS status;
78 struct security_descriptor *sd = NULL;
79 uint32_t rejected_share_access;
80 uint32_t rejected_mask = access_mask;
81 uint32_t do_not_check_mask = 0;
82
83 rejected_share_access = access_mask & ~(conn->share_access);
84
85 if (rejected_share_access) {
86 DEBUG(10, ("smbd_check_access_rights: rejected share access 0x%x "
87 "on %s (0x%x)\n",
88 (unsigned int)access_mask,
89 smb_fname_str_dbg(smb_fname),
90 (unsigned int)rejected_share_access ));
91 return NT_STATUS_ACCESS_DENIED;
92 }
93
94 if (!use_privs && get_current_uid(conn) == (uid_t)0) {
95 /* I'm sorry sir, I didn't know you were root... */
96 DEBUG(10,("smbd_check_access_rights: root override "
97 "on %s. Granting 0x%x\n",
98 smb_fname_str_dbg(smb_fname),
99 (unsigned int)access_mask ));
100 return NT_STATUS_OK;
101 }
102
103 if ((access_mask & DELETE_ACCESS) && !lp_acl_check_permissions(SNUM(conn))) {
104 DEBUG(10,("smbd_check_access_rights: not checking ACL "
105 "on DELETE_ACCESS on file %s. Granting 0x%x\n",
106 smb_fname_str_dbg(smb_fname),
107 (unsigned int)access_mask ));
108 return NT_STATUS_OK;
109 }
110
111 if (access_mask == DELETE_ACCESS &&
112 VALID_STAT(smb_fname->st) &&
113 S_ISLNK(smb_fname->st.st_ex_mode)) {
114 /* We can always delete a symlink. */
115 DEBUG(10,("smbd_check_access_rights: not checking ACL "
116 "on DELETE_ACCESS on symlink %s.\n",
117 smb_fname_str_dbg(smb_fname) ));
118 return NT_STATUS_OK;
119 }
120
121 status = SMB_VFS_GET_NT_ACL(conn, smb_fname->base_name,
122 (SECINFO_OWNER |
123 SECINFO_GROUP |
124 SECINFO_DACL), talloc_tos(), &sd);
125
126 if (!NT_STATUS_IS_OK(status)) {
127 DEBUG(10, ("smbd_check_access_rights: Could not get acl "
128 "on %s: %s\n",
129 smb_fname_str_dbg(smb_fname),
130 nt_errstr(status)));
131
132 if (NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
133 goto access_denied;
134 }
135
136 return status;
137 }
138
139 /*
140 * If we can access the path to this file, by
141 * default we have FILE_READ_ATTRIBUTES from the
142 * containing directory. See the section:
143 * "Algorithm to Check Access to an Existing File"
144 * in MS-FSA.pdf.
145 *
146 * se_file_access_check() also takes care of
147 * owner WRITE_DAC and READ_CONTROL.
148 */
149 do_not_check_mask = FILE_READ_ATTRIBUTES;
150
151 /*
152 * Samba 3.6 and earlier granted execute access even
153 * if the ACL did not contain execute rights.
154 * Samba 4.0 is more correct and checks it.
155 * The compatibilty mode allows to skip this check
156 * to smoothen upgrades.
157 */
158 if (lp_acl_allow_execute_always(SNUM(conn))) {
159 do_not_check_mask |= FILE_EXECUTE;
160 }
161
162 status = se_file_access_check(sd,
163 get_current_nttok(conn),
164 use_privs,
165 (access_mask & ~do_not_check_mask),
166 &rejected_mask);
167
168 DEBUG(10,("smbd_check_access_rights: file %s requesting "
169 "0x%x returning 0x%x (%s)\n",
170 smb_fname_str_dbg(smb_fname),
171 (unsigned int)access_mask,
172 (unsigned int)rejected_mask,
173 nt_errstr(status) ));
174
175 if (!NT_STATUS_IS_OK(status)) {
176 if (DEBUGLEVEL >= 10) {
177 DEBUG(10,("smbd_check_access_rights: acl for %s is:\n",
178 smb_fname_str_dbg(smb_fname) ));
179 NDR_PRINT_DEBUG(security_descriptor, sd);
180 }
181 }
182
183 TALLOC_FREE(sd);
184
185 if (NT_STATUS_IS_OK(status) ||
186 !NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
187 return status;
188 }
189
190 /* Here we know status == NT_STATUS_ACCESS_DENIED. */
191
192 access_denied:
193
194 if ((access_mask & FILE_WRITE_ATTRIBUTES) &&
195 (rejected_mask & FILE_WRITE_ATTRIBUTES) &&
196 !lp_store_dos_attributes(SNUM(conn)) &&
197 (lp_map_readonly(SNUM(conn)) ||
198 lp_map_archive(SNUM(conn)) ||
199 lp_map_hidden(SNUM(conn)) ||
200 lp_map_system(SNUM(conn)))) {
201 rejected_mask &= ~FILE_WRITE_ATTRIBUTES;
202
203 DEBUG(10,("smbd_check_access_rights: "
204 "overrode "
205 "FILE_WRITE_ATTRIBUTES "
206 "on file %s\n",
207 smb_fname_str_dbg(smb_fname)));
208 }
209
210 if (parent_override_delete(conn,
211 smb_fname,
212 access_mask,
213 rejected_mask)) {
214 /* Were we trying to do an open
215 * for delete and didn't get DELETE
216 * access (only) ? Check if the
217 * directory allows DELETE_CHILD.
218 * See here:
219 * http://blogs.msdn.com/oldnewthing/archive/2004/06/04/148426.aspx
220 * for details. */
221
222 rejected_mask &= ~DELETE_ACCESS;
223
224 DEBUG(10,("smbd_check_access_rights: "
225 "overrode "
226 "DELETE_ACCESS on "
227 "file %s\n",
228 smb_fname_str_dbg(smb_fname)));
229 }
230
231 if (rejected_mask != 0) {
232 return NT_STATUS_ACCESS_DENIED;
233 }
234 return NT_STATUS_OK;
235 }
236
237 static NTSTATUS check_parent_access(struct connection_struct *conn,
238 struct smb_filename *smb_fname,
239 uint32_t access_mask)
240 {
241 NTSTATUS status;
242 char *parent_dir = NULL;
243 struct security_descriptor *parent_sd = NULL;
244 uint32_t access_granted = 0;
245
246 if (!parent_dirname(talloc_tos(),
247 smb_fname->base_name,
248 &parent_dir,
249 NULL)) {
250 return NT_STATUS_NO_MEMORY;
251 }
252
253 if (get_current_uid(conn) == (uid_t)0) {
254 /* I'm sorry sir, I didn't know you were root... */
255 DEBUG(10,("check_parent_access: root override "
256 "on %s. Granting 0x%x\n",
257 smb_fname_str_dbg(smb_fname),
258 (unsigned int)access_mask ));
259 return NT_STATUS_OK;
260 }
261
262 status = SMB_VFS_GET_NT_ACL(conn,
263 parent_dir,
264 SECINFO_DACL,
265 talloc_tos(),
266 &parent_sd);
267
268 if (!NT_STATUS_IS_OK(status)) {
269 DEBUG(5,("check_parent_access: SMB_VFS_GET_NT_ACL failed for "
270 "%s with error %s\n",
271 parent_dir,
272 nt_errstr(status)));
273 return status;
274 }
275
276 /*
277 * If we can access the path to this file, by
278 * default we have FILE_READ_ATTRIBUTES from the
279 * containing directory. See the section:
280 * "Algorithm to Check Access to an Existing File"
281 * in MS-FSA.pdf.
282 *
283 * se_file_access_check() also takes care of
284 * owner WRITE_DAC and READ_CONTROL.
285 */
286 status = se_file_access_check(parent_sd,
287 get_current_nttok(conn),
288 false,
289 (access_mask & ~FILE_READ_ATTRIBUTES),
290 &access_granted);
291 if(!NT_STATUS_IS_OK(status)) {
292 DEBUG(5,("check_parent_access: access check "
293 "on directory %s for "
294 "path %s for mask 0x%x returned (0x%x) %s\n",
295 parent_dir,
296 smb_fname->base_name,
297 access_mask,
298 access_granted,
299 nt_errstr(status) ));
300 return status;
301 }
302
303 return NT_STATUS_OK;
304 }
305
306 /****************************************************************************
307 Ensure when opening a base file for a stream open that we have permissions
308 to do so given the access mask on the base file.
309 ****************************************************************************/
310
311 static NTSTATUS check_base_file_access(struct connection_struct *conn,
312 struct smb_filename *smb_fname,
313 uint32_t access_mask)
314 {
315 NTSTATUS status;
316
317 status = smbd_calculate_access_mask(conn, smb_fname,
318 false,
319 access_mask,
320 &access_mask);
321 if (!NT_STATUS_IS_OK(status)) {
322 DEBUG(10, ("smbd_calculate_access_mask "
323 "on file %s returned %s\n",
324 smb_fname_str_dbg(smb_fname),
325 nt_errstr(status)));
326 return status;
327 }
328
329 if (access_mask & (FILE_WRITE_DATA|FILE_APPEND_DATA)) {
330 uint32_t dosattrs;
331 if (!CAN_WRITE(conn)) {
332 return NT_STATUS_ACCESS_DENIED;
333 }
334 dosattrs = dos_mode(conn, smb_fname);
335 if (IS_DOS_READONLY(dosattrs)) {
336 return NT_STATUS_ACCESS_DENIED;
337 }
338 }
339
340 return smbd_check_access_rights(conn,
341 smb_fname,
342 false,
343 access_mask);
344 }
345
346 /****************************************************************************
347 fd support routines - attempt to do a dos_open.
348 ****************************************************************************/
349
350 NTSTATUS fd_open(struct connection_struct *conn,
351 files_struct *fsp,
352 int flags,
353 mode_t mode)
354 {
355 struct smb_filename *smb_fname = fsp->fsp_name;
356 NTSTATUS status = NT_STATUS_OK;
357
358 #ifdef O_NOFOLLOW
359 /*
360 * Never follow symlinks on a POSIX client. The
361 * client should be doing this.
362 */
363
364 if (fsp->posix_open || !lp_follow_symlinks(SNUM(conn))) {
365 flags |= O_NOFOLLOW;
366 }
367 #endif
368
369 fsp->fh->fd = SMB_VFS_OPEN(conn, smb_fname, fsp, flags, mode);
370 if (fsp->fh->fd == -1) {
371 int posix_errno = errno;
372 #ifdef O_NOFOLLOW
373 #if defined(ENOTSUP) && defined(OSF1)
374 /* handle special Tru64 errno */
375 if (errno == ENOTSUP) {
376 posix_errno = ELOOP;
377 }
378 #endif /* ENOTSUP */
379 #ifdef EFTYPE
380 /* fix broken NetBSD errno */
381 if (errno == EFTYPE) {
382 posix_errno = ELOOP;
383 }
384 #endif /* EFTYPE */
385 /* fix broken FreeBSD errno */
386 if (errno == EMLINK) {
387 posix_errno = ELOOP;
388 }
389 #endif /* O_NOFOLLOW */
390 status = map_nt_error_from_unix(posix_errno);
391 if (errno == EMFILE) {
392 static time_t last_warned = 0L;
393
394 if (time((time_t *) NULL) > last_warned) {
395 DEBUG(0,("Too many open files, unable "
396 "to open more! smbd's max "
397 "open files = %d\n",
398 lp_max_open_files()));
399 last_warned = time((time_t *) NULL);
400 }
401 }
402
403 }
404
405 DEBUG(10,("fd_open: name %s, flags = 0%o mode = 0%o, fd = %d. %s\n",
406 smb_fname_str_dbg(smb_fname), flags, (int)mode, fsp->fh->fd,
407 (fsp->fh->fd == -1) ? strerror(errno) : "" ));
408
409 return status;
410 }
411
412 /****************************************************************************
413 Close the file associated with a fsp.
414 ****************************************************************************/
415
416 NTSTATUS fd_close(files_struct *fsp)
417 {
418 int ret;
419
420 if (fsp->dptr) {
421 dptr_CloseDir(fsp);
422 }
423 if (fsp->fh->fd == -1) {
424 return NT_STATUS_OK; /* What we used to call a stat open. */
425 }
426 if (fsp->fh->ref_count > 1) {
427 return NT_STATUS_OK; /* Shared handle. Only close last reference. */
428 }
429
430 ret = SMB_VFS_CLOSE(fsp);
431 fsp->fh->fd = -1;
432 if (ret == -1) {
433 return map_nt_error_from_unix(errno);
434 }
435 return NT_STATUS_OK;
436 }
437
438 /****************************************************************************
439 Change the ownership of a file to that of the parent directory.
440 Do this by fd if possible.
441 ****************************************************************************/
442
443 void change_file_owner_to_parent(connection_struct *conn,
444 const char *inherit_from_dir,
445 files_struct *fsp)
446 {
447 struct smb_filename *smb_fname_parent;
448 int ret;
449
450 smb_fname_parent = synthetic_smb_fname(talloc_tos(), inherit_from_dir,
451 NULL, NULL);
452 if (smb_fname_parent == NULL) {
453 return;
454 }
455
456 ret = SMB_VFS_STAT(conn, smb_fname_parent);
457 if (ret == -1) {
458 DEBUG(0,("change_file_owner_to_parent: failed to stat parent "
459 "directory %s. Error was %s\n",
460 smb_fname_str_dbg(smb_fname_parent),
461 strerror(errno)));
462 TALLOC_FREE(smb_fname_parent);
463 return;
464 }
465
466 if (smb_fname_parent->st.st_ex_uid == fsp->fsp_name->st.st_ex_uid) {
467 /* Already this uid - no need to change. */
468 DEBUG(10,("change_file_owner_to_parent: file %s "
469 "is already owned by uid %d\n",
470 fsp_str_dbg(fsp),
471 (int)fsp->fsp_name->st.st_ex_uid ));
472 TALLOC_FREE(smb_fname_parent);
473 return;
474 }
475
476 become_root();
477 ret = SMB_VFS_FCHOWN(fsp, smb_fname_parent->st.st_ex_uid, (gid_t)-1);
478 unbecome_root();
479 if (ret == -1) {
480 DEBUG(0,("change_file_owner_to_parent: failed to fchown "
481 "file %s to parent directory uid %u. Error "
482 "was %s\n", fsp_str_dbg(fsp),
483 (unsigned int)smb_fname_parent->st.st_ex_uid,
484 strerror(errno) ));
485 } else {
486 DEBUG(10,("change_file_owner_to_parent: changed new file %s to "
487 "parent directory uid %u.\n", fsp_str_dbg(fsp),
488 (unsigned int)smb_fname_parent->st.st_ex_uid));
489 /* Ensure the uid entry is updated. */
490 fsp->fsp_name->st.st_ex_uid = smb_fname_parent->st.st_ex_uid;
491 }
492
493 TALLOC_FREE(smb_fname_parent);
494 }
495
496 NTSTATUS change_dir_owner_to_parent(connection_struct *conn,
497 const char *inherit_from_dir,
498 const char *fname,
499 SMB_STRUCT_STAT *psbuf)
500 {
501 struct smb_filename *smb_fname_parent;
502 struct smb_filename *smb_fname_cwd = NULL;
503 char *saved_dir = NULL;
504 TALLOC_CTX *ctx = talloc_tos();
505 NTSTATUS status = NT_STATUS_OK;
506 int ret;
507
508 smb_fname_parent = synthetic_smb_fname(ctx, inherit_from_dir,
509 NULL, NULL);
510 if (smb_fname_parent == NULL) {
511 return NT_STATUS_NO_MEMORY;
512 }
513
514 ret = SMB_VFS_STAT(conn, smb_fname_parent);
515 if (ret == -1) {
516 status = map_nt_error_from_unix(errno);
517 DEBUG(0,("change_dir_owner_to_parent: failed to stat parent "
518 "directory %s. Error was %s\n",
519 smb_fname_str_dbg(smb_fname_parent),
520 strerror(errno)));
521 goto out;
522 }
523
524 /* We've already done an lstat into psbuf, and we know it's a
525 directory. If we can cd into the directory and the dev/ino
526 are the same then we can safely chown without races as
527 we're locking the directory in place by being in it. This
528 should work on any UNIX (thanks tridge :-). JRA.
529 */
530
531 saved_dir = vfs_GetWd(ctx,conn);
532 if (!saved_dir) {
533 status = map_nt_error_from_unix(errno);
534 DEBUG(0,("change_dir_owner_to_parent: failed to get "
535 "current working directory. Error was %s\n",
536 strerror(errno)));
537 goto out;
538 }
539
540 /* Chdir into the new path. */
541 if (vfs_ChDir(conn, fname) == -1) {
542 status = map_nt_error_from_unix(errno);
543 DEBUG(0,("change_dir_owner_to_parent: failed to change "
544 "current working directory to %s. Error "
545 "was %s\n", fname, strerror(errno) ));
546 goto chdir;
547 }
548
549 smb_fname_cwd = synthetic_smb_fname(ctx, ".", NULL, NULL);
550 if (smb_fname_cwd == NULL) {
551 status = NT_STATUS_NO_MEMORY;
552 goto chdir;
553 }
554
555 ret = SMB_VFS_STAT(conn, smb_fname_cwd);
556 if (ret == -1) {
557 status = map_nt_error_from_unix(errno);
558 DEBUG(0,("change_dir_owner_to_parent: failed to stat "
559 "directory '.' (%s) Error was %s\n",
560 fname, strerror(errno)));
561 goto chdir;
562 }
563
564 /* Ensure we're pointing at the same place. */
565 if (smb_fname_cwd->st.st_ex_dev != psbuf->st_ex_dev ||
566 smb_fname_cwd->st.st_ex_ino != psbuf->st_ex_ino) {
567 DEBUG(0,("change_dir_owner_to_parent: "
568 "device/inode on directory %s changed. "
569 "Refusing to chown !\n", fname ));
570 status = NT_STATUS_ACCESS_DENIED;
571 goto chdir;
572 }
573
574 if (smb_fname_parent->st.st_ex_uid == smb_fname_cwd->st.st_ex_uid) {
575 /* Already this uid - no need to change. */
576 DEBUG(10,("change_dir_owner_to_parent: directory %s "
577 "is already owned by uid %d\n",
578 fname,
579 (int)smb_fname_cwd->st.st_ex_uid ));
580 status = NT_STATUS_OK;
581 goto chdir;
582 }
583
584 become_root();
585 ret = SMB_VFS_LCHOWN(conn, ".", smb_fname_parent->st.st_ex_uid,
586 (gid_t)-1);
587 unbecome_root();
588 if (ret == -1) {
589 status = map_nt_error_from_unix(errno);
590 DEBUG(10,("change_dir_owner_to_parent: failed to chown "
591 "directory %s to parent directory uid %u. "
592 "Error was %s\n", fname,
593 (unsigned int)smb_fname_parent->st.st_ex_uid,
594 strerror(errno) ));
595 } else {
596 DEBUG(10,("change_dir_owner_to_parent: changed ownership of new "
597 "directory %s to parent directory uid %u.\n",
598 fname, (unsigned int)smb_fname_parent->st.st_ex_uid ));
599 /* Ensure the uid entry is updated. */
600 psbuf->st_ex_uid = smb_fname_parent->st.st_ex_uid;
601 }
602
603 chdir:
604 vfs_ChDir(conn,saved_dir);
605 out:
606 TALLOC_FREE(smb_fname_parent);
607 TALLOC_FREE(smb_fname_cwd);
608 return status;
609 }
610
611 /****************************************************************************
612 Open a file - returning a guaranteed ATOMIC indication of if the
613 file was created or not.
614 ****************************************************************************/
615
616 static NTSTATUS fd_open_atomic(struct connection_struct *conn,
617 files_struct *fsp,
618 int flags,
619 mode_t mode,
620 bool *file_created)
621 {
622 NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
623 bool file_existed = VALID_STAT(fsp->fsp_name->st);
624
625 *file_created = false;
626
627 if (!(flags & O_CREAT)) {
628 /*
629 * We're not creating the file, just pass through.
630 */
631 return fd_open(conn, fsp, flags, mode);
632 }
633
634 if (flags & O_EXCL) {
635 /*
636 * Fail if already exists, just pass through.
637 */
638 status = fd_open(conn, fsp, flags, mode);
639
640 /*
641 * Here we've opened with O_CREAT|O_EXCL. If that went
642 * NT_STATUS_OK, we *know* we created this file.
643 */
644 *file_created = NT_STATUS_IS_OK(status);
645
646 return status;
647 }
648
649 /*
650 * Now it gets tricky. We have O_CREAT, but not O_EXCL.
651 * To know absolutely if we created the file or not,
652 * we can never call O_CREAT without O_EXCL. So if
653 * we think the file existed, try without O_CREAT|O_EXCL.
654 * If we think the file didn't exist, try with
655 * O_CREAT|O_EXCL. Keep bouncing between these two
656 * requests until either the file is created, or
657 * opened. Either way, we keep going until we get
658 * a returnable result (error, or open/create).
659 */
660
661 while(1) {
662 int curr_flags = flags;
663
664 if (file_existed) {
665 /* Just try open, do not create. */
666 curr_flags &= ~(O_CREAT);
667 status = fd_open(conn, fsp, curr_flags, mode);
668 if (NT_STATUS_EQUAL(status,
669 NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
670 /*
671 * Someone deleted it in the meantime.
672 * Retry with O_EXCL.
673 */
674 file_existed = false;
675 DEBUG(10,("fd_open_atomic: file %s existed. "
676 "Retry.\n",
677 smb_fname_str_dbg(fsp->fsp_name)));
678 continue;
679 }
680 } else {
681 /* Try create exclusively, fail if it exists. */
682 curr_flags |= O_EXCL;
683 status = fd_open(conn, fsp, curr_flags, mode);
684 if (NT_STATUS_EQUAL(status,
685 NT_STATUS_OBJECT_NAME_COLLISION)) {
686 /*
687 * Someone created it in the meantime.
688 * Retry without O_CREAT.
689 */
690 file_existed = true;
691 DEBUG(10,("fd_open_atomic: file %s "
692 "did not exist. Retry.\n",
693 smb_fname_str_dbg(fsp->fsp_name)));
694 continue;
695 }
696 if (NT_STATUS_IS_OK(status)) {
697 /*
698 * Here we've opened with O_CREAT|O_EXCL
699 * and got success. We *know* we created
700 * this file.
701 */
702 *file_created = true;
703 }
704 }
705 /* Create is done, or failed. */
706 break;
707 }
708 return status;
709 }
710
711 /****************************************************************************
712 Open a file.
713 ****************************************************************************/
714
715 static NTSTATUS open_file(files_struct *fsp,
716 connection_struct *conn,
717 struct smb_request *req,
718 const char *parent_dir,
719 int flags,
720 mode_t unx_mode,
721 uint32 access_mask, /* client requested access mask. */
722 uint32 open_access_mask, /* what we're actually using in the open. */
723 bool *p_file_created)
724 {
725 struct smb_filename *smb_fname = fsp->fsp_name;
726 NTSTATUS status = NT_STATUS_OK;
727 int accmode = (flags & O_ACCMODE);
728 int local_flags = flags;
729 bool file_existed = VALID_STAT(fsp->fsp_name->st);
730
731 fsp->fh->fd = -1;
732 errno = EPERM;
733
734 /* Check permissions */
735
736 /*
737 * This code was changed after seeing a client open request
738 * containing the open mode of (DENY_WRITE/read-only) with
739 * the 'create if not exist' bit set. The previous code
740 * would fail to open the file read only on a read-only share
741 * as it was checking the flags parameter directly against O_RDONLY,
742 * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
743 * JRA.
744 */
745
746 if (!CAN_WRITE(conn)) {
747 /* It's a read-only share - fail if we wanted to write. */
748 if(accmode != O_RDONLY || (flags & O_TRUNC) || (flags & O_APPEND)) {
749 DEBUG(3,("Permission denied opening %s\n",
750 smb_fname_str_dbg(smb_fname)));
751 return NT_STATUS_ACCESS_DENIED;
752 }
753 if (flags & O_CREAT) {
754 /* We don't want to write - but we must make sure that
755 O_CREAT doesn't create the file if we have write
756 access into the directory.
757 */
758 flags &= ~(O_CREAT|O_EXCL);
759 local_flags &= ~(O_CREAT|O_EXCL);
760 }
761 }
762
763 /*
764 * This little piece of insanity is inspired by the
765 * fact that an NT client can open a file for O_RDONLY,
766 * but set the create disposition to FILE_EXISTS_TRUNCATE.
767 * If the client *can* write to the file, then it expects to
768 * truncate the file, even though it is opening for readonly.
769 * Quicken uses this stupid trick in backup file creation...
770 * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
771 * for helping track this one down. It didn't bite us in 2.0.x
772 * as we always opened files read-write in that release. JRA.
773 */
774
775 if ((accmode == O_RDONLY) && ((flags & O_TRUNC) == O_TRUNC)) {
776 DEBUG(10,("open_file: truncate requested on read-only open "
777 "for file %s\n", smb_fname_str_dbg(smb_fname)));
778 local_flags = (flags & ~O_ACCMODE)|O_RDWR;
779 }
780
781 if ((open_access_mask & (FILE_READ_DATA|FILE_WRITE_DATA|FILE_APPEND_DATA|FILE_EXECUTE)) ||
782 (!file_existed && (local_flags & O_CREAT)) ||
783 ((local_flags & O_TRUNC) == O_TRUNC) ) {
784 const char *wild;
785 int ret;
786
787 #if defined(O_NONBLOCK) && defined(S_ISFIFO)
788 /*
789 * We would block on opening a FIFO with no one else on the
790 * other end. Do what we used to do and add O_NONBLOCK to the
791 * open flags. JRA.
792 */
793
794 if (file_existed && S_ISFIFO(smb_fname->st.st_ex_mode)) {
795 local_flags &= ~O_TRUNC; /* Can't truncate a FIFO. */
796 local_flags |= O_NONBLOCK;
797 }
798 #endif
799
800 /* Don't create files with Microsoft wildcard characters. */
801 if (fsp->base_fsp) {
802 /*
803 * wildcard characters are allowed in stream names
804 * only test the basefilename
805 */
806 wild = fsp->base_fsp->fsp_name->base_name;
807 } else {
808 wild = smb_fname->base_name;
809 }
810 if ((local_flags & O_CREAT) && !file_existed &&
811 ms_has_wild(wild)) {
812 return NT_STATUS_OBJECT_NAME_INVALID;
813 }
814
815 /* Can we access this file ? */
816 if (!fsp->base_fsp) {
817 /* Only do this check on non-stream open. */
818 if (file_existed) {
819 status = smbd_check_access_rights(conn,
820 smb_fname,
821 false,
822 access_mask);
823
824 if (!NT_STATUS_IS_OK(status)) {
825 DEBUG(10, ("open_file: "
826 "smbd_check_access_rights "
827 "on file %s returned %s\n",
828 smb_fname_str_dbg(smb_fname),
829 nt_errstr(status)));
830 }
831
832 if (!NT_STATUS_IS_OK(status) &&
833 !NT_STATUS_EQUAL(status,
834 NT_STATUS_OBJECT_NAME_NOT_FOUND))
835 {
836 return status;
837 }
838
839 if (NT_STATUS_EQUAL(status,
840 NT_STATUS_OBJECT_NAME_NOT_FOUND))
841 {
842 DEBUG(10, ("open_file: "
843 "file %s vanished since we "
844 "checked for existence.\n",
845 smb_fname_str_dbg(smb_fname)));
846 file_existed = false;
847 SET_STAT_INVALID(fsp->fsp_name->st);
848 }
849 }
850
851 if (!file_existed) {
852 if (!(local_flags & O_CREAT)) {
853 /* File didn't exist and no O_CREAT. */
854 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
855 }
856
857 status = check_parent_access(conn,
858 smb_fname,
859 SEC_DIR_ADD_FILE);
860 if (!NT_STATUS_IS_OK(status)) {
861 DEBUG(10, ("open_file: "
862 "check_parent_access on "
863 "file %s returned %s\n",
864 smb_fname_str_dbg(smb_fname),
865 nt_errstr(status) ));
866 return status;
867 }
868 }
869 }
870
871 /*
872 * Actually do the open - if O_TRUNC is needed handle it
873 * below under the share mode lock.
874 */
875 status = fd_open_atomic(conn, fsp, local_flags & ~O_TRUNC,
876 unx_mode, p_file_created);
877 if (!NT_STATUS_IS_OK(status)) {
878 DEBUG(3,("Error opening file %s (%s) (local_flags=%d) "
879 "(flags=%d)\n", smb_fname_str_dbg(smb_fname),
880 nt_errstr(status),local_flags,flags));
881 return status;
882 }
883
884 ret = SMB_VFS_FSTAT(fsp, &smb_fname->st);
885 if (ret == -1) {
886 /* If we have an fd, this stat should succeed. */
887 DEBUG(0,("Error doing fstat on open file %s "
888 "(%s)\n",
889 smb_fname_str_dbg(smb_fname),
890 strerror(errno) ));
891 status = map_nt_error_from_unix(errno);
892 fd_close(fsp);
893 return status;
894 }
895
896 if (*p_file_created) {
897 /* We created this file. */
898
899 bool need_re_stat = false;
900 /* Do all inheritance work after we've
901 done a successful fstat call and filled
902 in the stat struct in fsp->fsp_name. */
903
904 /* Inherit the ACL if required */
905 if (lp_inherit_permissions(SNUM(conn))) {
906 inherit_access_posix_acl(conn, parent_dir,
907 smb_fname->base_name,
908 unx_mode);
909 need_re_stat = true;
910 }
911
912 /* Change the owner if required. */
913 if (lp_inherit_owner(SNUM(conn))) {
914 change_file_owner_to_parent(conn, parent_dir,
915 fsp);
916 need_re_stat = true;
917 }
918
919 if (need_re_stat) {
920 ret = SMB_VFS_FSTAT(fsp, &smb_fname->st);
921 /* If we have an fd, this stat should succeed. */
922 if (ret == -1) {
923 DEBUG(0,("Error doing fstat on open file %s "
924 "(%s)\n",
925 smb_fname_str_dbg(smb_fname),
926 strerror(errno) ));
927 }
928 }
929
930 notify_fname(conn, NOTIFY_ACTION_ADDED,
931 FILE_NOTIFY_CHANGE_FILE_NAME,
932 smb_fname->base_name);
933 }
934 } else {
935 fsp->fh->fd = -1; /* What we used to call a stat open. */
936 if (!file_existed) {
937 /* File must exist for a stat open. */
938 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
939 }
940
941 status = smbd_check_access_rights(conn,
942 smb_fname,
943 false,
944 access_mask);
945
946 if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND) &&
947 fsp->posix_open &&
948 S_ISLNK(smb_fname->st.st_ex_mode)) {
949 /* This is a POSIX stat open for delete
950 * or rename on a symlink that points
951 * nowhere. Allow. */
952 DEBUG(10,("open_file: allowing POSIX "
953 "open on bad symlink %s\n",
954 smb_fname_str_dbg(smb_fname)));
955 status = NT_STATUS_OK;
956 }
957
958 if (!NT_STATUS_IS_OK(status)) {
959 DEBUG(10,("open_file: "
960 "smbd_check_access_rights on file "
961 "%s returned %s\n",
962 smb_fname_str_dbg(smb_fname),
963 nt_errstr(status) ));
964 return status;
965 }
966 }
967
968 /*
969 * POSIX allows read-only opens of directories. We don't
970 * want to do this (we use a different code path for this)
971 * so catch a directory open and return an EISDIR. JRA.
972 */
973
974 if(S_ISDIR(smb_fname->st.st_ex_mode)) {
975 fd_close(fsp);
976 errno = EISDIR;
977 return NT_STATUS_FILE_IS_A_DIRECTORY;
978 }
979
980 fsp->file_id = vfs_file_id_from_sbuf(conn, &smb_fname->st);
981 fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
982 fsp->file_pid = req ? req->smbpid : 0;
983 fsp->can_lock = True;
984 fsp->can_read = ((access_mask & FILE_READ_DATA) != 0);
985 fsp->can_write =
986 CAN_WRITE(conn) &&
987 ((access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) != 0);
988 fsp->print_file = NULL;
989 fsp->modified = False;
990 fsp->sent_oplock_break = NO_BREAK_SENT;
991 fsp->is_directory = False;
992 if (conn->aio_write_behind_list &&
993 is_in_path(smb_fname->base_name, conn->aio_write_behind_list,
994 conn->case_sensitive)) {
995 fsp->aio_write_behind = True;
996 }
997
998 fsp->wcp = NULL; /* Write cache pointer. */
999
1000 DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
1001 conn->session_info->unix_info->unix_name,
1002 smb_fname_str_dbg(smb_fname),
1003 BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
1004 conn->num_files_open));
1005
1006 errno = 0;
1007 return NT_STATUS_OK;
1008 }
1009
1010 /****************************************************************************
1011 Check if we can open a file with a share mode.
1012 Returns True if conflict, False if not.
1013 ****************************************************************************/
1014
1015 static bool share_conflict(struct share_mode_entry *entry,
1016 uint32 access_mask,
1017 uint32 share_access)
1018 {
1019 DEBUG(10,("share_conflict: entry->access_mask = 0x%x, "
1020 "entry->share_access = 0x%x, "
1021 "entry->private_options = 0x%x\n",
1022 (unsigned int)entry->access_mask,
1023 (unsigned int)entry->share_access,
1024 (unsigned int)entry->private_options));
1025
1026 if (server_id_is_disconnected(&entry->pid)) {
1027 /*
1028 * note: cleanup should have been done by
1029 * delay_for_batch_oplocks()
1030 */
1031 return false;
1032 }
1033
1034 DEBUG(10,("share_conflict: access_mask = 0x%x, share_access = 0x%x\n",
1035 (unsigned int)access_mask, (unsigned int)share_access));
1036
1037 if ((entry->access_mask & (FILE_WRITE_DATA|
1038 FILE_APPEND_DATA|
1039 FILE_READ_DATA|
1040 FILE_EXECUTE|
1041 DELETE_ACCESS)) == 0) {
1042 DEBUG(10,("share_conflict: No conflict due to "
1043 "entry->access_mask = 0x%x\n",
1044 (unsigned int)entry->access_mask ));
1045 return False;
1046 }
1047
1048 if ((access_mask & (FILE_WRITE_DATA|
1049 FILE_APPEND_DATA|
1050 FILE_READ_DATA|
1051 FILE_EXECUTE|
1052 DELETE_ACCESS)) == 0) {
1053 DEBUG(10,("share_conflict: No conflict due to "
1054 "access_mask = 0x%x\n",
1055 (unsigned int)access_mask ));
1056 return False;
1057 }
1058
1059 #if 1 /* JRA TEST - Superdebug. */
1060 #define CHECK_MASK(num, am, right, sa, share) \
1061 DEBUG(10,("share_conflict: [%d] am (0x%x) & right (0x%x) = 0x%x\n", \
1062 (unsigned int)(num), (unsigned int)(am), \
1063 (unsigned int)(right), (unsigned int)(am)&(right) )); \
1064 DEBUG(10,("share_conflict: [%d] sa (0x%x) & share (0x%x) = 0x%x\n", \
1065 (unsigned int)(num), (unsigned int)(sa), \
1066 (unsigned int)(share), (unsigned int)(sa)&(share) )); \
1067 if (((am) & (right)) && !((sa) & (share))) { \
1068 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
1069 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
1070 (unsigned int)(share) )); \
1071 return True; \
1072 }
1073 #else
1074 #define CHECK_MASK(num, am, right, sa, share) \
1075 if (((am) & (right)) && !((sa) & (share))) { \
1076 DEBUG(10,("share_conflict: check %d conflict am = 0x%x, right = 0x%x, \
1077 sa = 0x%x, share = 0x%x\n", (num), (unsigned int)(am), (unsigned int)(right), (unsigned int)(sa), \
1078 (unsigned int)(share) )); \
1079 return True; \
1080 }
1081 #endif
1082
1083 CHECK_MASK(1, entry->access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
1084 share_access, FILE_SHARE_WRITE);
1085 CHECK_MASK(2, access_mask, FILE_WRITE_DATA | FILE_APPEND_DATA,
1086 entry->share_access, FILE_SHARE_WRITE);
1087
1088 CHECK_MASK(3, entry->access_mask, FILE_READ_DATA | FILE_EXECUTE,
1089 share_access, FILE_SHARE_READ);
1090 CHECK_MASK(4, access_mask, FILE_READ_DATA | FILE_EXECUTE,
1091 entry->share_access, FILE_SHARE_READ);
1092
1093 CHECK_MASK(5, entry->access_mask, DELETE_ACCESS,
1094 share_access, FILE_SHARE_DELETE);
1095 CHECK_MASK(6, access_mask, DELETE_ACCESS,
1096 entry->share_access, FILE_SHARE_DELETE);
1097
1098 DEBUG(10,("share_conflict: No conflict.\n"));
1099 return False;
1100 }
1101
1102 #if defined(DEVELOPER)
1103 static void validate_my_share_entries(struct smbd_server_connection *sconn,
1104 int num,
1105 struct share_mode_entry *share_entry)
1106 {
1107 struct server_id self = messaging_server_id(sconn->msg_ctx);
1108 files_struct *fsp;
1109
1110 if (!serverid_equal(&self, &share_entry->pid)) {
1111 return;
1112 }
1113
1114 if (share_entry->op_mid == 0) {
1115 /* INTERNAL_OPEN_ONLY */
1116 return;
1117 }
1118
1119 if (!is_valid_share_mode_entry(share_entry)) {
1120 return;
1121 }
1122
1123 fsp = file_find_dif(sconn, share_entry->id,
1124 share_entry->share_file_id);
1125 if (!fsp) {
1126 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
1127 share_mode_str(talloc_tos(), num, share_entry) ));
1128 smb_panic("validate_my_share_entries: Cannot match a "
1129 "share entry with an open file\n");
1130 }
1131
1132 if (((uint16)fsp->oplock_type) != share_entry->op_type) {
1133 goto panic;
1134 }
1135
1136 return;
1137
1138 panic:
1139 {
1140 char *str;
1141 DEBUG(0,("validate_my_share_entries: PANIC : %s\n",
1142 share_mode_str(talloc_tos(), num, share_entry) ));
1143 str = talloc_asprintf(talloc_tos(),
1144 "validate_my_share_entries: "
1145 "file %s, oplock_type = 0x%x, op_type = 0x%x\n",
1146 fsp->fsp_name->base_name,
1147 (unsigned int)fsp->oplock_type,
1148 (unsigned int)share_entry->op_type );
1149 smb_panic(str);
1150 }
1151 }
1152 #endif
1153
1154 bool is_stat_open(uint32 access_mask)
1155 {
1156 const uint32_t stat_open_bits =
1157 (SYNCHRONIZE_ACCESS|
1158 FILE_READ_ATTRIBUTES|
1159 FILE_WRITE_ATTRIBUTES);
1160
1161 return (((access_mask & stat_open_bits) != 0) &&
1162 ((access_mask & ~stat_open_bits) == 0));
1163 }
1164
1165 static bool has_delete_on_close(struct share_mode_lock *lck,
1166 uint32_t name_hash)
1167 {
1168 struct share_mode_data *d = lck->data;
1169 uint32_t i;
1170
1171 if (d->num_share_modes == 0) {
1172 return false;
1173 }
1174 if (!is_delete_on_close_set(lck, name_hash)) {
1175 return false;
1176 }
1177 for (i=0; i<d->num_share_modes; i++) {
1178 if (!share_mode_stale_pid(d, i)) {
1179 return true;
1180 }
1181 }
1182 return false;
1183 }
1184
1185 /****************************************************************************
1186 Deal with share modes
1187 Invariant: Share mode must be locked on entry and exit.
1188 Returns -1 on error, or number of share modes on success (may be zero).
1189 ****************************************************************************/
1190
1191 static NTSTATUS open_mode_check(connection_struct *conn,
1192 struct share_mode_lock *lck,
1193 uint32 access_mask,
1194 uint32 share_access)
1195 {
1196 int i;
1197
1198 if(lck->data->num_share_modes == 0) {
1199 return NT_STATUS_OK;
1200 }
1201
1202 if (is_stat_open(access_mask)) {
1203 /* Stat open that doesn't trigger oplock breaks or share mode
1204 * checks... ! JRA. */
1205 return NT_STATUS_OK;
1206 }
1207
1208 /*
1209 * Check if the share modes will give us access.
1210 */
1211
1212 #if defined(DEVELOPER)
1213 for(i = 0; i < lck->data->num_share_modes; i++) {
1214 validate_my_share_entries(conn->sconn, i,
1215 &lck->data->share_modes[i]);
1216 }
1217 #endif
1218
1219 /* Now we check the share modes, after any oplock breaks. */
1220 for(i = 0; i < lck->data->num_share_modes; i++) {
1221
1222 if (!is_valid_share_mode_entry(&lck->data->share_modes[i])) {
1223 continue;
1224 }
1225
1226 /* someone else has a share lock on it, check to see if we can
1227 * too */
1228 if (share_conflict(&lck->data->share_modes[i],
1229 access_mask, share_access)) {
1230
1231 if (share_mode_stale_pid(lck->data, i)) {
1232 continue;
1233 }
1234
1235 return NT_STATUS_SHARING_VIOLATION;
1236 }
1237 }
1238
1239 return NT_STATUS_OK;
1240 }
1241
1242 /*
1243 * Send a break message to the oplock holder and delay the open for
1244 * our client.
1245 */
1246
1247 static NTSTATUS send_break_message(struct messaging_context *msg_ctx,
1248 const struct share_mode_entry *exclusive,
1249 uint16_t break_to)
1250 {
1251 NTSTATUS status;
1252 char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
1253
1254 DEBUG(10, ("Sending break request to PID %s\n",
1255 procid_str_static(&exclusive->pid)));
1256
1257 /* Create the message. */
1258 share_mode_entry_to_message(msg, exclusive);
1259
1260 /* Overload entry->op_type */
1261 /*
1262 * This is a cut from uint32 to uint16, but so far only the lower 3
1263 * bits (LEASE_WRITE/HANDLE/READ are used anyway.
1264 */
1265 SSVAL(msg,OP_BREAK_MSG_OP_TYPE_OFFSET, break_to);
1266
1267 status = messaging_send_buf(msg_ctx, exclusive->pid,
1268 MSG_SMB_BREAK_REQUEST,
1269 (uint8 *)msg, sizeof(msg));
1270 if (!NT_STATUS_IS_OK(status)) {
1271 DEBUG(3, ("Could not send oplock break message: %s\n",
1272 nt_errstr(status)));
1273 }
1274
1275 return status;
1276 }
1277
1278 /*
1279 * Do internal consistency checks on the share mode for a file.
1280 */
1281
1282 static bool validate_oplock_types(struct share_mode_lock *lck)
1283 {
1284 struct share_mode_data *d = lck->data;
1285 bool batch = false;
1286 bool ex_or_batch = false;
1287 bool level2 = false;
1288 bool no_oplock = false;
1289 uint32_t num_non_stat_opens = 0;
1290 uint32_t i;
1291
1292 for (i=0; i<d->num_share_modes; i++) {
1293 struct share_mode_entry *e = &d->share_modes[i];
1294
1295 if (!is_valid_share_mode_entry(e)) {
1296 continue;
1297 }
1298
1299 if (e->op_mid == 0) {
1300 /* INTERNAL_OPEN_ONLY */
1301 continue;
1302 }
1303
1304 if (e->op_type == NO_OPLOCK && is_stat_open(e->access_mask)) {
1305 /* We ignore stat opens in the table - they
1306 always have NO_OPLOCK and never get or
1307 cause breaks. JRA. */
1308 continue;
1309 }
1310
1311 num_non_stat_opens += 1;
1312
1313 if (BATCH_OPLOCK_TYPE(e->op_type)) {
1314 /* batch - can only be one. */
1315 if (share_mode_stale_pid(d, i)) {
1316 DEBUG(10, ("Found stale batch oplock\n"));
1317 continue;
1318 }
1319 if (ex_or_batch || batch || level2 || no_oplock) {
1320 DEBUG(0, ("Bad batch oplock entry %u.",
1321 (unsigned)i));
1322 return false;
1323 }
1324 batch = true;
1325 }
1326
1327 if (EXCLUSIVE_OPLOCK_TYPE(e->op_type)) {
1328 if (share_mode_stale_pid(d, i)) {
1329 DEBUG(10, ("Found stale duplicate oplock\n"));
1330 continue;
1331 }
1332 /* Exclusive or batch - can only be one. */
1333 if (ex_or_batch || level2 || no_oplock) {
1334 DEBUG(0, ("Bad exclusive or batch oplock "
1335 "entry %u.", (unsigned)i));
1336 return false;
1337 }
1338 ex_or_batch = true;
1339 }
1340
1341 if (LEVEL_II_OPLOCK_TYPE(e->op_type)) {
1342 if (batch || ex_or_batch) {
1343 if (share_mode_stale_pid(d, i)) {
1344 DEBUG(10, ("Found stale LevelII "
1345 "oplock\n"));
1346 continue;
1347 }
1348 DEBUG(0, ("Bad levelII oplock entry %u.",
1349 (unsigned)i));
1350 return false;
1351 }
1352 level2 = true;
1353 }
1354
1355 if (e->op_type == NO_OPLOCK) {
1356 if (batch || ex_or_batch) {
1357 if (share_mode_stale_pid(d, i)) {
1358 DEBUG(10, ("Found stale NO_OPLOCK "
1359 "entry\n"));
1360 continue;
1361 }
1362 DEBUG(0, ("Bad no oplock entry %u.",
1363 (unsigned)i));
1364 return false;
1365 }
1366 no_oplock = true;
1367 }
1368 }
1369
1370 remove_stale_share_mode_entries(d);
1371
1372 if ((batch || ex_or_batch) && (num_non_stat_opens != 1)) {
1373 DEBUG(1, ("got batch (%d) or ex (%d) non-exclusively (%d)\n",
1374 (int)batch, (int)ex_or_batch,
1375 (int)d->num_share_modes));
1376 return false;
1377 }
1378
1379 return true;
1380 }
1381
1382 static bool delay_for_oplock(files_struct *fsp,
1383 int oplock_request,
1384 const struct smb2_lease *lease,
1385 struct share_mode_lock *lck,
1386 bool have_sharing_violation,
1387 uint32_t create_disposition,
1388 bool first_open_attempt)
1389 {
1390 struct share_mode_data *d = lck->data;
1391 uint32_t i;
1392 bool delay = false;
1393 bool will_overwrite;
1394
1395 if ((oplock_request & INTERNAL_OPEN_ONLY) ||
1396 is_stat_open(fsp->access_mask)) {
1397 return false;
1398 }
1399
1400 switch (create_disposition) {
1401 case FILE_SUPERSEDE:
1402 case FILE_OVERWRITE:
1403 case FILE_OVERWRITE_IF:
1404 will_overwrite = true;
1405 break;
1406 default:
1407 will_overwrite = false;
1408 break;
1409 }
1410
1411 for (i=0; i<d->num_share_modes; i++) {
1412 struct share_mode_entry *e = &d->share_modes[i];
1413 struct share_mode_lease *l = NULL;
1414 uint32_t e_lease_type = get_lease_type(d, e);
1415 uint32_t break_to;
1416 uint32_t delay_mask = 0;
1417
1418 if (e->op_type == LEASE_OPLOCK) {
1419 l = &d->leases[e->lease_idx];
1420 }
1421
1422 if (have_sharing_violation) {
1423 delay_mask = SMB2_LEASE_HANDLE;
1424 } else {
1425 delay_mask = SMB2_LEASE_WRITE;
1426 }
1427
1428 break_to = e_lease_type & ~delay_mask;
1429
1430 if (will_overwrite) {
1431 /*
1432 * we'll decide about SMB2_LEASE_READ later.
1433 *
1434 * Maybe the break will be defered
1435 */
1436 break_to &= ~SMB2_LEASE_HANDLE;
1437 }
1438
1439 DEBUG(10, ("entry %u: e_lease_type %u, will_overwrite: %u\n",
1440 (unsigned)i, (unsigned)e_lease_type,
1441 (unsigned)will_overwrite));
1442
1443 if (lease != NULL && l != NULL) {
1444 bool ign;
1445
1446 ign = smb2_lease_equal(fsp_client_guid(fsp),
1447 &lease->lease_key,
1448 &l->client_guid,
1449 &l->lease_key);
1450 if (ign) {
1451 continue;
1452 }
1453 }
1454
1455 if ((e_lease_type & ~break_to) == 0) {
1456 if (l != NULL && l->breaking) {
1457 delay = true;
1458 }
1459 continue;
1460 }
1461
1462 if (share_mode_stale_pid(d, i)) {
1463 continue;
1464 }
1465
1466 if (will_overwrite) {
1467 /*
1468 * If we break anyway break to NONE directly.
1469 * Otherwise vfs_set_filelen() will trigger the
1470 * break.
1471 */
1472 break_to &= ~(SMB2_LEASE_READ|SMB2_LEASE_WRITE);
1473 }
1474
1475 if (e->op_type != LEASE_OPLOCK) {
1476 /*
1477 * Oplocks only support breaking to R or NONE.
1478 */
1479 break_to &= ~(SMB2_LEASE_HANDLE|SMB2_LEASE_WRITE);
1480 }
1481
1482 DEBUG(10, ("breaking from %d to %d\n",
1483 (int)e_lease_type, (int)break_to));
1484 send_break_message(fsp->conn->sconn->msg_ctx, e,
1485 break_to);
1486 if (e_lease_type & delay_mask) {
1487 delay = true;
1488 }
1489 if (l != NULL && l->breaking && !first_open_attempt) {
1490 delay = true;
1491 }
1492 continue;
1493 }
1494
1495 return delay;
1496 }
1497
1498 static bool file_has_brlocks(files_struct *fsp)
1499 {
1500 struct byte_range_lock *br_lck;
1501
1502 br_lck = brl_get_locks_readonly(fsp);
1503 if (!br_lck)
1504 return false;
1505
1506 return (brl_num_locks(br_lck) > 0);
1507 }
1508
1509 int find_share_mode_lease(struct share_mode_data *d,
1510 const struct GUID *client_guid,
1511 const struct smb2_lease_key *key)
1512 {
1513 uint32_t i;
1514
1515 for (i=0; i<d->num_leases; i++) {
1516 struct share_mode_lease *l = &d->leases[i];
1517
1518 if (smb2_lease_equal(client_guid,
1519 key,
1520 &l->client_guid,
1521 &l->lease_key)) {
1522 return i;
1523 }
1524 }
1525
1526 return -1;
1527 }
1528
1529 struct fsp_lease *find_fsp_lease(struct files_struct *new_fsp,
1530 const struct smb2_lease_key *key,
1531 const struct share_mode_lease *l)
1532 {
1533 struct files_struct *fsp;
1534
1535 /*
1536 * TODO: Measure how expensive this loop is with thousands of open
1537 * handles...
1538 */
1539
1540 for (fsp = file_find_di_first(new_fsp->conn->sconn, new_fsp->file_id);
1541 fsp != NULL;
1542 fsp = file_find_di_next(fsp)) {
1543
1544 if (fsp == new_fsp) {
1545 continue;
1546 }
1547 if (fsp->oplock_type != LEASE_OPLOCK) {
1548 continue;
1549 }
1550 if (smb2_lease_key_equal(&fsp->lease->lease.lease_key, key)) {
1551 fsp->lease->ref_count += 1;
1552 return fsp->lease;
1553 }
1554 }
1555
1556 /* Not found - must be leased in another smbd. */
1557 new_fsp->lease = talloc_zero(new_fsp->conn->sconn, struct fsp_lease);
1558 if (new_fsp->lease == NULL) {
1559 return NULL;
1560 }
1561 new_fsp->lease->ref_count = 1;
1562 new_fsp->lease->sconn = new_fsp->conn->sconn;
1563 new_fsp->lease->lease.lease_key = *key;
1564 new_fsp->lease->lease.lease_state = l->current_state;
1565 /*
1566 * We internally treat all leases as V2 and update
1567 * the epoch, but when sending breaks it matters if
1568 * the requesting lease was v1 or v2.
1569 */
1570 new_fsp->lease->lease.lease_version = l->lease_version;
1571 new_fsp->lease->lease.lease_epoch = l->epoch;
1572 return new_fsp->lease;
1573 }
1574
1575 static NTSTATUS grant_fsp_lease(struct files_struct *fsp,
1576 struct share_mode_lock *lck,
1577 const struct smb2_lease *lease,
1578 uint32_t *p_lease_idx,
1579 uint32_t granted)
1580 {
1581 struct share_mode_data *d = lck->data;
1582 const struct GUID *client_guid = fsp_client_guid(fsp);
1583 struct share_mode_lease *tmp;
1584 NTSTATUS status;
1585 int idx;
1586
1587 idx = find_share_mode_lease(d, client_guid, &lease->lease_key);
1588
1589 if (idx != -1) {
1590 struct share_mode_lease *l = &d->leases[idx];
1591 bool do_upgrade;
1592 uint32_t existing, requested;
1593
1594 fsp->lease = find_fsp_lease(fsp, &lease->lease_key, l);
1595 if (fsp->lease == NULL) {
1596 DEBUG(1, ("Did not find existing lease for file %s\n",
1597 fsp_str_dbg(fsp)));
1598 return NT_STATUS_NO_MEMORY;
1599 }
1600
1601 *p_lease_idx = idx;
1602
1603 /*
1604 * Upgrade only if the requested lease is a strict upgrade.
1605 */
1606 existing = l->current_state;
1607 requested = lease->lease_state;
1608
1609 /*
1610 * Tricky: This test makes sure that "requested" is a
1611 * strict bitwise superset of "existing".
1612 */
1613 do_upgrade = ((existing & requested) == existing);
1614
1615 /*
1616 * Upgrade only if there's a change.
1617 */
1618 do_upgrade &= (granted != existing);
1619
1620 /*
1621 * Upgrade only if other leases don't prevent what was asked
1622 * for.
1623 */
1624 do_upgrade &= (granted == requested);
1625
1626 /*
1627 * only upgrade if we are not in breaking state
1628 */
1629 do_upgrade &= !l->breaking;
1630
1631 DEBUG(10, ("existing=%"PRIu32", requested=%"PRIu32", "
1632 "granted=%"PRIu32", do_upgrade=%d\n",
1633 existing, requested, granted, (int)do_upgrade));
1634
1635 if (do_upgrade) {
1636 l->current_state = granted;
1637 l->epoch += 1;
1638 }
1639
1640 /* Ensure we're in sync with current lease state. */
1641 fsp_lease_update(lck, fsp_client_guid(fsp), fsp->lease);
1642 return NT_STATUS_OK;
1643 }
1644
1645 /*
1646 * Create new lease
1647 */
1648
1649 tmp = talloc_realloc(d, d->leases, struct share_mode_lease,
1650 d->num_leases+1);
1651 if (tmp == NULL) {
1652 /*
1653 * See [MS-SMB2]
1654 */
1655 return NT_STATUS_INSUFFICIENT_RESOURCES;
1656 }
1657 d->leases = tmp;
1658
1659 fsp->lease = talloc_zero(fsp->conn->sconn, struct fsp_lease);
1660 if (fsp->lease == NULL) {
1661 return NT_STATUS_INSUFFICIENT_RESOURCES;
1662 }
1663 fsp->lease->ref_count = 1;
1664 fsp->lease->sconn = fsp->conn->sconn;
1665 fsp->lease->lease.lease_version = lease->lease_version;
1666 fsp->lease->lease.lease_key = lease->lease_key;
1667 fsp->lease->lease.lease_state = granted;
1668 fsp->lease->lease.lease_epoch = lease->lease_epoch + 1;
1669
1670 *p_lease_idx = d->num_leases;
1671
1672 d->leases[d->num_leases] = (struct share_mode_lease) {
1673 .client_guid = *client_guid,
1674 .lease_key = fsp->lease->lease.lease_key,
1675 .current_state = fsp->lease->lease.lease_state,
1676 .lease_version = fsp->lease->lease.lease_version,
1677 .epoch = fsp->lease->lease.lease_epoch,
1678 };
1679
1680 status = leases_db_add(client_guid, &lease->lease_key,
1681 &fsp->file_id, fsp->fsp_name->base_name,
1682 fsp->fsp_name->stream_name);
1683 if (!NT_STATUS_IS_OK(status)) {
1684 DEBUG(10, ("%s: leases_db_add failed: %s\n", __func__,
1685 nt_errstr(status)));
1686 TALLOC_FREE(fsp->lease);
1687 return NT_STATUS_INSUFFICIENT_RESOURCES;
1688 }
1689
1690 d->num_leases += 1;
1691 d->modified = true;
1692
1693 return NT_STATUS_OK;
1694 }
1695
1696 static bool is_same_lease(const files_struct *fsp,
1697 const struct share_mode_data *d,
1698 const struct share_mode_entry *e,
1699 const struct smb2_lease *lease)
1700 {
1701 if (e->op_type != LEASE_OPLOCK) {
1702 return false;
1703 }
1704 if (lease == NULL) {
1705 return false;
1706 }
1707
1708 return smb2_lease_equal(fsp_client_guid(fsp),
1709 &lease->lease_key,
1710 &d->leases[e->lease_idx].client_guid,
1711 &d->leases[e->lease_idx].lease_key);
1712 }
1713
1714 static NTSTATUS grant_fsp_oplock_type(struct smb_request *req,
1715 struct files_struct *fsp,
1716 struct share_mode_lock *lck,
1717 int oplock_request,
1718 struct smb2_lease *lease)
1719 {
1720 struct share_mode_data *d = lck->data;
1721 bool got_handle_lease = false;
1722 bool got_oplock = false;
1723 uint32_t i;
1724 uint32_t granted;
1725 uint32_t lease_idx = UINT32_MAX;
1726 bool ok;
1727 NTSTATUS status;
1728
1729 if (oplock_request & INTERNAL_OPEN_ONLY) {
1730 /* No oplocks on internal open. */
1731 oplock_request = NO_OPLOCK;
1732 DEBUG(10,("grant_fsp_oplock_type: oplock type 0x%x on file %s\n",
1733 fsp->oplock_type, fsp_str_dbg(fsp)));
1734 }
1735
1736 if (oplock_request == LEASE_OPLOCK) {
1737 if (lease == NULL) {
1738 /*
1739 * The SMB2 layer should have checked this
1740 */
1741 return NT_STATUS_INTERNAL_ERROR;
1742 }
1743
1744 granted = lease->lease_state;
1745
1746 if (lp_kernel_oplocks(SNUM(fsp->conn))) {
1747 DEBUG(10, ("No lease granted because kernel oplocks are enabled\n"));
1748 granted = SMB2_LEASE_NONE;
1749 }
1750 if ((granted & (SMB2_LEASE_READ|SMB2_LEASE_WRITE)) == 0) {
1751 DEBUG(10, ("No read or write lease requested\n"));
1752 granted = SMB2_LEASE_NONE;
1753 }
1754 if (granted == SMB2_LEASE_WRITE) {
1755 DEBUG(10, ("pure write lease requested\n"));
1756 granted = SMB2_LEASE_NONE;
1757 }
1758 if (granted == (SMB2_LEASE_WRITE|SMB2_LEASE_HANDLE)) {
1759 DEBUG(10, ("write and handle lease requested\n"));
1760 granted = SMB2_LEASE_NONE;
1761 }
1762 } else {
1763 granted = map_oplock_to_lease_type(
1764 oplock_request & ~SAMBA_PRIVATE_OPLOCK_MASK);
1765 }
1766
1767 if (lp_locking(fsp->conn->params) && file_has_brlocks(fsp)) {
1768 DEBUG(10,("grant_fsp_oplock_type: file %s has byte range locks\n",
1769 fsp_str_dbg(fsp)));
1770 granted &= ~SMB2_LEASE_READ;
1771 }
1772
1773 for (i=0; i<d->num_share_modes; i++) {
1774 struct share_mode_entry *e = &d->share_modes[i];
1775 uint32_t e_lease_type;
1776
1777 e_lease_type = get_lease_type(d, e);
1778
1779 if ((granted & SMB2_LEASE_WRITE) &&
1780 !is_same_lease(fsp, d, e, lease) &&
1781 !share_mode_stale_pid(d, i)) {
1782 /*
1783 * Can grant only one writer
1784 */
1785 granted &= ~SMB2_LEASE_WRITE;
1786 }
1787
1788 if ((e_lease_type & SMB2_LEASE_HANDLE) && !got_handle_lease &&
1789 !share_mode_stale_pid(d, i)) {
1790 got_handle_lease = true;
1791 }
1792
1793 if ((e->op_type != LEASE_OPLOCK) && !got_oplock &&
1794 !share_mode_stale_pid(d, i)) {
1795 got_oplock = true;
1796 }
1797 }
1798
1799 if ((granted & SMB2_LEASE_READ) && !(granted & SMB2_LEASE_WRITE)) {
1800 bool allow_level2 =
1801 (global_client_caps & CAP_LEVEL_II_OPLOCKS) &&
1802 lp_level2_oplocks(SNUM(fsp->conn));
1803
1804 if (!allow_level2) {
1805 granted = SMB2_LEASE_NONE;
1806 }
1807 }
1808
1809 if (oplock_request == LEASE_OPLOCK) {
1810 if (got_oplock) {
1811 granted &= ~SMB2_LEASE_HANDLE;
1812 }
1813
1814 fsp->oplock_type = LEASE_OPLOCK;
1815
1816 status = grant_fsp_lease(fsp, lck, lease, &lease_idx,
1817 granted);
1818 if (!NT_STATUS_IS_OK(status)) {
1819 return status;
1820
1821 }
1822 *lease = fsp->lease->lease;
1823 DEBUG(10, ("lease_state=%d\n", lease->lease_state));
1824 } else {
1825 if (got_handle_lease) {
1826 granted = SMB2_LEASE_NONE;
1827 }
1828
1829 switch (granted) {
1830 case SMB2_LEASE_READ|SMB2_LEASE_WRITE|SMB2_LEASE_HANDLE:
1831 fsp->oplock_type = BATCH_OPLOCK|EXCLUSIVE_OPLOCK;
1832 break;
1833 case SMB2_LEASE_READ|SMB2_LEASE_WRITE:
1834 fsp->oplock_type = EXCLUSIVE_OPLOCK;
1835 break;
1836 case SMB2_LEASE_READ|SMB2_LEASE_HANDLE:
1837 case SMB2_LEASE_READ:
1838 fsp->oplock_type = LEVEL_II_OPLOCK;
1839 break;
1840 default:
1841 fsp->oplock_type = NO_OPLOCK;
1842 break;
1843 }
1844
1845 status = set_file_oplock(fsp);
1846 if (!NT_STATUS_IS_OK(status)) {
1847 /*
1848 * Could not get the kernel oplock
1849 */
1850 fsp->oplock_type = NO_OPLOCK;
1851 }
1852 }
1853
1854 ok = set_share_mode(lck, fsp, get_current_uid(fsp->conn),
1855 req ? req->mid : 0,
1856 fsp->oplock_type,
1857 lease_idx);
1858 if (!ok) {
1859 return NT_STATUS_NO_MEMORY;
1860 }
1861
1862 ok = update_num_read_oplocks(fsp, lck);
1863 if (!ok) {
1864 del_share_mode(lck, fsp);
1865 return NT_STATUS_INTERNAL_ERROR;
1866 }
1867
1868 DEBUG(10,("grant_fsp_oplock_type: oplock type 0x%x on file %s\n",
1869 fsp->oplock_type, fsp_str_dbg(fsp)));
1870
1871 return NT_STATUS_OK;
1872 }
1873
1874 static bool request_timed_out(struct timeval request_time,
1875 struct timeval timeout)
1876 {
1877 struct timeval now, end_time;
1878 GetTimeOfDay(&now);
1879 end_time = timeval_sum(&request_time, &timeout);
1880 return (timeval_compare(&end_time, &now) < 0);
1881 }
1882
1883 struct defer_open_state {
1884 struct smbXsrv_connection *xconn;
1885 uint64_t mid;
1886 };
1887
1888 static void defer_open_done(struct tevent_req *req);
1889
1890 /****************************************************************************
1891 Handle the 1 second delay in returning a SHARING_VIOLATION error.
1892 ****************************************************************************/
1893
1894 static void defer_open(struct share_mode_lock *lck,
1895 struct timeval request_time,
1896 struct timeval timeout,
1897 struct smb_request *req,
1898 struct deferred_open_record *state)
1899 {
1900 struct deferred_open_record *open_rec;
1901
1902 DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred "
1903 "open entry for mid %llu\n",
1904 (unsigned int)request_time.tv_sec,
1905 (unsigned int)request_time.tv_usec,
1906 (unsigned long long)req->mid));
1907
1908 open_rec = talloc(NULL, struct deferred_open_record);
1909 if (open_rec == NULL) {
1910 TALLOC_FREE(lck);
1911 exit_server("talloc failed");
1912 }
1913
1914 *open_rec = *state;
1915
1916 if (lck) {
1917 struct defer_open_state *watch_state;
1918 struct tevent_req *watch_req;
1919 bool ret;
1920
1921 watch_state = talloc(open_rec, struct defer_open_state);
1922 if (watch_state == NULL) {
1923 exit_server("talloc failed");
1924 }
1925 watch_state->xconn = req->xconn;
1926 watch_state->mid = req->mid;
1927
1928 DEBUG(10, ("defering mid %llu\n",
1929 (unsigned long long)req->mid));
1930
1931 watch_req = dbwrap_record_watch_send(
1932 watch_state, req->sconn->ev_ctx, lck->data->record,
1933 req->sconn->msg_ctx);
1934 if (watch_req == NULL) {
1935 exit_server("Could not watch share mode record");
1936 }
1937 tevent_req_set_callback(watch_req, defer_open_done,
1938 watch_state);
1939
1940 ret = tevent_req_set_endtime(
1941 watch_req, req->sconn->ev_ctx,
1942 timeval_sum(&request_time, &timeout));
1943 SMB_ASSERT(ret);
1944 }
1945
1946 if (!push_deferred_open_message_smb(req, request_time, timeout,
1947 state->id, open_rec)) {
1948 TALLOC_FREE(lck);
1949 exit_server("push_deferred_open_message_smb failed");
1950 }
1951 }
1952
1953 static void defer_open_done(struct tevent_req *req)
1954 {
1955 struct defer_open_state *state = tevent_req_callback_data(
1956 req, struct defer_open_state);
1957 NTSTATUS status;
1958 bool ret;
1959
1960 status = dbwrap_record_watch_recv(req, talloc_tos(), NULL);
1961 TALLOC_FREE(req);
1962 if (!NT_STATUS_IS_OK(status)) {
1963 DEBUG(5, ("dbwrap_record_watch_recv returned %s\n",
1964 nt_errstr(status)));
1965 /*
1966 * Even if it failed, retry anyway. TODO: We need a way to
1967 * tell a re-scheduled open about that error.
1968 */
1969 }
1970
1971 DEBUG(10, ("scheduling mid %llu\n", (unsigned long long)state->mid));
1972
1973 ret = schedule_deferred_open_message_smb(state->xconn, state->mid);
1974 SMB_ASSERT(ret);
1975 TALLOC_FREE(state);
1976 }
1977
1978
1979 /****************************************************************************
1980 On overwrite open ensure that the attributes match.
1981 ****************************************************************************/
1982
1983 static bool open_match_attributes(connection_struct *conn,
1984 uint32 old_dos_attr,
1985 uint32 new_dos_attr,
1986 mode_t existing_unx_mode,
1987 mode_t new_unx_mode,
1988 mode_t *returned_unx_mode)
1989 {
1990 uint32 noarch_old_dos_attr, noarch_new_dos_attr;
1991
1992 noarch_old_dos_attr = (old_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
1993 noarch_new_dos_attr = (new_dos_attr & ~FILE_ATTRIBUTE_ARCHIVE);
1994
1995 if((noarch_old_dos_attr == 0 && noarch_new_dos_attr != 0) ||
1996 (noarch_old_dos_attr != 0 && ((noarch_old_dos_attr & noarch_new_dos_attr) == noarch_old_dos_attr))) {
1997 *returned_unx_mode = new_unx_mode;
1998 } else {
1999 *returned_unx_mode = (mode_t)0;
2000 }
2001
2002 DEBUG(10,("open_match_attributes: old_dos_attr = 0x%x, "
2003 "existing_unx_mode = 0%o, new_dos_attr = 0x%x "
2004 "returned_unx_mode = 0%o\n",
2005 (unsigned int)old_dos_attr,
2006 (unsigned int)existing_unx_mode,
2007 (unsigned int)new_dos_attr,
2008 (unsigned int)*returned_unx_mode ));
2009
2010 /* If we're mapping SYSTEM and HIDDEN ensure they match. */
2011 if (lp_map_system(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
2012 if ((old_dos_attr & FILE_ATTRIBUTE_SYSTEM) &&
2013 !(new_dos_attr & FILE_ATTRIBUTE_SYSTEM)) {
2014 return False;
2015 }
2016 }
2017 if (lp_map_hidden(SNUM(conn)) || lp_store_dos_attributes(SNUM(conn))) {
2018 if ((old_dos_attr & FILE_ATTRIBUTE_HIDDEN) &&
2019 !(new_dos_attr & FILE_ATTRIBUTE_HIDDEN)) {
2020 return False;
2021 }
2022 }
2023 return True;
2024 }
2025
2026 /****************************************************************************
2027 Special FCB or DOS processing in the case of a sharing violation.
2028 Try and find a duplicated file handle.
2029 ****************************************************************************/
2030
2031 static NTSTATUS fcb_or_dos_open(struct smb_request *req,
2032 connection_struct *conn,
2033 files_struct *fsp_to_dup_into,
2034 const struct smb_filename *smb_fname,
2035 struct file_id id,
2036 uint16 file_pid,
2037 uint64_t vuid,
2038 uint32 access_mask,
2039 uint32 share_access,
2040 uint32 create_options)
2041 {
2042 files_struct *fsp;
2043
2044 DEBUG(5,("fcb_or_dos_open: attempting old open semantics for "
2045 "file %s.\n", smb_fname_str_dbg(smb_fname)));
2046
2047 for(fsp = file_find_di_first(conn->sconn, id); fsp;
2048 fsp = file_find_di_next(fsp)) {
2049
2050 DEBUG(10,("fcb_or_dos_open: checking file %s, fd = %d, "
2051 "vuid = %llu, file_pid = %u, private_options = 0x%x "
2052 "access_mask = 0x%x\n", fsp_str_dbg(fsp),
2053 fsp->fh->fd, (unsigned long long)fsp->vuid,
2054 (unsigned int)fsp->file_pid,
2055 (unsigned int)fsp->fh->private_options,
2056 (unsigned int)fsp->access_mask ));
2057
2058 if (fsp != fsp_to_dup_into &&
2059 fsp->fh->fd != -1 &&
2060 fsp->vuid == vuid &&
2061 fsp->file_pid == file_pid &&
2062 (fsp->fh->private_options & (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS |
2063 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) &&
2064 (fsp->access_mask & FILE_WRITE_DATA) &&
2065 strequal(fsp->fsp_name->base_name, smb_fname->base_name) &&
2066 strequal(fsp->fsp_name->stream_name,
2067 smb_fname->stream_name)) {
2068 DEBUG(10,("fcb_or_dos_open: file match\n"));
2069 break;
2070 }
2071 }
2072
2073 if (!fsp) {
2074 return NT_STATUS_NOT_FOUND;
2075 }
2076
2077 /* quite an insane set of semantics ... */
2078 if (is_executable(smb_fname->base_name) &&
2079 (fsp->fh->private_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS)) {
2080 DEBUG(10,("fcb_or_dos_open: file fail due to is_executable.\n"));
2081 return NT_STATUS_INVALID_PARAMETER;
2082 }
2083
2084 /* We need to duplicate this fsp. */
2085 return dup_file_fsp(req, fsp, access_mask, share_access,
2086 create_options, fsp_to_dup_into);
2087 }
2088
2089 static void schedule_defer_open(struct share_mode_lock *lck,
2090 struct file_id id,
2091 struct timeval request_time,
2092 struct smb_request *req)
2093 {
2094 struct deferred_open_record state;
2095
2096 /* This is a relative time, added to the absolute
2097 request_time value to get the absolute timeout time.
2098 Note that if this is the second or greater time we enter
2099 this codepath for this particular request mid then
2100 request_time is left as the absolute time of the *first*
2101 time this request mid was processed. This is what allows
2102 the request to eventually time out. */
2103
2104 struct timeval timeout;
2105
2106 /* Normally the smbd we asked should respond within
2107 * OPLOCK_BREAK_TIMEOUT seconds regardless of whether
2108 * the client did, give twice the timeout as a safety
2109 * measure here in case the other smbd is stuck
2110 * somewhere else. */
2111
2112 timeout = timeval_set(OPLOCK_BREAK_TIMEOUT*2, 0);
2113
2114 /* Nothing actually uses state.delayed_for_oplocks
2115 but it's handy to differentiate in debug messages
2116 between a 30 second delay due to oplock break, and
2117 a 1 second delay for share mode conflicts. */
2118
2119 state.delayed_for_oplocks = True;
2120 state.async_open = false;
2121 state.id = id;
2122
2123 if (!request_timed_out(request_time, timeout)) {
2124 defer_open(lck, request_time, timeout, req, &state);
2125 }
2126 }
2127
2128 /****************************************************************************
2129 Reschedule an open call that went asynchronous.
2130 ****************************************************************************/
2131
2132 static void schedule_async_open(struct timeval request_time,
2133 struct smb_request *req)
2134 {
2135 struct deferred_open_record state;
2136 struct timeval timeout;
2137
2138 timeout = timeval_set(20, 0);
2139
2140 ZERO_STRUCT(state);
2141 state.delayed_for_oplocks = false;
2142 state.async_open = true;
2143
2144 if (!request_timed_out(request_time, timeout)) {
2145 defer_open(NULL, request_time, timeout, req, &state);
2146 }
2147 }
2148
2149 /****************************************************************************
2150 Work out what access_mask to use from what the client sent us.
2151 ****************************************************************************/
2152
2153 static NTSTATUS smbd_calculate_maximum_allowed_access(
2154 connection_struct *conn,
2155 const struct smb_filename *smb_fname,
2156 bool use_privs,
2157 uint32_t *p_access_mask)
2158 {
2159 struct security_descriptor *sd;
2160 uint32_t access_granted;
2161 NTSTATUS status;
2162
2163 if (!use_privs && (get_current_uid(conn) == (uid_t)0)) {
2164 *p_access_mask |= FILE_GENERIC_ALL;
2165 return NT_STATUS_OK;
2166 }
2167
2168 status = SMB_VFS_GET_NT_ACL(conn, smb_fname->base_name,
2169 (SECINFO_OWNER |
2170 SECINFO_GROUP |
2171 SECINFO_DACL),
2172 talloc_tos(), &sd);
2173
2174 if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
2175 /*
2176 * File did not exist
2177 */
2178 *p_access_mask = FILE_GENERIC_ALL;
2179 return NT_STATUS_OK;
2180 }
2181 if (!NT_STATUS_IS_OK(status)) {
2182 DEBUG(10,("Could not get acl on file %s: %s\n",
2183 smb_fname_str_dbg(smb_fname),
2184 nt_errstr(status)));
2185 return NT_STATUS_ACCESS_DENIED;
2186 }
2187
2188 /*
2189 * If we can access the path to this file, by
2190 * default we have FILE_READ_ATTRIBUTES from the
2191 * containing directory. See the section:
2192 * "Algorithm to Check Access to an Existing File"
2193 * in MS-FSA.pdf.
2194 *
2195 * se_file_access_check()
2196 * also takes care of owner WRITE_DAC and READ_CONTROL.
2197 */
2198 status = se_file_access_check(sd,
2199 get_current_nttok(conn),
2200 use_privs,
2201 (*p_access_mask & ~FILE_READ_ATTRIBUTES),
2202 &access_granted);
2203
2204 TALLOC_FREE(sd);
2205
2206 if (!NT_STATUS_IS_OK(status)) {
2207 DEBUG(10, ("Access denied on file %s: "
2208 "when calculating maximum access\n",
2209 smb_fname_str_dbg(smb_fname)));
2210 return NT_STATUS_ACCESS_DENIED;
2211 }
2212 *p_access_mask = (access_granted | FILE_READ_ATTRIBUTES);
2213
2214 if (!(access_granted & DELETE_ACCESS)) {
2215 if (can_delete_file_in_directory(conn, smb_fname)) {
2216 *p_access_mask |= DELETE_ACCESS;
2217 }
2218 }
2219
2220 return NT_STATUS_OK;
2221 }
2222
2223 NTSTATUS smbd_calculate_access_mask(connection_struct *conn,
2224 const struct smb_filename *smb_fname,
2225 bool use_privs,
2226 uint32_t access_mask,
2227 uint32_t *access_mask_out)
2228 {
2229 NTSTATUS status;
2230 uint32_t orig_access_mask = access_mask;
2231 uint32_t rejected_share_access;
2232
2233 /*
2234 * Convert GENERIC bits to specific bits.
2235 */
2236
2237 se_map_generic(&access_mask, &file_generic_mapping);
2238
2239 /* Calculate MAXIMUM_ALLOWED_ACCESS if requested. */
2240 if (access_mask & MAXIMUM_ALLOWED_ACCESS) {
2241
2242 status = smbd_calculate_maximum_allowed_access(
2243 conn, smb_fname, use_privs, &access_mask);
2244
2245 if (!NT_STATUS_IS_OK(status)) {
2246 return status;
2247 }
2248
2249 access_mask &= conn->share_access;
2250 }
2251
2252 rejected_share_access = access_mask & ~(conn->share_access);
2253
2254 if (rejected_share_access) {
2255 DEBUG(10, ("smbd_calculate_access_mask: Access denied on "
2256 "file %s: rejected by share access mask[0x%08X] "
2257 "orig[0x%08X] mapped[0x%08X] reject[0x%08X]\n",
2258 smb_fname_str_dbg(smb_fname),
2259 conn->share_access,
2260 orig_access_mask, access_mask,
2261 rejected_share_access));
2262 return NT_STATUS_ACCESS_DENIED;
2263 }
2264
2265 *access_mask_out = access_mask;
2266 return NT_STATUS_OK;
2267 }
2268
2269 /****************************************************************************
2270 Remove the deferred open entry under lock.
2271 ****************************************************************************/
2272
2273 /****************************************************************************
2274 Return true if this is a state pointer to an asynchronous create.
2275 ****************************************************************************/
2276
2277 bool is_deferred_open_async(const struct deferred_open_record *rec)
2278 {
2279 return rec->async_open;
2280 }
2281
2282 static bool clear_ads(uint32_t create_disposition)
2283 {
2284 bool ret = false;
2285
2286 switch (create_disposition) {
2287 case FILE_SUPERSEDE:
2288 case FILE_OVERWRITE_IF:
2289 case FILE_OVERWRITE:
2290 ret = true;
2291 break;
2292 default:
2293 break;
2294 }
2295 return ret;
2296 }
2297
2298 static int disposition_to_open_flags(uint32_t create_disposition)
2299 {
2300 int ret = 0;
2301
2302 /*
2303 * Currently we're using FILE_SUPERSEDE as the same as
2304 * FILE_OVERWRITE_IF but they really are
2305 * different. FILE_SUPERSEDE deletes an existing file
2306 * (requiring delete access) then recreates it.
2307 */
2308
2309 switch (create_disposition) {
2310 case FILE_SUPERSEDE:
2311 case FILE_OVERWRITE_IF:
2312 /*
2313 * If file exists replace/overwrite. If file doesn't
2314 * exist create.
2315 */
2316 ret = O_CREAT|O_TRUNC;
2317 break;
2318
2319 case FILE_OPEN:
2320 /*
2321 * If file exists open. If file doesn't exist error.
2322 */
2323 ret = 0;
2324 break;
2325
2326 case FILE_OVERWRITE:
2327 /*
2328 * If file exists overwrite. If file doesn't exist
2329 * error.
2330 */
2331 ret = O_TRUNC;
2332 break;
2333
2334 case FILE_CREATE:
2335 /*
2336 * If file exists error. If file doesn't exist create.
2337 */
2338 ret = O_CREAT|O_EXCL;
2339 break;
2340
2341 case FILE_OPEN_IF:
2342 /*
2343 * If file exists open. If file doesn't exist create.
2344 */
2345 ret = O_CREAT;
2346 break;
2347 }
2348 return ret;
2349 }
2350
2351 static int calculate_open_access_flags(uint32_t access_mask,
2352 int oplock_request,
2353 uint32_t private_flags)
2354 {
2355 bool need_write, need_read;
2356
2357 /*
2358 * Note that we ignore the append flag as append does not
2359 * mean the same thing under DOS and Unix.
2360 */
2361
2362 need_write = (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA));
2363 if (!need_write) {
2364 return O_RDONLY;
2365 }
2366
2367 /* DENY_DOS opens are always underlying read-write on the
2368 file handle, no matter what the requested access mask
2369 says. */
2370
2371 need_read =
2372 ((private_flags & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) ||
2373 access_mask & (FILE_READ_ATTRIBUTES|FILE_READ_DATA|
2374 FILE_READ_EA|FILE_EXECUTE));
2375
2376 if (!need_read) {
2377 return O_WRONLY;
2378 }
2379 return O_RDWR;
2380 }
2381
2382 /****************************************************************************
2383 Open a file with a share mode. Passed in an already created files_struct *.
2384 ****************************************************************************/
2385
2386 static NTSTATUS open_file_ntcreate(connection_struct *conn,
2387 struct smb_request *req,
2388 uint32 access_mask, /* access bits (FILE_READ_DATA etc.) */
2389 uint32 share_access, /* share constants (FILE_SHARE_READ etc) */
2390 uint32 create_disposition, /* FILE_OPEN_IF etc. */
2391 uint32 create_options, /* options such as delete on close. */
2392 uint32 new_dos_attributes, /* attributes used for new file. */
2393 int oplock_request, /* internal Samba oplock codes. */
2394 struct smb2_lease *lease,
2395 /* Information (FILE_EXISTS etc.) */
2396 uint32_t private_flags, /* Samba specific flags. */
2397 int *pinfo,
2398 files_struct *fsp)
2399 {
2400 struct smb_filename *smb_fname = fsp->fsp_name;
2401 int flags=0;
2402 int flags2=0;
2403 bool file_existed = VALID_STAT(smb_fname->st);
2404 bool def_acl = False;
2405 bool posix_open = False;
2406 bool new_file_created = False;
2407 bool first_open_attempt = true;
2408 NTSTATUS fsp_open = NT_STATUS_ACCESS_DENIED;
2409 mode_t new_unx_mode = (mode_t)0;
2410 mode_t unx_mode = (mode_t)0;
2411 int info;
2412 uint32 existing_dos_attributes = 0;
2413 struct timeval request_time = timeval_zero();
2414 struct share_mode_lock *lck = NULL;
2415 uint32 open_access_mask = access_mask;
2416 NTSTATUS status;
2417 char *parent_dir;
2418 SMB_STRUCT_STAT saved_stat = smb_fname->st;
2419 struct timespec old_write_time;
2420 struct file_id id;
2421
2422 if (conn->printer) {
2423 /*
2424 * Printers are handled completely differently.
2425 * Most of the passed parameters are ignored.
2426 */
2427
2428 if (pinfo) {
2429 *pinfo = FILE_WAS_CREATED;
2430 }
2431
2432 DEBUG(10, ("open_file_ntcreate: printer open fname=%s\n",
2433 smb_fname_str_dbg(smb_fname)));
2434
2435 if (!req) {
2436 DEBUG(0,("open_file_ntcreate: printer open without "
2437 "an SMB request!\n"));
2438 return NT_STATUS_INTERNAL_ERROR;
2439 }
2440
2441 return print_spool_open(fsp, smb_fname->base_name,
2442 req->vuid);
2443 }
2444
2445 if (!parent_dirname(talloc_tos(), smb_fname->base_name, &parent_dir,
2446 NULL)) {
2447 return NT_STATUS_NO_MEMORY;
2448 }
2449
2450 if (new_dos_attributes & FILE_FLAG_POSIX_SEMANTICS) {
2451 posix_open = True;
2452 unx_mode = (mode_t)(new_dos_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
2453 new_dos_attributes = 0;
2454 } else {
2455 /* Windows allows a new file to be created and
2456 silently removes a FILE_ATTRIBUTE_DIRECTORY
2457 sent by the client. Do the same. */
2458
2459 new_dos_attributes &= ~FILE_ATTRIBUTE_DIRECTORY;
2460
2461 /* We add FILE_ATTRIBUTE_ARCHIVE to this as this mode is only used if the file is
2462 * created new. */
2463 unx_mode = unix_mode(conn, new_dos_attributes | FILE_ATTRIBUTE_ARCHIVE,
2464 smb_fname, parent_dir);
2465 }
2466
2467 DEBUG(10, ("open_file_ntcreate: fname=%s, dos_attrs=0x%x "
2468 "access_mask=0x%x share_access=0x%x "
2469 "create_disposition = 0x%x create_options=0x%x "
2470 "unix mode=0%o oplock_request=%d private_flags = 0x%x\n",
2471 smb_fname_str_dbg(smb_fname), new_dos_attributes,
2472 access_mask, share_access, create_disposition,
2473 create_options, (unsigned int)unx_mode, oplock_request,
2474 (unsigned int)private_flags));
2475
2476 if (req == NULL) {
2477 /* Ensure req == NULL means INTERNAL_OPEN_ONLY */
2478 SMB_ASSERT(((oplock_request & INTERNAL_OPEN_ONLY) != 0));
2479 } else {
2480 /* And req != NULL means no INTERNAL_OPEN_ONLY */
2481 SMB_ASSERT(((oplock_request & INTERNAL_OPEN_ONLY) == 0));
2482 }
2483
2484 /*
2485 * Only non-internal opens can be deferred at all
2486 */
2487
2488 if (req) {
2489 struct deferred_open_record *open_rec;
2490 if (get_deferred_open_message_state(req,
2491 &request_time,
2492 &open_rec)) {
2493 /* Remember the absolute time of the original
2494 request with this mid. We'll use it later to
2495 see if this has timed out. */
2496
2497 /* If it was an async create retry, the file
2498 didn't exist. */
2499
2500 if (is_deferred_open_async(open_rec)) {
2501 SET_STAT_INVALID(smb_fname->st);
2502 file_existed = false;
2503 }
2504
2505 /* Ensure we don't reprocess this message. */
2506 remove_deferred_open_message_smb(req->xconn, req->mid);
2507
2508 first_open_attempt = false;
2509 }
2510 }
2511
2512 if (!posix_open) {
2513 new_dos_attributes &= SAMBA_ATTRIBUTES_MASK;
2514 if (file_existed) {
2515 existing_dos_attributes = dos_mode(conn, smb_fname);
2516 }
2517 }
2518
2519 /* ignore any oplock requests if oplocks are disabled */
2520 if (!lp_oplocks(SNUM(conn)) ||
2521 IS_VETO_OPLOCK_PATH(conn, smb_fname->base_name)) {
2522 /* Mask off everything except the private Samba bits. */
2523 oplock_request &= SAMBA_PRIVATE_OPLOCK_MASK;
2524 }
2525
2526 /* this is for OS/2 long file names - say we don't support them */
2527 if (!lp_posix_pathnames() && strstr(smb_fname->base_name,".+,;=[].")) {
2528 /* OS/2 Workplace shell fix may be main code stream in a later
2529 * release. */
2530 DEBUG(5,("open_file_ntcreate: OS/2 long filenames are not "
2531 "supported.\n"));
2532 if (use_nt_status()) {
2533 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
2534 }
2535 return NT_STATUS_DOS(ERRDOS, ERRcannotopen);
2536 }
2537
2538 switch( create_disposition ) {
2539 case FILE_OPEN:
2540 /* If file exists open. If file doesn't exist error. */
2541 if (!file_existed) {
2542 DEBUG(5,("open_file_ntcreate: FILE_OPEN "
2543 "requested for file %s and file "
2544 "doesn't exist.\n",
2545 smb_fname_str_dbg(smb_fname)));
2546 errno = ENOENT;
2547 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
2548 }
2549 break;
2550
2551 case FILE_OVERWRITE:
2552 /* If file exists overwrite. If file doesn't exist
2553 * error. */
2554 if (!file_existed) {
2555 DEBUG(5,("open_file_ntcreate: FILE_OVERWRITE "
2556 "requested for file %s and file "
2557 "doesn't exist.\n",
2558 smb_fname_str_dbg(smb_fname) ));
2559 errno = ENOENT;
2560 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
2561 }
2562 break;
2563
2564 case FILE_CREATE:
2565 /* If file exists error. If file doesn't exist
2566 * create. */
2567 if (file_existed) {
2568 DEBUG(5,("open_file_ntcreate: FILE_CREATE "
2569 "requested for file %s and file "
2570 "already exists.\n",
2571 smb_fname_str_dbg(smb_fname)));
2572 if (S_ISDIR(smb_fname->st.st_ex_mode)) {
2573 errno = EISDIR;
2574 } else {
2575 errno = EEXIST;
2576 }
2577 return map_nt_error_from_unix(errno);
2578 }
2579 break;
2580
2581 case FILE_SUPERSEDE:
2582 case FILE_OVERWRITE_IF:
2583 case FILE_OPEN_IF:
2584 break;
2585 default:
2586 return NT_STATUS_INVALID_PARAMETER;
2587 }
2588
2589 flags2 = disposition_to_open_flags(create_disposition);
2590
2591 /* We only care about matching attributes on file exists and
2592 * overwrite. */
2593
2594 if (!posix_open && file_existed &&
2595 ((create_disposition == FILE_OVERWRITE) ||
2596 (create_disposition == FILE_OVERWRITE_IF))) {
2597 if (!open_match_attributes(conn, existing_dos_attributes,
2598 new_dos_attributes,
2599 smb_fname->st.st_ex_mode,
2600 unx_mode, &new_unx_mode)) {
2601 DEBUG(5,("open_file_ntcreate: attributes missmatch "
2602 "for file %s (%x %x) (0%o, 0%o)\n",
2603 smb_fname_str_dbg(smb_fname),
2604 existing_dos_attributes,
2605 new_dos_attributes,
2606 (unsigned int)smb_fname->st.st_ex_mode,
2607 (unsigned int)unx_mode ));
2608 errno = EACCES;
2609 return NT_STATUS_ACCESS_DENIED;
2610 }
2611 }
2612
2613 status = smbd_calculate_access_mask(conn, smb_fname,
2614 false,
2615 access_mask,
2616 &access_mask);
2617 if (!NT_STATUS_IS_OK(status)) {
2618 DEBUG(10, ("open_file_ntcreate: smbd_calculate_access_mask "
2619 "on file %s returned %s\n",
2620 smb_fname_str_dbg(smb_fname), nt_errstr(status)));
2621 return status;
2622 }
2623
2624 open_access_mask = access_mask;
2625
2626 if (flags2 & O_TRUNC) {
2627 open_access_mask |= FILE_WRITE_DATA; /* This will cause oplock breaks. */
2628 }
2629
2630 DEBUG(10, ("open_file_ntcreate: fname=%s, after mapping "
2631 "access_mask=0x%x\n", smb_fname_str_dbg(smb_fname),
2632 access_mask));
2633
2634 /*
2635 * Note that we ignore the append flag as append does not
2636 * mean the same thing under DOS and Unix.
2637 */
2638
2639 flags = calculate_open_access_flags(access_mask, oplock_request,
2640 private_flags);
2641
2642 /*
2643 * Currently we only look at FILE_WRITE_THROUGH for create options.
2644 */
2645
2646 #if defined(O_SYNC)
2647 if ((create_options & FILE_WRITE_THROUGH) && lp_strict_sync(SNUM(conn))) {
2648 flags2 |= O_SYNC;
2649 }
2650 #endif /* O_SYNC */
2651
2652 if (posix_open && (access_mask & FILE_APPEND_DATA)) {
2653 flags2 |= O_APPEND;
2654 }
2655
2656 if (!posix_open && !CAN_WRITE(conn)) {
2657 /*
2658 * We should really return a permission denied error if either
2659 * O_CREAT or O_TRUNC are set, but for compatibility with
2660 * older versions of Samba we just AND them out.
2661 */
2662 flags2 &= ~(O_CREAT|O_TRUNC);
2663 }
2664
2665 if (first_open_attempt && lp_kernel_oplocks(SNUM(conn))) {
2666 /*
2667 * With kernel oplocks the open breaking an oplock
2668 * blocks until the oplock holder has given up the
2669 * oplock or closed the file. We prevent this by first
2670 * trying to open the file with O_NONBLOCK (see "man
2671 * fcntl" on Linux). For the second try, triggered by
2672 * an oplock break response, we do not need this
2673 * anymore.
2674 *
2675 * This is true under the assumption that only Samba
2676 * requests kernel oplocks. Once someone else like
2677 * NFSv4 starts to use that API, we will have to
2678 * modify this by communicating with the NFSv4 server.
2679 */
2680 flags2 |= O_NONBLOCK;
2681 }
2682
2683 /*
2684 * Ensure we can't write on a read-only share or file.
2685 */
2686
2687 if (flags != O_RDONLY && file_existed &&
2688 (!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_attributes))) {
2689 DEBUG(5,("open_file_ntcreate: write access requested for "
2690 "file %s on read only %s\n",
2691 smb_fname_str_dbg(smb_fname),
2692 !CAN_WRITE(conn) ? "share" : "file" ));
2693 errno = EACCES;
2694 return NT_STATUS_ACCESS_DENIED;
2695 }
2696
2697 fsp->file_id = vfs_file_id_from_sbuf(conn, &smb_fname->st);
2698 fsp->share_access = share_access;
2699 fsp->fh->private_options = private_flags;
2700 fsp->access_mask = open_access_mask; /* We change this to the
2701 * requested access_mask after
2702 * the open is done. */
2703 fsp->posix_open = posix_open;
2704
2705 if (timeval_is_zero(&request_time)) {
2706 request_time = fsp->open_time;
2707 }
2708
2709 /*
2710 * Ensure we pay attention to default ACLs on directories if required.
2711 */
2712
2713 if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
2714 (def_acl = directory_has_default_acl(conn, parent_dir))) {
2715 unx_mode = (0777 & lp_create_mask(SNUM(conn)));
2716 }
2717
2718 DEBUG(4,("calling open_file with flags=0x%X flags2=0x%X mode=0%o, "
2719 "access_mask = 0x%x, open_access_mask = 0x%x\n",
2720 (unsigned int)flags, (unsigned int)flags2,
2721 (unsigned int)unx_mode, (unsigned int)access_mask,
2722 (unsigned int)open_access_mask));
2723
2724 fsp_open = open_file(fsp, conn, req, parent_dir,
2725 flags|flags2, unx_mode, access_mask,
2726 open_access_mask, &new_file_created);
2727
2728 if (NT_STATUS_EQUAL(fsp_open, NT_STATUS_NETWORK_BUSY)) {
2729 struct deferred_open_record state;
2730
2731 /*
2732 * EWOULDBLOCK/EAGAIN maps to NETWORK_BUSY.
2733 */
2734 if (file_existed && S_ISFIFO(fsp->fsp_name->st.st_ex_mode)) {
2735 DEBUG(10, ("FIFO busy\n"));
2736 return NT_STATUS_NETWORK_BUSY;
2737 }
2738 if (req == NULL) {
2739 DEBUG(10, ("Internal open busy\n"));
2740 return NT_STATUS_NETWORK_BUSY;
2741 }
2742
2743 /*
2744 * From here on we assume this is an oplock break triggered
2745 */
2746
2747 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
2748 if (lck == NULL) {
2749 state.delayed_for_oplocks = false;
2750 state.async_open = false;
2751 state.id = fsp->file_id;
2752 defer_open(NULL, request_time, timeval_set(0, 0),
2753 req, &state);
2754 DEBUG(10, ("No share mode lock found after "
2755 "EWOULDBLOCK, retrying sync\n"));
2756 return NT_STATUS_SHARING_VIOLATION;
2757 }
2758
2759 if (!validate_oplock_types(lck)) {
2760 smb_panic("validate_oplock_types failed");
2761 }
2762
2763 if (delay_for_oplock(fsp, 0, lease, lck, false,
2764 create_disposition, first_open_attempt)) {
2765 schedule_defer_open(lck, fsp->file_id, request_time,
2766 req);
2767 TALLOC_FREE(lck);
2768 DEBUG(10, ("Sent oplock break request to kernel "
2769 "oplock holder\n"));
2770 return NT_STATUS_SHARING_VIOLATION;
2771 }
2772
2773 /*
2774 * No oplock from Samba around. Immediately retry with
2775 * a blocking open.
2776 */
2777 state.delayed_for_oplocks = false;
2778 state.async_open = false;
2779 state.id = fsp->file_id;
2780 defer_open(lck, request_time, timeval_set(0, 0), req, &state);
2781 TALLOC_FREE(lck);
2782 DEBUG(10, ("No Samba oplock around after EWOULDBLOCK. "
2783 "Retrying sync\n"));
2784 return NT_STATUS_SHARING_VIOLATION;
2785 }
2786
2787 if (!NT_STATUS_IS_OK(fsp_open)) {
2788 if (NT_STATUS_EQUAL(fsp_open, NT_STATUS_RETRY)) {
2789 schedule_async_open(request_time, req);
2790 }
2791 return fsp_open;
2792 }
2793
2794 if (new_file_created) {
2795 /*
2796 * As we atomically create using O_CREAT|O_EXCL,
2797 * then if new_file_created is true, then
2798 * file_existed *MUST* have been false (even
2799 * if the file was previously detected as being
2800 * there).
2801 */
2802 file_existed = false;
2803 }
2804
2805 if (file_existed && !check_same_dev_ino(&saved_stat, &smb_fname->st)) {
2806 /*
2807 * The file did exist, but some other (local or NFS)
2808 * process either renamed/unlinked and re-created the
2809 * file with different dev/ino after we walked the path,
2810 * but before we did the open. We could retry the
2811 * open but it's a rare enough case it's easier to
2812 * just fail the open to prevent creating any problems
2813 * in the open file db having the wrong dev/ino key.
2814 */
2815 fd_close(fsp);
2816 DEBUG(1,("open_file_ntcreate: file %s - dev/ino mismatch. "
2817 "Old (dev=0x%llu, ino =0x%llu). "
2818 "New (dev=0x%llu, ino=0x%llu). Failing open "
2819 " with NT_STATUS_ACCESS_DENIED.\n",
2820 smb_fname_str_dbg(smb_fname),
2821 (unsigned long long)saved_stat.st_ex_dev,
2822 (unsigned long long)saved_stat.st_ex_ino,
2823 (unsigned long long)smb_fname->st.st_ex_dev,
2824 (unsigned long long)smb_fname->st.st_ex_ino));
2825 return NT_STATUS_ACCESS_DENIED;
2826 }
2827
2828 old_write_time = smb_fname->st.st_ex_mtime;
2829
2830 /*
2831 * Deal with the race condition where two smbd's detect the
2832 * file doesn't exist and do the create at the same time. One
2833 * of them will win and set a share mode, the other (ie. this
2834 * one) should check if the requested share mode for this
2835 * create is allowed.
2836 */
2837
2838 /*
2839 * Now the file exists and fsp is successfully opened,
2840 * fsp->dev and fsp->inode are valid and should replace the
2841 * dev=0,inode=0 from a non existent file. Spotted by
2842 * Nadav Danieli <nadavd@exanet.com>. JRA.
2843 */
2844
2845 id = fsp->file_id;
2846
2847 lck = get_share_mode_lock(talloc_tos(), id,
2848 conn->connectpath,
2849 smb_fname, &old_write_time);
2850
2851 if (lck == NULL) {
2852 DEBUG(0, ("open_file_ntcreate: Could not get share "
2853 "mode lock for %s\n",
2854 smb_fname_str_dbg(smb_fname)));
2855 fd_close(fsp);
2856 return NT_STATUS_SHARING_VIOLATION;
2857 }
2858
2859 /* Get the types we need to examine. */
2860 if (!validate_oplock_types(lck)) {
2861 smb_panic("validate_oplock_types failed");
2862 }
2863
2864 if (has_delete_on_close(lck, fsp->name_hash)) {
2865 TALLOC_FREE(lck);
2866 fd_close(fsp);
2867 return NT_STATUS_DELETE_PENDING;
2868 }
2869
2870 status = open_mode_check(conn, lck,
2871 access_mask, share_access);
2872
2873 if (NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION) ||
2874 (lck->data->num_share_modes > 0)) {
2875 /*
2876 * This comes from ancient times out of open_mode_check. I
2877 * have no clue whether this is still necessary. I can't think
2878 * of a case where this would actually matter further down in
2879 * this function. I leave it here for further investigation
2880 * :-)
2881 */
2882 file_existed = true;
2883 }
2884
2885 if ((req != NULL) &&
2886 delay_for_oplock(
2887 fsp, oplock_request, lease, lck,
2888 NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION),
2889 create_disposition, first_open_attempt)) {
2890 schedule_defer_open(lck, fsp->file_id, request_time, req);
2891 TALLOC_FREE(lck);
2892 fd_close(fsp);
2893 return NT_STATUS_SHARING_VIOLATION;
2894 }
2895
2896 if (!NT_STATUS_IS_OK(status)) {
2897 uint32 can_access_mask;
2898 bool can_access = True;
2899
2900 SMB_ASSERT(NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION));
2901
2902 /* Check if this can be done with the deny_dos and fcb
2903 * calls. */
2904 if (private_flags &
2905 (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS|
2906 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
2907 if (req == NULL) {
2908 DEBUG(0, ("DOS open without an SMB "
2909 "request!\n"));
2910 TALLOC_FREE(lck);
2911 fd_close(fsp);
2912 return NT_STATUS_INTERNAL_ERROR;
2913 }
2914
2915 /* Use the client requested access mask here,
2916 * not the one we open with. */
2917 status = fcb_or_dos_open(req,
2918 conn,
2919 fsp,
2920 smb_fname,
2921 id,
2922 req->smbpid,
2923 req->vuid,
2924 access_mask,
2925 share_access,
2926 create_options);
2927
2928 if (NT_STATUS_IS_OK(status)) {
2929 TALLOC_FREE(lck);
2930 if (pinfo) {
2931 *pinfo = FILE_WAS_OPENED;
2932 }
2933 return NT_STATUS_OK;
2934 }
2935 }
2936
2937 /*
2938 * This next line is a subtlety we need for
2939 * MS-Access. If a file open will fail due to share
2940 * permissions and also for security (access) reasons,
2941 * we need to return the access failed error, not the
2942 * share error. We can't open the file due to kernel
2943 * oplock deadlock (it's possible we failed above on
2944 * the open_mode_check()) so use a userspace check.
2945 */
2946
2947 if (flags & O_RDWR) {
2948 can_access_mask = FILE_READ_DATA|FILE_WRITE_DATA;
2949 } else if (flags & O_WRONLY) {
2950 can_access_mask = FILE_WRITE_DATA;
2951 } else {
2952 can_access_mask = FILE_READ_DATA;
2953 }
2954
2955 if (((can_access_mask & FILE_WRITE_DATA) &&
2956 !CAN_WRITE(conn)) ||
2957 !NT_STATUS_IS_OK(smbd_check_access_rights(conn,
2958 smb_fname,
2959 false,
2960 can_access_mask))) {
2961 can_access = False;
2962 }
2963
2964 /*
2965 * If we're returning a share violation, ensure we
2966 * cope with the braindead 1 second delay (SMB1 only).
2967 */
2968
2969 if (!(oplock_request & INTERNAL_OPEN_ONLY) &&
2970 !conn->sconn->using_smb2 &&
2971 lp_defer_sharing_violations()) {
2972 struct timeval timeout;
2973 struct deferred_open_record state;
2974 int timeout_usecs;
2975
2976 /* this is a hack to speed up torture tests
2977 in 'make test' */
2978 timeout_usecs = lp_parm_int(SNUM(conn),
2979 "smbd","sharedelay",
2980 SHARING_VIOLATION_USEC_WAIT);
2981
2982 /* This is a relative time, added to the absolute
2983 request_time value to get the absolute timeout time.
2984 Note that if this is the second or greater time we enter
2985 this codepath for this particular request mid then
2986 request_time is left as the absolute time of the *first*
2987 time this request mid was processed. This is what allows
2988 the request to eventually time out. */
2989
2990 timeout = timeval_set(0, timeout_usecs);
2991
2992 /* Nothing actually uses state.delayed_for_oplocks
2993 but it's handy to differentiate in debug messages
2994 between a 30 second delay due to oplock break, and
2995 a 1 second delay for share mode conflicts. */
2996
2997 state.delayed_for_oplocks = False;
2998 state.async_open = false;
2999 state.id = id;
3000
3001 if ((req != NULL)
3002 && !request_timed_out(request_time,
3003 timeout)) {
3004 defer_open(lck, request_time, timeout,
3005 req, &state);
3006 }
3007 }
3008
3009 TALLOC_FREE(lck);
3010 fd_close(fsp);
3011 if (can_access) {
3012 /*
3013 * We have detected a sharing violation here
3014 * so return the correct error code
3015 */
3016 status = NT_STATUS_SHARING_VIOLATION;
3017 } else {
3018 status = NT_STATUS_ACCESS_DENIED;
3019 }
3020 return status;
3021 }
3022
3023 /* Should we atomically (to the client at least) truncate ? */
3024 if ((!new_file_created) &&
3025 (flags2 & O_TRUNC) &&
3026 (!S_ISFIFO(fsp->fsp_name->st.st_ex_mode))) {
3027 int ret;
3028
3029 ret = vfs_set_filelen(fsp, 0);
3030 if (ret != 0) {
3031 status = map_nt_error_from_unix(errno);
3032 TALLOC_FREE(lck);
3033 fd_close(fsp);
3034 return status;
3035 }
3036 }
3037
3038 /*
3039 * We have the share entry *locked*.....
3040 */
3041
3042 /* Delete streams if create_disposition requires it */
3043 if (!new_file_created && clear_ads(create_disposition) &&
3044 !is_ntfs_stream_smb_fname(smb_fname)) {
3045 status = delete_all_streams(conn, smb_fname->base_name);
3046 if (!NT_STATUS_IS_OK(status)) {
3047 TALLOC_FREE(lck);
3048 fd_close(fsp);
3049 return status;
3050 }
3051 }
3052
3053 /* note that we ignore failure for the following. It is
3054 basically a hack for NFS, and NFS will never set one of
3055 these only read them. Nobody but Samba can ever set a deny
3056 mode and we have already checked our more authoritative
3057 locking database for permission to set this deny mode. If
3058 the kernel refuses the operations then the kernel is wrong.
3059 note that GPFS supports it as well - jmcd */
3060
3061 if (fsp->fh->fd != -1 && lp_kernel_share_modes(SNUM(conn))) {
3062 int ret_flock;
3063 ret_flock = SMB_VFS_KERNEL_FLOCK(fsp, share_access, access_mask);
3064 if(ret_flock == -1 ){
3065
3066 TALLOC_FREE(lck);
3067 fd_close(fsp);
3068
3069 return NT_STATUS_SHARING_VIOLATION;
3070 }
3071 }
3072
3073 /*
3074 * At this point onwards, we can guarantee that the share entry
3075 * is locked, whether we created the file or not, and that the
3076 * deny mode is compatible with all current opens.
3077 */
3078
3079 /*
3080 * According to Samba4, SEC_FILE_READ_ATTRIBUTE is always granted,
3081 * but we don't have to store this - just ignore it on access check.
3082 */
3083 if (conn->sconn->using_smb2) {
3084 /*
3085 * SMB2 doesn't return it (according to Microsoft tests).
3086 * Test Case: TestSuite_ScenarioNo009GrantedAccessTestS0
3087 * File created with access = 0x7 (Read, Write, Delete)
3088 * Query Info on file returns 0x87 (Read, Write, Delete, Read Attributes)
3089 */
3090 fsp->access_mask = access_mask;
3091 } else {
3092 /* But SMB1 does. */
3093 fsp->access_mask = access_mask | FILE_READ_ATTRIBUTES;
3094 }
3095
3096 if (file_existed) {
3097 /*
3098 * stat opens on existing files don't get oplocks or leases.
3099 *
3100 * Note that we check for stat open on the *open_access_mask*,
3101 * i.e. the access mask we actually used to do the open,
3102 * not the one the client asked for (which is in
3103 * fsp->access_mask). This is due to the fact that
3104 * FILE_OVERWRITE and FILE_OVERWRITE_IF add in O_TRUNC,
3105 * which adds FILE_WRITE_DATA to open_access_mask.
3106 */
3107 if (is_stat_open(open_access_mask)) {
3108 if (lease) {
3109 lease->lease_state = SMB2_LEASE_NONE;
3110 } else {
3111 oplock_request = NO_OPLOCK;
3112 }
3113 }
3114 }
3115
3116 if (new_file_created) {
3117 info = FILE_WAS_CREATED;
3118 } else {
3119 if (flags2 & O_TRUNC) {
3120 info = FILE_WAS_OVERWRITTEN;
3121 } else {
3122 info = FILE_WAS_OPENED;
3123 }
3124 }
3125
3126 if (pinfo) {
3127 *pinfo = info;
3128 }
3129
3130 /*
3131 * Setup the oplock info in both the shared memory and
3132 * file structs.
3133 */
3134 status = grant_fsp_oplock_type(req, fsp, lck, oplock_request, lease);
3135 if (!NT_STATUS_IS_OK(status)) {
3136 TALLOC_FREE(lck);
3137 fd_close(fsp);
3138 return status;
3139 }
3140
3141 /* Handle strange delete on close create semantics. */
3142 if (create_options & FILE_DELETE_ON_CLOSE) {
3143
3144 status = can_set_delete_on_close(fsp, new_dos_attributes);
3145
3146 if (!NT_STATUS_IS_OK(status)) {
3147 /* Remember to delete the mode we just added. */
3148 del_share_mode(lck, fsp);
3149 TALLOC_FREE(lck);
3150 fd_close(fsp);
3151 return status;
3152 }
3153 /* Note that here we set the *inital* delete on close flag,
3154 not the regular one. The magic gets handled in close. */
3155 fsp->initial_delete_on_close = True;
3156 }
3157
3158 if (info != FILE_WAS_OPENED) {
3159 /* Files should be initially set as archive */
3160 if (lp_map_archive(SNUM(conn)) ||
3161 lp_store_dos_attributes(SNUM(conn))) {
3162 if (!posix_open) {
3163 if (file_set_dosmode(conn, smb_fname,
3164 new_dos_attributes | FILE_ATTRIBUTE_ARCHIVE,
3165 parent_dir, true) == 0) {
3166 unx_mode = smb_fname->st.st_ex_mode;
3167 }
3168 }
3169 }
3170 }
3171
3172 /* Determine sparse flag. */
3173 if (posix_open) {
3174 /* POSIX opens are sparse by default. */
3175 fsp->is_sparse = true;
3176 } else {
3177 fsp->is_sparse = (file_existed &&
3178 (existing_dos_attributes & FILE_ATTRIBUTE_SPARSE));
3179 }
3180
3181 /*
3182 * Take care of inherited ACLs on created files - if default ACL not
3183 * selected.
3184 */
3185
3186 if (!posix_open && new_file_created && !def_acl) {
3187
3188 int saved_errno = errno; /* We might get ENOSYS in the next
3189 * call.. */
3190
3191 if (SMB_VFS_FCHMOD_ACL(fsp, unx_mode) == -1 &&
3192 errno == ENOSYS) {
3193 errno = saved_errno; /* Ignore ENOSYS */
3194 }
3195
3196 } else if (new_unx_mode) {
3197
3198 int ret = -1;
3199
3200 /* Attributes need changing. File already existed. */
3201
3202 {
3203 int saved_errno = errno; /* We might get ENOSYS in the
3204 * next call.. */
3205 ret = SMB_VFS_FCHMOD_ACL(fsp, new_unx_mode);
3206
3207 if (ret == -1 && errno == ENOSYS) {
3208 errno = saved_errno; /* Ignore ENOSYS */
3209 } else {
3210 DEBUG(5, ("open_file_ntcreate: reset "
3211 "attributes of file %s to 0%o\n",
3212 smb_fname_str_dbg(smb_fname),
3213 (unsigned int)new_unx_mode));
3214 ret = 0; /* Don't do the fchmod below. */
3215 }
3216 }
3217
3218 if ((ret == -1) &&
3219 (SMB_VFS_FCHMOD(fsp, new_unx_mode) == -1))
3220 DEBUG(5, ("open_file_ntcreate: failed to reset "
3221 "attributes of file %s to 0%o\n",
3222 smb_fname_str_dbg(smb_fname),
3223 (unsigned int)new_unx_mode));
3224 }
3225
3226 {
3227 /*
3228 * Deal with other opens having a modified write time.
3229 */
3230 struct timespec write_time = get_share_mode_write_time(lck);
3231
3232 if (!null_timespec(write_time)) {
3233 update_stat_ex_mtime(&fsp->fsp_name->st, write_time);
3234 }
3235 }
3236
3237 TALLOC_FREE(lck);
3238
3239 return NT_STATUS_OK;
3240 }
3241
3242 static NTSTATUS mkdir_internal(connection_struct *conn,
3243 struct smb_filename *smb_dname,
3244 uint32 file_attributes)
3245 {
3246 mode_t mode;
3247 char *parent_dir = NULL;
3248 NTSTATUS status;
3249 bool posix_open = false;
3250 bool need_re_stat = false;
3251 uint32_t access_mask = SEC_DIR_ADD_SUBDIR;
3252
3253 if (!CAN_WRITE(conn) || (access_mask & ~(conn->share_access))) {
3254 DEBUG(5,("mkdir_internal: failing share access "
3255 "%s\n", lp_servicename(talloc_tos(), SNUM(conn))));
3256 return NT_STATUS_ACCESS_DENIED;
3257 }
3258
3259 if (!parent_dirname(talloc_tos(), smb_dname->base_name, &parent_dir,
3260 NULL)) {
3261 return NT_STATUS_NO_MEMORY;
3262 }
3263
3264 if (file_attributes & FILE_FLAG_POSIX_SEMANTICS) {
3265 posix_open = true;
3266 mode = (mode_t)(file_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
3267 } else {
3268 mode = unix_mode(conn, FILE_ATTRIBUTE_DIRECTORY, smb_dname, parent_dir);
3269 }
3270
3271 status = check_parent_access(conn,
3272 smb_dname,
3273 access_mask);
3274 if(!NT_STATUS_IS_OK(status)) {
3275 DEBUG(5,("mkdir_internal: check_parent_access "
3276 "on directory %s for path %s returned %s\n",
3277 parent_dir,
3278 smb_dname->base_name,
3279 nt_errstr(status) ));
3280 return status;
3281 }
3282
3283 if (SMB_VFS_MKDIR(conn, smb_dname->base_name, mode) != 0) {
3284 return map_nt_error_from_unix(errno);
3285 }
3286
3287 /* Ensure we're checking for a symlink here.... */
3288 /* We don't want to get caught by a symlink racer. */
3289
3290 if (SMB_VFS_LSTAT(conn, smb_dname) == -1) {
3291 DEBUG(2, ("Could not stat directory '%s' just created: %s\n",
3292 smb_fname_str_dbg(smb_dname), strerror(errno)));
3293 return map_nt_error_from_unix(errno);
3294 }
3295
3296 if (!S_ISDIR(smb_dname->st.st_ex_mode)) {
3297 DEBUG(0, ("Directory '%s' just created is not a directory !\n",
3298 smb_fname_str_dbg(smb_dname)));
3299 return NT_STATUS_NOT_A_DIRECTORY;
3300 }
3301
3302 if (lp_store_dos_attributes(SNUM(conn))) {
3303 if (!posix_open) {
3304 file_set_dosmode(conn, smb_dname,
3305 file_attributes | FILE_ATTRIBUTE_DIRECTORY,
3306 parent_dir, true);
3307 }
3308 }
3309
3310 if (lp_inherit_permissions(SNUM(conn))) {
3311 inherit_access_posix_acl(conn, parent_dir,
3312 smb_dname->base_name, mode);
3313 need_re_stat = true;
3314 }
3315
3316 if (!posix_open) {
3317 /*
3318 * Check if high bits should have been set,
3319 * then (if bits are missing): add them.
3320 * Consider bits automagically set by UNIX, i.e. SGID bit from parent
3321 * dir.
3322 */
3323 if ((mode & ~(S_IRWXU|S_IRWXG|S_IRWXO)) &&
3324 (mode & ~smb_dname->st.st_ex_mode)) {
3325 SMB_VFS_CHMOD(conn, smb_dname->base_name,
3326 (smb_dname->st.st_ex_mode |
3327 (mode & ~smb_dname->st.st_ex_mode)));
3328 need_re_stat = true;
3329 }
3330 }
3331
3332 /* Change the owner if required. */
3333 if (lp_inherit_owner(SNUM(conn))) {
3334 change_dir_owner_to_parent(conn, parent_dir,
3335 smb_dname->base_name,
3336 &smb_dname->st);
3337 need_re_stat = true;
3338 }
3339
3340 if (need_re_stat) {
3341 if (SMB_VFS_LSTAT(conn, smb_dname) == -1) {
3342 DEBUG(2, ("Could not stat directory '%s' just created: %s\n",
3343 smb_fname_str_dbg(smb_dname), strerror(errno)));
3344 return map_nt_error_from_unix(errno);
3345 }
3346 }
3347
3348 notify_fname(conn, NOTIFY_ACTION_ADDED, FILE_NOTIFY_CHANGE_DIR_NAME,
3349 smb_dname->base_name);
3350
3351 return NT_STATUS_OK;
3352 }
3353
3354 /****************************************************************************
3355 Open a directory from an NT SMB call.
3356 ****************************************************************************/
3357
3358 static NTSTATUS open_directory(connection_struct *conn,
3359 struct smb_request *req,
3360 struct smb_filename *smb_dname,
3361 uint32 access_mask,
3362 uint32 share_access,
3363 uint32 create_disposition,
3364 uint32 create_options,
3365 uint32 file_attributes,
3366 int *pinfo,
3367 files_struct **result)
3368 {
3369 files_struct *fsp = NULL;
3370 bool dir_existed = VALID_STAT(smb_dname->st) ? True : False;
3371 struct share_mode_lock *lck = NULL;
3372 NTSTATUS status;
3373 struct timespec mtimespec;
3374 int info = 0;
3375 bool ok;
3376
3377 if (is_ntfs_stream_smb_fname(smb_dname)) {
3378 DEBUG(2, ("open_directory: %s is a stream name!\n",
3379 smb_fname_str_dbg(smb_dname)));
3380 return NT_STATUS_NOT_A_DIRECTORY;
3381 }
3382
3383 if (!(file_attributes & FILE_FLAG_POSIX_SEMANTICS)) {
3384 /* Ensure we have a directory attribute. */
3385 file_attributes |= FILE_ATTRIBUTE_DIRECTORY;
3386 }
3387
3388 DEBUG(5,("open_directory: opening directory %s, access_mask = 0x%x, "
3389 "share_access = 0x%x create_options = 0x%x, "
3390 "create_disposition = 0x%x, file_attributes = 0x%x\n",
3391 smb_fname_str_dbg(smb_dname),
3392 (unsigned int)access_mask,
3393 (unsigned int)share_access,
3394 (unsigned int)create_options,
3395 (unsigned int)create_disposition,
3396 (unsigned int)file_attributes));
3397
3398 status = smbd_calculate_access_mask(conn, smb_dname, false,
3399 access_mask, &access_mask);
3400 if (!NT_STATUS_IS_OK(status)) {
3401 DEBUG(10, ("open_directory: smbd_calculate_access_mask "
3402 "on file %s returned %s\n",
3403 smb_fname_str_dbg(smb_dname),
3404 nt_errstr(status)));
3405 return status;
3406 }
3407
3408 if ((access_mask & SEC_FLAG_SYSTEM_SECURITY) &&
3409 !security_token_has_privilege(get_current_nttok(conn),
3410 SEC_PRIV_SECURITY)) {
3411 DEBUG(10, ("open_directory: open on %s "
3412 "failed - SEC_FLAG_SYSTEM_SECURITY denied.\n",
3413 smb_fname_str_dbg(smb_dname)));
3414 return NT_STATUS_PRIVILEGE_NOT_HELD;
3415 }
3416
3417 switch( create_disposition ) {
3418 case FILE_OPEN:
3419
3420 if (!dir_existed) {
3421 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
3422 }
3423
3424 info = FILE_WAS_OPENED;
3425 break;
3426
3427 case FILE_CREATE:
3428
3429 /* If directory exists error. If directory doesn't
3430 * exist create. */
3431
3432 if (dir_existed) {
3433 status = NT_STATUS_OBJECT_NAME_COLLISION;
3434 DEBUG(2, ("open_directory: unable to create "
3435 "%s. Error was %s\n",
3436 smb_fname_str_dbg(smb_dname),
3437 nt_errstr(status)));
3438 return status;
3439 }
3440
3441 status = mkdir_internal(conn, smb_dname,
3442 file_attributes);
3443
3444 if (!NT_STATUS_IS_OK(status)) {
3445 DEBUG(2, ("open_directory: unable to create "
3446 "%s. Error was %s\n",
3447 smb_fname_str_dbg(smb_dname),
3448 nt_errstr(status)));
3449 return status;
3450 }
3451
3452 info = FILE_WAS_CREATED;
3453 break;
3454
3455 case FILE_OPEN_IF:
3456 /*
3457 * If directory exists open. If directory doesn't
3458 * exist create.
3459 */
3460
3461 if (dir_existed) {
3462 status = NT_STATUS_OK;
3463 info = FILE_WAS_OPENED;
3464 } else {
3465 status = mkdir_internal(conn, smb_dname,
3466 file_attributes);
3467
3468 if (NT_STATUS_IS_OK(status)) {
3469 info = FILE_WAS_CREATED;
3470 } else {
3471 /* Cope with create race. */
3472 if (!NT_STATUS_EQUAL(status,
3473 NT_STATUS_OBJECT_NAME_COLLISION)) {
3474 DEBUG(2, ("open_directory: unable to create "
3475 "%s. Error was %s\n",
3476 smb_fname_str_dbg(smb_dname),
3477 nt_errstr(status)));
3478 return status;
3479 }
3480 info = FILE_WAS_OPENED;
3481 }
3482 }
3483
3484 break;
3485
3486 case FILE_SUPERSEDE:
3487 case FILE_OVERWRITE:
3488 case FILE_OVERWRITE_IF:
3489 default:
3490 DEBUG(5,("open_directory: invalid create_disposition "
3491 "0x%x for directory %s\n",
3492 (unsigned int)create_disposition,
3493 smb_fname_str_dbg(smb_dname)));
3494 return NT_STATUS_INVALID_PARAMETER;
3495 }
3496
3497 if(!S_ISDIR(smb_dname->st.st_ex_mode)) {
3498 DEBUG(5,("open_directory: %s is not a directory !\n",
3499 smb_fname_str_dbg(smb_dname)));
3500 return NT_STATUS_NOT_A_DIRECTORY;
3501 }
3502
3503 if (info == FILE_WAS_OPENED) {
3504 status = smbd_check_access_rights(conn,
3505 smb_dname,
3506 false,
3507 access_mask);
3508 if (!NT_STATUS_IS_OK(status)) {
3509 DEBUG(10, ("open_directory: smbd_check_access_rights on "
3510 "file %s failed with %s\n",
3511 smb_fname_str_dbg(smb_dname),
3512 nt_errstr(status)));
3513 return status;
3514 }
3515 }
3516
3517 status = file_new(req, conn, &fsp);
3518 if(!NT_STATUS_IS_OK(status)) {
3519 return status;
3520 }
3521
3522 /*
3523 * Setup the files_struct for it.
3524 */
3525
3526 fsp->file_id = vfs_file_id_from_sbuf(conn, &smb_dname->st);
3527 fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
3528 fsp->file_pid = req ? req->smbpid : 0;
3529 fsp->can_lock = False;
3530 fsp->can_read = False;
3531 fsp->can_write = False;
3532
3533 fsp->share_access = share_access;
3534 fsp->fh->private_options = 0;
3535 /*
3536 * According to Samba4, SEC_FILE_READ_ATTRIBUTE is always granted,
3537 */
3538 fsp->access_mask = access_mask | FILE_READ_ATTRIBUTES;
3539 fsp->print_file = NULL;
3540 fsp->modified = False;
3541 fsp->oplock_type = NO_OPLOCK;
3542 fsp->sent_oplock_break = NO_BREAK_SENT;
3543 fsp->is_directory = True;
3544 fsp->posix_open = (file_attributes & FILE_FLAG_POSIX_SEMANTICS) ? True : False;
3545 status = fsp_set_smb_fname(fsp, smb_dname);
3546 if (!NT_STATUS_IS_OK(status)) {
3547 file_free(req, fsp);
3548 return status;
3549 }
3550
3551 /* Don't store old timestamps for directory
3552 handles in the internal database. We don't
3553 update them in there if new objects
3554 are creaded in the directory. Currently
3555 we only update timestamps on file writes.
3556 See bug #9870.
3557 */
3558 ZERO_STRUCT(mtimespec);
3559
3560 if (access_mask & (FILE_LIST_DIRECTORY|
3561 FILE_ADD_FILE|
3562 FILE_ADD_SUBDIRECTORY|
3563 FILE_TRAVERSE|
3564 DELETE_ACCESS|
3565 FILE_DELETE_CHILD)) {
3566 #ifdef O_DIRECTORY
3567 status = fd_open(conn, fsp, O_RDONLY|O_DIRECTORY, 0);
3568 #else
3569 /* POSIX allows us to open a directory with O_RDONLY. */
3570 status = fd_open(conn, fsp, O_RDONLY, 0);
3571 #endif
3572 if (!NT_STATUS_IS_OK(status)) {
3573 DEBUG(5, ("open_directory: Could not open fd for "
3574 "%s (%s)\n",
3575 smb_fname_str_dbg(smb_dname),
3576 nt_errstr(status)));
3577 file_free(req, fsp);
3578 return status;
3579 }
3580 } else {
3581 fsp->fh->fd = -1;
3582 DEBUG(10, ("Not opening Directory %s\n",
3583 smb_fname_str_dbg(smb_dname)));
3584 }
3585
3586 status = vfs_stat_fsp(fsp);
3587 if (!NT_STATUS_IS_OK(status)) {
3588 fd_close(fsp);
3589 file_free(req, fsp);
3590 return status;
3591 }
3592
3593 /* Ensure there was no race condition. */
3594 if (!check_same_stat(&smb_dname->st, &fsp->fsp_name->st)) {
3595 DEBUG(5,("open_directory: stat struct differs for "
3596 "directory %s.\n",
3597 smb_fname_str_dbg(smb_dname)));
3598 fd_close(fsp);
3599 file_free(req, fsp);
3600 return NT_STATUS_ACCESS_DENIED;
3601 }
3602
3603 lck = get_share_mode_lock(talloc_tos(), fsp->file_id,
3604 conn->connectpath, smb_dname,
3605 &mtimespec);
3606
3607 if (lck == NULL) {
3608 DEBUG(0, ("open_directory: Could not get share mode lock for "
3609 "%s\n", smb_fname_str_dbg(smb_dname)));
3610 fd_close(fsp);
3611 file_free(req, fsp);
3612 return NT_STATUS_SHARING_VIOLATION;
3613 }
3614
3615 if (has_delete_on_close(lck, fsp->name_hash)) {
3616 TALLOC_FREE(lck);
3617 fd_close(fsp);
3618 file_free(req, fsp);
3619 return NT_STATUS_DELETE_PENDING;
3620 }
3621
3622 status = open_mode_check(conn, lck,
3623 access_mask, share_access);
3624
3625 if (!NT_STATUS_IS_OK(status)) {
3626 TALLOC_FREE(lck);
3627 fd_close(fsp);
3628 file_free(req, fsp);
3629 return status;
3630 }
3631
3632 ok = set_share_mode(lck, fsp, get_current_uid(conn),
3633 req ? req->mid : 0, NO_OPLOCK,
3634 UINT32_MAX);
3635 if (!ok) {
3636 TALLOC_FREE(lck);
3637 fd_close(fsp);
3638 file_free(req, fsp);
3639 return NT_STATUS_NO_MEMORY;
3640 }
3641
3642 /* For directories the delete on close bit at open time seems
3643 always to be honored on close... See test 19 in Samba4 BASE-DELETE. */
3644 if (create_options & FILE_DELETE_ON_CLOSE) {
3645 status = can_set_delete_on_close(fsp, 0);
3646 if (!NT_STATUS_IS_OK(status) && !NT_STATUS_EQUAL(status, NT_STATUS_DIRECTORY_NOT_EMPTY)) {
3647 del_share_mode(lck, fsp);
3648 TALLOC_FREE(lck);
3649 fd_close(fsp);
3650 file_free(req, fsp);
3651 return status;
3652 }
3653
3654 if (NT_STATUS_IS_OK(status)) {
3655 /* Note that here we set the *inital* delete on close flag,
3656 not the regular one. The magic gets handled in close. */
3657 fsp->initial_delete_on_close = True;
3658 }
3659 }
3660
3661 {
3662 /*
3663 * Deal with other opens having a modified write time. Is this
3664 * possible for directories?
3665 */
3666 struct timespec write_time = get_share_mode_write_time(lck);
3667
3668 if (!null_timespec(write_time)) {
3669 update_stat_ex_mtime(&fsp->fsp_name->st, write_time);
3670 }
3671 }
3672
3673 TALLOC_FREE(lck);
3674
3675 if (pinfo) {
3676 *pinfo = info;
3677 }
3678
3679 *result = fsp;
3680 return NT_STATUS_OK;
3681 }
3682
3683 NTSTATUS create_directory(connection_struct *conn, struct smb_request *req,
3684 struct smb_filename *smb_dname)
3685 {
3686 NTSTATUS status;
3687 files_struct *fsp;
3688
3689 status = SMB_VFS_CREATE_FILE(
3690 conn, /* conn */
3691 req, /* req */
3692 0, /* root_dir_fid */
3693 smb_dname, /* fname */
3694 FILE_READ_ATTRIBUTES, /* access_mask */
3695 FILE_SHARE_NONE, /* share_access */
3696 FILE_CREATE, /* create_disposition*/
3697 FILE_DIRECTORY_FILE, /* create_options */
3698 FILE_ATTRIBUTE_DIRECTORY, /* file_attributes */
3699 0, /* oplock_request */
3700 NULL, /* lease */
3701 0, /* allocation_size */
3702 0, /* private_flags */
3703 NULL, /* sd */
3704 NULL, /* ea_list */
3705 &fsp, /* result */
3706 NULL, /* pinfo */
3707 NULL, NULL); /* create context */
3708
3709 if (NT_STATUS_IS_OK(status)) {
3710 close_file(req, fsp, NORMAL_CLOSE);
3711 }
3712
3713 return status;
3714 }
3715
3716 /****************************************************************************
3717 Receive notification that one of our open files has been renamed by another
3718 smbd process.
3719 ****************************************************************************/
3720
3721 void msg_file_was_renamed(struct messaging_context *msg,
3722 void *private_data,
3723 uint32_t msg_type,
3724 struct server_id server_id,
3725 DATA_BLOB *data)
3726 {
3727 files_struct *fsp;
3728 char *frm = (char *)data->data;
3729 struct file_id id;
3730 const char *sharepath;
3731 const char *base_name;
3732 const char *stream_name;
3733 struct smb_filename *smb_fname = NULL;
3734 size_t sp_len, bn_len;
3735 NTSTATUS status;
3736 struct smbd_server_connection *sconn =
3737 talloc_get_type_abort(private_data,
3738 struct smbd_server_connection);
3739
3740 if (data->data == NULL
3741 || data->length < MSG_FILE_RENAMED_MIN_SIZE + 2) {
3742 DEBUG(0, ("msg_file_was_renamed: Got invalid msg len %d\n",
3743 (int)data->length));
3744 return;
3745 }
3746
3747 /* Unpack the message. */
3748 pull_file_id_24(frm, &id);
3749 sharepath = &frm[24];
3750 sp_len = strlen(sharepath);
3751 base_name = sharepath + sp_len + 1;
3752 bn_len = strlen(base_name);
3753 stream_name = sharepath + sp_len + 1 + bn_len + 1;
3754
3755 /* stream_name must always be NULL if there is no stream. */
3756 if (stream_name[0] == '\0') {
3757 stream_name = NULL;
3758 }
3759
3760 smb_fname = synthetic_smb_fname(talloc_tos(), base_name,
3761 stream_name, NULL);
3762 if (smb_fname == NULL) {
3763 return;
3764 }
3765
3766 DEBUG(10,("msg_file_was_renamed: Got rename message for sharepath %s, new name %s, "
3767 "file_id %s\n",
3768 sharepath, smb_fname_str_dbg(smb_fname),
3769 file_id_string_tos(&id)));
3770
3771 for(fsp = file_find_di_first(sconn, id); fsp;
3772 fsp = file_find_di_next(fsp)) {
3773 if (memcmp(fsp->conn->connectpath, sharepath, sp_len) == 0) {
3774
3775 DEBUG(10,("msg_file_was_renamed: renaming file %s from %s -> %s\n",
3776 fsp_fnum_dbg(fsp), fsp_str_dbg(fsp),
3777 smb_fname_str_dbg(smb_fname)));
3778 status = fsp_set_smb_fname(fsp, smb_fname);
3779 if (!NT_STATUS_IS_OK(status)) {
3780 goto out;
3781 }
3782 } else {
3783 /* TODO. JRA. */
3784 /* Now we have the complete path we can work out if this is
3785 actually within this share and adjust newname accordingly. */
3786 DEBUG(10,("msg_file_was_renamed: share mismatch (sharepath %s "
3787 "not sharepath %s) "
3788 "%s from %s -> %s\n",
3789 fsp->conn->connectpath,
3790 sharepath,
3791 fsp_fnum_dbg(fsp),
3792 fsp_str_dbg(fsp),
3793 smb_fname_str_dbg(smb_fname)));
3794 }
3795 }
3796 out:
3797 TALLOC_FREE(smb_fname);
3798 return;
3799 }
3800
3801 /*
3802 * If a main file is opened for delete, all streams need to be checked for
3803 * !FILE_SHARE_DELETE. Do this by opening with DELETE_ACCESS.
3804 * If that works, delete them all by setting the delete on close and close.
3805 */
3806
3807 NTSTATUS open_streams_for_delete(connection_struct *conn,
3808 const char *fname)
3809 {
3810 struct stream_struct *stream_info = NULL;
3811 files_struct **streams = NULL;
3812 int i;
3813 unsigned int num_streams = 0;
3814 TALLOC_CTX *frame = talloc_stackframe();
3815 NTSTATUS status;
3816
3817 status = vfs_streaminfo(conn, NULL, fname, talloc_tos(),
3818 &num_streams, &stream_info);
3819
3820 if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)
3821 || NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
3822 DEBUG(10, ("no streams around\n"));
3823 TALLOC_FREE(frame);
3824 return NT_STATUS_OK;
3825 }
3826
3827 if (!NT_STATUS_IS_OK(status)) {
3828 DEBUG(10, ("vfs_streaminfo failed: %s\n",
3829 nt_errstr(status)));
3830 goto fail;
3831 }
3832
3833 DEBUG(10, ("open_streams_for_delete found %d streams\n",
3834 num_streams));
3835
3836 if (num_streams == 0) {
3837 TALLOC_FREE(frame);
3838 return NT_STATUS_OK;
3839 }
3840
3841 streams = talloc_array(talloc_tos(), files_struct *, num_streams);
3842 if (streams == NULL) {
3843 DEBUG(0, ("talloc failed\n"));
3844 status = NT_STATUS_NO_MEMORY;
3845 goto fail;
3846 }
3847
3848 for (i=0; i<num_streams; i++) {
3849 struct smb_filename *smb_fname;
3850
3851 if (strequal(stream_info[i].name, "::$DATA")) {
3852 streams[i] = NULL;
3853 continue;
3854 }
3855
3856 smb_fname = synthetic_smb_fname(
3857 talloc_tos(), fname, stream_info[i].name, NULL);
3858 if (smb_fname == NULL) {
3859 status = NT_STATUS_NO_MEMORY;
3860 goto fail;
3861 }
3862
3863 if (SMB_VFS_STAT(conn, smb_fname) == -1) {
3864 DEBUG(10, ("Unable to stat stream: %s\n",
3865 smb_fname_str_dbg(smb_fname)));
3866 }
3867
3868 status = SMB_VFS_CREATE_FILE(
3869 conn, /* conn */
3870 NULL, /* req */
3871 0, /* root_dir_fid */
3872 smb_fname, /* fname */
3873 DELETE_ACCESS, /* access_mask */
3874 (FILE_SHARE_READ | /* share_access */
3875 FILE_SHARE_WRITE | FILE_SHARE_DELETE),
3876 FILE_OPEN, /* create_disposition*/
3877 0, /* create_options */
3878 FILE_ATTRIBUTE_NORMAL, /* file_attributes */
3879 0, /* oplock_request */
3880 NULL, /* lease */
3881 0, /* allocation_size */
3882 NTCREATEX_OPTIONS_PRIVATE_STREAM_DELETE, /* private_flags */
3883 NULL, /* sd */
3884 NULL, /* ea_list */
3885 &streams[i], /* result */
3886 NULL, /* pinfo */
3887 NULL, NULL); /* create context */
3888
3889 if (!NT_STATUS_IS_OK(status)) {
3890 DEBUG(10, ("Could not open stream %s: %s\n",
3891 smb_fname_str_dbg(smb_fname),
3892 nt_errstr(status)));
3893
3894 TALLOC_FREE(smb_fname);
3895 break;
3896 }
3897 TALLOC_FREE(smb_fname);
3898 }
3899
3900 /*
3901 * don't touch the variable "status" beyond this point :-)
3902 */
3903
3904 for (i -= 1 ; i >= 0; i--) {
3905 if (streams[i] == NULL) {
3906 continue;
3907 }
3908
3909 DEBUG(10, ("Closing stream # %d, %s\n", i,
3910 fsp_str_dbg(streams[i])));
3911 close_file(NULL, streams[i], NORMAL_CLOSE);
3912 }
3913
3914 fail:
3915 TALLOC_FREE(frame);
3916 return status;
3917 }
3918
3919 /*********************************************************************
3920 Create a default ACL by inheriting from the parent. If no inheritance
3921 from the parent available, don't set anything. This will leave the actual
3922 permissions the new file or directory already got from the filesystem
3923 as the NT ACL when read.
3924 *********************************************************************/
3925
3926 static NTSTATUS inherit_new_acl(files_struct *fsp)
3927 {
3928 TALLOC_CTX *frame = talloc_stackframe();
3929 char *parent_name = NULL;
3930 struct security_descriptor *parent_desc = NULL;
3931 NTSTATUS status = NT_STATUS_OK;
3932 struct security_descriptor *psd = NULL;
3933 const struct dom_sid *owner_sid = NULL;
3934 const struct dom_sid *group_sid = NULL;
3935 uint32_t security_info_sent = (SECINFO_OWNER | SECINFO_GROUP | SECINFO_DACL);
3936 struct security_token *token = fsp->conn->session_info->security_token;
3937 bool inherit_owner = lp_inherit_owner(SNUM(fsp->conn));
3938 bool inheritable_components = false;
3939 bool try_builtin_administrators = false;
3940 const struct dom_sid *BA_U_sid = NULL;
3941 const struct dom_sid *BA_G_sid = NULL;
3942 bool try_system = false;
3943 const struct dom_sid *SY_U_sid = NULL;
3944 const struct dom_sid *SY_G_sid = NULL;
3945 size_t size = 0;
3946
3947 if (!parent_dirname(frame, fsp->fsp_name->base_name, &parent_name, NULL)) {
3948 TALLOC_FREE(frame);
3949 return NT_STATUS_NO_MEMORY;
3950 }
3951
3952 status = SMB_VFS_GET_NT_ACL(fsp->conn,
3953 parent_name,
3954 (SECINFO_OWNER | SECINFO_GROUP | SECINFO_DACL),
3955 frame,
3956 &parent_desc);
3957 if (!NT_STATUS_IS_OK(status)) {
3958 TALLOC_FREE(frame);
3959 return status;
3960 }
3961
3962 inheritable_components = sd_has_inheritable_components(parent_desc,
3963 fsp->is_directory);
3964
3965 if (!inheritable_components && !inherit_owner) {
3966 TALLOC_FREE(frame);
3967 /* Nothing to inherit and not setting owner. */
3968 return NT_STATUS_OK;
3969 }
3970
3971 /* Create an inherited descriptor from the parent. */
3972
3973 if (DEBUGLEVEL >= 10) {
3974 DEBUG(10,("inherit_new_acl: parent acl for %s is:\n",
3975 fsp_str_dbg(fsp) ));
3976 NDR_PRINT_DEBUG(security_descriptor, parent_desc);
3977 }
3978
3979 /* Inherit from parent descriptor if "inherit owner" set. */
3980 if (inherit_owner) {
3981 owner_sid = parent_desc->owner_sid;
3982 group_sid = parent_desc->group_sid;
3983 }
3984
3985 if (owner_sid == NULL) {
3986 if (security_token_has_builtin_administrators(token)) {
3987 try_builtin_administrators = true;
3988 } else if (security_token_is_system(token)) {
3989 try_builtin_administrators = true;
3990 try_system = true;
3991 }
3992 }
3993
3994 if (group_sid == NULL &&
3995 token->num_sids == PRIMARY_GROUP_SID_INDEX)
3996 {
3997 if (security_token_is_system(token)) {
3998 try_builtin_administrators = true;
3999 try_system = true;
4000 }
4001 }
4002
4003 if (try_builtin_administrators) {
4004 struct unixid ids;
4005 bool ok;
4006
4007 ZERO_STRUCT(ids);
4008 ok = sids_to_unixids(&global_sid_Builtin_Administrators, 1, &ids);
4009 if (ok) {
4010 switch (ids.type) {
4011 case ID_TYPE_BOTH:
4012 BA_U_sid = &global_sid_Builtin_Administrators;
4013 BA_G_sid = &global_sid_Builtin_Administrators;
4014 break;
4015 case ID_TYPE_UID:
4016 BA_U_sid = &global_sid_Builtin_Administrators;
4017 break;
4018 case ID_TYPE_GID:
4019 BA_G_sid = &global_sid_Builtin_Administrators;
4020 break;
4021 default:
4022 break;
4023 }
4024 }
4025 }
4026
4027 if (try_system) {
4028 struct unixid ids;
4029 bool ok;
4030
4031 ZERO_STRUCT(ids);
4032 ok = sids_to_unixids(&global_sid_System, 1, &ids);
4033 if (ok) {
4034 switch (ids.type) {
4035 case ID_TYPE_BOTH:
4036 SY_U_sid = &global_sid_System;
4037 SY_G_sid = &global_sid_System;
4038 break;
4039 case ID_TYPE_UID:
4040 SY_U_sid = &global_sid_System;
4041 break;
4042 case ID_TYPE_GID:
4043 SY_G_sid = &global_sid_System;
4044 break;
4045 default:
4046 break;
4047 }
4048 }
4049 }
4050
4051 if (owner_sid == NULL) {
4052 owner_sid = BA_U_sid;
4053 }
4054
4055 if (owner_sid == NULL) {
4056 owner_sid = SY_U_sid;
4057 }
4058
4059 if (group_sid == NULL) {
4060 group_sid = SY_G_sid;
4061 }
4062
4063 if (try_system && group_sid == NULL) {
4064 group_sid = BA_G_sid;
4065 }
4066
4067 if (owner_sid == NULL) {
4068 owner_sid = &token->sids[PRIMARY_USER_SID_INDEX];
4069 }
4070 if (group_sid == NULL) {
4071 if (token->num_sids == PRIMARY_GROUP_SID_INDEX) {
4072 group_sid = &token->sids[PRIMARY_USER_SID_INDEX];
4073 } else {
4074 group_sid = &token->sids[PRIMARY_GROUP_SID_INDEX];
4075 }
4076 }
4077
4078 status = se_create_child_secdesc(frame,
4079 &psd,
4080 &size,
4081 parent_desc,
4082 owner_sid,
4083 group_sid,
4084 fsp->is_directory);
4085 if (!NT_STATUS_IS_OK(status)) {
4086 TALLOC_FREE(frame);
4087 return status;
4088 }
4089
4090 /* If inheritable_components == false,
4091 se_create_child_secdesc()
4092 creates a security desriptor with a NULL dacl
4093 entry, but with SEC_DESC_DACL_PRESENT. We need
4094 to remove that flag. */
4095
4096 if (!inheritable_components) {
4097 security_info_sent &= ~SECINFO_DACL;
4098 psd->type &= ~SEC_DESC_DACL_PRESENT;
4099 }
4100
4101 if (DEBUGLEVEL >= 10) {
4102 DEBUG(10,("inherit_new_acl: child acl for %s is:\n",
4103 fsp_str_dbg(fsp) ));
4104 NDR_PRINT_DEBUG(security_descriptor, psd);
4105 }
4106
4107 if (inherit_owner) {
4108 /* We need to be root to force this. */
4109 become_root();
4110 }
4111 status = SMB_VFS_FSET_NT_ACL(fsp,
4112 security_info_sent,
4113 psd);
4114 if (inherit_owner) {
4115 unbecome_root();
4116 }
4117 TALLOC_FREE(frame);
4118 return status;
4119 }
4120
4121 /*
4122 * If we already have a lease, it must match the new file id. [MS-SMB2]
4123 * 3.3.5.9.8 speaks about INVALID_PARAMETER if an already used lease key is
4124 * used for a different file name.
4125 */
4126
4127 struct lease_fname_match_state {
4128 /* Input parameters. */
4129 const struct smb_filename *fname;
4130 bool file_existed;
4131 struct file_id id;
4132 /* Return parameters. */
4133 uint32_t num_file_ids;
4134 struct file_id *ids;
4135 NTSTATUS match_status;
4136 };
4137
4138 static void lease_fname_match_parser(
4139 uint32_t num_file_ids,
4140 struct file_id *ids, const char *filename, const char *stream_name,
4141 void *private_data)
4142 {
4143 struct lease_fname_match_state *state =
4144 (struct lease_fname_match_state *)private_data;
4145
4146 if (!strequal(filename, state->fname->base_name) ||
4147 !strequal(stream_name, state->fname->stream_name))
4148 {
4149 /* Names don't match lease key. */
4150 state->match_status = NT_STATUS_INVALID_PARAMETER;
4151 return;
4152 }
4153
4154 if (state->file_existed &&
4155 num_file_ids == 1 &&
4156 file_id_equal(&ids[0],&state->id))
4157 {
4158 /* Common case - non-dynamic share. We're ok.. */
4159 state->match_status = NT_STATUS_OK;
4160 return;
4161 }
4162
4163 /*
4164 * More than one file id, or not equal, or new file
4165 * being created and there's already an existing lease
4166 * on this (client_guid, lease id) pair.
4167 * Don't allow leases.
4168 */
4169
4170 state->match_status = NT_STATUS_OPLOCK_NOT_GRANTED;
4171 state->num_file_ids = num_file_ids;
4172 state->ids = talloc_memdup(talloc_tos(),
4173 ids,
4174 num_file_ids * sizeof(struct file_id));
4175 if (state->ids == NULL) {
4176 state->match_status = NT_STATUS_NO_MEMORY;
4177 }
4178 }
4179
4180 static NTSTATUS lease_match(connection_struct *conn,
4181 struct smb_request *req,
4182 struct smb2_lease_key *lease_key,
4183 const struct smb_filename *fname,
4184 uint16_t *p_version,
4185 uint16_t *p_epoch)
4186 {
4187 struct smbd_server_connection *sconn = req->sconn;
4188 struct lease_fname_match_state state = {
4189 .fname = fname,
4190 .match_status = NT_STATUS_OK
4191 };
4192 uint32_t i;
4193 NTSTATUS status;
4194
4195 state.file_existed = VALID_STAT(fname->st);
4196 if (state.file_existed) {
4197 state.id = vfs_file_id_from_sbuf(conn, &fname->st);
4198 } else {
4199 memset(&state.id, '\0', sizeof(state.id));
4200 }
4201
4202 status = leases_db_parse(&sconn->client->connections->smb2.client.guid,
4203 lease_key, lease_fname_match_parser, &state);
4204 if (!NT_STATUS_IS_OK(status)) {
4205 /*
4206 * Not found or error means okay: We can make the lease pass
4207 */
4208 return NT_STATUS_OK;
4209 }
4210 if (!NT_STATUS_EQUAL(state.match_status, NT_STATUS_OPLOCK_NOT_GRANTED)) {
4211 /*
4212 * Anything but NT_STATUS_OPLOCK_NOT_GRANTED, let the caller
4213 * deal with it.
4214 */
4215 return state.match_status;
4216 }
4217
4218 /* We have to break all existing leases. */
4219 for (i = 0; i < state.num_file_ids; i++) {
4220 struct share_mode_lock *lck;
4221 struct share_mode_data *d;
4222 uint32_t j;
4223
4224 if (file_id_equal(&state.ids[i], &state.id)) {
4225 /* Don't need to break our own file. */
4226 continue;
4227 }
4228
4229 lck = get_existing_share_mode_lock(talloc_tos(), state.ids[i]);
4230 if (lck == NULL) {
4231 /* Race condition - file already closed. */
4232 continue;
4233 }
4234 d = lck->data;
4235 for (j=0; j<d->num_share_modes; j++) {
4236 struct share_mode_entry *e = &d->share_modes[j];
4237 uint32_t e_lease_type = get_lease_type(d, e);
4238 struct share_mode_lease *l = NULL;
4239
4240 if (share_mode_stale_pid(d, j)) {
4241 continue;
4242 }
4243
4244 if (e->op_type == LEASE_OPLOCK) {
4245 l = &lck->data->leases[e->lease_idx];
4246 if (!smb2_lease_key_equal(&l->lease_key,
4247 lease_key)) {
4248 continue;
4249 }
4250 *p_epoch = l->epoch;
4251 *p_version = l->lease_version;
4252 }
4253
4254 if (e_lease_type == SMB2_LEASE_NONE) {
4255 continue;
4256 }
4257
4258 send_break_message(conn->sconn->msg_ctx, e,
4259 SMB2_LEASE_NONE);
4260
4261 /*
4262 * Windows 7 and 8 lease clients
4263 * are broken in that they will not
4264 * respond to lease break requests
4265 * whilst waiting for an outstanding
4266 * open request on that lease handle
4267 * on the same TCP connection, due
4268 * to holding an internal inode lock.
4269 *
4270 * This means we can't reschedule
4271 * ourselves here, but must return
4272 * from the create.
4273 *
4274 * Work around:
4275 *
4276 * Send the breaks and then return
4277 * SMB2_LEASE_NONE in the lease handle
4278 * to cause them to acknowledge the
4279 * lease break. Consulatation with
4280 * Microsoft engineering confirmed
4281 * this approach is safe.
4282 */
4283
4284 }
4285 TALLOC_FREE(lck);
4286 }
4287 /*
4288 * Ensure we don't grant anything more so we
4289 * never upgrade.
4290 */
4291 return NT_STATUS_OPLOCK_NOT_GRANTED;
4292 }
4293
4294 /*
4295 * Wrapper around open_file_ntcreate and open_directory
4296 */
4297
4298 static NTSTATUS create_file_unixpath(connection_struct *conn,
4299 struct smb_request *req,
4300 struct smb_filename *smb_fname,
4301 uint32_t access_mask,
4302 uint32_t share_access,
4303 uint32_t create_disposition,
4304 uint32_t create_options,
4305 uint32_t file_attributes,
4306 uint32_t oplock_request,
4307 struct smb2_lease *lease,
4308 uint64_t allocation_size,
4309 uint32_t private_flags,
4310 struct security_descriptor *sd,
4311 struct ea_list *ea_list,
4312
4313 files_struct **result,
4314 int *pinfo)
4315 {
4316 int info = FILE_WAS_OPENED;
4317 files_struct *base_fsp = NULL;
4318 files_struct *fsp = NULL;
4319 NTSTATUS status;
4320
4321 DEBUG(10,("create_file_unixpath: access_mask = 0x%x "
4322 "file_attributes = 0x%x, share_access = 0x%x, "
4323 "create_disposition = 0x%x create_options = 0x%x "
4324 "oplock_request = 0x%x private_flags = 0x%x "
4325 "ea_list = 0x%p, sd = 0x%p, "
4326 "fname = %s\n",
4327 (unsigned int)access_mask,
4328 (unsigned int)file_attributes,
4329 (unsigned int)share_access,
4330 (unsigned int)create_disposition,
4331 (unsigned int)create_options,
4332 (unsigned int)oplock_request,
4333 (unsigned int)private_flags,
4334 ea_list, sd, smb_fname_str_dbg(smb_fname)));
4335
4336 if (create_options & FILE_OPEN_BY_FILE_ID) {
4337 status = NT_STATUS_NOT_SUPPORTED;
4338 goto fail;
4339 }
4340
4341 if (create_options & NTCREATEX_OPTIONS_INVALID_PARAM_MASK) {
4342 status = NT_STATUS_INVALID_PARAMETER;
4343 goto fail;
4344 }
4345
4346 if (req == NULL) {
4347 oplock_request |= INTERNAL_OPEN_ONLY;
4348 }
4349
4350 if (lease != NULL) {
4351 uint16_t epoch = lease->lease_epoch;
4352 uint16_t version = lease->lease_version;
4353 status = lease_match(conn,
4354 req,
4355 &lease->lease_key,
4356 smb_fname,
4357 &version,
4358 &epoch);
4359 if (NT_STATUS_EQUAL(status, NT_STATUS_OPLOCK_NOT_GRANTED)) {
4360 /* Dynamic share file. No leases and update epoch... */
4361 lease->lease_state = SMB2_LEASE_NONE;
4362 lease->lease_epoch = epoch;
4363 lease->lease_version = version;
4364 } else if (!NT_STATUS_IS_OK(status)) {
4365 goto fail;
4366 }
4367 }
4368
4369 if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
4370 && (access_mask & DELETE_ACCESS)
4371 && !is_ntfs_stream_smb_fname(smb_fname)) {
4372 /*
4373 * We can't open a file with DELETE access if any of the
4374 * streams is open without FILE_SHARE_DELETE
4375 */
4376 status = open_streams_for_delete(conn, smb_fname->base_name);
4377
4378 if (!NT_STATUS_IS_OK(status)) {
4379 goto fail;
4380 }
4381 }
4382
4383 if ((access_mask & SEC_FLAG_SYSTEM_SECURITY) &&
4384 !security_token_has_privilege(get_current_nttok(conn),
4385 SEC_PRIV_SECURITY)) {
4386 DEBUG(10, ("create_file_unixpath: open on %s "
4387 "failed - SEC_FLAG_SYSTEM_SECURITY denied.\n",
4388 smb_fname_str_dbg(smb_fname)));
4389 status = NT_STATUS_PRIVILEGE_NOT_HELD;
4390 goto fail;
4391 }
4392
4393 if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
4394 && is_ntfs_stream_smb_fname(smb_fname)
4395 && (!(private_flags & NTCREATEX_OPTIONS_PRIVATE_STREAM_DELETE))) {
4396 uint32 base_create_disposition;
4397 struct smb_filename *smb_fname_base = NULL;
4398
4399 if (create_options & FILE_DIRECTORY_FILE) {
4400 status = NT_STATUS_NOT_A_DIRECTORY;
4401 goto fail;
4402 }
4403
4404 switch (create_disposition) {
4405 case FILE_OPEN:
4406 base_create_disposition = FILE_OPEN;
4407 break;
4408 default:
4409 base_create_disposition = FILE_OPEN_IF;
4410 break;
4411 }
4412
4413 /* Create an smb_filename with stream_name == NULL. */
4414 smb_fname_base = synthetic_smb_fname(talloc_tos(),
4415 smb_fname->base_name,
4416 NULL, NULL);
4417 if (smb_fname_base == NULL) {
4418 status = NT_STATUS_NO_MEMORY;
4419 goto fail;
4420 }
4421
4422 if (SMB_VFS_STAT(conn, smb_fname_base) == -1) {
4423 DEBUG(10, ("Unable to stat stream: %s\n",
4424 smb_fname_str_dbg(smb_fname_base)));
4425 } else {
4426 /*
4427 * https://bugzilla.samba.org/show_bug.cgi?id=10229
4428 * We need to check if the requested access mask
4429 * could be used to open the underlying file (if
4430 * it existed), as we're passing in zero for the
4431 * access mask to the base filename.
4432 */
4433 status = check_base_file_access(conn,
4434 smb_fname_base,
4435 access_mask);
4436
4437 if (!NT_STATUS_IS_OK(status)) {
4438 DEBUG(10, ("Permission check "
4439 "for base %s failed: "
4440 "%s\n", smb_fname->base_name,
4441 nt_errstr(status)));
4442 goto fail;
4443 }
4444 }
4445
4446 /* Open the base file. */
4447 status = create_file_unixpath(conn, NULL, smb_fname_base, 0,
4448 FILE_SHARE_READ
4449 | FILE_SHARE_WRITE
4450 | FILE_SHARE_DELETE,
4451 base_create_disposition,
4452 0, 0, 0, NULL, 0, 0, NULL, NULL,
4453 &base_fsp, NULL);
4454 TALLOC_FREE(smb_fname_base);
4455
4456 if (!NT_STATUS_IS_OK(status)) {
4457 DEBUG(10, ("create_file_unixpath for base %s failed: "
4458 "%s\n", smb_fname->base_name,
4459 nt_errstr(status)));
4460 goto fail;
4461 }
4462 /* we don't need the low level fd */
4463 fd_close(base_fsp);
4464 }
4465
4466 /*
4467 * If it's a request for a directory open, deal with it separately.
4468 */
4469
4470 if (create_options & FILE_DIRECTORY_FILE) {
4471
4472 if (create_options & FILE_NON_DIRECTORY_FILE) {
4473 status = NT_STATUS_INVALID_PARAMETER;
4474 goto fail;
4475 }
4476
4477 /* Can't open a temp directory. IFS kit test. */
4478 if (!(file_attributes & FILE_FLAG_POSIX_SEMANTICS) &&
4479 (file_attributes & FILE_ATTRIBUTE_TEMPORARY)) {
4480 status = NT_STATUS_INVALID_PARAMETER;
4481 goto fail;
4482 }
4483
4484 /*
4485 * We will get a create directory here if the Win32
4486 * app specified a security descriptor in the
4487 * CreateDirectory() call.
4488 */
4489
4490 oplock_request = 0;
4491 status = open_directory(
4492 conn, req, smb_fname, access_mask, share_access,
4493 create_disposition, create_options, file_attributes,
4494 &info, &fsp);
4495 } else {
4496
4497 /*
4498 * Ordinary file case.
4499 */
4500
4501 status = file_new(req, conn, &fsp);
4502 if(!NT_STATUS_IS_OK(status)) {
4503 goto fail;
4504 }
4505
4506 status = fsp_set_smb_fname(fsp, smb_fname);
4507 if (!NT_STATUS_IS_OK(status)) {
4508 goto fail;
4509 }
4510
4511 if (base_fsp) {
4512 /*
4513 * We're opening the stream element of a
4514 * base_fsp we already opened. Set up the
4515 * base_fsp pointer.
4516 */
4517 fsp->base_fsp = base_fsp;
4518 }
4519
4520 if (allocation_size) {
4521 fsp->initial_allocation_size = smb_roundup(fsp->conn,
4522 allocation_size);
4523 }
4524
4525 status = open_file_ntcreate(conn,
4526 req,
4527 access_mask,
4528 share_access,
4529 create_disposition,
4530 create_options,
4531 file_attributes,
4532 oplock_request,
4533 lease,
4534 private_flags,
4535 &info,
4536 fsp);
4537
4538 if(!NT_STATUS_IS_OK(status)) {
4539 file_free(req, fsp);
4540 fsp = NULL;
4541 }
4542
4543 if (NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) {
4544
4545 /* A stream open never opens a directory */
4546
4547 if (base_fsp) {
4548 status = NT_STATUS_FILE_IS_A_DIRECTORY;
4549 goto fail;
4550 }
4551
4552 /*
4553 * Fail the open if it was explicitly a non-directory
4554 * file.
4555 */
4556
4557 if (create_options & FILE_NON_DIRECTORY_FILE) {
4558 status = NT_STATUS_FILE_IS_A_DIRECTORY;
4559 goto fail;
4560 }
4561
4562 oplock_request = 0;
4563 status = open_directory(
4564 conn, req, smb_fname, access_mask,
4565 share_access, create_disposition,
4566 create_options, file_attributes,
4567 &info, &fsp);
4568 }
4569 }
4570
4571 if (!NT_STATUS_IS_OK(status)) {
4572 goto fail;
4573 }
4574
4575 fsp->base_fsp = base_fsp;
4576
4577 if ((ea_list != NULL) &&
4578 ((info == FILE_WAS_CREATED) || (info == FILE_WAS_OVERWRITTEN))) {
4579 status = set_ea(conn, fsp, fsp->fsp_name, ea_list);
4580 if (!NT_STATUS_IS_OK(status)) {
4581 goto fail;
4582 }
4583 }
4584
4585 if (!fsp->is_directory && S_ISDIR(fsp->fsp_name->st.st_ex_mode)) {
4586 status = NT_STATUS_ACCESS_DENIED;
4587 goto fail;
4588 }
4589
4590 /* Save the requested allocation size. */
4591 if ((info == FILE_WAS_CREATED) || (info == FILE_WAS_OVERWRITTEN)) {
4592 if (allocation_size
4593 && (allocation_size > fsp->fsp_name->st.st_ex_size)) {
4594 fsp->initial_allocation_size = smb_roundup(
4595 fsp->conn, allocation_size);
4596 if (fsp->is_directory) {
4597 /* Can't set allocation size on a directory. */
4598 status = NT_STATUS_ACCESS_DENIED;
4599 goto fail;
4600 }
4601 if (vfs_allocate_file_space(
4602 fsp, fsp->initial_allocation_size) == -1) {
4603 status = NT_STATUS_DISK_FULL;
4604 goto fail;
4605 }
4606 } else {
4607 fsp->initial_allocation_size = smb_roundup(
4608 fsp->conn, (uint64_t)fsp->fsp_name->st.st_ex_size);
4609 }
4610 } else {
4611 fsp->initial_allocation_size = 0;
4612 }
4613
4614 if ((info == FILE_WAS_CREATED) && lp_nt_acl_support(SNUM(conn)) &&
4615 fsp->base_fsp == NULL) {
4616 if (sd != NULL) {
4617 /*
4618 * According to the MS documentation, the only time the security
4619 * descriptor is applied to the opened file is iff we *created* the
4620 * file; an existing file stays the same.
4621 *
4622 * Also, it seems (from observation) that you can open the file with
4623 * any access mask but you can still write the sd. We need to override
4624 * the granted access before we call set_sd
4625 * Patch for bug #2242 from Tom Lackemann <cessnatomny@yahoo.com>.
4626 */
4627
4628 uint32_t sec_info_sent;
4629 uint32_t saved_access_mask = fsp->access_mask;
4630
4631 sec_info_sent = get_sec_info(sd);
4632
4633 fsp->access_mask = FILE_GENERIC_ALL;
4634
4635 if (sec_info_sent & (SECINFO_OWNER|
4636 SECINFO_GROUP|
4637 SECINFO_DACL|
4638 SECINFO_SACL)) {
4639 status = set_sd(fsp, sd, sec_info_sent);
4640 }
4641
4642 fsp->access_mask = saved_access_mask;
4643
4644 if (!NT_STATUS_IS_OK(status)) {
4645 goto fail;
4646 }
4647 } else if (lp_inherit_acls(SNUM(conn))) {
4648 /* Inherit from parent. Errors here are not fatal. */
4649 status = inherit_new_acl(fsp);
4650 if (!NT_STATUS_IS_OK(status)) {
4651 DEBUG(10,("inherit_new_acl: failed for %s with %s\n",
4652 fsp_str_dbg(fsp),
4653 nt_errstr(status) ));
4654 }
4655 }
4656 }
4657
4658 if ((conn->fs_capabilities & FILE_FILE_COMPRESSION)
4659 && (create_options & FILE_NO_COMPRESSION)
4660 && (info == FILE_WAS_CREATED)) {
4661 status = SMB_VFS_SET_COMPRESSION(conn, fsp, fsp,
4662 COMPRESSION_FORMAT_NONE);
4663 if (!NT_STATUS_IS_OK(status)) {
4664 DEBUG(1, ("failed to disable compression: %s\n",
4665 nt_errstr(status)));
4666 }
4667 }
4668
4669 DEBUG(10, ("create_file_unixpath: info=%d\n", info));
4670
4671 *result = fsp;
4672 if (pinfo != NULL) {
4673 *pinfo = info;
4674 }
4675
4676 smb_fname->st = fsp->fsp_name->st;
4677
4678 return NT_STATUS_OK;
4679
4680 fail:
4681 DEBUG(10, ("create_file_unixpath: %s\n", nt_errstr(status)));
4682
4683 if (fsp != NULL) {
4684 if (base_fsp && fsp->base_fsp == base_fsp) {
4685 /*
4686 * The close_file below will close
4687 * fsp->base_fsp.
4688 */
4689 base_fsp = NULL;
4690 }
4691 close_file(req, fsp, ERROR_CLOSE);
4692 fsp = NULL;
4693 }
4694 if (base_fsp != NULL) {
4695 close_file(req, base_fsp, ERROR_CLOSE);
4696 base_fsp = NULL;
4697 }
4698 return status;
4699 }
4700
4701 /*
4702 * Calculate the full path name given a relative fid.
4703 */
4704 NTSTATUS get_relative_fid_filename(connection_struct *conn,
4705 struct smb_request *req,
4706 uint16_t root_dir_fid,
4707 const struct smb_filename *smb_fname,
4708 struct smb_filename **smb_fname_out)
4709 {
4710 files_struct *dir_fsp;
4711 char *parent_fname = NULL;
4712 char *new_base_name = NULL;
4713 NTSTATUS status;
4714
4715 if (root_dir_fid == 0 || !smb_fname) {
4716 status = NT_STATUS_INTERNAL_ERROR;
4717 goto out;
4718 }
4719
4720 dir_fsp = file_fsp(req, root_dir_fid);
4721
4722 if (dir_fsp == NULL) {
4723 status = NT_STATUS_INVALID_HANDLE;
4724 goto out;
4725 }
4726
4727 if (is_ntfs_stream_smb_fname(dir_fsp->fsp_name)) {
4728 status = NT_STATUS_INVALID_HANDLE;
4729 goto out;
4730 }
4731
4732 if (!dir_fsp->is_directory) {
4733
4734 /*
4735 * Check to see if this is a mac fork of some kind.
4736 */
4737
4738 if ((conn->fs_capabilities & FILE_NAMED_STREAMS) &&
4739 is_ntfs_stream_smb_fname(smb_fname)) {
4740 status = NT_STATUS_OBJECT_PATH_NOT_FOUND;
4741 goto out;
4742 }
4743
4744 /*
4745 we need to handle the case when we get a
4746 relative open relative to a file and the
4747 pathname is blank - this is a reopen!
4748 (hint from demyn plantenberg)
4749 */
4750
4751 status = NT_STATUS_INVALID_HANDLE;
4752 goto out;
4753 }
4754
4755 if (ISDOT(dir_fsp->fsp_name->base_name)) {
4756 /*
4757 * We're at the toplevel dir, the final file name
4758 * must not contain ./, as this is filtered out
4759 * normally by srvstr_get_path and unix_convert
4760 * explicitly rejects paths containing ./.
4761 */
4762 parent_fname = talloc_strdup(talloc_tos(), "");
4763 if (parent_fname == NULL) {
4764 status = NT_STATUS_NO_MEMORY;
4765 goto out;
4766 }
4767 } else {
4768 size_t dir_name_len = strlen(dir_fsp->fsp_name->base_name);
4769
4770 /*
4771 * Copy in the base directory name.
4772 */
4773
4774 parent_fname = talloc_array(talloc_tos(), char,
4775 dir_name_len+2);
4776 if (parent_fname == NULL) {
4777 status = NT_STATUS_NO_MEMORY;
4778 goto out;
4779 }
4780 memcpy(parent_fname, dir_fsp->fsp_name->base_name,
4781 dir_name_len+1);
4782
4783 /*
4784 * Ensure it ends in a '/'.
4785 * We used TALLOC_SIZE +2 to add space for the '/'.
4786 */
4787
4788 if(dir_name_len
4789 && (parent_fname[dir_name_len-1] != '\\')
4790 && (parent_fname[dir_name_len-1] != '/')) {
4791 parent_fname[dir_name_len] = '/';
4792 parent_fname[dir_name_len+1] = '\0';
4793 }
4794 }
4795
4796 new_base_name = talloc_asprintf(talloc_tos(), "%s%s", parent_fname,
4797 smb_fname->base_name);
4798 if (new_base_name == NULL) {
4799 status = NT_STATUS_NO_MEMORY;
4800 goto out;
4801 }
4802
4803 status = filename_convert(req,
4804 conn,
4805 req->flags2 & FLAGS2_DFS_PATHNAMES,
4806 new_base_name,
4807 0,
4808 NULL,
4809 smb_fname_out);
4810 if (!NT_STATUS_IS_OK(status)) {
4811 goto out;
4812 }
4813
4814 out:
4815 TALLOC_FREE(parent_fname);
4816 TALLOC_FREE(new_base_name);
4817 return status;
4818 }
4819
4820 NTSTATUS create_file_default(connection_struct *conn,
4821 struct smb_request *req,
4822 uint16_t root_dir_fid,
4823 struct smb_filename *smb_fname,
4824 uint32_t access_mask,
4825 uint32_t share_access,
4826 uint32_t create_disposition,
4827 uint32_t create_options,
4828 uint32_t file_attributes,
4829 uint32_t oplock_request,
4830 struct smb2_lease *lease,
4831 uint64_t allocation_size,
4832 uint32_t private_flags,
4833 struct security_descriptor *sd,
4834 struct ea_list *ea_list,
4835 files_struct **result,
4836 int *pinfo,
4837 const struct smb2_create_blobs *in_context_blobs,
4838 struct smb2_create_blobs *out_context_blobs)
4839 {
4840 int info = FILE_WAS_OPENED;
4841 files_struct *fsp = NULL;
4842 NTSTATUS status;
4843 bool stream_name = false;
4844
4845 DEBUG(10,("create_file: access_mask = 0x%x "
4846 "file_attributes = 0x%x, share_access = 0x%x, "
4847 "create_disposition = 0x%x create_options = 0x%x "
4848 "oplock_request = 0x%x "
4849 "private_flags = 0x%x "
4850 "root_dir_fid = 0x%x, ea_list = 0x%p, sd = 0x%p, "
4851 "fname = %s\n",
4852 (unsigned int)access_mask,
4853 (unsigned int)file_attributes,
4854 (unsigned int)share_access,
4855 (unsigned int)create_disposition,
4856 (unsigned int)create_options,
4857 (unsigned int)oplock_request,
4858 (unsigned int)private_flags,
4859 (unsigned int)root_dir_fid,
4860 ea_list, sd, smb_fname_str_dbg(smb_fname)));
4861
4862 /*
4863 * Calculate the filename from the root_dir_if if necessary.
4864 */
4865
4866 if (root_dir_fid != 0) {
4867 struct smb_filename *smb_fname_out = NULL;
4868 status = get_relative_fid_filename(conn, req, root_dir_fid,
4869 smb_fname, &smb_fname_out);
4870 if (!NT_STATUS_IS_OK(status)) {
4871 goto fail;
4872 }
4873 smb_fname = smb_fname_out;
4874 }
4875
4876 /*
4877 * Check to see if this is a mac fork of some kind.
4878 */
4879
4880 stream_name = is_ntfs_stream_smb_fname(smb_fname);
4881 if (stream_name) {
4882 enum FAKE_FILE_TYPE fake_file_type;
4883
4884 fake_file_type = is_fake_file(smb_fname);
4885
4886 if (fake_file_type != FAKE_FILE_TYPE_NONE) {
4887
4888 /*
4889 * Here we go! support for changing the disk quotas
4890 * --metze
4891 *
4892 * We need to fake up to open this MAGIC QUOTA file
4893 * and return a valid FID.
4894 *
4895 * w2k close this file directly after openening xp
4896 * also tries a QUERY_FILE_INFO on the file and then
4897 * close it
4898 */
4899 status = open_fake_file(req, conn, req->vuid,
4900 fake_file_type, smb_fname,
4901 access_mask, &fsp);
4902 if (!NT_STATUS_IS_OK(status)) {
4903 goto fail;
4904 }
4905
4906 ZERO_STRUCT(smb_fname->st);
4907 goto done;
4908 }
4909
4910 if (!(conn->fs_capabilities & FILE_NAMED_STREAMS)) {
4911 status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
4912 goto fail;
4913 }
4914 }
4915
4916 if (is_ntfs_default_stream_smb_fname(smb_fname)) {
4917 int ret;
4918 smb_fname->stream_name = NULL;
4919 /* We have to handle this error here. */
4920 if (create_options & FILE_DIRECTORY_FILE) {
4921 status = NT_STATUS_NOT_A_DIRECTORY;
4922 goto fail;
4923 }
4924 if (lp_posix_pathnames()) {
4925 ret = SMB_VFS_LSTAT(conn, smb_fname);
4926 } else {
4927 ret = SMB_VFS_STAT(conn, smb_fname);
4928 }
4929
4930 if (ret == 0 && VALID_STAT_OF_DIR(smb_fname->st)) {
4931 status = NT_STATUS_FILE_IS_A_DIRECTORY;
4932 goto fail;
4933 }
4934 }
4935
4936 status = create_file_unixpath(
4937 conn, req, smb_fname, access_mask, share_access,
4938 create_disposition, create_options, file_attributes,
4939 oplock_request, lease, allocation_size, private_flags,
4940 sd, ea_list,
4941 &fsp, &info);
4942
4943 if (!NT_STATUS_IS_OK(status)) {
4944 goto fail;
4945 }
4946
4947 done:
4948 DEBUG(10, ("create_file: info=%d\n", info));
4949
4950 *result = fsp;
4951 if (pinfo != NULL) {
4952 *pinfo = info;
4953 }
4954 return NT_STATUS_OK;
4955
4956 fail:
4957 DEBUG(10, ("create_file: %s\n", nt_errstr(status)));
4958
4959 if (fsp != NULL) {
4960 close_file(req, fsp, ERROR_CLOSE);
4961 fsp = NULL;
4962 }
4963 return status;
4964 }
Samba GIT mirror