?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
smbd: replace CHECK_WRITE() macro with calls to check_any_access_fsp()
[Samba.git] / source3 / modules / vfs_fruit.c
blob49a1723864e18c6530d6eff987672e7d7e4652ce
1 /*
2 * OS X and Netatalk interoperability VFS module for Samba-3.x
3 *
4 * Copyright (C) Ralph Boehme, 2013, 2014
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21 #include "MacExtensions.h"
22 #include "smbd/smbd.h"
23 #include "system/filesys.h"
24 #include "lib/util/time.h"
25 #include "system/shmem.h"
26 #include "locking/proto.h"
27 #include "smbd/globals.h"
28 #include "messages.h"
29 #include "libcli/security/security.h"
30 #include "../libcli/smb/smb2_create_ctx.h"
31 #include "lib/util/tevent_ntstatus.h"
32 #include "lib/util/tevent_unix.h"
33 #include "offload_token.h"
34 #include "string_replace.h"
35 #include "hash_inode.h"
36 #include "lib/adouble.h"
37 #include "lib/util_macstreams.h"
38
39 /*
40 * Enhanced OS X and Netatalk compatibility
41 * ========================================
42 *
43 * This modules takes advantage of vfs_streams_xattr and
44 * vfs_catia. VFS modules vfs_fruit and vfs_streams_xattr must be
45 * loaded in the correct order:
46 *
47 * vfs modules = catia fruit streams_xattr
48 *
49 * The module intercepts the OS X special streams "AFP_AfpInfo" and
50 * "AFP_Resource" and handles them in a special way. All other named
51 * streams are deferred to vfs_streams_xattr.
52 *
53 * The OS X client maps all NTFS illegal characters to the Unicode
54 * private range. This module optionally stores the characters using
55 * their native ASCII encoding using vfs_catia. If you're not enabling
56 * this feature, you can skip catia from vfs modules.
57 *
58 * Finally, open modes are optionally checked against Netatalk AFP
59 * share modes.
60 *
61 * The "AFP_AfpInfo" named stream is a binary blob containing OS X
62 * extended metadata for files and directories. This module optionally
63 * reads and stores this metadata in a way compatible with Netatalk 3
64 * which stores the metadata in an EA "org.netatalk.metadata". Cf
65 * source3/include/MacExtensions.h for a description of the binary
66 * blobs content.
67 *
68 * The "AFP_Resource" named stream may be arbitrarily large, thus it
69 * can't be stored in an xattr on most filesystem. ZFS on Solaris is
70 * the only available filesystem where xattrs can be of any size and
71 * the OS supports using the file APIs for xattrs.
72 *
73 * The AFP_Resource stream is stored in an AppleDouble file prepending
74 * "._" to the filename. On Solaris with ZFS the stream is optionally
75 * stored in an EA "org.netatalk.resource".
76 *
77 *
78 * Extended Attributes
79 * ===================
80 *
81 * The OS X SMB client sends xattrs as ADS too. For xattr interop with
82 * other protocols you may want to adjust the xattr names the VFS
83 * module vfs_streams_xattr uses for storing ADS's. This defaults to
84 * user.DosStream.ADS_NAME:$DATA and can be changed by specifying
85 * these module parameters:
86 *
87 * streams_xattr:prefix = user.
88 * streams_xattr:store_stream_type = false
89 *
90 *
91 * TODO
92 * ====
93 *
94 * - log diagnostic if any needed VFS module is not loaded
95 * (eg with lp_vfs_objects())
96 * - add tests
97 */
98
99 static int vfs_fruit_debug_level = DBGC_VFS;
100
101 static struct global_fruit_config {
102 bool nego_aapl; /* client negotiated AAPL */
103
104 } global_fruit_config;
105
106 #undef DBGC_CLASS
107 #define DBGC_CLASS vfs_fruit_debug_level
108
109 #define FRUIT_PARAM_TYPE_NAME "fruit"
110
111 enum apple_fork {APPLE_FORK_DATA, APPLE_FORK_RSRC};
112
113 enum fruit_rsrc {FRUIT_RSRC_STREAM, FRUIT_RSRC_ADFILE, FRUIT_RSRC_XATTR};
114 enum fruit_meta {FRUIT_META_STREAM, FRUIT_META_NETATALK};
115 enum fruit_locking {FRUIT_LOCKING_NETATALK, FRUIT_LOCKING_NONE};
116 enum fruit_encoding {FRUIT_ENC_NATIVE, FRUIT_ENC_PRIVATE};
117
118 struct fruit_config_data {
119 enum fruit_rsrc rsrc;
120 enum fruit_meta meta;
121 enum fruit_locking locking;
122 enum fruit_encoding encoding;
123 bool use_aapl; /* config from smb.conf */
124 bool use_copyfile;
125 bool readdir_attr_enabled;
126 bool unix_info_enabled;
127 bool copyfile_enabled;
128 bool veto_appledouble;
129 bool posix_rename;
130 bool aapl_zero_file_id;
131 const char *model;
132 bool time_machine;
133 off_t time_machine_max_size;
134 bool convert_adouble;
135 bool wipe_intentionally_left_blank_rfork;
136 bool delete_empty_adfiles;
137
138 /*
139 * Additional options, all enabled by default,
140 * possibly useful for analyzing performance. The associated
141 * operations with each of them may be expensive, so having
142 * the chance to disable them individually gives a chance
143 * tweaking the setup for the particular usecase.
144 */
145 bool readdir_attr_rsize;
146 bool readdir_attr_finder_info;
147 bool readdir_attr_max_access;
148 /* Recursion guard. Will go away when we have STATX. */
149 bool in_openat_pathref_fsp;
150 };
151
152 static const struct enum_list fruit_rsrc[] = {
153 {FRUIT_RSRC_STREAM, "stream"}, /* pass on to vfs_streams_xattr */
154 {FRUIT_RSRC_ADFILE, "file"}, /* ._ AppleDouble file */
155 {FRUIT_RSRC_XATTR, "xattr"}, /* Netatalk compatible xattr (ZFS only) */
156 { -1, NULL}
157 };
158
159 static const struct enum_list fruit_meta[] = {
160 {FRUIT_META_STREAM, "stream"}, /* pass on to vfs_streams_xattr */
161 {FRUIT_META_NETATALK, "netatalk"}, /* Netatalk compatible xattr */
162 { -1, NULL}
163 };
164
165 static const struct enum_list fruit_locking[] = {
166 {FRUIT_LOCKING_NETATALK, "netatalk"}, /* synchronize locks with Netatalk */
167 {FRUIT_LOCKING_NONE, "none"},
168 { -1, NULL}
169 };
170
171 static const struct enum_list fruit_encoding[] = {
172 {FRUIT_ENC_NATIVE, "native"}, /* map unicode private chars to ASCII */
173 {FRUIT_ENC_PRIVATE, "private"}, /* keep unicode private chars */
174 { -1, NULL}
175 };
176
177 struct fio {
178 vfs_handle_struct *handle;
179 files_struct *fsp; /* backlink to itself */
180
181 /* tcon config handle */
182 struct fruit_config_data *config;
183
184 /* Backend fsp for AppleDouble file, can be NULL */
185 files_struct *ad_fsp;
186 /* link from adouble_open_from_base_fsp() to fio */
187 struct fio *real_fio;
188
189 /* Denote stream type, meta or rsrc */
190 adouble_type_t type;
191
192 /*
193 * AFP_AfpInfo stream created, but not written yet, thus still a fake
194 * pipe fd. This is set to true in fruit_open_meta if there was no
195 * existing stream but the caller requested O_CREAT. It is later set to
196 * false when we get a write on the stream that then does open and
197 * create the stream.
198 */
199 bool fake_fd;
200 int flags;
201 int mode;
202 };
203
204 /*****************************************************************************
205 * Helper functions
206 *****************************************************************************/
207
208 static struct adouble *ad_get_meta_fsp(TALLOC_CTX *ctx,
209 vfs_handle_struct *handle,
210 const struct smb_filename *smb_fname)
211 {
212 NTSTATUS status;
213 struct adouble *ad = NULL;
214 struct smb_filename *smb_fname_cp = NULL;
215 struct fruit_config_data *config = NULL;
216
217 if (smb_fname->fsp != NULL) {
218 return ad_get(ctx, handle, smb_fname, ADOUBLE_META);
219 }
220
221 SMB_VFS_HANDLE_GET_DATA(handle,
222 config,
223 struct fruit_config_data,
224 return NULL);
225
226 if (config->in_openat_pathref_fsp) {
227 return NULL;
228 }
229
230 smb_fname_cp = cp_smb_filename(ctx,
231 smb_fname);
232 if (smb_fname_cp == NULL) {
233 return NULL;
234 }
235 TALLOC_FREE(smb_fname_cp->stream_name);
236 config->in_openat_pathref_fsp = true;
237 status = openat_pathref_fsp(handle->conn->cwd_fsp,
238 smb_fname_cp);
239 config->in_openat_pathref_fsp = false;
240 if (!NT_STATUS_IS_OK(status)) {
241 TALLOC_FREE(smb_fname_cp);
242 return NULL;
243 }
244
245 ad = ad_get(ctx, handle, smb_fname_cp, ADOUBLE_META);
246 TALLOC_FREE(smb_fname_cp);
247 return ad;
248 }
249
250 static struct fio *fruit_get_complete_fio(vfs_handle_struct *handle,
251 files_struct *fsp)
252 {
253 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
254
255 if (fio == NULL) {
256 return NULL;
257 }
258
259 if (fio->real_fio != NULL) {
260 /*
261 * This is an fsp from adouble_open_from_base_fsp()
262 * we should just pass this to the next
263 * module.
264 */
265 return NULL;
266 }
267
268 return fio;
269 }
270
271 /**
272 * Initialize config struct from our smb.conf config parameters
273 **/
274 static int init_fruit_config(vfs_handle_struct *handle)
275 {
276 struct fruit_config_data *config;
277 int enumval = -1;
278 const char *tm_size_str = NULL;
279
280 config = talloc_zero(handle->conn, struct fruit_config_data);
281 if (!config) {
282 DEBUG(1, ("talloc_zero() failed\n"));
283 errno = ENOMEM;
284 return -1;
285 }
286
287 enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
288 "resource", fruit_rsrc, FRUIT_RSRC_ADFILE);
289 if (enumval == -1) {
290 DEBUG(1, ("value for %s: resource type unknown\n",
291 FRUIT_PARAM_TYPE_NAME));
292 return -1;
293 }
294 config->rsrc = (enum fruit_rsrc)enumval;
295
296 enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
297 "metadata", fruit_meta, FRUIT_META_NETATALK);
298 if (enumval == -1) {
299 DEBUG(1, ("value for %s: metadata type unknown\n",
300 FRUIT_PARAM_TYPE_NAME));
301 return -1;
302 }
303 config->meta = (enum fruit_meta)enumval;
304
305 enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
306 "locking", fruit_locking, FRUIT_LOCKING_NONE);
307 if (enumval == -1) {
308 DEBUG(1, ("value for %s: locking type unknown\n",
309 FRUIT_PARAM_TYPE_NAME));
310 return -1;
311 }
312 config->locking = (enum fruit_locking)enumval;
313
314 enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
315 "encoding", fruit_encoding, FRUIT_ENC_PRIVATE);
316 if (enumval == -1) {
317 DEBUG(1, ("value for %s: encoding type unknown\n",
318 FRUIT_PARAM_TYPE_NAME));
319 return -1;
320 }
321 config->encoding = (enum fruit_encoding)enumval;
322
323 if (config->rsrc == FRUIT_RSRC_ADFILE) {
324 config->veto_appledouble = lp_parm_bool(SNUM(handle->conn),
325 FRUIT_PARAM_TYPE_NAME,
326 "veto_appledouble",
327 true);
328 }
329
330 config->use_aapl = lp_parm_bool(
331 -1, FRUIT_PARAM_TYPE_NAME, "aapl", true);
332
333 config->time_machine = lp_parm_bool(
334 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME, "time machine", false);
335
336 config->unix_info_enabled = lp_parm_bool(
337 -1, FRUIT_PARAM_TYPE_NAME, "nfs_aces", true);
338
339 config->use_copyfile = lp_parm_bool(-1, FRUIT_PARAM_TYPE_NAME,
340 "copyfile", false);
341
342 config->posix_rename = lp_parm_bool(
343 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME, "posix_rename", true);
344
345 config->aapl_zero_file_id =
346 lp_parm_bool(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
347 "zero_file_id", true);
348
349 config->readdir_attr_rsize = lp_parm_bool(
350 SNUM(handle->conn), "readdir_attr", "aapl_rsize", true);
351
352 config->readdir_attr_finder_info = lp_parm_bool(
353 SNUM(handle->conn), "readdir_attr", "aapl_finder_info", true);
354
355 config->readdir_attr_max_access = lp_parm_bool(
356 SNUM(handle->conn), "readdir_attr", "aapl_max_access", true);
357
358 config->model = lp_parm_const_string(
359 -1, FRUIT_PARAM_TYPE_NAME, "model", "MacSamba");
360
361 tm_size_str = lp_parm_const_string(
362 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
363 "time machine max size", NULL);
364 if (tm_size_str != NULL) {
365 config->time_machine_max_size = conv_str_size(tm_size_str);
366 }
367
368 config->convert_adouble = lp_parm_bool(
369 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
370 "convert_adouble", true);
371
372 config->wipe_intentionally_left_blank_rfork = lp_parm_bool(
373 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
374 "wipe_intentionally_left_blank_rfork", false);
375
376 config->delete_empty_adfiles = lp_parm_bool(
377 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
378 "delete_empty_adfiles", false);
379
380 SMB_VFS_HANDLE_SET_DATA(handle, config,
381 NULL, struct fruit_config_data,
382 return -1);
383
384 return 0;
385 }
386
387 static bool add_fruit_stream(TALLOC_CTX *mem_ctx, unsigned int *num_streams,
388 struct stream_struct **streams,
389 const char *name, off_t size,
390 off_t alloc_size)
391 {
392 struct stream_struct *tmp;
393
394 tmp = talloc_realloc(mem_ctx, *streams, struct stream_struct,
395 (*num_streams)+1);
396 if (tmp == NULL) {
397 return false;
398 }
399
400 tmp[*num_streams].name = talloc_asprintf(tmp, "%s:$DATA", name);
401 if (tmp[*num_streams].name == NULL) {
402 return false;
403 }
404
405 tmp[*num_streams].size = size;
406 tmp[*num_streams].alloc_size = alloc_size;
407
408 *streams = tmp;
409 *num_streams += 1;
410 return true;
411 }
412
413 static bool filter_empty_rsrc_stream(unsigned int *num_streams,
414 struct stream_struct **streams)
415 {
416 struct stream_struct *tmp = *streams;
417 unsigned int i;
418
419 if (*num_streams == 0) {
420 return true;
421 }
422
423 for (i = 0; i < *num_streams; i++) {
424 if (strequal_m(tmp[i].name, AFPRESOURCE_STREAM)) {
425 break;
426 }
427 }
428
429 if (i == *num_streams) {
430 return true;
431 }
432
433 if (tmp[i].size > 0) {
434 return true;
435 }
436
437 TALLOC_FREE(tmp[i].name);
438 ARRAY_DEL_ELEMENT(tmp, i, *num_streams);
439 *num_streams -= 1;
440 return true;
441 }
442
443 static bool del_fruit_stream(TALLOC_CTX *mem_ctx, unsigned int *num_streams,
444 struct stream_struct **streams,
445 const char *name)
446 {
447 struct stream_struct *tmp = *streams;
448 unsigned int i;
449
450 if (*num_streams == 0) {
451 return true;
452 }
453
454 for (i = 0; i < *num_streams; i++) {
455 if (strequal_m(tmp[i].name, name)) {
456 break;
457 }
458 }
459
460 if (i == *num_streams) {
461 return true;
462 }
463
464 TALLOC_FREE(tmp[i].name);
465 ARRAY_DEL_ELEMENT(tmp, i, *num_streams);
466 *num_streams -= 1;
467 return true;
468 }
469
470 static bool ad_empty_finderinfo(const struct adouble *ad)
471 {
472 int cmp;
473 char emptybuf[ADEDLEN_FINDERI] = {0};
474 char *fi = NULL;
475
476 fi = ad_get_entry(ad, ADEID_FINDERI);
477 if (fi == NULL) {
478 DBG_ERR("Missing FinderInfo in struct adouble [%p]\n", ad);
479 return false;
480 }
481
482 cmp = memcmp(emptybuf, fi, ADEDLEN_FINDERI);
483 return (cmp == 0);
484 }
485
486 static bool ai_empty_finderinfo(const AfpInfo *ai)
487 {
488 int cmp;
489 char emptybuf[ADEDLEN_FINDERI] = {0};
490
491 cmp = memcmp(emptybuf, &ai->afpi_FinderInfo[0], ADEDLEN_FINDERI);
492 return (cmp == 0);
493 }
494
495 /**
496 * Update btime with btime from Netatalk
497 **/
498 static void update_btime(vfs_handle_struct *handle,
499 struct smb_filename *smb_fname)
500 {
501 uint32_t t;
502 struct timespec creation_time = {0};
503 struct adouble *ad;
504 struct fruit_config_data *config = NULL;
505
506 SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
507 return);
508
509 switch (config->meta) {
510 case FRUIT_META_STREAM:
511 return;
512 case FRUIT_META_NETATALK:
513 /* Handled below */
514 break;
515 default:
516 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
517 return;
518 }
519
520 ad = ad_get_meta_fsp(talloc_tos(), handle, smb_fname);
521 if (ad == NULL) {
522 return;
523 }
524 if (ad_getdate(ad, AD_DATE_UNIX | AD_DATE_CREATE, &t) != 0) {
525 TALLOC_FREE(ad);
526 return;
527 }
528 TALLOC_FREE(ad);
529
530 creation_time.tv_sec = convert_uint32_t_to_time_t(t);
531 update_stat_ex_create_time(&smb_fname->st, creation_time);
532
533 return;
534 }
535
536 /**
537 * Map an access mask to a Netatalk single byte byte range lock
538 **/
539 static off_t access_to_netatalk_brl(enum apple_fork fork_type,
540 uint32_t access_mask)
541 {
542 off_t offset;
543
544 switch (access_mask) {
545 case FILE_READ_DATA:
546 offset = AD_FILELOCK_OPEN_RD;
547 break;
548
549 case FILE_WRITE_DATA:
550 case FILE_APPEND_DATA:
551 offset = AD_FILELOCK_OPEN_WR;
552 break;
553
554 default:
555 offset = AD_FILELOCK_OPEN_NONE;
556 break;
557 }
558
559 if (fork_type == APPLE_FORK_RSRC) {
560 if (offset == AD_FILELOCK_OPEN_NONE) {
561 offset = AD_FILELOCK_RSRC_OPEN_NONE;
562 } else {
563 offset += 2;
564 }
565 }
566
567 return offset;
568 }
569
570 /**
571 * Map a deny mode to a Netatalk brl
572 **/
573 static off_t denymode_to_netatalk_brl(enum apple_fork fork_type,
574 uint32_t deny_mode)
575 {
576 off_t offset = 0;
577
578 switch (deny_mode) {
579 case DENY_READ:
580 offset = AD_FILELOCK_DENY_RD;
581 break;
582
583 case DENY_WRITE:
584 offset = AD_FILELOCK_DENY_WR;
585 break;
586
587 default:
588 smb_panic("denymode_to_netatalk_brl: bad deny mode\n");
589 }
590
591 if (fork_type == APPLE_FORK_RSRC) {
592 offset += 2;
593 }
594
595 return offset;
596 }
597
598 /**
599 * Call fcntl() with an exclusive F_GETLK request in order to
600 * determine if there's an existing shared lock
601 *
602 * @return true if the requested lock was found or any error occurred
603 * false if the lock was not found
604 **/
605 static bool test_netatalk_lock(files_struct *fsp, off_t in_offset)
606 {
607 bool result;
608 off_t offset = in_offset;
609 off_t len = 1;
610 int type = F_WRLCK;
611 pid_t pid = 0;
612
613 result = SMB_VFS_GETLOCK(fsp, &offset, &len, &type, &pid);
614 if (result == false) {
615 return true;
616 }
617
618 if (type != F_UNLCK) {
619 return true;
620 }
621
622 return false;
623 }
624
625 static NTSTATUS fruit_check_access(vfs_handle_struct *handle,
626 files_struct *fsp,
627 uint32_t access_mask,
628 uint32_t share_mode)
629 {
630 NTSTATUS status = NT_STATUS_OK;
631 off_t off;
632 bool share_for_read = (share_mode & FILE_SHARE_READ);
633 bool share_for_write = (share_mode & FILE_SHARE_WRITE);
634 bool netatalk_already_open_for_reading = false;
635 bool netatalk_already_open_for_writing = false;
636 bool netatalk_already_open_with_deny_read = false;
637 bool netatalk_already_open_with_deny_write = false;
638 struct GUID req_guid = GUID_random();
639
640 /* FIXME: hardcoded data fork, add resource fork */
641 enum apple_fork fork_type = APPLE_FORK_DATA;
642
643 DBG_DEBUG("fruit_check_access: %s, am: %s/%s, sm: 0x%x\n",
644 fsp_str_dbg(fsp),
645 access_mask & FILE_READ_DATA ? "READ" :"-",
646 access_mask & FILE_WRITE_DATA ? "WRITE" : "-",
647 share_mode);
648
649 if (fsp_get_io_fd(fsp) == -1) {
650 return NT_STATUS_OK;
651 }
652
653 /* Read NetATalk opens and deny modes on the file. */
654 netatalk_already_open_for_reading = test_netatalk_lock(fsp,
655 access_to_netatalk_brl(fork_type,
656 FILE_READ_DATA));
657
658 netatalk_already_open_with_deny_read = test_netatalk_lock(fsp,
659 denymode_to_netatalk_brl(fork_type,
660 DENY_READ));
661
662 netatalk_already_open_for_writing = test_netatalk_lock(fsp,
663 access_to_netatalk_brl(fork_type,
664 FILE_WRITE_DATA));
665
666 netatalk_already_open_with_deny_write = test_netatalk_lock(fsp,
667 denymode_to_netatalk_brl(fork_type,
668 DENY_WRITE));
669
670 /* If there are any conflicts - sharing violation. */
671 if ((access_mask & FILE_READ_DATA) &&
672 netatalk_already_open_with_deny_read) {
673 return NT_STATUS_SHARING_VIOLATION;
674 }
675
676 if (!share_for_read &&
677 netatalk_already_open_for_reading) {
678 return NT_STATUS_SHARING_VIOLATION;
679 }
680
681 if ((access_mask & FILE_WRITE_DATA) &&
682 netatalk_already_open_with_deny_write) {
683 return NT_STATUS_SHARING_VIOLATION;
684 }
685
686 if (!share_for_write &&
687 netatalk_already_open_for_writing) {
688 return NT_STATUS_SHARING_VIOLATION;
689 }
690
691 if (!(access_mask & FILE_READ_DATA)) {
692 /*
693 * Nothing we can do here, we need read access
694 * to set locks.
695 */
696 return NT_STATUS_OK;
697 }
698
699 /* Set NetAtalk locks matching our access */
700 if (access_mask & FILE_READ_DATA) {
701 off = access_to_netatalk_brl(fork_type, FILE_READ_DATA);
702 req_guid.time_hi_and_version = __LINE__;
703 status = do_lock(
704 fsp,
705 talloc_tos(),
706 &req_guid,
707 fsp->op->global->open_persistent_id,
708 1,
709 off,
710 READ_LOCK,
711 POSIX_LOCK,
712 NULL,
713 NULL);
714
715 if (!NT_STATUS_IS_OK(status)) {
716 return status;
717 }
718 }
719
720 if (!share_for_read) {
721 off = denymode_to_netatalk_brl(fork_type, DENY_READ);
722 req_guid.time_hi_and_version = __LINE__;
723 status = do_lock(
724 fsp,
725 talloc_tos(),
726 &req_guid,
727 fsp->op->global->open_persistent_id,
728 1,
729 off,
730 READ_LOCK,
731 POSIX_LOCK,
732 NULL,
733 NULL);
734
735 if (!NT_STATUS_IS_OK(status)) {
736 return status;
737 }
738 }
739
740 if (access_mask & FILE_WRITE_DATA) {
741 off = access_to_netatalk_brl(fork_type, FILE_WRITE_DATA);
742 req_guid.time_hi_and_version = __LINE__;
743 status = do_lock(
744 fsp,
745 talloc_tos(),
746 &req_guid,
747 fsp->op->global->open_persistent_id,
748 1,
749 off,
750 READ_LOCK,
751 POSIX_LOCK,
752 NULL,
753 NULL);
754
755 if (!NT_STATUS_IS_OK(status)) {
756 return status;
757 }
758 }
759
760 if (!share_for_write) {
761 off = denymode_to_netatalk_brl(fork_type, DENY_WRITE);
762 req_guid.time_hi_and_version = __LINE__;
763 status = do_lock(
764 fsp,
765 talloc_tos(),
766 &req_guid,
767 fsp->op->global->open_persistent_id,
768 1,
769 off,
770 READ_LOCK,
771 POSIX_LOCK,
772 NULL,
773 NULL);
774
775 if (!NT_STATUS_IS_OK(status)) {
776 return status;
777 }
778 }
779
780 return NT_STATUS_OK;
781 }
782
783 static NTSTATUS check_aapl(vfs_handle_struct *handle,
784 struct smb_request *req,
785 const struct smb2_create_blobs *in_context_blobs,
786 struct smb2_create_blobs *out_context_blobs)
787 {
788 struct fruit_config_data *config;
789 NTSTATUS status;
790 struct smb2_create_blob *aapl = NULL;
791 uint32_t cmd;
792 bool ok;
793 uint8_t p[16];
794 DATA_BLOB blob = data_blob_talloc(req, NULL, 0);
795 uint64_t req_bitmap, client_caps;
796 uint64_t server_caps = SMB2_CRTCTX_AAPL_UNIX_BASED;
797 smb_ucs2_t *model;
798 size_t modellen;
799
800 SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
801 return NT_STATUS_UNSUCCESSFUL);
802
803 if (!config->use_aapl
804 || in_context_blobs == NULL
805 || out_context_blobs == NULL) {
806 return NT_STATUS_OK;
807 }
808
809 aapl = smb2_create_blob_find(in_context_blobs,
810 SMB2_CREATE_TAG_AAPL);
811 if (aapl == NULL) {
812 return NT_STATUS_OK;
813 }
814
815 if (aapl->data.length != 24) {
816 DEBUG(1, ("unexpected AAPL ctxt length: %ju\n",
817 (uintmax_t)aapl->data.length));
818 return NT_STATUS_INVALID_PARAMETER;
819 }
820
821 cmd = IVAL(aapl->data.data, 0);
822 if (cmd != SMB2_CRTCTX_AAPL_SERVER_QUERY) {
823 DEBUG(1, ("unsupported AAPL cmd: %d\n", cmd));
824 return NT_STATUS_INVALID_PARAMETER;
825 }
826
827 req_bitmap = BVAL(aapl->data.data, 8);
828 client_caps = BVAL(aapl->data.data, 16);
829
830 SIVAL(p, 0, SMB2_CRTCTX_AAPL_SERVER_QUERY);
831 SIVAL(p, 4, 0);
832 SBVAL(p, 8, req_bitmap);
833 ok = data_blob_append(req, &blob, p, 16);
834 if (!ok) {
835 return NT_STATUS_UNSUCCESSFUL;
836 }
837
838 if (req_bitmap & SMB2_CRTCTX_AAPL_SERVER_CAPS) {
839 if ((client_caps & SMB2_CRTCTX_AAPL_SUPPORTS_READ_DIR_ATTR) &&
840 (handle->conn->fs_capabilities & FILE_NAMED_STREAMS)) {
841 server_caps |= SMB2_CRTCTX_AAPL_SUPPORTS_READ_DIR_ATTR;
842 config->readdir_attr_enabled = true;
843 }
844
845 if (config->use_copyfile) {
846 server_caps |= SMB2_CRTCTX_AAPL_SUPPORTS_OSX_COPYFILE;
847 config->copyfile_enabled = true;
848 }
849
850 /*
851 * The client doesn't set the flag, so we can't check
852 * for it and just set it unconditionally
853 */
854 if (config->unix_info_enabled) {
855 server_caps |= SMB2_CRTCTX_AAPL_SUPPORTS_NFS_ACE;
856 }
857
858 SBVAL(p, 0, server_caps);
859 ok = data_blob_append(req, &blob, p, 8);
860 if (!ok) {
861 return NT_STATUS_UNSUCCESSFUL;
862 }
863 }
864
865 if (req_bitmap & SMB2_CRTCTX_AAPL_VOLUME_CAPS) {
866 int val = lp_case_sensitive(SNUM(handle->conn));
867 uint64_t caps = 0;
868
869 switch (val) {
870 case Auto:
871 break;
872
873 case True:
874 caps |= SMB2_CRTCTX_AAPL_CASE_SENSITIVE;
875 break;
876
877 default:
878 break;
879 }
880
881 if (config->time_machine) {
882 caps |= SMB2_CRTCTX_AAPL_FULL_SYNC;
883 }
884
885 SBVAL(p, 0, caps);
886
887 ok = data_blob_append(req, &blob, p, 8);
888 if (!ok) {
889 return NT_STATUS_UNSUCCESSFUL;
890 }
891 }
892
893 if (req_bitmap & SMB2_CRTCTX_AAPL_MODEL_INFO) {
894 ok = convert_string_talloc(req,
895 CH_UNIX, CH_UTF16LE,
896 config->model, strlen(config->model),
897 &model, &modellen);
898 if (!ok) {
899 return NT_STATUS_UNSUCCESSFUL;
900 }
901
902 SIVAL(p, 0, 0);
903 SIVAL(p + 4, 0, modellen);
904 ok = data_blob_append(req, &blob, p, 8);
905 if (!ok) {
906 talloc_free(model);
907 return NT_STATUS_UNSUCCESSFUL;
908 }
909
910 ok = data_blob_append(req, &blob, model, modellen);
911 talloc_free(model);
912 if (!ok) {
913 return NT_STATUS_UNSUCCESSFUL;
914 }
915 }
916
917 status = smb2_create_blob_add(out_context_blobs,
918 out_context_blobs,
919 SMB2_CREATE_TAG_AAPL,
920 blob);
921 if (NT_STATUS_IS_OK(status)) {
922 global_fruit_config.nego_aapl = true;
923 }
924
925 return status;
926 }
927
928 static bool readdir_attr_meta_finderi_stream(
929 struct vfs_handle_struct *handle,
930 const struct smb_filename *smb_fname,
931 AfpInfo *ai)
932 {
933 struct smb_filename *stream_name = NULL;
934 files_struct *fsp = NULL;
935 ssize_t nread;
936 NTSTATUS status;
937 bool ok;
938 uint8_t buf[AFP_INFO_SIZE];
939
940 status = synthetic_pathref(talloc_tos(),
941 handle->conn->cwd_fsp,
942 smb_fname->base_name,
943 AFPINFO_STREAM_NAME,
944 NULL,
945 smb_fname->twrp,
946 smb_fname->flags,
947 &stream_name);
948 if (!NT_STATUS_IS_OK(status)) {
949 return false;
950 }
951
952 status = SMB_VFS_CREATE_FILE(
953 handle->conn, /* conn */
954 NULL, /* req */
955 NULL, /* dirfsp */
956 stream_name, /* fname */
957 FILE_READ_DATA, /* access_mask */
958 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
959 FILE_SHARE_DELETE),
960 FILE_OPEN, /* create_disposition*/
961 0, /* create_options */
962 0, /* file_attributes */
963 INTERNAL_OPEN_ONLY, /* oplock_request */
964 NULL, /* lease */
965 0, /* allocation_size */
966 0, /* private_flags */
967 NULL, /* sd */
968 NULL, /* ea_list */
969 &fsp, /* result */
970 NULL, /* pinfo */
971 NULL, NULL); /* create context */
972
973 TALLOC_FREE(stream_name);
974
975 if (!NT_STATUS_IS_OK(status)) {
976 return false;
977 }
978
979 nread = SMB_VFS_PREAD(fsp, &buf[0], AFP_INFO_SIZE, 0);
980 if (nread != AFP_INFO_SIZE) {
981 DBG_ERR("short read [%s] [%zd/%d]\n",
982 smb_fname_str_dbg(stream_name), nread, AFP_INFO_SIZE);
983 ok = false;
984 goto fail;
985 }
986
987 memcpy(&ai->afpi_FinderInfo[0], &buf[AFP_OFF_FinderInfo],
988 AFP_FinderSize);
989
990 ok = true;
991
992 fail:
993 if (fsp != NULL) {
994 close_file_free(NULL, &fsp, NORMAL_CLOSE);
995 }
996
997 return ok;
998 }
999
1000 static bool readdir_attr_meta_finderi_netatalk(
1001 struct vfs_handle_struct *handle,
1002 const struct smb_filename *smb_fname,
1003 AfpInfo *ai)
1004 {
1005 struct adouble *ad = NULL;
1006 char *p = NULL;
1007
1008 ad = ad_get_meta_fsp(talloc_tos(), handle, smb_fname);
1009 if (ad == NULL) {
1010 return false;
1011 }
1012
1013 p = ad_get_entry(ad, ADEID_FINDERI);
1014 if (p == NULL) {
1015 DBG_ERR("No ADEID_FINDERI for [%s]\n", smb_fname->base_name);
1016 TALLOC_FREE(ad);
1017 return false;
1018 }
1019
1020 memcpy(&ai->afpi_FinderInfo[0], p, AFP_FinderSize);
1021 TALLOC_FREE(ad);
1022 return true;
1023 }
1024
1025 static bool readdir_attr_meta_finderi(struct vfs_handle_struct *handle,
1026 const struct smb_filename *smb_fname,
1027 struct readdir_attr_data *attr_data)
1028 {
1029 struct fruit_config_data *config = NULL;
1030 uint32_t date_added;
1031 AfpInfo ai = {0};
1032 bool ok;
1033
1034 SMB_VFS_HANDLE_GET_DATA(handle, config,
1035 struct fruit_config_data,
1036 return false);
1037
1038 switch (config->meta) {
1039 case FRUIT_META_NETATALK:
1040 ok = readdir_attr_meta_finderi_netatalk(
1041 handle, smb_fname, &ai);
1042 break;
1043
1044 case FRUIT_META_STREAM:
1045 ok = readdir_attr_meta_finderi_stream(
1046 handle, smb_fname, &ai);
1047 break;
1048
1049 default:
1050 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
1051 return false;
1052 }
1053
1054 if (!ok) {
1055 /* Don't bother with errors, it's likely ENOENT */
1056 return true;
1057 }
1058
1059 if (S_ISREG(smb_fname->st.st_ex_mode)) {
1060 /* finder_type */
1061 memcpy(&attr_data->attr_data.aapl.finder_info[0],
1062 &ai.afpi_FinderInfo[0], 4);
1063
1064 /* finder_creator */
1065 memcpy(&attr_data->attr_data.aapl.finder_info[0] + 4,
1066 &ai.afpi_FinderInfo[4], 4);
1067 }
1068
1069 /* finder_flags */
1070 memcpy(&attr_data->attr_data.aapl.finder_info[0] + 8,
1071 &ai.afpi_FinderInfo[8], 2);
1072
1073 /* finder_ext_flags */
1074 memcpy(&attr_data->attr_data.aapl.finder_info[0] + 10,
1075 &ai.afpi_FinderInfo[24], 2);
1076
1077 /* creation date */
1078 date_added = convert_time_t_to_uint32_t(
1079 smb_fname->st.st_ex_btime.tv_sec - AD_DATE_DELTA);
1080
1081 RSIVAL(&attr_data->attr_data.aapl.finder_info[0], 12, date_added);
1082
1083 return true;
1084 }
1085
1086 static uint64_t readdir_attr_rfork_size_adouble(
1087 struct vfs_handle_struct *handle,
1088 const struct smb_filename *smb_fname)
1089 {
1090 struct adouble *ad = NULL;
1091 uint64_t rfork_size;
1092
1093 ad = ad_get(talloc_tos(), handle, smb_fname,
1094 ADOUBLE_RSRC);
1095 if (ad == NULL) {
1096 return 0;
1097 }
1098
1099 rfork_size = ad_getentrylen(ad, ADEID_RFORK);
1100 TALLOC_FREE(ad);
1101
1102 return rfork_size;
1103 }
1104
1105 static uint64_t readdir_attr_rfork_size_stream(
1106 struct vfs_handle_struct *handle,
1107 const struct smb_filename *smb_fname)
1108 {
1109 struct smb_filename *stream_name = NULL;
1110 int ret;
1111 uint64_t rfork_size;
1112
1113 stream_name = synthetic_smb_fname(talloc_tos(),
1114 smb_fname->base_name,
1115 AFPRESOURCE_STREAM_NAME,
1116 NULL,
1117 smb_fname->twrp,
1118 0);
1119 if (stream_name == NULL) {
1120 return 0;
1121 }
1122
1123 ret = SMB_VFS_STAT(handle->conn, stream_name);
1124 if (ret != 0) {
1125 TALLOC_FREE(stream_name);
1126 return 0;
1127 }
1128
1129 rfork_size = stream_name->st.st_ex_size;
1130 TALLOC_FREE(stream_name);
1131
1132 return rfork_size;
1133 }
1134
1135 static uint64_t readdir_attr_rfork_size(struct vfs_handle_struct *handle,
1136 const struct smb_filename *smb_fname)
1137 {
1138 struct fruit_config_data *config = NULL;
1139 uint64_t rfork_size;
1140
1141 SMB_VFS_HANDLE_GET_DATA(handle, config,
1142 struct fruit_config_data,
1143 return 0);
1144
1145 switch (config->rsrc) {
1146 case FRUIT_RSRC_ADFILE:
1147 rfork_size = readdir_attr_rfork_size_adouble(handle,
1148 smb_fname);
1149 break;
1150
1151 case FRUIT_RSRC_XATTR:
1152 case FRUIT_RSRC_STREAM:
1153 rfork_size = readdir_attr_rfork_size_stream(handle,
1154 smb_fname);
1155 break;
1156
1157 default:
1158 DBG_ERR("Unexpected rsrc config [%d]\n", config->rsrc);
1159 rfork_size = 0;
1160 break;
1161 }
1162
1163 return rfork_size;
1164 }
1165
1166 static NTSTATUS readdir_attr_macmeta(struct vfs_handle_struct *handle,
1167 const struct smb_filename *smb_fname,
1168 struct readdir_attr_data *attr_data)
1169 {
1170 NTSTATUS status = NT_STATUS_OK;
1171 struct fruit_config_data *config = NULL;
1172 bool ok;
1173
1174 SMB_VFS_HANDLE_GET_DATA(handle, config,
1175 struct fruit_config_data,
1176 return NT_STATUS_UNSUCCESSFUL);
1177
1178
1179 /* Ensure we return a default value in the creation_date field */
1180 RSIVAL(&attr_data->attr_data.aapl.finder_info, 12, AD_DATE_START);
1181
1182 /*
1183 * Resource fork length
1184 */
1185
1186 if (config->readdir_attr_rsize) {
1187 uint64_t rfork_size;
1188
1189 rfork_size = readdir_attr_rfork_size(handle, smb_fname);
1190 attr_data->attr_data.aapl.rfork_size = rfork_size;
1191 }
1192
1193 /*
1194 * FinderInfo
1195 */
1196
1197 if (config->readdir_attr_finder_info) {
1198 ok = readdir_attr_meta_finderi(handle, smb_fname, attr_data);
1199 if (!ok) {
1200 status = NT_STATUS_INTERNAL_ERROR;
1201 }
1202 }
1203
1204 return status;
1205 }
1206
1207 static NTSTATUS remove_virtual_nfs_aces(struct security_descriptor *psd)
1208 {
1209 NTSTATUS status;
1210 uint32_t i;
1211
1212 if (psd->dacl == NULL) {
1213 return NT_STATUS_OK;
1214 }
1215
1216 for (i = 0; i < psd->dacl->num_aces; i++) {
1217 /* MS NFS style mode/uid/gid */
1218 int cmp = dom_sid_compare_domain(
1219 &global_sid_Unix_NFS,
1220 &psd->dacl->aces[i].trustee);
1221 if (cmp != 0) {
1222 /* Normal ACE entry. */
1223 continue;
1224 }
1225
1226 /*
1227 * security_descriptor_dacl_del()
1228 * *must* return NT_STATUS_OK as we know
1229 * we have something to remove.
1230 */
1231
1232 status = security_descriptor_dacl_del(psd,
1233 &psd->dacl->aces[i].trustee);
1234 if (!NT_STATUS_IS_OK(status)) {
1235 DBG_WARNING("failed to remove MS NFS style ACE: %s\n",
1236 nt_errstr(status));
1237 return status;
1238 }
1239
1240 /*
1241 * security_descriptor_dacl_del() may delete more
1242 * then one entry subsequent to this one if the
1243 * SID matches, but we only need to ensure that
1244 * we stay looking at the same element in the array.
1245 */
1246 i--;
1247 }
1248 return NT_STATUS_OK;
1249 }
1250
1251 /* Search MS NFS style ACE with UNIX mode */
1252 static NTSTATUS check_ms_nfs(vfs_handle_struct *handle,
1253 files_struct *fsp,
1254 struct security_descriptor *psd,
1255 mode_t *pmode,
1256 bool *pdo_chmod)
1257 {
1258 uint32_t i;
1259 struct fruit_config_data *config = NULL;
1260
1261 *pdo_chmod = false;
1262
1263 SMB_VFS_HANDLE_GET_DATA(handle, config,
1264 struct fruit_config_data,
1265 return NT_STATUS_UNSUCCESSFUL);
1266
1267 if (!global_fruit_config.nego_aapl) {
1268 return NT_STATUS_OK;
1269 }
1270 if (psd->dacl == NULL || !config->unix_info_enabled) {
1271 return NT_STATUS_OK;
1272 }
1273
1274 for (i = 0; i < psd->dacl->num_aces; i++) {
1275 if (dom_sid_compare_domain(
1276 &global_sid_Unix_NFS_Mode,
1277 &psd->dacl->aces[i].trustee) == 0) {
1278 *pmode = (mode_t)psd->dacl->aces[i].trustee.sub_auths[2];
1279 *pmode &= (S_IRWXU | S_IRWXG | S_IRWXO);
1280 *pdo_chmod = true;
1281
1282 DEBUG(10, ("MS NFS chmod request %s, %04o\n",
1283 fsp_str_dbg(fsp), (unsigned)(*pmode)));
1284 break;
1285 }
1286 }
1287
1288 /*
1289 * Remove any incoming virtual ACE entries generated by
1290 * fruit_fget_nt_acl().
1291 */
1292
1293 return remove_virtual_nfs_aces(psd);
1294 }
1295
1296 /****************************************************************************
1297 * VFS ops
1298 ****************************************************************************/
1299
1300 static int fruit_connect(vfs_handle_struct *handle,
1301 const char *service,
1302 const char *user)
1303 {
1304 int rc;
1305 char *list = NULL, *newlist = NULL;
1306 struct fruit_config_data *config;
1307 const struct loadparm_substitution *lp_sub =
1308 loadparm_s3_global_substitution();
1309
1310 DEBUG(10, ("fruit_connect\n"));
1311
1312 rc = SMB_VFS_NEXT_CONNECT(handle, service, user);
1313 if (rc < 0) {
1314 return rc;
1315 }
1316
1317 rc = init_fruit_config(handle);
1318 if (rc != 0) {
1319 return rc;
1320 }
1321
1322 SMB_VFS_HANDLE_GET_DATA(handle, config,
1323 struct fruit_config_data, return -1);
1324
1325 if (config->veto_appledouble) {
1326 list = lp_veto_files(talloc_tos(), lp_sub, SNUM(handle->conn));
1327
1328 if (list) {
1329 if (strstr(list, "/" ADOUBLE_NAME_PREFIX "*/") == NULL) {
1330 newlist = talloc_asprintf(
1331 list,
1332 "%s/" ADOUBLE_NAME_PREFIX "*/",
1333 list);
1334 lp_do_parameter(SNUM(handle->conn),
1335 "veto files",
1336 newlist);
1337 }
1338 } else {
1339 lp_do_parameter(SNUM(handle->conn),
1340 "veto files",
1341 "/" ADOUBLE_NAME_PREFIX "*/");
1342 }
1343
1344 TALLOC_FREE(list);
1345 }
1346
1347 if (config->encoding == FRUIT_ENC_NATIVE) {
1348 lp_do_parameter(SNUM(handle->conn),
1349 "catia:mappings",
1350 macos_string_replace_map);
1351 }
1352
1353 if (config->time_machine) {
1354 DBG_NOTICE("Enabling durable handles for Time Machine "
1355 "support on [%s]\n", service);
1356 lp_do_parameter(SNUM(handle->conn), "durable handles", "yes");
1357 lp_do_parameter(SNUM(handle->conn), "kernel oplocks", "no");
1358 lp_do_parameter(SNUM(handle->conn), "kernel share modes", "no");
1359 if (!lp_strict_sync(SNUM(handle->conn))) {
1360 DBG_WARNING("Time Machine without strict sync is not "
1361 "recommended!\n");
1362 }
1363 lp_do_parameter(SNUM(handle->conn), "posix locking", "no");
1364 }
1365
1366 return rc;
1367 }
1368
1369 static void fio_ref_destroy_fn(void *p_data)
1370 {
1371 struct fio *ref_fio = (struct fio *)p_data;
1372 if (ref_fio->real_fio != NULL) {
1373 SMB_ASSERT(ref_fio->real_fio->ad_fsp == ref_fio->fsp);
1374 ref_fio->real_fio->ad_fsp = NULL;
1375 ref_fio->real_fio = NULL;
1376 }
1377 }
1378
1379 static void fio_close_ad_fsp(struct fio *fio)
1380 {
1381 if (fio->ad_fsp != NULL) {
1382 fd_close(fio->ad_fsp);
1383 file_free(NULL, fio->ad_fsp);
1384 /* fio_ref_destroy_fn() should have cleared this */
1385 SMB_ASSERT(fio->ad_fsp == NULL);
1386 }
1387 }
1388
1389 static void fio_destroy_fn(void *p_data)
1390 {
1391 struct fio *fio = (struct fio *)p_data;
1392 fio_close_ad_fsp(fio);
1393 }
1394
1395 static int fruit_open_meta_stream(vfs_handle_struct *handle,
1396 const struct files_struct *dirfsp,
1397 const struct smb_filename *smb_fname,
1398 files_struct *fsp,
1399 int flags,
1400 mode_t mode)
1401 {
1402 struct fruit_config_data *config = NULL;
1403 struct fio *fio = NULL;
1404 struct vfs_open_how how = {
1405 .flags = flags & ~O_CREAT,
1406 .mode = mode,
1407 };
1408 int fd;
1409
1410 DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
1411
1412 SMB_VFS_HANDLE_GET_DATA(handle, config,
1413 struct fruit_config_data, return -1);
1414
1415 fio = VFS_ADD_FSP_EXTENSION(handle, fsp, struct fio, fio_destroy_fn);
1416 fio->handle = handle;
1417 fio->fsp = fsp;
1418 fio->type = ADOUBLE_META;
1419 fio->config = config;
1420
1421 fd = SMB_VFS_NEXT_OPENAT(handle,
1422 dirfsp,
1423 smb_fname,
1424 fsp,
1425 &how);
1426 if (fd != -1) {
1427 return fd;
1428 }
1429
1430 if (!(flags & O_CREAT)) {
1431 VFS_REMOVE_FSP_EXTENSION(handle, fsp);
1432 return -1;
1433 }
1434
1435 fd = vfs_fake_fd();
1436 if (fd == -1) {
1437 VFS_REMOVE_FSP_EXTENSION(handle, fsp);
1438 return -1;
1439 }
1440
1441 fio->fake_fd = true;
1442 fio->flags = flags;
1443 fio->mode = mode;
1444
1445 return fd;
1446 }
1447
1448 static int fruit_open_meta_netatalk(vfs_handle_struct *handle,
1449 const struct files_struct *dirfsp,
1450 const struct smb_filename *smb_fname,
1451 files_struct *fsp,
1452 int flags,
1453 mode_t mode)
1454 {
1455 struct fruit_config_data *config = NULL;
1456 struct fio *fio = NULL;
1457 struct adouble *ad = NULL;
1458 bool meta_exists = false;
1459 int fd;
1460
1461 DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
1462
1463 /*
1464 * We know this is a stream open, so fsp->base_fsp must
1465 * already be open.
1466 */
1467 SMB_ASSERT(fsp_is_alternate_stream(fsp));
1468 SMB_ASSERT(fsp->base_fsp->fsp_name->fsp == fsp->base_fsp);
1469
1470 ad = ad_get(talloc_tos(), handle, fsp->base_fsp->fsp_name, ADOUBLE_META);
1471 if (ad != NULL) {
1472 meta_exists = true;
1473 }
1474
1475 TALLOC_FREE(ad);
1476
1477 if (!meta_exists && !(flags & O_CREAT)) {
1478 errno = ENOENT;
1479 return -1;
1480 }
1481
1482 fd = vfs_fake_fd();
1483 if (fd == -1) {
1484 return -1;
1485 }
1486
1487 SMB_VFS_HANDLE_GET_DATA(handle, config,
1488 struct fruit_config_data, return -1);
1489
1490 fio = VFS_ADD_FSP_EXTENSION(handle, fsp, struct fio, fio_destroy_fn);
1491 fio->handle = handle;
1492 fio->fsp = fsp;
1493 fio->type = ADOUBLE_META;
1494 fio->config = config;
1495 fio->fake_fd = true;
1496 fio->flags = flags;
1497 fio->mode = mode;
1498
1499 return fd;
1500 }
1501
1502 static int fruit_open_meta(vfs_handle_struct *handle,
1503 const struct files_struct *dirfsp,
1504 const struct smb_filename *smb_fname,
1505 files_struct *fsp, int flags, mode_t mode)
1506 {
1507 int fd;
1508 struct fruit_config_data *config = NULL;
1509
1510 DBG_DEBUG("path [%s]\n", smb_fname_str_dbg(smb_fname));
1511
1512 SMB_VFS_HANDLE_GET_DATA(handle, config,
1513 struct fruit_config_data, return -1);
1514
1515 switch (config->meta) {
1516 case FRUIT_META_STREAM:
1517 fd = fruit_open_meta_stream(handle, dirfsp, smb_fname,
1518 fsp, flags, mode);
1519 break;
1520
1521 case FRUIT_META_NETATALK:
1522 fd = fruit_open_meta_netatalk(handle, dirfsp, smb_fname,
1523 fsp, flags, mode);
1524 break;
1525
1526 default:
1527 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
1528 return -1;
1529 }
1530
1531 DBG_DEBUG("path [%s] fd [%d]\n", smb_fname_str_dbg(smb_fname), fd);
1532
1533 return fd;
1534 }
1535
1536 static int fruit_open_rsrc_adouble(vfs_handle_struct *handle,
1537 const struct files_struct *dirfsp,
1538 const struct smb_filename *smb_fname,
1539 files_struct *fsp,
1540 int flags,
1541 mode_t mode)
1542 {
1543 int rc = 0;
1544 struct fruit_config_data *config = NULL;
1545 struct files_struct *ad_fsp = NULL;
1546 struct fio *fio = NULL;
1547 struct fio *ref_fio = NULL;
1548 NTSTATUS status;
1549 int fd = -1;
1550
1551 SMB_VFS_HANDLE_GET_DATA(handle, config,
1552 struct fruit_config_data, return -1);
1553
1554 if ((!(flags & O_CREAT)) &&
1555 S_ISDIR(fsp->base_fsp->fsp_name->st.st_ex_mode))
1556 {
1557 /* sorry, but directories don't have a resource fork */
1558 errno = ENOENT;
1559 rc = -1;
1560 goto exit;
1561 }
1562
1563 /*
1564 * We return a fake_fd to the vfs modules above,
1565 * while we open an internal backend fsp for the
1566 * '._' file for the next vfs modules.
1567 *
1568 * Note that adouble_open_from_base_fsp() recurses
1569 * into fruit_openat(), but it'll just pass to
1570 * the next module as just opens a flat file on
1571 * disk.
1572 */
1573
1574 fd = vfs_fake_fd();
1575 if (fd == -1) {
1576 rc = fd;
1577 goto exit;
1578 }
1579
1580 status = adouble_open_from_base_fsp(fsp->conn->cwd_fsp,
1581 fsp->base_fsp,
1582 ADOUBLE_RSRC,
1583 flags,
1584 mode,
1585 &ad_fsp);
1586 if (!NT_STATUS_IS_OK(status)) {
1587 errno = map_errno_from_nt_status(status);
1588 rc = -1;
1589 goto exit;
1590 }
1591
1592 /*
1593 * Now we need to glue both handles together,
1594 * so that they automatically detach each other
1595 * on close.
1596 */
1597 fio = fruit_get_complete_fio(handle, fsp);
1598 if (fio == NULL) {
1599 DBG_ERR("fio=NULL for [%s]\n", fsp_str_dbg(fsp));
1600 errno = EBADF;
1601 rc = -1;
1602 goto exit;
1603 }
1604
1605 ref_fio = VFS_ADD_FSP_EXTENSION(handle, ad_fsp,
1606 struct fio,
1607 fio_ref_destroy_fn);
1608 if (ref_fio == NULL) {
1609 int saved_errno = errno;
1610 fd_close(ad_fsp);
1611 file_free(NULL, ad_fsp);
1612 ad_fsp = NULL;
1613 errno = saved_errno;
1614 rc = -1;
1615 goto exit;
1616 }
1617
1618 SMB_ASSERT(ref_fio->fsp == NULL);
1619 ref_fio->handle = handle;
1620 ref_fio->fsp = ad_fsp;
1621 ref_fio->type = ADOUBLE_RSRC;
1622 ref_fio->config = config;
1623 ref_fio->real_fio = fio;
1624 SMB_ASSERT(fio->ad_fsp == NULL);
1625 fio->ad_fsp = ad_fsp;
1626 fio->fake_fd = true;
1627
1628 exit:
1629
1630 DEBUG(10, ("fruit_open resource fork: rc=%d\n", rc));
1631 if (rc != 0) {
1632 int saved_errno = errno;
1633 if (fd != -1) {
1634 vfs_fake_fd_close(fd);
1635 }
1636 errno = saved_errno;
1637 return rc;
1638 }
1639 return fd;
1640 }
1641
1642 static int fruit_open_rsrc_xattr(vfs_handle_struct *handle,
1643 const struct files_struct *dirfsp,
1644 const struct smb_filename *smb_fname,
1645 files_struct *fsp,
1646 int flags,
1647 mode_t mode)
1648 {
1649 #ifdef HAVE_ATTROPEN
1650 int fd = -1;
1651
1652 /*
1653 * As there's no attropenat() this is only going to work with AT_FDCWD.
1654 */
1655 SMB_ASSERT(fsp_get_pathref_fd(dirfsp) == AT_FDCWD);
1656
1657 fd = attropen(smb_fname->base_name,
1658 AFPRESOURCE_EA_NETATALK,
1659 flags,
1660 mode);
1661 if (fd == -1) {
1662 return -1;
1663 }
1664
1665 return fd;
1666
1667 #else
1668 errno = ENOSYS;
1669 return -1;
1670 #endif
1671 }
1672
1673 static int fruit_open_rsrc(vfs_handle_struct *handle,
1674 const struct files_struct *dirfsp,
1675 const struct smb_filename *smb_fname,
1676 files_struct *fsp, int flags, mode_t mode)
1677 {
1678 int fd;
1679 struct fruit_config_data *config = NULL;
1680 struct fio *fio = NULL;
1681
1682 DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
1683
1684 SMB_VFS_HANDLE_GET_DATA(handle, config,
1685 struct fruit_config_data, return -1);
1686
1687 fio = VFS_ADD_FSP_EXTENSION(handle, fsp, struct fio, fio_destroy_fn);
1688 fio->handle = handle;
1689 fio->fsp = fsp;
1690 fio->type = ADOUBLE_RSRC;
1691 fio->config = config;
1692
1693 switch (config->rsrc) {
1694 case FRUIT_RSRC_STREAM: {
1695 struct vfs_open_how how = {
1696 .flags = flags, .mode = mode,
1697 };
1698 fd = SMB_VFS_NEXT_OPENAT(handle,
1699 dirfsp,
1700 smb_fname,
1701 fsp,
1702 &how);
1703 break;
1704 }
1705
1706 case FRUIT_RSRC_ADFILE:
1707 fd = fruit_open_rsrc_adouble(handle, dirfsp, smb_fname,
1708 fsp, flags, mode);
1709 break;
1710
1711 case FRUIT_RSRC_XATTR:
1712 fd = fruit_open_rsrc_xattr(handle, dirfsp, smb_fname,
1713 fsp, flags, mode);
1714 break;
1715
1716 default:
1717 DBG_ERR("Unexpected rsrc config [%d]\n", config->rsrc);
1718 errno = EINVAL;
1719 return -1;
1720 }
1721
1722 DBG_DEBUG("Path [%s] fd [%d]\n", smb_fname_str_dbg(smb_fname), fd);
1723
1724 if (fd == -1) {
1725 return -1;
1726 }
1727
1728 return fd;
1729 }
1730
1731 static int fruit_openat(vfs_handle_struct *handle,
1732 const struct files_struct *dirfsp,
1733 const struct smb_filename *smb_fname,
1734 files_struct *fsp,
1735 const struct vfs_open_how *how)
1736 {
1737 int fd;
1738
1739 DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
1740
1741 if (!is_named_stream(smb_fname)) {
1742 return SMB_VFS_NEXT_OPENAT(handle,
1743 dirfsp,
1744 smb_fname,
1745 fsp,
1746 how);
1747 }
1748
1749 if (how->resolve != 0) {
1750 errno = ENOSYS;
1751 return -1;
1752 }
1753
1754 SMB_ASSERT(fsp_is_alternate_stream(fsp));
1755
1756 if (is_afpinfo_stream(smb_fname->stream_name)) {
1757 fd = fruit_open_meta(handle,
1758 dirfsp,
1759 smb_fname,
1760 fsp,
1761 how->flags,
1762 how->mode);
1763 } else if (is_afpresource_stream(smb_fname->stream_name)) {
1764 fd = fruit_open_rsrc(handle,
1765 dirfsp,
1766 smb_fname,
1767 fsp,
1768 how->flags,
1769 how->mode);
1770 } else {
1771 fd = SMB_VFS_NEXT_OPENAT(handle,
1772 dirfsp,
1773 smb_fname,
1774 fsp,
1775 how);
1776 }
1777
1778 DBG_DEBUG("Path [%s] fd [%d]\n", smb_fname_str_dbg(smb_fname), fd);
1779
1780 /* Prevent reopen optimisation */
1781 fsp->fsp_flags.have_proc_fds = false;
1782 return fd;
1783 }
1784
1785 static int fruit_close_meta(vfs_handle_struct *handle,
1786 files_struct *fsp)
1787 {
1788 int ret;
1789 struct fruit_config_data *config = NULL;
1790
1791 SMB_VFS_HANDLE_GET_DATA(handle, config,
1792 struct fruit_config_data, return -1);
1793
1794 switch (config->meta) {
1795 case FRUIT_META_STREAM:
1796 {
1797 struct fio *fio = fruit_get_complete_fio(handle, fsp);
1798 if (fio == NULL) {
1799 return -1;
1800 }
1801 if (fio->fake_fd) {
1802 ret = vfs_fake_fd_close(fsp_get_pathref_fd(fsp));
1803 fsp_set_fd(fsp, -1);
1804 } else {
1805 ret = SMB_VFS_NEXT_CLOSE(handle, fsp);
1806 }
1807 break;
1808 }
1809 case FRUIT_META_NETATALK:
1810 ret = vfs_fake_fd_close(fsp_get_pathref_fd(fsp));
1811 fsp_set_fd(fsp, -1);
1812 break;
1813
1814 default:
1815 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
1816 return -1;
1817 }
1818
1819 return ret;
1820 }
1821
1822
1823 static int fruit_close_rsrc(vfs_handle_struct *handle,
1824 files_struct *fsp)
1825 {
1826 int ret;
1827 struct fruit_config_data *config = NULL;
1828
1829 SMB_VFS_HANDLE_GET_DATA(handle, config,
1830 struct fruit_config_data, return -1);
1831
1832 switch (config->rsrc) {
1833 case FRUIT_RSRC_STREAM:
1834 ret = SMB_VFS_NEXT_CLOSE(handle, fsp);
1835 break;
1836
1837 case FRUIT_RSRC_ADFILE:
1838 {
1839 struct fio *fio = fruit_get_complete_fio(handle, fsp);
1840 if (fio == NULL) {
1841 return -1;
1842 }
1843 fio_close_ad_fsp(fio);
1844 ret = vfs_fake_fd_close(fsp_get_pathref_fd(fsp));
1845 fsp_set_fd(fsp, -1);
1846 break;
1847 }
1848
1849 case FRUIT_RSRC_XATTR:
1850 ret = vfs_fake_fd_close(fsp_get_pathref_fd(fsp));
1851 fsp_set_fd(fsp, -1);
1852 break;
1853
1854 default:
1855 DBG_ERR("Unexpected rsrc config [%d]\n", config->rsrc);
1856 return -1;
1857 }
1858
1859 return ret;
1860 }
1861
1862 static int fruit_close(vfs_handle_struct *handle,
1863 files_struct *fsp)
1864 {
1865 int ret;
1866 int fd;
1867
1868 fd = fsp_get_pathref_fd(fsp);
1869
1870 DBG_DEBUG("Path [%s] fd [%d]\n", smb_fname_str_dbg(fsp->fsp_name), fd);
1871
1872 if (!fsp_is_alternate_stream(fsp)) {
1873 return SMB_VFS_NEXT_CLOSE(handle, fsp);
1874 }
1875
1876 if (is_afpinfo_stream(fsp->fsp_name->stream_name)) {
1877 ret = fruit_close_meta(handle, fsp);
1878 } else if (is_afpresource_stream(fsp->fsp_name->stream_name)) {
1879 ret = fruit_close_rsrc(handle, fsp);
1880 } else {
1881 ret = SMB_VFS_NEXT_CLOSE(handle, fsp);
1882 }
1883
1884 return ret;
1885 }
1886
1887 static int fruit_renameat(struct vfs_handle_struct *handle,
1888 files_struct *srcfsp,
1889 const struct smb_filename *smb_fname_src,
1890 files_struct *dstfsp,
1891 const struct smb_filename *smb_fname_dst)
1892 {
1893 int rc = -1;
1894 struct fruit_config_data *config = NULL;
1895 struct smb_filename *src_adp_smb_fname = NULL;
1896 struct smb_filename *dst_adp_smb_fname = NULL;
1897
1898 SMB_VFS_HANDLE_GET_DATA(handle, config,
1899 struct fruit_config_data, return -1);
1900
1901 if (!VALID_STAT(smb_fname_src->st)) {
1902 DBG_ERR("Need valid stat for [%s]\n",
1903 smb_fname_str_dbg(smb_fname_src));
1904 return -1;
1905 }
1906
1907 rc = SMB_VFS_NEXT_RENAMEAT(handle,
1908 srcfsp,
1909 smb_fname_src,
1910 dstfsp,
1911 smb_fname_dst);
1912 if (rc != 0) {
1913 return -1;
1914 }
1915
1916 if ((config->rsrc != FRUIT_RSRC_ADFILE) ||
1917 (!S_ISREG(smb_fname_src->st.st_ex_mode)))
1918 {
1919 return 0;
1920 }
1921
1922 rc = adouble_path(talloc_tos(), smb_fname_src, &src_adp_smb_fname);
1923 if (rc != 0) {
1924 goto done;
1925 }
1926
1927 rc = adouble_path(talloc_tos(), smb_fname_dst, &dst_adp_smb_fname);
1928 if (rc != 0) {
1929 goto done;
1930 }
1931
1932 DBG_DEBUG("%s -> %s\n",
1933 smb_fname_str_dbg(src_adp_smb_fname),
1934 smb_fname_str_dbg(dst_adp_smb_fname));
1935
1936 rc = SMB_VFS_NEXT_RENAMEAT(handle,
1937 srcfsp,
1938 src_adp_smb_fname,
1939 dstfsp,
1940 dst_adp_smb_fname);
1941 if (errno == ENOENT) {
1942 rc = 0;
1943 }
1944
1945 done:
1946 TALLOC_FREE(src_adp_smb_fname);
1947 TALLOC_FREE(dst_adp_smb_fname);
1948 return rc;
1949 }
1950
1951 static int fruit_unlink_meta_stream(vfs_handle_struct *handle,
1952 struct files_struct *dirfsp,
1953 const struct smb_filename *smb_fname)
1954 {
1955 return SMB_VFS_NEXT_UNLINKAT(handle,
1956 dirfsp,
1957 smb_fname,
1958 0);
1959 }
1960
1961 static int fruit_unlink_meta_netatalk(vfs_handle_struct *handle,
1962 const struct smb_filename *smb_fname)
1963 {
1964 SMB_ASSERT(smb_fname->fsp != NULL);
1965 SMB_ASSERT(fsp_is_alternate_stream(smb_fname->fsp));
1966 return SMB_VFS_FREMOVEXATTR(smb_fname->fsp->base_fsp,
1967 AFPINFO_EA_NETATALK);
1968 }
1969
1970 static int fruit_unlink_meta(vfs_handle_struct *handle,
1971 struct files_struct *dirfsp,
1972 const struct smb_filename *smb_fname)
1973 {
1974 struct fruit_config_data *config = NULL;
1975 int rc;
1976
1977 SMB_VFS_HANDLE_GET_DATA(handle, config,
1978 struct fruit_config_data, return -1);
1979
1980 switch (config->meta) {
1981 case FRUIT_META_STREAM:
1982 rc = fruit_unlink_meta_stream(handle,
1983 dirfsp,
1984 smb_fname);
1985 break;
1986
1987 case FRUIT_META_NETATALK:
1988 rc = fruit_unlink_meta_netatalk(handle, smb_fname);
1989 break;
1990
1991 default:
1992 DBG_ERR("Unsupported meta config [%d]\n", config->meta);
1993 return -1;
1994 }
1995
1996 return rc;
1997 }
1998
1999 static int fruit_unlink_rsrc_stream(vfs_handle_struct *handle,
2000 struct files_struct *dirfsp,
2001 const struct smb_filename *smb_fname,
2002 bool force_unlink)
2003 {
2004 int ret;
2005
2006 if (!force_unlink) {
2007 struct smb_filename *full_fname = NULL;
2008 off_t size;
2009
2010 /*
2011 * TODO: use SMB_VFS_STATX() once we have it.
2012 */
2013
2014 full_fname = full_path_from_dirfsp_atname(talloc_tos(),
2015 dirfsp,
2016 smb_fname);
2017 if (full_fname == NULL) {
2018 return -1;
2019 }
2020
2021 /*
2022 * 0 byte resource fork streams are not listed by
2023 * vfs_streaminfo, as a result stream cleanup/deletion of file
2024 * deletion doesn't remove the resourcefork stream.
2025 */
2026
2027 ret = SMB_VFS_NEXT_STAT(handle, full_fname);
2028 if (ret != 0) {
2029 TALLOC_FREE(full_fname);
2030 DBG_ERR("stat [%s] failed [%s]\n",
2031 smb_fname_str_dbg(full_fname), strerror(errno));
2032 return -1;
2033 }
2034
2035 size = full_fname->st.st_ex_size;
2036 TALLOC_FREE(full_fname);
2037
2038 if (size > 0) {
2039 /* OS X ignores resource fork stream delete requests */
2040 return 0;
2041 }
2042 }
2043
2044 ret = SMB_VFS_NEXT_UNLINKAT(handle,
2045 dirfsp,
2046 smb_fname,
2047 0);
2048 if ((ret != 0) && (errno == ENOENT) && force_unlink) {
2049 ret = 0;
2050 }
2051
2052 return ret;
2053 }
2054
2055 static int fruit_unlink_rsrc_adouble(vfs_handle_struct *handle,
2056 struct files_struct *dirfsp,
2057 const struct smb_filename *smb_fname,
2058 bool force_unlink)
2059 {
2060 int rc;
2061 struct adouble *ad = NULL;
2062 struct smb_filename *adp_smb_fname = NULL;
2063
2064 if (!force_unlink) {
2065 struct smb_filename *full_fname = NULL;
2066
2067 full_fname = full_path_from_dirfsp_atname(talloc_tos(),
2068 dirfsp,
2069 smb_fname);
2070 if (full_fname == NULL) {
2071 return -1;
2072 }
2073
2074 ad = ad_get(talloc_tos(), handle, full_fname,
2075 ADOUBLE_RSRC);
2076 TALLOC_FREE(full_fname);
2077 if (ad == NULL) {
2078 errno = ENOENT;
2079 return -1;
2080 }
2081
2082
2083 /*
2084 * 0 byte resource fork streams are not listed by
2085 * vfs_streaminfo, as a result stream cleanup/deletion of file
2086 * deletion doesn't remove the resourcefork stream.
2087 */
2088
2089 if (ad_getentrylen(ad, ADEID_RFORK) > 0) {
2090 /* OS X ignores resource fork stream delete requests */
2091 TALLOC_FREE(ad);
2092 return 0;
2093 }
2094
2095 TALLOC_FREE(ad);
2096 }
2097
2098 rc = adouble_path(talloc_tos(), smb_fname, &adp_smb_fname);
2099 if (rc != 0) {
2100 return -1;
2101 }
2102
2103 rc = SMB_VFS_NEXT_UNLINKAT(handle,
2104 dirfsp,
2105 adp_smb_fname,
2106 0);
2107 TALLOC_FREE(adp_smb_fname);
2108 if ((rc != 0) && (errno == ENOENT) && force_unlink) {
2109 rc = 0;
2110 }
2111
2112 return rc;
2113 }
2114
2115 static int fruit_unlink_rsrc_xattr(vfs_handle_struct *handle,
2116 const struct smb_filename *smb_fname,
2117 bool force_unlink)
2118 {
2119 /*
2120 * OS X ignores resource fork stream delete requests, so nothing to do
2121 * here. Removing the file will remove the xattr anyway, so we don't
2122 * have to take care of removing 0 byte resource forks that could be
2123 * left behind.
2124 */
2125 return 0;
2126 }
2127
2128 static int fruit_unlink_rsrc(vfs_handle_struct *handle,
2129 struct files_struct *dirfsp,
2130 const struct smb_filename *smb_fname,
2131 bool force_unlink)
2132 {
2133 struct fruit_config_data *config = NULL;
2134 int rc;
2135
2136 SMB_VFS_HANDLE_GET_DATA(handle, config,
2137 struct fruit_config_data, return -1);
2138
2139 switch (config->rsrc) {
2140 case FRUIT_RSRC_STREAM:
2141 rc = fruit_unlink_rsrc_stream(handle,
2142 dirfsp,
2143 smb_fname,
2144 force_unlink);
2145 break;
2146
2147 case FRUIT_RSRC_ADFILE:
2148 rc = fruit_unlink_rsrc_adouble(handle,
2149 dirfsp,
2150 smb_fname,
2151 force_unlink);
2152 break;
2153
2154 case FRUIT_RSRC_XATTR:
2155 rc = fruit_unlink_rsrc_xattr(handle, smb_fname, force_unlink);
2156 break;
2157
2158 default:
2159 DBG_ERR("Unsupported rsrc config [%d]\n", config->rsrc);
2160 return -1;
2161 }
2162
2163 return rc;
2164 }
2165
2166 static int fruit_fchmod(vfs_handle_struct *handle,
2167 struct files_struct *fsp,
2168 mode_t mode)
2169 {
2170 int rc = -1;
2171 struct fruit_config_data *config = NULL;
2172 struct smb_filename *smb_fname_adp = NULL;
2173 const struct smb_filename *smb_fname = NULL;
2174 NTSTATUS status;
2175
2176 rc = SMB_VFS_NEXT_FCHMOD(handle, fsp, mode);
2177 if (rc != 0) {
2178 return rc;
2179 }
2180
2181 smb_fname = fsp->fsp_name;
2182 SMB_VFS_HANDLE_GET_DATA(handle, config,
2183 struct fruit_config_data, return -1);
2184
2185 if (config->rsrc != FRUIT_RSRC_ADFILE) {
2186 return 0;
2187 }
2188
2189 if (!VALID_STAT(smb_fname->st)) {
2190 return 0;
2191 }
2192
2193 if (!S_ISREG(smb_fname->st.st_ex_mode)) {
2194 return 0;
2195 }
2196
2197 rc = adouble_path(talloc_tos(), smb_fname, &smb_fname_adp);
2198 if (rc != 0) {
2199 return -1;
2200 }
2201
2202 status = openat_pathref_fsp(handle->conn->cwd_fsp,
2203 smb_fname_adp);
2204 if (!NT_STATUS_IS_OK(status)) {
2205 /* detect ENOENT (mapped to OBJECT_NAME_NOT_FOUND) */
2206 if (NT_STATUS_EQUAL(status,
2207 NT_STATUS_OBJECT_NAME_NOT_FOUND)){
2208 rc = 0;
2209 goto out;
2210 }
2211 rc = -1;
2212 goto out;
2213 }
2214
2215 DBG_DEBUG("%s\n", smb_fname_adp->base_name);
2216
2217 rc = SMB_VFS_NEXT_FCHMOD(handle, smb_fname_adp->fsp, mode);
2218 if (errno == ENOENT) {
2219 rc = 0;
2220 }
2221 out:
2222 TALLOC_FREE(smb_fname_adp);
2223 return rc;
2224 }
2225
2226 static int fruit_unlinkat(vfs_handle_struct *handle,
2227 struct files_struct *dirfsp,
2228 const struct smb_filename *smb_fname,
2229 int flags)
2230 {
2231 struct fruit_config_data *config = NULL;
2232 struct smb_filename *rsrc_smb_fname = NULL;
2233 int ret;
2234
2235 if (flags & AT_REMOVEDIR) {
2236 return SMB_VFS_NEXT_UNLINKAT(handle,
2237 dirfsp,
2238 smb_fname,
2239 AT_REMOVEDIR);
2240 }
2241
2242 SMB_VFS_HANDLE_GET_DATA(handle, config,
2243 struct fruit_config_data, return -1);
2244
2245 if (is_afpinfo_stream(smb_fname->stream_name)) {
2246 return fruit_unlink_meta(handle,
2247 dirfsp,
2248 smb_fname);
2249 } else if (is_afpresource_stream(smb_fname->stream_name)) {
2250 return fruit_unlink_rsrc(handle,
2251 dirfsp,
2252 smb_fname,
2253 false);
2254 } else if (is_named_stream(smb_fname)) {
2255 return SMB_VFS_NEXT_UNLINKAT(handle,
2256 dirfsp,
2257 smb_fname,
2258 0);
2259 } else if (is_adouble_file(smb_fname->base_name)) {
2260 return SMB_VFS_NEXT_UNLINKAT(handle,
2261 dirfsp,
2262 smb_fname,
2263 0);
2264 }
2265
2266 /*
2267 * A request to delete the base file. Because 0 byte resource
2268 * fork streams are not listed by fruit_streaminfo,
2269 * delete_all_streams() can't remove 0 byte resource fork
2270 * streams, so we have to cleanup this here.
2271 */
2272 rsrc_smb_fname = synthetic_smb_fname(talloc_tos(),
2273 smb_fname->base_name,
2274 AFPRESOURCE_STREAM_NAME,
2275 NULL,
2276 smb_fname->twrp,
2277 smb_fname->flags);
2278 if (rsrc_smb_fname == NULL) {
2279 return -1;
2280 }
2281
2282 ret = fruit_unlink_rsrc(handle, dirfsp, rsrc_smb_fname, true);
2283 if ((ret != 0) && (errno != ENOENT)) {
2284 DBG_ERR("Forced unlink of [%s] failed [%s]\n",
2285 smb_fname_str_dbg(rsrc_smb_fname), strerror(errno));
2286 TALLOC_FREE(rsrc_smb_fname);
2287 return -1;
2288 }
2289 TALLOC_FREE(rsrc_smb_fname);
2290
2291 return SMB_VFS_NEXT_UNLINKAT(handle,
2292 dirfsp,
2293 smb_fname,
2294 0);
2295 }
2296
2297 static ssize_t fruit_pread_meta_stream(vfs_handle_struct *handle,
2298 files_struct *fsp, void *data,
2299 size_t n, off_t offset)
2300 {
2301 struct fio *fio = fruit_get_complete_fio(handle, fsp);
2302 ssize_t nread;
2303 int ret;
2304
2305 if ((fio == NULL) || fio->fake_fd) {
2306 return -1;
2307 }
2308
2309 nread = SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
2310 if (nread == -1 || nread == n) {
2311 return nread;
2312 }
2313
2314 DBG_ERR("Removing [%s] after short read [%zd]\n",
2315 fsp_str_dbg(fsp), nread);
2316
2317 ret = SMB_VFS_NEXT_UNLINKAT(handle,
2318 fsp->conn->cwd_fsp,
2319 fsp->fsp_name,
2320 0);
2321 if (ret != 0) {
2322 DBG_ERR("Removing [%s] failed\n", fsp_str_dbg(fsp));
2323 return -1;
2324 }
2325
2326 errno = EINVAL;
2327 return -1;
2328 }
2329
2330 static ssize_t fruit_pread_meta_adouble(vfs_handle_struct *handle,
2331 files_struct *fsp, void *data,
2332 size_t n, off_t offset)
2333 {
2334 AfpInfo *ai = NULL;
2335 struct adouble *ad = NULL;
2336 char afpinfo_buf[AFP_INFO_SIZE];
2337 char *p = NULL;
2338 ssize_t nread;
2339
2340 ai = afpinfo_new(talloc_tos());
2341 if (ai == NULL) {
2342 return -1;
2343 }
2344
2345 ad = ad_fget(talloc_tos(), handle, fsp, ADOUBLE_META);
2346 if (ad == NULL) {
2347 nread = -1;
2348 goto fail;
2349 }
2350
2351 p = ad_get_entry(ad, ADEID_FINDERI);
2352 if (p == NULL) {
2353 DBG_ERR("No ADEID_FINDERI for [%s]\n", fsp_str_dbg(fsp));
2354 nread = -1;
2355 goto fail;
2356 }
2357
2358 memcpy(&ai->afpi_FinderInfo[0], p, ADEDLEN_FINDERI);
2359
2360 nread = afpinfo_pack(ai, afpinfo_buf);
2361 if (nread != AFP_INFO_SIZE) {
2362 nread = -1;
2363 goto fail;
2364 }
2365
2366 memcpy(data, afpinfo_buf, n);
2367 nread = n;
2368
2369 fail:
2370 TALLOC_FREE(ai);
2371 return nread;
2372 }
2373
2374 static ssize_t fruit_pread_meta(vfs_handle_struct *handle,
2375 files_struct *fsp, void *data,
2376 size_t n, off_t offset)
2377 {
2378 struct fio *fio = fruit_get_complete_fio(handle, fsp);
2379 ssize_t nread;
2380 ssize_t to_return;
2381
2382 /*
2383 * OS X has a off-by-1 error in the offset calculation, so we're
2384 * bug compatible here. It won't hurt, as any relevant real
2385 * world read requests from the AFP_AfpInfo stream will be
2386 * offset=0 n=60. offset is ignored anyway, see below.
2387 */
2388 if ((offset < 0) || (offset >= AFP_INFO_SIZE + 1)) {
2389 return 0;
2390 }
2391
2392 if (fio == NULL) {
2393 DBG_ERR("Failed to fetch fsp extension");
2394 return -1;
2395 }
2396
2397 /* Yes, macOS always reads from offset 0 */
2398 offset = 0;
2399 to_return = MIN(n, AFP_INFO_SIZE);
2400
2401 switch (fio->config->meta) {
2402 case FRUIT_META_STREAM:
2403 nread = fruit_pread_meta_stream(handle, fsp, data,
2404 to_return, offset);
2405 break;
2406
2407 case FRUIT_META_NETATALK:
2408 nread = fruit_pread_meta_adouble(handle, fsp, data,
2409 to_return, offset);
2410 break;
2411
2412 default:
2413 DBG_ERR("Unexpected meta config [%d]\n", fio->config->meta);
2414 return -1;
2415 }
2416
2417 if (nread == -1 && fio->fake_fd) {
2418 AfpInfo *ai = NULL;
2419 char afpinfo_buf[AFP_INFO_SIZE];
2420
2421 ai = afpinfo_new(talloc_tos());
2422 if (ai == NULL) {
2423 return -1;
2424 }
2425
2426 nread = afpinfo_pack(ai, afpinfo_buf);
2427 TALLOC_FREE(ai);
2428 if (nread != AFP_INFO_SIZE) {
2429 return -1;
2430 }
2431
2432 memcpy(data, afpinfo_buf, to_return);
2433 return to_return;
2434 }
2435
2436 return nread;
2437 }
2438
2439 static ssize_t fruit_pread_rsrc_stream(vfs_handle_struct *handle,
2440 files_struct *fsp, void *data,
2441 size_t n, off_t offset)
2442 {
2443 return SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
2444 }
2445
2446 static ssize_t fruit_pread_rsrc_xattr(vfs_handle_struct *handle,
2447 files_struct *fsp, void *data,
2448 size_t n, off_t offset)
2449 {
2450 return SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
2451 }
2452
2453 static ssize_t fruit_pread_rsrc_adouble(vfs_handle_struct *handle,
2454 files_struct *fsp, void *data,
2455 size_t n, off_t offset)
2456 {
2457 struct fio *fio = fruit_get_complete_fio(handle, fsp);
2458 struct adouble *ad = NULL;
2459 ssize_t nread;
2460
2461 if (fio == NULL || fio->ad_fsp == NULL) {
2462 DBG_ERR("fio/ad_fsp=NULL for [%s]\n", fsp_str_dbg(fsp));
2463 errno = EBADF;
2464 return -1;
2465 }
2466
2467 ad = ad_fget(talloc_tos(), handle, fio->ad_fsp, ADOUBLE_RSRC);
2468 if (ad == NULL) {
2469 DBG_ERR("ad_fget [%s] failed [%s]\n",
2470 fsp_str_dbg(fio->ad_fsp), strerror(errno));
2471 return -1;
2472 }
2473
2474 nread = SMB_VFS_NEXT_PREAD(handle, fio->ad_fsp, data, n,
2475 offset + ad_getentryoff(ad, ADEID_RFORK));
2476
2477 TALLOC_FREE(ad);
2478 return nread;
2479 }
2480
2481 static ssize_t fruit_pread_rsrc(vfs_handle_struct *handle,
2482 files_struct *fsp, void *data,
2483 size_t n, off_t offset)
2484 {
2485 struct fio *fio = fruit_get_complete_fio(handle, fsp);
2486 ssize_t nread;
2487
2488 if (fio == NULL) {
2489 errno = EINVAL;
2490 return -1;
2491 }
2492
2493 switch (fio->config->rsrc) {
2494 case FRUIT_RSRC_STREAM:
2495 nread = fruit_pread_rsrc_stream(handle, fsp, data, n, offset);
2496 break;
2497
2498 case FRUIT_RSRC_ADFILE:
2499 nread = fruit_pread_rsrc_adouble(handle, fsp, data, n, offset);
2500 break;
2501
2502 case FRUIT_RSRC_XATTR:
2503 nread = fruit_pread_rsrc_xattr(handle, fsp, data, n, offset);
2504 break;
2505
2506 default:
2507 DBG_ERR("Unexpected rsrc config [%d]\n", fio->config->rsrc);
2508 return -1;
2509 }
2510
2511 return nread;
2512 }
2513
2514 static ssize_t fruit_pread(vfs_handle_struct *handle,
2515 files_struct *fsp, void *data,
2516 size_t n, off_t offset)
2517 {
2518 struct fio *fio = fruit_get_complete_fio(handle, fsp);
2519 ssize_t nread;
2520
2521 DBG_DEBUG("Path [%s] offset=%"PRIdMAX", size=%zd\n",
2522 fsp_str_dbg(fsp), (intmax_t)offset, n);
2523
2524 if (fio == NULL) {
2525 return SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
2526 }
2527
2528 if (fio->type == ADOUBLE_META) {
2529 nread = fruit_pread_meta(handle, fsp, data, n, offset);
2530 } else {
2531 nread = fruit_pread_rsrc(handle, fsp, data, n, offset);
2532 }
2533
2534 DBG_DEBUG("Path [%s] nread [%zd]\n", fsp_str_dbg(fsp), nread);
2535 return nread;
2536 }
2537
2538 static bool fruit_must_handle_aio_stream(struct fio *fio)
2539 {
2540 if (fio == NULL) {
2541 return false;
2542 };
2543
2544 if (fio->type == ADOUBLE_META) {
2545 return true;
2546 }
2547
2548 if ((fio->type == ADOUBLE_RSRC) &&
2549 (fio->config->rsrc == FRUIT_RSRC_ADFILE))
2550 {
2551 return true;
2552 }
2553
2554 return false;
2555 }
2556
2557 struct fruit_pread_state {
2558 ssize_t nread;
2559 struct vfs_aio_state vfs_aio_state;
2560 };
2561
2562 static void fruit_pread_done(struct tevent_req *subreq);
2563
2564 static struct tevent_req *fruit_pread_send(
2565 struct vfs_handle_struct *handle,
2566 TALLOC_CTX *mem_ctx,
2567 struct tevent_context *ev,
2568 struct files_struct *fsp,
2569 void *data,
2570 size_t n, off_t offset)
2571 {
2572 struct tevent_req *req = NULL;
2573 struct tevent_req *subreq = NULL;
2574 struct fruit_pread_state *state = NULL;
2575 struct fio *fio = fruit_get_complete_fio(handle, fsp);
2576
2577 req = tevent_req_create(mem_ctx, &state,
2578 struct fruit_pread_state);
2579 if (req == NULL) {
2580 return NULL;
2581 }
2582
2583 if (fruit_must_handle_aio_stream(fio)) {
2584 state->nread = SMB_VFS_PREAD(fsp, data, n, offset);
2585 if (state->nread != n) {
2586 if (state->nread != -1) {
2587 errno = EIO;
2588 }
2589 tevent_req_error(req, errno);
2590 return tevent_req_post(req, ev);
2591 }
2592 tevent_req_done(req);
2593 return tevent_req_post(req, ev);
2594 }
2595
2596 subreq = SMB_VFS_NEXT_PREAD_SEND(state, ev, handle, fsp,
2597 data, n, offset);
2598 if (tevent_req_nomem(req, subreq)) {
2599 return tevent_req_post(req, ev);
2600 }
2601 tevent_req_set_callback(subreq, fruit_pread_done, req);
2602 return req;
2603 }
2604
2605 static void fruit_pread_done(struct tevent_req *subreq)
2606 {
2607 struct tevent_req *req = tevent_req_callback_data(
2608 subreq, struct tevent_req);
2609 struct fruit_pread_state *state = tevent_req_data(
2610 req, struct fruit_pread_state);
2611
2612 state->nread = SMB_VFS_PREAD_RECV(subreq, &state->vfs_aio_state);
2613 TALLOC_FREE(subreq);
2614
2615 if (tevent_req_error(req, state->vfs_aio_state.error)) {
2616 return;
2617 }
2618 tevent_req_done(req);
2619 }
2620
2621 static ssize_t fruit_pread_recv(struct tevent_req *req,
2622 struct vfs_aio_state *vfs_aio_state)
2623 {
2624 struct fruit_pread_state *state = tevent_req_data(
2625 req, struct fruit_pread_state);
2626 ssize_t retval = -1;
2627
2628 if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
2629 tevent_req_received(req);
2630 return -1;
2631 }
2632
2633 *vfs_aio_state = state->vfs_aio_state;
2634 retval = state->nread;
2635 tevent_req_received(req);
2636 return retval;
2637 }
2638
2639 static ssize_t fruit_pwrite_meta_stream(vfs_handle_struct *handle,
2640 files_struct *fsp, const void *data,
2641 size_t n, off_t offset)
2642 {
2643 struct fio *fio = fruit_get_complete_fio(handle, fsp);
2644 AfpInfo *ai = NULL;
2645 size_t nwritten;
2646 int ret;
2647 bool ok;
2648
2649 DBG_DEBUG("Path [%s] offset=%"PRIdMAX", size=%zd\n",
2650 fsp_str_dbg(fsp), (intmax_t)offset, n);
2651
2652 if (fio == NULL) {
2653 return -1;
2654 }
2655
2656 if (fio->fake_fd) {
2657 struct vfs_open_how how = {
2658 .flags = fio->flags, .mode = fio->mode,
2659 };
2660 int fd = fsp_get_pathref_fd(fsp);
2661
2662 ret = vfs_fake_fd_close(fd);
2663 fsp_set_fd(fsp, -1);
2664 if (ret != 0) {
2665 DBG_ERR("Close [%s] failed: %s\n",
2666 fsp_str_dbg(fsp), strerror(errno));
2667 return -1;
2668 }
2669
2670 fd = SMB_VFS_NEXT_OPENAT(handle,
2671 NULL, /* opening a stream */
2672 fsp->fsp_name,
2673 fsp,
2674 &how);
2675 if (fd == -1) {
2676 DBG_ERR("On-demand create [%s] in write failed: %s\n",
2677 fsp_str_dbg(fsp), strerror(errno));
2678 return -1;
2679 }
2680 fsp_set_fd(fsp, fd);
2681 fio->fake_fd = false;
2682 }
2683
2684 ai = afpinfo_unpack(talloc_tos(), data);
2685 if (ai == NULL) {
2686 return -1;
2687 }
2688
2689 if (ai_empty_finderinfo(ai)) {
2690 /*
2691 * Writing an all 0 blob to the metadata stream results in the
2692 * stream being removed on a macOS server. This ensures we
2693 * behave the same and it verified by the "delete AFP_AfpInfo by
2694 * writing all 0" test.
2695 */
2696 ret = SMB_VFS_NEXT_FTRUNCATE(handle, fsp, 0);
2697 if (ret != 0) {
2698 DBG_ERR("SMB_VFS_NEXT_FTRUNCATE on [%s] failed\n",
2699 fsp_str_dbg(fsp));
2700 return -1;
2701 }
2702
2703 ok = set_delete_on_close(
2704 fsp,
2705 true,
2706 handle->conn->session_info->security_token,
2707 handle->conn->session_info->unix_token);
2708 if (!ok) {
2709 DBG_ERR("set_delete_on_close on [%s] failed\n",
2710 fsp_str_dbg(fsp));
2711 return -1;
2712 }
2713 return n;
2714 }
2715
2716 nwritten = SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
2717 if (nwritten != n) {
2718 return -1;
2719 }
2720
2721 return n;
2722 }
2723
2724 static ssize_t fruit_pwrite_meta_netatalk(vfs_handle_struct *handle,
2725 files_struct *fsp, const void *data,
2726 size_t n, off_t offset)
2727 {
2728 struct adouble *ad = NULL;
2729 AfpInfo *ai = NULL;
2730 char *p = NULL;
2731 int ret;
2732 bool ok;
2733
2734 ai = afpinfo_unpack(talloc_tos(), data);
2735 if (ai == NULL) {
2736 return -1;
2737 }
2738
2739 ad = ad_fget(talloc_tos(), handle, fsp, ADOUBLE_META);
2740 if (ad == NULL) {
2741 ad = ad_init(talloc_tos(), ADOUBLE_META);
2742 if (ad == NULL) {
2743 return -1;
2744 }
2745 }
2746 p = ad_get_entry(ad, ADEID_FINDERI);
2747 if (p == NULL) {
2748 DBG_ERR("No ADEID_FINDERI for [%s]\n", fsp_str_dbg(fsp));
2749 TALLOC_FREE(ad);
2750 return -1;
2751 }
2752
2753 memcpy(p, &ai->afpi_FinderInfo[0], ADEDLEN_FINDERI);
2754
2755 ret = ad_fset(handle, ad, fsp);
2756 if (ret != 0) {
2757 DBG_ERR("ad_pwrite [%s] failed\n", fsp_str_dbg(fsp));
2758 TALLOC_FREE(ad);
2759 return -1;
2760 }
2761
2762 TALLOC_FREE(ad);
2763
2764 if (!ai_empty_finderinfo(ai)) {
2765 return n;
2766 }
2767
2768 /*
2769 * Writing an all 0 blob to the metadata stream results in the stream
2770 * being removed on a macOS server. This ensures we behave the same and
2771 * it verified by the "delete AFP_AfpInfo by writing all 0" test.
2772 */
2773
2774 ok = set_delete_on_close(
2775 fsp,
2776 true,
2777 handle->conn->session_info->security_token,
2778 handle->conn->session_info->unix_token);
2779 if (!ok) {
2780 DBG_ERR("set_delete_on_close on [%s] failed\n",
2781 fsp_str_dbg(fsp));
2782 return -1;
2783 }
2784
2785 return n;
2786 }
2787
2788 static ssize_t fruit_pwrite_meta(vfs_handle_struct *handle,
2789 files_struct *fsp, const void *data,
2790 size_t n, off_t offset)
2791 {
2792 struct fio *fio = fruit_get_complete_fio(handle, fsp);
2793 ssize_t nwritten;
2794 uint8_t buf[AFP_INFO_SIZE];
2795 size_t to_write;
2796 size_t to_copy;
2797 int cmp;
2798
2799 if (fio == NULL) {
2800 DBG_ERR("Failed to fetch fsp extension");
2801 return -1;
2802 }
2803
2804 if (n < 3) {
2805 errno = EINVAL;
2806 return -1;
2807 }
2808
2809 if (offset != 0 && n < 60) {
2810 errno = EINVAL;
2811 return -1;
2812 }
2813
2814 cmp = memcmp(data, "AFP", 3);
2815 if (cmp != 0) {
2816 errno = EINVAL;
2817 return -1;
2818 }
2819
2820 if (n <= AFP_OFF_FinderInfo) {
2821 /*
2822 * Nothing to do here really, just return
2823 */
2824 return n;
2825 }
2826
2827 offset = 0;
2828
2829 to_copy = n;
2830 if (to_copy > AFP_INFO_SIZE) {
2831 to_copy = AFP_INFO_SIZE;
2832 }
2833 memcpy(buf, data, to_copy);
2834
2835 to_write = n;
2836 if (to_write != AFP_INFO_SIZE) {
2837 to_write = AFP_INFO_SIZE;
2838 }
2839
2840 switch (fio->config->meta) {
2841 case FRUIT_META_STREAM:
2842 nwritten = fruit_pwrite_meta_stream(handle,
2843 fsp,
2844 buf,
2845 to_write,
2846 offset);
2847 break;
2848
2849 case FRUIT_META_NETATALK:
2850 nwritten = fruit_pwrite_meta_netatalk(handle,
2851 fsp,
2852 buf,
2853 to_write,
2854 offset);
2855 break;
2856
2857 default:
2858 DBG_ERR("Unexpected meta config [%d]\n", fio->config->meta);
2859 return -1;
2860 }
2861
2862 if (nwritten != to_write) {
2863 return -1;
2864 }
2865
2866 /*
2867 * Return the requested amount, verified against macOS SMB server
2868 */
2869 return n;
2870 }
2871
2872 static ssize_t fruit_pwrite_rsrc_stream(vfs_handle_struct *handle,
2873 files_struct *fsp, const void *data,
2874 size_t n, off_t offset)
2875 {
2876 return SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
2877 }
2878
2879 static ssize_t fruit_pwrite_rsrc_xattr(vfs_handle_struct *handle,
2880 files_struct *fsp, const void *data,
2881 size_t n, off_t offset)
2882 {
2883 return SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
2884 }
2885
2886 static ssize_t fruit_pwrite_rsrc_adouble(vfs_handle_struct *handle,
2887 files_struct *fsp, const void *data,
2888 size_t n, off_t offset)
2889 {
2890 struct fio *fio = fruit_get_complete_fio(handle, fsp);
2891 struct adouble *ad = NULL;
2892 ssize_t nwritten;
2893 int ret;
2894
2895 if (fio == NULL || fio->ad_fsp == NULL) {
2896 DBG_ERR("fio/ad_fsp=NULL for [%s]\n", fsp_str_dbg(fsp));
2897 errno = EBADF;
2898 return -1;
2899 }
2900
2901 ad = ad_fget(talloc_tos(), handle, fio->ad_fsp, ADOUBLE_RSRC);
2902 if (ad == NULL) {
2903 DBG_ERR("ad_fget [%s] failed [%s]\n",
2904 fsp_str_dbg(fio->ad_fsp), strerror(errno));
2905 return -1;
2906 }
2907
2908 nwritten = SMB_VFS_NEXT_PWRITE(handle, fio->ad_fsp, data, n,
2909 offset + ad_getentryoff(ad, ADEID_RFORK));
2910 if (nwritten != n) {
2911 DBG_ERR("Short write on [%s] [%zd/%zd]\n",
2912 fsp_str_dbg(fio->ad_fsp), nwritten, n);
2913 TALLOC_FREE(ad);
2914 return -1;
2915 }
2916
2917 if ((n + offset) > ad_getentrylen(ad, ADEID_RFORK)) {
2918 ad_setentrylen(ad, ADEID_RFORK, n + offset);
2919 ret = ad_fset(handle, ad, fio->ad_fsp);
2920 if (ret != 0) {
2921 DBG_ERR("ad_pwrite [%s] failed\n", fsp_str_dbg(fio->ad_fsp));
2922 TALLOC_FREE(ad);
2923 return -1;
2924 }
2925 }
2926
2927 TALLOC_FREE(ad);
2928 return n;
2929 }
2930
2931 static ssize_t fruit_pwrite_rsrc(vfs_handle_struct *handle,
2932 files_struct *fsp, const void *data,
2933 size_t n, off_t offset)
2934 {
2935 struct fio *fio = fruit_get_complete_fio(handle, fsp);
2936 ssize_t nwritten;
2937
2938 if (fio == NULL) {
2939 DBG_ERR("Failed to fetch fsp extension");
2940 return -1;
2941 }
2942
2943 switch (fio->config->rsrc) {
2944 case FRUIT_RSRC_STREAM:
2945 nwritten = fruit_pwrite_rsrc_stream(handle, fsp, data, n, offset);
2946 break;
2947
2948 case FRUIT_RSRC_ADFILE:
2949 nwritten = fruit_pwrite_rsrc_adouble(handle, fsp, data, n, offset);
2950 break;
2951
2952 case FRUIT_RSRC_XATTR:
2953 nwritten = fruit_pwrite_rsrc_xattr(handle, fsp, data, n, offset);
2954 break;
2955
2956 default:
2957 DBG_ERR("Unexpected rsrc config [%d]\n", fio->config->rsrc);
2958 return -1;
2959 }
2960
2961 return nwritten;
2962 }
2963
2964 static ssize_t fruit_pwrite(vfs_handle_struct *handle,
2965 files_struct *fsp, const void *data,
2966 size_t n, off_t offset)
2967 {
2968 struct fio *fio = fruit_get_complete_fio(handle, fsp);
2969 ssize_t nwritten;
2970
2971 DBG_DEBUG("Path [%s] offset=%"PRIdMAX", size=%zd\n",
2972 fsp_str_dbg(fsp), (intmax_t)offset, n);
2973
2974 if (fio == NULL) {
2975 return SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
2976 }
2977
2978 if (fio->type == ADOUBLE_META) {
2979 nwritten = fruit_pwrite_meta(handle, fsp, data, n, offset);
2980 } else {
2981 nwritten = fruit_pwrite_rsrc(handle, fsp, data, n, offset);
2982 }
2983
2984 DBG_DEBUG("Path [%s] nwritten=%zd\n", fsp_str_dbg(fsp), nwritten);
2985 return nwritten;
2986 }
2987
2988 struct fruit_pwrite_state {
2989 ssize_t nwritten;
2990 struct vfs_aio_state vfs_aio_state;
2991 };
2992
2993 static void fruit_pwrite_done(struct tevent_req *subreq);
2994
2995 static struct tevent_req *fruit_pwrite_send(
2996 struct vfs_handle_struct *handle,
2997 TALLOC_CTX *mem_ctx,
2998 struct tevent_context *ev,
2999 struct files_struct *fsp,
3000 const void *data,
3001 size_t n, off_t offset)
3002 {
3003 struct tevent_req *req = NULL;
3004 struct tevent_req *subreq = NULL;
3005 struct fruit_pwrite_state *state = NULL;
3006 struct fio *fio = fruit_get_complete_fio(handle, fsp);
3007
3008 req = tevent_req_create(mem_ctx, &state,
3009 struct fruit_pwrite_state);
3010 if (req == NULL) {
3011 return NULL;
3012 }
3013
3014 if (fruit_must_handle_aio_stream(fio)) {
3015 state->nwritten = SMB_VFS_PWRITE(fsp, data, n, offset);
3016 if (state->nwritten != n) {
3017 if (state->nwritten != -1) {
3018 errno = EIO;
3019 }
3020 tevent_req_error(req, errno);
3021 return tevent_req_post(req, ev);
3022 }
3023 tevent_req_done(req);
3024 return tevent_req_post(req, ev);
3025 }
3026
3027 subreq = SMB_VFS_NEXT_PWRITE_SEND(state, ev, handle, fsp,
3028 data, n, offset);
3029 if (tevent_req_nomem(req, subreq)) {
3030 return tevent_req_post(req, ev);
3031 }
3032 tevent_req_set_callback(subreq, fruit_pwrite_done, req);
3033 return req;
3034 }
3035
3036 static void fruit_pwrite_done(struct tevent_req *subreq)
3037 {
3038 struct tevent_req *req = tevent_req_callback_data(
3039 subreq, struct tevent_req);
3040 struct fruit_pwrite_state *state = tevent_req_data(
3041 req, struct fruit_pwrite_state);
3042
3043 state->nwritten = SMB_VFS_PWRITE_RECV(subreq, &state->vfs_aio_state);
3044 TALLOC_FREE(subreq);
3045
3046 if (tevent_req_error(req, state->vfs_aio_state.error)) {
3047 return;
3048 }
3049 tevent_req_done(req);
3050 }
3051
3052 static ssize_t fruit_pwrite_recv(struct tevent_req *req,
3053 struct vfs_aio_state *vfs_aio_state)
3054 {
3055 struct fruit_pwrite_state *state = tevent_req_data(
3056 req, struct fruit_pwrite_state);
3057 ssize_t retval = -1;
3058
3059 if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
3060 tevent_req_received(req);
3061 return -1;
3062 }
3063
3064 *vfs_aio_state = state->vfs_aio_state;
3065 retval = state->nwritten;
3066 tevent_req_received(req);
3067 return retval;
3068 }
3069
3070 struct fruit_fsync_state {
3071 int ret;
3072 struct vfs_aio_state vfs_aio_state;
3073 };
3074
3075 static void fruit_fsync_done(struct tevent_req *subreq);
3076
3077 static struct tevent_req *fruit_fsync_send(
3078 struct vfs_handle_struct *handle,
3079 TALLOC_CTX *mem_ctx,
3080 struct tevent_context *ev,
3081 struct files_struct *fsp)
3082 {
3083 struct tevent_req *req = NULL;
3084 struct tevent_req *subreq = NULL;
3085 struct fruit_fsync_state *state = NULL;
3086 struct fio *fio = fruit_get_complete_fio(handle, fsp);
3087
3088 req = tevent_req_create(mem_ctx, &state,
3089 struct fruit_fsync_state);
3090 if (req == NULL) {
3091 return NULL;
3092 }
3093
3094 if (fruit_must_handle_aio_stream(fio)) {
3095 struct adouble *ad = NULL;
3096
3097 if (fio->type == ADOUBLE_META) {
3098 /*
3099 * We must never pass a fake_fd
3100 * to lower level fsync calls.
3101 * Everything is already done
3102 * synchronously, so just return
3103 * true.
3104 */
3105 SMB_ASSERT(fio->fake_fd);
3106 tevent_req_done(req);
3107 return tevent_req_post(req, ev);
3108 }
3109
3110 /*
3111 * We know the following must be true,
3112 * as it's the condition for fruit_must_handle_aio_stream()
3113 * to return true if fio->type == ADOUBLE_RSRC.
3114 */
3115 SMB_ASSERT(fio->config->rsrc == FRUIT_RSRC_ADFILE);
3116 if (fio->ad_fsp == NULL) {
3117 tevent_req_error(req, EBADF);
3118 return tevent_req_post(req, ev);
3119 }
3120 ad = ad_fget(talloc_tos(), handle, fio->ad_fsp, ADOUBLE_RSRC);
3121 if (ad == NULL) {
3122 tevent_req_error(req, ENOMEM);
3123 return tevent_req_post(req, ev);
3124 }
3125 fsp = fio->ad_fsp;
3126 }
3127
3128 subreq = SMB_VFS_NEXT_FSYNC_SEND(state, ev, handle, fsp);
3129 if (tevent_req_nomem(req, subreq)) {
3130 return tevent_req_post(req, ev);
3131 }
3132 tevent_req_set_callback(subreq, fruit_fsync_done, req);
3133 return req;
3134 }
3135
3136 static void fruit_fsync_done(struct tevent_req *subreq)
3137 {
3138 struct tevent_req *req = tevent_req_callback_data(
3139 subreq, struct tevent_req);
3140 struct fruit_fsync_state *state = tevent_req_data(
3141 req, struct fruit_fsync_state);
3142
3143 state->ret = SMB_VFS_FSYNC_RECV(subreq, &state->vfs_aio_state);
3144 TALLOC_FREE(subreq);
3145 if (state->ret != 0) {
3146 tevent_req_error(req, errno);
3147 return;
3148 }
3149 tevent_req_done(req);
3150 }
3151
3152 static int fruit_fsync_recv(struct tevent_req *req,
3153 struct vfs_aio_state *vfs_aio_state)
3154 {
3155 struct fruit_fsync_state *state = tevent_req_data(
3156 req, struct fruit_fsync_state);
3157 int retval = -1;
3158
3159 if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
3160 tevent_req_received(req);
3161 return -1;
3162 }
3163
3164 *vfs_aio_state = state->vfs_aio_state;
3165 retval = state->ret;
3166 tevent_req_received(req);
3167 return retval;
3168 }
3169
3170 /**
3171 * Helper to stat/lstat the base file of an smb_fname.
3172 */
3173 static int fruit_stat_base(vfs_handle_struct *handle,
3174 struct smb_filename *smb_fname,
3175 bool follow_links)
3176 {
3177 char *tmp_stream_name;
3178 int rc;
3179
3180 tmp_stream_name = smb_fname->stream_name;
3181 smb_fname->stream_name = NULL;
3182 if (follow_links) {
3183 rc = SMB_VFS_NEXT_STAT(handle, smb_fname);
3184 } else {
3185 rc = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
3186 }
3187 smb_fname->stream_name = tmp_stream_name;
3188
3189 DBG_DEBUG("fruit_stat_base [%s] dev [%ju] ino [%ju]\n",
3190 smb_fname->base_name,
3191 (uintmax_t)smb_fname->st.st_ex_dev,
3192 (uintmax_t)smb_fname->st.st_ex_ino);
3193 return rc;
3194 }
3195
3196 static int fruit_stat_meta_stream(vfs_handle_struct *handle,
3197 struct smb_filename *smb_fname,
3198 bool follow_links)
3199 {
3200 int ret;
3201 ino_t ino;
3202
3203 ret = fruit_stat_base(handle, smb_fname, false);
3204 if (ret != 0) {
3205 return -1;
3206 }
3207
3208 ino = hash_inode(&smb_fname->st, smb_fname->stream_name);
3209
3210 if (follow_links) {
3211 ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
3212 } else {
3213 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
3214 }
3215
3216 smb_fname->st.st_ex_ino = ino;
3217
3218 return ret;
3219 }
3220
3221 static int fruit_stat_meta_netatalk(vfs_handle_struct *handle,
3222 struct smb_filename *smb_fname,
3223 bool follow_links)
3224 {
3225 struct adouble *ad = NULL;
3226
3227 /* Populate the stat struct with info from the base file. */
3228 if (fruit_stat_base(handle, smb_fname, follow_links) == -1) {
3229 return -1;
3230 }
3231
3232 ad = ad_get_meta_fsp(talloc_tos(), handle, smb_fname);
3233 if (ad == NULL) {
3234 DBG_INFO("fruit_stat_meta %s: %s\n",
3235 smb_fname_str_dbg(smb_fname), strerror(errno));
3236 errno = ENOENT;
3237 return -1;
3238 }
3239 TALLOC_FREE(ad);
3240
3241 smb_fname->st.st_ex_size = AFP_INFO_SIZE;
3242 smb_fname->st.st_ex_ino = hash_inode(&smb_fname->st,
3243 smb_fname->stream_name);
3244 return 0;
3245 }
3246
3247 static int fruit_stat_meta(vfs_handle_struct *handle,
3248 struct smb_filename *smb_fname,
3249 bool follow_links)
3250 {
3251 struct fruit_config_data *config = NULL;
3252 int ret;
3253
3254 SMB_VFS_HANDLE_GET_DATA(handle, config,
3255 struct fruit_config_data, return -1);
3256
3257 switch (config->meta) {
3258 case FRUIT_META_STREAM:
3259 ret = fruit_stat_meta_stream(handle, smb_fname, follow_links);
3260 break;
3261
3262 case FRUIT_META_NETATALK:
3263 ret = fruit_stat_meta_netatalk(handle, smb_fname, follow_links);
3264 break;
3265
3266 default:
3267 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
3268 return -1;
3269 }
3270
3271 return ret;
3272 }
3273
3274 static int fruit_stat_rsrc_netatalk(vfs_handle_struct *handle,
3275 struct smb_filename *smb_fname,
3276 bool follow_links)
3277 {
3278 struct adouble *ad = NULL;
3279 int ret;
3280
3281 ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_RSRC);
3282 if (ad == NULL) {
3283 errno = ENOENT;
3284 return -1;
3285 }
3286
3287 /* Populate the stat struct with info from the base file. */
3288 ret = fruit_stat_base(handle, smb_fname, follow_links);
3289 if (ret != 0) {
3290 TALLOC_FREE(ad);
3291 return -1;
3292 }
3293
3294 smb_fname->st.st_ex_size = ad_getentrylen(ad, ADEID_RFORK);
3295 smb_fname->st.st_ex_ino = hash_inode(&smb_fname->st,
3296 smb_fname->stream_name);
3297 TALLOC_FREE(ad);
3298 return 0;
3299 }
3300
3301 static int fruit_stat_rsrc_stream(vfs_handle_struct *handle,
3302 struct smb_filename *smb_fname,
3303 bool follow_links)
3304 {
3305 int ret;
3306
3307 if (follow_links) {
3308 ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
3309 } else {
3310 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
3311 }
3312
3313 return ret;
3314 }
3315
3316 static int fruit_stat_rsrc_xattr(vfs_handle_struct *handle,
3317 struct smb_filename *smb_fname,
3318 bool follow_links)
3319 {
3320 #ifdef HAVE_ATTROPEN
3321 int ret;
3322 int fd = -1;
3323
3324 /* Populate the stat struct with info from the base file. */
3325 ret = fruit_stat_base(handle, smb_fname, follow_links);
3326 if (ret != 0) {
3327 return -1;
3328 }
3329
3330 fd = attropen(smb_fname->base_name,
3331 AFPRESOURCE_EA_NETATALK,
3332 O_RDONLY);
3333 if (fd == -1) {
3334 return 0;
3335 }
3336
3337 ret = sys_fstat(fd, &smb_fname->st, false);
3338 if (ret != 0) {
3339 close(fd);
3340 DBG_ERR("fstat [%s:%s] failed\n", smb_fname->base_name,
3341 AFPRESOURCE_EA_NETATALK);
3342 return -1;
3343 }
3344 close(fd);
3345 fd = -1;
3346
3347 smb_fname->st.st_ex_ino = hash_inode(&smb_fname->st,
3348 smb_fname->stream_name);
3349
3350 return ret;
3351
3352 #else
3353 errno = ENOSYS;
3354 return -1;
3355 #endif
3356 }
3357
3358 static int fruit_stat_rsrc(vfs_handle_struct *handle,
3359 struct smb_filename *smb_fname,
3360 bool follow_links)
3361 {
3362 struct fruit_config_data *config = NULL;
3363 int ret;
3364
3365 DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
3366
3367 SMB_VFS_HANDLE_GET_DATA(handle, config,
3368 struct fruit_config_data, return -1);
3369
3370 switch (config->rsrc) {
3371 case FRUIT_RSRC_STREAM:
3372 ret = fruit_stat_rsrc_stream(handle, smb_fname, follow_links);
3373 break;
3374
3375 case FRUIT_RSRC_XATTR:
3376 ret = fruit_stat_rsrc_xattr(handle, smb_fname, follow_links);
3377 break;
3378
3379 case FRUIT_RSRC_ADFILE:
3380 ret = fruit_stat_rsrc_netatalk(handle, smb_fname, follow_links);
3381 break;
3382
3383 default:
3384 DBG_ERR("Unexpected rsrc config [%d]\n", config->rsrc);
3385 return -1;
3386 }
3387
3388 return ret;
3389 }
3390
3391 static int fruit_stat(vfs_handle_struct *handle,
3392 struct smb_filename *smb_fname)
3393 {
3394 int rc = -1;
3395
3396 DEBUG(10, ("fruit_stat called for %s\n",
3397 smb_fname_str_dbg(smb_fname)));
3398
3399 if (!is_named_stream(smb_fname)) {
3400 rc = SMB_VFS_NEXT_STAT(handle, smb_fname);
3401 if (rc == 0) {
3402 update_btime(handle, smb_fname);
3403 }
3404 return rc;
3405 }
3406
3407 /*
3408 * Note if lp_posix_paths() is true, we can never
3409 * get here as is_ntfs_stream_smb_fname() is
3410 * always false. So we never need worry about
3411 * not following links here.
3412 */
3413
3414 if (is_afpinfo_stream(smb_fname->stream_name)) {
3415 rc = fruit_stat_meta(handle, smb_fname, true);
3416 } else if (is_afpresource_stream(smb_fname->stream_name)) {
3417 rc = fruit_stat_rsrc(handle, smb_fname, true);
3418 } else {
3419 return SMB_VFS_NEXT_STAT(handle, smb_fname);
3420 }
3421
3422 if (rc == 0) {
3423 update_btime(handle, smb_fname);
3424 smb_fname->st.st_ex_mode &= ~S_IFMT;
3425 smb_fname->st.st_ex_mode |= S_IFREG;
3426 smb_fname->st.st_ex_blocks =
3427 smb_fname->st.st_ex_size / STAT_ST_BLOCKSIZE + 1;
3428 }
3429 return rc;
3430 }
3431
3432 static int fruit_lstat(vfs_handle_struct *handle,
3433 struct smb_filename *smb_fname)
3434 {
3435 int rc = -1;
3436
3437 DEBUG(10, ("fruit_lstat called for %s\n",
3438 smb_fname_str_dbg(smb_fname)));
3439
3440 if (!is_named_stream(smb_fname)) {
3441 rc = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
3442 if (rc == 0) {
3443 update_btime(handle, smb_fname);
3444 }
3445 return rc;
3446 }
3447
3448 if (is_afpinfo_stream(smb_fname->stream_name)) {
3449 rc = fruit_stat_meta(handle, smb_fname, false);
3450 } else if (is_afpresource_stream(smb_fname->stream_name)) {
3451 rc = fruit_stat_rsrc(handle, smb_fname, false);
3452 } else {
3453 return SMB_VFS_NEXT_LSTAT(handle, smb_fname);
3454 }
3455
3456 if (rc == 0) {
3457 update_btime(handle, smb_fname);
3458 smb_fname->st.st_ex_mode &= ~S_IFMT;
3459 smb_fname->st.st_ex_mode |= S_IFREG;
3460 smb_fname->st.st_ex_blocks =
3461 smb_fname->st.st_ex_size / STAT_ST_BLOCKSIZE + 1;
3462 }
3463 return rc;
3464 }
3465
3466 static int fruit_fstat_meta_stream(vfs_handle_struct *handle,
3467 files_struct *fsp,
3468 SMB_STRUCT_STAT *sbuf)
3469 {
3470 struct fio *fio = fruit_get_complete_fio(handle, fsp);
3471 struct smb_filename smb_fname;
3472 ino_t ino;
3473 int ret;
3474
3475 if (fio == NULL) {
3476 return -1;
3477 }
3478
3479 if (fio->fake_fd) {
3480 ret = fruit_stat_base(handle, fsp->base_fsp->fsp_name, false);
3481 if (ret != 0) {
3482 return -1;
3483 }
3484
3485 *sbuf = fsp->base_fsp->fsp_name->st;
3486 sbuf->st_ex_size = AFP_INFO_SIZE;
3487 sbuf->st_ex_ino = hash_inode(sbuf, fsp->fsp_name->stream_name);
3488 return 0;
3489 }
3490
3491 smb_fname = (struct smb_filename) {
3492 .base_name = fsp->fsp_name->base_name,
3493 .twrp = fsp->fsp_name->twrp,
3494 };
3495
3496 ret = fruit_stat_base(handle, &smb_fname, false);
3497 if (ret != 0) {
3498 return -1;
3499 }
3500 *sbuf = smb_fname.st;
3501
3502 ino = hash_inode(sbuf, fsp->fsp_name->stream_name);
3503
3504 ret = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
3505 if (ret != 0) {
3506 return -1;
3507 }
3508
3509 sbuf->st_ex_ino = ino;
3510 return 0;
3511 }
3512
3513 static int fruit_fstat_meta_netatalk(vfs_handle_struct *handle,
3514 files_struct *fsp,
3515 SMB_STRUCT_STAT *sbuf)
3516 {
3517 int ret;
3518
3519 ret = fruit_stat_base(handle, fsp->base_fsp->fsp_name, false);
3520 if (ret != 0) {
3521 return -1;
3522 }
3523
3524 *sbuf = fsp->base_fsp->fsp_name->st;
3525 sbuf->st_ex_size = AFP_INFO_SIZE;
3526 sbuf->st_ex_ino = hash_inode(sbuf, fsp->fsp_name->stream_name);
3527
3528 return 0;
3529 }
3530
3531 static int fruit_fstat_meta(vfs_handle_struct *handle,
3532 files_struct *fsp,
3533 SMB_STRUCT_STAT *sbuf,
3534 struct fio *fio)
3535 {
3536 int ret;
3537
3538 DBG_DEBUG("Path [%s]\n", fsp_str_dbg(fsp));
3539
3540 switch (fio->config->meta) {
3541 case FRUIT_META_STREAM:
3542 ret = fruit_fstat_meta_stream(handle, fsp, sbuf);
3543 break;
3544
3545 case FRUIT_META_NETATALK:
3546 ret = fruit_fstat_meta_netatalk(handle, fsp, sbuf);
3547 break;
3548
3549 default:
3550 DBG_ERR("Unexpected meta config [%d]\n", fio->config->meta);
3551 return -1;
3552 }
3553
3554 DBG_DEBUG("Path [%s] ret [%d]\n", fsp_str_dbg(fsp), ret);
3555 return ret;
3556 }
3557
3558 static int fruit_fstat_rsrc_xattr(vfs_handle_struct *handle,
3559 files_struct *fsp,
3560 SMB_STRUCT_STAT *sbuf)
3561 {
3562 return SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
3563 }
3564
3565 static int fruit_fstat_rsrc_stream(vfs_handle_struct *handle,
3566 files_struct *fsp,
3567 SMB_STRUCT_STAT *sbuf)
3568 {
3569 return SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
3570 }
3571
3572 static int fruit_fstat_rsrc_adouble(vfs_handle_struct *handle,
3573 files_struct *fsp,
3574 SMB_STRUCT_STAT *sbuf)
3575 {
3576 struct fio *fio = fruit_get_complete_fio(handle, fsp);
3577 struct adouble *ad = NULL;
3578 int ret;
3579
3580 if (fio == NULL || fio->ad_fsp == NULL) {
3581 DBG_ERR("fio/ad_fsp=NULL for [%s]\n", fsp_str_dbg(fsp));
3582 errno = EBADF;
3583 return -1;
3584 }
3585
3586 /* Populate the stat struct with info from the base file. */
3587 ret = fruit_stat_base(handle, fsp->base_fsp->fsp_name, false);
3588 if (ret == -1) {
3589 return -1;
3590 }
3591
3592 ad = ad_fget(talloc_tos(), handle, fio->ad_fsp, ADOUBLE_RSRC);
3593 if (ad == NULL) {
3594 DBG_ERR("ad_fget [%s] failed [%s]\n",
3595 fsp_str_dbg(fio->ad_fsp), strerror(errno));
3596 return -1;
3597 }
3598
3599 *sbuf = fsp->base_fsp->fsp_name->st;
3600 sbuf->st_ex_size = ad_getentrylen(ad, ADEID_RFORK);
3601 sbuf->st_ex_ino = hash_inode(sbuf, fsp->fsp_name->stream_name);
3602
3603 TALLOC_FREE(ad);
3604 return 0;
3605 }
3606
3607 static int fruit_fstat_rsrc(vfs_handle_struct *handle, files_struct *fsp,
3608 SMB_STRUCT_STAT *sbuf, struct fio *fio)
3609 {
3610 int ret;
3611
3612 switch (fio->config->rsrc) {
3613 case FRUIT_RSRC_STREAM:
3614 ret = fruit_fstat_rsrc_stream(handle, fsp, sbuf);
3615 break;
3616
3617 case FRUIT_RSRC_ADFILE:
3618 ret = fruit_fstat_rsrc_adouble(handle, fsp, sbuf);
3619 break;
3620
3621 case FRUIT_RSRC_XATTR:
3622 ret = fruit_fstat_rsrc_xattr(handle, fsp, sbuf);
3623 break;
3624
3625 default:
3626 DBG_ERR("Unexpected rsrc config [%d]\n", fio->config->rsrc);
3627 return -1;
3628 }
3629
3630 return ret;
3631 }
3632
3633 static int fruit_fstat(vfs_handle_struct *handle, files_struct *fsp,
3634 SMB_STRUCT_STAT *sbuf)
3635 {
3636 struct fio *fio = fruit_get_complete_fio(handle, fsp);
3637 int rc;
3638
3639 if (fio == NULL) {
3640 return SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
3641 }
3642
3643 DBG_DEBUG("Path [%s]\n", fsp_str_dbg(fsp));
3644
3645 if (fio->type == ADOUBLE_META) {
3646 rc = fruit_fstat_meta(handle, fsp, sbuf, fio);
3647 } else {
3648 rc = fruit_fstat_rsrc(handle, fsp, sbuf, fio);
3649 }
3650
3651 if (rc == 0) {
3652 sbuf->st_ex_mode &= ~S_IFMT;
3653 sbuf->st_ex_mode |= S_IFREG;
3654 sbuf->st_ex_blocks = sbuf->st_ex_size / STAT_ST_BLOCKSIZE + 1;
3655 }
3656
3657 DBG_DEBUG("Path [%s] rc [%d] size [%"PRIdMAX"]\n",
3658 fsp_str_dbg(fsp), rc, (intmax_t)sbuf->st_ex_size);
3659 return rc;
3660 }
3661
3662 static NTSTATUS delete_invalid_meta_stream(
3663 vfs_handle_struct *handle,
3664 const struct smb_filename *smb_fname,
3665 TALLOC_CTX *mem_ctx,
3666 unsigned int *pnum_streams,
3667 struct stream_struct **pstreams,
3668 off_t size)
3669 {
3670 struct smb_filename *sname = NULL;
3671 NTSTATUS status;
3672 int ret;
3673 bool ok;
3674
3675 ok = del_fruit_stream(mem_ctx, pnum_streams, pstreams, AFPINFO_STREAM);
3676 if (!ok) {
3677 return NT_STATUS_INTERNAL_ERROR;
3678 }
3679
3680 if (size == 0) {
3681 return NT_STATUS_OK;
3682 }
3683
3684 status = synthetic_pathref(talloc_tos(),
3685 handle->conn->cwd_fsp,
3686 smb_fname->base_name,
3687 AFPINFO_STREAM_NAME,
3688 NULL,
3689 smb_fname->twrp,
3690 0,
3691 &sname);
3692 if (!NT_STATUS_IS_OK(status)) {
3693 return NT_STATUS_NO_MEMORY;
3694 }
3695
3696 ret = SMB_VFS_NEXT_UNLINKAT(handle,
3697 handle->conn->cwd_fsp,
3698 sname,
3699 0);
3700 if (ret != 0) {
3701 DBG_ERR("Removing [%s] failed\n", smb_fname_str_dbg(sname));
3702 TALLOC_FREE(sname);
3703 return map_nt_error_from_unix(errno);
3704 }
3705
3706 TALLOC_FREE(sname);
3707 return NT_STATUS_OK;
3708 }
3709
3710 static NTSTATUS fruit_streaminfo_meta_stream(
3711 vfs_handle_struct *handle,
3712 struct files_struct *fsp,
3713 const struct smb_filename *smb_fname,
3714 TALLOC_CTX *mem_ctx,
3715 unsigned int *pnum_streams,
3716 struct stream_struct **pstreams)
3717 {
3718 struct stream_struct *stream = *pstreams;
3719 unsigned int num_streams = *pnum_streams;
3720 int i;
3721
3722 for (i = 0; i < num_streams; i++) {
3723 if (strequal_m(stream[i].name, AFPINFO_STREAM)) {
3724 break;
3725 }
3726 }
3727
3728 if (i == num_streams) {
3729 return NT_STATUS_OK;
3730 }
3731
3732 if (stream[i].size != AFP_INFO_SIZE) {
3733 DBG_ERR("Removing invalid AFPINFO_STREAM size [%jd] from [%s]\n",
3734 (intmax_t)stream[i].size, smb_fname_str_dbg(smb_fname));
3735
3736 return delete_invalid_meta_stream(handle,
3737 smb_fname,
3738 mem_ctx,
3739 pnum_streams,
3740 pstreams,
3741 stream[i].size);
3742 }
3743
3744
3745 return NT_STATUS_OK;
3746 }
3747
3748 static NTSTATUS fruit_streaminfo_meta_netatalk(
3749 vfs_handle_struct *handle,
3750 struct files_struct *fsp,
3751 const struct smb_filename *smb_fname,
3752 TALLOC_CTX *mem_ctx,
3753 unsigned int *pnum_streams,
3754 struct stream_struct **pstreams)
3755 {
3756 struct stream_struct *stream = *pstreams;
3757 unsigned int num_streams = *pnum_streams;
3758 struct adouble *ad = NULL;
3759 bool is_fi_empty;
3760 int i;
3761 bool ok;
3762
3763 /* Remove the Netatalk xattr from the list */
3764 ok = del_fruit_stream(mem_ctx, pnum_streams, pstreams,
3765 ":" NETATALK_META_XATTR ":$DATA");
3766 if (!ok) {
3767 return NT_STATUS_NO_MEMORY;
3768 }
3769
3770 /*
3771 * Check if there's a AFPINFO_STREAM from the VFS streams
3772 * backend and if yes, remove it from the list
3773 */
3774 for (i = 0; i < num_streams; i++) {
3775 if (strequal_m(stream[i].name, AFPINFO_STREAM)) {
3776 break;
3777 }
3778 }
3779
3780 if (i < num_streams) {
3781 DBG_WARNING("Unexpected AFPINFO_STREAM on [%s]\n",
3782 smb_fname_str_dbg(smb_fname));
3783
3784 ok = del_fruit_stream(mem_ctx, pnum_streams, pstreams,
3785 AFPINFO_STREAM);
3786 if (!ok) {
3787 return NT_STATUS_INTERNAL_ERROR;
3788 }
3789 }
3790
3791 ad = ad_get_meta_fsp(talloc_tos(), handle, smb_fname);
3792 if (ad == NULL) {
3793 return NT_STATUS_OK;
3794 }
3795
3796 is_fi_empty = ad_empty_finderinfo(ad);
3797 TALLOC_FREE(ad);
3798
3799 if (is_fi_empty) {
3800 return NT_STATUS_OK;
3801 }
3802
3803 ok = add_fruit_stream(mem_ctx, pnum_streams, pstreams,
3804 AFPINFO_STREAM_NAME, AFP_INFO_SIZE,
3805 smb_roundup(handle->conn, AFP_INFO_SIZE));
3806 if (!ok) {
3807 return NT_STATUS_NO_MEMORY;
3808 }
3809
3810 return NT_STATUS_OK;
3811 }
3812
3813 static NTSTATUS fruit_streaminfo_meta(vfs_handle_struct *handle,
3814 struct files_struct *fsp,
3815 const struct smb_filename *smb_fname,
3816 TALLOC_CTX *mem_ctx,
3817 unsigned int *pnum_streams,
3818 struct stream_struct **pstreams)
3819 {
3820 struct fruit_config_data *config = NULL;
3821 NTSTATUS status;
3822
3823 SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
3824 return NT_STATUS_INTERNAL_ERROR);
3825
3826 switch (config->meta) {
3827 case FRUIT_META_NETATALK:
3828 status = fruit_streaminfo_meta_netatalk(handle, fsp, smb_fname,
3829 mem_ctx, pnum_streams,
3830 pstreams);
3831 break;
3832
3833 case FRUIT_META_STREAM:
3834 status = fruit_streaminfo_meta_stream(handle, fsp, smb_fname,
3835 mem_ctx, pnum_streams,
3836 pstreams);
3837 break;
3838
3839 default:
3840 return NT_STATUS_INTERNAL_ERROR;
3841 }
3842
3843 return status;
3844 }
3845
3846 static NTSTATUS fruit_streaminfo_rsrc_stream(
3847 vfs_handle_struct *handle,
3848 struct files_struct *fsp,
3849 const struct smb_filename *smb_fname,
3850 TALLOC_CTX *mem_ctx,
3851 unsigned int *pnum_streams,
3852 struct stream_struct **pstreams)
3853 {
3854 bool ok;
3855
3856 ok = filter_empty_rsrc_stream(pnum_streams, pstreams);
3857 if (!ok) {
3858 DBG_ERR("Filtering resource stream failed\n");
3859 return NT_STATUS_INTERNAL_ERROR;
3860 }
3861 return NT_STATUS_OK;
3862 }
3863
3864 static NTSTATUS fruit_streaminfo_rsrc_xattr(
3865 vfs_handle_struct *handle,
3866 struct files_struct *fsp,
3867 const struct smb_filename *smb_fname,
3868 TALLOC_CTX *mem_ctx,
3869 unsigned int *pnum_streams,
3870 struct stream_struct **pstreams)
3871 {
3872 bool ok;
3873
3874 ok = filter_empty_rsrc_stream(pnum_streams, pstreams);
3875 if (!ok) {
3876 DBG_ERR("Filtering resource stream failed\n");
3877 return NT_STATUS_INTERNAL_ERROR;
3878 }
3879 return NT_STATUS_OK;
3880 }
3881
3882 static NTSTATUS fruit_streaminfo_rsrc_adouble(
3883 vfs_handle_struct *handle,
3884 struct files_struct *fsp,
3885 const struct smb_filename *smb_fname,
3886 TALLOC_CTX *mem_ctx,
3887 unsigned int *pnum_streams,
3888 struct stream_struct **pstreams)
3889 {
3890 struct stream_struct *stream = *pstreams;
3891 unsigned int num_streams = *pnum_streams;
3892 struct adouble *ad = NULL;
3893 bool ok;
3894 size_t rlen;
3895 int i;
3896
3897 /*
3898 * Check if there's a AFPRESOURCE_STREAM from the VFS streams backend
3899 * and if yes, remove it from the list
3900 */
3901 for (i = 0; i < num_streams; i++) {
3902 if (strequal_m(stream[i].name, AFPRESOURCE_STREAM)) {
3903 break;
3904 }
3905 }
3906
3907 if (i < num_streams) {
3908 DBG_WARNING("Unexpected AFPRESOURCE_STREAM on [%s]\n",
3909 smb_fname_str_dbg(smb_fname));
3910
3911 ok = del_fruit_stream(mem_ctx, pnum_streams, pstreams,
3912 AFPRESOURCE_STREAM);
3913 if (!ok) {
3914 return NT_STATUS_INTERNAL_ERROR;
3915 }
3916 }
3917
3918 ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_RSRC);
3919 if (ad == NULL) {
3920 return NT_STATUS_OK;
3921 }
3922
3923 rlen = ad_getentrylen(ad, ADEID_RFORK);
3924 TALLOC_FREE(ad);
3925
3926 if (rlen == 0) {
3927 return NT_STATUS_OK;
3928 }
3929
3930 ok = add_fruit_stream(mem_ctx, pnum_streams, pstreams,
3931 AFPRESOURCE_STREAM_NAME, rlen,
3932 smb_roundup(handle->conn, rlen));
3933 if (!ok) {
3934 return NT_STATUS_NO_MEMORY;
3935 }
3936
3937 return NT_STATUS_OK;
3938 }
3939
3940 static NTSTATUS fruit_streaminfo_rsrc(vfs_handle_struct *handle,
3941 struct files_struct *fsp,
3942 const struct smb_filename *smb_fname,
3943 TALLOC_CTX *mem_ctx,
3944 unsigned int *pnum_streams,
3945 struct stream_struct **pstreams)
3946 {
3947 struct fruit_config_data *config = NULL;
3948 NTSTATUS status;
3949
3950 if (S_ISDIR(smb_fname->st.st_ex_mode)) {
3951 return NT_STATUS_OK;
3952 }
3953
3954 SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
3955 return NT_STATUS_INTERNAL_ERROR);
3956
3957 switch (config->rsrc) {
3958 case FRUIT_RSRC_STREAM:
3959 status = fruit_streaminfo_rsrc_stream(handle, fsp, smb_fname,
3960 mem_ctx, pnum_streams,
3961 pstreams);
3962 break;
3963
3964 case FRUIT_RSRC_XATTR:
3965 status = fruit_streaminfo_rsrc_xattr(handle, fsp, smb_fname,
3966 mem_ctx, pnum_streams,
3967 pstreams);
3968 break;
3969
3970 case FRUIT_RSRC_ADFILE:
3971 status = fruit_streaminfo_rsrc_adouble(handle, fsp, smb_fname,
3972 mem_ctx, pnum_streams,
3973 pstreams);
3974 break;
3975
3976 default:
3977 return NT_STATUS_INTERNAL_ERROR;
3978 }
3979
3980 return status;
3981 }
3982
3983 static void fruit_filter_empty_streams(unsigned int *pnum_streams,
3984 struct stream_struct **pstreams)
3985 {
3986 unsigned num_streams = *pnum_streams;
3987 struct stream_struct *streams = *pstreams;
3988 unsigned i = 0;
3989
3990 if (!global_fruit_config.nego_aapl) {
3991 return;
3992 }
3993
3994 while (i < num_streams) {
3995 struct smb_filename smb_fname = (struct smb_filename) {
3996 .stream_name = streams[i].name,
3997 };
3998
3999 if (is_ntfs_default_stream_smb_fname(&smb_fname)
4000 || streams[i].size > 0)
4001 {
4002 i++;
4003 continue;
4004 }
4005
4006 streams[i] = streams[num_streams - 1];
4007 num_streams--;
4008 }
4009
4010 *pnum_streams = num_streams;
4011 }
4012
4013 static NTSTATUS fruit_fstreaminfo(vfs_handle_struct *handle,
4014 struct files_struct *fsp,
4015 TALLOC_CTX *mem_ctx,
4016 unsigned int *pnum_streams,
4017 struct stream_struct **pstreams)
4018 {
4019 struct fruit_config_data *config = NULL;
4020 const struct smb_filename *smb_fname = NULL;
4021 NTSTATUS status;
4022
4023 smb_fname = fsp->fsp_name;
4024
4025 SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
4026 return NT_STATUS_UNSUCCESSFUL);
4027
4028 DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
4029
4030 status = SMB_VFS_NEXT_FSTREAMINFO(handle, fsp, mem_ctx,
4031 pnum_streams, pstreams);
4032 if (!NT_STATUS_IS_OK(status)) {
4033 return status;
4034 }
4035
4036 fruit_filter_empty_streams(pnum_streams, pstreams);
4037
4038 status = fruit_streaminfo_meta(handle, fsp, smb_fname,
4039 mem_ctx, pnum_streams, pstreams);
4040 if (!NT_STATUS_IS_OK(status)) {
4041 return status;
4042 }
4043
4044 status = fruit_streaminfo_rsrc(handle, fsp, smb_fname,
4045 mem_ctx, pnum_streams, pstreams);
4046 if (!NT_STATUS_IS_OK(status)) {
4047 return status;
4048 }
4049
4050 return NT_STATUS_OK;
4051 }
4052
4053 static int fruit_fntimes(vfs_handle_struct *handle,
4054 files_struct *fsp,
4055 struct smb_file_time *ft)
4056 {
4057 int rc = 0;
4058 struct adouble *ad = NULL;
4059 struct fruit_config_data *config = NULL;
4060
4061 SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
4062 return -1);
4063
4064 if ((config->meta != FRUIT_META_NETATALK) ||
4065 is_omit_timespec(&ft->create_time))
4066 {
4067 return SMB_VFS_NEXT_FNTIMES(handle, fsp, ft);
4068 }
4069
4070 DBG_DEBUG("set btime for %s to %s\n", fsp_str_dbg(fsp),
4071 time_to_asc(convert_timespec_to_time_t(ft->create_time)));
4072
4073 ad = ad_fget(talloc_tos(), handle, fsp, ADOUBLE_META);
4074 if (ad == NULL) {
4075 goto exit;
4076 }
4077
4078 ad_setdate(ad, AD_DATE_CREATE | AD_DATE_UNIX,
4079 convert_time_t_to_uint32_t(ft->create_time.tv_sec));
4080
4081 rc = ad_fset(handle, ad, fsp);
4082
4083 exit:
4084
4085 TALLOC_FREE(ad);
4086 if (rc != 0) {
4087 DBG_WARNING("%s\n", fsp_str_dbg(fsp));
4088 return -1;
4089 }
4090 return SMB_VFS_NEXT_FNTIMES(handle, fsp, ft);
4091 }
4092
4093 static int fruit_fallocate(struct vfs_handle_struct *handle,
4094 struct files_struct *fsp,
4095 uint32_t mode,
4096 off_t offset,
4097 off_t len)
4098 {
4099 struct fio *fio = fruit_get_complete_fio(handle, fsp);
4100
4101 if (fio == NULL) {
4102 return SMB_VFS_NEXT_FALLOCATE(handle, fsp, mode, offset, len);
4103 }
4104
4105 /* Let the pwrite code path handle it. */
4106 errno = ENOSYS;
4107 return -1;
4108 }
4109
4110 static int fruit_ftruncate_rsrc_xattr(struct vfs_handle_struct *handle,
4111 struct files_struct *fsp,
4112 off_t offset)
4113 {
4114 #ifdef HAVE_ATTROPEN
4115 return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, offset);
4116 #endif
4117 return 0;
4118 }
4119
4120 static int fruit_ftruncate_rsrc_adouble(struct vfs_handle_struct *handle,
4121 struct files_struct *fsp,
4122 off_t offset)
4123 {
4124 struct fio *fio = fruit_get_complete_fio(handle, fsp);
4125 int rc;
4126 struct adouble *ad = NULL;
4127 off_t ad_off;
4128
4129 if (fio == NULL || fio->ad_fsp == NULL) {
4130 DBG_ERR("fio/ad_fsp=NULL for [%s]\n", fsp_str_dbg(fsp));
4131 errno = EBADF;
4132 return -1;
4133 }
4134
4135 ad = ad_fget(talloc_tos(), handle, fio->ad_fsp, ADOUBLE_RSRC);
4136 if (ad == NULL) {
4137 DBG_ERR("ad_fget [%s] failed [%s]\n",
4138 fsp_str_dbg(fio->ad_fsp), strerror(errno));
4139 return -1;
4140 }
4141
4142 ad_off = ad_getentryoff(ad, ADEID_RFORK);
4143
4144 rc = SMB_VFS_NEXT_FTRUNCATE(handle, fio->ad_fsp, offset + ad_off);
4145 if (rc != 0) {
4146 TALLOC_FREE(ad);
4147 return -1;
4148 }
4149
4150 ad_setentrylen(ad, ADEID_RFORK, offset);
4151
4152 rc = ad_fset(handle, ad, fio->ad_fsp);
4153 if (rc != 0) {
4154 DBG_ERR("ad_fset [%s] failed [%s]\n",
4155 fsp_str_dbg(fio->ad_fsp), strerror(errno));
4156 TALLOC_FREE(ad);
4157 return -1;
4158 }
4159
4160 TALLOC_FREE(ad);
4161 return 0;
4162 }
4163
4164 static int fruit_ftruncate_rsrc_stream(struct vfs_handle_struct *handle,
4165 struct files_struct *fsp,
4166 off_t offset)
4167 {
4168 return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, offset);
4169 }
4170
4171 static int fruit_ftruncate_rsrc(struct vfs_handle_struct *handle,
4172 struct files_struct *fsp,
4173 off_t offset)
4174 {
4175 struct fio *fio = fruit_get_complete_fio(handle, fsp);
4176 int ret;
4177
4178 if (fio == NULL) {
4179 DBG_ERR("Failed to fetch fsp extension");
4180 return -1;
4181 }
4182
4183 switch (fio->config->rsrc) {
4184 case FRUIT_RSRC_XATTR:
4185 ret = fruit_ftruncate_rsrc_xattr(handle, fsp, offset);
4186 break;
4187
4188 case FRUIT_RSRC_ADFILE:
4189 ret = fruit_ftruncate_rsrc_adouble(handle, fsp, offset);
4190 break;
4191
4192 case FRUIT_RSRC_STREAM:
4193 ret = fruit_ftruncate_rsrc_stream(handle, fsp, offset);
4194 break;
4195
4196 default:
4197 DBG_ERR("Unexpected rsrc config [%d]\n", fio->config->rsrc);
4198 return -1;
4199 }
4200
4201
4202 return ret;
4203 }
4204
4205 static int fruit_ftruncate_meta(struct vfs_handle_struct *handle,
4206 struct files_struct *fsp,
4207 off_t offset)
4208 {
4209 if (offset > 60) {
4210 DBG_WARNING("ftruncate %s to %jd",
4211 fsp_str_dbg(fsp), (intmax_t)offset);
4212 /* OS X returns NT_STATUS_ALLOTTED_SPACE_EXCEEDED */
4213 errno = EOVERFLOW;
4214 return -1;
4215 }
4216
4217 /* OS X returns success but does nothing */
4218 DBG_INFO("ignoring ftruncate %s to %jd\n",
4219 fsp_str_dbg(fsp), (intmax_t)offset);
4220 return 0;
4221 }
4222
4223 static int fruit_ftruncate(struct vfs_handle_struct *handle,
4224 struct files_struct *fsp,
4225 off_t offset)
4226 {
4227 struct fio *fio = fruit_get_complete_fio(handle, fsp);
4228 int ret;
4229
4230 DBG_DEBUG("Path [%s] offset [%"PRIdMAX"]\n", fsp_str_dbg(fsp),
4231 (intmax_t)offset);
4232
4233 if (fio == NULL) {
4234 return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, offset);
4235 }
4236
4237 if (fio->type == ADOUBLE_META) {
4238 ret = fruit_ftruncate_meta(handle, fsp, offset);
4239 } else {
4240 ret = fruit_ftruncate_rsrc(handle, fsp, offset);
4241 }
4242
4243 DBG_DEBUG("Path [%s] result [%d]\n", fsp_str_dbg(fsp), ret);
4244 return ret;
4245 }
4246
4247 static NTSTATUS fruit_create_file(vfs_handle_struct *handle,
4248 struct smb_request *req,
4249 struct files_struct *dirfsp,
4250 struct smb_filename *smb_fname,
4251 uint32_t access_mask,
4252 uint32_t share_access,
4253 uint32_t create_disposition,
4254 uint32_t create_options,
4255 uint32_t file_attributes,
4256 uint32_t oplock_request,
4257 const struct smb2_lease *lease,
4258 uint64_t allocation_size,
4259 uint32_t private_flags,
4260 struct security_descriptor *sd,
4261 struct ea_list *ea_list,
4262 files_struct **result,
4263 int *pinfo,
4264 const struct smb2_create_blobs *in_context_blobs,
4265 struct smb2_create_blobs *out_context_blobs)
4266 {
4267 NTSTATUS status;
4268 struct fruit_config_data *config = NULL;
4269 files_struct *fsp = NULL;
4270 bool internal_open = (oplock_request & INTERNAL_OPEN_ONLY);
4271 int ret;
4272
4273 status = check_aapl(handle, req, in_context_blobs, out_context_blobs);
4274 if (!NT_STATUS_IS_OK(status)) {
4275 goto fail;
4276 }
4277
4278 SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
4279 return NT_STATUS_UNSUCCESSFUL);
4280
4281 if (is_apple_stream(smb_fname->stream_name) &&
4282 !internal_open &&
4283 config->convert_adouble)
4284 {
4285 uint32_t conv_flags = 0;
4286
4287 if (config->wipe_intentionally_left_blank_rfork) {
4288 conv_flags |= AD_CONV_WIPE_BLANK;
4289 }
4290 if (config->delete_empty_adfiles) {
4291 conv_flags |= AD_CONV_DELETE;
4292 }
4293
4294 ret = ad_convert(handle,
4295 smb_fname,
4296 macos_string_replace_map,
4297 conv_flags);
4298 if (ret != 0) {
4299 DBG_ERR("ad_convert(\"%s\") failed\n",
4300 smb_fname_str_dbg(smb_fname));
4301 }
4302 }
4303
4304 status = SMB_VFS_NEXT_CREATE_FILE(
4305 handle, req, dirfsp, smb_fname,
4306 access_mask, share_access,
4307 create_disposition, create_options,
4308 file_attributes, oplock_request,
4309 lease,
4310 allocation_size, private_flags,
4311 sd, ea_list, result,
4312 pinfo, in_context_blobs, out_context_blobs);
4313 if (!NT_STATUS_IS_OK(status)) {
4314 return status;
4315 }
4316
4317 fsp = *result;
4318
4319 if (global_fruit_config.nego_aapl) {
4320 if (config->posix_rename && fsp->fsp_flags.is_directory) {
4321 /*
4322 * Enable POSIX directory rename behaviour
4323 */
4324 fsp->posix_flags |= FSP_POSIX_FLAGS_RENAME;
4325 }
4326 }
4327
4328 /*
4329 * If this is a plain open for existing files, opening an 0
4330 * byte size resource fork MUST fail with
4331 * NT_STATUS_OBJECT_NAME_NOT_FOUND.
4332 *
4333 * Cf the vfs_fruit torture tests in test_rfork_create().
4334 */
4335 if (global_fruit_config.nego_aapl &&
4336 create_disposition == FILE_OPEN &&
4337 smb_fname->st.st_ex_size == 0 &&
4338 is_named_stream(smb_fname))
4339 {
4340 status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
4341 goto fail;
4342 }
4343
4344 if (is_named_stream(smb_fname) || fsp->fsp_flags.is_directory) {
4345 return status;
4346 }
4347
4348 if ((config->locking == FRUIT_LOCKING_NETATALK) &&
4349 (fsp->op != NULL) &&
4350 !fsp->fsp_flags.is_pathref)
4351 {
4352 status = fruit_check_access(
4353 handle, *result,
4354 access_mask,
4355 share_access);
4356 if (!NT_STATUS_IS_OK(status)) {
4357 goto fail;
4358 }
4359 }
4360
4361 return status;
4362
4363 fail:
4364 DEBUG(10, ("fruit_create_file: %s\n", nt_errstr(status)));
4365
4366 if (fsp) {
4367 close_file_free(req, &fsp, ERROR_CLOSE);
4368 *result = NULL;
4369 }
4370
4371 return status;
4372 }
4373
4374 static NTSTATUS fruit_freaddir_attr(struct vfs_handle_struct *handle,
4375 struct files_struct *fsp,
4376 TALLOC_CTX *mem_ctx,
4377 struct readdir_attr_data **pattr_data)
4378 {
4379 struct fruit_config_data *config = NULL;
4380 struct readdir_attr_data *attr_data;
4381 uint32_t conv_flags = 0;
4382 NTSTATUS status;
4383 int ret;
4384
4385 SMB_VFS_HANDLE_GET_DATA(handle, config,
4386 struct fruit_config_data,
4387 return NT_STATUS_UNSUCCESSFUL);
4388
4389 if (!global_fruit_config.nego_aapl) {
4390 return SMB_VFS_NEXT_FREADDIR_ATTR(handle,
4391 fsp,
4392 mem_ctx,
4393 pattr_data);
4394 }
4395
4396 DBG_DEBUG("Path [%s]\n", fsp_str_dbg(fsp));
4397
4398 if (config->convert_adouble) {
4399 if (config->wipe_intentionally_left_blank_rfork) {
4400 conv_flags |= AD_CONV_WIPE_BLANK;
4401 }
4402 if (config->delete_empty_adfiles) {
4403 conv_flags |= AD_CONV_DELETE;
4404 }
4405
4406 ret = ad_convert(handle,
4407 fsp->fsp_name,
4408 macos_string_replace_map,
4409 conv_flags);
4410 if (ret != 0) {
4411 DBG_ERR("ad_convert(\"%s\") failed\n",
4412 fsp_str_dbg(fsp));
4413 }
4414 }
4415
4416 *pattr_data = talloc_zero(mem_ctx, struct readdir_attr_data);
4417 if (*pattr_data == NULL) {
4418 return NT_STATUS_NO_MEMORY;
4419 }
4420 attr_data = *pattr_data;
4421 attr_data->type = RDATTR_AAPL;
4422
4423 /*
4424 * Mac metadata: compressed FinderInfo, resource fork length
4425 * and creation date
4426 */
4427 status = readdir_attr_macmeta(handle, fsp->fsp_name, attr_data);
4428 if (!NT_STATUS_IS_OK(status)) {
4429 /*
4430 * Error handling is tricky: if we return failure from
4431 * this function, the corresponding directory entry
4432 * will to be passed to the client, so we really just
4433 * want to error out on fatal errors.
4434 */
4435 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
4436 goto fail;
4437 }
4438 }
4439
4440 /*
4441 * UNIX mode
4442 */
4443 if (config->unix_info_enabled) {
4444 attr_data->attr_data.aapl.unix_mode =
4445 fsp->fsp_name->st.st_ex_mode;
4446 }
4447
4448 /*
4449 * max_access
4450 */
4451 if (!config->readdir_attr_max_access) {
4452 attr_data->attr_data.aapl.max_access = FILE_GENERIC_ALL;
4453 } else {
4454 status = smbd_calculate_access_mask_fsp(fsp->conn->cwd_fsp,
4455 fsp,
4456 false,
4457 SEC_FLAG_MAXIMUM_ALLOWED,
4458 &attr_data->attr_data.aapl.max_access);
4459 if (!NT_STATUS_IS_OK(status)) {
4460 goto fail;
4461 }
4462 }
4463
4464 return NT_STATUS_OK;
4465
4466 fail:
4467 DBG_WARNING("Path [%s], error: %s\n", fsp_str_dbg(fsp),
4468 nt_errstr(status));
4469 TALLOC_FREE(*pattr_data);
4470 return status;
4471 }
4472
4473 static NTSTATUS fruit_fget_nt_acl(vfs_handle_struct *handle,
4474 files_struct *fsp,
4475 uint32_t security_info,
4476 TALLOC_CTX *mem_ctx,
4477 struct security_descriptor **ppdesc)
4478 {
4479 NTSTATUS status;
4480 struct security_ace ace;
4481 struct dom_sid sid;
4482 struct fruit_config_data *config;
4483
4484 SMB_VFS_HANDLE_GET_DATA(handle, config,
4485 struct fruit_config_data,
4486 return NT_STATUS_UNSUCCESSFUL);
4487
4488 status = SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info,
4489 mem_ctx, ppdesc);
4490 if (!NT_STATUS_IS_OK(status)) {
4491 return status;
4492 }
4493
4494 /*
4495 * Add MS NFS style ACEs with uid, gid and mode
4496 */
4497 if (!global_fruit_config.nego_aapl) {
4498 return NT_STATUS_OK;
4499 }
4500 if (!config->unix_info_enabled) {
4501 return NT_STATUS_OK;
4502 }
4503
4504 /* First remove any existing ACE's with NFS style mode/uid/gid SIDs. */
4505 status = remove_virtual_nfs_aces(*ppdesc);
4506 if (!NT_STATUS_IS_OK(status)) {
4507 DBG_WARNING("failed to remove MS NFS style ACEs\n");
4508 return status;
4509 }
4510
4511 /* MS NFS style mode */
4512 sid_compose(&sid, &global_sid_Unix_NFS_Mode, fsp->fsp_name->st.st_ex_mode);
4513 init_sec_ace(&ace, &sid, SEC_ACE_TYPE_ACCESS_DENIED, 0, 0);
4514 status = security_descriptor_dacl_add(*ppdesc, &ace);
4515 if (!NT_STATUS_IS_OK(status)) {
4516 DEBUG(1,("failed to add MS NFS style ACE\n"));
4517 return status;
4518 }
4519
4520 /* MS NFS style uid */
4521 sid_compose(&sid, &global_sid_Unix_NFS_Users, fsp->fsp_name->st.st_ex_uid);
4522 init_sec_ace(&ace, &sid, SEC_ACE_TYPE_ACCESS_DENIED, 0, 0);
4523 status = security_descriptor_dacl_add(*ppdesc, &ace);
4524 if (!NT_STATUS_IS_OK(status)) {
4525 DEBUG(1,("failed to add MS NFS style ACE\n"));
4526 return status;
4527 }
4528
4529 /* MS NFS style gid */
4530 sid_compose(&sid, &global_sid_Unix_NFS_Groups, fsp->fsp_name->st.st_ex_gid);
4531 init_sec_ace(&ace, &sid, SEC_ACE_TYPE_ACCESS_DENIED, 0, 0);
4532 status = security_descriptor_dacl_add(*ppdesc, &ace);
4533 if (!NT_STATUS_IS_OK(status)) {
4534 DEBUG(1,("failed to add MS NFS style ACE\n"));
4535 return status;
4536 }
4537
4538 return NT_STATUS_OK;
4539 }
4540
4541 static NTSTATUS fruit_fset_nt_acl(vfs_handle_struct *handle,
4542 files_struct *fsp,
4543 uint32_t security_info_sent,
4544 const struct security_descriptor *orig_psd)
4545 {
4546 NTSTATUS status;
4547 bool do_chmod;
4548 mode_t ms_nfs_mode = 0;
4549 int result;
4550 struct security_descriptor *psd = NULL;
4551 uint32_t orig_num_aces = 0;
4552
4553 if (orig_psd->dacl != NULL) {
4554 orig_num_aces = orig_psd->dacl->num_aces;
4555 }
4556
4557 psd = security_descriptor_copy(talloc_tos(), orig_psd);
4558 if (psd == NULL) {
4559 return NT_STATUS_NO_MEMORY;
4560 }
4561
4562 DBG_DEBUG("fruit_fset_nt_acl: %s\n", fsp_str_dbg(fsp));
4563
4564 status = check_ms_nfs(handle, fsp, psd, &ms_nfs_mode, &do_chmod);
4565 if (!NT_STATUS_IS_OK(status)) {
4566 DEBUG(1, ("fruit_fset_nt_acl: check_ms_nfs failed%s\n", fsp_str_dbg(fsp)));
4567 TALLOC_FREE(psd);
4568 return status;
4569 }
4570
4571 /*
4572 * If only ms_nfs ACE entries were sent, ensure we set the DACL
4573 * sent/present flags correctly now we've removed them.
4574 */
4575
4576 if (orig_num_aces != 0) {
4577 /*
4578 * Are there any ACE's left ?
4579 */
4580 if (psd->dacl->num_aces == 0) {
4581 /* No - clear the DACL sent/present flags. */
4582 security_info_sent &= ~SECINFO_DACL;
4583 psd->type &= ~SEC_DESC_DACL_PRESENT;
4584 }
4585 }
4586
4587 status = SMB_VFS_NEXT_FSET_NT_ACL(handle, fsp, security_info_sent, psd);
4588 if (!NT_STATUS_IS_OK(status)) {
4589 DEBUG(1, ("fruit_fset_nt_acl: SMB_VFS_NEXT_FSET_NT_ACL failed%s\n", fsp_str_dbg(fsp)));
4590 TALLOC_FREE(psd);
4591 return status;
4592 }
4593
4594 if (do_chmod) {
4595 result = SMB_VFS_FCHMOD(fsp, ms_nfs_mode);
4596 if (result != 0) {
4597 DBG_WARNING("%s, result: %d, %04o error %s\n",
4598 fsp_str_dbg(fsp),
4599 result,
4600 (unsigned)ms_nfs_mode,
4601 strerror(errno));
4602 status = map_nt_error_from_unix(errno);
4603 TALLOC_FREE(psd);
4604 return status;
4605 }
4606 }
4607
4608 TALLOC_FREE(psd);
4609 return NT_STATUS_OK;
4610 }
4611
4612 static struct vfs_offload_ctx *fruit_offload_ctx;
4613
4614 struct fruit_offload_read_state {
4615 struct vfs_handle_struct *handle;
4616 struct tevent_context *ev;
4617 files_struct *fsp;
4618 uint32_t fsctl;
4619 uint32_t flags;
4620 uint64_t xferlen;
4621 DATA_BLOB token;
4622 };
4623
4624 static void fruit_offload_read_done(struct tevent_req *subreq);
4625
4626 static struct tevent_req *fruit_offload_read_send(
4627 TALLOC_CTX *mem_ctx,
4628 struct tevent_context *ev,
4629 struct vfs_handle_struct *handle,
4630 files_struct *fsp,
4631 uint32_t fsctl,
4632 uint32_t ttl,
4633 off_t offset,
4634 size_t to_copy)
4635 {
4636 struct tevent_req *req = NULL;
4637 struct tevent_req *subreq = NULL;
4638 struct fruit_offload_read_state *state = NULL;
4639
4640 req = tevent_req_create(mem_ctx, &state,
4641 struct fruit_offload_read_state);
4642 if (req == NULL) {
4643 return NULL;
4644 }
4645 *state = (struct fruit_offload_read_state) {
4646 .handle = handle,
4647 .ev = ev,
4648 .fsp = fsp,
4649 .fsctl = fsctl,
4650 };
4651
4652 subreq = SMB_VFS_NEXT_OFFLOAD_READ_SEND(mem_ctx, ev, handle, fsp,
4653 fsctl, ttl, offset, to_copy);
4654 if (tevent_req_nomem(subreq, req)) {
4655 return tevent_req_post(req, ev);
4656 }
4657 tevent_req_set_callback(subreq, fruit_offload_read_done, req);
4658 return req;
4659 }
4660
4661 static void fruit_offload_read_done(struct tevent_req *subreq)
4662 {
4663 struct tevent_req *req = tevent_req_callback_data(
4664 subreq, struct tevent_req);
4665 struct fruit_offload_read_state *state = tevent_req_data(
4666 req, struct fruit_offload_read_state);
4667 NTSTATUS status;
4668
4669 status = SMB_VFS_NEXT_OFFLOAD_READ_RECV(subreq,
4670 state->handle,
4671 state,
4672 &state->flags,
4673 &state->xferlen,
4674 &state->token);
4675 TALLOC_FREE(subreq);
4676 if (tevent_req_nterror(req, status)) {
4677 return;
4678 }
4679
4680 if (state->fsctl != FSCTL_SRV_REQUEST_RESUME_KEY) {
4681 tevent_req_done(req);
4682 return;
4683 }
4684
4685 status = vfs_offload_token_ctx_init(state->fsp->conn->sconn->client,
4686 &fruit_offload_ctx);
4687 if (tevent_req_nterror(req, status)) {
4688 return;
4689 }
4690
4691 status = vfs_offload_token_db_store_fsp(fruit_offload_ctx,
4692 state->fsp,
4693 &state->token);
4694 if (tevent_req_nterror(req, status)) {
4695 return;
4696 }
4697
4698 tevent_req_done(req);
4699 return;
4700 }
4701
4702 static NTSTATUS fruit_offload_read_recv(struct tevent_req *req,
4703 struct vfs_handle_struct *handle,
4704 TALLOC_CTX *mem_ctx,
4705 uint32_t *flags,
4706 uint64_t *xferlen,
4707 DATA_BLOB *token)
4708 {
4709 struct fruit_offload_read_state *state = tevent_req_data(
4710 req, struct fruit_offload_read_state);
4711 NTSTATUS status;
4712
4713 if (tevent_req_is_nterror(req, &status)) {
4714 tevent_req_received(req);
4715 return status;
4716 }
4717
4718 *flags = state->flags;
4719 *xferlen = state->xferlen;
4720 token->length = state->token.length;
4721 token->data = talloc_move(mem_ctx, &state->token.data);
4722
4723 tevent_req_received(req);
4724 return NT_STATUS_OK;
4725 }
4726
4727 struct fruit_offload_write_state {
4728 struct vfs_handle_struct *handle;
4729 off_t copied;
4730 struct files_struct *src_fsp;
4731 struct files_struct *dst_fsp;
4732 bool is_copyfile;
4733 };
4734
4735 static void fruit_offload_write_done(struct tevent_req *subreq);
4736 static struct tevent_req *fruit_offload_write_send(struct vfs_handle_struct *handle,
4737 TALLOC_CTX *mem_ctx,
4738 struct tevent_context *ev,
4739 uint32_t fsctl,
4740 DATA_BLOB *token,
4741 off_t transfer_offset,
4742 struct files_struct *dest_fsp,
4743 off_t dest_off,
4744 off_t num)
4745 {
4746 struct tevent_req *req, *subreq;
4747 struct fruit_offload_write_state *state;
4748 NTSTATUS status;
4749 struct fruit_config_data *config;
4750 off_t src_off = transfer_offset;
4751 files_struct *src_fsp = NULL;
4752 off_t to_copy = num;
4753 bool copyfile_enabled = false;
4754
4755 DEBUG(10,("soff: %ju, doff: %ju, len: %ju\n",
4756 (uintmax_t)src_off, (uintmax_t)dest_off, (uintmax_t)num));
4757
4758 SMB_VFS_HANDLE_GET_DATA(handle, config,
4759 struct fruit_config_data,
4760 return NULL);
4761
4762 req = tevent_req_create(mem_ctx, &state,
4763 struct fruit_offload_write_state);
4764 if (req == NULL) {
4765 return NULL;
4766 }
4767 state->handle = handle;
4768 state->dst_fsp = dest_fsp;
4769
4770 switch (fsctl) {
4771 case FSCTL_SRV_COPYCHUNK:
4772 case FSCTL_SRV_COPYCHUNK_WRITE:
4773 copyfile_enabled = config->copyfile_enabled;
4774 break;
4775 default:
4776 break;
4777 }
4778
4779 /*
4780 * Check if this a OS X copyfile style copychunk request with
4781 * a requested chunk count of 0 that was translated to a
4782 * offload_write_send VFS call overloading the parameters src_off
4783 * = dest_off = num = 0.
4784 */
4785 if (copyfile_enabled && num == 0 && src_off == 0 && dest_off == 0) {
4786 status = vfs_offload_token_db_fetch_fsp(
4787 fruit_offload_ctx, token, &src_fsp);
4788 if (tevent_req_nterror(req, status)) {
4789 return tevent_req_post(req, ev);
4790 }
4791 state->src_fsp = src_fsp;
4792
4793 status = vfs_stat_fsp(src_fsp);
4794 if (tevent_req_nterror(req, status)) {
4795 return tevent_req_post(req, ev);
4796 }
4797
4798 to_copy = src_fsp->fsp_name->st.st_ex_size;
4799 state->is_copyfile = true;
4800 }
4801
4802 subreq = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle,
4803 mem_ctx,
4804 ev,
4805 fsctl,
4806 token,
4807 transfer_offset,
4808 dest_fsp,
4809 dest_off,
4810 to_copy);
4811 if (tevent_req_nomem(subreq, req)) {
4812 return tevent_req_post(req, ev);
4813 }
4814
4815 tevent_req_set_callback(subreq, fruit_offload_write_done, req);
4816 return req;
4817 }
4818
4819 static void fruit_offload_write_done(struct tevent_req *subreq)
4820 {
4821 struct tevent_req *req = tevent_req_callback_data(
4822 subreq, struct tevent_req);
4823 struct fruit_offload_write_state *state = tevent_req_data(
4824 req, struct fruit_offload_write_state);
4825 NTSTATUS status;
4826 unsigned int num_streams = 0;
4827 struct stream_struct *streams = NULL;
4828 unsigned int i;
4829 struct smb_filename *src_fname_tmp = NULL;
4830 struct smb_filename *dst_fname_tmp = NULL;
4831
4832 status = SMB_VFS_NEXT_OFFLOAD_WRITE_RECV(state->handle,
4833 subreq,
4834 &state->copied);
4835 TALLOC_FREE(subreq);
4836 if (tevent_req_nterror(req, status)) {
4837 return;
4838 }
4839
4840 if (!state->is_copyfile) {
4841 tevent_req_done(req);
4842 return;
4843 }
4844
4845 /*
4846 * Now copy all remaining streams. We know the share supports
4847 * streams, because we're in vfs_fruit. We don't do this async
4848 * because streams are few and small.
4849 */
4850 status = vfs_fstreaminfo(state->src_fsp,
4851 req, &num_streams, &streams);
4852 if (tevent_req_nterror(req, status)) {
4853 return;
4854 }
4855
4856 if (num_streams == 1) {
4857 /* There is always one stream, ::$DATA. */
4858 tevent_req_done(req);
4859 return;
4860 }
4861
4862 for (i = 0; i < num_streams; i++) {
4863 DEBUG(10, ("%s: stream: '%s'/%zu\n",
4864 __func__, streams[i].name, (size_t)streams[i].size));
4865
4866 src_fname_tmp = synthetic_smb_fname(
4867 req,
4868 state->src_fsp->fsp_name->base_name,
4869 streams[i].name,
4870 NULL,
4871 state->src_fsp->fsp_name->twrp,
4872 state->src_fsp->fsp_name->flags);
4873 if (tevent_req_nomem(src_fname_tmp, req)) {
4874 return;
4875 }
4876
4877 if (is_ntfs_default_stream_smb_fname(src_fname_tmp)) {
4878 TALLOC_FREE(src_fname_tmp);
4879 continue;
4880 }
4881
4882 dst_fname_tmp = synthetic_smb_fname(
4883 req,
4884 state->dst_fsp->fsp_name->base_name,
4885 streams[i].name,
4886 NULL,
4887 state->dst_fsp->fsp_name->twrp,
4888 state->dst_fsp->fsp_name->flags);
4889 if (tevent_req_nomem(dst_fname_tmp, req)) {
4890 TALLOC_FREE(src_fname_tmp);
4891 return;
4892 }
4893
4894 status = copy_file(req,
4895 state->handle->conn,
4896 src_fname_tmp,
4897 dst_fname_tmp,
4898 FILE_CREATE);
4899 if (!NT_STATUS_IS_OK(status)) {
4900 DEBUG(1, ("%s: copy %s to %s failed: %s\n", __func__,
4901 smb_fname_str_dbg(src_fname_tmp),
4902 smb_fname_str_dbg(dst_fname_tmp),
4903 nt_errstr(status)));
4904 TALLOC_FREE(src_fname_tmp);
4905 TALLOC_FREE(dst_fname_tmp);
4906 tevent_req_nterror(req, status);
4907 return;
4908 }
4909
4910 TALLOC_FREE(src_fname_tmp);
4911 TALLOC_FREE(dst_fname_tmp);
4912 }
4913
4914 TALLOC_FREE(streams);
4915 TALLOC_FREE(src_fname_tmp);
4916 TALLOC_FREE(dst_fname_tmp);
4917 tevent_req_done(req);
4918 }
4919
4920 static NTSTATUS fruit_offload_write_recv(struct vfs_handle_struct *handle,
4921 struct tevent_req *req,
4922 off_t *copied)
4923 {
4924 struct fruit_offload_write_state *state = tevent_req_data(
4925 req, struct fruit_offload_write_state);
4926 NTSTATUS status;
4927
4928 if (tevent_req_is_nterror(req, &status)) {
4929 DEBUG(1, ("server side copy chunk failed: %s\n",
4930 nt_errstr(status)));
4931 *copied = 0;
4932 tevent_req_received(req);
4933 return status;
4934 }
4935
4936 *copied = state->copied;
4937 tevent_req_received(req);
4938
4939 return NT_STATUS_OK;
4940 }
4941
4942 static char *fruit_get_bandsize_line(char **lines, int numlines)
4943 {
4944 static regex_t re;
4945 static bool re_initialized = false;
4946 int i;
4947 int ret;
4948
4949 if (!re_initialized) {
4950 ret = regcomp(&re, "^[[:blank:]]*<key>band-size</key>$", 0);
4951 if (ret != 0) {
4952 return NULL;
4953 }
4954 re_initialized = true;
4955 }
4956
4957 for (i = 0; i < numlines; i++) {
4958 regmatch_t matches[1];
4959
4960 ret = regexec(&re, lines[i], 1, matches, 0);
4961 if (ret == 0) {
4962 /*
4963 * Check if the match was on the last line, sa we want
4964 * the subsequent line.
4965 */
4966 if (i + 1 == numlines) {
4967 return NULL;
4968 }
4969 return lines[i + 1];
4970 }
4971 if (ret != REG_NOMATCH) {
4972 return NULL;
4973 }
4974 }
4975
4976 return NULL;
4977 }
4978
4979 static bool fruit_get_bandsize_from_line(char *line, size_t *_band_size)
4980 {
4981 static regex_t re;
4982 static bool re_initialized = false;
4983 regmatch_t matches[2];
4984 uint64_t band_size;
4985 int ret;
4986 bool ok;
4987
4988 if (!re_initialized) {
4989 ret = regcomp(&re,
4990 "^[[:blank:]]*"
4991 "<integer>\\([[:digit:]]*\\)</integer>$",
4992 0);
4993 if (ret != 0) {
4994 return false;
4995 }
4996 re_initialized = true;
4997 }
4998
4999 ret = regexec(&re, line, 2, matches, 0);
5000 if (ret != 0) {
5001 DBG_ERR("regex failed [%s]\n", line);
5002 return false;
5003 }
5004
5005 line[matches[1].rm_eo] = '\0';
5006
5007 ok = conv_str_u64(&line[matches[1].rm_so], &band_size);
5008 if (!ok) {
5009 return false;
5010 }
5011 *_band_size = (size_t)band_size;
5012 return true;
5013 }
5014
5015 /*
5016 * This reads and parses an Info.plist from a TM sparsebundle looking for the
5017 * "band-size" key and value.
5018 */
5019 static bool fruit_get_bandsize(vfs_handle_struct *handle,
5020 const char *dir,
5021 size_t *band_size)
5022 {
5023 #define INFO_PLIST_MAX_SIZE 64*1024
5024 char *plist = NULL;
5025 struct smb_filename *smb_fname = NULL;
5026 files_struct *fsp = NULL;
5027 uint8_t *file_data = NULL;
5028 char **lines = NULL;
5029 char *band_size_line = NULL;
5030 size_t plist_file_size;
5031 ssize_t nread;
5032 int numlines;
5033 int ret;
5034 bool ok = false;
5035 NTSTATUS status;
5036
5037 plist = talloc_asprintf(talloc_tos(),
5038 "%s/%s/Info.plist",
5039 handle->conn->connectpath,
5040 dir);
5041 if (plist == NULL) {
5042 ok = false;
5043 goto out;
5044 }
5045
5046 smb_fname = synthetic_smb_fname(talloc_tos(),
5047 plist,
5048 NULL,
5049 NULL,
5050 0,
5051 0);
5052 if (smb_fname == NULL) {
5053 ok = false;
5054 goto out;
5055 }
5056
5057 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
5058 if (ret != 0) {
5059 DBG_INFO("Ignoring Sparsebundle without Info.plist [%s]\n", dir);
5060 ok = true;
5061 goto out;
5062 }
5063
5064 plist_file_size = smb_fname->st.st_ex_size;
5065
5066 if (plist_file_size > INFO_PLIST_MAX_SIZE) {
5067 DBG_INFO("%s is too large, ignoring\n", plist);
5068 ok = true;
5069 goto out;
5070 }
5071
5072 status = SMB_VFS_NEXT_CREATE_FILE(
5073 handle, /* conn */
5074 NULL, /* req */
5075 NULL, /* dirfsp */
5076 smb_fname, /* fname */
5077 FILE_GENERIC_READ, /* access_mask */
5078 FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */
5079 FILE_OPEN, /* create_disposition */
5080 0, /* create_options */
5081 0, /* file_attributes */
5082 INTERNAL_OPEN_ONLY, /* oplock_request */
5083 NULL, /* lease */
5084 0, /* allocation_size */
5085 0, /* private_flags */
5086 NULL, /* sd */
5087 NULL, /* ea_list */
5088 &fsp, /* result */
5089 NULL, /* psbuf */
5090 NULL, NULL); /* create context */
5091 if (!NT_STATUS_IS_OK(status)) {
5092 DBG_INFO("Opening [%s] failed [%s]\n",
5093 smb_fname_str_dbg(smb_fname), nt_errstr(status));
5094 ok = false;
5095 goto out;
5096 }
5097
5098 file_data = talloc_zero_array(talloc_tos(),
5099 uint8_t,
5100 plist_file_size + 1);
5101 if (file_data == NULL) {
5102 ok = false;
5103 goto out;
5104 }
5105
5106 nread = SMB_VFS_NEXT_PREAD(handle, fsp, file_data, plist_file_size, 0);
5107 if (nread != plist_file_size) {
5108 DBG_ERR("Short read on [%s]: %zu/%zd\n",
5109 fsp_str_dbg(fsp), nread, plist_file_size);
5110 ok = false;
5111 goto out;
5112
5113 }
5114
5115 status = close_file_free(NULL, &fsp, NORMAL_CLOSE);
5116 if (!NT_STATUS_IS_OK(status)) {
5117 DBG_ERR("close_file failed: %s\n", nt_errstr(status));
5118 ok = false;
5119 goto out;
5120 }
5121
5122 lines = file_lines_parse((char *)file_data,
5123 plist_file_size,
5124 &numlines,
5125 talloc_tos());
5126 if (lines == NULL) {
5127 ok = false;
5128 goto out;
5129 }
5130
5131 band_size_line = fruit_get_bandsize_line(lines, numlines);
5132 if (band_size_line == NULL) {
5133 DBG_ERR("Didn't find band-size key in [%s]\n",
5134 smb_fname_str_dbg(smb_fname));
5135 ok = false;
5136 goto out;
5137 }
5138
5139 ok = fruit_get_bandsize_from_line(band_size_line, band_size);
5140 if (!ok) {
5141 DBG_ERR("fruit_get_bandsize_from_line failed\n");
5142 goto out;
5143 }
5144
5145 DBG_DEBUG("Parsed band-size [%zu] for [%s]\n", *band_size, plist);
5146
5147 out:
5148 if (fsp != NULL) {
5149 status = close_file_free(NULL, &fsp, NORMAL_CLOSE);
5150 if (!NT_STATUS_IS_OK(status)) {
5151 DBG_ERR("close_file failed: %s\n", nt_errstr(status));
5152 }
5153 }
5154 TALLOC_FREE(plist);
5155 TALLOC_FREE(smb_fname);
5156 TALLOC_FREE(file_data);
5157 TALLOC_FREE(lines);
5158 return ok;
5159 }
5160
5161 struct fruit_disk_free_state {
5162 off_t total_size;
5163 };
5164
5165 static bool fruit_get_num_bands(vfs_handle_struct *handle,
5166 const char *bundle,
5167 size_t *_nbands)
5168 {
5169 char *path = NULL;
5170 struct smb_filename *bands_dir = NULL;
5171 struct smb_Dir *dir_hnd = NULL;
5172 const char *dname = NULL;
5173 char *talloced = NULL;
5174 size_t nbands;
5175 NTSTATUS status;
5176
5177 path = talloc_asprintf(talloc_tos(),
5178 "%s/%s/bands",
5179 handle->conn->connectpath,
5180 bundle);
5181 if (path == NULL) {
5182 return false;
5183 }
5184
5185 bands_dir = synthetic_smb_fname(talloc_tos(),
5186 path,
5187 NULL,
5188 NULL,
5189 0,
5190 0);
5191 TALLOC_FREE(path);
5192 if (bands_dir == NULL) {
5193 return false;
5194 }
5195
5196 status = OpenDir(talloc_tos(),
5197 handle->conn,
5198 bands_dir,
5199 NULL,
5200 0,
5201 &dir_hnd);
5202 if (!NT_STATUS_IS_OK(status)) {
5203 TALLOC_FREE(bands_dir);
5204 errno = map_errno_from_nt_status(status);
5205 return false;
5206 }
5207
5208 nbands = 0;
5209
5210 while ((dname = ReadDirName(dir_hnd, &talloced)) != NULL) {
5211 if (ISDOT(dname) || ISDOTDOT(dname)) {
5212 continue;
5213 }
5214 nbands++;
5215 }
5216 TALLOC_FREE(dir_hnd);
5217
5218 DBG_DEBUG("%zu bands in [%s]\n", nbands, smb_fname_str_dbg(bands_dir));
5219
5220 TALLOC_FREE(bands_dir);
5221
5222 *_nbands = nbands;
5223 return true;
5224 }
5225
5226 static bool fruit_tmsize_do_dirent(vfs_handle_struct *handle,
5227 struct fruit_disk_free_state *state,
5228 const char *name)
5229 {
5230 bool ok;
5231 char *p = NULL;
5232 size_t sparsebundle_strlen = strlen("sparsebundle");
5233 size_t bandsize = 0;
5234 size_t nbands;
5235 off_t tm_size;
5236
5237 p = strstr(name, "sparsebundle");
5238 if (p == NULL) {
5239 return true;
5240 }
5241
5242 if (p[sparsebundle_strlen] != '\0') {
5243 return true;
5244 }
5245
5246 DBG_DEBUG("Processing sparsebundle [%s]\n", name);
5247
5248 ok = fruit_get_bandsize(handle, name, &bandsize);
5249 if (!ok) {
5250 /*
5251 * Beware of race conditions: this may be an uninitialized
5252 * Info.plist that a client is just creating. We don't want let
5253 * this to trigger complete failure.
5254 */
5255 DBG_ERR("Processing sparsebundle [%s] failed\n", name);
5256 return true;
5257 }
5258
5259 ok = fruit_get_num_bands(handle, name, &nbands);
5260 if (!ok) {
5261 /*
5262 * Beware of race conditions: this may be a backup sparsebundle
5263 * in an early stage lacking a bands subdirectory. We don't want
5264 * let this to trigger complete failure.
5265 */
5266 DBG_ERR("Processing sparsebundle [%s] failed\n", name);
5267 return true;
5268 }
5269
5270 /*
5271 * Arithmetic on 32-bit systems may cause overflow, depending on
5272 * size_t precision. First we check its unlikely, then we
5273 * force the precision into target off_t, then we check that
5274 * the total did not overflow either.
5275 */
5276 if (bandsize > SIZE_MAX/nbands) {
5277 DBG_ERR("tmsize potential overflow: bandsize [%zu] nbands [%zu]\n",
5278 bandsize, nbands);
5279 return false;
5280 }
5281 tm_size = (off_t)bandsize * (off_t)nbands;
5282
5283 if (state->total_size + tm_size < state->total_size) {
5284 DBG_ERR("tm total size overflow: bandsize [%zu] nbands [%zu]\n",
5285 bandsize, nbands);
5286 return false;
5287 }
5288
5289 state->total_size += tm_size;
5290
5291 DBG_DEBUG("[%s] tm_size [%jd] total_size [%jd]\n",
5292 name, (intmax_t)tm_size, (intmax_t)state->total_size);
5293
5294 return true;
5295 }
5296
5297 /**
5298 * Calculate used size of a TimeMachine volume
5299 *
5300 * This assumes that the volume is used only for TimeMachine.
5301 *
5302 * - readdir(basedir of share), then
5303 * - for every element that matches regex "^\(.*\)\.sparsebundle$" :
5304 * - parse "\1.sparsebundle/Info.plist" and read the band-size XML key
5305 * - count band files in "\1.sparsebundle/bands/"
5306 * - calculate used size of all bands: band_count * band_size
5307 **/
5308 static uint64_t fruit_disk_free(vfs_handle_struct *handle,
5309 const struct smb_filename *smb_fname,
5310 uint64_t *_bsize,
5311 uint64_t *_dfree,
5312 uint64_t *_dsize)
5313 {
5314 struct fruit_config_data *config = NULL;
5315 struct fruit_disk_free_state state = {0};
5316 struct smb_Dir *dir_hnd = NULL;
5317 const char *dname = NULL;
5318 char *talloced = NULL;
5319 uint64_t dfree;
5320 uint64_t dsize;
5321 bool ok;
5322 NTSTATUS status;
5323
5324 SMB_VFS_HANDLE_GET_DATA(handle, config,
5325 struct fruit_config_data,
5326 return UINT64_MAX);
5327
5328 if (!config->time_machine ||
5329 config->time_machine_max_size == 0)
5330 {
5331 return SMB_VFS_NEXT_DISK_FREE(handle,
5332 smb_fname,
5333 _bsize,
5334 _dfree,
5335 _dsize);
5336 }
5337
5338 status = OpenDir(talloc_tos(),
5339 handle->conn,
5340 smb_fname,
5341 NULL,
5342 0,
5343 &dir_hnd);
5344 if (!NT_STATUS_IS_OK(status)) {
5345 errno = map_errno_from_nt_status(status);
5346 return UINT64_MAX;
5347 }
5348
5349 while ((dname = ReadDirName(dir_hnd, &talloced)) != NULL) {
5350 ok = fruit_tmsize_do_dirent(handle, &state, dname);
5351 if (!ok) {
5352 TALLOC_FREE(talloced);
5353 TALLOC_FREE(dir_hnd);
5354 return UINT64_MAX;
5355 }
5356 TALLOC_FREE(talloced);
5357 }
5358
5359 TALLOC_FREE(dir_hnd);
5360
5361 dsize = config->time_machine_max_size / 512;
5362 dfree = dsize - (state.total_size / 512);
5363 if (dfree > dsize) {
5364 dfree = 0;
5365 }
5366
5367 *_bsize = 512;
5368 *_dsize = dsize;
5369 *_dfree = dfree;
5370 return dfree / 2;
5371 }
5372
5373 static uint64_t fruit_fs_file_id(struct vfs_handle_struct *handle,
5374 const SMB_STRUCT_STAT *psbuf)
5375 {
5376 struct fruit_config_data *config = NULL;
5377
5378 SMB_VFS_HANDLE_GET_DATA(handle, config,
5379 struct fruit_config_data,
5380 return 0);
5381
5382 if (global_fruit_config.nego_aapl &&
5383 config->aapl_zero_file_id)
5384 {
5385 return 0;
5386 }
5387
5388 return SMB_VFS_NEXT_FS_FILE_ID(handle, psbuf);
5389 }
5390
5391 static struct vfs_fn_pointers vfs_fruit_fns = {
5392 .connect_fn = fruit_connect,
5393 .disk_free_fn = fruit_disk_free,
5394
5395 /* File operations */
5396 .fchmod_fn = fruit_fchmod,
5397 .unlinkat_fn = fruit_unlinkat,
5398 .renameat_fn = fruit_renameat,
5399 .openat_fn = fruit_openat,
5400 .close_fn = fruit_close,
5401 .pread_fn = fruit_pread,
5402 .pwrite_fn = fruit_pwrite,
5403 .pread_send_fn = fruit_pread_send,
5404 .pread_recv_fn = fruit_pread_recv,
5405 .pwrite_send_fn = fruit_pwrite_send,
5406 .pwrite_recv_fn = fruit_pwrite_recv,
5407 .fsync_send_fn = fruit_fsync_send,
5408 .fsync_recv_fn = fruit_fsync_recv,
5409 .stat_fn = fruit_stat,
5410 .lstat_fn = fruit_lstat,
5411 .fstat_fn = fruit_fstat,
5412 .fstreaminfo_fn = fruit_fstreaminfo,
5413 .fntimes_fn = fruit_fntimes,
5414 .ftruncate_fn = fruit_ftruncate,
5415 .fallocate_fn = fruit_fallocate,
5416 .create_file_fn = fruit_create_file,
5417 .freaddir_attr_fn = fruit_freaddir_attr,
5418 .offload_read_send_fn = fruit_offload_read_send,
5419 .offload_read_recv_fn = fruit_offload_read_recv,
5420 .offload_write_send_fn = fruit_offload_write_send,
5421 .offload_write_recv_fn = fruit_offload_write_recv,
5422 .fs_file_id_fn = fruit_fs_file_id,
5423
5424 /* NT ACL operations */
5425 .fget_nt_acl_fn = fruit_fget_nt_acl,
5426 .fset_nt_acl_fn = fruit_fset_nt_acl,
5427 };
5428
5429 static_decl_vfs;
5430 NTSTATUS vfs_fruit_init(TALLOC_CTX *ctx)
5431 {
5432 NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "fruit",
5433 &vfs_fruit_fns);
5434 if (!NT_STATUS_IS_OK(ret)) {
5435 return ret;
5436 }
5437
5438 vfs_fruit_debug_level = debug_add_class("fruit");
5439 if (vfs_fruit_debug_level == -1) {
5440 vfs_fruit_debug_level = DBGC_VFS;
5441 DEBUG(0, ("%s: Couldn't register custom debugging class!\n",
5442 "vfs_fruit_init"));
5443 } else {
5444 DEBUG(10, ("%s: Debug class number of '%s': %d\n",
5445 "vfs_fruit_init","fruit",vfs_fruit_debug_level));
5446 }
5447
5448 return ret;
5449 }
Samba GIT mirror