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