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