?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove "store create time" code, cause create time to be stored
[Samba/gbeck.git] / source3 / modules / onefs_open.c
blobfd12fff58ca484d6adf1c66a0cf074827bf2276e
1 /*
2 * Unix SMB/CIFS implementation.
3 *
4 * This file began with some code from source3/smbd/open.c and has been
5 * modified it work with ifs_createfile.
6 *
7 * ifs_createfile is a CIFS-specific syscall for opening/files and
8 * directories. It adds support for:
9 * - Full in-kernel access checks using a windows access_mask
10 * - Cluster-coherent share mode locks
11 * - Cluster-coherent oplocks
12 * - Streams
13 * - Setting security descriptors at create time
14 * - Setting dos_attributes at create time
15 *
16 * Copyright (C) Andrew Tridgell 1992-1998
17 * Copyright (C) Jeremy Allison 2001-2004
18 * Copyright (C) Volker Lendecke 2005
19 * Copyright (C) Tim Prouty, 2008
20 *
21 * This program is free software; you can redistribute it and/or modify
22 * it under the terms of the GNU General Public License as published by
23 * the Free Software Foundation; either version 3 of the License, or
24 * (at your option) any later version.
25 *
26 * This program is distributed in the hope that it will be useful,
27 * but WITHOUT ANY WARRANTY; without even the implied warranty of
28 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29 * GNU General Public License for more details.
30 *
31 * You should have received a copy of the GNU General Public License
32 * along with this program; if not, see <http://www.gnu.org/licenses/>.
33 */
34
35 #include "includes.h"
36 #include "onefs.h"
37 #include "onefs_config.h"
38 #include "oplock_onefs.h"
39 #include "smbd/globals.h"
40
41 extern const struct generic_mapping file_generic_mapping;
42
43 struct onefs_fsp_data {
44 uint64_t oplock_callback_id;
45 };
46
47 static NTSTATUS onefs_create_file_unixpath(connection_struct *conn,
48 struct smb_request *req,
49 struct smb_filename *smb_fname,
50 uint32_t access_mask,
51 uint32_t share_access,
52 uint32_t create_disposition,
53 uint32_t create_options,
54 uint32_t file_attributes,
55 uint32_t oplock_request,
56 uint64_t allocation_size,
57 struct security_descriptor *sd,
58 struct ea_list *ea_list,
59 files_struct **result,
60 int *pinfo,
61 struct onefs_fsp_data *fsp_data);
62
63 /****************************************************************************
64 Open a file.
65 ****************************************************************************/
66
67 static NTSTATUS onefs_open_file(files_struct *fsp,
68 connection_struct *conn,
69 struct smb_request *req,
70 const char *parent_dir,
71 struct smb_filename *smb_fname,
72 int flags,
73 mode_t unx_mode,
74 uint32 access_mask,
75 uint32 open_access_mask,
76 int oplock_request,
77 uint64 id,
78 uint32 share_access,
79 uint32 create_options,
80 uint32_t new_dos_attributes,
81 struct security_descriptor *sd,
82 int *granted_oplock)
83 {
84 struct smb_filename *smb_fname_onefs = NULL;
85 NTSTATUS status = NT_STATUS_OK;
86 int accmode = (flags & O_ACCMODE);
87 int local_flags = flags;
88 bool file_existed = VALID_STAT(smb_fname->st);
89 const char *wild;
90 int base_fd = -1;
91
92 fsp->fh->fd = -1;
93 errno = EPERM;
94
95 /* Check permissions */
96
97 /*
98 * This code was changed after seeing a client open request
99 * containing the open mode of (DENY_WRITE/read-only) with
100 * the 'create if not exist' bit set. The previous code
101 * would fail to open the file read only on a read-only share
102 * as it was checking the flags parameter directly against O_RDONLY,
103 * this was failing as the flags parameter was set to O_RDONLY|O_CREAT.
104 * JRA.
105 */
106
107 if (!CAN_WRITE(conn)) {
108 /* It's a read-only share - fail if we wanted to write. */
109 if(accmode != O_RDONLY) {
110 DEBUG(3, ("Permission denied opening %s\n",
111 smb_fname_str_dbg(smb_fname)));
112 return NT_STATUS_ACCESS_DENIED;
113 } else if(flags & O_CREAT) {
114 /* We don't want to write - but we must make sure that
115 O_CREAT doesn't create the file if we have write
116 access into the directory.
117 */
118 flags &= ~O_CREAT;
119 local_flags &= ~O_CREAT;
120 }
121 }
122
123 /*
124 * This little piece of insanity is inspired by the
125 * fact that an NT client can open a file for O_RDONLY,
126 * but set the create disposition to FILE_EXISTS_TRUNCATE.
127 * If the client *can* write to the file, then it expects to
128 * truncate the file, even though it is opening for readonly.
129 * Quicken uses this stupid trick in backup file creation...
130 * Thanks *greatly* to "David W. Chapman Jr." <dwcjr@inethouston.net>
131 * for helping track this one down. It didn't bite us in 2.0.x
132 * as we always opened files read-write in that release. JRA.
133 */
134
135 if ((accmode == O_RDONLY) && ((flags & O_TRUNC) == O_TRUNC)) {
136 DEBUG(10,("onefs_open_file: truncate requested on read-only "
137 "open for file %s\n", smb_fname_str_dbg(smb_fname)));
138 local_flags = (flags & ~O_ACCMODE)|O_RDWR;
139 }
140
141 #if defined(O_NONBLOCK) && defined(S_ISFIFO)
142 /*
143 * We would block on opening a FIFO with no one else on the
144 * other end. Do what we used to do and add O_NONBLOCK to the
145 * open flags. JRA.
146 */
147
148 if (file_existed && S_ISFIFO(smb_fname->st.st_ex_mode)) {
149 local_flags |= O_NONBLOCK;
150 }
151 #endif
152
153 /* Don't create files with Microsoft wildcard characters. */
154 if (fsp->base_fsp) {
155 /*
156 * wildcard characters are allowed in stream names
157 * only test the basefilename
158 */
159 wild = fsp->base_fsp->fsp_name->base_name;
160 } else {
161 wild = smb_fname->base_name;
162 }
163 if ((local_flags & O_CREAT) && !file_existed &&
164 ms_has_wild(wild)) {
165 /*
166 * XXX: may need to remvoe this return...
167 *
168 * We dont think this check needs to exist. All it does is
169 * block creating files with Microsoft wildcards, which is
170 * fine if the creation originated from NFS or locally and
171 * then was copied via Samba.
172 */
173 DEBUG(1, ("onefs_open_file: creating file with wildcard: %s\n",
174 smb_fname_str_dbg(smb_fname)));
175 return NT_STATUS_OBJECT_NAME_INVALID;
176 }
177
178 /* Actually do the open */
179
180 #ifdef O_NOFOLLOW
181 /*
182 * Never follow symlinks on a POSIX client. The
183 * client should be doing this.
184 */
185
186 if (fsp->posix_open || !lp_symlinks(SNUM(conn))) {
187 flags |= O_NOFOLLOW;
188 }
189 #endif
190 /* Setup a onefs-style smb_fname struct. */
191 status = onefs_stream_prep_smb_fname(talloc_tos(), smb_fname,
192 &smb_fname_onefs);
193 if (!NT_STATUS_IS_OK(status)) {
194 return status;
195 }
196
197 /* If it's a stream pass in the base_fd */
198 if ((conn->fs_capabilities & FILE_NAMED_STREAMS) &&
199 is_ntfs_stream_smb_fname(smb_fname_onefs)) {
200 SMB_ASSERT(fsp->base_fsp);
201
202 DEBUG(10, ("Opening a stream: base=%s(%d), stream=%s\n",
203 smb_fname_onefs->base_name, fsp->base_fsp->fh->fd,
204 smb_fname_onefs->stream_name));
205
206 base_fd = fsp->base_fsp->fh->fd;
207 }
208
209 fsp->fh->fd = onefs_sys_create_file(conn,
210 base_fd,
211 smb_fname_onefs->stream_name != NULL ?
212 smb_fname_onefs->stream_name :
213 smb_fname_onefs->base_name,
214 access_mask,
215 open_access_mask,
216 share_access,
217 create_options,
218 flags,
219 unx_mode,
220 oplock_request,
221 id,
222 sd,
223 new_dos_attributes,
224 granted_oplock);
225 TALLOC_FREE(smb_fname_onefs);
226
227 if (fsp->fh->fd == -1) {
228 if (errno == EMFILE) {
229 static time_t last_warned = 0L;
230
231 if (time((time_t *) NULL) > last_warned) {
232 DEBUG(0, ("Too many open files, unable "
233 "to open more! smbd's max "
234 "open files = %d, also check "
235 "sysctl kern.maxfiles and "
236 "sysctl kern.maxfilesperproc\n",
237 lp_max_open_files()));
238 last_warned = time((time_t *) NULL);
239 }
240 }
241
242 status = map_nt_error_from_unix(errno);
243 DEBUG(3, ("Error opening file %s (%s) (local_flags=%d) "
244 "(flags=%d)\n", smb_fname_str_dbg(smb_fname),
245 strerror(errno), local_flags, flags));
246 return status;
247 }
248
249 if ((local_flags & O_CREAT) && !file_existed) {
250
251 /* Inherit the ACL if required */
252 if (lp_inherit_perms(SNUM(conn))) {
253 inherit_access_posix_acl(conn, parent_dir,
254 smb_fname->base_name, unx_mode);
255 }
256
257 /* Change the owner if required. */
258 if (lp_inherit_owner(SNUM(conn))) {
259 change_file_owner_to_parent(conn, parent_dir,
260 fsp);
261 }
262
263 notify_fname(conn, NOTIFY_ACTION_ADDED,
264 FILE_NOTIFY_CHANGE_FILE_NAME, smb_fname->base_name);
265 }
266
267 if (!file_existed) {
268 int ret;
269
270 if (fsp->fh->fd == -1) {
271 ret = SMB_VFS_STAT(conn, smb_fname);
272 } else {
273 ret = SMB_VFS_FSTAT(fsp, &smb_fname->st);
274 /* If we have an fd, this stat should succeed. */
275 if (ret == -1) {
276 DEBUG(0, ("Error doing fstat on open file %s "
277 "(%s)\n",
278 smb_fname_str_dbg(smb_fname),
279 strerror(errno) ));
280 }
281 }
282
283 /* For a non-io open, this stat failing means file not found. JRA */
284 if (ret == -1) {
285 status = map_nt_error_from_unix(errno);
286 fd_close(fsp);
287 return status;
288 }
289 }
290
291 /*
292 * POSIX allows read-only opens of directories. We don't
293 * want to do this (we use a different code path for this)
294 * so catch a directory open and return an EISDIR. JRA.
295 */
296
297 if(S_ISDIR(smb_fname->st.st_ex_mode)) {
298 fd_close(fsp);
299 errno = EISDIR;
300 return NT_STATUS_FILE_IS_A_DIRECTORY;
301 }
302
303 fsp->mode = smb_fname->st.st_ex_mode;
304 fsp->file_id = vfs_file_id_from_sbuf(conn, &smb_fname->st);
305 fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
306 fsp->file_pid = req ? req->smbpid : 0;
307 fsp->can_lock = True;
308 fsp->can_read = (access_mask & (FILE_READ_DATA)) ? True : False;
309 if (!CAN_WRITE(conn)) {
310 fsp->can_write = False;
311 } else {
312 fsp->can_write = (access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) ?
313 True : False;
314 }
315 fsp->print_file = False;
316 fsp->modified = False;
317 fsp->sent_oplock_break = NO_BREAK_SENT;
318 fsp->is_directory = False;
319 if (conn->aio_write_behind_list &&
320 is_in_path(smb_fname->base_name, conn->aio_write_behind_list,
321 conn->case_sensitive)) {
322 fsp->aio_write_behind = True;
323 }
324
325 status = fsp_set_smb_fname(fsp, smb_fname);
326 if (!NT_STATUS_IS_OK(status)) {
327 fd_close(fsp);
328 errno = map_errno_from_nt_status(status);
329 return status;
330 }
331
332 fsp->wcp = NULL; /* Write cache pointer. */
333
334 DEBUG(2,("%s opened file %s read=%s write=%s (numopen=%d)\n",
335 conn->server_info->unix_name,
336 smb_fname_str_dbg(smb_fname),
337 BOOLSTR(fsp->can_read), BOOLSTR(fsp->can_write),
338 conn->num_files_open));
339
340 errno = 0;
341 return NT_STATUS_OK;
342 }
343
344 /****************************************************************************
345 Handle the 1 second delay in returning a SHARING_VIOLATION error.
346 ****************************************************************************/
347
348 static void defer_open(struct share_mode_lock *lck,
349 struct timeval request_time,
350 struct timeval timeout,
351 struct smb_request *req,
352 struct deferred_open_record *state)
353 {
354 int i;
355
356 /* Paranoia check */
357
358 for (i=0; i<lck->num_share_modes; i++) {
359 struct share_mode_entry *e = &lck->share_modes[i];
360
361 if (!is_deferred_open_entry(e)) {
362 continue;
363 }
364
365 if (procid_is_me(&e->pid) && (e->op_mid == req->mid)) {
366 DEBUG(0, ("Trying to defer an already deferred "
367 "request: mid=%d, exiting\n", req->mid));
368 exit_server("attempt to defer a deferred request");
369 }
370 }
371
372 /* End paranoia check */
373
374 DEBUG(10,("defer_open_sharing_error: time [%u.%06u] adding deferred "
375 "open entry for mid %u\n",
376 (unsigned int)request_time.tv_sec,
377 (unsigned int)request_time.tv_usec,
378 (unsigned int)req->mid));
379
380 if (!push_deferred_smb_message(req, request_time, timeout,
381 (char *)state, sizeof(*state))) {
382 exit_server("push_deferred_smb_message failed");
383 }
384 add_deferred_open(lck, req->mid, request_time, state->id);
385 }
386
387 static void schedule_defer_open(struct share_mode_lock *lck,
388 struct timeval request_time,
389 struct smb_request *req)
390 {
391 struct deferred_open_record state;
392
393 /* This is a relative time, added to the absolute
394 request_time value to get the absolute timeout time.
395 Note that if this is the second or greater time we enter
396 this codepath for this particular request mid then
397 request_time is left as the absolute time of the *first*
398 time this request mid was processed. This is what allows
399 the request to eventually time out. */
400
401 struct timeval timeout;
402
403 /* Normally the smbd we asked should respond within
404 * OPLOCK_BREAK_TIMEOUT seconds regardless of whether
405 * the client did, give twice the timeout as a safety
406 * measure here in case the other smbd is stuck
407 * somewhere else. */
408
409 /*
410 * On OneFS, the kernel will always send an oplock_revoked message
411 * before this timeout is hit.
412 */
413 timeout = timeval_set(OPLOCK_BREAK_TIMEOUT*10, 0);
414
415 /* Nothing actually uses state.delayed_for_oplocks
416 but it's handy to differentiate in debug messages
417 between a 30 second delay due to oplock break, and
418 a 1 second delay for share mode conflicts. */
419
420 state.delayed_for_oplocks = True;
421 state.failed = false;
422 state.id = lck->id;
423
424 if (!request_timed_out(request_time, timeout)) {
425 defer_open(lck, request_time, timeout, req, &state);
426 } else {
427 /* A delayed-for-oplocks deferred open timing out should only
428 * happen if there is a bug or extreme load, since we set the
429 * timeout to 300 seconds. */
430 DEBUG(0, ("Deferred open timeout! request_time=%d.%d, "
431 "mid=%d\n", request_time.tv_sec, request_time.tv_usec,
432 req->mid));
433 }
434 }
435
436 /****************************************************************************
437 Open a file with a share mode. Passed in an already created files_struct.
438 ****************************************************************************/
439 NTSTATUS onefs_open_file_ntcreate(connection_struct *conn,
440 struct smb_request *req,
441 struct smb_filename *smb_fname,
442 uint32 access_mask,
443 uint32 share_access,
444 uint32 create_disposition,
445 uint32 create_options,
446 uint32 new_dos_attributes,
447 int oplock_request,
448 struct security_descriptor *sd,
449 files_struct *fsp,
450 int *pinfo,
451 struct onefs_fsp_data *fsp_data)
452 {
453 int flags=0;
454 int flags2=0;
455 bool file_existed = VALID_STAT(smb_fname->st);
456 bool def_acl = False;
457 bool posix_open = False;
458 bool new_file_created = False;
459 bool clear_ads = False;
460 struct file_id id;
461 mode_t new_unx_mode = (mode_t)0;
462 mode_t unx_mode = (mode_t)0;
463 int info;
464 uint32 existing_dos_attributes = 0;
465 struct pending_message_list *pml = NULL;
466 struct timeval request_time = timeval_zero();
467 struct share_mode_lock *lck = NULL;
468 uint32 open_access_mask = access_mask;
469 NTSTATUS status;
470 int ret_flock;
471 char *parent_dir;
472 int granted_oplock;
473 uint64_t oplock_callback_id = 0;
474 uint32 createfile_attributes = 0;
475
476 ZERO_STRUCT(id);
477
478 if (conn->printer) {
479 /*
480 * Printers are handled completely differently.
481 * Most of the passed parameters are ignored.
482 */
483
484 if (pinfo) {
485 *pinfo = FILE_WAS_CREATED;
486 }
487
488 DEBUG(10, ("onefs_open_file_ntcreate: printer open fname=%s\n",
489 smb_fname_str_dbg(smb_fname)));
490
491 return print_fsp_open(req, conn, smb_fname->base_name,
492 req->vuid, fsp);
493 }
494
495 if (!parent_dirname(talloc_tos(), smb_fname->base_name, &parent_dir,
496 NULL)) {
497 return NT_STATUS_NO_MEMORY;
498 }
499
500 if (new_dos_attributes & FILE_FLAG_POSIX_SEMANTICS) {
501 posix_open = True;
502 unx_mode = (mode_t)(new_dos_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
503 new_dos_attributes = 0;
504 } else {
505 /* We add aARCH to this as this mode is only used if the file is
506 * created new. */
507 unx_mode = unix_mode(conn, new_dos_attributes | aARCH,
508 smb_fname, parent_dir);
509 }
510
511 DEBUG(10,("onefs_open_file_ntcreate: fname=%s, dos_attrs=0x%x "
512 "access_mask=0x%x share_access=0x%x "
513 "create_disposition = 0x%x create_options=0x%x "
514 "unix mode=0%o oplock_request=0x%x\n",
515 smb_fname_str_dbg(smb_fname), new_dos_attributes,
516 access_mask, share_access, create_disposition,
517 create_options, unx_mode, oplock_request));
518
519 /*
520 * Any non-stat-only open has the potential to contend oplocks, which
521 * means to avoid blocking in the kernel (which is unacceptable), the
522 * open must be deferred. In order to defer opens, req must not be
523 * NULL. The known cases of calling with a NULL req:
524 *
525 * 1. Open the base file of a stream: Always done stat-only
526 *
527 * 2. open_file_fchmod(), which is called from 3 places:
528 * A. try_chown: Posix acls only. Never called on onefs.
529 * B. set_ea_dos_attributes: Can't be called from onefs, because
530 * SMB_VFS_SETXATTR return ENOSYS.
531 * C. file_set_dos_mode: This would only happen if the "dos
532 * filemode" smb.conf parameter is set to yes. We ship with
533 * it off, but if a customer were to turn it on it would be
534 * bad.
535 */
536 if (req == NULL && !is_stat_open(access_mask) &&
537 !is_ntfs_stream_smb_fname(smb_fname)) {
538 smb_panic("NULL req on a non-stat-open!");
539 }
540
541 if ((req == NULL) && ((oplock_request & INTERNAL_OPEN_ONLY) == 0)) {
542 DEBUG(0, ("No smb request but not an internal only open!\n"));
543 return NT_STATUS_INTERNAL_ERROR;
544 }
545
546 /*
547 * Only non-internal opens can be deferred at all
548 */
549
550 if ((req != NULL)
551 && ((pml = get_open_deferred_message(req->mid)) != NULL)) {
552 struct deferred_open_record *state =
553 (struct deferred_open_record *)pml->private_data.data;
554
555 /* Remember the absolute time of the original
556 request with this mid. We'll use it later to
557 see if this has timed out. */
558
559 request_time = pml->request_time;
560
561 /* Remove the deferred open entry under lock. */
562 lck = get_share_mode_lock(talloc_tos(), state->id, NULL, NULL,
563 NULL);
564 if (lck == NULL) {
565 DEBUG(0, ("could not get share mode lock\n"));
566 } else {
567 del_deferred_open_entry(lck, req->mid);
568 TALLOC_FREE(lck);
569 }
570
571 /* Ensure we don't reprocess this message. */
572 remove_deferred_open_smb_message(req->mid);
573
574 /*
575 * When receiving a semlock_async_failure message, the
576 * deferred open will be marked as "failed". Returning
577 * INTERNAL_ERROR.
578 */
579 if (state->failed) {
580 DEBUG(0, ("onefs_open_file_ntcreate: "
581 "semlock_async_failure detected!\n"));
582 return NT_STATUS_INTERNAL_ERROR;
583 }
584 }
585
586 status = check_name(conn, smb_fname->base_name);
587 if (!NT_STATUS_IS_OK(status)) {
588 return status;
589 }
590
591 if (!posix_open) {
592 new_dos_attributes &= SAMBA_ATTRIBUTES_MASK;
593 if (file_existed) {
594 existing_dos_attributes = dos_mode(conn, smb_fname);
595 }
596 }
597
598 /* Setup dos_attributes to be set by ifs_createfile */
599 if (lp_store_dos_attributes(SNUM(conn))) {
600 createfile_attributes = (new_dos_attributes | aARCH) &
601 ~(FILE_ATTRIBUTE_NONINDEXED | FILE_ATTRIBUTE_COMPRESSED);
602 }
603
604 /* Ignore oplock requests if oplocks are disabled. */
605 if (!lp_oplocks(SNUM(conn)) || global_client_failed_oplock_break ||
606 IS_VETO_OPLOCK_PATH(conn, smb_fname->base_name)) {
607 /* Mask off everything except the private Samba bits. */
608 oplock_request &= SAMBA_PRIVATE_OPLOCK_MASK;
609 }
610
611 /* this is for OS/2 long file names - say we don't support them */
612 if (!lp_posix_pathnames() && strstr(smb_fname->base_name,".+,;=[].")) {
613 /* OS/2 Workplace shell fix may be main code stream in a later
614 * release. */
615 DEBUG(5,("onefs_open_file_ntcreate: OS/2 long filenames are "
616 "not supported.\n"));
617 if (use_nt_status()) {
618 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
619 }
620 return NT_STATUS_DOS(ERRDOS, ERRcannotopen);
621 }
622
623 switch( create_disposition ) {
624 /*
625 * Currently we're using FILE_SUPERSEDE as the same as
626 * FILE_OVERWRITE_IF but they really are
627 * different. FILE_SUPERSEDE deletes an existing file
628 * (requiring delete access) then recreates it.
629 */
630 case FILE_SUPERSEDE:
631 /**
632 * @todo: Clear all file attributes?
633 * http://www.osronline.com/article.cfm?article=302
634 * create if not exist, trunc if exist
635 *
636 * If file exists replace/overwrite. If file doesn't
637 * exist create.
638 */
639 flags2 |= (O_CREAT | O_TRUNC);
640 clear_ads = true;
641 break;
642
643 case FILE_OVERWRITE_IF:
644 /* If file exists replace/overwrite. If file doesn't
645 * exist create. */
646 flags2 |= (O_CREAT | O_TRUNC);
647 clear_ads = true;
648 break;
649
650 case FILE_OPEN:
651 /* If file exists open. If file doesn't exist error. */
652 if (!file_existed) {
653 DEBUG(5,("onefs_open_file_ntcreate: FILE_OPEN "
654 "requested for file %s and file "
655 "doesn't exist.\n",
656 smb_fname_str_dbg(smb_fname)));
657 errno = ENOENT;
658 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
659 }
660 break;
661
662 case FILE_OVERWRITE:
663 /* If file exists overwrite. If file doesn't exist
664 * error. */
665 if (!file_existed) {
666 DEBUG(5, ("onefs_open_file_ntcreate: "
667 "FILE_OVERWRITE requested for file "
668 "%s and file doesn't exist.\n",
669 smb_fname_str_dbg(smb_fname)));
670 errno = ENOENT;
671 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
672 }
673 flags2 |= O_TRUNC;
674 clear_ads = true;
675 break;
676
677 case FILE_CREATE:
678 /* If file exists error. If file doesn't exist
679 * create. */
680 if (file_existed) {
681 DEBUG(5, ("onefs_open_file_ntcreate: "
682 "FILE_CREATE requested for file %s "
683 "and file already exists.\n",
684 smb_fname_str_dbg(smb_fname)));
685 if (S_ISDIR(smb_fname->st.st_ex_mode)) {
686 errno = EISDIR;
687 } else {
688 errno = EEXIST;
689 }
690 return map_nt_error_from_unix(errno);
691 }
692 flags2 |= (O_CREAT|O_EXCL);
693 break;
694
695 case FILE_OPEN_IF:
696 /* If file exists open. If file doesn't exist
697 * create. */
698 flags2 |= O_CREAT;
699 break;
700
701 default:
702 return NT_STATUS_INVALID_PARAMETER;
703 }
704
705 /* Match attributes on file exists and overwrite. */
706 if (!posix_open && file_existed &&
707 ((create_disposition == FILE_OVERWRITE) ||
708 (create_disposition == FILE_OVERWRITE_IF))) {
709 if (!open_match_attributes(conn, existing_dos_attributes,
710 new_dos_attributes,
711 smb_fname->st.st_ex_mode,
712 unx_mode, &new_unx_mode)) {
713 DEBUG(5, ("onefs_open_file_ntcreate: attributes "
714 "missmatch for file %s (%x %x) (0%o, 0%o)\n",
715 smb_fname_str_dbg(smb_fname),
716 existing_dos_attributes,
717 new_dos_attributes,
718 (unsigned int)smb_fname->st.st_ex_mode,
719 (unsigned int)unx_mode ));
720 errno = EACCES;
721 return NT_STATUS_ACCESS_DENIED;
722 }
723 }
724
725 /*
726 * OneFS understands MAXIMUM_ALLOWED_ACCESS, so only hack the
727 * access_mask, but leave the MAA for the actual open in
728 * open_access_mask.
729 */
730 open_access_mask = access_mask;
731 if (open_access_mask & MAXIMUM_ALLOWED_ACCESS) {
732 access_mask |= FILE_GENERIC_ALL;
733 }
734
735 /* Convert GENERIC bits to specific bits. */
736 se_map_generic(&access_mask, &file_generic_mapping);
737 se_map_generic(&open_access_mask, &file_generic_mapping);
738
739 if ((flags2 & O_TRUNC) || (oplock_request & FORCE_OPLOCK_BREAK_TO_NONE)) {
740 /* This will cause oplock breaks. */
741 open_access_mask |= FILE_WRITE_DATA;
742 }
743
744 DEBUG(10, ("onefs_open_file_ntcreate: fname=%s, after mapping "
745 "open_access_mask=%#x, access_mask=0x%x\n",
746 smb_fname_str_dbg(smb_fname), open_access_mask,
747 access_mask));
748
749 /*
750 * Note that we ignore the append flag as append does not
751 * mean the same thing under DOS and Unix.
752 */
753
754 if ((access_mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) ||
755 (oplock_request & FORCE_OPLOCK_BREAK_TO_NONE)) {
756
757 /*
758 * DENY_DOS opens are always underlying read-write on the
759 * file handle, no matter what the requested access mask
760 * says. Stock samba just sets the flags, but since
761 * ifs_createfile uses the access_mask, it must be updated as
762 * well. This allows BASE-DENY* to pass.
763 */
764 if (create_options & NTCREATEX_OPTIONS_PRIVATE_DENY_DOS) {
765
766 DEBUG(10,("onefs_open_file_ntcreate: deny_dos: "
767 "Adding O_RDWR to flags "
768 "(0x%x) and some READ bits to "
769 "open_access_mask (0x%x)\n",
770 flags, open_access_mask));
771
772 flags = O_RDWR;
773 open_access_mask |= (FILE_READ_ATTRIBUTES |
774 FILE_READ_DATA | FILE_READ_EA | FILE_EXECUTE);
775
776 } else if (access_mask & (FILE_READ_ATTRIBUTES |
777 FILE_READ_DATA |
778 FILE_READ_EA |
779 FILE_EXECUTE)) {
780 flags = O_RDWR;
781 } else {
782 flags = O_WRONLY;
783 }
784 } else {
785 flags = O_RDONLY;
786 }
787
788 /* Currently we only look at FILE_WRITE_THROUGH for create options. */
789 #if defined(O_SYNC)
790 if ((create_options & FILE_WRITE_THROUGH) &&
791 lp_strict_sync(SNUM(conn))) {
792 flags2 |= O_SYNC;
793 }
794 #endif /* O_SYNC */
795
796 if (posix_open && (access_mask & FILE_APPEND_DATA)) {
797 flags2 |= O_APPEND;
798 }
799
800 if (!posix_open && !CAN_WRITE(conn)) {
801 /*
802 * We should really return a permission denied error if either
803 * O_CREAT or O_TRUNC are set, but for compatibility with
804 * older versions of Samba we just AND them out.
805 */
806 flags2 &= ~(O_CREAT|O_TRUNC);
807
808 /* Deny DELETE_ACCESS explicitly if the share is read only. */
809 if (access_mask & DELETE_ACCESS) {
810 return map_nt_error_from_unix(EACCES);
811 }
812 }
813
814 /* Ensure we can't write on a read-only share or file. */
815 if (flags != O_RDONLY && file_existed &&
816 (!CAN_WRITE(conn) || IS_DOS_READONLY(existing_dos_attributes))) {
817 DEBUG(5, ("onefs_open_file_ntcreate: write access requested "
818 "for file %s on read only %s\n",
819 smb_fname_str_dbg(smb_fname),
820 !CAN_WRITE(conn) ? "share" : "file" ));
821 errno = EACCES;
822 return NT_STATUS_ACCESS_DENIED;
823 }
824
825 DEBUG(10, ("fsp = %p\n", fsp));
826
827 fsp->share_access = share_access;
828 fsp->fh->private_options = create_options;
829 fsp->access_mask = open_access_mask; /* We change this to the
830 * requested access_mask after
831 * the open is done. */
832 fsp->posix_open = posix_open;
833
834 /* Ensure no SAMBA_PRIVATE bits can be set. */
835 fsp->oplock_type = (oplock_request & ~SAMBA_PRIVATE_OPLOCK_MASK);
836
837 if (timeval_is_zero(&request_time)) {
838 request_time = fsp->open_time;
839 }
840
841 if (file_existed) {
842 struct timespec old_write_time = smb_fname->st.st_ex_mtime;
843 id = vfs_file_id_from_sbuf(conn, &smb_fname->st);
844
845 lck = get_share_mode_lock(talloc_tos(), id,
846 conn->connectpath,
847 smb_fname, &old_write_time);
848
849 if (lck == NULL) {
850 DEBUG(0, ("Could not get share mode lock\n"));
851 return NT_STATUS_SHARING_VIOLATION;
852 }
853
854 if (lck->delete_on_close) {
855 /* DELETE_PENDING is not deferred for a second */
856 TALLOC_FREE(lck);
857 return NT_STATUS_DELETE_PENDING;
858 }
859 }
860
861 SMB_ASSERT(!file_existed || (lck != NULL));
862
863 /*
864 * Ensure we pay attention to default ACLs on directories. May be
865 * neccessary depending on ACL policies.
866 */
867 if ((flags2 & O_CREAT) && lp_inherit_acls(SNUM(conn)) &&
868 (def_acl = directory_has_default_acl(conn, parent_dir))) {
869 unx_mode = 0777;
870 }
871
872 DEBUG(4,("calling onefs_open_file with flags=0x%X flags2=0x%X "
873 "mode=0%o, access_mask = 0x%x, open_access_mask = 0x%x\n",
874 (unsigned int)flags, (unsigned int)flags2,
875 (unsigned int)unx_mode, (unsigned int)access_mask,
876 (unsigned int)open_access_mask));
877
878 /*
879 * Since the open is guaranteed to be stat only if req == NULL, a
880 * callback record is only needed if req != NULL.
881 */
882 if (req) {
883 SMB_ASSERT(fsp_data);
884 oplock_callback_id = onefs_oplock_wait_record(req->mid);
885 if (oplock_callback_id == 0) {
886 return NT_STATUS_NO_MEMORY;
887 }
888 } else {
889 /*
890 * It is also already asserted it's either a stream or a
891 * stat-only open at this point.
892 */
893 SMB_ASSERT(fsp->oplock_type == NO_OPLOCK);
894
895 /* The kernel and Samba's version of stat-only differs
896 * slightly: The kernel doesn't think its stat-only if we're
897 * truncating. We'd better have a req in order to defer the
898 * open. */
899 SMB_ASSERT(!((flags|flags2) & O_TRUNC));
900 }
901
902 /* Do the open. */
903 status = onefs_open_file(fsp,
904 conn,
905 req,
906 parent_dir,
907 smb_fname,
908 flags|flags2,
909 unx_mode,
910 access_mask,
911 open_access_mask,
912 fsp->oplock_type,
913 oplock_callback_id,
914 share_access,
915 create_options,
916 createfile_attributes,
917 sd,
918 &granted_oplock);
919
920 if (!NT_STATUS_IS_OK(status)) {
921
922 /* OneFS Oplock Handling */
923 if (errno == EINPROGRESS) {
924
925 /* If we get EINPROGRESS, the kernel will send us an
926 * asynchronous semlock event back. Ensure we can defer
927 * the open, by asserting req. */
928 SMB_ASSERT(req);
929
930 if (lck == NULL) {
931 /*
932 * We hit the race that when we did the stat
933 * on the file it did not exist, and someone
934 * has created it in between the stat and the
935 * open_file() call. Defer our open waiting,
936 * to break the oplock of the first opener.
937 */
938
939 struct timespec old_write_time;
940
941 DEBUG(3, ("Someone created file %s with an "
942 "oplock after we looked: Retrying\n",
943 smb_fname_str_dbg(smb_fname)));
944 /*
945 * We hit the race that when we did the stat
946 * on the file it did not exist, and someone
947 * has created it in between the stat and the
948 * open_file() call. Just retry immediately.
949 */
950 id = vfs_file_id_from_sbuf(conn,
951 &smb_fname->st);
952 if (!(lck = get_share_mode_lock(talloc_tos(),
953 id, conn->connectpath, smb_fname,
954 &old_write_time))) {
955 /*
956 * Emergency exit
957 */
958 DEBUG(0, ("onefs_open_file_ntcreate: "
959 "Could not get share mode "
960 "lock for %s\n",
961 smb_fname_str_dbg(smb_fname)));
962 status = NT_STATUS_SHARING_VIOLATION;
963
964 /* XXXZLK: This will cause us to get a
965 * semlock event when we aren't
966 * expecting one. */
967 goto cleanup_destroy;
968 }
969
970 schedule_defer_open(lck, request_time, req);
971 goto cleanup;
972 }
973 /* Waiting for an oplock */
974 DEBUG(5,("Async createfile because a client has an "
975 "oplock on %s\n",
976 smb_fname_str_dbg(smb_fname)));
977
978 SMB_ASSERT(req);
979 schedule_defer_open(lck, request_time, req);
980 goto cleanup;
981 }
982
983 /* Check for a sharing violation */
984 if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {
985 uint32 can_access_mask;
986 bool can_access = True;
987
988 /* If we raced on open we may not have a valid file_id
989 * or stat buf. Get them again. */
990 if (SMB_VFS_STAT(conn, fname, psbuf) == -1) {
991 DEBUG(0,("Error doing stat on file %s "
992 "(%s)\n", fname, strerror(errno)));
993 status = NT_STATUS_SHARING_VIOLATION;
994 goto cleanup_destroy;
995 }
996 id = vfs_file_id_from_sbuf(conn, psbuf);
997
998 /* Check if this can be done with the deny_dos and fcb
999 * calls. */
1000
1001 /* Try to find dup fsp if possible. */
1002 if (create_options &
1003 (NTCREATEX_OPTIONS_PRIVATE_DENY_DOS|
1004 NTCREATEX_OPTIONS_PRIVATE_DENY_FCB)) {
1005
1006 if (req == NULL) {
1007 DEBUG(0, ("DOS open without an SMB "
1008 "request!\n"));
1009 status = NT_STATUS_INTERNAL_ERROR;
1010 goto cleanup_destroy;
1011 }
1012
1013 /* Use the client requested access mask here,
1014 * not the one we open with. */
1015 status = fcb_or_dos_open(req,
1016 conn,
1017 fsp,
1018 smb_fname,
1019 id,
1020 req->smbpid,
1021 req->vuid,
1022 access_mask,
1023 share_access,
1024 create_options);
1025
1026 if (NT_STATUS_IS_OK(status)) {
1027 if (pinfo) {
1028 *pinfo = FILE_WAS_OPENED;
1029 }
1030 status = NT_STATUS_OK;
1031 goto cleanup;
1032 }
1033 }
1034
1035 /*
1036 * This next line is a subtlety we need for
1037 * MS-Access. If a file open will fail due to share
1038 * permissions and also for security (access) reasons,
1039 * we need to return the access failed error, not the
1040 * share error. We can't open the file due to kernel
1041 * oplock deadlock (it's possible we failed above on
1042 * the open_mode_check()) so use a userspace check.
1043 */
1044
1045 if (flags & O_RDWR) {
1046 can_access_mask = FILE_READ_DATA|FILE_WRITE_DATA;
1047 } else if (flags & O_WRONLY) {
1048 can_access_mask = FILE_WRITE_DATA;
1049 } else {
1050 can_access_mask = FILE_READ_DATA;
1051 }
1052
1053 if (((can_access_mask & FILE_WRITE_DATA) &&
1054 !CAN_WRITE(conn)) ||
1055 !can_access_file_data(conn, smb_fname,
1056 can_access_mask)) {
1057 can_access = False;
1058 }
1059
1060 /*
1061 * If we're returning a share violation, ensure we
1062 * cope with the braindead 1 second delay.
1063 */
1064 if (!(oplock_request & INTERNAL_OPEN_ONLY) &&
1065 lp_defer_sharing_violations()) {
1066 struct timeval timeout;
1067 struct deferred_open_record state;
1068 int timeout_usecs;
1069
1070 /* this is a hack to speed up torture tests
1071 in 'make test' */
1072 timeout_usecs = lp_parm_int(SNUM(conn),
1073 "smbd","sharedelay",
1074 SHARING_VIOLATION_USEC_WAIT);
1075
1076 /* This is a relative time, added to the
1077 absolute request_time value to get the
1078 absolute timeout time. Note that if this
1079 is the second or greater time we enter this
1080 codepath for this particular request mid
1081 then request_time is left as the absolute
1082 time of the *first* time this request mid
1083 was processed. This is what allows the
1084 request to eventually time out. */
1085
1086 timeout = timeval_set(0, timeout_usecs);
1087
1088 /* Nothing actually uses
1089 state.delayed_for_oplocks but it's handy to
1090 differentiate in debug messages between a
1091 30 second delay due to oplock break, and a
1092 1 second delay for share mode conflicts. */
1093
1094 state.delayed_for_oplocks = False;
1095 state.id = id;
1096 state.failed = false;
1097
1098 /*
1099 * We hit the race that when we did the stat
1100 * on the file it did not exist, and someone
1101 * has created it in between the stat and the
1102 * open_file() call. Retrieve the share_mode
1103 * lock on the newly opened file so we can
1104 * defer our request.
1105 */
1106 if (lck == NULL) {
1107 struct timespec old_write_time;
1108 old_write_time = get_mtimespec(psbuf);
1109
1110 lck = get_share_mode_lock(talloc_tos(),
1111 id, conn->connectpath, fname,
1112 &old_write_time);
1113 if (lck == NULL) {
1114 DEBUG(0,
1115 ("onefs_open_file_ntcreate:"
1116 " Could not get share "
1117 "mode lock for %s\n",
1118 fname));
1119 /* This will cause us to return
1120 * immediately skipping the
1121 * the 1 second delay, which
1122 * isn't a big deal */
1123 status = NT_STATUS_SHARING_VIOLATION;
1124 goto cleanup_destroy;
1125 }
1126 }
1127
1128 if ((req != NULL) &&
1129 !request_timed_out(request_time, timeout))
1130 {
1131 defer_open(lck, request_time, timeout,
1132 req, &state);
1133 }
1134 }
1135
1136 if (can_access) {
1137 /*
1138 * We have detected a sharing violation here
1139 * so return the correct error code
1140 */
1141 status = NT_STATUS_SHARING_VIOLATION;
1142 } else {
1143 status = NT_STATUS_ACCESS_DENIED;
1144 }
1145
1146 goto cleanup_destroy;
1147 }
1148
1149 /*
1150 * Normal error, for example EACCES
1151 */
1152 cleanup_destroy:
1153 if (oplock_callback_id != 0) {
1154 destroy_onefs_callback_record(oplock_callback_id);
1155 }
1156 cleanup:
1157 TALLOC_FREE(lck);
1158 return status;
1159 }
1160
1161 fsp->oplock_type = granted_oplock;
1162
1163 if (oplock_callback_id != 0) {
1164 onefs_set_oplock_callback(oplock_callback_id, fsp);
1165 fsp_data->oplock_callback_id = oplock_callback_id;
1166 } else {
1167 SMB_ASSERT(fsp->oplock_type == NO_OPLOCK);
1168 }
1169
1170 if (!file_existed) {
1171 struct timespec old_write_time = smb_fname->st.st_ex_mtime;
1172 /*
1173 * Deal with the race condition where two smbd's detect the
1174 * file doesn't exist and do the create at the same time. One
1175 * of them will win and set a share mode, the other (ie. this
1176 * one) should check if the requested share mode for this
1177 * create is allowed.
1178 */
1179
1180 /*
1181 * Now the file exists and fsp is successfully opened,
1182 * fsp->file_id is valid and should replace the
1183 * dev=0, inode=0 from a non existent file. Spotted by
1184 * Nadav Danieli <nadavd@exanet.com>. JRA.
1185 */
1186
1187 id = fsp->file_id;
1188
1189 lck = get_share_mode_lock(talloc_tos(), id,
1190 conn->connectpath,
1191 smb_fname, &old_write_time);
1192
1193 if (lck == NULL) {
1194 DEBUG(0, ("onefs_open_file_ntcreate: Could not get "
1195 "share mode lock for %s\n",
1196 smb_fname_str_dbg(smb_fname)));
1197 fd_close(fsp);
1198 return NT_STATUS_SHARING_VIOLATION;
1199 }
1200
1201 if (lck->delete_on_close) {
1202 status = NT_STATUS_DELETE_PENDING;
1203 }
1204
1205 if (!NT_STATUS_IS_OK(status)) {
1206 struct deferred_open_record state;
1207
1208 fd_close(fsp);
1209
1210 state.delayed_for_oplocks = False;
1211 state.id = id;
1212
1213 /* Do it all over again immediately. In the second
1214 * round we will find that the file existed and handle
1215 * the DELETE_PENDING and FCB cases correctly. No need
1216 * to duplicate the code here. Essentially this is a
1217 * "goto top of this function", but don't tell
1218 * anybody... */
1219
1220 if (req != NULL) {
1221 defer_open(lck, request_time, timeval_zero(),
1222 req, &state);
1223 }
1224 TALLOC_FREE(lck);
1225 return status;
1226 }
1227
1228 /*
1229 * We exit this block with the share entry *locked*.....
1230 */
1231
1232 }
1233
1234 SMB_ASSERT(lck != NULL);
1235
1236 /* Delete streams if create_disposition requires it */
1237 if (file_existed && clear_ads &&
1238 !is_ntfs_stream_smb_fname(smb_fname)) {
1239 status = delete_all_streams(conn, smb_fname->base_name);
1240 if (!NT_STATUS_IS_OK(status)) {
1241 TALLOC_FREE(lck);
1242 fd_close(fsp);
1243 return status;
1244 }
1245 }
1246
1247 /* note that we ignore failure for the following. It is
1248 basically a hack for NFS, and NFS will never set one of
1249 these only read them. Nobody but Samba can ever set a deny
1250 mode and we have already checked our more authoritative
1251 locking database for permission to set this deny mode. If
1252 the kernel refuses the operations then the kernel is wrong.
1253 note that GPFS supports it as well - jmcd */
1254
1255 if (fsp->fh->fd != -1) {
1256 ret_flock = SMB_VFS_KERNEL_FLOCK(fsp, share_access, access_mask);
1257 if(ret_flock == -1 ){
1258
1259 TALLOC_FREE(lck);
1260 fd_close(fsp);
1261 return NT_STATUS_SHARING_VIOLATION;
1262 }
1263 }
1264
1265 /*
1266 * At this point onwards, we can guarentee that the share entry
1267 * is locked, whether we created the file or not, and that the
1268 * deny mode is compatible with all current opens.
1269 */
1270
1271 /* Record the options we were opened with. */
1272 fsp->share_access = share_access;
1273 fsp->fh->private_options = create_options;
1274 /*
1275 * According to Samba4, SEC_FILE_READ_ATTRIBUTE is always granted,
1276 */
1277 fsp->access_mask = access_mask | FILE_READ_ATTRIBUTES;
1278
1279 if (file_existed) {
1280 /* stat opens on existing files don't get oplocks. */
1281 if (is_stat_open(open_access_mask)) {
1282 fsp->oplock_type = NO_OPLOCK;
1283 }
1284
1285 if (!(flags2 & O_TRUNC)) {
1286 info = FILE_WAS_OPENED;
1287 } else {
1288 info = FILE_WAS_OVERWRITTEN;
1289 }
1290 } else {
1291 info = FILE_WAS_CREATED;
1292 }
1293
1294 if (pinfo) {
1295 *pinfo = info;
1296 }
1297
1298 /*
1299 * Setup the oplock info in both the shared memory and
1300 * file structs.
1301 */
1302
1303 if ((fsp->oplock_type != NO_OPLOCK) &&
1304 (fsp->oplock_type != FAKE_LEVEL_II_OPLOCK)) {
1305 if (!set_file_oplock(fsp, fsp->oplock_type)) {
1306 /* Could not get the kernel oplock */
1307 fsp->oplock_type = NO_OPLOCK;
1308 }
1309 }
1310
1311 if (fsp->oplock_type == LEVEL_II_OPLOCK &&
1312 (!lp_level2_oplocks(SNUM(conn)) ||
1313 !(global_client_caps & CAP_LEVEL_II_OPLOCKS))) {
1314
1315 DEBUG(5, ("Downgrading level2 oplock on open "
1316 "because level2 oplocks = off\n"));
1317
1318 release_file_oplock(fsp);
1319 }
1320
1321 if (info == FILE_WAS_OVERWRITTEN || info == FILE_WAS_CREATED ||
1322 info == FILE_WAS_SUPERSEDED) {
1323 new_file_created = True;
1324 }
1325
1326 set_share_mode(lck, fsp, conn->server_info->utok.uid, 0,
1327 fsp->oplock_type);
1328
1329 /* Handle strange delete on close create semantics. */
1330 if (create_options & FILE_DELETE_ON_CLOSE) {
1331 status = can_set_delete_on_close(fsp, True, new_dos_attributes);
1332
1333 if (!NT_STATUS_IS_OK(status)) {
1334 /* Remember to delete the mode we just added. */
1335 del_share_mode(lck, fsp);
1336 TALLOC_FREE(lck);
1337 fd_close(fsp);
1338 return status;
1339 }
1340 /* Note that here we set the *inital* delete on close flag,
1341 not the regular one. The magic gets handled in close. */
1342 fsp->initial_delete_on_close = True;
1343 }
1344
1345 /*
1346 * Take care of inherited ACLs on created files - if default ACL not
1347 * selected.
1348 * May be necessary depending on acl policies.
1349 */
1350 if (!posix_open && !file_existed && !def_acl &&
1351 !(VALID_STAT(smb_fname->st) &&
1352 (smb_fname->st.st_ex_flags & SF_HASNTFSACL))) {
1353
1354 int saved_errno = errno; /* We might get ENOSYS in the next
1355 * call.. */
1356
1357 if (SMB_VFS_FCHMOD_ACL(fsp, unx_mode) == -1 &&
1358 errno == ENOSYS) {
1359 errno = saved_errno; /* Ignore ENOSYS */
1360 }
1361
1362 } else if (new_unx_mode) {
1363
1364 int ret = -1;
1365
1366 /* Attributes need changing. File already existed. */
1367
1368 {
1369 int saved_errno = errno; /* We might get ENOSYS in the
1370 * next call.. */
1371 ret = SMB_VFS_FCHMOD_ACL(fsp, new_unx_mode);
1372
1373 if (ret == -1 && errno == ENOSYS) {
1374 errno = saved_errno; /* Ignore ENOSYS */
1375 } else {
1376 DEBUG(5, ("onefs_open_file_ntcreate: reset "
1377 "attributes of file %s to 0%o\n",
1378 smb_fname_str_dbg(smb_fname),
1379 (unsigned int)new_unx_mode));
1380 ret = 0; /* Don't do the fchmod below. */
1381 }
1382 }
1383
1384 if ((ret == -1) &&
1385 (SMB_VFS_FCHMOD(fsp, new_unx_mode) == -1))
1386 DEBUG(5, ("onefs_open_file_ntcreate: failed to reset "
1387 "attributes of file %s to 0%o\n",
1388 smb_fname_str_dbg(smb_fname),
1389 (unsigned int)new_unx_mode));
1390 }
1391
1392 /* If this is a successful open, we must remove any deferred open
1393 * records. */
1394 if (req != NULL) {
1395 del_deferred_open_entry(lck, req->mid);
1396 }
1397 TALLOC_FREE(lck);
1398
1399 return NT_STATUS_OK;
1400 }
1401
1402
1403 /****************************************************************************
1404 Open a directory from an NT SMB call.
1405 ****************************************************************************/
1406 static NTSTATUS onefs_open_directory(connection_struct *conn,
1407 struct smb_request *req,
1408 struct smb_filename *smb_dname,
1409 uint32 access_mask,
1410 uint32 share_access,
1411 uint32 create_disposition,
1412 uint32 create_options,
1413 uint32 file_attributes,
1414 struct security_descriptor *sd,
1415 files_struct **result,
1416 int *pinfo)
1417 {
1418 files_struct *fsp = NULL;
1419 struct share_mode_lock *lck = NULL;
1420 NTSTATUS status;
1421 struct timespec mtimespec;
1422 int info = 0;
1423 char *parent_dir;
1424 bool posix_open = false;
1425 uint32 create_flags = 0;
1426 uint32 mode = lp_dir_mask(SNUM(conn));
1427
1428 DEBUG(5, ("onefs_open_directory: opening directory %s, "
1429 "access_mask = 0x%x, "
1430 "share_access = 0x%x create_options = 0x%x, "
1431 "create_disposition = 0x%x, file_attributes = 0x%x\n",
1432 smb_fname_str_dbg(smb_dname), (unsigned int)access_mask,
1433 (unsigned int)share_access, (unsigned int)create_options,
1434 (unsigned int)create_disposition,
1435 (unsigned int)file_attributes));
1436
1437 if (!(file_attributes & FILE_FLAG_POSIX_SEMANTICS) &&
1438 (conn->fs_capabilities & FILE_NAMED_STREAMS) &&
1439 is_ntfs_stream_smb_fname(smb_dname)) {
1440 DEBUG(2, ("onefs_open_directory: %s is a stream name!\n",
1441 smb_fname_str_dbg(smb_dname)));
1442 return NT_STATUS_NOT_A_DIRECTORY;
1443 }
1444
1445 switch (create_disposition) {
1446 case FILE_OPEN:
1447 /* If directory exists open. If directory doesn't
1448 * exist error. */
1449 create_flags = 0;
1450 info = FILE_WAS_OPENED;
1451 break;
1452 case FILE_CREATE:
1453 /* If directory exists error. If directory doesn't
1454 * exist create. */
1455 create_flags = O_CREAT | O_EXCL;
1456 info = FILE_WAS_CREATED;
1457 break;
1458 case FILE_OPEN_IF:
1459 /* If directory exists open. If directory doesn't
1460 * exist create. */
1461
1462 /* Note: in order to return whether the directory was
1463 * opened or created, we first try to open and then try
1464 * to create. */
1465 create_flags = 0;
1466 info = FILE_WAS_OPENED;
1467 break;
1468 case FILE_SUPERSEDE:
1469 case FILE_OVERWRITE:
1470 case FILE_OVERWRITE_IF:
1471 default:
1472 DEBUG(5, ("onefs_open_directory: invalid "
1473 "create_disposition 0x%x for directory %s\n",
1474 (unsigned int)create_disposition,
1475 smb_fname_str_dbg(smb_dname)));
1476 return NT_STATUS_INVALID_PARAMETER;
1477 }
1478
1479 /*
1480 * Check for write access to the share. Done in mkdir_internal() in
1481 * mainline samba.
1482 */
1483 if (!CAN_WRITE(conn) && (create_flags & O_CREAT)) {
1484 return NT_STATUS_ACCESS_DENIED;
1485 }
1486
1487 /* Get parent dirname */
1488 if (!parent_dirname(talloc_tos(), smb_dname->base_name, &parent_dir,
1489 NULL)) {
1490 return NT_STATUS_NO_MEMORY;
1491 }
1492
1493 if (file_attributes & FILE_FLAG_POSIX_SEMANTICS) {
1494 posix_open = true;
1495 mode = (mode_t)(file_attributes & ~FILE_FLAG_POSIX_SEMANTICS);
1496 file_attributes = 0;
1497 } else {
1498 mode = unix_mode(conn, aDIR, smb_dname, parent_dir);
1499 }
1500
1501 /*
1502 * The NONINDEXED and COMPRESSED bits seem to always be cleared on
1503 * directories, no matter if you specify that they should be set.
1504 */
1505 file_attributes &=
1506 ~(FILE_ATTRIBUTE_NONINDEXED | FILE_ATTRIBUTE_COMPRESSED);
1507
1508 status = file_new(req, conn, &fsp);
1509 if(!NT_STATUS_IS_OK(status)) {
1510 return status;
1511 }
1512
1513 /*
1514 * Actual open with retry magic to handle FILE_OPEN_IF which is
1515 * unique because the kernel won't tell us if the file was opened or
1516 * created.
1517 */
1518 retry_open:
1519 fsp->fh->fd = onefs_sys_create_file(conn,
1520 -1,
1521 smb_dname->base_name,
1522 access_mask,
1523 access_mask,
1524 share_access,
1525 create_options,
1526 create_flags | O_DIRECTORY,
1527 mode,
1528 0,
1529 0,
1530 sd,
1531 file_attributes,
1532 NULL);
1533
1534 if (fsp->fh->fd == -1) {
1535 DEBUG(3, ("Error opening %s. Errno=%d (%s).\n",
1536 smb_fname_str_dbg(smb_dname), errno,
1537 strerror(errno)));
1538 SMB_ASSERT(errno != EINPROGRESS);
1539
1540 if (create_disposition == FILE_OPEN_IF) {
1541 if (errno == ENOENT) {
1542 /* Try again, creating it this time. */
1543 create_flags = O_CREAT | O_EXCL;
1544 info = FILE_WAS_CREATED;
1545 goto retry_open;
1546 } else if (errno == EEXIST) {
1547 /* Uggh. Try again again. */
1548 create_flags = 0;
1549 info = FILE_WAS_OPENED;
1550 goto retry_open;
1551 }
1552 }
1553
1554 /* Error cases below: */
1555 file_free(req, fsp);
1556
1557 if ((errno == ENOENT) && (create_disposition == FILE_OPEN)) {
1558 DEBUG(5, ("onefs_open_directory: FILE_OPEN requested "
1559 "for directory %s and it doesn't "
1560 "exist.\n", smb_fname_str_dbg(smb_dname)));
1561 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1562 } else if ((errno == EEXIST) &&
1563 (create_disposition == FILE_CREATE)) {
1564 DEBUG(5, ("onefs_open_directory: FILE_CREATE "
1565 "requested for directory %s and it "
1566 "already exists.\n",
1567 smb_fname_str_dbg(smb_dname)));
1568 return NT_STATUS_OBJECT_NAME_COLLISION;
1569 } else if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) {
1570 /* Catch sharing violations. */
1571 return NT_STATUS_SHARING_VIOLATION;
1572 }
1573
1574 return map_nt_error_from_unix(errno);
1575 }
1576
1577 if (info == FILE_WAS_CREATED) {
1578
1579 /* Pulled from mkdir_internal() */
1580 if (SMB_VFS_LSTAT(conn, smb_dname) == -1) {
1581 DEBUG(2, ("Could not stat directory '%s' just "
1582 "created: %s\n",
1583 smb_fname_str_dbg(smb_dname),
1584 strerror(errno)));
1585 return map_nt_error_from_unix(errno);
1586 }
1587
1588 if (!S_ISDIR(smb_dname->st.st_ex_mode)) {
1589 DEBUG(0, ("Directory just '%s' created is not a "
1590 "directory\n",
1591 smb_fname_str_dbg(smb_dname)));
1592 return NT_STATUS_ACCESS_DENIED;
1593 }
1594
1595 if (!posix_open) {
1596 /*
1597 * Check if high bits should have been set, then (if
1598 * bits are missing): add them. Consider bits
1599 * automagically set by UNIX, i.e. SGID bit from
1600 * parent dir.
1601 */
1602 if (mode & ~(S_IRWXU|S_IRWXG|S_IRWXO) &&
1603 (mode & ~smb_dname->st.st_ex_mode)) {
1604 SMB_VFS_CHMOD(conn, smb_dname->base_name,
1605 (smb_dname->st.st_ex_mode |
1606 (mode & ~smb_dname->st.st_ex_mode)));
1607 }
1608 }
1609
1610 /* Change the owner if required. */
1611 if (lp_inherit_owner(SNUM(conn))) {
1612 change_dir_owner_to_parent(conn, parent_dir,
1613 smb_dname->base_name,
1614 &smb_dname->st);
1615 }
1616
1617 notify_fname(conn, NOTIFY_ACTION_ADDED,
1618 FILE_NOTIFY_CHANGE_DIR_NAME,
1619 smb_dname->base_name);
1620 }
1621
1622 /* Stat the fd for Samba bookkeeping. */
1623 if(SMB_VFS_FSTAT(fsp, &smb_dname->st) != 0) {
1624 fd_close(fsp);
1625 file_free(req, fsp);
1626 return map_nt_error_from_unix(errno);
1627 }
1628
1629 /* Setup the files_struct for it. */
1630 fsp->mode = smb_dname->st.st_ex_mode;
1631 fsp->file_id = vfs_file_id_from_sbuf(conn, &smb_dname->st);
1632 fsp->vuid = req ? req->vuid : UID_FIELD_INVALID;
1633 fsp->file_pid = req ? req->smbpid : 0;
1634 fsp->can_lock = False;
1635 fsp->can_read = False;
1636 fsp->can_write = False;
1637
1638 fsp->share_access = share_access;
1639 fsp->fh->private_options = create_options;
1640 /*
1641 * According to Samba4, SEC_FILE_READ_ATTRIBUTE is always granted,
1642 */
1643 fsp->access_mask = access_mask | FILE_READ_ATTRIBUTES;
1644 fsp->print_file = False;
1645 fsp->modified = False;
1646 fsp->oplock_type = NO_OPLOCK;
1647 fsp->sent_oplock_break = NO_BREAK_SENT;
1648 fsp->is_directory = True;
1649 fsp->posix_open = posix_open;
1650
1651 status = fsp_set_smb_fname(fsp, smb_dname);
1652 if (!NT_STATUS_IS_OK(status)) {
1653 fd_close(fsp);
1654 file_free(req, fsp);
1655 return status;
1656 }
1657
1658 mtimespec = smb_dname->st.st_ex_mtime;
1659
1660 /*
1661 * Still set the samba share mode lock for correct delete-on-close
1662 * semantics and to make smbstatus more useful.
1663 */
1664 lck = get_share_mode_lock(talloc_tos(), fsp->file_id,
1665 conn->connectpath, smb_dname, &mtimespec);
1666
1667 if (lck == NULL) {
1668 DEBUG(0, ("onefs_open_directory: Could not get share mode "
1669 "lock for %s\n", smb_fname_str_dbg(smb_dname)));
1670 fd_close(fsp);
1671 file_free(req, fsp);
1672 return NT_STATUS_SHARING_VIOLATION;
1673 }
1674
1675 if (lck->delete_on_close) {
1676 TALLOC_FREE(lck);
1677 fd_close(fsp);
1678 file_free(req, fsp);
1679 return NT_STATUS_DELETE_PENDING;
1680 }
1681
1682 set_share_mode(lck, fsp, conn->server_info->utok.uid, 0, NO_OPLOCK);
1683
1684 /*
1685 * For directories the delete on close bit at open time seems
1686 * always to be honored on close... See test 19 in Samba4 BASE-DELETE.
1687 */
1688 if (create_options & FILE_DELETE_ON_CLOSE) {
1689 status = can_set_delete_on_close(fsp, True, 0);
1690 if (!NT_STATUS_IS_OK(status) &&
1691 !NT_STATUS_EQUAL(status, NT_STATUS_DIRECTORY_NOT_EMPTY)) {
1692 TALLOC_FREE(lck);
1693 fd_close(fsp);
1694 file_free(req, fsp);
1695 return status;
1696 }
1697
1698 if (NT_STATUS_IS_OK(status)) {
1699 /* Note that here we set the *inital* delete on close flag,
1700 not the regular one. The magic gets handled in close. */
1701 fsp->initial_delete_on_close = True;
1702 }
1703 }
1704
1705 TALLOC_FREE(lck);
1706
1707 if (pinfo) {
1708 *pinfo = info;
1709 }
1710
1711 *result = fsp;
1712 return NT_STATUS_OK;
1713 }
1714
1715 /*
1716 * Wrapper around onefs_open_file_ntcreate and onefs_open_directory.
1717 */
1718 static NTSTATUS onefs_create_file_unixpath(connection_struct *conn,
1719 struct smb_request *req,
1720 struct smb_filename *smb_fname,
1721 uint32_t access_mask,
1722 uint32_t share_access,
1723 uint32_t create_disposition,
1724 uint32_t create_options,
1725 uint32_t file_attributes,
1726 uint32_t oplock_request,
1727 uint64_t allocation_size,
1728 struct security_descriptor *sd,
1729 struct ea_list *ea_list,
1730 files_struct **result,
1731 int *pinfo,
1732 struct onefs_fsp_data *fsp_data)
1733 {
1734 int info = FILE_WAS_OPENED;
1735 files_struct *base_fsp = NULL;
1736 files_struct *fsp = NULL;
1737 NTSTATUS status;
1738
1739 DEBUG(10,("onefs_create_file_unixpath: access_mask = 0x%x "
1740 "file_attributes = 0x%x, share_access = 0x%x, "
1741 "create_disposition = 0x%x create_options = 0x%x "
1742 "oplock_request = 0x%x ea_list = 0x%p, sd = 0x%p, "
1743 "fname = %s\n",
1744 (unsigned int)access_mask,
1745 (unsigned int)file_attributes,
1746 (unsigned int)share_access,
1747 (unsigned int)create_disposition,
1748 (unsigned int)create_options,
1749 (unsigned int)oplock_request,
1750 ea_list, sd, smb_fname_str_dbg(smb_fname)));
1751
1752 if (create_options & FILE_OPEN_BY_FILE_ID) {
1753 status = NT_STATUS_NOT_SUPPORTED;
1754 goto fail;
1755 }
1756
1757 if (create_options & NTCREATEX_OPTIONS_INVALID_PARAM_MASK) {
1758 status = NT_STATUS_INVALID_PARAMETER;
1759 goto fail;
1760 }
1761
1762 if (req == NULL) {
1763 SMB_ASSERT((oplock_request & ~SAMBA_PRIVATE_OPLOCK_MASK) ==
1764 NO_OPLOCK);
1765 oplock_request |= INTERNAL_OPEN_ONLY;
1766 }
1767
1768 if (lp_parm_bool(SNUM(conn), PARM_ONEFS_TYPE,
1769 PARM_IGNORE_SACLS, PARM_IGNORE_SACLS_DEFAULT)) {
1770 access_mask &= ~SYSTEM_SECURITY_ACCESS;
1771 }
1772
1773 if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
1774 && (access_mask & DELETE_ACCESS)
1775 && !is_ntfs_stream_smb_fname(smb_fname)) {
1776 /*
1777 * We can't open a file with DELETE access if any of the
1778 * streams is open without FILE_SHARE_DELETE
1779 */
1780 status = open_streams_for_delete(conn, smb_fname->base_name);
1781
1782 if (!NT_STATUS_IS_OK(status)) {
1783 goto fail;
1784 }
1785 }
1786
1787 if ((conn->fs_capabilities & FILE_NAMED_STREAMS)
1788 && is_ntfs_stream_smb_fname(smb_fname)) {
1789 uint32 base_create_disposition;
1790 struct smb_filename *smb_fname_base = NULL;
1791
1792 if (create_options & FILE_DIRECTORY_FILE) {
1793 status = NT_STATUS_NOT_A_DIRECTORY;
1794 goto fail;
1795 }
1796
1797 switch (create_disposition) {
1798 case FILE_OPEN:
1799 base_create_disposition = FILE_OPEN;
1800 break;
1801 default:
1802 base_create_disposition = FILE_OPEN_IF;
1803 break;
1804 }
1805
1806 /* Create an smb_filename with stream_name == NULL. */
1807 status = create_synthetic_smb_fname(talloc_tos(),
1808 smb_fname->base_name,
1809 NULL, NULL,
1810 &smb_fname_base);
1811 if (!NT_STATUS_IS_OK(status)) {
1812 goto fail;
1813 }
1814
1815 if (SMB_VFS_STAT(conn, smb_fname_base) == -1) {
1816 DEBUG(10, ("Unable to stat stream: %s\n",
1817 smb_fname_str_dbg(smb_fname_base)));
1818 }
1819
1820 status = onefs_create_file_unixpath(
1821 conn, /* conn */
1822 NULL, /* req */
1823 smb_fname_base, /* fname */
1824 SYNCHRONIZE_ACCESS, /* access_mask */
1825 (FILE_SHARE_READ |
1826 FILE_SHARE_WRITE |
1827 FILE_SHARE_DELETE), /* share_access */
1828 base_create_disposition, /* create_disposition*/
1829 0, /* create_options */
1830 file_attributes, /* file_attributes */
1831 NO_OPLOCK, /* oplock_request */
1832 0, /* allocation_size */
1833 NULL, /* sd */
1834 NULL, /* ea_list */
1835 &base_fsp, /* result */
1836 NULL, /* pinfo */
1837 NULL); /* fsp_data */
1838
1839 TALLOC_FREE(smb_fname_base);
1840
1841 if (!NT_STATUS_IS_OK(status)) {
1842 DEBUG(10, ("onefs_create_file_unixpath for base %s "
1843 "failed: %s\n", smb_fname->base_name,
1844 nt_errstr(status)));
1845 goto fail;
1846 }
1847
1848 /*
1849 * Testing against windows xp/2003/vista shows that oplocks
1850 * can actually be requested and granted on streams (see the
1851 * RAW-OPLOCK-STREAM1 smbtorture test).
1852 */
1853 if ((oplock_request & ~SAMBA_PRIVATE_OPLOCK_MASK) !=
1854 NO_OPLOCK) {
1855 DEBUG(5, ("Oplock(%d) being requested on a stream! "
1856 "Ignoring oplock request: fname=%s\n",
1857 oplock_request & ~SAMBA_PRIVATE_OPLOCK_MASK,
1858 smb_fname_str_dbg(smb_fname)));
1859 /* Request NO_OPLOCK instead. */
1860 oplock_request &= SAMBA_PRIVATE_OPLOCK_MASK;
1861 }
1862 }
1863
1864 /* Covert generic bits in the security descriptor. */
1865 if (sd != NULL) {
1866 security_acl_map_generic(sd->dacl, &file_generic_mapping);
1867 security_acl_map_generic(sd->sacl, &file_generic_mapping);
1868 }
1869
1870 /*
1871 * If it's a request for a directory open, deal with it separately.
1872 */
1873
1874 if (create_options & FILE_DIRECTORY_FILE) {
1875
1876 if (create_options & FILE_NON_DIRECTORY_FILE) {
1877 status = NT_STATUS_INVALID_PARAMETER;
1878 goto fail;
1879 }
1880
1881 /* Can't open a temp directory. IFS kit test. */
1882 if (!(file_attributes & FILE_FLAG_POSIX_SEMANTICS) &&
1883 (file_attributes & FILE_ATTRIBUTE_TEMPORARY)) {
1884 status = NT_STATUS_INVALID_PARAMETER;
1885 goto fail;
1886 }
1887
1888 /*
1889 * We will get a create directory here if the Win32
1890 * app specified a security descriptor in the
1891 * CreateDirectory() call.
1892 */
1893
1894 status = onefs_open_directory(
1895 conn, /* conn */
1896 req, /* req */
1897 smb_fname, /* fname */
1898 access_mask, /* access_mask */
1899 share_access, /* share_access */
1900 create_disposition, /* create_disposition*/
1901 create_options, /* create_options */
1902 file_attributes, /* file_attributes */
1903 sd, /* sd */
1904 &fsp, /* result */
1905 &info); /* pinfo */
1906 } else {
1907
1908 /*
1909 * Ordinary file case.
1910 */
1911
1912 status = file_new(req, conn, &fsp);
1913 if(!NT_STATUS_IS_OK(status)) {
1914 goto fail;
1915 }
1916
1917 /*
1918 * We're opening the stream element of a base_fsp
1919 * we already opened. Set up the base_fsp pointer.
1920 */
1921 if (base_fsp) {
1922 fsp->base_fsp = base_fsp;
1923 }
1924
1925 status = onefs_open_file_ntcreate(
1926 conn, /* conn */
1927 req, /* req */
1928 smb_fname, /* fname */
1929 access_mask, /* access_mask */
1930 share_access, /* share_access */
1931 create_disposition, /* create_disposition*/
1932 create_options, /* create_options */
1933 file_attributes, /* file_attributes */
1934 oplock_request, /* oplock_request */
1935 sd, /* sd */
1936 fsp, /* result */
1937 &info, /* pinfo */
1938 fsp_data); /* fsp_data */
1939
1940 if(!NT_STATUS_IS_OK(status)) {
1941 file_free(req, fsp);
1942 fsp = NULL;
1943 }
1944
1945 if (NT_STATUS_EQUAL(status, NT_STATUS_FILE_IS_A_DIRECTORY)) {
1946
1947 /* A stream open never opens a directory */
1948
1949 if (base_fsp) {
1950 status = NT_STATUS_FILE_IS_A_DIRECTORY;
1951 goto fail;
1952 }
1953
1954 /*
1955 * Fail the open if it was explicitly a non-directory
1956 * file.
1957 */
1958
1959 if (create_options & FILE_NON_DIRECTORY_FILE) {
1960 status = NT_STATUS_FILE_IS_A_DIRECTORY;
1961 goto fail;
1962 }
1963
1964 create_options |= FILE_DIRECTORY_FILE;
1965
1966 status = onefs_open_directory(
1967 conn, /* conn */
1968 req, /* req */
1969 smb_fname, /* fname */
1970 access_mask, /* access_mask */
1971 share_access, /* share_access */
1972 create_disposition, /* create_disposition*/
1973 create_options, /* create_options */
1974 file_attributes, /* file_attributes */
1975 sd, /* sd */
1976 &fsp, /* result */
1977 &info); /* pinfo */
1978 }
1979 }
1980
1981 if (!NT_STATUS_IS_OK(status)) {
1982 goto fail;
1983 }
1984
1985 fsp->base_fsp = base_fsp;
1986
1987 SMB_ASSERT(fsp);
1988
1989 if ((ea_list != NULL) && (info == FILE_WAS_CREATED)) {
1990 status = set_ea(conn, fsp, smb_fname, ea_list);
1991 if (!NT_STATUS_IS_OK(status)) {
1992 goto fail;
1993 }
1994 }
1995
1996 if (!fsp->is_directory && S_ISDIR(smb_fname->st.st_ex_mode)) {
1997 status = NT_STATUS_ACCESS_DENIED;
1998 goto fail;
1999 }
2000
2001 /* Save the requested allocation size. */
2002 if ((info == FILE_WAS_CREATED) || (info == FILE_WAS_OVERWRITTEN)) {
2003 if (allocation_size
2004 && (allocation_size > smb_fname->st.st_ex_size)) {
2005 fsp->initial_allocation_size = smb_roundup(
2006 fsp->conn, allocation_size);
2007 if (fsp->is_directory) {
2008 /* Can't set allocation size on a directory. */
2009 status = NT_STATUS_ACCESS_DENIED;
2010 goto fail;
2011 }
2012 if (vfs_allocate_file_space(
2013 fsp, fsp->initial_allocation_size) == -1) {
2014 status = NT_STATUS_DISK_FULL;
2015 goto fail;
2016 }
2017 } else {
2018 fsp->initial_allocation_size = smb_roundup(
2019 fsp->conn, (uint64_t)smb_fname->st.st_ex_size);
2020 }
2021 }
2022
2023 DEBUG(10, ("onefs_create_file_unixpath: info=%d\n", info));
2024
2025 *result = fsp;
2026 if (pinfo != NULL) {
2027 *pinfo = info;
2028 }
2029 if ((fsp->fh != NULL) && (fsp->fh->fd != -1)) {
2030 SMB_VFS_FSTAT(fsp, &smb_fname->st);
2031 }
2032 return NT_STATUS_OK;
2033
2034 fail:
2035 DEBUG(10, ("onefs_create_file_unixpath: %s\n", nt_errstr(status)));
2036
2037 if (fsp != NULL) {
2038 if (base_fsp && fsp->base_fsp == base_fsp) {
2039 /*
2040 * The close_file below will close
2041 * fsp->base_fsp.
2042 */
2043 base_fsp = NULL;
2044 }
2045 close_file(req, fsp, ERROR_CLOSE);
2046 fsp = NULL;
2047 }
2048 if (base_fsp != NULL) {
2049 close_file(req, base_fsp, ERROR_CLOSE);
2050 base_fsp = NULL;
2051 }
2052 return status;
2053 }
2054
2055 static void destroy_onefs_fsp_data(void *p_data)
2056 {
2057 struct onefs_fsp_data *fsp_data = (struct onefs_fsp_data *)p_data;
2058
2059 destroy_onefs_callback_record(fsp_data->oplock_callback_id);
2060 }
2061
2062 /**
2063 * SMB_VFS_CREATE_FILE interface to onefs.
2064 */
2065 NTSTATUS onefs_create_file(vfs_handle_struct *handle,
2066 struct smb_request *req,
2067 uint16_t root_dir_fid,
2068 struct smb_filename *smb_fname,
2069 uint32_t access_mask,
2070 uint32_t share_access,
2071 uint32_t create_disposition,
2072 uint32_t create_options,
2073 uint32_t file_attributes,
2074 uint32_t oplock_request,
2075 uint64_t allocation_size,
2076 struct security_descriptor *sd,
2077 struct ea_list *ea_list,
2078 files_struct **result,
2079 int *pinfo)
2080 {
2081 connection_struct *conn = handle->conn;
2082 struct onefs_fsp_data fsp_data = {};
2083 int info = FILE_WAS_OPENED;
2084 files_struct *fsp = NULL;
2085 NTSTATUS status;
2086
2087 DEBUG(10,("onefs_create_file: access_mask = 0x%x "
2088 "file_attributes = 0x%x, share_access = 0x%x, "
2089 "create_disposition = 0x%x create_options = 0x%x "
2090 "oplock_request = 0x%x "
2091 "root_dir_fid = 0x%x, ea_list = 0x%p, sd = 0x%p, "
2092 "fname = %s\n",
2093 (unsigned int)access_mask,
2094 (unsigned int)file_attributes,
2095 (unsigned int)share_access,
2096 (unsigned int)create_disposition,
2097 (unsigned int)create_options,
2098 (unsigned int)oplock_request,
2099 (unsigned int)root_dir_fid,
2100 ea_list, sd, smb_fname_str_dbg(smb_fname)));
2101
2102 /* Get the file name if root_dir_fid was specified. */
2103 if (root_dir_fid != 0) {
2104 status = get_relative_fid_filename(conn, req, root_dir_fid,
2105 smb_fname);
2106 if (!NT_STATUS_IS_OK(status)) {
2107 goto fail;
2108 }
2109 }
2110
2111 /* All file access must go through check_name() */
2112 status = check_name(conn, smb_fname->base_name);
2113 if (!NT_STATUS_IS_OK(status)) {
2114 goto fail;
2115 }
2116
2117 status = onefs_create_file_unixpath(
2118 conn, /* conn */
2119 req, /* req */
2120 smb_fname, /* fname */
2121 access_mask, /* access_mask */
2122 share_access, /* share_access */
2123 create_disposition, /* create_disposition*/
2124 create_options, /* create_options */
2125 file_attributes, /* file_attributes */
2126 oplock_request, /* oplock_request */
2127 allocation_size, /* allocation_size */
2128 sd, /* sd */
2129 ea_list, /* ea_list */
2130 &fsp, /* result */
2131 &info, /* pinfo */
2132 &fsp_data); /* psbuf */
2133
2134 if (!NT_STATUS_IS_OK(status)) {
2135 goto fail;
2136 }
2137
2138 DEBUG(10, ("onefs_create_file: info=%d\n", info));
2139
2140 /*
2141 * Setup private onefs_fsp_data. Currently the private data struct is
2142 * only used to store the oplock_callback_id so that when the file is
2143 * closed, the onefs_callback_record can be properly cleaned up in the
2144 * oplock_onefs sub-system.
2145 */
2146 if (fsp) {
2147 struct onefs_fsp_data *fsp_data_tmp = NULL;
2148 fsp_data_tmp = (struct onefs_fsp_data *)
2149 VFS_ADD_FSP_EXTENSION(handle, fsp, struct onefs_fsp_data,
2150 &destroy_onefs_fsp_data);
2151
2152 if (fsp_data_tmp == NULL) {
2153 status = NT_STATUS_NO_MEMORY;
2154 goto fail;
2155 }
2156
2157 *fsp_data_tmp = fsp_data;
2158 }
2159
2160 *result = fsp;
2161 if (pinfo != NULL) {
2162 *pinfo = info;
2163 }
2164 return NT_STATUS_OK;
2165
2166 fail:
2167 DEBUG(10, ("onefs_create_file: %s\n", nt_errstr(status)));
2168
2169 if (fsp != NULL) {
2170 close_file(req, fsp, ERROR_CLOSE);
2171 fsp = NULL;
2172 }
2173 return status;
2174 }
WIP