2 * OS X and Netatalk interoperability VFS module for Samba-3.x
4 * Copyright (C) Ralph Boehme, 2013, 2014
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.
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.
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/>.
21 #include "MacExtensions.h"
22 #include "smbd/smbd.h"
23 #include "system/filesys.h"
24 #include "lib/util/time.h"
25 #include "../lib/crypto/md5.h"
26 #include "system/shmem.h"
27 #include "locking/proto.h"
28 #include "smbd/globals.h"
30 #include "libcli/security/security.h"
31 #include "../libcli/smb/smb2_create_ctx.h"
32 #include "lib/util/sys_rw.h"
33 #include "lib/util/tevent_ntstatus.h"
34 #include "lib/util/tevent_unix.h"
35 #include "offload_token.h"
36 #include "string_replace.h"
39 * Enhanced OS X and Netatalk compatibility
40 * ========================================
42 * This modules takes advantage of vfs_streams_xattr and
43 * vfs_catia. VFS modules vfs_fruit and vfs_streams_xattr must be
44 * loaded in the correct order:
46 * vfs modules = catia fruit streams_xattr
48 * The module intercepts the OS X special streams "AFP_AfpInfo" and
49 * "AFP_Resource" and handles them in a special way. All other named
50 * streams are deferred to vfs_streams_xattr.
52 * The OS X client maps all NTFS illegal characters to the Unicode
53 * private range. This module optionally stores the charcters using
54 * their native ASCII encoding using vfs_catia. If you're not enabling
55 * this feature, you can skip catia from vfs modules.
57 * Finally, open modes are optionally checked against Netatalk AFP
60 * The "AFP_AfpInfo" named stream is a binary blob containing OS X
61 * extended metadata for files and directories. This module optionally
62 * reads and stores this metadata in a way compatible with Netatalk 3
63 * which stores the metadata in an EA "org.netatalk.metadata". Cf
64 * source3/include/MacExtensions.h for a description of the binary
67 * The "AFP_Resource" named stream may be arbitrarily large, thus it
68 * can't be stored in an xattr on most filesystem. ZFS on Solaris is
69 * the only available filesystem where xattrs can be of any size and
70 * the OS supports using the file APIs for xattrs.
72 * The AFP_Resource stream is stored in an AppleDouble file prepending
73 * "._" to the filename. On Solaris with ZFS the stream is optionally
74 * stored in an EA "org.netatalk.resource".
80 * The OS X SMB client sends xattrs as ADS too. For xattr interop with
81 * other protocols you may want to adjust the xattr names the VFS
82 * module vfs_streams_xattr uses for storing ADS's. This defaults to
83 * user.DosStream.ADS_NAME:$DATA and can be changed by specifying
84 * these module parameters:
86 * streams_xattr:prefix = user.
87 * streams_xattr:store_stream_type = false
93 * - log diagnostic if any needed VFS module is not loaded
94 * (eg with lp_vfs_objects())
98 static int vfs_fruit_debug_level = DBGC_VFS;
100 static struct global_fruit_config {
101 bool nego_aapl; /* client negotiated AAPL */
103 } global_fruit_config;
106 #define DBGC_CLASS vfs_fruit_debug_level
108 #define FRUIT_PARAM_TYPE_NAME "fruit"
109 #define ADOUBLE_NAME_PREFIX "._"
111 #define NETATALK_META_XATTR "org.netatalk.Metadata"
112 #define NETATALK_RSRC_XATTR "org.netatalk.ResourceFork"
114 #if defined(HAVE_ATTROPEN)
115 #define AFPINFO_EA_NETATALK NETATALK_META_XATTR
116 #define AFPRESOURCE_EA_NETATALK NETATALK_RSRC_XATTR
118 #define AFPINFO_EA_NETATALK "user." NETATALK_META_XATTR
119 #define AFPRESOURCE_EA_NETATALK "user." NETATALK_RSRC_XATTR
122 enum apple_fork {APPLE_FORK_DATA, APPLE_FORK_RSRC};
124 enum fruit_rsrc {FRUIT_RSRC_STREAM, FRUIT_RSRC_ADFILE, FRUIT_RSRC_XATTR};
125 enum fruit_meta {FRUIT_META_STREAM, FRUIT_META_NETATALK};
126 enum fruit_locking {FRUIT_LOCKING_NETATALK, FRUIT_LOCKING_NONE};
127 enum fruit_encoding {FRUIT_ENC_NATIVE, FRUIT_ENC_PRIVATE};
129 struct fruit_config_data {
130 enum fruit_rsrc rsrc;
131 enum fruit_meta meta;
132 enum fruit_locking locking;
133 enum fruit_encoding encoding;
134 bool use_aapl; /* config from smb.conf */
136 bool readdir_attr_enabled;
137 bool unix_info_enabled;
138 bool copyfile_enabled;
139 bool veto_appledouble;
141 bool aapl_zero_file_id;
144 off_t time_machine_max_size;
145 bool wipe_intentionally_left_blank_rfork;
146 bool delete_empty_adfiles;
149 * Additional options, all enabled by default,
150 * possibly useful for analyzing performance. The associated
151 * operations with each of them may be expensive, so having
152 * the chance to disable them individually gives a chance
153 * tweaking the setup for the particular usecase.
155 bool readdir_attr_rsize;
156 bool readdir_attr_finder_info;
157 bool readdir_attr_max_access;
160 static const struct enum_list fruit_rsrc[] = {
161 {FRUIT_RSRC_STREAM, "stream"}, /* pass on to vfs_streams_xattr */
162 {FRUIT_RSRC_ADFILE, "file"}, /* ._ AppleDouble file */
163 {FRUIT_RSRC_XATTR, "xattr"}, /* Netatalk compatible xattr (ZFS only) */
167 static const struct enum_list fruit_meta[] = {
168 {FRUIT_META_STREAM, "stream"}, /* pass on to vfs_streams_xattr */
169 {FRUIT_META_NETATALK, "netatalk"}, /* Netatalk compatible xattr */
173 static const struct enum_list fruit_locking[] = {
174 {FRUIT_LOCKING_NETATALK, "netatalk"}, /* synchronize locks with Netatalk */
175 {FRUIT_LOCKING_NONE, "none"},
179 static const struct enum_list fruit_encoding[] = {
180 {FRUIT_ENC_NATIVE, "native"}, /* map unicode private chars to ASCII */
181 {FRUIT_ENC_PRIVATE, "private"}, /* keep unicode private chars */
185 static const char *fruit_catia_maps =
186 "0x01:0xf001,0x02:0xf002,0x03:0xf003,0x04:0xf004,"
187 "0x05:0xf005,0x06:0xf006,0x07:0xf007,0x08:0xf008,"
188 "0x09:0xf009,0x0a:0xf00a,0x0b:0xf00b,0x0c:0xf00c,"
189 "0x0d:0xf00d,0x0e:0xf00e,0x0f:0xf00f,0x10:0xf010,"
190 "0x11:0xf011,0x12:0xf012,0x13:0xf013,0x14:0xf014,"
191 "0x15:0xf015,0x16:0xf016,0x17:0xf017,0x18:0xf018,"
192 "0x19:0xf019,0x1a:0xf01a,0x1b:0xf01b,0x1c:0xf01c,"
193 "0x1d:0xf01d,0x1e:0xf01e,0x1f:0xf01f,"
194 "0x22:0xf020,0x2a:0xf021,0x3a:0xf022,0x3c:0xf023,"
195 "0x3e:0xf024,0x3f:0xf025,0x5c:0xf026,0x7c:0xf027,"
198 /*****************************************************************************
199 * Defines, functions and data structures that deal with AppleDouble
200 *****************************************************************************/
203 * There are two AppleDouble blobs we deal with:
205 * - ADOUBLE_META - AppleDouble blob used by Netatalk for storing
206 * metadata in an xattr
208 * - ADOUBLE_RSRC - AppleDouble blob used by OS X and Netatalk in
211 typedef enum {ADOUBLE_META, ADOUBLE_RSRC} adouble_type_t;
214 #define AD_VERSION2 0x00020000
215 #define AD_VERSION AD_VERSION2
218 * AppleDouble entry IDs.
220 #define ADEID_DFORK 1
221 #define ADEID_RFORK 2
223 #define ADEID_COMMENT 4
224 #define ADEID_ICONBW 5
225 #define ADEID_ICONCOL 6
226 #define ADEID_FILEI 7
227 #define ADEID_FILEDATESI 8
228 #define ADEID_FINDERI 9
229 #define ADEID_MACFILEI 10
230 #define ADEID_PRODOSFILEI 11
231 #define ADEID_MSDOSFILEI 12
232 #define ADEID_SHORTNAME 13
233 #define ADEID_AFPFILEI 14
236 /* Private Netatalk entries */
237 #define ADEID_PRIVDEV 16
238 #define ADEID_PRIVINO 17
239 #define ADEID_PRIVSYN 18
240 #define ADEID_PRIVID 19
241 #define ADEID_MAX (ADEID_PRIVID + 1)
244 * These are the real ids for the private entries,
245 * as stored in the adouble file
247 #define AD_DEV 0x80444556
248 #define AD_INO 0x80494E4F
249 #define AD_SYN 0x8053594E
250 #define AD_ID 0x8053567E
252 /* Number of actually used entries */
253 #define ADEID_NUM_XATTR 8
254 #define ADEID_NUM_DOT_UND 2
255 #define ADEID_NUM_RSRC_XATTR 1
257 /* AppleDouble magic */
258 #define AD_APPLESINGLE_MAGIC 0x00051600
259 #define AD_APPLEDOUBLE_MAGIC 0x00051607
260 #define AD_MAGIC AD_APPLEDOUBLE_MAGIC
262 /* Sizes of relevant entry bits */
263 #define ADEDLEN_MAGIC 4
264 #define ADEDLEN_VERSION 4
265 #define ADEDLEN_FILLER 16
266 #define AD_FILLER_TAG "Netatalk " /* should be 16 bytes */
267 #define AD_FILLER_TAG_OSX "Mac OS X " /* should be 16 bytes */
268 #define ADEDLEN_NENTRIES 2
269 #define AD_HEADER_LEN (ADEDLEN_MAGIC + ADEDLEN_VERSION + \
270 ADEDLEN_FILLER + ADEDLEN_NENTRIES) /* 26 */
271 #define AD_ENTRY_LEN_EID 4
272 #define AD_ENTRY_LEN_OFF 4
273 #define AD_ENTRY_LEN_LEN 4
274 #define AD_ENTRY_LEN (AD_ENTRY_LEN_EID + AD_ENTRY_LEN_OFF + AD_ENTRY_LEN_LEN)
277 #define ADEDLEN_NAME 255
278 #define ADEDLEN_COMMENT 200
279 #define ADEDLEN_FILEI 16
280 #define ADEDLEN_FINDERI 32
281 #define ADEDLEN_FILEDATESI 16
282 #define ADEDLEN_SHORTNAME 12 /* length up to 8.3 */
283 #define ADEDLEN_AFPFILEI 4
284 #define ADEDLEN_MACFILEI 4
285 #define ADEDLEN_PRODOSFILEI 8
286 #define ADEDLEN_MSDOSFILEI 2
287 #define ADEDLEN_DID 4
288 #define ADEDLEN_PRIVDEV 8
289 #define ADEDLEN_PRIVINO 8
290 #define ADEDLEN_PRIVSYN 8
291 #define ADEDLEN_PRIVID 4
294 #define ADEDOFF_MAGIC 0
295 #define ADEDOFF_VERSION (ADEDOFF_MAGIC + ADEDLEN_MAGIC)
296 #define ADEDOFF_FILLER (ADEDOFF_VERSION + ADEDLEN_VERSION)
297 #define ADEDOFF_NENTRIES (ADEDOFF_FILLER + ADEDLEN_FILLER)
299 #define ADEDOFF_FINDERI_XATTR (AD_HEADER_LEN + \
300 (ADEID_NUM_XATTR * AD_ENTRY_LEN))
301 #define ADEDOFF_COMMENT_XATTR (ADEDOFF_FINDERI_XATTR + ADEDLEN_FINDERI)
302 #define ADEDOFF_FILEDATESI_XATTR (ADEDOFF_COMMENT_XATTR + ADEDLEN_COMMENT)
303 #define ADEDOFF_AFPFILEI_XATTR (ADEDOFF_FILEDATESI_XATTR + \
305 #define ADEDOFF_PRIVDEV_XATTR (ADEDOFF_AFPFILEI_XATTR + ADEDLEN_AFPFILEI)
306 #define ADEDOFF_PRIVINO_XATTR (ADEDOFF_PRIVDEV_XATTR + ADEDLEN_PRIVDEV)
307 #define ADEDOFF_PRIVSYN_XATTR (ADEDOFF_PRIVINO_XATTR + ADEDLEN_PRIVINO)
308 #define ADEDOFF_PRIVID_XATTR (ADEDOFF_PRIVSYN_XATTR + ADEDLEN_PRIVSYN)
310 #define ADEDOFF_FINDERI_DOT_UND (AD_HEADER_LEN + \
311 (ADEID_NUM_DOT_UND * AD_ENTRY_LEN))
312 #define ADEDOFF_RFORK_DOT_UND (ADEDOFF_FINDERI_DOT_UND + ADEDLEN_FINDERI)
314 #define AD_DATASZ_XATTR (AD_HEADER_LEN + \
315 (ADEID_NUM_XATTR * AD_ENTRY_LEN) + \
316 ADEDLEN_FINDERI + ADEDLEN_COMMENT + \
317 ADEDLEN_FILEDATESI + ADEDLEN_AFPFILEI + \
318 ADEDLEN_PRIVDEV + ADEDLEN_PRIVINO + \
319 ADEDLEN_PRIVSYN + ADEDLEN_PRIVID)
321 #if AD_DATASZ_XATTR != 402
322 #error bad size for AD_DATASZ_XATTR
325 #define AD_DATASZ_DOT_UND (AD_HEADER_LEN + \
326 (ADEID_NUM_DOT_UND * AD_ENTRY_LEN) + \
328 #if AD_DATASZ_DOT_UND != 82
329 #error bad size for AD_DATASZ_DOT_UND
333 * Sharemode locks fcntl() offsets
335 #if _FILE_OFFSET_BITS == 64 || defined(HAVE_LARGEFILE)
336 #define AD_FILELOCK_BASE (UINT64_C(0x7FFFFFFFFFFFFFFF) - 9)
338 #define AD_FILELOCK_BASE (UINT32_C(0x7FFFFFFF) - 9)
340 #define BYTELOCK_MAX (AD_FILELOCK_BASE - 1)
342 #define AD_FILELOCK_OPEN_WR (AD_FILELOCK_BASE + 0)
343 #define AD_FILELOCK_OPEN_RD (AD_FILELOCK_BASE + 1)
344 #define AD_FILELOCK_RSRC_OPEN_WR (AD_FILELOCK_BASE + 2)
345 #define AD_FILELOCK_RSRC_OPEN_RD (AD_FILELOCK_BASE + 3)
346 #define AD_FILELOCK_DENY_WR (AD_FILELOCK_BASE + 4)
347 #define AD_FILELOCK_DENY_RD (AD_FILELOCK_BASE + 5)
348 #define AD_FILELOCK_RSRC_DENY_WR (AD_FILELOCK_BASE + 6)
349 #define AD_FILELOCK_RSRC_DENY_RD (AD_FILELOCK_BASE + 7)
350 #define AD_FILELOCK_OPEN_NONE (AD_FILELOCK_BASE + 8)
351 #define AD_FILELOCK_RSRC_OPEN_NONE (AD_FILELOCK_BASE + 9)
353 /* Time stuff we overload the bits a little */
354 #define AD_DATE_CREATE 0
355 #define AD_DATE_MODIFY 4
356 #define AD_DATE_BACKUP 8
357 #define AD_DATE_ACCESS 12
358 #define AD_DATE_MASK (AD_DATE_CREATE | AD_DATE_MODIFY | \
359 AD_DATE_BACKUP | AD_DATE_ACCESS)
360 #define AD_DATE_UNIX (1 << 10)
361 #define AD_DATE_START 0x80000000
362 #define AD_DATE_DELTA 946684800
363 #define AD_DATE_FROM_UNIX(x) (htonl((x) - AD_DATE_DELTA))
364 #define AD_DATE_TO_UNIX(x) (ntohl(x) + AD_DATE_DELTA)
366 #define AD_XATTR_HDR_MAGIC 0x41545452 /* 'ATTR' */
367 #define AD_XATTR_MAX_ENTRIES 1024 /* Some arbitrarily enforced limit */
368 #define AD_XATTR_HDR_SIZE 36
369 #define AD_XATTR_MAX_HDR_SIZE 65536
371 /* Accessor macros */
372 #define ad_getentrylen(ad,eid) ((ad)->ad_eid[(eid)].ade_len)
373 #define ad_getentryoff(ad,eid) ((ad)->ad_eid[(eid)].ade_off)
374 #define ad_setentrylen(ad,eid,len) ((ad)->ad_eid[(eid)].ade_len = (len))
375 #define ad_setentryoff(ad,eid,off) ((ad)->ad_eid[(eid)].ade_off = (off))
378 * Both struct ad_xattr_header and struct ad_xattr_entry describe the in memory
379 * representation as well as the on-disk format.
381 * The ad_xattr_header follows the FinderInfo data in the FinderInfo entry if
382 * the length of the FinderInfo entry is larger then 32 bytes. It is then
383 * preceeded with 2 bytes padding.
385 * Cf: https://opensource.apple.com/source/xnu/xnu-4570.1.46/bsd/vfs/vfs_xattr.c
388 struct ad_xattr_header {
389 uint32_t adx_magic; /* ATTR_HDR_MAGIC */
390 uint32_t adx_debug_tag; /* for debugging == file id of owning file */
391 uint32_t adx_total_size; /* file offset of end of attribute header + entries + data */
392 uint32_t adx_data_start; /* file offset to attribute data area */
393 uint32_t adx_data_length; /* length of attribute data area */
394 uint32_t adx_reserved[3];
396 uint16_t adx_num_attrs;
399 /* On-disk entries are aligned on 4 byte boundaries */
400 struct ad_xattr_entry {
401 uint32_t adx_offset; /* file offset to data */
402 uint32_t adx_length; /* size of attribute data */
404 uint8_t adx_namelen; /* included the NULL terminator */
405 char *adx_name; /* NULL-terminated UTF-8 name */
414 vfs_handle_struct *ad_handle;
417 adouble_type_t ad_type;
420 uint8_t ad_filler[ADEDLEN_FILLER];
421 struct ad_entry ad_eid[ADEID_MAX];
423 struct ad_xattr_header adx_header;
424 struct ad_xattr_entry *adx_entries;
427 struct ad_entry_order {
428 uint32_t id, offset, len;
431 /* Netatalk AppleDouble metadata xattr */
433 struct ad_entry_order entry_order_meta_xattr[ADEID_NUM_XATTR + 1] = {
434 {ADEID_FINDERI, ADEDOFF_FINDERI_XATTR, ADEDLEN_FINDERI},
435 {ADEID_COMMENT, ADEDOFF_COMMENT_XATTR, 0},
436 {ADEID_FILEDATESI, ADEDOFF_FILEDATESI_XATTR, ADEDLEN_FILEDATESI},
437 {ADEID_AFPFILEI, ADEDOFF_AFPFILEI_XATTR, ADEDLEN_AFPFILEI},
438 {ADEID_PRIVDEV, ADEDOFF_PRIVDEV_XATTR, 0},
439 {ADEID_PRIVINO, ADEDOFF_PRIVINO_XATTR, 0},
440 {ADEID_PRIVSYN, ADEDOFF_PRIVSYN_XATTR, 0},
441 {ADEID_PRIVID, ADEDOFF_PRIVID_XATTR, 0},
445 /* AppleDouble resource fork file (the ones prefixed by "._") */
447 struct ad_entry_order entry_order_dot_und[ADEID_NUM_DOT_UND + 1] = {
448 {ADEID_FINDERI, ADEDOFF_FINDERI_DOT_UND, ADEDLEN_FINDERI},
449 {ADEID_RFORK, ADEDOFF_RFORK_DOT_UND, 0},
454 * Fake AppleDouble entry oder for resource fork xattr. The xattr
455 * isn't an AppleDouble file, it simply contains the resource data,
456 * but in order to be able to use some API calls like ad_getentryoff()
457 * we build a fake/helper struct adouble with this entry order struct.
460 struct ad_entry_order entry_order_rsrc_xattr[ADEID_NUM_RSRC_XATTR + 1] = {
465 /* Conversion from enumerated id to on-disk AppleDouble id */
466 #define AD_EID_DISK(a) (set_eid[a])
467 static const uint32_t set_eid[] = {
468 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
469 AD_DEV, AD_INO, AD_SYN, AD_ID
472 static char empty_resourcefork[] = {
473 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
474 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E,
475 0x54, 0x68, 0x69, 0x73, 0x20, 0x72, 0x65, 0x73,
476 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x66, 0x6F,
477 0x72, 0x6B, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x6E,
478 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x6C, 0x79,
479 0x20, 0x6C, 0x65, 0x66, 0x74, 0x20, 0x62, 0x6C,
480 0x61, 0x6E, 0x6B, 0x20, 0x20, 0x20, 0x00, 0x00,
481 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
482 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
483 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
484 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
485 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
486 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
487 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
488 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
489 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
490 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
491 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
492 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
493 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
494 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
495 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
496 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
497 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
498 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
499 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
500 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
501 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
502 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
503 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
504 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
505 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
506 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E,
507 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
508 0x00, 0x1C, 0x00, 0x1E, 0xFF, 0xFF
512 /* tcon config handle */
513 struct fruit_config_data *config;
515 /* Denote stream type, meta or rsrc */
518 /* Whether the create created the stream */
522 * AFP_AfpInfo stream created, but not written yet, thus still a fake
523 * pipe fd. This is set to true in fruit_open_meta if there was no
524 * exisiting stream but the caller requested O_CREAT. It is later set to
525 * false when we get a write on the stream that then does open and
534 * Forward declarations
536 static struct adouble *ad_init(TALLOC_CTX *ctx, vfs_handle_struct *handle,
537 adouble_type_t type);
538 static int ad_set(struct adouble *ad, const struct smb_filename *smb_fname);
539 static int ad_fset(struct adouble *ad, files_struct *fsp);
540 static int adouble_path(TALLOC_CTX *ctx,
541 const struct smb_filename *smb_fname__in,
542 struct smb_filename **ppsmb_fname_out);
543 static AfpInfo *afpinfo_new(TALLOC_CTX *ctx);
544 static ssize_t afpinfo_pack(const AfpInfo *ai, char *buf);
545 static AfpInfo *afpinfo_unpack(TALLOC_CTX *ctx, const void *data);
549 * Return a pointer to an AppleDouble entry
551 * Returns NULL if the entry is not present
553 static char *ad_get_entry(const struct adouble *ad, int eid)
555 off_t off = ad_getentryoff(ad, eid);
556 size_t len = ad_getentrylen(ad, eid);
558 if (off == 0 || len == 0) {
562 return ad->ad_data + off;
568 static int ad_getdate(const struct adouble *ad,
569 unsigned int dateoff,
572 bool xlate = (dateoff & AD_DATE_UNIX);
575 dateoff &= AD_DATE_MASK;
576 p = ad_get_entry(ad, ADEID_FILEDATESI);
581 if (dateoff > AD_DATE_ACCESS) {
585 memcpy(date, p + dateoff, sizeof(uint32_t));
588 *date = AD_DATE_TO_UNIX(*date);
596 static int ad_setdate(struct adouble *ad, unsigned int dateoff, uint32_t date)
598 bool xlate = (dateoff & AD_DATE_UNIX);
601 p = ad_get_entry(ad, ADEID_FILEDATESI);
606 dateoff &= AD_DATE_MASK;
608 date = AD_DATE_FROM_UNIX(date);
611 if (dateoff > AD_DATE_ACCESS) {
615 memcpy(p + dateoff, &date, sizeof(date));
622 * Map on-disk AppleDouble id to enumerated id
624 static uint32_t get_eid(uint32_t eid)
632 return ADEID_PRIVDEV;
634 return ADEID_PRIVINO;
636 return ADEID_PRIVSYN;
647 * Pack AppleDouble structure into data buffer
649 static bool ad_pack(struct adouble *ad)
656 bufsize = talloc_get_size(ad->ad_data);
657 if (bufsize < AD_DATASZ_DOT_UND) {
658 DBG_ERR("bad buffer size [0x%" PRIx32 "]\n", bufsize);
662 if (offset + ADEDLEN_MAGIC < offset ||
663 offset + ADEDLEN_MAGIC >= bufsize) {
666 RSIVAL(ad->ad_data, offset, ad->ad_magic);
667 offset += ADEDLEN_MAGIC;
669 if (offset + ADEDLEN_VERSION < offset ||
670 offset + ADEDLEN_VERSION >= bufsize) {
673 RSIVAL(ad->ad_data, offset, ad->ad_version);
674 offset += ADEDLEN_VERSION;
676 if (offset + ADEDLEN_FILLER < offset ||
677 offset + ADEDLEN_FILLER >= bufsize) {
680 if (ad->ad_type == ADOUBLE_RSRC) {
681 memcpy(ad->ad_data + offset, AD_FILLER_TAG, ADEDLEN_FILLER);
683 offset += ADEDLEN_FILLER;
685 if (offset + ADEDLEN_NENTRIES < offset ||
686 offset + ADEDLEN_NENTRIES >= bufsize) {
689 offset += ADEDLEN_NENTRIES;
691 for (eid = 0, nent = 0; eid < ADEID_MAX; eid++) {
692 if (ad->ad_eid[eid].ade_off == 0) {
694 * ade_off is also used as indicator whether a
695 * specific entry is used or not
700 if (offset + AD_ENTRY_LEN_EID < offset ||
701 offset + AD_ENTRY_LEN_EID >= bufsize) {
704 RSIVAL(ad->ad_data, offset, AD_EID_DISK(eid));
705 offset += AD_ENTRY_LEN_EID;
707 if (offset + AD_ENTRY_LEN_OFF < offset ||
708 offset + AD_ENTRY_LEN_OFF >= bufsize) {
711 RSIVAL(ad->ad_data, offset, ad->ad_eid[eid].ade_off);
712 offset += AD_ENTRY_LEN_OFF;
714 if (offset + AD_ENTRY_LEN_LEN < offset ||
715 offset + AD_ENTRY_LEN_LEN >= bufsize) {
718 RSIVAL(ad->ad_data, offset, ad->ad_eid[eid].ade_len);
719 offset += AD_ENTRY_LEN_LEN;
724 if (ADEDOFF_NENTRIES + 2 >= bufsize) {
727 RSSVAL(ad->ad_data, ADEDOFF_NENTRIES, nent);
732 static bool ad_unpack_xattrs(struct adouble *ad)
734 struct ad_xattr_header *h = &ad->adx_header;
735 const char *p = ad->ad_data;
739 if (ad_getentrylen(ad, ADEID_FINDERI) <= ADEDLEN_FINDERI) {
743 /* 2 bytes padding */
744 hoff = ad_getentryoff(ad, ADEID_FINDERI) + ADEDLEN_FINDERI + 2;
746 h->adx_magic = RIVAL(p, hoff + 0);
747 h->adx_debug_tag = RIVAL(p, hoff + 4); /* Not used -> not checked */
748 h->adx_total_size = RIVAL(p, hoff + 8);
749 h->adx_data_start = RIVAL(p, hoff + 12);
750 h->adx_data_length = RIVAL(p, hoff + 16);
751 h->adx_flags = RSVAL(p, hoff + 32); /* Not used -> not checked */
752 h->adx_num_attrs = RSVAL(p, hoff + 34);
754 if (h->adx_magic != AD_XATTR_HDR_MAGIC) {
755 DBG_ERR("Bad magic: 0x%" PRIx32 "\n", h->adx_magic);
759 if (h->adx_total_size > ad_getentryoff(ad, ADEID_RFORK)) {
760 DBG_ERR("Bad total size: 0x%" PRIx32 "\n", h->adx_total_size);
763 if (h->adx_total_size > AD_XATTR_MAX_HDR_SIZE) {
764 DBG_ERR("Bad total size: 0x%" PRIx32 "\n", h->adx_total_size);
768 if (h->adx_data_start < (hoff + AD_XATTR_HDR_SIZE)) {
769 DBG_ERR("Bad start: 0x%" PRIx32 "\n", h->adx_data_start);
773 if ((h->adx_data_start + h->adx_data_length) < h->adx_data_start) {
774 DBG_ERR("Bad length: %" PRIu32 "\n", h->adx_data_length);
777 if ((h->adx_data_start + h->adx_data_length) >
778 ad->adx_header.adx_total_size)
780 DBG_ERR("Bad length: %" PRIu32 "\n", h->adx_data_length);
784 if (h->adx_num_attrs > AD_XATTR_MAX_ENTRIES) {
785 DBG_ERR("Bad num xattrs: %" PRIu16 "\n", h->adx_num_attrs);
789 if (h->adx_num_attrs == 0) {
793 ad->adx_entries = talloc_zero_array(
794 ad, struct ad_xattr_entry, h->adx_num_attrs);
795 if (ad->adx_entries == NULL) {
799 hoff += AD_XATTR_HDR_SIZE;
801 for (i = 0; i < h->adx_num_attrs; i++) {
802 struct ad_xattr_entry *e = &ad->adx_entries[i];
804 hoff = (hoff + 3) & ~3;
806 e->adx_offset = RIVAL(p, hoff + 0);
807 e->adx_length = RIVAL(p, hoff + 4);
808 e->adx_flags = RSVAL(p, hoff + 8);
809 e->adx_namelen = *(p + hoff + 10);
811 if (e->adx_offset >= ad->adx_header.adx_total_size) {
812 DBG_ERR("Bad adx_offset: %" PRIx32 "\n",
817 if ((e->adx_offset + e->adx_length) < e->adx_offset) {
818 DBG_ERR("Bad adx_length: %" PRIx32 "\n",
823 if ((e->adx_offset + e->adx_length) >
824 ad->adx_header.adx_total_size)
826 DBG_ERR("Bad adx_length: %" PRIx32 "\n",
831 if (e->adx_namelen == 0) {
832 DBG_ERR("Bad adx_namelen: %" PRIx32 "\n",
836 if ((hoff + 11 + e->adx_namelen) < hoff + 11) {
837 DBG_ERR("Bad adx_namelen: %" PRIx32 "\n",
841 if ((hoff + 11 + e->adx_namelen) >
842 ad->adx_header.adx_data_start)
844 DBG_ERR("Bad adx_namelen: %" PRIx32 "\n",
849 e->adx_name = talloc_strndup(ad->adx_entries,
852 if (e->adx_name == NULL) {
856 DBG_DEBUG("xattr [%s] offset [0x%x] size [0x%x]\n",
857 e->adx_name, e->adx_offset, e->adx_length);
858 dump_data(10, (uint8_t *)(ad->ad_data + e->adx_offset),
861 hoff += 11 + e->adx_namelen;
868 * Unpack an AppleDouble blob into a struct adoble
870 static bool ad_unpack(struct adouble *ad, const size_t nentries,
873 size_t bufsize = talloc_get_size(ad->ad_data);
875 uint32_t eid, len, off;
879 * The size of the buffer ad->ad_data is checked when read, so
880 * we wouldn't have to check our own offsets, a few extra
881 * checks won't hurt though. We have to check the offsets we
882 * read from the buffer anyway.
885 if (bufsize < (AD_HEADER_LEN + (AD_ENTRY_LEN * nentries))) {
886 DEBUG(1, ("bad size\n"));
890 ad->ad_magic = RIVAL(ad->ad_data, 0);
891 ad->ad_version = RIVAL(ad->ad_data, ADEDOFF_VERSION);
892 if ((ad->ad_magic != AD_MAGIC) || (ad->ad_version != AD_VERSION)) {
893 DEBUG(1, ("wrong magic or version\n"));
897 memcpy(ad->ad_filler, ad->ad_data + ADEDOFF_FILLER, ADEDLEN_FILLER);
899 adentries = RSVAL(ad->ad_data, ADEDOFF_NENTRIES);
900 if (adentries != nentries) {
901 DEBUG(1, ("invalid number of entries: %zu\n",
906 /* now, read in the entry bits */
907 for (i = 0; i < adentries; i++) {
908 eid = RIVAL(ad->ad_data, AD_HEADER_LEN + (i * AD_ENTRY_LEN));
910 off = RIVAL(ad->ad_data, AD_HEADER_LEN + (i * AD_ENTRY_LEN) + 4);
911 len = RIVAL(ad->ad_data, AD_HEADER_LEN + (i * AD_ENTRY_LEN) + 8);
913 if (!eid || eid >= ADEID_MAX) {
914 DEBUG(1, ("bogus eid %d\n", eid));
919 * All entries other than the resource fork are
920 * expected to be read into the ad_data buffer, so
921 * ensure the specified offset is within that bound
923 if ((off > bufsize) && (eid != ADEID_RFORK)) {
924 DEBUG(1, ("bogus eid %d: off: %" PRIu32 ", len: %" PRIu32 "\n",
930 * All entries besides FinderInfo and resource fork
931 * must fit into the buffer. FinderInfo is special as
932 * it may be larger then the default 32 bytes (if it
933 * contains marshalled xattrs), but we will fixup that
934 * in ad_convert(). And the resource fork is never
935 * accessed directly by the ad_data buf (also see
936 * comment above) anyway.
938 if ((eid != ADEID_RFORK) &&
939 (eid != ADEID_FINDERI) &&
940 ((off + len) > bufsize)) {
941 DEBUG(1, ("bogus eid %d: off: %" PRIu32 ", len: %" PRIu32 "\n",
947 * That would be obviously broken
949 if (off > filesize) {
950 DEBUG(1, ("bogus eid %d: off: %" PRIu32 ", len: %" PRIu32 "\n",
956 * Check for any entry that has its end beyond the
959 if (off + len < off) {
960 DEBUG(1, ("offset wrap in eid %d: off: %" PRIu32
961 ", len: %" PRIu32 "\n",
966 if (off + len > filesize) {
968 * If this is the resource fork entry, we fix
969 * up the length, for any other entry we bail
972 if (eid != ADEID_RFORK) {
973 DEBUG(1, ("bogus eid %d: off: %" PRIu32
974 ", len: %" PRIu32 "\n",
980 * Fixup the resource fork entry by limiting
981 * the size to entryoffset - filesize.
983 len = filesize - off;
984 DEBUG(1, ("Limiting ADEID_RFORK: off: %" PRIu32
985 ", len: %" PRIu32 "\n", off, len));
988 ad->ad_eid[eid].ade_off = off;
989 ad->ad_eid[eid].ade_len = len;
992 ok = ad_unpack_xattrs(ad);
1000 static bool ad_convert_move_reso(struct adouble *ad,
1001 const struct smb_filename *smb_fname)
1003 char *map = MAP_FAILED;
1009 if (ad_getentrylen(ad, ADEID_RFORK) == 0) {
1013 maplen = ad_getentryoff(ad, ADEID_RFORK) +
1014 ad_getentrylen(ad, ADEID_RFORK);
1016 /* FIXME: direct use of mmap(), vfs_aio_fork does it too */
1017 map = mmap(NULL, maplen, PROT_READ|PROT_WRITE, MAP_SHARED,
1019 if (map == MAP_FAILED) {
1020 DBG_ERR("mmap AppleDouble: %s\n", strerror(errno));
1025 memmove(map + ADEDOFF_RFORK_DOT_UND,
1026 map + ad_getentryoff(ad, ADEID_RFORK),
1027 ad_getentrylen(ad, ADEID_RFORK));
1029 rc = munmap(map, maplen);
1031 DBG_ERR("munmap failed: %s\n", strerror(errno));
1035 ad_setentryoff(ad, ADEID_RFORK, ADEDOFF_RFORK_DOT_UND);
1039 DBG_WARNING("ad_pack [%s] failed\n", smb_fname->base_name);
1043 len = sys_pwrite(ad->ad_fd, ad->ad_data, AD_DATASZ_DOT_UND, 0);
1044 if (len != AD_DATASZ_DOT_UND) {
1045 DBG_ERR("%s: bad size: %zd\n", smb_fname->base_name, len);
1052 static bool ad_convert_xattr(struct adouble *ad,
1053 const struct smb_filename *smb_fname,
1054 bool *converted_xattr)
1056 static struct char_mappings **string_replace_cmaps = NULL;
1057 char *map = MAP_FAILED;
1061 int saved_errno = 0;
1066 *converted_xattr = false;
1068 if (ad_getentrylen(ad, ADEID_FINDERI) == ADEDLEN_FINDERI) {
1072 if (string_replace_cmaps == NULL) {
1073 const char **mappings = NULL;
1075 mappings = str_list_make_v3_const(
1076 talloc_tos(), fruit_catia_maps, NULL);
1077 if (mappings == NULL) {
1080 string_replace_cmaps = string_replace_init_map(mappings);
1081 TALLOC_FREE(mappings);
1084 maplen = ad_getentryoff(ad, ADEID_RFORK) +
1085 ad_getentrylen(ad, ADEID_RFORK);
1087 /* FIXME: direct use of mmap(), vfs_aio_fork does it too */
1088 map = mmap(NULL, maplen, PROT_READ|PROT_WRITE, MAP_SHARED,
1090 if (map == MAP_FAILED) {
1091 DBG_ERR("mmap AppleDouble: %s\n", strerror(errno));
1095 for (i = 0; i < ad->adx_header.adx_num_attrs; i++) {
1096 struct ad_xattr_entry *e = &ad->adx_entries[i];
1097 char *mapped_name = NULL;
1099 struct smb_filename *stream_name = NULL;
1100 files_struct *fsp = NULL;
1103 status = string_replace_allocate(ad->ad_handle->conn,
1105 string_replace_cmaps,
1108 vfs_translate_to_windows);
1109 if (!NT_STATUS_IS_OK(status) &&
1110 !NT_STATUS_EQUAL(status, NT_STATUS_NONE_MAPPED))
1112 DBG_ERR("string_replace_allocate failed\n");
1118 mapped_name = talloc_asprintf(talloc_tos(), ":%s", tmp);
1120 if (mapped_name == NULL) {
1125 stream_name = synthetic_smb_fname(talloc_tos(),
1126 smb_fname->base_name,
1130 TALLOC_FREE(mapped_name);
1131 if (stream_name == NULL) {
1132 DBG_ERR("synthetic_smb_fname failed\n");
1137 DBG_DEBUG("stream_name: %s\n", smb_fname_str_dbg(stream_name));
1139 status = SMB_VFS_CREATE_FILE(
1140 ad->ad_handle->conn, /* conn */
1142 0, /* root_dir_fid */
1143 stream_name, /* fname */
1144 FILE_GENERIC_WRITE, /* access_mask */
1145 FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */
1146 FILE_OPEN_IF, /* create_disposition */
1147 0, /* create_options */
1148 0, /* file_attributes */
1149 INTERNAL_OPEN_ONLY, /* oplock_request */
1151 0, /* allocation_size */
1152 0, /* private_flags */
1157 NULL, NULL); /* create context */
1158 TALLOC_FREE(stream_name);
1159 if (!NT_STATUS_IS_OK(status)) {
1160 DBG_ERR("SMB_VFS_CREATE_FILE failed\n");
1165 nwritten = SMB_VFS_PWRITE(fsp,
1166 map + e->adx_offset,
1169 if (nwritten == -1) {
1170 DBG_ERR("SMB_VFS_PWRITE failed\n");
1171 saved_errno = errno;
1172 close_file(NULL, fsp, ERROR_CLOSE);
1173 errno = saved_errno;
1178 status = close_file(NULL, fsp, NORMAL_CLOSE);
1179 if (!NT_STATUS_IS_OK(status)) {
1186 ad_setentrylen(ad, ADEID_FINDERI, ADEDLEN_FINDERI);
1190 DBG_WARNING("ad_pack [%s] failed\n", smb_fname->base_name);
1194 len = sys_pwrite(ad->ad_fd, ad->ad_data, AD_DATASZ_DOT_UND, 0);
1195 if (len != AD_DATASZ_DOT_UND) {
1196 DBG_ERR("%s: bad size: %zd\n", smb_fname->base_name, len);
1201 ok = ad_convert_move_reso(ad, smb_fname);
1206 *converted_xattr = true;
1210 rc = munmap(map, maplen);
1212 DBG_ERR("munmap failed: %s\n", strerror(errno));
1219 static bool ad_convert_finderinfo(struct adouble *ad,
1220 const struct smb_filename *smb_fname)
1225 struct smb_filename *stream_name = NULL;
1226 files_struct *fsp = NULL;
1230 int saved_errno = 0;
1233 cmp = memcmp(ad->ad_filler, AD_FILLER_TAG_OSX, ADEDLEN_FILLER);
1238 p_ad = ad_get_entry(ad, ADEID_FINDERI);
1243 ai = afpinfo_new(talloc_tos());
1248 memcpy(ai->afpi_FinderInfo, p_ad, ADEDLEN_FINDERI);
1250 aiblob = data_blob_talloc(talloc_tos(), NULL, AFP_INFO_SIZE);
1251 if (aiblob.data == NULL) {
1256 size = afpinfo_pack(ai, (char *)aiblob.data);
1258 if (size != AFP_INFO_SIZE) {
1262 stream_name = synthetic_smb_fname(talloc_tos(),
1263 smb_fname->base_name,
1267 if (stream_name == NULL) {
1268 data_blob_free(&aiblob);
1269 DBG_ERR("synthetic_smb_fname failed\n");
1273 DBG_DEBUG("stream_name: %s\n", smb_fname_str_dbg(stream_name));
1275 status = SMB_VFS_CREATE_FILE(
1276 ad->ad_handle->conn, /* conn */
1278 0, /* root_dir_fid */
1279 stream_name, /* fname */
1280 FILE_GENERIC_WRITE, /* access_mask */
1281 FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */
1282 FILE_OPEN_IF, /* create_disposition */
1283 0, /* create_options */
1284 0, /* file_attributes */
1285 INTERNAL_OPEN_ONLY, /* oplock_request */
1287 0, /* allocation_size */
1288 0, /* private_flags */
1293 NULL, NULL); /* create context */
1294 TALLOC_FREE(stream_name);
1295 if (!NT_STATUS_IS_OK(status)) {
1296 DBG_ERR("SMB_VFS_CREATE_FILE failed\n");
1300 nwritten = SMB_VFS_PWRITE(fsp,
1304 if (nwritten == -1) {
1305 DBG_ERR("SMB_VFS_PWRITE failed\n");
1306 saved_errno = errno;
1307 close_file(NULL, fsp, ERROR_CLOSE);
1308 errno = saved_errno;
1312 status = close_file(NULL, fsp, NORMAL_CLOSE);
1313 if (!NT_STATUS_IS_OK(status)) {
1321 static bool ad_convert_truncate(struct adouble *ad,
1322 const struct smb_filename *smb_fname)
1327 * FIXME: direct ftruncate(), but we don't have a fsp for the
1330 rc = ftruncate(ad->ad_fd, ADEDOFF_RFORK_DOT_UND +
1331 ad_getentrylen(ad, ADEID_RFORK));
1339 static bool ad_convert_blank_rfork(struct adouble *ad,
1342 struct fruit_config_data *config = NULL;
1343 uint8_t *map = MAP_FAILED;
1352 SMB_VFS_HANDLE_GET_DATA(ad->ad_handle, config,
1353 struct fruit_config_data, return false);
1355 if (!config->wipe_intentionally_left_blank_rfork) {
1359 if (ad_getentrylen(ad, ADEID_RFORK) != sizeof(empty_resourcefork)) {
1363 maplen = ad_getentryoff(ad, ADEID_RFORK) +
1364 ad_getentrylen(ad, ADEID_RFORK);
1366 /* FIXME: direct use of mmap(), vfs_aio_fork does it too */
1367 map = mmap(NULL, maplen, PROT_READ|PROT_WRITE, MAP_SHARED,
1369 if (map == MAP_FAILED) {
1370 DBG_ERR("mmap AppleDouble: %s\n", strerror(errno));
1374 cmp = memcmp(map + ADEDOFF_RFORK_DOT_UND,
1376 sizeof(empty_resourcefork));
1377 rc = munmap(map, maplen);
1379 DBG_ERR("munmap failed: %s\n", strerror(errno));
1387 ad_setentrylen(ad, ADEID_RFORK, 0);
1394 len = sys_pwrite(ad->ad_fd, ad->ad_data, AD_DATASZ_DOT_UND, 0);
1395 if (len != AD_DATASZ_DOT_UND) {
1403 static bool ad_convert_delete_adfile(struct adouble *ad,
1404 const struct smb_filename *smb_fname)
1406 struct fruit_config_data *config = NULL;
1407 struct smb_filename *ad_name = NULL;
1410 if (ad_getentrylen(ad, ADEID_RFORK) > 0) {
1414 SMB_VFS_HANDLE_GET_DATA(ad->ad_handle, config,
1415 struct fruit_config_data, return false);
1417 if (!config->delete_empty_adfiles) {
1421 rc = adouble_path(talloc_tos(), smb_fname, &ad_name);
1426 rc = SMB_VFS_NEXT_UNLINK(ad->ad_handle, ad_name);
1428 DBG_ERR("Unlinking [%s] failed: %s\n",
1429 smb_fname_str_dbg(ad_name), strerror(errno));
1430 TALLOC_FREE(ad_name);
1434 DBG_WARNING("Unlinked [%s] after conversion\n", smb_fname_str_dbg(ad_name));
1435 TALLOC_FREE(ad_name);
1441 * Convert from Apple's ._ file to Netatalk
1443 * Apple's AppleDouble may contain a FinderInfo entry longer then 32
1444 * bytes containing packed xattrs.
1446 * @return -1 in case an error occurred, 0 if no conversion was done, 1
1449 static int ad_convert(struct adouble *ad,
1450 const struct smb_filename *smb_fname)
1453 bool converted_xattr = false;
1456 ok = ad_convert_xattr(ad, smb_fname, &converted_xattr);
1461 ok = ad_convert_blank_rfork(ad, &blank);
1466 if (converted_xattr || blank) {
1467 ok = ad_convert_truncate(ad, smb_fname);
1473 ok = ad_convert_finderinfo(ad, smb_fname);
1475 DBG_ERR("Failed to convert [%s]\n",
1476 smb_fname_str_dbg(smb_fname));
1480 ok = ad_convert_delete_adfile(ad, smb_fname);
1489 * Read and parse Netatalk AppleDouble metadata xattr
1491 static ssize_t ad_read_meta(struct adouble *ad,
1492 const struct smb_filename *smb_fname)
1498 DEBUG(10, ("reading meta xattr for %s\n", smb_fname->base_name));
1500 ealen = SMB_VFS_GETXATTR(ad->ad_handle->conn, smb_fname,
1501 AFPINFO_EA_NETATALK, ad->ad_data,
1507 if (errno == ENOATTR) {
1513 DEBUG(2, ("error reading meta xattr: %s\n",
1519 if (ealen != AD_DATASZ_XATTR) {
1520 DEBUG(2, ("bad size %zd\n", ealen));
1526 /* Now parse entries */
1527 ok = ad_unpack(ad, ADEID_NUM_XATTR, AD_DATASZ_XATTR);
1529 DEBUG(2, ("invalid AppleDouble metadata xattr\n"));
1535 if (!ad_getentryoff(ad, ADEID_FINDERI)
1536 || !ad_getentryoff(ad, ADEID_COMMENT)
1537 || !ad_getentryoff(ad, ADEID_FILEDATESI)
1538 || !ad_getentryoff(ad, ADEID_AFPFILEI)
1539 || !ad_getentryoff(ad, ADEID_PRIVDEV)
1540 || !ad_getentryoff(ad, ADEID_PRIVINO)
1541 || !ad_getentryoff(ad, ADEID_PRIVSYN)
1542 || !ad_getentryoff(ad, ADEID_PRIVID)) {
1543 DEBUG(2, ("invalid AppleDouble metadata xattr\n"));
1550 DEBUG(10, ("reading meta xattr for %s, rc: %d\n",
1551 smb_fname->base_name, rc));
1555 if (errno == EINVAL) {
1557 removexattr(smb_fname->base_name, AFPINFO_EA_NETATALK);
1565 static int ad_open_rsrc_xattr(const struct smb_filename *smb_fname,
1569 #ifdef HAVE_ATTROPEN
1570 /* FIXME: direct Solaris xattr syscall */
1571 return attropen(smb_fname->base_name,
1572 AFPRESOURCE_EA_NETATALK, flags, mode);
1579 static int ad_open_rsrc_adouble(const struct smb_filename *smb_fname,
1585 struct smb_filename *adp_smb_fname = NULL;
1587 ret = adouble_path(talloc_tos(), smb_fname, &adp_smb_fname);
1592 fd = open(adp_smb_fname->base_name, flags, mode);
1593 TALLOC_FREE(adp_smb_fname);
1598 static int ad_open_rsrc(vfs_handle_struct *handle,
1599 const struct smb_filename *smb_fname,
1603 struct fruit_config_data *config = NULL;
1606 SMB_VFS_HANDLE_GET_DATA(handle, config,
1607 struct fruit_config_data, return -1);
1609 if (config->rsrc == FRUIT_RSRC_XATTR) {
1610 fd = ad_open_rsrc_xattr(smb_fname, flags, mode);
1612 fd = ad_open_rsrc_adouble(smb_fname, flags, mode);
1619 * Here's the deal: for ADOUBLE_META we can do without an fd as we can issue
1620 * path based xattr calls. For ADOUBLE_RSRC however we need a full-fledged fd
1621 * for file IO on the ._ file.
1623 static int ad_open(vfs_handle_struct *handle,
1626 const struct smb_filename *smb_fname,
1632 DBG_DEBUG("Path [%s] type [%s]\n", smb_fname->base_name,
1633 ad->ad_type == ADOUBLE_META ? "meta" : "rsrc");
1635 if (ad->ad_type == ADOUBLE_META) {
1639 if ((fsp != NULL) && (fsp->fh != NULL) && (fsp->fh->fd != -1)) {
1640 ad->ad_fd = fsp->fh->fd;
1641 ad->ad_opened = false;
1645 fd = ad_open_rsrc(handle, smb_fname, flags, mode);
1649 ad->ad_opened = true;
1652 DBG_DEBUG("Path [%s] type [%s] fd [%d]\n",
1653 smb_fname->base_name,
1654 ad->ad_type == ADOUBLE_META ? "meta" : "rsrc", fd);
1659 static ssize_t ad_read_rsrc_xattr(struct adouble *ad)
1664 /* FIXME: direct sys_fstat(), don't have an fsp */
1665 ret = sys_fstat(ad->ad_fd, &st,
1666 lp_fake_directory_create_times(
1667 SNUM(ad->ad_handle->conn)));
1672 ad_setentrylen(ad, ADEID_RFORK, st.st_ex_size);
1673 return st.st_ex_size;
1676 static ssize_t ad_read_rsrc_adouble(struct adouble *ad,
1677 const struct smb_filename *smb_fname)
1679 SMB_STRUCT_STAT sbuf;
1686 ret = sys_fstat(ad->ad_fd, &sbuf, lp_fake_directory_create_times(
1687 SNUM(ad->ad_handle->conn)));
1693 * AppleDouble file header content and size, two cases:
1695 * - without xattrs it is exactly AD_DATASZ_DOT_UND (82) bytes large
1696 * - with embedded xattrs it can be larger, up to AD_XATTR_MAX_HDR_SIZE
1698 * Read as much as we can up to AD_XATTR_MAX_HDR_SIZE.
1700 size = sbuf.st_ex_size;
1701 if (size > talloc_array_length(ad->ad_data)) {
1702 if (size > AD_XATTR_MAX_HDR_SIZE) {
1703 size = AD_XATTR_MAX_HDR_SIZE;
1705 p_ad = talloc_realloc(ad, ad->ad_data, char, size);
1712 len = sys_pread(ad->ad_fd, ad->ad_data,
1713 talloc_array_length(ad->ad_data), 0);
1714 if (len != talloc_array_length(ad->ad_data)) {
1715 DBG_NOTICE("%s %s: bad size: %zd\n",
1716 smb_fname->base_name, strerror(errno), len);
1720 /* Now parse entries */
1721 ok = ad_unpack(ad, ADEID_NUM_DOT_UND, sbuf.st_ex_size);
1723 DBG_ERR("invalid AppleDouble resource %s\n",
1724 smb_fname->base_name);
1729 if ((ad_getentryoff(ad, ADEID_FINDERI) != ADEDOFF_FINDERI_DOT_UND)
1730 || (ad_getentrylen(ad, ADEID_FINDERI) < ADEDLEN_FINDERI)
1731 || (ad_getentryoff(ad, ADEID_RFORK) < ADEDOFF_RFORK_DOT_UND)) {
1732 DBG_ERR("invalid AppleDouble resource %s\n",
1733 smb_fname->base_name);
1739 * Try to fixup AppleDouble files created by OS X with xattrs
1740 * appended to the ADEID_FINDERI entry.
1743 ret = ad_convert(ad, smb_fname);
1745 DBG_WARNING("Failed to convert [%s]\n", smb_fname->base_name);
1753 * Read and parse resource fork, either ._ AppleDouble file or xattr
1755 static ssize_t ad_read_rsrc(struct adouble *ad,
1756 const struct smb_filename *smb_fname)
1758 struct fruit_config_data *config = NULL;
1761 SMB_VFS_HANDLE_GET_DATA(ad->ad_handle, config,
1762 struct fruit_config_data, return -1);
1764 if (config->rsrc == FRUIT_RSRC_XATTR) {
1765 len = ad_read_rsrc_xattr(ad);
1767 len = ad_read_rsrc_adouble(ad, smb_fname);
1774 * Read and unpack an AppleDouble metadata xattr or resource
1776 static ssize_t ad_read(struct adouble *ad, const struct smb_filename *smb_fname)
1778 switch (ad->ad_type) {
1780 return ad_read_meta(ad, smb_fname);
1782 return ad_read_rsrc(ad, smb_fname);
1788 static int adouble_destructor(struct adouble *ad)
1790 if ((ad->ad_fd != -1) && ad->ad_opened) {
1798 * Allocate a struct adouble without initialiing it
1800 * The struct is either hang of the fsp extension context or if fsp is
1803 * @param[in] ctx talloc context
1804 * @param[in] handle vfs handle
1805 * @param[in] type type of AppleDouble, ADOUBLE_META or ADOUBLE_RSRC
1807 * @return adouble handle
1809 static struct adouble *ad_alloc(TALLOC_CTX *ctx, vfs_handle_struct *handle,
1810 adouble_type_t type)
1815 struct fruit_config_data *config;
1817 SMB_VFS_HANDLE_GET_DATA(handle, config,
1818 struct fruit_config_data, return NULL);
1822 adsize = AD_DATASZ_XATTR;
1825 if (config->rsrc == FRUIT_RSRC_ADFILE) {
1826 adsize = AD_DATASZ_DOT_UND;
1833 ad = talloc_zero(ctx, struct adouble);
1840 ad->ad_data = talloc_zero_array(ad, char, adsize);
1841 if (ad->ad_data == NULL) {
1847 ad->ad_handle = handle;
1849 ad->ad_magic = AD_MAGIC;
1850 ad->ad_version = AD_VERSION;
1853 talloc_set_destructor(ad, adouble_destructor);
1863 * Allocate and initialize a new struct adouble
1865 * @param[in] ctx talloc context
1866 * @param[in] handle vfs handle
1867 * @param[in] type type of AppleDouble, ADOUBLE_META or ADOUBLE_RSRC
1869 * @return adouble handle, initialized
1871 static struct adouble *ad_init(TALLOC_CTX *ctx, vfs_handle_struct *handle,
1872 adouble_type_t type)
1875 const struct ad_entry_order *eid;
1876 struct adouble *ad = NULL;
1877 struct fruit_config_data *config;
1878 time_t t = time(NULL);
1880 SMB_VFS_HANDLE_GET_DATA(handle, config,
1881 struct fruit_config_data, return NULL);
1885 eid = entry_order_meta_xattr;
1888 if (config->rsrc == FRUIT_RSRC_ADFILE) {
1889 eid = entry_order_dot_und;
1891 eid = entry_order_rsrc_xattr;
1898 ad = ad_alloc(ctx, handle, type);
1904 ad->ad_eid[eid->id].ade_off = eid->offset;
1905 ad->ad_eid[eid->id].ade_len = eid->len;
1909 /* put something sane in the date fields */
1910 ad_setdate(ad, AD_DATE_CREATE | AD_DATE_UNIX, t);
1911 ad_setdate(ad, AD_DATE_MODIFY | AD_DATE_UNIX, t);
1912 ad_setdate(ad, AD_DATE_ACCESS | AD_DATE_UNIX, t);
1913 ad_setdate(ad, AD_DATE_BACKUP, htonl(AD_DATE_START));
1921 static struct adouble *ad_get_internal(TALLOC_CTX *ctx,
1922 vfs_handle_struct *handle,
1924 const struct smb_filename *smb_fname,
1925 adouble_type_t type)
1929 struct adouble *ad = NULL;
1933 smb_fname = fsp->base_fsp->fsp_name;
1936 DEBUG(10, ("ad_get(%s) called for %s\n",
1937 type == ADOUBLE_META ? "meta" : "rsrc",
1938 smb_fname->base_name));
1940 ad = ad_alloc(ctx, handle, type);
1946 /* Try rw first so we can use the fd in ad_convert() */
1949 rc = ad_open(handle, ad, fsp, smb_fname, mode, 0);
1950 if (rc == -1 && ((errno == EROFS) || (errno == EACCES))) {
1952 rc = ad_open(handle, ad, fsp, smb_fname, mode, 0);
1955 DBG_DEBUG("ad_open [%s] error [%s]\n",
1956 smb_fname->base_name, strerror(errno));
1961 len = ad_read(ad, smb_fname);
1963 DEBUG(10, ("error reading AppleDouble for %s\n",
1964 smb_fname->base_name));
1970 DEBUG(10, ("ad_get(%s) for %s returning %d\n",
1971 type == ADOUBLE_META ? "meta" : "rsrc",
1972 smb_fname->base_name, rc));
1981 * Return AppleDouble data for a file
1983 * @param[in] ctx talloc context
1984 * @param[in] handle vfs handle
1985 * @param[in] smb_fname pathname to file or directory
1986 * @param[in] type type of AppleDouble, ADOUBLE_META or ADOUBLE_RSRC
1988 * @return talloced struct adouble or NULL on error
1990 static struct adouble *ad_get(TALLOC_CTX *ctx,
1991 vfs_handle_struct *handle,
1992 const struct smb_filename *smb_fname,
1993 adouble_type_t type)
1995 return ad_get_internal(ctx, handle, NULL, smb_fname, type);
1999 * Return AppleDouble data for a file
2001 * @param[in] ctx talloc context
2002 * @param[in] handle vfs handle
2003 * @param[in] fsp fsp to use for IO
2004 * @param[in] type type of AppleDouble, ADOUBLE_META or ADOUBLE_RSRC
2006 * @return talloced struct adouble or NULL on error
2008 static struct adouble *ad_fget(TALLOC_CTX *ctx, vfs_handle_struct *handle,
2009 files_struct *fsp, adouble_type_t type)
2011 return ad_get_internal(ctx, handle, fsp, NULL, type);
2015 * Set AppleDouble metadata on a file or directory
2017 * @param[in] ad adouble handle
2019 * @param[in] smb_fname pathname to file or directory
2021 * @return status code, 0 means success
2023 static int ad_set(struct adouble *ad, const struct smb_filename *smb_fname)
2028 DBG_DEBUG("Path [%s]\n", smb_fname->base_name);
2030 if (ad->ad_type != ADOUBLE_META) {
2031 DBG_ERR("ad_set on [%s] used with ADOUBLE_RSRC\n",
2032 smb_fname->base_name);
2041 ret = SMB_VFS_SETXATTR(ad->ad_handle->conn,
2043 AFPINFO_EA_NETATALK,
2045 AD_DATASZ_XATTR, 0);
2047 DBG_DEBUG("Path [%s] ret [%d]\n", smb_fname->base_name, ret);
2053 * Set AppleDouble metadata on a file or directory
2055 * @param[in] ad adouble handle
2056 * @param[in] fsp file handle
2058 * @return status code, 0 means success
2060 static int ad_fset(struct adouble *ad, files_struct *fsp)
2066 DBG_DEBUG("Path [%s]\n", fsp_str_dbg(fsp));
2069 || (fsp->fh == NULL)
2070 || (fsp->fh->fd == -1))
2072 smb_panic("bad fsp");
2080 switch (ad->ad_type) {
2082 rc = SMB_VFS_NEXT_SETXATTR(ad->ad_handle,
2084 AFPINFO_EA_NETATALK,
2086 AD_DATASZ_XATTR, 0);
2090 len = SMB_VFS_NEXT_PWRITE(ad->ad_handle,
2095 if (len != AD_DATASZ_DOT_UND) {
2096 DBG_ERR("short write on %s: %zd", fsp_str_dbg(fsp), len);
2106 DBG_DEBUG("Path [%s] rc [%d]\n", fsp_str_dbg(fsp), rc);
2111 /*****************************************************************************
2113 *****************************************************************************/
2115 static bool is_afpinfo_stream(const struct smb_filename *smb_fname)
2117 if (strncasecmp_m(smb_fname->stream_name,
2118 AFPINFO_STREAM_NAME,
2119 strlen(AFPINFO_STREAM_NAME)) == 0) {
2125 static bool is_afpresource_stream(const struct smb_filename *smb_fname)
2127 if (strncasecmp_m(smb_fname->stream_name,
2128 AFPRESOURCE_STREAM_NAME,
2129 strlen(AFPRESOURCE_STREAM_NAME)) == 0) {
2136 * Test whether stream is an Apple stream, not used atm
2139 static bool is_apple_stream(const struct smb_filename *smb_fname)
2141 if (is_afpinfo_stream(smb_fname)) {
2144 if (is_afpresource_stream(smb_fname)) {
2152 * Initialize config struct from our smb.conf config parameters
2154 static int init_fruit_config(vfs_handle_struct *handle)
2156 struct fruit_config_data *config;
2158 const char *tm_size_str = NULL;
2160 config = talloc_zero(handle->conn, struct fruit_config_data);
2162 DEBUG(1, ("talloc_zero() failed\n"));
2168 * Versions up to Samba 4.5.x had a spelling bug in the
2169 * fruit:resource option calling lp_parm_enum with
2170 * "res*s*ource" (ie two s).
2172 * In Samba 4.6 we accept both the wrong and the correct
2173 * spelling, in Samba 4.7 the bad spelling will be removed.
2175 enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
2176 "ressource", fruit_rsrc, FRUIT_RSRC_ADFILE);
2177 if (enumval == -1) {
2178 DEBUG(1, ("value for %s: resource type unknown\n",
2179 FRUIT_PARAM_TYPE_NAME));
2182 config->rsrc = (enum fruit_rsrc)enumval;
2184 enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
2185 "resource", fruit_rsrc, enumval);
2186 if (enumval == -1) {
2187 DEBUG(1, ("value for %s: resource type unknown\n",
2188 FRUIT_PARAM_TYPE_NAME));
2191 config->rsrc = (enum fruit_rsrc)enumval;
2193 enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
2194 "metadata", fruit_meta, FRUIT_META_NETATALK);
2195 if (enumval == -1) {
2196 DEBUG(1, ("value for %s: metadata type unknown\n",
2197 FRUIT_PARAM_TYPE_NAME));
2200 config->meta = (enum fruit_meta)enumval;
2202 enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
2203 "locking", fruit_locking, FRUIT_LOCKING_NONE);
2204 if (enumval == -1) {
2205 DEBUG(1, ("value for %s: locking type unknown\n",
2206 FRUIT_PARAM_TYPE_NAME));
2209 config->locking = (enum fruit_locking)enumval;
2211 enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
2212 "encoding", fruit_encoding, FRUIT_ENC_PRIVATE);
2213 if (enumval == -1) {
2214 DEBUG(1, ("value for %s: encoding type unknown\n",
2215 FRUIT_PARAM_TYPE_NAME));
2218 config->encoding = (enum fruit_encoding)enumval;
2220 if (config->rsrc == FRUIT_RSRC_ADFILE) {
2221 config->veto_appledouble = lp_parm_bool(SNUM(handle->conn),
2222 FRUIT_PARAM_TYPE_NAME,
2227 config->use_aapl = lp_parm_bool(
2228 -1, FRUIT_PARAM_TYPE_NAME, "aapl", true);
2230 config->time_machine = lp_parm_bool(
2231 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME, "time machine", false);
2233 config->unix_info_enabled = lp_parm_bool(
2234 -1, FRUIT_PARAM_TYPE_NAME, "nfs_aces", true);
2236 config->use_copyfile = lp_parm_bool(-1, FRUIT_PARAM_TYPE_NAME,
2239 config->posix_rename = lp_parm_bool(
2240 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME, "posix_rename", true);
2242 config->aapl_zero_file_id =
2243 lp_parm_bool(-1, FRUIT_PARAM_TYPE_NAME, "zero_file_id", true);
2245 config->readdir_attr_rsize = lp_parm_bool(
2246 SNUM(handle->conn), "readdir_attr", "aapl_rsize", true);
2248 config->readdir_attr_finder_info = lp_parm_bool(
2249 SNUM(handle->conn), "readdir_attr", "aapl_finder_info", true);
2251 config->readdir_attr_max_access = lp_parm_bool(
2252 SNUM(handle->conn), "readdir_attr", "aapl_max_access", true);
2254 config->model = lp_parm_const_string(
2255 -1, FRUIT_PARAM_TYPE_NAME, "model", "MacSamba");
2257 tm_size_str = lp_parm_const_string(
2258 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
2259 "time machine max size", NULL);
2260 if (tm_size_str != NULL) {
2261 config->time_machine_max_size = conv_str_size(tm_size_str);
2264 config->wipe_intentionally_left_blank_rfork = lp_parm_bool(
2265 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
2266 "wipe_intentionally_left_blank_rfork", false);
2268 config->delete_empty_adfiles = lp_parm_bool(
2269 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
2270 "delete_empty_adfiles", false);
2272 SMB_VFS_HANDLE_SET_DATA(handle, config,
2273 NULL, struct fruit_config_data,
2280 * Prepend "._" to a basename
2281 * Return a new struct smb_filename with stream_name == NULL.
2283 static int adouble_path(TALLOC_CTX *ctx,
2284 const struct smb_filename *smb_fname_in,
2285 struct smb_filename **pp_smb_fname_out)
2289 struct smb_filename *smb_fname = cp_smb_filename(ctx,
2292 if (smb_fname == NULL) {
2296 /* We need streamname to be NULL */
2297 TALLOC_FREE(smb_fname->stream_name);
2299 /* And we're replacing base_name. */
2300 TALLOC_FREE(smb_fname->base_name);
2302 if (!parent_dirname(smb_fname, smb_fname_in->base_name,
2304 TALLOC_FREE(smb_fname);
2308 smb_fname->base_name = talloc_asprintf(smb_fname,
2309 "%s/._%s", parent, base);
2310 if (smb_fname->base_name == NULL) {
2311 TALLOC_FREE(smb_fname);
2315 *pp_smb_fname_out = smb_fname;
2321 * Allocate and initialize an AfpInfo struct
2323 static AfpInfo *afpinfo_new(TALLOC_CTX *ctx)
2325 AfpInfo *ai = talloc_zero(ctx, AfpInfo);
2329 ai->afpi_Signature = AFP_Signature;
2330 ai->afpi_Version = AFP_Version;
2331 ai->afpi_BackupTime = AD_DATE_START;
2336 * Pack an AfpInfo struct into a buffer
2338 * Buffer size must be at least AFP_INFO_SIZE
2339 * Returns size of packed buffer
2341 static ssize_t afpinfo_pack(const AfpInfo *ai, char *buf)
2343 memset(buf, 0, AFP_INFO_SIZE);
2345 RSIVAL(buf, 0, ai->afpi_Signature);
2346 RSIVAL(buf, 4, ai->afpi_Version);
2347 RSIVAL(buf, 12, ai->afpi_BackupTime);
2348 memcpy(buf + 16, ai->afpi_FinderInfo, sizeof(ai->afpi_FinderInfo));
2350 return AFP_INFO_SIZE;
2354 * Unpack a buffer into a AfpInfo structure
2356 * Buffer size must be at least AFP_INFO_SIZE
2357 * Returns allocated AfpInfo struct
2359 static AfpInfo *afpinfo_unpack(TALLOC_CTX *ctx, const void *data)
2361 AfpInfo *ai = talloc_zero(ctx, AfpInfo);
2366 ai->afpi_Signature = RIVAL(data, 0);
2367 ai->afpi_Version = RIVAL(data, 4);
2368 ai->afpi_BackupTime = RIVAL(data, 12);
2369 memcpy(ai->afpi_FinderInfo, (const char *)data + 16,
2370 sizeof(ai->afpi_FinderInfo));
2372 if (ai->afpi_Signature != AFP_Signature
2373 || ai->afpi_Version != AFP_Version) {
2374 DEBUG(1, ("Bad AfpInfo signature or version\n"));
2382 * Fake an inode number from the md5 hash of the (xattr) name
2384 static SMB_INO_T fruit_inode(const SMB_STRUCT_STAT *sbuf, const char *sname)
2387 unsigned char hash[16];
2391 DBG_DEBUG("fruit_inode called for %ju/%ju [%s]\n",
2392 (uintmax_t)sbuf->st_ex_dev,
2393 (uintmax_t)sbuf->st_ex_ino, sname);
2395 upper_sname = talloc_strdup_upper(talloc_tos(), sname);
2396 SMB_ASSERT(upper_sname != NULL);
2399 MD5Update(&ctx, (const unsigned char *)&(sbuf->st_ex_dev),
2400 sizeof(sbuf->st_ex_dev));
2401 MD5Update(&ctx, (const unsigned char *)&(sbuf->st_ex_ino),
2402 sizeof(sbuf->st_ex_ino));
2403 MD5Update(&ctx, (unsigned char *)upper_sname,
2404 talloc_get_size(upper_sname)-1);
2405 MD5Final(hash, &ctx);
2407 TALLOC_FREE(upper_sname);
2409 /* Hopefully all the variation is in the lower 4 (or 8) bytes! */
2410 memcpy(&result, hash, sizeof(result));
2412 DBG_DEBUG("fruit_inode \"%s\": ino=%ju\n",
2413 sname, (uintmax_t)result);
2418 static bool add_fruit_stream(TALLOC_CTX *mem_ctx, unsigned int *num_streams,
2419 struct stream_struct **streams,
2420 const char *name, off_t size,
2423 struct stream_struct *tmp;
2425 tmp = talloc_realloc(mem_ctx, *streams, struct stream_struct,
2431 tmp[*num_streams].name = talloc_asprintf(tmp, "%s:$DATA", name);
2432 if (tmp[*num_streams].name == NULL) {
2436 tmp[*num_streams].size = size;
2437 tmp[*num_streams].alloc_size = alloc_size;
2444 static bool filter_empty_rsrc_stream(unsigned int *num_streams,
2445 struct stream_struct **streams)
2447 struct stream_struct *tmp = *streams;
2450 if (*num_streams == 0) {
2454 for (i = 0; i < *num_streams; i++) {
2455 if (strequal_m(tmp[i].name, AFPRESOURCE_STREAM)) {
2460 if (i == *num_streams) {
2464 if (tmp[i].size > 0) {
2468 TALLOC_FREE(tmp[i].name);
2469 if (*num_streams - 1 > i) {
2470 memmove(&tmp[i], &tmp[i+1],
2471 (*num_streams - i - 1) * sizeof(struct stream_struct));
2478 static bool del_fruit_stream(TALLOC_CTX *mem_ctx, unsigned int *num_streams,
2479 struct stream_struct **streams,
2482 struct stream_struct *tmp = *streams;
2485 if (*num_streams == 0) {
2489 for (i = 0; i < *num_streams; i++) {
2490 if (strequal_m(tmp[i].name, name)) {
2495 if (i == *num_streams) {
2499 TALLOC_FREE(tmp[i].name);
2500 if (*num_streams - 1 > i) {
2501 memmove(&tmp[i], &tmp[i+1],
2502 (*num_streams - i - 1) * sizeof(struct stream_struct));
2509 static bool ad_empty_finderinfo(const struct adouble *ad)
2512 char emptybuf[ADEDLEN_FINDERI] = {0};
2515 fi = ad_get_entry(ad, ADEID_FINDERI);
2517 DBG_ERR("Missing FinderInfo in struct adouble [%p]\n", ad);
2521 cmp = memcmp(emptybuf, fi, ADEDLEN_FINDERI);
2525 static bool ai_empty_finderinfo(const AfpInfo *ai)
2528 char emptybuf[ADEDLEN_FINDERI] = {0};
2530 cmp = memcmp(emptybuf, &ai->afpi_FinderInfo[0], ADEDLEN_FINDERI);
2535 * Update btime with btime from Netatalk
2537 static void update_btime(vfs_handle_struct *handle,
2538 struct smb_filename *smb_fname)
2541 struct timespec creation_time = {0};
2543 struct fruit_config_data *config = NULL;
2545 SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
2548 switch (config->meta) {
2549 case FRUIT_META_STREAM:
2551 case FRUIT_META_NETATALK:
2555 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
2559 ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_META);
2563 if (ad_getdate(ad, AD_DATE_UNIX | AD_DATE_CREATE, &t) != 0) {
2569 creation_time.tv_sec = convert_uint32_t_to_time_t(t);
2570 update_stat_ex_create_time(&smb_fname->st, creation_time);
2576 * Map an access mask to a Netatalk single byte byte range lock
2578 static off_t access_to_netatalk_brl(enum apple_fork fork_type,
2579 uint32_t access_mask)
2583 switch (access_mask) {
2584 case FILE_READ_DATA:
2585 offset = AD_FILELOCK_OPEN_RD;
2588 case FILE_WRITE_DATA:
2589 case FILE_APPEND_DATA:
2590 offset = AD_FILELOCK_OPEN_WR;
2594 offset = AD_FILELOCK_OPEN_NONE;
2598 if (fork_type == APPLE_FORK_RSRC) {
2599 if (offset == AD_FILELOCK_OPEN_NONE) {
2600 offset = AD_FILELOCK_RSRC_OPEN_NONE;
2610 * Map a deny mode to a Netatalk brl
2612 static off_t denymode_to_netatalk_brl(enum apple_fork fork_type,
2617 switch (deny_mode) {
2619 offset = AD_FILELOCK_DENY_RD;
2623 offset = AD_FILELOCK_DENY_WR;
2627 smb_panic("denymode_to_netatalk_brl: bad deny mode\n");
2630 if (fork_type == APPLE_FORK_RSRC) {
2638 * Call fcntl() with an exclusive F_GETLK request in order to
2639 * determine if there's an exisiting shared lock
2641 * @return true if the requested lock was found or any error occurred
2642 * false if the lock was not found
2644 static bool test_netatalk_lock(files_struct *fsp, off_t in_offset)
2647 off_t offset = in_offset;
2652 result = SMB_VFS_GETLOCK(fsp, &offset, &len, &type, &pid);
2653 if (result == false) {
2657 if (type != F_UNLCK) {
2664 static NTSTATUS fruit_check_access(vfs_handle_struct *handle,
2666 uint32_t access_mask,
2669 NTSTATUS status = NT_STATUS_OK;
2670 bool open_for_reading, open_for_writing, deny_read, deny_write;
2672 bool have_read = false;
2675 /* FIXME: hardcoded data fork, add resource fork */
2676 enum apple_fork fork_type = APPLE_FORK_DATA;
2678 DEBUG(10, ("fruit_check_access: %s, am: %s/%s, dm: %s/%s\n",
2680 access_mask & FILE_READ_DATA ? "READ" :"-",
2681 access_mask & FILE_WRITE_DATA ? "WRITE" : "-",
2682 deny_mode & DENY_READ ? "DENY_READ" : "-",
2683 deny_mode & DENY_WRITE ? "DENY_WRITE" : "-"));
2685 if (fsp->fh->fd == -1) {
2686 return NT_STATUS_OK;
2689 flags = fcntl(fsp->fh->fd, F_GETFL);
2691 DBG_ERR("fcntl get flags [%s] fd [%d] failed [%s]\n",
2692 fsp_str_dbg(fsp), fsp->fh->fd, strerror(errno));
2693 return map_nt_error_from_unix(errno);
2696 if (flags & (O_RDONLY|O_RDWR)) {
2698 * Applying fcntl read locks requires an fd opened for
2699 * reading. This means we won't be applying locks for
2700 * files openend write-only, but what can we do...
2706 * Check read access and deny read mode
2708 if ((access_mask & FILE_READ_DATA) || (deny_mode & DENY_READ)) {
2710 open_for_reading = test_netatalk_lock(
2711 fsp, access_to_netatalk_brl(fork_type, FILE_READ_DATA));
2713 deny_read = test_netatalk_lock(
2714 fsp, denymode_to_netatalk_brl(fork_type, DENY_READ));
2716 DEBUG(10, ("read: %s, deny_write: %s\n",
2717 open_for_reading == true ? "yes" : "no",
2718 deny_read == true ? "yes" : "no"));
2720 if (((access_mask & FILE_READ_DATA) && deny_read)
2721 || ((deny_mode & DENY_READ) && open_for_reading)) {
2722 return NT_STATUS_SHARING_VIOLATION;
2726 if ((access_mask & FILE_READ_DATA) && have_read) {
2727 struct byte_range_lock *br_lck = NULL;
2729 off = access_to_netatalk_brl(fork_type, FILE_READ_DATA);
2731 handle->conn->sconn->msg_ctx, fsp,
2732 fsp->op->global->open_persistent_id, 1, off,
2733 READ_LOCK, POSIX_LOCK, false,
2736 TALLOC_FREE(br_lck);
2738 if (!NT_STATUS_IS_OK(status)) {
2743 if ((deny_mode & DENY_READ) && have_read) {
2744 struct byte_range_lock *br_lck = NULL;
2746 off = denymode_to_netatalk_brl(fork_type, DENY_READ);
2748 handle->conn->sconn->msg_ctx, fsp,
2749 fsp->op->global->open_persistent_id, 1, off,
2750 READ_LOCK, POSIX_LOCK, false,
2753 TALLOC_FREE(br_lck);
2755 if (!NT_STATUS_IS_OK(status)) {
2762 * Check write access and deny write mode
2764 if ((access_mask & FILE_WRITE_DATA) || (deny_mode & DENY_WRITE)) {
2766 open_for_writing = test_netatalk_lock(
2767 fsp, access_to_netatalk_brl(fork_type, FILE_WRITE_DATA));
2769 deny_write = test_netatalk_lock(
2770 fsp, denymode_to_netatalk_brl(fork_type, DENY_WRITE));
2772 DEBUG(10, ("write: %s, deny_write: %s\n",
2773 open_for_writing == true ? "yes" : "no",
2774 deny_write == true ? "yes" : "no"));
2776 if (((access_mask & FILE_WRITE_DATA) && deny_write)
2777 || ((deny_mode & DENY_WRITE) && open_for_writing)) {
2778 return NT_STATUS_SHARING_VIOLATION;
2782 if ((access_mask & FILE_WRITE_DATA) && have_read) {
2783 struct byte_range_lock *br_lck = NULL;
2785 off = access_to_netatalk_brl(fork_type, FILE_WRITE_DATA);
2787 handle->conn->sconn->msg_ctx, fsp,
2788 fsp->op->global->open_persistent_id, 1, off,
2789 READ_LOCK, POSIX_LOCK, false,
2792 TALLOC_FREE(br_lck);
2794 if (!NT_STATUS_IS_OK(status)) {
2798 if ((deny_mode & DENY_WRITE) && have_read) {
2799 struct byte_range_lock *br_lck = NULL;
2801 off = denymode_to_netatalk_brl(fork_type, DENY_WRITE);
2803 handle->conn->sconn->msg_ctx, fsp,
2804 fsp->op->global->open_persistent_id, 1, off,
2805 READ_LOCK, POSIX_LOCK, false,
2808 TALLOC_FREE(br_lck);
2810 if (!NT_STATUS_IS_OK(status)) {
2819 static NTSTATUS check_aapl(vfs_handle_struct *handle,
2820 struct smb_request *req,
2821 const struct smb2_create_blobs *in_context_blobs,
2822 struct smb2_create_blobs *out_context_blobs)
2824 struct fruit_config_data *config;
2826 struct smb2_create_blob *aapl = NULL;
2830 DATA_BLOB blob = data_blob_talloc(req, NULL, 0);
2831 uint64_t req_bitmap, client_caps;
2832 uint64_t server_caps = SMB2_CRTCTX_AAPL_UNIX_BASED;
2836 SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
2837 return NT_STATUS_UNSUCCESSFUL);
2839 if (!config->use_aapl
2840 || in_context_blobs == NULL
2841 || out_context_blobs == NULL) {
2842 return NT_STATUS_OK;
2845 aapl = smb2_create_blob_find(in_context_blobs,
2846 SMB2_CREATE_TAG_AAPL);
2848 return NT_STATUS_OK;
2851 if (aapl->data.length != 24) {
2852 DEBUG(1, ("unexpected AAPL ctxt length: %ju\n",
2853 (uintmax_t)aapl->data.length));
2854 return NT_STATUS_INVALID_PARAMETER;
2857 cmd = IVAL(aapl->data.data, 0);
2858 if (cmd != SMB2_CRTCTX_AAPL_SERVER_QUERY) {
2859 DEBUG(1, ("unsupported AAPL cmd: %d\n", cmd));
2860 return NT_STATUS_INVALID_PARAMETER;
2863 req_bitmap = BVAL(aapl->data.data, 8);
2864 client_caps = BVAL(aapl->data.data, 16);
2866 SIVAL(p, 0, SMB2_CRTCTX_AAPL_SERVER_QUERY);
2868 SBVAL(p, 8, req_bitmap);
2869 ok = data_blob_append(req, &blob, p, 16);
2871 return NT_STATUS_UNSUCCESSFUL;
2874 if (req_bitmap & SMB2_CRTCTX_AAPL_SERVER_CAPS) {
2875 if ((client_caps & SMB2_CRTCTX_AAPL_SUPPORTS_READ_DIR_ATTR) &&
2876 (handle->conn->tcon->compat->fs_capabilities & FILE_NAMED_STREAMS)) {
2877 server_caps |= SMB2_CRTCTX_AAPL_SUPPORTS_READ_DIR_ATTR;
2878 config->readdir_attr_enabled = true;
2881 if (config->use_copyfile) {
2882 server_caps |= SMB2_CRTCTX_AAPL_SUPPORTS_OSX_COPYFILE;
2883 config->copyfile_enabled = true;
2887 * The client doesn't set the flag, so we can't check
2888 * for it and just set it unconditionally
2890 if (config->unix_info_enabled) {
2891 server_caps |= SMB2_CRTCTX_AAPL_SUPPORTS_NFS_ACE;
2894 SBVAL(p, 0, server_caps);
2895 ok = data_blob_append(req, &blob, p, 8);
2897 return NT_STATUS_UNSUCCESSFUL;
2901 if (req_bitmap & SMB2_CRTCTX_AAPL_VOLUME_CAPS) {
2902 int val = lp_case_sensitive(SNUM(handle->conn->tcon->compat));
2910 caps |= SMB2_CRTCTX_AAPL_CASE_SENSITIVE;
2917 if (config->time_machine) {
2918 caps |= SMB2_CRTCTX_AAPL_FULL_SYNC;
2923 ok = data_blob_append(req, &blob, p, 8);
2925 return NT_STATUS_UNSUCCESSFUL;
2929 if (req_bitmap & SMB2_CRTCTX_AAPL_MODEL_INFO) {
2930 ok = convert_string_talloc(req,
2931 CH_UNIX, CH_UTF16LE,
2932 config->model, strlen(config->model),
2935 return NT_STATUS_UNSUCCESSFUL;
2939 SIVAL(p + 4, 0, modellen);
2940 ok = data_blob_append(req, &blob, p, 8);
2943 return NT_STATUS_UNSUCCESSFUL;
2946 ok = data_blob_append(req, &blob, model, modellen);
2949 return NT_STATUS_UNSUCCESSFUL;
2953 status = smb2_create_blob_add(out_context_blobs,
2955 SMB2_CREATE_TAG_AAPL,
2957 if (NT_STATUS_IS_OK(status)) {
2958 global_fruit_config.nego_aapl = true;
2959 if (config->aapl_zero_file_id) {
2960 aapl_force_zero_file_id(handle->conn->sconn);
2967 static bool readdir_attr_meta_finderi_stream(
2968 struct vfs_handle_struct *handle,
2969 const struct smb_filename *smb_fname,
2972 struct smb_filename *stream_name = NULL;
2973 files_struct *fsp = NULL;
2978 uint8_t buf[AFP_INFO_SIZE];
2980 stream_name = synthetic_smb_fname(talloc_tos(),
2981 smb_fname->base_name,
2982 AFPINFO_STREAM_NAME,
2983 NULL, smb_fname->flags);
2984 if (stream_name == NULL) {
2988 ret = SMB_VFS_STAT(handle->conn, stream_name);
2993 status = SMB_VFS_CREATE_FILE(
2994 handle->conn, /* conn */
2996 0, /* root_dir_fid */
2997 stream_name, /* fname */
2998 FILE_READ_DATA, /* access_mask */
2999 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
3001 FILE_OPEN, /* create_disposition*/
3002 0, /* create_options */
3003 0, /* file_attributes */
3004 INTERNAL_OPEN_ONLY, /* oplock_request */
3006 0, /* allocation_size */
3007 0, /* private_flags */
3012 NULL, NULL); /* create context */
3014 TALLOC_FREE(stream_name);
3016 if (!NT_STATUS_IS_OK(status)) {
3020 nread = SMB_VFS_PREAD(fsp, &buf[0], AFP_INFO_SIZE, 0);
3021 if (nread != AFP_INFO_SIZE) {
3022 DBG_ERR("short read [%s] [%zd/%d]\n",
3023 smb_fname_str_dbg(stream_name), nread, AFP_INFO_SIZE);
3028 memcpy(&ai->afpi_FinderInfo[0], &buf[AFP_OFF_FinderInfo],
3035 close_file(NULL, fsp, NORMAL_CLOSE);
3041 static bool readdir_attr_meta_finderi_netatalk(
3042 struct vfs_handle_struct *handle,
3043 const struct smb_filename *smb_fname,
3046 struct adouble *ad = NULL;
3049 ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_META);
3054 p = ad_get_entry(ad, ADEID_FINDERI);
3056 DBG_ERR("No ADEID_FINDERI for [%s]\n", smb_fname->base_name);
3061 memcpy(&ai->afpi_FinderInfo[0], p, AFP_FinderSize);
3066 static bool readdir_attr_meta_finderi(struct vfs_handle_struct *handle,
3067 const struct smb_filename *smb_fname,
3068 struct readdir_attr_data *attr_data)
3070 struct fruit_config_data *config = NULL;
3071 uint32_t date_added;
3075 SMB_VFS_HANDLE_GET_DATA(handle, config,
3076 struct fruit_config_data,
3079 switch (config->meta) {
3080 case FRUIT_META_NETATALK:
3081 ok = readdir_attr_meta_finderi_netatalk(
3082 handle, smb_fname, &ai);
3085 case FRUIT_META_STREAM:
3086 ok = readdir_attr_meta_finderi_stream(
3087 handle, smb_fname, &ai);
3091 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
3096 /* Don't bother with errors, it's likely ENOENT */
3100 if (S_ISREG(smb_fname->st.st_ex_mode)) {
3102 memcpy(&attr_data->attr_data.aapl.finder_info[0],
3103 &ai.afpi_FinderInfo[0], 4);
3105 /* finder_creator */
3106 memcpy(&attr_data->attr_data.aapl.finder_info[0] + 4,
3107 &ai.afpi_FinderInfo[4], 4);
3111 memcpy(&attr_data->attr_data.aapl.finder_info[0] + 8,
3112 &ai.afpi_FinderInfo[8], 2);
3114 /* finder_ext_flags */
3115 memcpy(&attr_data->attr_data.aapl.finder_info[0] + 10,
3116 &ai.afpi_FinderInfo[24], 2);
3119 date_added = convert_time_t_to_uint32_t(
3120 smb_fname->st.st_ex_btime.tv_sec - AD_DATE_DELTA);
3122 RSIVAL(&attr_data->attr_data.aapl.finder_info[0], 12, date_added);
3127 static uint64_t readdir_attr_rfork_size_adouble(
3128 struct vfs_handle_struct *handle,
3129 const struct smb_filename *smb_fname)
3131 struct adouble *ad = NULL;
3132 uint64_t rfork_size;
3134 ad = ad_get(talloc_tos(), handle, smb_fname,
3140 rfork_size = ad_getentrylen(ad, ADEID_RFORK);
3146 static uint64_t readdir_attr_rfork_size_stream(
3147 struct vfs_handle_struct *handle,
3148 const struct smb_filename *smb_fname)
3150 struct smb_filename *stream_name = NULL;
3152 uint64_t rfork_size;
3154 stream_name = synthetic_smb_fname(talloc_tos(),
3155 smb_fname->base_name,
3156 AFPRESOURCE_STREAM_NAME,
3158 if (stream_name == NULL) {
3162 ret = SMB_VFS_STAT(handle->conn, stream_name);
3164 TALLOC_FREE(stream_name);
3168 rfork_size = stream_name->st.st_ex_size;
3169 TALLOC_FREE(stream_name);
3174 static uint64_t readdir_attr_rfork_size(struct vfs_handle_struct *handle,
3175 const struct smb_filename *smb_fname)
3177 struct fruit_config_data *config = NULL;
3178 uint64_t rfork_size;
3180 SMB_VFS_HANDLE_GET_DATA(handle, config,
3181 struct fruit_config_data,
3184 switch (config->rsrc) {
3185 case FRUIT_RSRC_ADFILE:
3186 case FRUIT_RSRC_XATTR:
3187 rfork_size = readdir_attr_rfork_size_adouble(handle,
3191 case FRUIT_META_STREAM:
3192 rfork_size = readdir_attr_rfork_size_stream(handle,
3197 DBG_ERR("Unexpected rsrc config [%d]\n", config->rsrc);
3205 static NTSTATUS readdir_attr_macmeta(struct vfs_handle_struct *handle,
3206 const struct smb_filename *smb_fname,
3207 struct readdir_attr_data *attr_data)
3209 NTSTATUS status = NT_STATUS_OK;
3210 struct fruit_config_data *config = NULL;
3213 SMB_VFS_HANDLE_GET_DATA(handle, config,
3214 struct fruit_config_data,
3215 return NT_STATUS_UNSUCCESSFUL);
3218 /* Ensure we return a default value in the creation_date field */
3219 RSIVAL(&attr_data->attr_data.aapl.finder_info, 12, AD_DATE_START);
3222 * Resource fork length
3225 if (config->readdir_attr_rsize) {
3226 uint64_t rfork_size;
3228 rfork_size = readdir_attr_rfork_size(handle, smb_fname);
3229 attr_data->attr_data.aapl.rfork_size = rfork_size;
3236 if (config->readdir_attr_finder_info) {
3237 ok = readdir_attr_meta_finderi(handle, smb_fname, attr_data);
3239 status = NT_STATUS_INTERNAL_ERROR;
3246 static NTSTATUS remove_virtual_nfs_aces(struct security_descriptor *psd)
3251 if (psd->dacl == NULL) {
3252 return NT_STATUS_OK;
3255 for (i = 0; i < psd->dacl->num_aces; i++) {
3256 /* MS NFS style mode/uid/gid */
3257 int cmp = dom_sid_compare_domain(
3258 &global_sid_Unix_NFS,
3259 &psd->dacl->aces[i].trustee);
3261 /* Normal ACE entry. */
3266 * security_descriptor_dacl_del()
3267 * *must* return NT_STATUS_OK as we know
3268 * we have something to remove.
3271 status = security_descriptor_dacl_del(psd,
3272 &psd->dacl->aces[i].trustee);
3273 if (!NT_STATUS_IS_OK(status)) {
3274 DBG_WARNING("failed to remove MS NFS style ACE: %s\n",
3280 * security_descriptor_dacl_del() may delete more
3281 * then one entry subsequent to this one if the
3282 * SID matches, but we only need to ensure that
3283 * we stay looking at the same element in the array.
3287 return NT_STATUS_OK;
3290 /* Search MS NFS style ACE with UNIX mode */
3291 static NTSTATUS check_ms_nfs(vfs_handle_struct *handle,
3293 struct security_descriptor *psd,
3298 struct fruit_config_data *config = NULL;
3302 SMB_VFS_HANDLE_GET_DATA(handle, config,
3303 struct fruit_config_data,
3304 return NT_STATUS_UNSUCCESSFUL);
3306 if (!global_fruit_config.nego_aapl) {
3307 return NT_STATUS_OK;
3309 if (psd->dacl == NULL || !config->unix_info_enabled) {
3310 return NT_STATUS_OK;
3313 for (i = 0; i < psd->dacl->num_aces; i++) {
3314 if (dom_sid_compare_domain(
3315 &global_sid_Unix_NFS_Mode,
3316 &psd->dacl->aces[i].trustee) == 0) {
3317 *pmode = (mode_t)psd->dacl->aces[i].trustee.sub_auths[2];
3318 *pmode &= (S_IRWXU | S_IRWXG | S_IRWXO);
3321 DEBUG(10, ("MS NFS chmod request %s, %04o\n",
3322 fsp_str_dbg(fsp), (unsigned)(*pmode)));
3328 * Remove any incoming virtual ACE entries generated by
3329 * fruit_fget_nt_acl().
3332 return remove_virtual_nfs_aces(psd);
3335 /****************************************************************************
3337 ****************************************************************************/
3339 static int fruit_connect(vfs_handle_struct *handle,
3340 const char *service,
3344 char *list = NULL, *newlist = NULL;
3345 struct fruit_config_data *config;
3347 DEBUG(10, ("fruit_connect\n"));
3349 rc = SMB_VFS_NEXT_CONNECT(handle, service, user);
3354 rc = init_fruit_config(handle);
3359 SMB_VFS_HANDLE_GET_DATA(handle, config,
3360 struct fruit_config_data, return -1);
3362 if (config->veto_appledouble) {
3363 list = lp_veto_files(talloc_tos(), SNUM(handle->conn));
3366 if (strstr(list, "/" ADOUBLE_NAME_PREFIX "*/") == NULL) {
3367 newlist = talloc_asprintf(
3369 "%s/" ADOUBLE_NAME_PREFIX "*/",
3371 lp_do_parameter(SNUM(handle->conn),
3376 lp_do_parameter(SNUM(handle->conn),
3378 "/" ADOUBLE_NAME_PREFIX "*/");
3384 if (config->encoding == FRUIT_ENC_NATIVE) {
3385 lp_do_parameter(SNUM(handle->conn),
3390 if (config->time_machine) {
3391 DBG_NOTICE("Enabling durable handles for Time Machine "
3392 "support on [%s]\n", service);
3393 lp_do_parameter(SNUM(handle->conn), "durable handles", "yes");
3394 lp_do_parameter(SNUM(handle->conn), "kernel oplocks", "no");
3395 lp_do_parameter(SNUM(handle->conn), "kernel share modes", "no");
3396 if (!lp_strict_sync(SNUM(handle->conn))) {
3397 DBG_WARNING("Time Machine without strict sync is not "
3400 lp_do_parameter(SNUM(handle->conn), "posix locking", "no");
3406 static int fruit_fake_fd(void)
3413 * Return a valid fd, but ensure any attempt to use it returns
3414 * an error (EPIPE). Once we get a write on the handle, we open
3417 ret = pipe(pipe_fds);
3427 static int fruit_open_meta_stream(vfs_handle_struct *handle,
3428 struct smb_filename *smb_fname,
3433 struct fruit_config_data *config = NULL;
3434 struct fio *fio = NULL;
3435 int open_flags = flags & ~O_CREAT;
3438 DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
3440 SMB_VFS_HANDLE_GET_DATA(handle, config,
3441 struct fruit_config_data, return -1);
3443 fio = VFS_ADD_FSP_EXTENSION(handle, fsp, struct fio, NULL);
3444 fio->type = ADOUBLE_META;
3445 fio->config = config;
3447 fd = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, open_flags, mode);
3452 if (!(flags & O_CREAT)) {
3453 VFS_REMOVE_FSP_EXTENSION(handle, fsp);
3457 fd = fruit_fake_fd();
3459 VFS_REMOVE_FSP_EXTENSION(handle, fsp);
3463 fio->fake_fd = true;
3470 static int fruit_open_meta_netatalk(vfs_handle_struct *handle,
3471 struct smb_filename *smb_fname,
3476 struct fruit_config_data *config = NULL;
3477 struct fio *fio = NULL;
3478 struct adouble *ad = NULL;
3479 bool meta_exists = false;
3482 DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
3484 ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_META);
3491 if (!meta_exists && !(flags & O_CREAT)) {
3496 fd = fruit_fake_fd();
3501 SMB_VFS_HANDLE_GET_DATA(handle, config,
3502 struct fruit_config_data, return -1);
3504 fio = VFS_ADD_FSP_EXTENSION(handle, fsp, struct fio, NULL);
3505 fio->type = ADOUBLE_META;
3506 fio->config = config;
3507 fio->fake_fd = true;
3514 static int fruit_open_meta(vfs_handle_struct *handle,
3515 struct smb_filename *smb_fname,
3516 files_struct *fsp, int flags, mode_t mode)
3519 struct fruit_config_data *config = NULL;
3521 DBG_DEBUG("path [%s]\n", smb_fname_str_dbg(smb_fname));
3523 SMB_VFS_HANDLE_GET_DATA(handle, config,
3524 struct fruit_config_data, return -1);
3526 switch (config->meta) {
3527 case FRUIT_META_STREAM:
3528 fd = fruit_open_meta_stream(handle, smb_fname,
3532 case FRUIT_META_NETATALK:
3533 fd = fruit_open_meta_netatalk(handle, smb_fname,
3538 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
3542 DBG_DEBUG("path [%s] fd [%d]\n", smb_fname_str_dbg(smb_fname), fd);
3547 static int fruit_open_rsrc_adouble(vfs_handle_struct *handle,
3548 struct smb_filename *smb_fname,
3554 struct adouble *ad = NULL;
3555 struct smb_filename *smb_fname_base = NULL;
3556 struct fruit_config_data *config = NULL;
3559 SMB_VFS_HANDLE_GET_DATA(handle, config,
3560 struct fruit_config_data, return -1);
3562 if ((!(flags & O_CREAT)) &&
3563 S_ISDIR(fsp->base_fsp->fsp_name->st.st_ex_mode))
3565 /* sorry, but directories don't habe a resource fork */
3570 rc = adouble_path(talloc_tos(), smb_fname, &smb_fname_base);
3575 /* We always need read/write access for the metadata header too */
3576 flags &= ~(O_RDONLY | O_WRONLY);
3579 hostfd = SMB_VFS_NEXT_OPEN(handle, smb_fname_base, fsp,
3586 if (flags & (O_CREAT | O_TRUNC)) {
3587 ad = ad_init(fsp, handle, ADOUBLE_RSRC);
3593 fsp->fh->fd = hostfd;
3595 rc = ad_fset(ad, fsp);
3606 TALLOC_FREE(smb_fname_base);
3608 DEBUG(10, ("fruit_open resource fork: rc=%d, fd=%d\n", rc, hostfd));
3610 int saved_errno = errno;
3613 * BUGBUGBUG -- we would need to call
3614 * fd_close_posix here, but we don't have a
3617 fsp->fh->fd = hostfd;
3621 errno = saved_errno;
3626 static int fruit_open_rsrc_xattr(vfs_handle_struct *handle,
3627 struct smb_filename *smb_fname,
3632 #ifdef HAVE_ATTROPEN
3635 fd = attropen(smb_fname->base_name,
3636 AFPRESOURCE_EA_NETATALK,
3651 static int fruit_open_rsrc(vfs_handle_struct *handle,
3652 struct smb_filename *smb_fname,
3653 files_struct *fsp, int flags, mode_t mode)
3656 struct fruit_config_data *config = NULL;
3657 struct fio *fio = NULL;
3659 DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
3661 SMB_VFS_HANDLE_GET_DATA(handle, config,
3662 struct fruit_config_data, return -1);
3664 switch (config->rsrc) {
3665 case FRUIT_RSRC_STREAM:
3666 fd = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
3669 case FRUIT_RSRC_ADFILE:
3670 fd = fruit_open_rsrc_adouble(handle, smb_fname,
3674 case FRUIT_RSRC_XATTR:
3675 fd = fruit_open_rsrc_xattr(handle, smb_fname,
3680 DBG_ERR("Unexpected rsrc config [%d]\n", config->rsrc);
3684 DBG_DEBUG("Path [%s] fd [%d]\n", smb_fname_str_dbg(smb_fname), fd);
3690 fio = VFS_ADD_FSP_EXTENSION(handle, fsp, struct fio, NULL);
3691 fio->type = ADOUBLE_RSRC;
3692 fio->config = config;
3697 static int fruit_open(vfs_handle_struct *handle,
3698 struct smb_filename *smb_fname,
3699 files_struct *fsp, int flags, mode_t mode)
3703 DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
3705 if (!is_ntfs_stream_smb_fname(smb_fname)) {
3706 return SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
3709 if (is_afpinfo_stream(smb_fname)) {
3710 fd = fruit_open_meta(handle, smb_fname, fsp, flags, mode);
3711 } else if (is_afpresource_stream(smb_fname)) {
3712 fd = fruit_open_rsrc(handle, smb_fname, fsp, flags, mode);
3714 fd = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
3717 DBG_DEBUG("Path [%s] fd [%d]\n", smb_fname_str_dbg(smb_fname), fd);
3722 static int fruit_rename(struct vfs_handle_struct *handle,
3723 const struct smb_filename *smb_fname_src,
3724 const struct smb_filename *smb_fname_dst)
3727 struct fruit_config_data *config = NULL;
3728 struct smb_filename *src_adp_smb_fname = NULL;
3729 struct smb_filename *dst_adp_smb_fname = NULL;
3731 SMB_VFS_HANDLE_GET_DATA(handle, config,
3732 struct fruit_config_data, return -1);
3734 if (!VALID_STAT(smb_fname_src->st)) {
3735 DBG_ERR("Need valid stat for [%s]\n",
3736 smb_fname_str_dbg(smb_fname_src));
3740 rc = SMB_VFS_NEXT_RENAME(handle, smb_fname_src, smb_fname_dst);
3745 if ((config->rsrc != FRUIT_RSRC_ADFILE) ||
3746 (!S_ISREG(smb_fname_src->st.st_ex_mode)))
3751 rc = adouble_path(talloc_tos(), smb_fname_src, &src_adp_smb_fname);
3756 rc = adouble_path(talloc_tos(), smb_fname_dst, &dst_adp_smb_fname);
3761 DBG_DEBUG("%s -> %s\n",
3762 smb_fname_str_dbg(src_adp_smb_fname),
3763 smb_fname_str_dbg(dst_adp_smb_fname));
3765 rc = SMB_VFS_NEXT_RENAME(handle, src_adp_smb_fname, dst_adp_smb_fname);
3766 if (errno == ENOENT) {
3771 TALLOC_FREE(src_adp_smb_fname);
3772 TALLOC_FREE(dst_adp_smb_fname);
3776 static int fruit_unlink_meta_stream(vfs_handle_struct *handle,
3777 const struct smb_filename *smb_fname)
3779 return SMB_VFS_NEXT_UNLINK(handle, smb_fname);
3782 static int fruit_unlink_meta_netatalk(vfs_handle_struct *handle,
3783 const struct smb_filename *smb_fname)
3785 return SMB_VFS_REMOVEXATTR(handle->conn,
3787 AFPINFO_EA_NETATALK);
3790 static int fruit_unlink_meta(vfs_handle_struct *handle,
3791 const struct smb_filename *smb_fname)
3793 struct fruit_config_data *config = NULL;
3796 SMB_VFS_HANDLE_GET_DATA(handle, config,
3797 struct fruit_config_data, return -1);
3799 switch (config->meta) {
3800 case FRUIT_META_STREAM:
3801 rc = fruit_unlink_meta_stream(handle, smb_fname);
3804 case FRUIT_META_NETATALK:
3805 rc = fruit_unlink_meta_netatalk(handle, smb_fname);
3809 DBG_ERR("Unsupported meta config [%d]\n", config->meta);
3816 static int fruit_unlink_rsrc_stream(vfs_handle_struct *handle,
3817 const struct smb_filename *smb_fname,
3822 if (!force_unlink) {
3823 struct smb_filename *smb_fname_cp = NULL;
3826 smb_fname_cp = cp_smb_filename(talloc_tos(), smb_fname);
3827 if (smb_fname_cp == NULL) {
3832 * 0 byte resource fork streams are not listed by
3833 * vfs_streaminfo, as a result stream cleanup/deletion of file
3834 * deletion doesn't remove the resourcefork stream.
3837 ret = SMB_VFS_NEXT_STAT(handle, smb_fname_cp);
3839 TALLOC_FREE(smb_fname_cp);
3840 DBG_ERR("stat [%s] failed [%s]\n",
3841 smb_fname_str_dbg(smb_fname_cp), strerror(errno));
3845 size = smb_fname_cp->st.st_ex_size;
3846 TALLOC_FREE(smb_fname_cp);
3849 /* OS X ignores resource fork stream delete requests */
3854 ret = SMB_VFS_NEXT_UNLINK(handle, smb_fname);
3855 if ((ret != 0) && (errno == ENOENT) && force_unlink) {
3862 static int fruit_unlink_rsrc_adouble(vfs_handle_struct *handle,
3863 const struct smb_filename *smb_fname,
3867 struct adouble *ad = NULL;
3868 struct smb_filename *adp_smb_fname = NULL;
3870 if (!force_unlink) {
3871 ad = ad_get(talloc_tos(), handle, smb_fname,
3880 * 0 byte resource fork streams are not listed by
3881 * vfs_streaminfo, as a result stream cleanup/deletion of file
3882 * deletion doesn't remove the resourcefork stream.
3885 if (ad_getentrylen(ad, ADEID_RFORK) > 0) {
3886 /* OS X ignores resource fork stream delete requests */
3894 rc = adouble_path(talloc_tos(), smb_fname, &adp_smb_fname);
3899 rc = SMB_VFS_NEXT_UNLINK(handle, adp_smb_fname);
3900 TALLOC_FREE(adp_smb_fname);
3901 if ((rc != 0) && (errno == ENOENT) && force_unlink) {
3908 static int fruit_unlink_rsrc_xattr(vfs_handle_struct *handle,
3909 const struct smb_filename *smb_fname,
3913 * OS X ignores resource fork stream delete requests, so nothing to do
3914 * here. Removing the file will remove the xattr anyway, so we don't
3915 * have to take care of removing 0 byte resource forks that could be
3921 static int fruit_unlink_rsrc(vfs_handle_struct *handle,
3922 const struct smb_filename *smb_fname,
3925 struct fruit_config_data *config = NULL;
3928 SMB_VFS_HANDLE_GET_DATA(handle, config,
3929 struct fruit_config_data, return -1);
3931 switch (config->rsrc) {
3932 case FRUIT_RSRC_STREAM:
3933 rc = fruit_unlink_rsrc_stream(handle, smb_fname, force_unlink);
3936 case FRUIT_RSRC_ADFILE:
3937 rc = fruit_unlink_rsrc_adouble(handle, smb_fname, force_unlink);
3940 case FRUIT_RSRC_XATTR:
3941 rc = fruit_unlink_rsrc_xattr(handle, smb_fname, force_unlink);
3945 DBG_ERR("Unsupported rsrc config [%d]\n", config->rsrc);
3952 static int fruit_unlink(vfs_handle_struct *handle,
3953 const struct smb_filename *smb_fname)
3956 struct fruit_config_data *config = NULL;
3957 struct smb_filename *rsrc_smb_fname = NULL;
3959 SMB_VFS_HANDLE_GET_DATA(handle, config,
3960 struct fruit_config_data, return -1);
3962 if (is_afpinfo_stream(smb_fname)) {
3963 return fruit_unlink_meta(handle, smb_fname);
3964 } else if (is_afpresource_stream(smb_fname)) {
3965 return fruit_unlink_rsrc(handle, smb_fname, false);
3966 } if (is_ntfs_stream_smb_fname(smb_fname)) {
3967 return SMB_VFS_NEXT_UNLINK(handle, smb_fname);
3971 * A request to delete the base file. Because 0 byte resource
3972 * fork streams are not listed by fruit_streaminfo,
3973 * delete_all_streams() can't remove 0 byte resource fork
3974 * streams, so we have to cleanup this here.
3976 rsrc_smb_fname = synthetic_smb_fname(talloc_tos(),
3977 smb_fname->base_name,
3978 AFPRESOURCE_STREAM_NAME,
3981 if (rsrc_smb_fname == NULL) {
3985 rc = fruit_unlink_rsrc(handle, rsrc_smb_fname, true);
3986 if ((rc != 0) && (errno != ENOENT)) {
3987 DBG_ERR("Forced unlink of [%s] failed [%s]\n",
3988 smb_fname_str_dbg(rsrc_smb_fname), strerror(errno));
3989 TALLOC_FREE(rsrc_smb_fname);
3992 TALLOC_FREE(rsrc_smb_fname);
3994 return SMB_VFS_NEXT_UNLINK(handle, smb_fname);
3997 static int fruit_chmod(vfs_handle_struct *handle,
3998 const struct smb_filename *smb_fname,
4002 struct fruit_config_data *config = NULL;
4003 struct smb_filename *smb_fname_adp = NULL;
4005 rc = SMB_VFS_NEXT_CHMOD(handle, smb_fname, mode);
4010 SMB_VFS_HANDLE_GET_DATA(handle, config,
4011 struct fruit_config_data, return -1);
4013 if (config->rsrc != FRUIT_RSRC_ADFILE) {
4017 if (!VALID_STAT(smb_fname->st)) {
4021 if (!S_ISREG(smb_fname->st.st_ex_mode)) {
4025 rc = adouble_path(talloc_tos(), smb_fname, &smb_fname_adp);
4030 DEBUG(10, ("fruit_chmod: %s\n", smb_fname_adp->base_name));
4032 rc = SMB_VFS_NEXT_CHMOD(handle, smb_fname_adp, mode);
4033 if (errno == ENOENT) {
4037 TALLOC_FREE(smb_fname_adp);
4041 static int fruit_chown(vfs_handle_struct *handle,
4042 const struct smb_filename *smb_fname,
4047 struct fruit_config_data *config = NULL;
4048 struct smb_filename *adp_smb_fname = NULL;
4050 rc = SMB_VFS_NEXT_CHOWN(handle, smb_fname, uid, gid);
4055 SMB_VFS_HANDLE_GET_DATA(handle, config,
4056 struct fruit_config_data, return -1);
4058 if (config->rsrc != FRUIT_RSRC_ADFILE) {
4062 if (!VALID_STAT(smb_fname->st)) {
4066 if (!S_ISREG(smb_fname->st.st_ex_mode)) {
4070 rc = adouble_path(talloc_tos(), smb_fname, &adp_smb_fname);
4075 DEBUG(10, ("fruit_chown: %s\n", adp_smb_fname->base_name));
4077 rc = SMB_VFS_NEXT_CHOWN(handle, adp_smb_fname, uid, gid);
4078 if (errno == ENOENT) {
4083 TALLOC_FREE(adp_smb_fname);
4087 static int fruit_rmdir(struct vfs_handle_struct *handle,
4088 const struct smb_filename *smb_fname)
4092 struct fruit_config_data *config;
4094 SMB_VFS_HANDLE_GET_DATA(handle, config,
4095 struct fruit_config_data, return -1);
4097 if (config->rsrc != FRUIT_RSRC_ADFILE) {
4102 * Due to there is no way to change bDeleteVetoFiles variable
4103 * from this module, need to clean up ourselves
4106 dh = SMB_VFS_OPENDIR(handle->conn, smb_fname, NULL, 0);
4111 while ((de = SMB_VFS_READDIR(handle->conn, dh, NULL)) != NULL) {
4113 struct adouble *ad = NULL;
4115 struct smb_filename *ad_smb_fname = NULL;
4118 match = strncmp(de->d_name,
4119 ADOUBLE_NAME_PREFIX,
4120 strlen(ADOUBLE_NAME_PREFIX));
4125 p = talloc_asprintf(talloc_tos(), "%s/%s",
4126 smb_fname->base_name, de->d_name);
4128 DBG_ERR("talloc_asprintf failed\n");
4132 ad_smb_fname = synthetic_smb_fname(talloc_tos(), p,
4136 if (ad_smb_fname == NULL) {
4137 DBG_ERR("synthetic_smb_fname failed\n");
4142 * Check whether it's a valid AppleDouble file, if
4143 * yes, delete it, ignore it otherwise.
4145 ad = ad_get(talloc_tos(), handle, ad_smb_fname, ADOUBLE_RSRC);
4147 TALLOC_FREE(ad_smb_fname);
4153 ret = SMB_VFS_NEXT_UNLINK(handle, ad_smb_fname);
4155 DBG_ERR("Deleting [%s] failed\n",
4156 smb_fname_str_dbg(ad_smb_fname));
4158 TALLOC_FREE(ad_smb_fname);
4163 SMB_VFS_CLOSEDIR(handle->conn, dh);
4165 return SMB_VFS_NEXT_RMDIR(handle, smb_fname);
4168 static ssize_t fruit_pread_meta_stream(vfs_handle_struct *handle,
4169 files_struct *fsp, void *data,
4170 size_t n, off_t offset)
4175 nread = SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
4176 if (nread == -1 || nread == n) {
4180 DBG_ERR("Removing [%s] after short read [%zd]\n",
4181 fsp_str_dbg(fsp), nread);
4183 ret = SMB_VFS_NEXT_UNLINK(handle, fsp->fsp_name);
4185 DBG_ERR("Removing [%s] failed\n", fsp_str_dbg(fsp));
4193 static ssize_t fruit_pread_meta_adouble(vfs_handle_struct *handle,
4194 files_struct *fsp, void *data,
4195 size_t n, off_t offset)
4198 struct adouble *ad = NULL;
4199 char afpinfo_buf[AFP_INFO_SIZE];
4203 ai = afpinfo_new(talloc_tos());
4208 ad = ad_fget(talloc_tos(), handle, fsp, ADOUBLE_META);
4214 p = ad_get_entry(ad, ADEID_FINDERI);
4216 DBG_ERR("No ADEID_FINDERI for [%s]\n", fsp_str_dbg(fsp));
4221 memcpy(&ai->afpi_FinderInfo[0], p, ADEDLEN_FINDERI);
4223 nread = afpinfo_pack(ai, afpinfo_buf);
4224 if (nread != AFP_INFO_SIZE) {
4229 memcpy(data, afpinfo_buf, n);
4237 static ssize_t fruit_pread_meta(vfs_handle_struct *handle,
4238 files_struct *fsp, void *data,
4239 size_t n, off_t offset)
4241 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4246 * OS X has a off-by-1 error in the offset calculation, so we're
4247 * bug compatible here. It won't hurt, as any relevant real
4248 * world read requests from the AFP_AfpInfo stream will be
4249 * offset=0 n=60. offset is ignored anyway, see below.
4251 if ((offset < 0) || (offset >= AFP_INFO_SIZE + 1)) {
4256 DBG_ERR("Failed to fetch fsp extension");
4260 /* Yes, macOS always reads from offset 0 */
4262 to_return = MIN(n, AFP_INFO_SIZE);
4264 switch (fio->config->meta) {
4265 case FRUIT_META_STREAM:
4266 nread = fruit_pread_meta_stream(handle, fsp, data,
4270 case FRUIT_META_NETATALK:
4271 nread = fruit_pread_meta_adouble(handle, fsp, data,
4276 DBG_ERR("Unexpected meta config [%d]\n", fio->config->meta);
4280 if (nread == -1 && fio->created) {
4282 char afpinfo_buf[AFP_INFO_SIZE];
4284 ai = afpinfo_new(talloc_tos());
4289 nread = afpinfo_pack(ai, afpinfo_buf);
4291 if (nread != AFP_INFO_SIZE) {
4295 memcpy(data, afpinfo_buf, to_return);
4302 static ssize_t fruit_pread_rsrc_stream(vfs_handle_struct *handle,
4303 files_struct *fsp, void *data,
4304 size_t n, off_t offset)
4306 return SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
4309 static ssize_t fruit_pread_rsrc_xattr(vfs_handle_struct *handle,
4310 files_struct *fsp, void *data,
4311 size_t n, off_t offset)
4313 return SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
4316 static ssize_t fruit_pread_rsrc_adouble(vfs_handle_struct *handle,
4317 files_struct *fsp, void *data,
4318 size_t n, off_t offset)
4320 struct adouble *ad = NULL;
4323 ad = ad_fget(talloc_tos(), handle, fsp, ADOUBLE_RSRC);
4328 nread = SMB_VFS_NEXT_PREAD(handle, fsp, data, n,
4329 offset + ad_getentryoff(ad, ADEID_RFORK));
4335 static ssize_t fruit_pread_rsrc(vfs_handle_struct *handle,
4336 files_struct *fsp, void *data,
4337 size_t n, off_t offset)
4339 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4347 switch (fio->config->rsrc) {
4348 case FRUIT_RSRC_STREAM:
4349 nread = fruit_pread_rsrc_stream(handle, fsp, data, n, offset);
4352 case FRUIT_RSRC_ADFILE:
4353 nread = fruit_pread_rsrc_adouble(handle, fsp, data, n, offset);
4356 case FRUIT_RSRC_XATTR:
4357 nread = fruit_pread_rsrc_xattr(handle, fsp, data, n, offset);
4361 DBG_ERR("Unexpected rsrc config [%d]\n", fio->config->rsrc);
4368 static ssize_t fruit_pread(vfs_handle_struct *handle,
4369 files_struct *fsp, void *data,
4370 size_t n, off_t offset)
4372 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4375 DBG_DEBUG("Path [%s] offset=%"PRIdMAX", size=%zd\n",
4376 fsp_str_dbg(fsp), (intmax_t)offset, n);
4379 return SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
4382 if (fio->type == ADOUBLE_META) {
4383 nread = fruit_pread_meta(handle, fsp, data, n, offset);
4385 nread = fruit_pread_rsrc(handle, fsp, data, n, offset);
4388 DBG_DEBUG("Path [%s] nread [%zd]\n", fsp_str_dbg(fsp), nread);
4392 static bool fruit_must_handle_aio_stream(struct fio *fio)
4398 if (fio->type == ADOUBLE_META) {
4402 if ((fio->type == ADOUBLE_RSRC) &&
4403 (fio->config->rsrc == FRUIT_RSRC_ADFILE))
4411 struct fruit_pread_state {
4413 struct vfs_aio_state vfs_aio_state;
4416 static void fruit_pread_done(struct tevent_req *subreq);
4418 static struct tevent_req *fruit_pread_send(
4419 struct vfs_handle_struct *handle,
4420 TALLOC_CTX *mem_ctx,
4421 struct tevent_context *ev,
4422 struct files_struct *fsp,
4424 size_t n, off_t offset)
4426 struct tevent_req *req = NULL;
4427 struct tevent_req *subreq = NULL;
4428 struct fruit_pread_state *state = NULL;
4429 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4431 req = tevent_req_create(mem_ctx, &state,
4432 struct fruit_pread_state);
4437 if (fruit_must_handle_aio_stream(fio)) {
4438 state->nread = SMB_VFS_PREAD(fsp, data, n, offset);
4439 if (state->nread != n) {
4440 if (state->nread != -1) {
4443 tevent_req_error(req, errno);
4444 return tevent_req_post(req, ev);
4446 tevent_req_done(req);
4447 return tevent_req_post(req, ev);
4450 subreq = SMB_VFS_NEXT_PREAD_SEND(state, ev, handle, fsp,
4452 if (tevent_req_nomem(req, subreq)) {
4453 return tevent_req_post(req, ev);
4455 tevent_req_set_callback(subreq, fruit_pread_done, req);
4459 static void fruit_pread_done(struct tevent_req *subreq)
4461 struct tevent_req *req = tevent_req_callback_data(
4462 subreq, struct tevent_req);
4463 struct fruit_pread_state *state = tevent_req_data(
4464 req, struct fruit_pread_state);
4466 state->nread = SMB_VFS_PREAD_RECV(subreq, &state->vfs_aio_state);
4467 TALLOC_FREE(subreq);
4469 if (tevent_req_error(req, state->vfs_aio_state.error)) {
4472 tevent_req_done(req);
4475 static ssize_t fruit_pread_recv(struct tevent_req *req,
4476 struct vfs_aio_state *vfs_aio_state)
4478 struct fruit_pread_state *state = tevent_req_data(
4479 req, struct fruit_pread_state);
4481 if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
4485 *vfs_aio_state = state->vfs_aio_state;
4486 return state->nread;
4489 static ssize_t fruit_pwrite_meta_stream(vfs_handle_struct *handle,
4490 files_struct *fsp, const void *data,
4491 size_t n, off_t offset)
4493 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4499 DBG_DEBUG("Path [%s] offset=%"PRIdMAX", size=%zd\n",
4500 fsp_str_dbg(fsp), (intmax_t)offset, n);
4509 ret = SMB_VFS_NEXT_CLOSE(handle, fsp);
4511 DBG_ERR("Close [%s] failed: %s\n",
4512 fsp_str_dbg(fsp), strerror(errno));
4517 fd = SMB_VFS_NEXT_OPEN(handle,
4523 DBG_ERR("On-demand create [%s] in write failed: %s\n",
4524 fsp_str_dbg(fsp), strerror(errno));
4528 fio->fake_fd = false;
4531 ai = afpinfo_unpack(talloc_tos(), data);
4536 if (ai_empty_finderinfo(ai)) {
4538 * Writing an all 0 blob to the metadata stream results in the
4539 * stream being removed on a macOS server. This ensures we
4540 * behave the same and it verified by the "delete AFP_AfpInfo by
4541 * writing all 0" test.
4543 ret = SMB_VFS_NEXT_FTRUNCATE(handle, fsp, 0);
4545 DBG_ERR("SMB_VFS_NEXT_FTRUNCATE on [%s] failed\n",
4550 ok = set_delete_on_close(
4553 handle->conn->session_info->security_token,
4554 handle->conn->session_info->unix_token);
4556 DBG_ERR("set_delete_on_close on [%s] failed\n",
4563 nwritten = SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
4564 if (nwritten != n) {
4571 static ssize_t fruit_pwrite_meta_netatalk(vfs_handle_struct *handle,
4572 files_struct *fsp, const void *data,
4573 size_t n, off_t offset)
4575 struct adouble *ad = NULL;
4581 ai = afpinfo_unpack(talloc_tos(), data);
4586 ad = ad_fget(talloc_tos(), handle, fsp, ADOUBLE_META);
4588 ad = ad_init(talloc_tos(), handle, ADOUBLE_META);
4593 p = ad_get_entry(ad, ADEID_FINDERI);
4595 DBG_ERR("No ADEID_FINDERI for [%s]\n", fsp_str_dbg(fsp));
4600 memcpy(p, &ai->afpi_FinderInfo[0], ADEDLEN_FINDERI);
4602 ret = ad_fset(ad, fsp);
4604 DBG_ERR("ad_pwrite [%s] failed\n", fsp_str_dbg(fsp));
4611 if (!ai_empty_finderinfo(ai)) {
4616 * Writing an all 0 blob to the metadata stream results in the stream
4617 * being removed on a macOS server. This ensures we behave the same and
4618 * it verified by the "delete AFP_AfpInfo by writing all 0" test.
4621 ok = set_delete_on_close(
4624 handle->conn->session_info->security_token,
4625 handle->conn->session_info->unix_token);
4627 DBG_ERR("set_delete_on_close on [%s] failed\n",
4635 static ssize_t fruit_pwrite_meta(vfs_handle_struct *handle,
4636 files_struct *fsp, const void *data,
4637 size_t n, off_t offset)
4639 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4642 if (n != AFP_INFO_SIZE || offset != 0) {
4643 DBG_ERR("unexpected offset=%jd or size=%jd\n",
4644 (intmax_t)offset, (intmax_t)n);
4649 DBG_ERR("Failed to fetch fsp extension");
4653 switch (fio->config->meta) {
4654 case FRUIT_META_STREAM:
4655 nwritten = fruit_pwrite_meta_stream(handle, fsp, data,
4659 case FRUIT_META_NETATALK:
4660 nwritten = fruit_pwrite_meta_netatalk(handle, fsp, data,
4665 DBG_ERR("Unexpected meta config [%d]\n", fio->config->meta);
4672 static ssize_t fruit_pwrite_rsrc_stream(vfs_handle_struct *handle,
4673 files_struct *fsp, const void *data,
4674 size_t n, off_t offset)
4676 return SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
4679 static ssize_t fruit_pwrite_rsrc_xattr(vfs_handle_struct *handle,
4680 files_struct *fsp, const void *data,
4681 size_t n, off_t offset)
4683 return SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
4686 static ssize_t fruit_pwrite_rsrc_adouble(vfs_handle_struct *handle,
4687 files_struct *fsp, const void *data,
4688 size_t n, off_t offset)
4690 struct adouble *ad = NULL;
4694 ad = ad_fget(talloc_tos(), handle, fsp, ADOUBLE_RSRC);
4696 DBG_ERR("ad_get [%s] failed\n", fsp_str_dbg(fsp));
4700 nwritten = SMB_VFS_NEXT_PWRITE(handle, fsp, data, n,
4701 offset + ad_getentryoff(ad, ADEID_RFORK));
4702 if (nwritten != n) {
4703 DBG_ERR("Short write on [%s] [%zd/%zd]\n",
4704 fsp_str_dbg(fsp), nwritten, n);
4709 if ((n + offset) > ad_getentrylen(ad, ADEID_RFORK)) {
4710 ad_setentrylen(ad, ADEID_RFORK, n + offset);
4711 ret = ad_fset(ad, fsp);
4713 DBG_ERR("ad_pwrite [%s] failed\n", fsp_str_dbg(fsp));
4723 static ssize_t fruit_pwrite_rsrc(vfs_handle_struct *handle,
4724 files_struct *fsp, const void *data,
4725 size_t n, off_t offset)
4727 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4731 DBG_ERR("Failed to fetch fsp extension");
4735 switch (fio->config->rsrc) {
4736 case FRUIT_RSRC_STREAM:
4737 nwritten = fruit_pwrite_rsrc_stream(handle, fsp, data, n, offset);
4740 case FRUIT_RSRC_ADFILE:
4741 nwritten = fruit_pwrite_rsrc_adouble(handle, fsp, data, n, offset);
4744 case FRUIT_RSRC_XATTR:
4745 nwritten = fruit_pwrite_rsrc_xattr(handle, fsp, data, n, offset);
4749 DBG_ERR("Unexpected rsrc config [%d]\n", fio->config->rsrc);
4756 static ssize_t fruit_pwrite(vfs_handle_struct *handle,
4757 files_struct *fsp, const void *data,
4758 size_t n, off_t offset)
4760 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4763 DBG_DEBUG("Path [%s] offset=%"PRIdMAX", size=%zd\n",
4764 fsp_str_dbg(fsp), (intmax_t)offset, n);
4767 return SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
4770 if (fio->type == ADOUBLE_META) {
4771 nwritten = fruit_pwrite_meta(handle, fsp, data, n, offset);
4773 nwritten = fruit_pwrite_rsrc(handle, fsp, data, n, offset);
4776 DBG_DEBUG("Path [%s] nwritten=%zd\n", fsp_str_dbg(fsp), nwritten);
4780 struct fruit_pwrite_state {
4782 struct vfs_aio_state vfs_aio_state;
4785 static void fruit_pwrite_done(struct tevent_req *subreq);
4787 static struct tevent_req *fruit_pwrite_send(
4788 struct vfs_handle_struct *handle,
4789 TALLOC_CTX *mem_ctx,
4790 struct tevent_context *ev,
4791 struct files_struct *fsp,
4793 size_t n, off_t offset)
4795 struct tevent_req *req = NULL;
4796 struct tevent_req *subreq = NULL;
4797 struct fruit_pwrite_state *state = NULL;
4798 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4800 req = tevent_req_create(mem_ctx, &state,
4801 struct fruit_pwrite_state);
4806 if (fruit_must_handle_aio_stream(fio)) {
4807 state->nwritten = SMB_VFS_PWRITE(fsp, data, n, offset);
4808 if (state->nwritten != n) {
4809 if (state->nwritten != -1) {
4812 tevent_req_error(req, errno);
4813 return tevent_req_post(req, ev);
4815 tevent_req_done(req);
4816 return tevent_req_post(req, ev);
4819 subreq = SMB_VFS_NEXT_PWRITE_SEND(state, ev, handle, fsp,
4821 if (tevent_req_nomem(req, subreq)) {
4822 return tevent_req_post(req, ev);
4824 tevent_req_set_callback(subreq, fruit_pwrite_done, req);
4828 static void fruit_pwrite_done(struct tevent_req *subreq)
4830 struct tevent_req *req = tevent_req_callback_data(
4831 subreq, struct tevent_req);
4832 struct fruit_pwrite_state *state = tevent_req_data(
4833 req, struct fruit_pwrite_state);
4835 state->nwritten = SMB_VFS_PWRITE_RECV(subreq, &state->vfs_aio_state);
4836 TALLOC_FREE(subreq);
4838 if (tevent_req_error(req, state->vfs_aio_state.error)) {
4841 tevent_req_done(req);
4844 static ssize_t fruit_pwrite_recv(struct tevent_req *req,
4845 struct vfs_aio_state *vfs_aio_state)
4847 struct fruit_pwrite_state *state = tevent_req_data(
4848 req, struct fruit_pwrite_state);
4850 if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
4854 *vfs_aio_state = state->vfs_aio_state;
4855 return state->nwritten;
4859 * Helper to stat/lstat the base file of an smb_fname.
4861 static int fruit_stat_base(vfs_handle_struct *handle,
4862 struct smb_filename *smb_fname,
4865 char *tmp_stream_name;
4868 tmp_stream_name = smb_fname->stream_name;
4869 smb_fname->stream_name = NULL;
4871 rc = SMB_VFS_NEXT_STAT(handle, smb_fname);
4873 rc = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
4875 smb_fname->stream_name = tmp_stream_name;
4877 DBG_DEBUG("fruit_stat_base [%s] dev [%ju] ino [%ju]\n",
4878 smb_fname->base_name,
4879 (uintmax_t)smb_fname->st.st_ex_dev,
4880 (uintmax_t)smb_fname->st.st_ex_ino);
4884 static int fruit_stat_meta_stream(vfs_handle_struct *handle,
4885 struct smb_filename *smb_fname,
4891 ret = fruit_stat_base(handle, smb_fname, false);
4896 ino = fruit_inode(&smb_fname->st, smb_fname->stream_name);
4899 ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
4901 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
4904 smb_fname->st.st_ex_ino = ino;
4909 static int fruit_stat_meta_netatalk(vfs_handle_struct *handle,
4910 struct smb_filename *smb_fname,
4913 struct adouble *ad = NULL;
4915 ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_META);
4917 DBG_INFO("fruit_stat_meta %s: %s\n",
4918 smb_fname_str_dbg(smb_fname), strerror(errno));
4924 /* Populate the stat struct with info from the base file. */
4925 if (fruit_stat_base(handle, smb_fname, follow_links) == -1) {
4928 smb_fname->st.st_ex_size = AFP_INFO_SIZE;
4929 smb_fname->st.st_ex_ino = fruit_inode(&smb_fname->st,
4930 smb_fname->stream_name);
4934 static int fruit_stat_meta(vfs_handle_struct *handle,
4935 struct smb_filename *smb_fname,
4938 struct fruit_config_data *config = NULL;
4941 SMB_VFS_HANDLE_GET_DATA(handle, config,
4942 struct fruit_config_data, return -1);
4944 switch (config->meta) {
4945 case FRUIT_META_STREAM:
4946 ret = fruit_stat_meta_stream(handle, smb_fname, follow_links);
4949 case FRUIT_META_NETATALK:
4950 ret = fruit_stat_meta_netatalk(handle, smb_fname, follow_links);
4954 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
4961 static int fruit_stat_rsrc_netatalk(vfs_handle_struct *handle,
4962 struct smb_filename *smb_fname,
4965 struct adouble *ad = NULL;
4968 ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_RSRC);
4974 /* Populate the stat struct with info from the base file. */
4975 ret = fruit_stat_base(handle, smb_fname, follow_links);
4981 smb_fname->st.st_ex_size = ad_getentrylen(ad, ADEID_RFORK);
4982 smb_fname->st.st_ex_ino = fruit_inode(&smb_fname->st,
4983 smb_fname->stream_name);
4988 static int fruit_stat_rsrc_stream(vfs_handle_struct *handle,
4989 struct smb_filename *smb_fname,
4995 ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
4997 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
5003 static int fruit_stat_rsrc_xattr(vfs_handle_struct *handle,
5004 struct smb_filename *smb_fname,
5007 #ifdef HAVE_ATTROPEN
5011 /* Populate the stat struct with info from the base file. */
5012 ret = fruit_stat_base(handle, smb_fname, follow_links);
5017 fd = attropen(smb_fname->base_name,
5018 AFPRESOURCE_EA_NETATALK,
5024 ret = sys_fstat(fd, &smb_fname->st, false);
5027 DBG_ERR("fstat [%s:%s] failed\n", smb_fname->base_name,
5028 AFPRESOURCE_EA_NETATALK);
5034 smb_fname->st.st_ex_ino = fruit_inode(&smb_fname->st,
5035 smb_fname->stream_name);
5045 static int fruit_stat_rsrc(vfs_handle_struct *handle,
5046 struct smb_filename *smb_fname,
5049 struct fruit_config_data *config = NULL;
5052 DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
5054 SMB_VFS_HANDLE_GET_DATA(handle, config,
5055 struct fruit_config_data, return -1);
5057 switch (config->rsrc) {
5058 case FRUIT_RSRC_STREAM:
5059 ret = fruit_stat_rsrc_stream(handle, smb_fname, follow_links);
5062 case FRUIT_RSRC_XATTR:
5063 ret = fruit_stat_rsrc_xattr(handle, smb_fname, follow_links);
5066 case FRUIT_RSRC_ADFILE:
5067 ret = fruit_stat_rsrc_netatalk(handle, smb_fname, follow_links);
5071 DBG_ERR("Unexpected rsrc config [%d]\n", config->rsrc);
5078 static int fruit_stat(vfs_handle_struct *handle,
5079 struct smb_filename *smb_fname)
5083 DEBUG(10, ("fruit_stat called for %s\n",
5084 smb_fname_str_dbg(smb_fname)));
5086 if (!is_ntfs_stream_smb_fname(smb_fname)
5087 || is_ntfs_default_stream_smb_fname(smb_fname)) {
5088 rc = SMB_VFS_NEXT_STAT(handle, smb_fname);
5090 update_btime(handle, smb_fname);
5096 * Note if lp_posix_paths() is true, we can never
5097 * get here as is_ntfs_stream_smb_fname() is
5098 * always false. So we never need worry about
5099 * not following links here.
5102 if (is_afpinfo_stream(smb_fname)) {
5103 rc = fruit_stat_meta(handle, smb_fname, true);
5104 } else if (is_afpresource_stream(smb_fname)) {
5105 rc = fruit_stat_rsrc(handle, smb_fname, true);
5107 return SMB_VFS_NEXT_STAT(handle, smb_fname);
5111 update_btime(handle, smb_fname);
5112 smb_fname->st.st_ex_mode &= ~S_IFMT;
5113 smb_fname->st.st_ex_mode |= S_IFREG;
5114 smb_fname->st.st_ex_blocks =
5115 smb_fname->st.st_ex_size / STAT_ST_BLOCKSIZE + 1;
5120 static int fruit_lstat(vfs_handle_struct *handle,
5121 struct smb_filename *smb_fname)
5125 DEBUG(10, ("fruit_lstat called for %s\n",
5126 smb_fname_str_dbg(smb_fname)));
5128 if (!is_ntfs_stream_smb_fname(smb_fname)
5129 || is_ntfs_default_stream_smb_fname(smb_fname)) {
5130 rc = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
5132 update_btime(handle, smb_fname);
5137 if (is_afpinfo_stream(smb_fname)) {
5138 rc = fruit_stat_meta(handle, smb_fname, false);
5139 } else if (is_afpresource_stream(smb_fname)) {
5140 rc = fruit_stat_rsrc(handle, smb_fname, false);
5142 return SMB_VFS_NEXT_LSTAT(handle, smb_fname);
5146 update_btime(handle, smb_fname);
5147 smb_fname->st.st_ex_mode &= ~S_IFMT;
5148 smb_fname->st.st_ex_mode |= S_IFREG;
5149 smb_fname->st.st_ex_blocks =
5150 smb_fname->st.st_ex_size / STAT_ST_BLOCKSIZE + 1;
5155 static int fruit_fstat_meta_stream(vfs_handle_struct *handle,
5157 SMB_STRUCT_STAT *sbuf)
5159 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
5168 ret = fruit_stat_base(handle, fsp->base_fsp->fsp_name, false);
5173 *sbuf = fsp->base_fsp->fsp_name->st;
5174 sbuf->st_ex_size = AFP_INFO_SIZE;
5175 sbuf->st_ex_ino = fruit_inode(sbuf, fsp->fsp_name->stream_name);
5179 ret = fruit_stat_base(handle, fsp->base_fsp->fsp_name, false);
5183 *sbuf = fsp->base_fsp->fsp_name->st;
5185 ino = fruit_inode(sbuf, fsp->fsp_name->stream_name);
5187 ret = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
5192 sbuf->st_ex_ino = ino;
5196 static int fruit_fstat_meta_netatalk(vfs_handle_struct *handle,
5198 SMB_STRUCT_STAT *sbuf)
5202 ret = fruit_stat_base(handle, fsp->base_fsp->fsp_name, false);
5207 *sbuf = fsp->base_fsp->fsp_name->st;
5208 sbuf->st_ex_size = AFP_INFO_SIZE;
5209 sbuf->st_ex_ino = fruit_inode(sbuf, fsp->fsp_name->stream_name);
5214 static int fruit_fstat_meta(vfs_handle_struct *handle,
5216 SMB_STRUCT_STAT *sbuf,
5221 DBG_DEBUG("Path [%s]\n", fsp_str_dbg(fsp));
5223 switch (fio->config->meta) {
5224 case FRUIT_META_STREAM:
5225 ret = fruit_fstat_meta_stream(handle, fsp, sbuf);
5228 case FRUIT_META_NETATALK:
5229 ret = fruit_fstat_meta_netatalk(handle, fsp, sbuf);
5233 DBG_ERR("Unexpected meta config [%d]\n", fio->config->meta);
5237 DBG_DEBUG("Path [%s] ret [%d]\n", fsp_str_dbg(fsp), ret);
5241 static int fruit_fstat_rsrc_xattr(vfs_handle_struct *handle,
5243 SMB_STRUCT_STAT *sbuf)
5245 return SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
5248 static int fruit_fstat_rsrc_stream(vfs_handle_struct *handle,
5250 SMB_STRUCT_STAT *sbuf)
5252 return SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
5255 static int fruit_fstat_rsrc_adouble(vfs_handle_struct *handle,
5257 SMB_STRUCT_STAT *sbuf)
5259 struct adouble *ad = NULL;
5262 /* Populate the stat struct with info from the base file. */
5263 ret = fruit_stat_base(handle, fsp->base_fsp->fsp_name, false);
5268 ad = ad_get(talloc_tos(), handle,
5269 fsp->base_fsp->fsp_name,
5272 DBG_ERR("ad_get [%s] failed [%s]\n",
5273 fsp_str_dbg(fsp), strerror(errno));
5277 *sbuf = fsp->base_fsp->fsp_name->st;
5278 sbuf->st_ex_size = ad_getentrylen(ad, ADEID_RFORK);
5279 sbuf->st_ex_ino = fruit_inode(sbuf, fsp->fsp_name->stream_name);
5285 static int fruit_fstat_rsrc(vfs_handle_struct *handle, files_struct *fsp,
5286 SMB_STRUCT_STAT *sbuf, struct fio *fio)
5290 switch (fio->config->rsrc) {
5291 case FRUIT_RSRC_STREAM:
5292 ret = fruit_fstat_rsrc_stream(handle, fsp, sbuf);
5295 case FRUIT_RSRC_ADFILE:
5296 ret = fruit_fstat_rsrc_adouble(handle, fsp, sbuf);
5299 case FRUIT_RSRC_XATTR:
5300 ret = fruit_fstat_rsrc_xattr(handle, fsp, sbuf);
5304 DBG_ERR("Unexpected rsrc config [%d]\n", fio->config->rsrc);
5311 static int fruit_fstat(vfs_handle_struct *handle, files_struct *fsp,
5312 SMB_STRUCT_STAT *sbuf)
5314 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
5318 return SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
5321 DBG_DEBUG("Path [%s]\n", fsp_str_dbg(fsp));
5323 if (fio->type == ADOUBLE_META) {
5324 rc = fruit_fstat_meta(handle, fsp, sbuf, fio);
5326 rc = fruit_fstat_rsrc(handle, fsp, sbuf, fio);
5330 sbuf->st_ex_mode &= ~S_IFMT;
5331 sbuf->st_ex_mode |= S_IFREG;
5332 sbuf->st_ex_blocks = sbuf->st_ex_size / STAT_ST_BLOCKSIZE + 1;
5335 DBG_DEBUG("Path [%s] rc [%d] size [%"PRIdMAX"]\n",
5336 fsp_str_dbg(fsp), rc, (intmax_t)sbuf->st_ex_size);
5340 static NTSTATUS delete_invalid_meta_stream(
5341 vfs_handle_struct *handle,
5342 const struct smb_filename *smb_fname,
5343 TALLOC_CTX *mem_ctx,
5344 unsigned int *pnum_streams,
5345 struct stream_struct **pstreams,
5348 struct smb_filename *sname = NULL;
5352 ok = del_fruit_stream(mem_ctx, pnum_streams, pstreams, AFPINFO_STREAM);
5354 return NT_STATUS_INTERNAL_ERROR;
5358 return NT_STATUS_OK;
5361 sname = synthetic_smb_fname(talloc_tos(),
5362 smb_fname->base_name,
5363 AFPINFO_STREAM_NAME,
5365 if (sname == NULL) {
5366 return NT_STATUS_NO_MEMORY;
5369 ret = SMB_VFS_NEXT_UNLINK(handle, sname);
5372 DBG_ERR("Removing [%s] failed\n", smb_fname_str_dbg(sname));
5373 return map_nt_error_from_unix(errno);
5376 return NT_STATUS_OK;
5379 static NTSTATUS fruit_streaminfo_meta_stream(
5380 vfs_handle_struct *handle,
5381 struct files_struct *fsp,
5382 const struct smb_filename *smb_fname,
5383 TALLOC_CTX *mem_ctx,
5384 unsigned int *pnum_streams,
5385 struct stream_struct **pstreams)
5387 struct stream_struct *stream = *pstreams;
5388 unsigned int num_streams = *pnum_streams;
5391 for (i = 0; i < num_streams; i++) {
5392 if (strequal_m(stream[i].name, AFPINFO_STREAM)) {
5397 if (i == num_streams) {
5398 return NT_STATUS_OK;
5401 if (stream[i].size != AFP_INFO_SIZE) {
5402 DBG_ERR("Removing invalid AFPINFO_STREAM size [%jd] from [%s]\n",
5403 (intmax_t)stream[i].size, smb_fname_str_dbg(smb_fname));
5405 return delete_invalid_meta_stream(handle,
5414 return NT_STATUS_OK;
5417 static NTSTATUS fruit_streaminfo_meta_netatalk(
5418 vfs_handle_struct *handle,
5419 struct files_struct *fsp,
5420 const struct smb_filename *smb_fname,
5421 TALLOC_CTX *mem_ctx,
5422 unsigned int *pnum_streams,
5423 struct stream_struct **pstreams)
5425 struct stream_struct *stream = *pstreams;
5426 unsigned int num_streams = *pnum_streams;
5427 struct adouble *ad = NULL;
5432 /* Remove the Netatalk xattr from the list */
5433 ok = del_fruit_stream(mem_ctx, pnum_streams, pstreams,
5434 ":" NETATALK_META_XATTR ":$DATA");
5436 return NT_STATUS_NO_MEMORY;
5440 * Check if there's a AFPINFO_STREAM from the VFS streams
5441 * backend and if yes, remove it from the list
5443 for (i = 0; i < num_streams; i++) {
5444 if (strequal_m(stream[i].name, AFPINFO_STREAM)) {
5449 if (i < num_streams) {
5450 DBG_WARNING("Unexpected AFPINFO_STREAM on [%s]\n",
5451 smb_fname_str_dbg(smb_fname));
5453 ok = del_fruit_stream(mem_ctx, pnum_streams, pstreams,
5456 return NT_STATUS_INTERNAL_ERROR;
5460 ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_META);
5462 return NT_STATUS_OK;
5465 is_fi_empty = ad_empty_finderinfo(ad);
5469 return NT_STATUS_OK;
5472 ok = add_fruit_stream(mem_ctx, pnum_streams, pstreams,
5473 AFPINFO_STREAM_NAME, AFP_INFO_SIZE,
5474 smb_roundup(handle->conn, AFP_INFO_SIZE));
5476 return NT_STATUS_NO_MEMORY;
5479 return NT_STATUS_OK;
5482 static NTSTATUS fruit_streaminfo_meta(vfs_handle_struct *handle,
5483 struct files_struct *fsp,
5484 const struct smb_filename *smb_fname,
5485 TALLOC_CTX *mem_ctx,
5486 unsigned int *pnum_streams,
5487 struct stream_struct **pstreams)
5489 struct fruit_config_data *config = NULL;
5492 SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
5493 return NT_STATUS_INTERNAL_ERROR);
5495 switch (config->meta) {
5496 case FRUIT_META_NETATALK:
5497 status = fruit_streaminfo_meta_netatalk(handle, fsp, smb_fname,
5498 mem_ctx, pnum_streams,
5502 case FRUIT_META_STREAM:
5503 status = fruit_streaminfo_meta_stream(handle, fsp, smb_fname,
5504 mem_ctx, pnum_streams,
5509 return NT_STATUS_INTERNAL_ERROR;
5515 static NTSTATUS fruit_streaminfo_rsrc_stream(
5516 vfs_handle_struct *handle,
5517 struct files_struct *fsp,
5518 const struct smb_filename *smb_fname,
5519 TALLOC_CTX *mem_ctx,
5520 unsigned int *pnum_streams,
5521 struct stream_struct **pstreams)
5525 ok = filter_empty_rsrc_stream(pnum_streams, pstreams);
5527 DBG_ERR("Filtering resource stream failed\n");
5528 return NT_STATUS_INTERNAL_ERROR;
5530 return NT_STATUS_OK;
5533 static NTSTATUS fruit_streaminfo_rsrc_xattr(
5534 vfs_handle_struct *handle,
5535 struct files_struct *fsp,
5536 const struct smb_filename *smb_fname,
5537 TALLOC_CTX *mem_ctx,
5538 unsigned int *pnum_streams,
5539 struct stream_struct **pstreams)
5543 ok = filter_empty_rsrc_stream(pnum_streams, pstreams);
5545 DBG_ERR("Filtering resource stream failed\n");
5546 return NT_STATUS_INTERNAL_ERROR;
5548 return NT_STATUS_OK;
5551 static NTSTATUS fruit_streaminfo_rsrc_adouble(
5552 vfs_handle_struct *handle,
5553 struct files_struct *fsp,
5554 const struct smb_filename *smb_fname,
5555 TALLOC_CTX *mem_ctx,
5556 unsigned int *pnum_streams,
5557 struct stream_struct **pstreams)
5559 struct stream_struct *stream = *pstreams;
5560 unsigned int num_streams = *pnum_streams;
5561 struct adouble *ad = NULL;
5567 * Check if there's a AFPRESOURCE_STREAM from the VFS streams backend
5568 * and if yes, remove it from the list
5570 for (i = 0; i < num_streams; i++) {
5571 if (strequal_m(stream[i].name, AFPRESOURCE_STREAM)) {
5576 if (i < num_streams) {
5577 DBG_WARNING("Unexpected AFPRESOURCE_STREAM on [%s]\n",
5578 smb_fname_str_dbg(smb_fname));
5580 ok = del_fruit_stream(mem_ctx, pnum_streams, pstreams,
5581 AFPRESOURCE_STREAM);
5583 return NT_STATUS_INTERNAL_ERROR;
5587 ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_RSRC);
5589 return NT_STATUS_OK;
5592 rlen = ad_getentrylen(ad, ADEID_RFORK);
5596 return NT_STATUS_OK;
5599 ok = add_fruit_stream(mem_ctx, pnum_streams, pstreams,
5600 AFPRESOURCE_STREAM_NAME, rlen,
5601 smb_roundup(handle->conn, rlen));
5603 return NT_STATUS_NO_MEMORY;
5606 return NT_STATUS_OK;
5609 static NTSTATUS fruit_streaminfo_rsrc(vfs_handle_struct *handle,
5610 struct files_struct *fsp,
5611 const struct smb_filename *smb_fname,
5612 TALLOC_CTX *mem_ctx,
5613 unsigned int *pnum_streams,
5614 struct stream_struct **pstreams)
5616 struct fruit_config_data *config = NULL;
5619 SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
5620 return NT_STATUS_INTERNAL_ERROR);
5622 switch (config->rsrc) {
5623 case FRUIT_RSRC_STREAM:
5624 status = fruit_streaminfo_rsrc_stream(handle, fsp, smb_fname,
5625 mem_ctx, pnum_streams,
5629 case FRUIT_RSRC_XATTR:
5630 status = fruit_streaminfo_rsrc_xattr(handle, fsp, smb_fname,
5631 mem_ctx, pnum_streams,
5635 case FRUIT_RSRC_ADFILE:
5636 status = fruit_streaminfo_rsrc_adouble(handle, fsp, smb_fname,
5637 mem_ctx, pnum_streams,
5642 return NT_STATUS_INTERNAL_ERROR;
5648 static void fruit_filter_empty_streams(unsigned int *pnum_streams,
5649 struct stream_struct **pstreams)
5651 unsigned num_streams = *pnum_streams;
5652 struct stream_struct *streams = *pstreams;
5655 if (!global_fruit_config.nego_aapl) {
5659 while (i < num_streams) {
5660 struct smb_filename smb_fname = (struct smb_filename) {
5661 .stream_name = streams[i].name,
5664 if (is_ntfs_default_stream_smb_fname(&smb_fname)
5665 || streams[i].size > 0)
5671 streams[i] = streams[num_streams - 1];
5675 *pnum_streams = num_streams;
5678 static NTSTATUS fruit_streaminfo(vfs_handle_struct *handle,
5679 struct files_struct *fsp,
5680 const struct smb_filename *smb_fname,
5681 TALLOC_CTX *mem_ctx,
5682 unsigned int *pnum_streams,
5683 struct stream_struct **pstreams)
5685 struct fruit_config_data *config = NULL;
5688 SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
5689 return NT_STATUS_UNSUCCESSFUL);
5691 DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
5693 status = SMB_VFS_NEXT_STREAMINFO(handle, fsp, smb_fname, mem_ctx,
5694 pnum_streams, pstreams);
5695 if (!NT_STATUS_IS_OK(status)) {
5699 fruit_filter_empty_streams(pnum_streams, pstreams);
5701 status = fruit_streaminfo_meta(handle, fsp, smb_fname,
5702 mem_ctx, pnum_streams, pstreams);
5703 if (!NT_STATUS_IS_OK(status)) {
5707 status = fruit_streaminfo_rsrc(handle, fsp, smb_fname,
5708 mem_ctx, pnum_streams, pstreams);
5709 if (!NT_STATUS_IS_OK(status)) {
5713 return NT_STATUS_OK;
5716 static int fruit_ntimes(vfs_handle_struct *handle,
5717 const struct smb_filename *smb_fname,
5718 struct smb_file_time *ft)
5721 struct adouble *ad = NULL;
5722 struct fruit_config_data *config = NULL;
5724 SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
5727 if ((config->meta != FRUIT_META_NETATALK) ||
5728 null_timespec(ft->create_time))
5730 return SMB_VFS_NEXT_NTIMES(handle, smb_fname, ft);
5733 DEBUG(10,("set btime for %s to %s\n", smb_fname_str_dbg(smb_fname),
5734 time_to_asc(convert_timespec_to_time_t(ft->create_time))));
5736 ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_META);
5741 ad_setdate(ad, AD_DATE_CREATE | AD_DATE_UNIX,
5742 convert_time_t_to_uint32_t(ft->create_time.tv_sec));
5744 rc = ad_set(ad, smb_fname);
5750 DEBUG(1, ("fruit_ntimes: %s\n", smb_fname_str_dbg(smb_fname)));
5753 return SMB_VFS_NEXT_NTIMES(handle, smb_fname, ft);
5756 static int fruit_fallocate(struct vfs_handle_struct *handle,
5757 struct files_struct *fsp,
5762 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
5765 return SMB_VFS_NEXT_FALLOCATE(handle, fsp, mode, offset, len);
5768 /* Let the pwrite code path handle it. */
5773 static int fruit_ftruncate_rsrc_xattr(struct vfs_handle_struct *handle,
5774 struct files_struct *fsp,
5777 #ifdef HAVE_ATTROPEN
5778 return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, offset);
5783 static int fruit_ftruncate_rsrc_adouble(struct vfs_handle_struct *handle,
5784 struct files_struct *fsp,
5788 struct adouble *ad = NULL;
5791 ad = ad_fget(talloc_tos(), handle, fsp, ADOUBLE_RSRC);
5793 DBG_DEBUG("ad_get [%s] failed [%s]\n",
5794 fsp_str_dbg(fsp), strerror(errno));
5798 ad_off = ad_getentryoff(ad, ADEID_RFORK);
5800 rc = ftruncate(fsp->fh->fd, offset + ad_off);
5806 ad_setentrylen(ad, ADEID_RFORK, offset);
5808 rc = ad_fset(ad, fsp);
5810 DBG_ERR("ad_fset [%s] failed [%s]\n",
5811 fsp_str_dbg(fsp), strerror(errno));
5820 static int fruit_ftruncate_rsrc_stream(struct vfs_handle_struct *handle,
5821 struct files_struct *fsp,
5824 return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, offset);
5827 static int fruit_ftruncate_rsrc(struct vfs_handle_struct *handle,
5828 struct files_struct *fsp,
5831 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
5835 DBG_ERR("Failed to fetch fsp extension");
5839 switch (fio->config->rsrc) {
5840 case FRUIT_RSRC_XATTR:
5841 ret = fruit_ftruncate_rsrc_xattr(handle, fsp, offset);
5844 case FRUIT_RSRC_ADFILE:
5845 ret = fruit_ftruncate_rsrc_adouble(handle, fsp, offset);
5848 case FRUIT_RSRC_STREAM:
5849 ret = fruit_ftruncate_rsrc_stream(handle, fsp, offset);
5853 DBG_ERR("Unexpected rsrc config [%d]\n", fio->config->rsrc);
5861 static int fruit_ftruncate_meta(struct vfs_handle_struct *handle,
5862 struct files_struct *fsp,
5866 DBG_WARNING("ftruncate %s to %jd",
5867 fsp_str_dbg(fsp), (intmax_t)offset);
5868 /* OS X returns NT_STATUS_ALLOTTED_SPACE_EXCEEDED */
5873 /* OS X returns success but does nothing */
5874 DBG_INFO("ignoring ftruncate %s to %jd\n",
5875 fsp_str_dbg(fsp), (intmax_t)offset);
5879 static int fruit_ftruncate(struct vfs_handle_struct *handle,
5880 struct files_struct *fsp,
5883 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
5886 DBG_DEBUG("Path [%s] offset [%"PRIdMAX"]\n", fsp_str_dbg(fsp),
5890 return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, offset);
5893 if (fio->type == ADOUBLE_META) {
5894 ret = fruit_ftruncate_meta(handle, fsp, offset);
5896 ret = fruit_ftruncate_rsrc(handle, fsp, offset);
5899 DBG_DEBUG("Path [%s] result [%d]\n", fsp_str_dbg(fsp), ret);
5903 static NTSTATUS fruit_create_file(vfs_handle_struct *handle,
5904 struct smb_request *req,
5905 uint16_t root_dir_fid,
5906 struct smb_filename *smb_fname,
5907 uint32_t access_mask,
5908 uint32_t share_access,
5909 uint32_t create_disposition,
5910 uint32_t create_options,
5911 uint32_t file_attributes,
5912 uint32_t oplock_request,
5913 struct smb2_lease *lease,
5914 uint64_t allocation_size,
5915 uint32_t private_flags,
5916 struct security_descriptor *sd,
5917 struct ea_list *ea_list,
5918 files_struct **result,
5920 const struct smb2_create_blobs *in_context_blobs,
5921 struct smb2_create_blobs *out_context_blobs)
5924 struct fruit_config_data *config = NULL;
5925 files_struct *fsp = NULL;
5926 struct fio *fio = NULL;
5928 status = check_aapl(handle, req, in_context_blobs, out_context_blobs);
5929 if (!NT_STATUS_IS_OK(status)) {
5933 SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
5934 return NT_STATUS_UNSUCCESSFUL);
5936 status = SMB_VFS_NEXT_CREATE_FILE(
5937 handle, req, root_dir_fid, smb_fname,
5938 access_mask, share_access,
5939 create_disposition, create_options,
5940 file_attributes, oplock_request,
5942 allocation_size, private_flags,
5943 sd, ea_list, result,
5944 pinfo, in_context_blobs, out_context_blobs);
5945 if (!NT_STATUS_IS_OK(status)) {
5951 if (global_fruit_config.nego_aapl) {
5952 if (config->posix_rename && fsp->is_directory) {
5954 * Enable POSIX directory rename behaviour
5956 fsp->posix_flags |= FSP_POSIX_FLAGS_RENAME;
5961 * If this is a plain open for existing files, opening an 0
5962 * byte size resource fork MUST fail with
5963 * NT_STATUS_OBJECT_NAME_NOT_FOUND.
5965 * Cf the vfs_fruit torture tests in test_rfork_create().
5967 if (global_fruit_config.nego_aapl &&
5968 create_disposition == FILE_OPEN &&
5969 smb_fname->st.st_ex_size == 0 &&
5970 is_ntfs_stream_smb_fname(smb_fname) &&
5971 !(is_ntfs_default_stream_smb_fname(smb_fname)))
5973 status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
5977 fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
5978 if (fio != NULL && pinfo != NULL && *pinfo == FILE_WAS_CREATED) {
5979 fio->created = true;
5982 if (is_ntfs_stream_smb_fname(smb_fname)
5983 || fsp->is_directory) {
5987 if (config->locking == FRUIT_LOCKING_NETATALK) {
5988 status = fruit_check_access(
5991 map_share_mode_to_deny_mode(share_access, 0));
5992 if (!NT_STATUS_IS_OK(status)) {
6000 DEBUG(10, ("fruit_create_file: %s\n", nt_errstr(status)));
6003 close_file(req, fsp, ERROR_CLOSE);
6004 *result = fsp = NULL;
6010 static NTSTATUS fruit_readdir_attr(struct vfs_handle_struct *handle,
6011 const struct smb_filename *fname,
6012 TALLOC_CTX *mem_ctx,
6013 struct readdir_attr_data **pattr_data)
6015 struct fruit_config_data *config = NULL;
6016 struct readdir_attr_data *attr_data;
6019 SMB_VFS_HANDLE_GET_DATA(handle, config,
6020 struct fruit_config_data,
6021 return NT_STATUS_UNSUCCESSFUL);
6023 if (!global_fruit_config.nego_aapl) {
6024 return SMB_VFS_NEXT_READDIR_ATTR(handle, fname, mem_ctx, pattr_data);
6027 DEBUG(10, ("fruit_readdir_attr %s\n", fname->base_name));
6029 *pattr_data = talloc_zero(mem_ctx, struct readdir_attr_data);
6030 if (*pattr_data == NULL) {
6031 return NT_STATUS_UNSUCCESSFUL;
6033 attr_data = *pattr_data;
6034 attr_data->type = RDATTR_AAPL;
6037 * Mac metadata: compressed FinderInfo, resource fork length
6040 status = readdir_attr_macmeta(handle, fname, attr_data);
6041 if (!NT_STATUS_IS_OK(status)) {
6043 * Error handling is tricky: if we return failure from
6044 * this function, the corresponding directory entry
6045 * will to be passed to the client, so we really just
6046 * want to error out on fatal errors.
6048 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
6056 if (config->unix_info_enabled) {
6057 attr_data->attr_data.aapl.unix_mode = fname->st.st_ex_mode;
6063 if (!config->readdir_attr_max_access) {
6064 attr_data->attr_data.aapl.max_access = FILE_GENERIC_ALL;
6066 status = smbd_calculate_access_mask(
6070 SEC_FLAG_MAXIMUM_ALLOWED,
6071 &attr_data->attr_data.aapl.max_access);
6072 if (!NT_STATUS_IS_OK(status)) {
6077 return NT_STATUS_OK;
6080 DEBUG(1, ("fruit_readdir_attr %s, error: %s\n",
6081 fname->base_name, nt_errstr(status)));
6082 TALLOC_FREE(*pattr_data);
6086 static NTSTATUS fruit_fget_nt_acl(vfs_handle_struct *handle,
6088 uint32_t security_info,
6089 TALLOC_CTX *mem_ctx,
6090 struct security_descriptor **ppdesc)
6093 struct security_ace ace;
6095 struct fruit_config_data *config;
6097 SMB_VFS_HANDLE_GET_DATA(handle, config,
6098 struct fruit_config_data,
6099 return NT_STATUS_UNSUCCESSFUL);
6101 status = SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info,
6103 if (!NT_STATUS_IS_OK(status)) {
6108 * Add MS NFS style ACEs with uid, gid and mode
6110 if (!global_fruit_config.nego_aapl) {
6111 return NT_STATUS_OK;
6113 if (!config->unix_info_enabled) {
6114 return NT_STATUS_OK;
6117 /* First remove any existing ACE's with NFS style mode/uid/gid SIDs. */
6118 status = remove_virtual_nfs_aces(*ppdesc);
6119 if (!NT_STATUS_IS_OK(status)) {
6120 DBG_WARNING("failed to remove MS NFS style ACEs\n");
6124 /* MS NFS style mode */
6125 sid_compose(&sid, &global_sid_Unix_NFS_Mode, fsp->fsp_name->st.st_ex_mode);
6126 init_sec_ace(&ace, &sid, SEC_ACE_TYPE_ACCESS_DENIED, 0, 0);
6127 status = security_descriptor_dacl_add(*ppdesc, &ace);
6128 if (!NT_STATUS_IS_OK(status)) {
6129 DEBUG(1,("failed to add MS NFS style ACE\n"));
6133 /* MS NFS style uid */
6134 sid_compose(&sid, &global_sid_Unix_NFS_Users, fsp->fsp_name->st.st_ex_uid);
6135 init_sec_ace(&ace, &sid, SEC_ACE_TYPE_ACCESS_DENIED, 0, 0);
6136 status = security_descriptor_dacl_add(*ppdesc, &ace);
6137 if (!NT_STATUS_IS_OK(status)) {
6138 DEBUG(1,("failed to add MS NFS style ACE\n"));
6142 /* MS NFS style gid */
6143 sid_compose(&sid, &global_sid_Unix_NFS_Groups, fsp->fsp_name->st.st_ex_gid);
6144 init_sec_ace(&ace, &sid, SEC_ACE_TYPE_ACCESS_DENIED, 0, 0);
6145 status = security_descriptor_dacl_add(*ppdesc, &ace);
6146 if (!NT_STATUS_IS_OK(status)) {
6147 DEBUG(1,("failed to add MS NFS style ACE\n"));
6151 return NT_STATUS_OK;
6154 static NTSTATUS fruit_fset_nt_acl(vfs_handle_struct *handle,
6156 uint32_t security_info_sent,
6157 const struct security_descriptor *orig_psd)
6161 mode_t ms_nfs_mode = 0;
6163 struct security_descriptor *psd = NULL;
6164 uint32_t orig_num_aces = 0;
6166 if (orig_psd->dacl != NULL) {
6167 orig_num_aces = orig_psd->dacl->num_aces;
6170 psd = security_descriptor_copy(talloc_tos(), orig_psd);
6172 return NT_STATUS_NO_MEMORY;
6175 DBG_DEBUG("fruit_fset_nt_acl: %s\n", fsp_str_dbg(fsp));
6177 status = check_ms_nfs(handle, fsp, psd, &ms_nfs_mode, &do_chmod);
6178 if (!NT_STATUS_IS_OK(status)) {
6179 DEBUG(1, ("fruit_fset_nt_acl: check_ms_nfs failed%s\n", fsp_str_dbg(fsp)));
6185 * If only ms_nfs ACE entries were sent, ensure we set the DACL
6186 * sent/present flags correctly now we've removed them.
6189 if (orig_num_aces != 0) {
6191 * Are there any ACE's left ?
6193 if (psd->dacl->num_aces == 0) {
6194 /* No - clear the DACL sent/present flags. */
6195 security_info_sent &= ~SECINFO_DACL;
6196 psd->type &= ~SEC_DESC_DACL_PRESENT;
6200 status = SMB_VFS_NEXT_FSET_NT_ACL(handle, fsp, security_info_sent, psd);
6201 if (!NT_STATUS_IS_OK(status)) {
6202 DEBUG(1, ("fruit_fset_nt_acl: SMB_VFS_NEXT_FSET_NT_ACL failed%s\n", fsp_str_dbg(fsp)));
6208 if (fsp->fh->fd != -1) {
6209 result = SMB_VFS_FCHMOD(fsp, ms_nfs_mode);
6211 result = SMB_VFS_CHMOD(fsp->conn,
6217 DEBUG(1, ("chmod: %s, result: %d, %04o error %s\n", fsp_str_dbg(fsp),
6218 result, (unsigned)ms_nfs_mode,
6220 status = map_nt_error_from_unix(errno);
6227 return NT_STATUS_OK;
6230 static struct vfs_offload_ctx *fruit_offload_ctx;
6232 struct fruit_offload_read_state {
6233 struct vfs_handle_struct *handle;
6234 struct tevent_context *ev;
6240 static void fruit_offload_read_done(struct tevent_req *subreq);
6242 static struct tevent_req *fruit_offload_read_send(
6243 TALLOC_CTX *mem_ctx,
6244 struct tevent_context *ev,
6245 struct vfs_handle_struct *handle,
6252 struct tevent_req *req = NULL;
6253 struct tevent_req *subreq = NULL;
6254 struct fruit_offload_read_state *state = NULL;
6256 req = tevent_req_create(mem_ctx, &state,
6257 struct fruit_offload_read_state);
6261 *state = (struct fruit_offload_read_state) {
6268 subreq = SMB_VFS_NEXT_OFFLOAD_READ_SEND(mem_ctx, ev, handle, fsp,
6269 fsctl, ttl, offset, to_copy);
6270 if (tevent_req_nomem(subreq, req)) {
6271 return tevent_req_post(req, ev);
6273 tevent_req_set_callback(subreq, fruit_offload_read_done, req);
6277 static void fruit_offload_read_done(struct tevent_req *subreq)
6279 struct tevent_req *req = tevent_req_callback_data(
6280 subreq, struct tevent_req);
6281 struct fruit_offload_read_state *state = tevent_req_data(
6282 req, struct fruit_offload_read_state);
6285 status = SMB_VFS_NEXT_OFFLOAD_READ_RECV(subreq,
6289 TALLOC_FREE(subreq);
6290 if (tevent_req_nterror(req, status)) {
6294 if (state->fsctl != FSCTL_SRV_REQUEST_RESUME_KEY) {
6295 tevent_req_done(req);
6299 status = vfs_offload_token_ctx_init(state->fsp->conn->sconn->client,
6300 &fruit_offload_ctx);
6301 if (tevent_req_nterror(req, status)) {
6305 status = vfs_offload_token_db_store_fsp(fruit_offload_ctx,
6308 if (tevent_req_nterror(req, status)) {
6312 tevent_req_done(req);
6316 static NTSTATUS fruit_offload_read_recv(struct tevent_req *req,
6317 struct vfs_handle_struct *handle,
6318 TALLOC_CTX *mem_ctx,
6321 struct fruit_offload_read_state *state = tevent_req_data(
6322 req, struct fruit_offload_read_state);
6325 if (tevent_req_is_nterror(req, &status)) {
6326 tevent_req_received(req);
6330 token->length = state->token.length;
6331 token->data = talloc_move(mem_ctx, &state->token.data);
6333 tevent_req_received(req);
6334 return NT_STATUS_OK;
6337 struct fruit_offload_write_state {
6338 struct vfs_handle_struct *handle;
6340 struct files_struct *src_fsp;
6341 struct files_struct *dst_fsp;
6345 static void fruit_offload_write_done(struct tevent_req *subreq);
6346 static struct tevent_req *fruit_offload_write_send(struct vfs_handle_struct *handle,
6347 TALLOC_CTX *mem_ctx,
6348 struct tevent_context *ev,
6351 off_t transfer_offset,
6352 struct files_struct *dest_fsp,
6356 struct tevent_req *req, *subreq;
6357 struct fruit_offload_write_state *state;
6359 struct fruit_config_data *config;
6360 off_t src_off = transfer_offset;
6361 files_struct *src_fsp = NULL;
6362 off_t to_copy = num;
6363 bool copyfile_enabled = false;
6365 DEBUG(10,("soff: %ju, doff: %ju, len: %ju\n",
6366 (uintmax_t)src_off, (uintmax_t)dest_off, (uintmax_t)num));
6368 SMB_VFS_HANDLE_GET_DATA(handle, config,
6369 struct fruit_config_data,
6372 req = tevent_req_create(mem_ctx, &state,
6373 struct fruit_offload_write_state);
6377 state->handle = handle;
6378 state->dst_fsp = dest_fsp;
6381 case FSCTL_SRV_COPYCHUNK:
6382 case FSCTL_SRV_COPYCHUNK_WRITE:
6383 copyfile_enabled = config->copyfile_enabled;
6390 * Check if this a OS X copyfile style copychunk request with
6391 * a requested chunk count of 0 that was translated to a
6392 * offload_write_send VFS call overloading the parameters src_off
6393 * = dest_off = num = 0.
6395 if (copyfile_enabled && num == 0 && src_off == 0 && dest_off == 0) {
6396 status = vfs_offload_token_db_fetch_fsp(
6397 fruit_offload_ctx, token, &src_fsp);
6398 if (tevent_req_nterror(req, status)) {
6399 return tevent_req_post(req, ev);
6401 state->src_fsp = src_fsp;
6403 status = vfs_stat_fsp(src_fsp);
6404 if (tevent_req_nterror(req, status)) {
6405 return tevent_req_post(req, ev);
6408 to_copy = src_fsp->fsp_name->st.st_ex_size;
6409 state->is_copyfile = true;
6412 subreq = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle,
6421 if (tevent_req_nomem(subreq, req)) {
6422 return tevent_req_post(req, ev);
6425 tevent_req_set_callback(subreq, fruit_offload_write_done, req);
6429 static void fruit_offload_write_done(struct tevent_req *subreq)
6431 struct tevent_req *req = tevent_req_callback_data(
6432 subreq, struct tevent_req);
6433 struct fruit_offload_write_state *state = tevent_req_data(
6434 req, struct fruit_offload_write_state);
6436 unsigned int num_streams = 0;
6437 struct stream_struct *streams = NULL;
6439 struct smb_filename *src_fname_tmp = NULL;
6440 struct smb_filename *dst_fname_tmp = NULL;
6442 status = SMB_VFS_NEXT_OFFLOAD_WRITE_RECV(state->handle,
6445 TALLOC_FREE(subreq);
6446 if (tevent_req_nterror(req, status)) {
6450 if (!state->is_copyfile) {
6451 tevent_req_done(req);
6456 * Now copy all remaining streams. We know the share supports
6457 * streams, because we're in vfs_fruit. We don't do this async
6458 * because streams are few and small.
6460 status = vfs_streaminfo(state->handle->conn, state->src_fsp,
6461 state->src_fsp->fsp_name,
6462 req, &num_streams, &streams);
6463 if (tevent_req_nterror(req, status)) {
6467 if (num_streams == 1) {
6468 /* There is always one stream, ::$DATA. */
6469 tevent_req_done(req);
6473 for (i = 0; i < num_streams; i++) {
6474 DEBUG(10, ("%s: stream: '%s'/%zu\n",
6475 __func__, streams[i].name, (size_t)streams[i].size));
6477 src_fname_tmp = synthetic_smb_fname(
6479 state->src_fsp->fsp_name->base_name,
6482 state->src_fsp->fsp_name->flags);
6483 if (tevent_req_nomem(src_fname_tmp, req)) {
6487 if (is_ntfs_default_stream_smb_fname(src_fname_tmp)) {
6488 TALLOC_FREE(src_fname_tmp);
6492 dst_fname_tmp = synthetic_smb_fname(
6494 state->dst_fsp->fsp_name->base_name,
6497 state->dst_fsp->fsp_name->flags);
6498 if (tevent_req_nomem(dst_fname_tmp, req)) {
6499 TALLOC_FREE(src_fname_tmp);
6503 status = copy_file(req,
6504 state->handle->conn,
6507 OPENX_FILE_CREATE_IF_NOT_EXIST,
6509 if (!NT_STATUS_IS_OK(status)) {
6510 DEBUG(1, ("%s: copy %s to %s failed: %s\n", __func__,
6511 smb_fname_str_dbg(src_fname_tmp),
6512 smb_fname_str_dbg(dst_fname_tmp),
6513 nt_errstr(status)));
6514 TALLOC_FREE(src_fname_tmp);
6515 TALLOC_FREE(dst_fname_tmp);
6516 tevent_req_nterror(req, status);
6520 TALLOC_FREE(src_fname_tmp);
6521 TALLOC_FREE(dst_fname_tmp);
6524 TALLOC_FREE(streams);
6525 TALLOC_FREE(src_fname_tmp);
6526 TALLOC_FREE(dst_fname_tmp);
6527 tevent_req_done(req);
6530 static NTSTATUS fruit_offload_write_recv(struct vfs_handle_struct *handle,
6531 struct tevent_req *req,
6534 struct fruit_offload_write_state *state = tevent_req_data(
6535 req, struct fruit_offload_write_state);
6538 if (tevent_req_is_nterror(req, &status)) {
6539 DEBUG(1, ("server side copy chunk failed: %s\n",
6540 nt_errstr(status)));
6542 tevent_req_received(req);
6546 *copied = state->copied;
6547 tevent_req_received(req);
6549 return NT_STATUS_OK;
6552 static char *fruit_get_bandsize_line(char **lines, int numlines)
6555 static bool re_initialized = false;
6559 if (!re_initialized) {
6560 ret = regcomp(&re, "^[[:blank:]]*<key>band-size</key>$", 0);
6564 re_initialized = true;
6567 for (i = 0; i < numlines; i++) {
6568 regmatch_t matches[1];
6570 ret = regexec(&re, lines[i], 1, matches, 0);
6573 * Check if the match was on the last line, sa we want
6574 * the subsequent line.
6576 if (i + 1 == numlines) {
6579 return lines[i + 1];
6581 if (ret != REG_NOMATCH) {
6589 static bool fruit_get_bandsize_from_line(char *line, size_t *_band_size)
6592 static bool re_initialized = false;
6593 regmatch_t matches[2];
6598 if (!re_initialized) {
6601 "<integer>\\([[:digit:]]*\\)</integer>$",
6606 re_initialized = true;
6609 ret = regexec(&re, line, 2, matches, 0);
6611 DBG_ERR("regex failed [%s]\n", line);
6615 line[matches[1].rm_eo] = '\0';
6617 ok = conv_str_u64(&line[matches[1].rm_so], &band_size);
6621 *_band_size = (size_t)band_size;
6626 * This reads and parses an Info.plist from a TM sparsebundle looking for the
6627 * "band-size" key and value.
6629 static bool fruit_get_bandsize(vfs_handle_struct *handle,
6633 #define INFO_PLIST_MAX_SIZE 64*1024
6635 struct smb_filename *smb_fname = NULL;
6636 files_struct *fsp = NULL;
6637 uint8_t *file_data = NULL;
6638 char **lines = NULL;
6639 char *band_size_line = NULL;
6640 size_t plist_file_size;
6647 plist = talloc_asprintf(talloc_tos(),
6649 handle->conn->connectpath,
6651 if (plist == NULL) {
6656 smb_fname = synthetic_smb_fname(talloc_tos(), plist, NULL, NULL, 0);
6657 if (smb_fname == NULL) {
6662 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
6664 DBG_INFO("Ignoring Sparsebundle without Info.plist [%s]\n", dir);
6669 plist_file_size = smb_fname->st.st_ex_size;
6671 if (plist_file_size > INFO_PLIST_MAX_SIZE) {
6672 DBG_INFO("%s is too large, ignoring\n", plist);
6677 status = SMB_VFS_NEXT_CREATE_FILE(
6680 0, /* root_dir_fid */
6681 smb_fname, /* fname */
6682 FILE_GENERIC_READ, /* access_mask */
6683 FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */
6684 FILE_OPEN, /* create_disposition */
6685 0, /* create_options */
6686 0, /* file_attributes */
6687 INTERNAL_OPEN_ONLY, /* oplock_request */
6689 0, /* allocation_size */
6690 0, /* private_flags */
6695 NULL, NULL); /* create context */
6696 if (!NT_STATUS_IS_OK(status)) {
6697 DBG_INFO("Opening [%s] failed [%s]\n",
6698 smb_fname_str_dbg(smb_fname), nt_errstr(status));
6703 file_data = talloc_array(talloc_tos(), uint8_t, plist_file_size);
6704 if (file_data == NULL) {
6709 nread = SMB_VFS_NEXT_PREAD(handle, fsp, file_data, plist_file_size, 0);
6710 if (nread != plist_file_size) {
6711 DBG_ERR("Short read on [%s]: %zu/%zd\n",
6712 fsp_str_dbg(fsp), nread, plist_file_size);
6718 status = close_file(NULL, fsp, NORMAL_CLOSE);
6720 if (!NT_STATUS_IS_OK(status)) {
6721 DBG_ERR("close_file failed: %s\n", nt_errstr(status));
6726 lines = file_lines_parse((char *)file_data,
6730 if (lines == NULL) {
6735 band_size_line = fruit_get_bandsize_line(lines, numlines);
6736 if (band_size_line == NULL) {
6737 DBG_ERR("Didn't find band-size key in [%s]\n",
6738 smb_fname_str_dbg(smb_fname));
6743 ok = fruit_get_bandsize_from_line(band_size_line, band_size);
6745 DBG_ERR("fruit_get_bandsize_from_line failed\n");
6749 DBG_DEBUG("Parsed band-size [%zu] for [%s]\n", *band_size, plist);
6753 status = close_file(NULL, fsp, NORMAL_CLOSE);
6754 if (!NT_STATUS_IS_OK(status)) {
6755 DBG_ERR("close_file failed: %s\n", nt_errstr(status));
6760 TALLOC_FREE(smb_fname);
6761 TALLOC_FREE(file_data);
6766 struct fruit_disk_free_state {
6770 static bool fruit_get_num_bands(vfs_handle_struct *handle,
6775 struct smb_filename *bands_dir = NULL;
6777 struct dirent *e = NULL;
6781 path = talloc_asprintf(talloc_tos(),
6783 handle->conn->connectpath,
6789 bands_dir = synthetic_smb_fname(talloc_tos(),
6795 if (bands_dir == NULL) {
6799 d = SMB_VFS_NEXT_OPENDIR(handle, bands_dir, NULL, 0);
6801 TALLOC_FREE(bands_dir);
6807 for (e = SMB_VFS_NEXT_READDIR(handle, d, NULL);
6809 e = SMB_VFS_NEXT_READDIR(handle, d, NULL))
6811 if (ISDOT(e->d_name) || ISDOTDOT(e->d_name)) {
6817 ret = SMB_VFS_NEXT_CLOSEDIR(handle, d);
6819 TALLOC_FREE(bands_dir);
6823 DBG_DEBUG("%zu bands in [%s]\n", nbands, smb_fname_str_dbg(bands_dir));
6825 TALLOC_FREE(bands_dir);
6831 static bool fruit_tmsize_do_dirent(vfs_handle_struct *handle,
6832 struct fruit_disk_free_state *state,
6837 size_t sparsebundle_strlen = strlen("sparsebundle");
6838 size_t bandsize = 0;
6842 p = strstr(e->d_name, "sparsebundle");
6847 if (p[sparsebundle_strlen] != '\0') {
6851 DBG_DEBUG("Processing sparsebundle [%s]\n", e->d_name);
6853 ok = fruit_get_bandsize(handle, e->d_name, &bandsize);
6856 * Beware of race conditions: this may be an uninitialized
6857 * Info.plist that a client is just creating. We don't want let
6858 * this to trigger complete failure.
6860 DBG_ERR("Processing sparsebundle [%s] failed\n", e->d_name);
6864 ok = fruit_get_num_bands(handle, e->d_name, &nbands);
6867 * Beware of race conditions: this may be a backup sparsebundle
6868 * in an early stage lacking a bands subdirectory. We don't want
6869 * let this to trigger complete failure.
6871 DBG_ERR("Processing sparsebundle [%s] failed\n", e->d_name);
6875 if (bandsize > SIZE_MAX/nbands) {
6876 DBG_ERR("tmsize overflow: bandsize [%zu] nbands [%zu]\n",
6880 tm_size = bandsize * nbands;
6882 if (state->total_size + tm_size < state->total_size) {
6883 DBG_ERR("tmsize overflow: bandsize [%zu] nbands [%zu]\n",
6888 state->total_size += tm_size;
6890 DBG_DEBUG("[%s] tm_size [%jd] total_size [%jd]\n",
6891 e->d_name, (intmax_t)tm_size, (intmax_t)state->total_size);
6897 * Calculate used size of a TimeMachine volume
6899 * This assumes that the volume is used only for TimeMachine.
6901 * - readdir(basedir of share), then
6902 * - for every element that matches regex "^\(.*\)\.sparsebundle$" :
6903 * - parse "\1.sparsebundle/Info.plist" and read the band-size XML key
6904 * - count band files in "\1.sparsebundle/bands/"
6905 * - calculate used size of all bands: band_count * band_size
6907 static uint64_t fruit_disk_free(vfs_handle_struct *handle,
6908 const struct smb_filename *smb_fname,
6913 struct fruit_config_data *config = NULL;
6914 struct fruit_disk_free_state state = {0};
6916 struct dirent *e = NULL;
6922 SMB_VFS_HANDLE_GET_DATA(handle, config,
6923 struct fruit_config_data,
6926 if (!config->time_machine ||
6927 config->time_machine_max_size == 0)
6929 return SMB_VFS_NEXT_DISK_FREE(handle,
6936 d = SMB_VFS_NEXT_OPENDIR(handle, smb_fname, NULL, 0);
6941 for (e = SMB_VFS_NEXT_READDIR(handle, d, NULL);
6943 e = SMB_VFS_NEXT_READDIR(handle, d, NULL))
6945 ok = fruit_tmsize_do_dirent(handle, &state, e);
6947 SMB_VFS_NEXT_CLOSEDIR(handle, d);
6952 ret = SMB_VFS_NEXT_CLOSEDIR(handle, d);
6957 dsize = config->time_machine_max_size / 512;
6958 dfree = dsize - (state.total_size / 512);
6959 if (dfree > dsize) {
6969 static struct vfs_fn_pointers vfs_fruit_fns = {
6970 .connect_fn = fruit_connect,
6971 .disk_free_fn = fruit_disk_free,
6973 /* File operations */
6974 .chmod_fn = fruit_chmod,
6975 .chown_fn = fruit_chown,
6976 .unlink_fn = fruit_unlink,
6977 .rename_fn = fruit_rename,
6978 .rmdir_fn = fruit_rmdir,
6979 .open_fn = fruit_open,
6980 .pread_fn = fruit_pread,
6981 .pwrite_fn = fruit_pwrite,
6982 .pread_send_fn = fruit_pread_send,
6983 .pread_recv_fn = fruit_pread_recv,
6984 .pwrite_send_fn = fruit_pwrite_send,
6985 .pwrite_recv_fn = fruit_pwrite_recv,
6986 .stat_fn = fruit_stat,
6987 .lstat_fn = fruit_lstat,
6988 .fstat_fn = fruit_fstat,
6989 .streaminfo_fn = fruit_streaminfo,
6990 .ntimes_fn = fruit_ntimes,
6991 .ftruncate_fn = fruit_ftruncate,
6992 .fallocate_fn = fruit_fallocate,
6993 .create_file_fn = fruit_create_file,
6994 .readdir_attr_fn = fruit_readdir_attr,
6995 .offload_read_send_fn = fruit_offload_read_send,
6996 .offload_read_recv_fn = fruit_offload_read_recv,
6997 .offload_write_send_fn = fruit_offload_write_send,
6998 .offload_write_recv_fn = fruit_offload_write_recv,
7000 /* NT ACL operations */
7001 .fget_nt_acl_fn = fruit_fget_nt_acl,
7002 .fset_nt_acl_fn = fruit_fset_nt_acl,
7006 NTSTATUS vfs_fruit_init(TALLOC_CTX *ctx)
7008 NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "fruit",
7010 if (!NT_STATUS_IS_OK(ret)) {
7014 vfs_fruit_debug_level = debug_add_class("fruit");
7015 if (vfs_fruit_debug_level == -1) {
7016 vfs_fruit_debug_level = DBGC_VFS;
7017 DEBUG(0, ("%s: Couldn't register custom debugging class!\n",
7020 DEBUG(10, ("%s: Debug class number of '%s': %d\n",
7021 "vfs_fruit_init","fruit",vfs_fruit_debug_level));