?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WHATSNEW: Add release notes for Samba 4.9.17.
[Samba.git] / source3 / modules / vfs_fruit.c
blobc85f3dd07a4cd16e7407173689dfe2ab18cede85
1 /*
2 * OS X and Netatalk interoperability VFS module for Samba-3.x
3 *
4 * Copyright (C) Ralph Boehme, 2013, 2014
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21 #include "MacExtensions.h"
22 #include "smbd/smbd.h"
23 #include "system/filesys.h"
24 #include "lib/util/time.h"
25 #include "../lib/crypto/md5.h"
26 #include "system/shmem.h"
27 #include "locking/proto.h"
28 #include "smbd/globals.h"
29 #include "messages.h"
30 #include "libcli/security/security.h"
31 #include "../libcli/smb/smb2_create_ctx.h"
32 #include "lib/util/tevent_ntstatus.h"
33 #include "lib/util/tevent_unix.h"
34 #include "offload_token.h"
35 #include "string_replace.h"
36
37 /*
38 * Enhanced OS X and Netatalk compatibility
39 * ========================================
40 *
41 * This modules takes advantage of vfs_streams_xattr and
42 * vfs_catia. VFS modules vfs_fruit and vfs_streams_xattr must be
43 * loaded in the correct order:
44 *
45 * vfs modules = catia fruit streams_xattr
46 *
47 * The module intercepts the OS X special streams "AFP_AfpInfo" and
48 * "AFP_Resource" and handles them in a special way. All other named
49 * streams are deferred to vfs_streams_xattr.
50 *
51 * The OS X client maps all NTFS illegal characters to the Unicode
52 * private range. This module optionally stores the charcters using
53 * their native ASCII encoding using vfs_catia. If you're not enabling
54 * this feature, you can skip catia from vfs modules.
55 *
56 * Finally, open modes are optionally checked against Netatalk AFP
57 * share modes.
58 *
59 * The "AFP_AfpInfo" named stream is a binary blob containing OS X
60 * extended metadata for files and directories. This module optionally
61 * reads and stores this metadata in a way compatible with Netatalk 3
62 * which stores the metadata in an EA "org.netatalk.metadata". Cf
63 * source3/include/MacExtensions.h for a description of the binary
64 * blobs content.
65 *
66 * The "AFP_Resource" named stream may be arbitrarily large, thus it
67 * can't be stored in an xattr on most filesystem. ZFS on Solaris is
68 * the only available filesystem where xattrs can be of any size and
69 * the OS supports using the file APIs for xattrs.
70 *
71 * The AFP_Resource stream is stored in an AppleDouble file prepending
72 * "._" to the filename. On Solaris with ZFS the stream is optionally
73 * stored in an EA "org.netatalk.resource".
74 *
75 *
76 * Extended Attributes
77 * ===================
78 *
79 * The OS X SMB client sends xattrs as ADS too. For xattr interop with
80 * other protocols you may want to adjust the xattr names the VFS
81 * module vfs_streams_xattr uses for storing ADS's. This defaults to
82 * user.DosStream.ADS_NAME:$DATA and can be changed by specifying
83 * these module parameters:
84 *
85 * streams_xattr:prefix = user.
86 * streams_xattr:store_stream_type = false
87 *
88 *
89 * TODO
90 * ====
91 *
92 * - log diagnostic if any needed VFS module is not loaded
93 * (eg with lp_vfs_objects())
94 * - add tests
95 */
96
97 static int vfs_fruit_debug_level = DBGC_VFS;
98
99 static struct global_fruit_config {
100 bool nego_aapl; /* client negotiated AAPL */
101
102 } global_fruit_config;
103
104 #undef DBGC_CLASS
105 #define DBGC_CLASS vfs_fruit_debug_level
106
107 #define FRUIT_PARAM_TYPE_NAME "fruit"
108 #define ADOUBLE_NAME_PREFIX "._"
109
110 #define NETATALK_META_XATTR "org.netatalk.Metadata"
111 #define NETATALK_RSRC_XATTR "org.netatalk.ResourceFork"
112
113 #if defined(HAVE_ATTROPEN)
114 #define AFPINFO_EA_NETATALK NETATALK_META_XATTR
115 #define AFPRESOURCE_EA_NETATALK NETATALK_RSRC_XATTR
116 #else
117 #define AFPINFO_EA_NETATALK "user." NETATALK_META_XATTR
118 #define AFPRESOURCE_EA_NETATALK "user." NETATALK_RSRC_XATTR
119 #endif
120
121 enum apple_fork {APPLE_FORK_DATA, APPLE_FORK_RSRC};
122
123 enum fruit_rsrc {FRUIT_RSRC_STREAM, FRUIT_RSRC_ADFILE, FRUIT_RSRC_XATTR};
124 enum fruit_meta {FRUIT_META_STREAM, FRUIT_META_NETATALK};
125 enum fruit_locking {FRUIT_LOCKING_NETATALK, FRUIT_LOCKING_NONE};
126 enum fruit_encoding {FRUIT_ENC_NATIVE, FRUIT_ENC_PRIVATE};
127
128 struct fruit_config_data {
129 enum fruit_rsrc rsrc;
130 enum fruit_meta meta;
131 enum fruit_locking locking;
132 enum fruit_encoding encoding;
133 bool use_aapl; /* config from smb.conf */
134 bool use_copyfile;
135 bool readdir_attr_enabled;
136 bool unix_info_enabled;
137 bool copyfile_enabled;
138 bool veto_appledouble;
139 bool posix_rename;
140 bool aapl_zero_file_id;
141 const char *model;
142 bool time_machine;
143 off_t time_machine_max_size;
144 bool wipe_intentionally_left_blank_rfork;
145 bool delete_empty_adfiles;
146
147 /*
148 * Additional options, all enabled by default,
149 * possibly useful for analyzing performance. The associated
150 * operations with each of them may be expensive, so having
151 * the chance to disable them individually gives a chance
152 * tweaking the setup for the particular usecase.
153 */
154 bool readdir_attr_rsize;
155 bool readdir_attr_finder_info;
156 bool readdir_attr_max_access;
157 };
158
159 static const struct enum_list fruit_rsrc[] = {
160 {FRUIT_RSRC_STREAM, "stream"}, /* pass on to vfs_streams_xattr */
161 {FRUIT_RSRC_ADFILE, "file"}, /* ._ AppleDouble file */
162 {FRUIT_RSRC_XATTR, "xattr"}, /* Netatalk compatible xattr (ZFS only) */
163 { -1, NULL}
164 };
165
166 static const struct enum_list fruit_meta[] = {
167 {FRUIT_META_STREAM, "stream"}, /* pass on to vfs_streams_xattr */
168 {FRUIT_META_NETATALK, "netatalk"}, /* Netatalk compatible xattr */
169 { -1, NULL}
170 };
171
172 static const struct enum_list fruit_locking[] = {
173 {FRUIT_LOCKING_NETATALK, "netatalk"}, /* synchronize locks with Netatalk */
174 {FRUIT_LOCKING_NONE, "none"},
175 { -1, NULL}
176 };
177
178 static const struct enum_list fruit_encoding[] = {
179 {FRUIT_ENC_NATIVE, "native"}, /* map unicode private chars to ASCII */
180 {FRUIT_ENC_PRIVATE, "private"}, /* keep unicode private chars */
181 { -1, NULL}
182 };
183
184 static const char *fruit_catia_maps =
185 "0x01:0xf001,0x02:0xf002,0x03:0xf003,0x04:0xf004,"
186 "0x05:0xf005,0x06:0xf006,0x07:0xf007,0x08:0xf008,"
187 "0x09:0xf009,0x0a:0xf00a,0x0b:0xf00b,0x0c:0xf00c,"
188 "0x0d:0xf00d,0x0e:0xf00e,0x0f:0xf00f,0x10:0xf010,"
189 "0x11:0xf011,0x12:0xf012,0x13:0xf013,0x14:0xf014,"
190 "0x15:0xf015,0x16:0xf016,0x17:0xf017,0x18:0xf018,"
191 "0x19:0xf019,0x1a:0xf01a,0x1b:0xf01b,0x1c:0xf01c,"
192 "0x1d:0xf01d,0x1e:0xf01e,0x1f:0xf01f,"
193 "0x22:0xf020,0x2a:0xf021,0x3a:0xf022,0x3c:0xf023,"
194 "0x3e:0xf024,0x3f:0xf025,0x5c:0xf026,0x7c:0xf027,"
195 "0x0d:0xf00d";
196
197 /*****************************************************************************
198 * Defines, functions and data structures that deal with AppleDouble
199 *****************************************************************************/
200
201 /*
202 * There are two AppleDouble blobs we deal with:
203 *
204 * - ADOUBLE_META - AppleDouble blob used by Netatalk for storing
205 * metadata in an xattr
206 *
207 * - ADOUBLE_RSRC - AppleDouble blob used by OS X and Netatalk in
208 * ._ files
209 */
210 typedef enum {ADOUBLE_META, ADOUBLE_RSRC} adouble_type_t;
211
212 /* Version info */
213 #define AD_VERSION2 0x00020000
214 #define AD_VERSION AD_VERSION2
215
216 /*
217 * AppleDouble entry IDs.
218 */
219 #define ADEID_DFORK 1
220 #define ADEID_RFORK 2
221 #define ADEID_NAME 3
222 #define ADEID_COMMENT 4
223 #define ADEID_ICONBW 5
224 #define ADEID_ICONCOL 6
225 #define ADEID_FILEI 7
226 #define ADEID_FILEDATESI 8
227 #define ADEID_FINDERI 9
228 #define ADEID_MACFILEI 10
229 #define ADEID_PRODOSFILEI 11
230 #define ADEID_MSDOSFILEI 12
231 #define ADEID_SHORTNAME 13
232 #define ADEID_AFPFILEI 14
233 #define ADEID_DID 15
234
235 /* Private Netatalk entries */
236 #define ADEID_PRIVDEV 16
237 #define ADEID_PRIVINO 17
238 #define ADEID_PRIVSYN 18
239 #define ADEID_PRIVID 19
240 #define ADEID_MAX (ADEID_PRIVID + 1)
241
242 /*
243 * These are the real ids for the private entries,
244 * as stored in the adouble file
245 */
246 #define AD_DEV 0x80444556
247 #define AD_INO 0x80494E4F
248 #define AD_SYN 0x8053594E
249 #define AD_ID 0x8053567E
250
251 /* Number of actually used entries */
252 #define ADEID_NUM_XATTR 8
253 #define ADEID_NUM_DOT_UND 2
254 #define ADEID_NUM_RSRC_XATTR 1
255
256 /* AppleDouble magic */
257 #define AD_APPLESINGLE_MAGIC 0x00051600
258 #define AD_APPLEDOUBLE_MAGIC 0x00051607
259 #define AD_MAGIC AD_APPLEDOUBLE_MAGIC
260
261 /* Sizes of relevant entry bits */
262 #define ADEDLEN_MAGIC 4
263 #define ADEDLEN_VERSION 4
264 #define ADEDLEN_FILLER 16
265 #define AD_FILLER_TAG "Netatalk " /* should be 16 bytes */
266 #define AD_FILLER_TAG_OSX "Mac OS X " /* should be 16 bytes */
267 #define ADEDLEN_NENTRIES 2
268 #define AD_HEADER_LEN (ADEDLEN_MAGIC + ADEDLEN_VERSION + \
269 ADEDLEN_FILLER + ADEDLEN_NENTRIES) /* 26 */
270 #define AD_ENTRY_LEN_EID 4
271 #define AD_ENTRY_LEN_OFF 4
272 #define AD_ENTRY_LEN_LEN 4
273 #define AD_ENTRY_LEN (AD_ENTRY_LEN_EID + AD_ENTRY_LEN_OFF + AD_ENTRY_LEN_LEN)
274
275 /* Field widths */
276 #define ADEDLEN_NAME 255
277 #define ADEDLEN_COMMENT 200
278 #define ADEDLEN_FILEI 16
279 #define ADEDLEN_FINDERI 32
280 #define ADEDLEN_FILEDATESI 16
281 #define ADEDLEN_SHORTNAME 12 /* length up to 8.3 */
282 #define ADEDLEN_AFPFILEI 4
283 #define ADEDLEN_MACFILEI 4
284 #define ADEDLEN_PRODOSFILEI 8
285 #define ADEDLEN_MSDOSFILEI 2
286 #define ADEDLEN_DID 4
287 #define ADEDLEN_PRIVDEV 8
288 #define ADEDLEN_PRIVINO 8
289 #define ADEDLEN_PRIVSYN 8
290 #define ADEDLEN_PRIVID 4
291
292 /* Offsets */
293 #define ADEDOFF_MAGIC 0
294 #define ADEDOFF_VERSION (ADEDOFF_MAGIC + ADEDLEN_MAGIC)
295 #define ADEDOFF_FILLER (ADEDOFF_VERSION + ADEDLEN_VERSION)
296 #define ADEDOFF_NENTRIES (ADEDOFF_FILLER + ADEDLEN_FILLER)
297
298 #define ADEDOFF_FINDERI_XATTR (AD_HEADER_LEN + \
299 (ADEID_NUM_XATTR * AD_ENTRY_LEN))
300 #define ADEDOFF_COMMENT_XATTR (ADEDOFF_FINDERI_XATTR + ADEDLEN_FINDERI)
301 #define ADEDOFF_FILEDATESI_XATTR (ADEDOFF_COMMENT_XATTR + ADEDLEN_COMMENT)
302 #define ADEDOFF_AFPFILEI_XATTR (ADEDOFF_FILEDATESI_XATTR + \
303 ADEDLEN_FILEDATESI)
304 #define ADEDOFF_PRIVDEV_XATTR (ADEDOFF_AFPFILEI_XATTR + ADEDLEN_AFPFILEI)
305 #define ADEDOFF_PRIVINO_XATTR (ADEDOFF_PRIVDEV_XATTR + ADEDLEN_PRIVDEV)
306 #define ADEDOFF_PRIVSYN_XATTR (ADEDOFF_PRIVINO_XATTR + ADEDLEN_PRIVINO)
307 #define ADEDOFF_PRIVID_XATTR (ADEDOFF_PRIVSYN_XATTR + ADEDLEN_PRIVSYN)
308
309 #define ADEDOFF_FINDERI_DOT_UND (AD_HEADER_LEN + \
310 (ADEID_NUM_DOT_UND * AD_ENTRY_LEN))
311 #define ADEDOFF_RFORK_DOT_UND (ADEDOFF_FINDERI_DOT_UND + ADEDLEN_FINDERI)
312
313 #define AD_DATASZ_XATTR (AD_HEADER_LEN + \
314 (ADEID_NUM_XATTR * AD_ENTRY_LEN) + \
315 ADEDLEN_FINDERI + ADEDLEN_COMMENT + \
316 ADEDLEN_FILEDATESI + ADEDLEN_AFPFILEI + \
317 ADEDLEN_PRIVDEV + ADEDLEN_PRIVINO + \
318 ADEDLEN_PRIVSYN + ADEDLEN_PRIVID)
319
320 #if AD_DATASZ_XATTR != 402
321 #error bad size for AD_DATASZ_XATTR
322 #endif
323
324 #define AD_DATASZ_DOT_UND (AD_HEADER_LEN + \
325 (ADEID_NUM_DOT_UND * AD_ENTRY_LEN) + \
326 ADEDLEN_FINDERI)
327 #if AD_DATASZ_DOT_UND != 82
328 #error bad size for AD_DATASZ_DOT_UND
329 #endif
330
331 /*
332 * Sharemode locks fcntl() offsets
333 */
334 #if _FILE_OFFSET_BITS == 64 || defined(HAVE_LARGEFILE)
335 #define AD_FILELOCK_BASE (UINT64_C(0x7FFFFFFFFFFFFFFF) - 9)
336 #else
337 #define AD_FILELOCK_BASE (UINT32_C(0x7FFFFFFF) - 9)
338 #endif
339 #define BYTELOCK_MAX (AD_FILELOCK_BASE - 1)
340
341 #define AD_FILELOCK_OPEN_WR (AD_FILELOCK_BASE + 0)
342 #define AD_FILELOCK_OPEN_RD (AD_FILELOCK_BASE + 1)
343 #define AD_FILELOCK_RSRC_OPEN_WR (AD_FILELOCK_BASE + 2)
344 #define AD_FILELOCK_RSRC_OPEN_RD (AD_FILELOCK_BASE + 3)
345 #define AD_FILELOCK_DENY_WR (AD_FILELOCK_BASE + 4)
346 #define AD_FILELOCK_DENY_RD (AD_FILELOCK_BASE + 5)
347 #define AD_FILELOCK_RSRC_DENY_WR (AD_FILELOCK_BASE + 6)
348 #define AD_FILELOCK_RSRC_DENY_RD (AD_FILELOCK_BASE + 7)
349 #define AD_FILELOCK_OPEN_NONE (AD_FILELOCK_BASE + 8)
350 #define AD_FILELOCK_RSRC_OPEN_NONE (AD_FILELOCK_BASE + 9)
351
352 /* Time stuff we overload the bits a little */
353 #define AD_DATE_CREATE 0
354 #define AD_DATE_MODIFY 4
355 #define AD_DATE_BACKUP 8
356 #define AD_DATE_ACCESS 12
357 #define AD_DATE_MASK (AD_DATE_CREATE | AD_DATE_MODIFY | \
358 AD_DATE_BACKUP | AD_DATE_ACCESS)
359 #define AD_DATE_UNIX (1 << 10)
360 #define AD_DATE_START 0x80000000
361 #define AD_DATE_DELTA 946684800
362 #define AD_DATE_FROM_UNIX(x) (htonl((x) - AD_DATE_DELTA))
363 #define AD_DATE_TO_UNIX(x) (ntohl(x) + AD_DATE_DELTA)
364
365 #define AD_XATTR_HDR_MAGIC 0x41545452 /* 'ATTR' */
366 #define AD_XATTR_MAX_ENTRIES 1024 /* Some arbitrarily enforced limit */
367 #define AD_XATTR_HDR_SIZE 36
368 #define AD_XATTR_MAX_HDR_SIZE 65536
369
370 /* Accessor macros */
371 #define ad_getentrylen(ad,eid) ((ad)->ad_eid[(eid)].ade_len)
372 #define ad_getentryoff(ad,eid) ((ad)->ad_eid[(eid)].ade_off)
373 #define ad_setentrylen(ad,eid,len) ((ad)->ad_eid[(eid)].ade_len = (len))
374 #define ad_setentryoff(ad,eid,off) ((ad)->ad_eid[(eid)].ade_off = (off))
375
376 /*
377 * Both struct ad_xattr_header and struct ad_xattr_entry describe the in memory
378 * representation as well as the on-disk format.
379 *
380 * The ad_xattr_header follows the FinderInfo data in the FinderInfo entry if
381 * the length of the FinderInfo entry is larger then 32 bytes. It is then
382 * preceeded with 2 bytes padding.
383 *
384 * Cf: https://opensource.apple.com/source/xnu/xnu-4570.1.46/bsd/vfs/vfs_xattr.c
385 */
386
387 struct ad_xattr_header {
388 uint32_t adx_magic; /* ATTR_HDR_MAGIC */
389 uint32_t adx_debug_tag; /* for debugging == file id of owning file */
390 uint32_t adx_total_size; /* file offset of end of attribute header + entries + data */
391 uint32_t adx_data_start; /* file offset to attribute data area */
392 uint32_t adx_data_length; /* length of attribute data area */
393 uint32_t adx_reserved[3];
394 uint16_t adx_flags;
395 uint16_t adx_num_attrs;
396 };
397
398 /* On-disk entries are aligned on 4 byte boundaries */
399 struct ad_xattr_entry {
400 uint32_t adx_offset; /* file offset to data */
401 uint32_t adx_length; /* size of attribute data */
402 uint16_t adx_flags;
403 uint8_t adx_namelen; /* included the NULL terminator */
404 char *adx_name; /* NULL-terminated UTF-8 name */
405 };
406
407 struct ad_entry {
408 size_t ade_off;
409 size_t ade_len;
410 };
411
412 struct adouble {
413 files_struct *ad_fsp;
414 bool ad_opened;
415 adouble_type_t ad_type;
416 uint32_t ad_magic;
417 uint32_t ad_version;
418 uint8_t ad_filler[ADEDLEN_FILLER];
419 struct ad_entry ad_eid[ADEID_MAX];
420 char *ad_data;
421 struct ad_xattr_header adx_header;
422 struct ad_xattr_entry *adx_entries;
423 };
424
425 struct ad_entry_order {
426 uint32_t id, offset, len;
427 };
428
429 /* Netatalk AppleDouble metadata xattr */
430 static const
431 struct ad_entry_order entry_order_meta_xattr[ADEID_NUM_XATTR + 1] = {
432 {ADEID_FINDERI, ADEDOFF_FINDERI_XATTR, ADEDLEN_FINDERI},
433 {ADEID_COMMENT, ADEDOFF_COMMENT_XATTR, 0},
434 {ADEID_FILEDATESI, ADEDOFF_FILEDATESI_XATTR, ADEDLEN_FILEDATESI},
435 {ADEID_AFPFILEI, ADEDOFF_AFPFILEI_XATTR, ADEDLEN_AFPFILEI},
436 {ADEID_PRIVDEV, ADEDOFF_PRIVDEV_XATTR, 0},
437 {ADEID_PRIVINO, ADEDOFF_PRIVINO_XATTR, 0},
438 {ADEID_PRIVSYN, ADEDOFF_PRIVSYN_XATTR, 0},
439 {ADEID_PRIVID, ADEDOFF_PRIVID_XATTR, 0},
440 {0, 0, 0}
441 };
442
443 /* AppleDouble resource fork file (the ones prefixed by "._") */
444 static const
445 struct ad_entry_order entry_order_dot_und[ADEID_NUM_DOT_UND + 1] = {
446 {ADEID_FINDERI, ADEDOFF_FINDERI_DOT_UND, ADEDLEN_FINDERI},
447 {ADEID_RFORK, ADEDOFF_RFORK_DOT_UND, 0},
448 {0, 0, 0}
449 };
450
451 /* Conversion from enumerated id to on-disk AppleDouble id */
452 #define AD_EID_DISK(a) (set_eid[a])
453 static const uint32_t set_eid[] = {
454 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
455 AD_DEV, AD_INO, AD_SYN, AD_ID
456 };
457
458 static char empty_resourcefork[] = {
459 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
460 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E,
461 0x54, 0x68, 0x69, 0x73, 0x20, 0x72, 0x65, 0x73,
462 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x66, 0x6F,
463 0x72, 0x6B, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x6E,
464 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x6C, 0x79,
465 0x20, 0x6C, 0x65, 0x66, 0x74, 0x20, 0x62, 0x6C,
466 0x61, 0x6E, 0x6B, 0x20, 0x20, 0x20, 0x00, 0x00,
467 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
468 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
469 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
470 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
471 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
472 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
473 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
474 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
475 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
476 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
477 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
478 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
479 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
480 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 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, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
492 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E,
493 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
494 0x00, 0x1C, 0x00, 0x1E, 0xFF, 0xFF
495 };
496
497 struct fio {
498 /* tcon config handle */
499 struct fruit_config_data *config;
500
501 /* Denote stream type, meta or rsrc */
502 adouble_type_t type;
503
504 /* Whether the create created the stream */
505 bool created;
506
507 /*
508 * AFP_AfpInfo stream created, but not written yet, thus still a fake
509 * pipe fd. This is set to true in fruit_open_meta if there was no
510 * exisiting stream but the caller requested O_CREAT. It is later set to
511 * false when we get a write on the stream that then does open and
512 * create the stream.
513 */
514 bool fake_fd;
515 int flags;
516 int mode;
517 };
518
519 /*
520 * Forward declarations
521 */
522 static struct adouble *ad_init(TALLOC_CTX *ctx,
523 adouble_type_t type);
524 static struct adouble *ad_get(TALLOC_CTX *ctx,
525 vfs_handle_struct *handle,
526 const struct smb_filename *smb_fname,
527 adouble_type_t type);
528 static int ad_set(vfs_handle_struct *handle,
529 struct adouble *ad,
530 const struct smb_filename *smb_fname);
531 static int ad_fset(struct vfs_handle_struct *handle,
532 struct adouble *ad,
533 files_struct *fsp);
534 static int adouble_path(TALLOC_CTX *ctx,
535 const struct smb_filename *smb_fname__in,
536 struct smb_filename **ppsmb_fname_out);
537 static AfpInfo *afpinfo_new(TALLOC_CTX *ctx);
538 static ssize_t afpinfo_pack(const AfpInfo *ai, char *buf);
539 static AfpInfo *afpinfo_unpack(TALLOC_CTX *ctx, const void *data);
540
541
542 /**
543 * Return a pointer to an AppleDouble entry
544 *
545 * Returns NULL if the entry is not present
546 **/
547 static char *ad_get_entry(const struct adouble *ad, int eid)
548 {
549 off_t off = ad_getentryoff(ad, eid);
550 size_t len = ad_getentrylen(ad, eid);
551
552 if (off == 0 || len == 0) {
553 return NULL;
554 }
555
556 return ad->ad_data + off;
557 }
558
559 /**
560 * Get a date
561 **/
562 static int ad_getdate(const struct adouble *ad,
563 unsigned int dateoff,
564 uint32_t *date)
565 {
566 bool xlate = (dateoff & AD_DATE_UNIX);
567 char *p = NULL;
568
569 dateoff &= AD_DATE_MASK;
570 p = ad_get_entry(ad, ADEID_FILEDATESI);
571 if (p == NULL) {
572 return -1;
573 }
574
575 if (dateoff > AD_DATE_ACCESS) {
576 return -1;
577 }
578
579 memcpy(date, p + dateoff, sizeof(uint32_t));
580
581 if (xlate) {
582 *date = AD_DATE_TO_UNIX(*date);
583 }
584 return 0;
585 }
586
587 /**
588 * Set a date
589 **/
590 static int ad_setdate(struct adouble *ad, unsigned int dateoff, uint32_t date)
591 {
592 bool xlate = (dateoff & AD_DATE_UNIX);
593 char *p = NULL;
594
595 p = ad_get_entry(ad, ADEID_FILEDATESI);
596 if (p == NULL) {
597 return -1;
598 }
599
600 dateoff &= AD_DATE_MASK;
601 if (xlate) {
602 date = AD_DATE_FROM_UNIX(date);
603 }
604
605 if (dateoff > AD_DATE_ACCESS) {
606 return -1;
607 }
608
609 memcpy(p + dateoff, &date, sizeof(date));
610
611 return 0;
612 }
613
614
615 /**
616 * Map on-disk AppleDouble id to enumerated id
617 **/
618 static uint32_t get_eid(uint32_t eid)
619 {
620 if (eid <= 15) {
621 return eid;
622 }
623
624 switch (eid) {
625 case AD_DEV:
626 return ADEID_PRIVDEV;
627 case AD_INO:
628 return ADEID_PRIVINO;
629 case AD_SYN:
630 return ADEID_PRIVSYN;
631 case AD_ID:
632 return ADEID_PRIVID;
633 default:
634 break;
635 }
636
637 return 0;
638 }
639
640 /**
641 * Pack AppleDouble structure into data buffer
642 **/
643 static bool ad_pack(struct adouble *ad)
644 {
645 uint32_t eid;
646 uint16_t nent;
647 uint32_t bufsize;
648 uint32_t offset = 0;
649
650 bufsize = talloc_get_size(ad->ad_data);
651 if (bufsize < AD_DATASZ_DOT_UND) {
652 DBG_ERR("bad buffer size [0x%" PRIx32 "]\n", bufsize);
653 return false;
654 }
655
656 if (offset + ADEDLEN_MAGIC < offset ||
657 offset + ADEDLEN_MAGIC >= bufsize) {
658 return false;
659 }
660 RSIVAL(ad->ad_data, offset, ad->ad_magic);
661 offset += ADEDLEN_MAGIC;
662
663 if (offset + ADEDLEN_VERSION < offset ||
664 offset + ADEDLEN_VERSION >= bufsize) {
665 return false;
666 }
667 RSIVAL(ad->ad_data, offset, ad->ad_version);
668 offset += ADEDLEN_VERSION;
669
670 if (offset + ADEDLEN_FILLER < offset ||
671 offset + ADEDLEN_FILLER >= bufsize) {
672 return false;
673 }
674 if (ad->ad_type == ADOUBLE_RSRC) {
675 memcpy(ad->ad_data + offset, AD_FILLER_TAG, ADEDLEN_FILLER);
676 }
677 offset += ADEDLEN_FILLER;
678
679 if (offset + ADEDLEN_NENTRIES < offset ||
680 offset + ADEDLEN_NENTRIES >= bufsize) {
681 return false;
682 }
683 offset += ADEDLEN_NENTRIES;
684
685 for (eid = 0, nent = 0; eid < ADEID_MAX; eid++) {
686 if (ad->ad_eid[eid].ade_off == 0) {
687 /*
688 * ade_off is also used as indicator whether a
689 * specific entry is used or not
690 */
691 continue;
692 }
693
694 if (offset + AD_ENTRY_LEN_EID < offset ||
695 offset + AD_ENTRY_LEN_EID >= bufsize) {
696 return false;
697 }
698 RSIVAL(ad->ad_data, offset, AD_EID_DISK(eid));
699 offset += AD_ENTRY_LEN_EID;
700
701 if (offset + AD_ENTRY_LEN_OFF < offset ||
702 offset + AD_ENTRY_LEN_OFF >= bufsize) {
703 return false;
704 }
705 RSIVAL(ad->ad_data, offset, ad->ad_eid[eid].ade_off);
706 offset += AD_ENTRY_LEN_OFF;
707
708 if (offset + AD_ENTRY_LEN_LEN < offset ||
709 offset + AD_ENTRY_LEN_LEN >= bufsize) {
710 return false;
711 }
712 RSIVAL(ad->ad_data, offset, ad->ad_eid[eid].ade_len);
713 offset += AD_ENTRY_LEN_LEN;
714
715 nent++;
716 }
717
718 if (ADEDOFF_NENTRIES + 2 >= bufsize) {
719 return false;
720 }
721 RSSVAL(ad->ad_data, ADEDOFF_NENTRIES, nent);
722
723 return true;
724 }
725
726 static bool ad_unpack_xattrs(struct adouble *ad)
727 {
728 struct ad_xattr_header *h = &ad->adx_header;
729 const char *p = ad->ad_data;
730 uint32_t hoff;
731 uint32_t i;
732
733 if (ad_getentrylen(ad, ADEID_FINDERI) <= ADEDLEN_FINDERI) {
734 return true;
735 }
736
737 /* 2 bytes padding */
738 hoff = ad_getentryoff(ad, ADEID_FINDERI) + ADEDLEN_FINDERI + 2;
739
740 h->adx_magic = RIVAL(p, hoff + 0);
741 h->adx_debug_tag = RIVAL(p, hoff + 4); /* Not used -> not checked */
742 h->adx_total_size = RIVAL(p, hoff + 8);
743 h->adx_data_start = RIVAL(p, hoff + 12);
744 h->adx_data_length = RIVAL(p, hoff + 16);
745 h->adx_flags = RSVAL(p, hoff + 32); /* Not used -> not checked */
746 h->adx_num_attrs = RSVAL(p, hoff + 34);
747
748 if (h->adx_magic != AD_XATTR_HDR_MAGIC) {
749 DBG_ERR("Bad magic: 0x%" PRIx32 "\n", h->adx_magic);
750 return false;
751 }
752
753 if (h->adx_total_size > ad_getentryoff(ad, ADEID_RFORK)) {
754 DBG_ERR("Bad total size: 0x%" PRIx32 "\n", h->adx_total_size);
755 return false;
756 }
757 if (h->adx_total_size > AD_XATTR_MAX_HDR_SIZE) {
758 DBG_ERR("Bad total size: 0x%" PRIx32 "\n", h->adx_total_size);
759 return false;
760 }
761
762 if (h->adx_data_start < (hoff + AD_XATTR_HDR_SIZE)) {
763 DBG_ERR("Bad start: 0x%" PRIx32 "\n", h->adx_data_start);
764 return false;
765 }
766
767 if ((h->adx_data_start + h->adx_data_length) < h->adx_data_start) {
768 DBG_ERR("Bad length: %" PRIu32 "\n", h->adx_data_length);
769 return false;
770 }
771 if ((h->adx_data_start + h->adx_data_length) >
772 ad->adx_header.adx_total_size)
773 {
774 DBG_ERR("Bad length: %" PRIu32 "\n", h->adx_data_length);
775 return false;
776 }
777
778 if (h->adx_num_attrs > AD_XATTR_MAX_ENTRIES) {
779 DBG_ERR("Bad num xattrs: %" PRIu16 "\n", h->adx_num_attrs);
780 return false;
781 }
782
783 if (h->adx_num_attrs == 0) {
784 return true;
785 }
786
787 ad->adx_entries = talloc_zero_array(
788 ad, struct ad_xattr_entry, h->adx_num_attrs);
789 if (ad->adx_entries == NULL) {
790 return false;
791 }
792
793 hoff += AD_XATTR_HDR_SIZE;
794
795 for (i = 0; i < h->adx_num_attrs; i++) {
796 struct ad_xattr_entry *e = &ad->adx_entries[i];
797
798 hoff = (hoff + 3) & ~3;
799
800 e->adx_offset = RIVAL(p, hoff + 0);
801 e->adx_length = RIVAL(p, hoff + 4);
802 e->adx_flags = RSVAL(p, hoff + 8);
803 e->adx_namelen = *(p + hoff + 10);
804
805 if (e->adx_offset >= ad->adx_header.adx_total_size) {
806 DBG_ERR("Bad adx_offset: %" PRIx32 "\n",
807 e->adx_offset);
808 return false;
809 }
810
811 if ((e->adx_offset + e->adx_length) < e->adx_offset) {
812 DBG_ERR("Bad adx_length: %" PRIx32 "\n",
813 e->adx_length);
814 return false;
815 }
816
817 if ((e->adx_offset + e->adx_length) >
818 ad->adx_header.adx_total_size)
819 {
820 DBG_ERR("Bad adx_length: %" PRIx32 "\n",
821 e->adx_length);
822 return false;
823 }
824
825 if (e->adx_namelen == 0) {
826 DBG_ERR("Bad adx_namelen: %" PRIx32 "\n",
827 e->adx_namelen);
828 return false;
829 }
830 if ((hoff + 11 + e->adx_namelen) < hoff + 11) {
831 DBG_ERR("Bad adx_namelen: %" PRIx32 "\n",
832 e->adx_namelen);
833 return false;
834 }
835 if ((hoff + 11 + e->adx_namelen) >
836 ad->adx_header.adx_data_start)
837 {
838 DBG_ERR("Bad adx_namelen: %" PRIx32 "\n",
839 e->adx_namelen);
840 return false;
841 }
842
843 e->adx_name = talloc_strndup(ad->adx_entries,
844 p + hoff + 11,
845 e->adx_namelen);
846 if (e->adx_name == NULL) {
847 return false;
848 }
849
850 DBG_DEBUG("xattr [%s] offset [0x%x] size [0x%x]\n",
851 e->adx_name, e->adx_offset, e->adx_length);
852 dump_data(10, (uint8_t *)(ad->ad_data + e->adx_offset),
853 e->adx_length);
854
855 hoff += 11 + e->adx_namelen;
856 }
857
858 return true;
859 }
860
861 /**
862 * Unpack an AppleDouble blob into a struct adoble
863 **/
864 static bool ad_unpack(struct adouble *ad, const size_t nentries,
865 size_t filesize)
866 {
867 size_t bufsize = talloc_get_size(ad->ad_data);
868 size_t adentries, i;
869 uint32_t eid, len, off;
870 bool ok;
871
872 /*
873 * The size of the buffer ad->ad_data is checked when read, so
874 * we wouldn't have to check our own offsets, a few extra
875 * checks won't hurt though. We have to check the offsets we
876 * read from the buffer anyway.
877 */
878
879 if (bufsize < (AD_HEADER_LEN + (AD_ENTRY_LEN * nentries))) {
880 DEBUG(1, ("bad size\n"));
881 return false;
882 }
883
884 ad->ad_magic = RIVAL(ad->ad_data, 0);
885 ad->ad_version = RIVAL(ad->ad_data, ADEDOFF_VERSION);
886 if ((ad->ad_magic != AD_MAGIC) || (ad->ad_version != AD_VERSION)) {
887 DEBUG(1, ("wrong magic or version\n"));
888 return false;
889 }
890
891 memcpy(ad->ad_filler, ad->ad_data + ADEDOFF_FILLER, ADEDLEN_FILLER);
892
893 adentries = RSVAL(ad->ad_data, ADEDOFF_NENTRIES);
894 if (adentries != nentries) {
895 DEBUG(1, ("invalid number of entries: %zu\n",
896 adentries));
897 return false;
898 }
899
900 /* now, read in the entry bits */
901 for (i = 0; i < adentries; i++) {
902 eid = RIVAL(ad->ad_data, AD_HEADER_LEN + (i * AD_ENTRY_LEN));
903 eid = get_eid(eid);
904 off = RIVAL(ad->ad_data, AD_HEADER_LEN + (i * AD_ENTRY_LEN) + 4);
905 len = RIVAL(ad->ad_data, AD_HEADER_LEN + (i * AD_ENTRY_LEN) + 8);
906
907 if (!eid || eid >= ADEID_MAX) {
908 DEBUG(1, ("bogus eid %d\n", eid));
909 return false;
910 }
911
912 /*
913 * All entries other than the resource fork are
914 * expected to be read into the ad_data buffer, so
915 * ensure the specified offset is within that bound
916 */
917 if ((off > bufsize) && (eid != ADEID_RFORK)) {
918 DEBUG(1, ("bogus eid %d: off: %" PRIu32 ", len: %" PRIu32 "\n",
919 eid, off, len));
920 return false;
921 }
922
923 /*
924 * All entries besides FinderInfo and resource fork
925 * must fit into the buffer. FinderInfo is special as
926 * it may be larger then the default 32 bytes (if it
927 * contains marshalled xattrs), but we will fixup that
928 * in ad_convert(). And the resource fork is never
929 * accessed directly by the ad_data buf (also see
930 * comment above) anyway.
931 */
932 if ((eid != ADEID_RFORK) &&
933 (eid != ADEID_FINDERI) &&
934 ((off + len) > bufsize)) {
935 DEBUG(1, ("bogus eid %d: off: %" PRIu32 ", len: %" PRIu32 "\n",
936 eid, off, len));
937 return false;
938 }
939
940 /*
941 * That would be obviously broken
942 */
943 if (off > filesize) {
944 DEBUG(1, ("bogus eid %d: off: %" PRIu32 ", len: %" PRIu32 "\n",
945 eid, off, len));
946 return false;
947 }
948
949 /*
950 * Check for any entry that has its end beyond the
951 * filesize.
952 */
953 if (off + len < off) {
954 DEBUG(1, ("offset wrap in eid %d: off: %" PRIu32
955 ", len: %" PRIu32 "\n",
956 eid, off, len));
957 return false;
958
959 }
960 if (off + len > filesize) {
961 /*
962 * If this is the resource fork entry, we fix
963 * up the length, for any other entry we bail
964 * out.
965 */
966 if (eid != ADEID_RFORK) {
967 DEBUG(1, ("bogus eid %d: off: %" PRIu32
968 ", len: %" PRIu32 "\n",
969 eid, off, len));
970 return false;
971 }
972
973 /*
974 * Fixup the resource fork entry by limiting
975 * the size to entryoffset - filesize.
976 */
977 len = filesize - off;
978 DEBUG(1, ("Limiting ADEID_RFORK: off: %" PRIu32
979 ", len: %" PRIu32 "\n", off, len));
980 }
981
982 ad->ad_eid[eid].ade_off = off;
983 ad->ad_eid[eid].ade_len = len;
984 }
985
986 ok = ad_unpack_xattrs(ad);
987 if (!ok) {
988 return false;
989 }
990
991 return true;
992 }
993
994 static bool ad_convert_move_reso(vfs_handle_struct *handle,
995 struct adouble *ad,
996 const struct smb_filename *smb_fname)
997 {
998 char *buf = NULL;
999 size_t rforklen;
1000 size_t rforkoff;
1001 ssize_t n;
1002 int ret;
1003 bool ok;
1004
1005 rforklen = ad_getentrylen(ad, ADEID_RFORK);
1006 if (rforklen == 0) {
1007 return true;
1008 }
1009
1010 buf = talloc_size(ad, rforklen);
1011 if (buf == NULL) {
1012 /*
1013 * This allocates a buffer for reading the resource fork data in
1014 * one big swoop. Resource forks won't be larger then, say, 64
1015 * MB, I swear, so just doing the allocation with the talloc
1016 * limit as safeguard seems safe.
1017 */
1018 DBG_ERR("Failed to allocate %zu bytes for rfork\n",
1019 rforklen);
1020 return false;
1021 }
1022
1023 rforkoff = ad_getentryoff(ad, ADEID_RFORK);
1024
1025 n = SMB_VFS_PREAD(ad->ad_fsp, buf, rforklen, rforkoff);
1026 if (n != rforklen) {
1027 DBG_ERR("Reading %zu bytes from rfork [%s] failed: %s\n",
1028 rforklen, fsp_str_dbg(ad->ad_fsp), strerror(errno));
1029 return false;
1030 }
1031
1032 rforkoff = ADEDOFF_RFORK_DOT_UND;
1033
1034 n = SMB_VFS_PWRITE(ad->ad_fsp, buf, rforklen, rforkoff);
1035 if (n != rforklen) {
1036 DBG_ERR("Writing %zu bytes to rfork [%s] failed: %s\n",
1037 rforklen, fsp_str_dbg(ad->ad_fsp), strerror(errno));
1038 return false;
1039 }
1040
1041 ad_setentryoff(ad, ADEID_RFORK, ADEDOFF_RFORK_DOT_UND);
1042 ok = ad_pack(ad);
1043 if (!ok) {
1044 DBG_WARNING("ad_pack [%s] failed\n", smb_fname->base_name);
1045 return false;
1046 }
1047
1048 ret = ad_fset(handle, ad, ad->ad_fsp);
1049 if (ret != 0) {
1050 DBG_ERR("ad_fset on [%s] failed\n", fsp_str_dbg(ad->ad_fsp));
1051 return false;
1052 }
1053
1054 return true;
1055 }
1056
1057 static bool ad_convert_xattr(vfs_handle_struct *handle,
1058 struct adouble *ad,
1059 const struct smb_filename *smb_fname,
1060 bool *converted_xattr)
1061 {
1062 static struct char_mappings **string_replace_cmaps = NULL;
1063 uint16_t i;
1064 int saved_errno = 0;
1065 NTSTATUS status;
1066 int rc;
1067 bool ok;
1068
1069 *converted_xattr = false;
1070
1071 if (ad_getentrylen(ad, ADEID_FINDERI) == ADEDLEN_FINDERI) {
1072 return true;
1073 }
1074
1075 if (string_replace_cmaps == NULL) {
1076 const char **mappings = NULL;
1077
1078 mappings = str_list_make_v3_const(
1079 talloc_tos(), fruit_catia_maps, NULL);
1080 if (mappings == NULL) {
1081 return false;
1082 }
1083 string_replace_cmaps = string_replace_init_map(mappings);
1084 TALLOC_FREE(mappings);
1085 }
1086
1087 for (i = 0; i < ad->adx_header.adx_num_attrs; i++) {
1088 struct ad_xattr_entry *e = &ad->adx_entries[i];
1089 char *mapped_name = NULL;
1090 char *tmp = NULL;
1091 struct smb_filename *stream_name = NULL;
1092 files_struct *fsp = NULL;
1093 ssize_t nwritten;
1094
1095 status = string_replace_allocate(handle->conn,
1096 e->adx_name,
1097 string_replace_cmaps,
1098 talloc_tos(),
1099 &mapped_name,
1100 vfs_translate_to_windows);
1101 if (!NT_STATUS_IS_OK(status) &&
1102 !NT_STATUS_EQUAL(status, NT_STATUS_NONE_MAPPED))
1103 {
1104 DBG_ERR("string_replace_allocate failed\n");
1105 ok = false;
1106 goto fail;
1107 }
1108
1109 tmp = mapped_name;
1110 mapped_name = talloc_asprintf(talloc_tos(), ":%s", tmp);
1111 TALLOC_FREE(tmp);
1112 if (mapped_name == NULL) {
1113 ok = false;
1114 goto fail;
1115 }
1116
1117 stream_name = synthetic_smb_fname(talloc_tos(),
1118 smb_fname->base_name,
1119 mapped_name,
1120 NULL,
1121 smb_fname->flags);
1122 TALLOC_FREE(mapped_name);
1123 if (stream_name == NULL) {
1124 DBG_ERR("synthetic_smb_fname failed\n");
1125 ok = false;
1126 goto fail;
1127 }
1128
1129 DBG_DEBUG("stream_name: %s\n", smb_fname_str_dbg(stream_name));
1130
1131 status = SMB_VFS_CREATE_FILE(
1132 handle->conn, /* conn */
1133 NULL, /* req */
1134 0, /* root_dir_fid */
1135 stream_name, /* fname */
1136 FILE_GENERIC_WRITE, /* access_mask */
1137 FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */
1138 FILE_OPEN_IF, /* create_disposition */
1139 0, /* create_options */
1140 0, /* file_attributes */
1141 INTERNAL_OPEN_ONLY, /* oplock_request */
1142 NULL, /* lease */
1143 0, /* allocation_size */
1144 0, /* private_flags */
1145 NULL, /* sd */
1146 NULL, /* ea_list */
1147 &fsp, /* result */
1148 NULL, /* psbuf */
1149 NULL, NULL); /* create context */
1150 TALLOC_FREE(stream_name);
1151 if (!NT_STATUS_IS_OK(status)) {
1152 DBG_ERR("SMB_VFS_CREATE_FILE failed\n");
1153 ok = false;
1154 goto fail;
1155 }
1156
1157 nwritten = SMB_VFS_PWRITE(fsp,
1158 ad->ad_data + e->adx_offset,
1159 e->adx_length,
1160 0);
1161 if (nwritten == -1) {
1162 DBG_ERR("SMB_VFS_PWRITE failed\n");
1163 saved_errno = errno;
1164 close_file(NULL, fsp, ERROR_CLOSE);
1165 errno = saved_errno;
1166 ok = false;
1167 goto fail;
1168 }
1169
1170 status = close_file(NULL, fsp, NORMAL_CLOSE);
1171 if (!NT_STATUS_IS_OK(status)) {
1172 ok = false;
1173 goto fail;
1174 }
1175 fsp = NULL;
1176 }
1177
1178 ad_setentrylen(ad, ADEID_FINDERI, ADEDLEN_FINDERI);
1179
1180 ok = ad_pack(ad);
1181 if (!ok) {
1182 DBG_WARNING("ad_pack [%s] failed\n", smb_fname->base_name);
1183 goto fail;
1184 }
1185
1186 rc = ad_fset(handle, ad, ad->ad_fsp);
1187 if (rc != 0) {
1188 DBG_ERR("ad_fset on [%s] failed: %s\n",
1189 fsp_str_dbg(ad->ad_fsp), strerror(errno));
1190 ok = false;
1191 goto fail;
1192 }
1193
1194 ok = ad_convert_move_reso(handle, ad, smb_fname);
1195 if (!ok) {
1196 goto fail;
1197 }
1198
1199 *converted_xattr = true;
1200 ok = true;
1201
1202 fail:
1203 return ok;
1204 }
1205
1206 static bool ad_convert_finderinfo(vfs_handle_struct *handle,
1207 struct adouble *ad,
1208 const struct smb_filename *smb_fname)
1209 {
1210 char *p_ad = NULL;
1211 AfpInfo *ai = NULL;
1212 DATA_BLOB aiblob;
1213 struct smb_filename *stream_name = NULL;
1214 files_struct *fsp = NULL;
1215 size_t size;
1216 ssize_t nwritten;
1217 NTSTATUS status;
1218 int saved_errno = 0;
1219 int cmp;
1220
1221 cmp = memcmp(ad->ad_filler, AD_FILLER_TAG_OSX, ADEDLEN_FILLER);
1222 if (cmp != 0) {
1223 return true;
1224 }
1225
1226 p_ad = ad_get_entry(ad, ADEID_FINDERI);
1227 if (p_ad == NULL) {
1228 return false;
1229 }
1230
1231 ai = afpinfo_new(talloc_tos());
1232 if (ai == NULL) {
1233 return false;
1234 }
1235
1236 memcpy(ai->afpi_FinderInfo, p_ad, ADEDLEN_FINDERI);
1237
1238 aiblob = data_blob_talloc(talloc_tos(), NULL, AFP_INFO_SIZE);
1239 if (aiblob.data == NULL) {
1240 TALLOC_FREE(ai);
1241 return false;
1242 }
1243
1244 size = afpinfo_pack(ai, (char *)aiblob.data);
1245 TALLOC_FREE(ai);
1246 if (size != AFP_INFO_SIZE) {
1247 return false;
1248 }
1249
1250 stream_name = synthetic_smb_fname(talloc_tos(),
1251 smb_fname->base_name,
1252 AFPINFO_STREAM,
1253 NULL,
1254 smb_fname->flags);
1255 if (stream_name == NULL) {
1256 data_blob_free(&aiblob);
1257 DBG_ERR("synthetic_smb_fname failed\n");
1258 return false;
1259 }
1260
1261 DBG_DEBUG("stream_name: %s\n", smb_fname_str_dbg(stream_name));
1262
1263 status = SMB_VFS_CREATE_FILE(
1264 handle->conn, /* conn */
1265 NULL, /* req */
1266 0, /* root_dir_fid */
1267 stream_name, /* fname */
1268 FILE_GENERIC_WRITE, /* access_mask */
1269 FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */
1270 FILE_OPEN_IF, /* create_disposition */
1271 0, /* create_options */
1272 0, /* file_attributes */
1273 INTERNAL_OPEN_ONLY, /* oplock_request */
1274 NULL, /* lease */
1275 0, /* allocation_size */
1276 0, /* private_flags */
1277 NULL, /* sd */
1278 NULL, /* ea_list */
1279 &fsp, /* result */
1280 NULL, /* psbuf */
1281 NULL, NULL); /* create context */
1282 TALLOC_FREE(stream_name);
1283 if (!NT_STATUS_IS_OK(status)) {
1284 DBG_ERR("SMB_VFS_CREATE_FILE failed\n");
1285 return false;
1286 }
1287
1288 nwritten = SMB_VFS_PWRITE(fsp,
1289 aiblob.data,
1290 aiblob.length,
1291 0);
1292 if (nwritten == -1) {
1293 DBG_ERR("SMB_VFS_PWRITE failed\n");
1294 saved_errno = errno;
1295 close_file(NULL, fsp, ERROR_CLOSE);
1296 errno = saved_errno;
1297 return false;
1298 }
1299
1300 status = close_file(NULL, fsp, NORMAL_CLOSE);
1301 if (!NT_STATUS_IS_OK(status)) {
1302 return false;
1303 }
1304 fsp = NULL;
1305
1306 return true;
1307 }
1308
1309 static bool ad_convert_truncate(vfs_handle_struct *handle,
1310 struct adouble *ad,
1311 const struct smb_filename *smb_fname)
1312 {
1313 int rc;
1314 off_t newlen;
1315
1316 newlen = ADEDOFF_RFORK_DOT_UND + ad_getentrylen(ad, ADEID_RFORK);
1317
1318 rc = SMB_VFS_FTRUNCATE(ad->ad_fsp, newlen);
1319 if (rc != 0) {
1320 return false;
1321 }
1322
1323 return true;
1324 }
1325
1326 static bool ad_convert_blank_rfork(vfs_handle_struct *handle,
1327 struct adouble *ad,
1328 bool *blank)
1329 {
1330 struct fruit_config_data *config = NULL;
1331 size_t rforklen = sizeof(empty_resourcefork);
1332 char buf[rforklen];
1333 ssize_t nread;
1334 int cmp;
1335 int rc;
1336 bool ok;
1337
1338 *blank = false;
1339
1340 SMB_VFS_HANDLE_GET_DATA(handle, config,
1341 struct fruit_config_data, return false);
1342
1343 if (!config->wipe_intentionally_left_blank_rfork) {
1344 return true;
1345 }
1346
1347 if (ad_getentrylen(ad, ADEID_RFORK) != rforklen) {
1348 return true;
1349 }
1350
1351 nread = SMB_VFS_PREAD(ad->ad_fsp, buf, rforklen, ADEDOFF_RFORK_DOT_UND);
1352 if (nread != rforklen) {
1353 DBG_ERR("Reading %zu bytes from rfork [%s] failed: %s\n",
1354 rforklen, fsp_str_dbg(ad->ad_fsp), strerror(errno));
1355 return false;
1356 }
1357
1358 cmp = memcmp(buf, empty_resourcefork, rforklen);
1359 if (cmp != 0) {
1360 return true;
1361 }
1362
1363 ad_setentrylen(ad, ADEID_RFORK, 0);
1364 ok = ad_pack(ad);
1365 if (!ok) {
1366 return false;
1367 }
1368
1369 rc = ad_fset(handle, ad, ad->ad_fsp);
1370 if (rc != 0) {
1371 DBG_ERR("ad_fset on [%s] failed\n", fsp_str_dbg(ad->ad_fsp));
1372 return false;
1373 }
1374
1375 *blank = true;
1376 return true;
1377 }
1378
1379 static bool ad_convert_delete_adfile(vfs_handle_struct *handle,
1380 struct adouble *ad,
1381 const struct smb_filename *smb_fname)
1382 {
1383 struct fruit_config_data *config = NULL;
1384 struct smb_filename *ad_name = NULL;
1385 int rc;
1386
1387 if (ad_getentrylen(ad, ADEID_RFORK) > 0) {
1388 return true;
1389 }
1390
1391 SMB_VFS_HANDLE_GET_DATA(handle, config,
1392 struct fruit_config_data, return false);
1393
1394 if (!config->delete_empty_adfiles) {
1395 return true;
1396 }
1397
1398 rc = adouble_path(talloc_tos(), smb_fname, &ad_name);
1399 if (rc != 0) {
1400 return false;
1401 }
1402
1403 rc = SMB_VFS_NEXT_UNLINK(handle, ad_name);
1404 if (rc != 0) {
1405 DBG_ERR("Unlinking [%s] failed: %s\n",
1406 smb_fname_str_dbg(ad_name), strerror(errno));
1407 TALLOC_FREE(ad_name);
1408 return false;
1409 }
1410
1411 DBG_WARNING("Unlinked [%s] after conversion\n", smb_fname_str_dbg(ad_name));
1412 TALLOC_FREE(ad_name);
1413
1414 return true;
1415 }
1416
1417 /**
1418 * Convert from Apple's ._ file to Netatalk
1419 *
1420 * Apple's AppleDouble may contain a FinderInfo entry longer then 32
1421 * bytes containing packed xattrs.
1422 *
1423 * @return -1 in case an error occurred, 0 if no conversion was done, 1
1424 * otherwise
1425 **/
1426 static int ad_convert(struct vfs_handle_struct *handle,
1427 const struct smb_filename *smb_fname)
1428 {
1429 struct adouble *ad = NULL;
1430 bool ok;
1431 bool converted_xattr = false;
1432 bool blank;
1433 int ret;
1434
1435 ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_RSRC);
1436 if (ad == NULL) {
1437 return 0;
1438 }
1439
1440 ok = ad_convert_xattr(handle, ad, smb_fname, &converted_xattr);
1441 if (!ok) {
1442 ret = -1;
1443 goto done;
1444 }
1445
1446 ok = ad_convert_blank_rfork(handle, ad, &blank);
1447 if (!ok) {
1448 ret = -1;
1449 goto done;
1450 }
1451
1452 if (converted_xattr || blank) {
1453 ok = ad_convert_truncate(handle, ad, smb_fname);
1454 if (!ok) {
1455 ret = -1;
1456 goto done;
1457 }
1458 }
1459
1460 ok = ad_convert_finderinfo(handle, ad, smb_fname);
1461 if (!ok) {
1462 DBG_ERR("Failed to convert [%s]\n",
1463 smb_fname_str_dbg(smb_fname));
1464 ret = -1;
1465 goto done;
1466 }
1467
1468 ok = ad_convert_delete_adfile(handle, ad, smb_fname);
1469 if (!ok) {
1470 ret = -1;
1471 goto done;
1472 }
1473
1474 ret = 0;
1475 done:
1476 TALLOC_FREE(ad);
1477 return ret;
1478 }
1479
1480 /**
1481 * Read and parse Netatalk AppleDouble metadata xattr
1482 **/
1483 static ssize_t ad_read_meta(vfs_handle_struct *handle,
1484 struct adouble *ad,
1485 const struct smb_filename *smb_fname)
1486 {
1487 int rc = 0;
1488 ssize_t ealen;
1489 bool ok;
1490
1491 DEBUG(10, ("reading meta xattr for %s\n", smb_fname->base_name));
1492
1493 ealen = SMB_VFS_GETXATTR(handle->conn, smb_fname,
1494 AFPINFO_EA_NETATALK, ad->ad_data,
1495 AD_DATASZ_XATTR);
1496 if (ealen == -1) {
1497 switch (errno) {
1498 case ENOATTR:
1499 case ENOENT:
1500 if (errno == ENOATTR) {
1501 errno = ENOENT;
1502 }
1503 rc = -1;
1504 goto exit;
1505 default:
1506 DEBUG(2, ("error reading meta xattr: %s\n",
1507 strerror(errno)));
1508 rc = -1;
1509 goto exit;
1510 }
1511 }
1512 if (ealen != AD_DATASZ_XATTR) {
1513 DEBUG(2, ("bad size %zd\n", ealen));
1514 errno = EINVAL;
1515 rc = -1;
1516 goto exit;
1517 }
1518
1519 /* Now parse entries */
1520 ok = ad_unpack(ad, ADEID_NUM_XATTR, AD_DATASZ_XATTR);
1521 if (!ok) {
1522 DEBUG(2, ("invalid AppleDouble metadata xattr\n"));
1523 errno = EINVAL;
1524 rc = -1;
1525 goto exit;
1526 }
1527
1528 if (!ad_getentryoff(ad, ADEID_FINDERI)
1529 || !ad_getentryoff(ad, ADEID_COMMENT)
1530 || !ad_getentryoff(ad, ADEID_FILEDATESI)
1531 || !ad_getentryoff(ad, ADEID_AFPFILEI)
1532 || !ad_getentryoff(ad, ADEID_PRIVDEV)
1533 || !ad_getentryoff(ad, ADEID_PRIVINO)
1534 || !ad_getentryoff(ad, ADEID_PRIVSYN)
1535 || !ad_getentryoff(ad, ADEID_PRIVID)) {
1536 DEBUG(2, ("invalid AppleDouble metadata xattr\n"));
1537 errno = EINVAL;
1538 rc = -1;
1539 goto exit;
1540 }
1541
1542 exit:
1543 DEBUG(10, ("reading meta xattr for %s, rc: %d\n",
1544 smb_fname->base_name, rc));
1545
1546 if (rc != 0) {
1547 ealen = -1;
1548 if (errno == EINVAL) {
1549 become_root();
1550 (void)SMB_VFS_REMOVEXATTR(handle->conn,
1551 smb_fname,
1552 AFPINFO_EA_NETATALK);
1553 unbecome_root();
1554 errno = ENOENT;
1555 }
1556 }
1557 return ealen;
1558 }
1559
1560 static int ad_open_rsrc(vfs_handle_struct *handle,
1561 const struct smb_filename *smb_fname,
1562 int flags,
1563 mode_t mode,
1564 files_struct **_fsp)
1565 {
1566 int ret;
1567 struct smb_filename *adp_smb_fname = NULL;
1568 files_struct *fsp = NULL;
1569 uint32_t access_mask;
1570 uint32_t share_access;
1571 uint32_t create_disposition;
1572 NTSTATUS status;
1573
1574 ret = adouble_path(talloc_tos(), smb_fname, &adp_smb_fname);
1575 if (ret != 0) {
1576 return -1;
1577 }
1578
1579 ret = SMB_VFS_STAT(handle->conn, adp_smb_fname);
1580 if (ret != 0) {
1581 TALLOC_FREE(adp_smb_fname);
1582 return -1;
1583 }
1584
1585 access_mask = FILE_GENERIC_READ;
1586 share_access = FILE_SHARE_READ | FILE_SHARE_WRITE;
1587 create_disposition = FILE_OPEN;
1588
1589 if (flags & O_RDWR) {
1590 access_mask |= FILE_GENERIC_WRITE;
1591 share_access &= ~FILE_SHARE_WRITE;
1592 }
1593
1594 status = SMB_VFS_CREATE_FILE(
1595 handle->conn, /* conn */
1596 NULL, /* req */
1597 0, /* root_dir_fid */
1598 adp_smb_fname,
1599 access_mask,
1600 share_access,
1601 create_disposition,
1602 0, /* create_options */
1603 0, /* file_attributes */
1604 INTERNAL_OPEN_ONLY, /* oplock_request */
1605 NULL, /* lease */
1606 0, /* allocation_size */
1607 0, /* private_flags */
1608 NULL, /* sd */
1609 NULL, /* ea_list */
1610 &fsp,
1611 NULL, /* psbuf */
1612 NULL, NULL); /* create context */
1613 TALLOC_FREE(adp_smb_fname);
1614 if (!NT_STATUS_IS_OK(status)) {
1615 DBG_ERR("SMB_VFS_CREATE_FILE failed\n");
1616 return -1;
1617 }
1618
1619 *_fsp = fsp;
1620 return 0;
1621 }
1622
1623 /*
1624 * Here's the deal: for ADOUBLE_META we can do without an fd as we can issue
1625 * path based xattr calls. For ADOUBLE_RSRC however we need a full-fledged fd
1626 * for file IO on the ._ file.
1627 */
1628 static int ad_open(vfs_handle_struct *handle,
1629 struct adouble *ad,
1630 files_struct *fsp,
1631 const struct smb_filename *smb_fname,
1632 int flags,
1633 mode_t mode)
1634 {
1635 int ret;
1636
1637 DBG_DEBUG("Path [%s] type [%s]\n", smb_fname->base_name,
1638 ad->ad_type == ADOUBLE_META ? "meta" : "rsrc");
1639
1640 if (ad->ad_type == ADOUBLE_META) {
1641 return 0;
1642 }
1643
1644 if (fsp != NULL) {
1645 ad->ad_fsp = fsp;
1646 ad->ad_opened = false;
1647 return 0;
1648 }
1649
1650 ret = ad_open_rsrc(handle, smb_fname, flags, mode, &ad->ad_fsp);
1651 if (ret != 0) {
1652 return -1;
1653 }
1654 ad->ad_opened = true;
1655
1656 DBG_DEBUG("Path [%s] type [%s]\n",
1657 smb_fname->base_name,
1658 ad->ad_type == ADOUBLE_META ? "meta" : "rsrc");
1659
1660 return 0;
1661 }
1662
1663 static ssize_t ad_read_rsrc_adouble(vfs_handle_struct *handle,
1664 struct adouble *ad,
1665 const struct smb_filename *smb_fname)
1666 {
1667 char *p_ad = NULL;
1668 size_t size;
1669 ssize_t len;
1670 int ret;
1671 bool ok;
1672
1673 ret = SMB_VFS_NEXT_FSTAT(handle, ad->ad_fsp, &ad->ad_fsp->fsp_name->st);
1674 if (ret != 0) {
1675 DBG_ERR("fstat [%s] failed: %s\n",
1676 fsp_str_dbg(ad->ad_fsp), strerror(errno));
1677 return -1;
1678 }
1679
1680 /*
1681 * AppleDouble file header content and size, two cases:
1682 *
1683 * - without xattrs it is exactly AD_DATASZ_DOT_UND (82) bytes large
1684 * - with embedded xattrs it can be larger, up to AD_XATTR_MAX_HDR_SIZE
1685 *
1686 * Read as much as we can up to AD_XATTR_MAX_HDR_SIZE.
1687 */
1688 size = ad->ad_fsp->fsp_name->st.st_ex_size;
1689 if (size > talloc_array_length(ad->ad_data)) {
1690 if (size > AD_XATTR_MAX_HDR_SIZE) {
1691 size = AD_XATTR_MAX_HDR_SIZE;
1692 }
1693 p_ad = talloc_realloc(ad, ad->ad_data, char, size);
1694 if (p_ad == NULL) {
1695 return -1;
1696 }
1697 ad->ad_data = p_ad;
1698 }
1699
1700 len = SMB_VFS_NEXT_PREAD(handle, ad->ad_fsp, ad->ad_data, talloc_array_length(ad->ad_data), 0);
1701 if (len != talloc_array_length(ad->ad_data)) {
1702 DBG_NOTICE("%s %s: bad size: %zd\n",
1703 smb_fname->base_name, strerror(errno), len);
1704 return -1;
1705 }
1706
1707 /* Now parse entries */
1708 ok = ad_unpack(ad, ADEID_NUM_DOT_UND, size);
1709 if (!ok) {
1710 DBG_ERR("invalid AppleDouble resource %s\n",
1711 smb_fname->base_name);
1712 errno = EINVAL;
1713 return -1;
1714 }
1715
1716 if ((ad_getentryoff(ad, ADEID_FINDERI) != ADEDOFF_FINDERI_DOT_UND)
1717 || (ad_getentrylen(ad, ADEID_FINDERI) < ADEDLEN_FINDERI)
1718 || (ad_getentryoff(ad, ADEID_RFORK) < ADEDOFF_RFORK_DOT_UND)) {
1719 DBG_ERR("invalid AppleDouble resource %s\n",
1720 smb_fname->base_name);
1721 errno = EINVAL;
1722 return -1;
1723 }
1724
1725 return len;
1726 }
1727
1728 /**
1729 * Read and parse resource fork, either ._ AppleDouble file or xattr
1730 **/
1731 static ssize_t ad_read_rsrc(vfs_handle_struct *handle,
1732 struct adouble *ad,
1733 const struct smb_filename *smb_fname)
1734 {
1735 return ad_read_rsrc_adouble(handle, ad, smb_fname);
1736 }
1737
1738 /**
1739 * Read and unpack an AppleDouble metadata xattr or resource
1740 **/
1741 static ssize_t ad_read(vfs_handle_struct *handle,
1742 struct adouble *ad,
1743 const struct smb_filename *smb_fname)
1744 {
1745 switch (ad->ad_type) {
1746 case ADOUBLE_META:
1747 return ad_read_meta(handle, ad, smb_fname);
1748 case ADOUBLE_RSRC:
1749 return ad_read_rsrc(handle, ad, smb_fname);
1750 default:
1751 return -1;
1752 }
1753 }
1754
1755 static int adouble_destructor(struct adouble *ad)
1756 {
1757 NTSTATUS status;
1758
1759 if (!ad->ad_opened) {
1760 return 0;
1761 }
1762
1763 SMB_ASSERT(ad->ad_fsp != NULL);
1764
1765 status = close_file(NULL, ad->ad_fsp, NORMAL_CLOSE);
1766 if (!NT_STATUS_IS_OK(status)) {
1767 DBG_ERR("Closing [%s] failed: %s\n",
1768 fsp_str_dbg(ad->ad_fsp), nt_errstr(status));
1769 }
1770
1771 return 0;
1772 }
1773
1774 /**
1775 * Allocate a struct adouble without initialiing it
1776 *
1777 * The struct is either hang of the fsp extension context or if fsp is
1778 * NULL from ctx.
1779 *
1780 * @param[in] ctx talloc context
1781 * @param[in] handle vfs handle
1782 * @param[in] type type of AppleDouble, ADOUBLE_META or ADOUBLE_RSRC
1783 *
1784 * @return adouble handle
1785 **/
1786 static struct adouble *ad_alloc(TALLOC_CTX *ctx,
1787 adouble_type_t type)
1788 {
1789 int rc = 0;
1790 size_t adsize = 0;
1791 struct adouble *ad;
1792
1793 switch (type) {
1794 case ADOUBLE_META:
1795 adsize = AD_DATASZ_XATTR;
1796 break;
1797 case ADOUBLE_RSRC:
1798 adsize = AD_DATASZ_DOT_UND;
1799 break;
1800 default:
1801 return NULL;
1802 }
1803
1804 ad = talloc_zero(ctx, struct adouble);
1805 if (ad == NULL) {
1806 rc = -1;
1807 goto exit;
1808 }
1809
1810 if (adsize) {
1811 ad->ad_data = talloc_zero_array(ad, char, adsize);
1812 if (ad->ad_data == NULL) {
1813 rc = -1;
1814 goto exit;
1815 }
1816 }
1817
1818 ad->ad_type = type;
1819 ad->ad_magic = AD_MAGIC;
1820 ad->ad_version = AD_VERSION;
1821
1822 talloc_set_destructor(ad, adouble_destructor);
1823
1824 exit:
1825 if (rc != 0) {
1826 TALLOC_FREE(ad);
1827 }
1828 return ad;
1829 }
1830
1831 /**
1832 * Allocate and initialize a new struct adouble
1833 *
1834 * @param[in] ctx talloc context
1835 * @param[in] type type of AppleDouble, ADOUBLE_META or ADOUBLE_RSRC
1836 *
1837 * @return adouble handle, initialized
1838 **/
1839 static struct adouble *ad_init(TALLOC_CTX *ctx,
1840 adouble_type_t type)
1841 {
1842 int rc = 0;
1843 const struct ad_entry_order *eid;
1844 struct adouble *ad = NULL;
1845 time_t t = time(NULL);
1846
1847 switch (type) {
1848 case ADOUBLE_META:
1849 eid = entry_order_meta_xattr;
1850 break;
1851 case ADOUBLE_RSRC:
1852 eid = entry_order_dot_und;
1853 break;
1854 default:
1855 return NULL;
1856 }
1857
1858 ad = ad_alloc(ctx, type);
1859 if (ad == NULL) {
1860 return NULL;
1861 }
1862
1863 while (eid->id) {
1864 ad->ad_eid[eid->id].ade_off = eid->offset;
1865 ad->ad_eid[eid->id].ade_len = eid->len;
1866 eid++;
1867 }
1868
1869 /* put something sane in the date fields */
1870 ad_setdate(ad, AD_DATE_CREATE | AD_DATE_UNIX, t);
1871 ad_setdate(ad, AD_DATE_MODIFY | AD_DATE_UNIX, t);
1872 ad_setdate(ad, AD_DATE_ACCESS | AD_DATE_UNIX, t);
1873 ad_setdate(ad, AD_DATE_BACKUP, htonl(AD_DATE_START));
1874
1875 if (rc != 0) {
1876 TALLOC_FREE(ad);
1877 }
1878 return ad;
1879 }
1880
1881 static struct adouble *ad_get_internal(TALLOC_CTX *ctx,
1882 vfs_handle_struct *handle,
1883 files_struct *fsp,
1884 const struct smb_filename *smb_fname,
1885 adouble_type_t type)
1886 {
1887 int rc = 0;
1888 ssize_t len;
1889 struct adouble *ad = NULL;
1890 int mode;
1891
1892 if (fsp != NULL) {
1893 smb_fname = fsp->base_fsp->fsp_name;
1894 }
1895
1896 DEBUG(10, ("ad_get(%s) called for %s\n",
1897 type == ADOUBLE_META ? "meta" : "rsrc",
1898 smb_fname->base_name));
1899
1900 ad = ad_alloc(ctx, type);
1901 if (ad == NULL) {
1902 rc = -1;
1903 goto exit;
1904 }
1905
1906 /* Try rw first so we can use the fd in ad_convert() */
1907 mode = O_RDWR;
1908
1909 rc = ad_open(handle, ad, fsp, smb_fname, mode, 0);
1910 if (rc == -1 && ((errno == EROFS) || (errno == EACCES))) {
1911 mode = O_RDONLY;
1912 rc = ad_open(handle, ad, fsp, smb_fname, mode, 0);
1913 }
1914 if (rc == -1) {
1915 DBG_DEBUG("ad_open [%s] error [%s]\n",
1916 smb_fname->base_name, strerror(errno));
1917 goto exit;
1918
1919 }
1920
1921 len = ad_read(handle, ad, smb_fname);
1922 if (len == -1) {
1923 DEBUG(10, ("error reading AppleDouble for %s\n",
1924 smb_fname->base_name));
1925 rc = -1;
1926 goto exit;
1927 }
1928
1929 exit:
1930 DEBUG(10, ("ad_get(%s) for %s returning %d\n",
1931 type == ADOUBLE_META ? "meta" : "rsrc",
1932 smb_fname->base_name, rc));
1933
1934 if (rc != 0) {
1935 TALLOC_FREE(ad);
1936 }
1937 return ad;
1938 }
1939
1940 /**
1941 * Return AppleDouble data for a file
1942 *
1943 * @param[in] ctx talloc context
1944 * @param[in] handle vfs handle
1945 * @param[in] smb_fname pathname to file or directory
1946 * @param[in] type type of AppleDouble, ADOUBLE_META or ADOUBLE_RSRC
1947 *
1948 * @return talloced struct adouble or NULL on error
1949 **/
1950 static struct adouble *ad_get(TALLOC_CTX *ctx,
1951 vfs_handle_struct *handle,
1952 const struct smb_filename *smb_fname,
1953 adouble_type_t type)
1954 {
1955 return ad_get_internal(ctx, handle, NULL, smb_fname, type);
1956 }
1957
1958 /**
1959 * Return AppleDouble data for a file
1960 *
1961 * @param[in] ctx talloc context
1962 * @param[in] handle vfs handle
1963 * @param[in] fsp fsp to use for IO
1964 * @param[in] type type of AppleDouble, ADOUBLE_META or ADOUBLE_RSRC
1965 *
1966 * @return talloced struct adouble or NULL on error
1967 **/
1968 static struct adouble *ad_fget(TALLOC_CTX *ctx, vfs_handle_struct *handle,
1969 files_struct *fsp, adouble_type_t type)
1970 {
1971 return ad_get_internal(ctx, handle, fsp, NULL, type);
1972 }
1973
1974 /**
1975 * Set AppleDouble metadata on a file or directory
1976 *
1977 * @param[in] ad adouble handle
1978 *
1979 * @param[in] smb_fname pathname to file or directory
1980 *
1981 * @return status code, 0 means success
1982 **/
1983 static int ad_set(vfs_handle_struct *handle,
1984 struct adouble *ad,
1985 const struct smb_filename *smb_fname)
1986 {
1987 bool ok;
1988 int ret;
1989
1990 DBG_DEBUG("Path [%s]\n", smb_fname->base_name);
1991
1992 if (ad->ad_type != ADOUBLE_META) {
1993 DBG_ERR("ad_set on [%s] used with ADOUBLE_RSRC\n",
1994 smb_fname->base_name);
1995 return -1;
1996 }
1997
1998 ok = ad_pack(ad);
1999 if (!ok) {
2000 return -1;
2001 }
2002
2003 ret = SMB_VFS_SETXATTR(handle->conn,
2004 smb_fname,
2005 AFPINFO_EA_NETATALK,
2006 ad->ad_data,
2007 AD_DATASZ_XATTR, 0);
2008
2009 DBG_DEBUG("Path [%s] ret [%d]\n", smb_fname->base_name, ret);
2010
2011 return ret;
2012 }
2013
2014 /**
2015 * Set AppleDouble metadata on a file or directory
2016 *
2017 * @param[in] ad adouble handle
2018 * @param[in] fsp file handle
2019 *
2020 * @return status code, 0 means success
2021 **/
2022 static int ad_fset(struct vfs_handle_struct *handle,
2023 struct adouble *ad,
2024 files_struct *fsp)
2025 {
2026 int rc = -1;
2027 ssize_t len;
2028 bool ok;
2029
2030 DBG_DEBUG("Path [%s]\n", fsp_str_dbg(fsp));
2031
2032 if ((fsp == NULL)
2033 || (fsp->fh == NULL)
2034 || (fsp->fh->fd == -1))
2035 {
2036 smb_panic("bad fsp");
2037 }
2038
2039 ok = ad_pack(ad);
2040 if (!ok) {
2041 return -1;
2042 }
2043
2044 switch (ad->ad_type) {
2045 case ADOUBLE_META:
2046 rc = SMB_VFS_NEXT_SETXATTR(handle,
2047 fsp->fsp_name,
2048 AFPINFO_EA_NETATALK,
2049 ad->ad_data,
2050 AD_DATASZ_XATTR, 0);
2051 break;
2052
2053 case ADOUBLE_RSRC:
2054 len = SMB_VFS_NEXT_PWRITE(handle,
2055 fsp,
2056 ad->ad_data,
2057 AD_DATASZ_DOT_UND,
2058 0);
2059 if (len != AD_DATASZ_DOT_UND) {
2060 DBG_ERR("short write on %s: %zd", fsp_str_dbg(fsp), len);
2061 return -1;
2062 }
2063 rc = 0;
2064 break;
2065
2066 default:
2067 return -1;
2068 }
2069
2070 DBG_DEBUG("Path [%s] rc [%d]\n", fsp_str_dbg(fsp), rc);
2071
2072 return rc;
2073 }
2074
2075 /*****************************************************************************
2076 * Helper functions
2077 *****************************************************************************/
2078
2079 static bool is_afpinfo_stream(const struct smb_filename *smb_fname)
2080 {
2081 if (strncasecmp_m(smb_fname->stream_name,
2082 AFPINFO_STREAM_NAME,
2083 strlen(AFPINFO_STREAM_NAME)) == 0) {
2084 return true;
2085 }
2086 return false;
2087 }
2088
2089 static bool is_afpresource_stream(const struct smb_filename *smb_fname)
2090 {
2091 if (strncasecmp_m(smb_fname->stream_name,
2092 AFPRESOURCE_STREAM_NAME,
2093 strlen(AFPRESOURCE_STREAM_NAME)) == 0) {
2094 return true;
2095 }
2096 return false;
2097 }
2098
2099 /**
2100 * Test whether stream is an Apple stream.
2101 **/
2102 static bool is_apple_stream(const struct smb_filename *smb_fname)
2103 {
2104 if (is_afpinfo_stream(smb_fname)) {
2105 return true;
2106 }
2107 if (is_afpresource_stream(smb_fname)) {
2108 return true;
2109 }
2110 return false;
2111 }
2112
2113 static bool is_adouble_file(const char *path)
2114 {
2115 const char *p = NULL;
2116 int match;
2117
2118 p = strrchr(path, '/');
2119 if (p == NULL) {
2120 p = path;
2121 } else {
2122 p++;
2123 }
2124
2125 match = strncmp(p,
2126 ADOUBLE_NAME_PREFIX,
2127 strlen(ADOUBLE_NAME_PREFIX));
2128 if (match != 0) {
2129 return false;
2130 }
2131 return true;
2132 }
2133
2134 /**
2135 * Initialize config struct from our smb.conf config parameters
2136 **/
2137 static int init_fruit_config(vfs_handle_struct *handle)
2138 {
2139 struct fruit_config_data *config;
2140 int enumval;
2141 const char *tm_size_str = NULL;
2142
2143 config = talloc_zero(handle->conn, struct fruit_config_data);
2144 if (!config) {
2145 DEBUG(1, ("talloc_zero() failed\n"));
2146 errno = ENOMEM;
2147 return -1;
2148 }
2149
2150 /*
2151 * Versions up to Samba 4.5.x had a spelling bug in the
2152 * fruit:resource option calling lp_parm_enum with
2153 * "res*s*ource" (ie two s).
2154 *
2155 * In Samba 4.6 we accept both the wrong and the correct
2156 * spelling, in Samba 4.7 the bad spelling will be removed.
2157 */
2158 enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
2159 "ressource", fruit_rsrc, FRUIT_RSRC_ADFILE);
2160 if (enumval == -1) {
2161 DEBUG(1, ("value for %s: resource type unknown\n",
2162 FRUIT_PARAM_TYPE_NAME));
2163 return -1;
2164 }
2165 config->rsrc = (enum fruit_rsrc)enumval;
2166
2167 enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
2168 "resource", fruit_rsrc, enumval);
2169 if (enumval == -1) {
2170 DEBUG(1, ("value for %s: resource type unknown\n",
2171 FRUIT_PARAM_TYPE_NAME));
2172 return -1;
2173 }
2174 config->rsrc = (enum fruit_rsrc)enumval;
2175
2176 enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
2177 "metadata", fruit_meta, FRUIT_META_NETATALK);
2178 if (enumval == -1) {
2179 DEBUG(1, ("value for %s: metadata type unknown\n",
2180 FRUIT_PARAM_TYPE_NAME));
2181 return -1;
2182 }
2183 config->meta = (enum fruit_meta)enumval;
2184
2185 enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
2186 "locking", fruit_locking, FRUIT_LOCKING_NONE);
2187 if (enumval == -1) {
2188 DEBUG(1, ("value for %s: locking type unknown\n",
2189 FRUIT_PARAM_TYPE_NAME));
2190 return -1;
2191 }
2192 config->locking = (enum fruit_locking)enumval;
2193
2194 enumval = lp_parm_enum(SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
2195 "encoding", fruit_encoding, FRUIT_ENC_PRIVATE);
2196 if (enumval == -1) {
2197 DEBUG(1, ("value for %s: encoding type unknown\n",
2198 FRUIT_PARAM_TYPE_NAME));
2199 return -1;
2200 }
2201 config->encoding = (enum fruit_encoding)enumval;
2202
2203 if (config->rsrc == FRUIT_RSRC_ADFILE) {
2204 config->veto_appledouble = lp_parm_bool(SNUM(handle->conn),
2205 FRUIT_PARAM_TYPE_NAME,
2206 "veto_appledouble",
2207 true);
2208 }
2209
2210 config->use_aapl = lp_parm_bool(
2211 -1, FRUIT_PARAM_TYPE_NAME, "aapl", true);
2212
2213 config->time_machine = lp_parm_bool(
2214 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME, "time machine", false);
2215
2216 config->unix_info_enabled = lp_parm_bool(
2217 -1, FRUIT_PARAM_TYPE_NAME, "nfs_aces", true);
2218
2219 config->use_copyfile = lp_parm_bool(-1, FRUIT_PARAM_TYPE_NAME,
2220 "copyfile", false);
2221
2222 config->posix_rename = lp_parm_bool(
2223 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME, "posix_rename", true);
2224
2225 config->aapl_zero_file_id =
2226 lp_parm_bool(-1, FRUIT_PARAM_TYPE_NAME, "zero_file_id", true);
2227
2228 config->readdir_attr_rsize = lp_parm_bool(
2229 SNUM(handle->conn), "readdir_attr", "aapl_rsize", true);
2230
2231 config->readdir_attr_finder_info = lp_parm_bool(
2232 SNUM(handle->conn), "readdir_attr", "aapl_finder_info", true);
2233
2234 config->readdir_attr_max_access = lp_parm_bool(
2235 SNUM(handle->conn), "readdir_attr", "aapl_max_access", true);
2236
2237 config->model = lp_parm_const_string(
2238 -1, FRUIT_PARAM_TYPE_NAME, "model", "MacSamba");
2239
2240 tm_size_str = lp_parm_const_string(
2241 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
2242 "time machine max size", NULL);
2243 if (tm_size_str != NULL) {
2244 config->time_machine_max_size = conv_str_size(tm_size_str);
2245 }
2246
2247 config->wipe_intentionally_left_blank_rfork = lp_parm_bool(
2248 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
2249 "wipe_intentionally_left_blank_rfork", false);
2250
2251 config->delete_empty_adfiles = lp_parm_bool(
2252 SNUM(handle->conn), FRUIT_PARAM_TYPE_NAME,
2253 "delete_empty_adfiles", false);
2254
2255 SMB_VFS_HANDLE_SET_DATA(handle, config,
2256 NULL, struct fruit_config_data,
2257 return -1);
2258
2259 return 0;
2260 }
2261
2262 /**
2263 * Prepend "._" to a basename
2264 * Return a new struct smb_filename with stream_name == NULL.
2265 **/
2266 static int adouble_path(TALLOC_CTX *ctx,
2267 const struct smb_filename *smb_fname_in,
2268 struct smb_filename **pp_smb_fname_out)
2269 {
2270 char *parent;
2271 const char *base;
2272 struct smb_filename *smb_fname = cp_smb_filename(ctx,
2273 smb_fname_in);
2274
2275 if (smb_fname == NULL) {
2276 return -1;
2277 }
2278
2279 /* We need streamname to be NULL */
2280 TALLOC_FREE(smb_fname->stream_name);
2281
2282 /* And we're replacing base_name. */
2283 TALLOC_FREE(smb_fname->base_name);
2284
2285 if (!parent_dirname(smb_fname, smb_fname_in->base_name,
2286 &parent, &base)) {
2287 TALLOC_FREE(smb_fname);
2288 return -1;
2289 }
2290
2291 smb_fname->base_name = talloc_asprintf(smb_fname,
2292 "%s/._%s", parent, base);
2293 if (smb_fname->base_name == NULL) {
2294 TALLOC_FREE(smb_fname);
2295 return -1;
2296 }
2297
2298 *pp_smb_fname_out = smb_fname;
2299
2300 return 0;
2301 }
2302
2303 /**
2304 * Allocate and initialize an AfpInfo struct
2305 **/
2306 static AfpInfo *afpinfo_new(TALLOC_CTX *ctx)
2307 {
2308 AfpInfo *ai = talloc_zero(ctx, AfpInfo);
2309 if (ai == NULL) {
2310 return NULL;
2311 }
2312 ai->afpi_Signature = AFP_Signature;
2313 ai->afpi_Version = AFP_Version;
2314 ai->afpi_BackupTime = AD_DATE_START;
2315 return ai;
2316 }
2317
2318 /**
2319 * Pack an AfpInfo struct into a buffer
2320 *
2321 * Buffer size must be at least AFP_INFO_SIZE
2322 * Returns size of packed buffer
2323 **/
2324 static ssize_t afpinfo_pack(const AfpInfo *ai, char *buf)
2325 {
2326 memset(buf, 0, AFP_INFO_SIZE);
2327
2328 RSIVAL(buf, 0, ai->afpi_Signature);
2329 RSIVAL(buf, 4, ai->afpi_Version);
2330 RSIVAL(buf, 12, ai->afpi_BackupTime);
2331 memcpy(buf + 16, ai->afpi_FinderInfo, sizeof(ai->afpi_FinderInfo));
2332
2333 return AFP_INFO_SIZE;
2334 }
2335
2336 /**
2337 * Unpack a buffer into a AfpInfo structure
2338 *
2339 * Buffer size must be at least AFP_INFO_SIZE
2340 * Returns allocated AfpInfo struct
2341 **/
2342 static AfpInfo *afpinfo_unpack(TALLOC_CTX *ctx, const void *data)
2343 {
2344 AfpInfo *ai = talloc_zero(ctx, AfpInfo);
2345 if (ai == NULL) {
2346 return NULL;
2347 }
2348
2349 ai->afpi_Signature = RIVAL(data, 0);
2350 ai->afpi_Version = RIVAL(data, 4);
2351 ai->afpi_BackupTime = RIVAL(data, 12);
2352 memcpy(ai->afpi_FinderInfo, (const char *)data + 16,
2353 sizeof(ai->afpi_FinderInfo));
2354
2355 if (ai->afpi_Signature != AFP_Signature
2356 || ai->afpi_Version != AFP_Version) {
2357 DEBUG(1, ("Bad AfpInfo signature or version\n"));
2358 TALLOC_FREE(ai);
2359 }
2360
2361 return ai;
2362 }
2363
2364 /**
2365 * Fake an inode number from the md5 hash of the (xattr) name
2366 **/
2367 static SMB_INO_T fruit_inode(const SMB_STRUCT_STAT *sbuf, const char *sname)
2368 {
2369 MD5_CTX ctx;
2370 unsigned char hash[16];
2371 SMB_INO_T result;
2372 char *upper_sname;
2373
2374 DBG_DEBUG("fruit_inode called for %ju/%ju [%s]\n",
2375 (uintmax_t)sbuf->st_ex_dev,
2376 (uintmax_t)sbuf->st_ex_ino, sname);
2377
2378 upper_sname = talloc_strdup_upper(talloc_tos(), sname);
2379 SMB_ASSERT(upper_sname != NULL);
2380
2381 MD5Init(&ctx);
2382 MD5Update(&ctx, (const unsigned char *)&(sbuf->st_ex_dev),
2383 sizeof(sbuf->st_ex_dev));
2384 MD5Update(&ctx, (const unsigned char *)&(sbuf->st_ex_ino),
2385 sizeof(sbuf->st_ex_ino));
2386 MD5Update(&ctx, (unsigned char *)upper_sname,
2387 talloc_get_size(upper_sname)-1);
2388 MD5Final(hash, &ctx);
2389
2390 TALLOC_FREE(upper_sname);
2391
2392 /* Hopefully all the variation is in the lower 4 (or 8) bytes! */
2393 memcpy(&result, hash, sizeof(result));
2394
2395 DBG_DEBUG("fruit_inode \"%s\": ino=%ju\n",
2396 sname, (uintmax_t)result);
2397
2398 return result;
2399 }
2400
2401 static bool add_fruit_stream(TALLOC_CTX *mem_ctx, unsigned int *num_streams,
2402 struct stream_struct **streams,
2403 const char *name, off_t size,
2404 off_t alloc_size)
2405 {
2406 struct stream_struct *tmp;
2407
2408 tmp = talloc_realloc(mem_ctx, *streams, struct stream_struct,
2409 (*num_streams)+1);
2410 if (tmp == NULL) {
2411 return false;
2412 }
2413
2414 tmp[*num_streams].name = talloc_asprintf(tmp, "%s:$DATA", name);
2415 if (tmp[*num_streams].name == NULL) {
2416 return false;
2417 }
2418
2419 tmp[*num_streams].size = size;
2420 tmp[*num_streams].alloc_size = alloc_size;
2421
2422 *streams = tmp;
2423 *num_streams += 1;
2424 return true;
2425 }
2426
2427 static bool filter_empty_rsrc_stream(unsigned int *num_streams,
2428 struct stream_struct **streams)
2429 {
2430 struct stream_struct *tmp = *streams;
2431 unsigned int i;
2432
2433 if (*num_streams == 0) {
2434 return true;
2435 }
2436
2437 for (i = 0; i < *num_streams; i++) {
2438 if (strequal_m(tmp[i].name, AFPRESOURCE_STREAM)) {
2439 break;
2440 }
2441 }
2442
2443 if (i == *num_streams) {
2444 return true;
2445 }
2446
2447 if (tmp[i].size > 0) {
2448 return true;
2449 }
2450
2451 TALLOC_FREE(tmp[i].name);
2452 if (*num_streams - 1 > i) {
2453 memmove(&tmp[i], &tmp[i+1],
2454 (*num_streams - i - 1) * sizeof(struct stream_struct));
2455 }
2456
2457 *num_streams -= 1;
2458 return true;
2459 }
2460
2461 static bool del_fruit_stream(TALLOC_CTX *mem_ctx, unsigned int *num_streams,
2462 struct stream_struct **streams,
2463 const char *name)
2464 {
2465 struct stream_struct *tmp = *streams;
2466 unsigned int i;
2467
2468 if (*num_streams == 0) {
2469 return true;
2470 }
2471
2472 for (i = 0; i < *num_streams; i++) {
2473 if (strequal_m(tmp[i].name, name)) {
2474 break;
2475 }
2476 }
2477
2478 if (i == *num_streams) {
2479 return true;
2480 }
2481
2482 TALLOC_FREE(tmp[i].name);
2483 if (*num_streams - 1 > i) {
2484 memmove(&tmp[i], &tmp[i+1],
2485 (*num_streams - i - 1) * sizeof(struct stream_struct));
2486 }
2487
2488 *num_streams -= 1;
2489 return true;
2490 }
2491
2492 static bool ad_empty_finderinfo(const struct adouble *ad)
2493 {
2494 int cmp;
2495 char emptybuf[ADEDLEN_FINDERI] = {0};
2496 char *fi = NULL;
2497
2498 fi = ad_get_entry(ad, ADEID_FINDERI);
2499 if (fi == NULL) {
2500 DBG_ERR("Missing FinderInfo in struct adouble [%p]\n", ad);
2501 return false;
2502 }
2503
2504 cmp = memcmp(emptybuf, fi, ADEDLEN_FINDERI);
2505 return (cmp == 0);
2506 }
2507
2508 static bool ai_empty_finderinfo(const AfpInfo *ai)
2509 {
2510 int cmp;
2511 char emptybuf[ADEDLEN_FINDERI] = {0};
2512
2513 cmp = memcmp(emptybuf, &ai->afpi_FinderInfo[0], ADEDLEN_FINDERI);
2514 return (cmp == 0);
2515 }
2516
2517 /**
2518 * Update btime with btime from Netatalk
2519 **/
2520 static void update_btime(vfs_handle_struct *handle,
2521 struct smb_filename *smb_fname)
2522 {
2523 uint32_t t;
2524 struct timespec creation_time = {0};
2525 struct adouble *ad;
2526 struct fruit_config_data *config = NULL;
2527
2528 SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
2529 return);
2530
2531 switch (config->meta) {
2532 case FRUIT_META_STREAM:
2533 return;
2534 case FRUIT_META_NETATALK:
2535 /* Handled below */
2536 break;
2537 default:
2538 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
2539 return;
2540 }
2541
2542 ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_META);
2543 if (ad == NULL) {
2544 return;
2545 }
2546 if (ad_getdate(ad, AD_DATE_UNIX | AD_DATE_CREATE, &t) != 0) {
2547 TALLOC_FREE(ad);
2548 return;
2549 }
2550 TALLOC_FREE(ad);
2551
2552 creation_time.tv_sec = convert_uint32_t_to_time_t(t);
2553 update_stat_ex_create_time(&smb_fname->st, creation_time);
2554
2555 return;
2556 }
2557
2558 /**
2559 * Map an access mask to a Netatalk single byte byte range lock
2560 **/
2561 static off_t access_to_netatalk_brl(enum apple_fork fork_type,
2562 uint32_t access_mask)
2563 {
2564 off_t offset;
2565
2566 switch (access_mask) {
2567 case FILE_READ_DATA:
2568 offset = AD_FILELOCK_OPEN_RD;
2569 break;
2570
2571 case FILE_WRITE_DATA:
2572 case FILE_APPEND_DATA:
2573 offset = AD_FILELOCK_OPEN_WR;
2574 break;
2575
2576 default:
2577 offset = AD_FILELOCK_OPEN_NONE;
2578 break;
2579 }
2580
2581 if (fork_type == APPLE_FORK_RSRC) {
2582 if (offset == AD_FILELOCK_OPEN_NONE) {
2583 offset = AD_FILELOCK_RSRC_OPEN_NONE;
2584 } else {
2585 offset += 2;
2586 }
2587 }
2588
2589 return offset;
2590 }
2591
2592 /**
2593 * Map a deny mode to a Netatalk brl
2594 **/
2595 static off_t denymode_to_netatalk_brl(enum apple_fork fork_type,
2596 uint32_t deny_mode)
2597 {
2598 off_t offset;
2599
2600 switch (deny_mode) {
2601 case DENY_READ:
2602 offset = AD_FILELOCK_DENY_RD;
2603 break;
2604
2605 case DENY_WRITE:
2606 offset = AD_FILELOCK_DENY_WR;
2607 break;
2608
2609 default:
2610 smb_panic("denymode_to_netatalk_brl: bad deny mode\n");
2611 }
2612
2613 if (fork_type == APPLE_FORK_RSRC) {
2614 offset += 2;
2615 }
2616
2617 return offset;
2618 }
2619
2620 /**
2621 * Call fcntl() with an exclusive F_GETLK request in order to
2622 * determine if there's an exisiting shared lock
2623 *
2624 * @return true if the requested lock was found or any error occurred
2625 * false if the lock was not found
2626 **/
2627 static bool test_netatalk_lock(files_struct *fsp, off_t in_offset)
2628 {
2629 bool result;
2630 off_t offset = in_offset;
2631 off_t len = 1;
2632 int type = F_WRLCK;
2633 pid_t pid = 0;
2634
2635 result = SMB_VFS_GETLOCK(fsp, &offset, &len, &type, &pid);
2636 if (result == false) {
2637 return true;
2638 }
2639
2640 if (type != F_UNLCK) {
2641 return true;
2642 }
2643
2644 return false;
2645 }
2646
2647 static NTSTATUS fruit_check_access(vfs_handle_struct *handle,
2648 files_struct *fsp,
2649 uint32_t access_mask,
2650 uint32_t share_mode)
2651 {
2652 NTSTATUS status = NT_STATUS_OK;
2653 off_t off;
2654 bool share_for_read = (share_mode & FILE_SHARE_READ);
2655 bool share_for_write = (share_mode & FILE_SHARE_WRITE);
2656 bool netatalk_already_open_for_reading = false;
2657 bool netatalk_already_open_for_writing = false;
2658 bool netatalk_already_open_with_deny_read = false;
2659 bool netatalk_already_open_with_deny_write = false;
2660
2661 /* FIXME: hardcoded data fork, add resource fork */
2662 enum apple_fork fork_type = APPLE_FORK_DATA;
2663
2664 DBG_DEBUG("fruit_check_access: %s, am: %s/%s, sm: 0x%x\n",
2665 fsp_str_dbg(fsp),
2666 access_mask & FILE_READ_DATA ? "READ" :"-",
2667 access_mask & FILE_WRITE_DATA ? "WRITE" : "-",
2668 share_mode);
2669
2670 if (fsp->fh->fd == -1) {
2671 return NT_STATUS_OK;
2672 }
2673
2674 /* Read NetATalk opens and deny modes on the file. */
2675 netatalk_already_open_for_reading = test_netatalk_lock(fsp,
2676 access_to_netatalk_brl(fork_type,
2677 FILE_READ_DATA));
2678
2679 netatalk_already_open_with_deny_read = test_netatalk_lock(fsp,
2680 denymode_to_netatalk_brl(fork_type,
2681 DENY_READ));
2682
2683 netatalk_already_open_for_writing = test_netatalk_lock(fsp,
2684 access_to_netatalk_brl(fork_type,
2685 FILE_WRITE_DATA));
2686
2687 netatalk_already_open_with_deny_write = test_netatalk_lock(fsp,
2688 denymode_to_netatalk_brl(fork_type,
2689 DENY_WRITE));
2690
2691 /* If there are any conflicts - sharing violation. */
2692 if ((access_mask & FILE_READ_DATA) &&
2693 netatalk_already_open_with_deny_read) {
2694 return NT_STATUS_SHARING_VIOLATION;
2695 }
2696
2697 if (!share_for_read &&
2698 netatalk_already_open_for_reading) {
2699 return NT_STATUS_SHARING_VIOLATION;
2700 }
2701
2702 if ((access_mask & FILE_WRITE_DATA) &&
2703 netatalk_already_open_with_deny_write) {
2704 return NT_STATUS_SHARING_VIOLATION;
2705 }
2706
2707 if (!share_for_write &&
2708 netatalk_already_open_for_writing) {
2709 return NT_STATUS_SHARING_VIOLATION;
2710 }
2711
2712 if (!(access_mask & FILE_READ_DATA)) {
2713 /*
2714 * Nothing we can do here, we need read access
2715 * to set locks.
2716 */
2717 return NT_STATUS_OK;
2718 }
2719
2720 /* Set NetAtalk locks matching our access */
2721 if (access_mask & FILE_READ_DATA) {
2722 struct byte_range_lock *br_lck = NULL;
2723
2724 off = access_to_netatalk_brl(fork_type, FILE_READ_DATA);
2725 br_lck = do_lock(
2726 handle->conn->sconn->msg_ctx, fsp,
2727 fsp->op->global->open_persistent_id, 1, off,
2728 READ_LOCK, POSIX_LOCK, false,
2729 &status, NULL);
2730
2731 TALLOC_FREE(br_lck);
2732
2733 if (!NT_STATUS_IS_OK(status)) {
2734 return status;
2735 }
2736 }
2737
2738 if (!share_for_read) {
2739 struct byte_range_lock *br_lck = NULL;
2740
2741 off = denymode_to_netatalk_brl(fork_type, DENY_READ);
2742 br_lck = do_lock(
2743 handle->conn->sconn->msg_ctx, fsp,
2744 fsp->op->global->open_persistent_id, 1, off,
2745 READ_LOCK, POSIX_LOCK, false,
2746 &status, NULL);
2747
2748 TALLOC_FREE(br_lck);
2749
2750 if (!NT_STATUS_IS_OK(status)) {
2751 return status;
2752 }
2753 }
2754
2755 if (access_mask & FILE_WRITE_DATA) {
2756 struct byte_range_lock *br_lck = NULL;
2757
2758 off = access_to_netatalk_brl(fork_type, FILE_WRITE_DATA);
2759 br_lck = do_lock(
2760 handle->conn->sconn->msg_ctx, fsp,
2761 fsp->op->global->open_persistent_id, 1, off,
2762 READ_LOCK, POSIX_LOCK, false,
2763 &status, NULL);
2764
2765 TALLOC_FREE(br_lck);
2766
2767 if (!NT_STATUS_IS_OK(status)) {
2768 return status;
2769 }
2770 }
2771
2772 if (!share_for_write) {
2773 struct byte_range_lock *br_lck = NULL;
2774
2775 off = denymode_to_netatalk_brl(fork_type, DENY_WRITE);
2776 br_lck = do_lock(
2777 handle->conn->sconn->msg_ctx, fsp,
2778 fsp->op->global->open_persistent_id, 1, off,
2779 READ_LOCK, POSIX_LOCK, false,
2780 &status, NULL);
2781
2782 TALLOC_FREE(br_lck);
2783
2784 if (!NT_STATUS_IS_OK(status)) {
2785 return status;
2786 }
2787 }
2788
2789 return NT_STATUS_OK;
2790 }
2791
2792 static NTSTATUS check_aapl(vfs_handle_struct *handle,
2793 struct smb_request *req,
2794 const struct smb2_create_blobs *in_context_blobs,
2795 struct smb2_create_blobs *out_context_blobs)
2796 {
2797 struct fruit_config_data *config;
2798 NTSTATUS status;
2799 struct smb2_create_blob *aapl = NULL;
2800 uint32_t cmd;
2801 bool ok;
2802 uint8_t p[16];
2803 DATA_BLOB blob = data_blob_talloc(req, NULL, 0);
2804 uint64_t req_bitmap, client_caps;
2805 uint64_t server_caps = SMB2_CRTCTX_AAPL_UNIX_BASED;
2806 smb_ucs2_t *model;
2807 size_t modellen;
2808
2809 SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
2810 return NT_STATUS_UNSUCCESSFUL);
2811
2812 if (!config->use_aapl
2813 || in_context_blobs == NULL
2814 || out_context_blobs == NULL) {
2815 return NT_STATUS_OK;
2816 }
2817
2818 aapl = smb2_create_blob_find(in_context_blobs,
2819 SMB2_CREATE_TAG_AAPL);
2820 if (aapl == NULL) {
2821 return NT_STATUS_OK;
2822 }
2823
2824 if (aapl->data.length != 24) {
2825 DEBUG(1, ("unexpected AAPL ctxt length: %ju\n",
2826 (uintmax_t)aapl->data.length));
2827 return NT_STATUS_INVALID_PARAMETER;
2828 }
2829
2830 cmd = IVAL(aapl->data.data, 0);
2831 if (cmd != SMB2_CRTCTX_AAPL_SERVER_QUERY) {
2832 DEBUG(1, ("unsupported AAPL cmd: %d\n", cmd));
2833 return NT_STATUS_INVALID_PARAMETER;
2834 }
2835
2836 req_bitmap = BVAL(aapl->data.data, 8);
2837 client_caps = BVAL(aapl->data.data, 16);
2838
2839 SIVAL(p, 0, SMB2_CRTCTX_AAPL_SERVER_QUERY);
2840 SIVAL(p, 4, 0);
2841 SBVAL(p, 8, req_bitmap);
2842 ok = data_blob_append(req, &blob, p, 16);
2843 if (!ok) {
2844 return NT_STATUS_UNSUCCESSFUL;
2845 }
2846
2847 if (req_bitmap & SMB2_CRTCTX_AAPL_SERVER_CAPS) {
2848 if ((client_caps & SMB2_CRTCTX_AAPL_SUPPORTS_READ_DIR_ATTR) &&
2849 (handle->conn->tcon->compat->fs_capabilities & FILE_NAMED_STREAMS)) {
2850 server_caps |= SMB2_CRTCTX_AAPL_SUPPORTS_READ_DIR_ATTR;
2851 config->readdir_attr_enabled = true;
2852 }
2853
2854 if (config->use_copyfile) {
2855 server_caps |= SMB2_CRTCTX_AAPL_SUPPORTS_OSX_COPYFILE;
2856 config->copyfile_enabled = true;
2857 }
2858
2859 /*
2860 * The client doesn't set the flag, so we can't check
2861 * for it and just set it unconditionally
2862 */
2863 if (config->unix_info_enabled) {
2864 server_caps |= SMB2_CRTCTX_AAPL_SUPPORTS_NFS_ACE;
2865 }
2866
2867 SBVAL(p, 0, server_caps);
2868 ok = data_blob_append(req, &blob, p, 8);
2869 if (!ok) {
2870 return NT_STATUS_UNSUCCESSFUL;
2871 }
2872 }
2873
2874 if (req_bitmap & SMB2_CRTCTX_AAPL_VOLUME_CAPS) {
2875 int val = lp_case_sensitive(SNUM(handle->conn->tcon->compat));
2876 uint64_t caps = 0;
2877
2878 switch (val) {
2879 case Auto:
2880 break;
2881
2882 case True:
2883 caps |= SMB2_CRTCTX_AAPL_CASE_SENSITIVE;
2884 break;
2885
2886 default:
2887 break;
2888 }
2889
2890 if (config->time_machine) {
2891 caps |= SMB2_CRTCTX_AAPL_FULL_SYNC;
2892 }
2893
2894 SBVAL(p, 0, caps);
2895
2896 ok = data_blob_append(req, &blob, p, 8);
2897 if (!ok) {
2898 return NT_STATUS_UNSUCCESSFUL;
2899 }
2900 }
2901
2902 if (req_bitmap & SMB2_CRTCTX_AAPL_MODEL_INFO) {
2903 ok = convert_string_talloc(req,
2904 CH_UNIX, CH_UTF16LE,
2905 config->model, strlen(config->model),
2906 &model, &modellen);
2907 if (!ok) {
2908 return NT_STATUS_UNSUCCESSFUL;
2909 }
2910
2911 SIVAL(p, 0, 0);
2912 SIVAL(p + 4, 0, modellen);
2913 ok = data_blob_append(req, &blob, p, 8);
2914 if (!ok) {
2915 talloc_free(model);
2916 return NT_STATUS_UNSUCCESSFUL;
2917 }
2918
2919 ok = data_blob_append(req, &blob, model, modellen);
2920 talloc_free(model);
2921 if (!ok) {
2922 return NT_STATUS_UNSUCCESSFUL;
2923 }
2924 }
2925
2926 status = smb2_create_blob_add(out_context_blobs,
2927 out_context_blobs,
2928 SMB2_CREATE_TAG_AAPL,
2929 blob);
2930 if (NT_STATUS_IS_OK(status)) {
2931 global_fruit_config.nego_aapl = true;
2932 if (config->aapl_zero_file_id) {
2933 aapl_force_zero_file_id(handle->conn->sconn);
2934 }
2935 }
2936
2937 return status;
2938 }
2939
2940 static bool readdir_attr_meta_finderi_stream(
2941 struct vfs_handle_struct *handle,
2942 const struct smb_filename *smb_fname,
2943 AfpInfo *ai)
2944 {
2945 struct smb_filename *stream_name = NULL;
2946 files_struct *fsp = NULL;
2947 ssize_t nread;
2948 NTSTATUS status;
2949 int ret;
2950 bool ok;
2951 uint8_t buf[AFP_INFO_SIZE];
2952
2953 stream_name = synthetic_smb_fname(talloc_tos(),
2954 smb_fname->base_name,
2955 AFPINFO_STREAM_NAME,
2956 NULL, smb_fname->flags);
2957 if (stream_name == NULL) {
2958 return false;
2959 }
2960
2961 ret = SMB_VFS_STAT(handle->conn, stream_name);
2962 if (ret != 0) {
2963 return false;
2964 }
2965
2966 status = SMB_VFS_CREATE_FILE(
2967 handle->conn, /* conn */
2968 NULL, /* req */
2969 0, /* root_dir_fid */
2970 stream_name, /* fname */
2971 FILE_READ_DATA, /* access_mask */
2972 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
2973 FILE_SHARE_DELETE),
2974 FILE_OPEN, /* create_disposition*/
2975 0, /* create_options */
2976 0, /* file_attributes */
2977 INTERNAL_OPEN_ONLY, /* oplock_request */
2978 NULL, /* lease */
2979 0, /* allocation_size */
2980 0, /* private_flags */
2981 NULL, /* sd */
2982 NULL, /* ea_list */
2983 &fsp, /* result */
2984 NULL, /* pinfo */
2985 NULL, NULL); /* create context */
2986
2987 TALLOC_FREE(stream_name);
2988
2989 if (!NT_STATUS_IS_OK(status)) {
2990 return false;
2991 }
2992
2993 nread = SMB_VFS_PREAD(fsp, &buf[0], AFP_INFO_SIZE, 0);
2994 if (nread != AFP_INFO_SIZE) {
2995 DBG_ERR("short read [%s] [%zd/%d]\n",
2996 smb_fname_str_dbg(stream_name), nread, AFP_INFO_SIZE);
2997 ok = false;
2998 goto fail;
2999 }
3000
3001 memcpy(&ai->afpi_FinderInfo[0], &buf[AFP_OFF_FinderInfo],
3002 AFP_FinderSize);
3003
3004 ok = true;
3005
3006 fail:
3007 if (fsp != NULL) {
3008 close_file(NULL, fsp, NORMAL_CLOSE);
3009 }
3010
3011 return ok;
3012 }
3013
3014 static bool readdir_attr_meta_finderi_netatalk(
3015 struct vfs_handle_struct *handle,
3016 const struct smb_filename *smb_fname,
3017 AfpInfo *ai)
3018 {
3019 struct adouble *ad = NULL;
3020 char *p = NULL;
3021
3022 ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_META);
3023 if (ad == NULL) {
3024 return false;
3025 }
3026
3027 p = ad_get_entry(ad, ADEID_FINDERI);
3028 if (p == NULL) {
3029 DBG_ERR("No ADEID_FINDERI for [%s]\n", smb_fname->base_name);
3030 TALLOC_FREE(ad);
3031 return false;
3032 }
3033
3034 memcpy(&ai->afpi_FinderInfo[0], p, AFP_FinderSize);
3035 TALLOC_FREE(ad);
3036 return true;
3037 }
3038
3039 static bool readdir_attr_meta_finderi(struct vfs_handle_struct *handle,
3040 const struct smb_filename *smb_fname,
3041 struct readdir_attr_data *attr_data)
3042 {
3043 struct fruit_config_data *config = NULL;
3044 uint32_t date_added;
3045 AfpInfo ai = {0};
3046 bool ok;
3047
3048 SMB_VFS_HANDLE_GET_DATA(handle, config,
3049 struct fruit_config_data,
3050 return false);
3051
3052 switch (config->meta) {
3053 case FRUIT_META_NETATALK:
3054 ok = readdir_attr_meta_finderi_netatalk(
3055 handle, smb_fname, &ai);
3056 break;
3057
3058 case FRUIT_META_STREAM:
3059 ok = readdir_attr_meta_finderi_stream(
3060 handle, smb_fname, &ai);
3061 break;
3062
3063 default:
3064 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
3065 return false;
3066 }
3067
3068 if (!ok) {
3069 /* Don't bother with errors, it's likely ENOENT */
3070 return true;
3071 }
3072
3073 if (S_ISREG(smb_fname->st.st_ex_mode)) {
3074 /* finder_type */
3075 memcpy(&attr_data->attr_data.aapl.finder_info[0],
3076 &ai.afpi_FinderInfo[0], 4);
3077
3078 /* finder_creator */
3079 memcpy(&attr_data->attr_data.aapl.finder_info[0] + 4,
3080 &ai.afpi_FinderInfo[4], 4);
3081 }
3082
3083 /* finder_flags */
3084 memcpy(&attr_data->attr_data.aapl.finder_info[0] + 8,
3085 &ai.afpi_FinderInfo[8], 2);
3086
3087 /* finder_ext_flags */
3088 memcpy(&attr_data->attr_data.aapl.finder_info[0] + 10,
3089 &ai.afpi_FinderInfo[24], 2);
3090
3091 /* creation date */
3092 date_added = convert_time_t_to_uint32_t(
3093 smb_fname->st.st_ex_btime.tv_sec - AD_DATE_DELTA);
3094
3095 RSIVAL(&attr_data->attr_data.aapl.finder_info[0], 12, date_added);
3096
3097 return true;
3098 }
3099
3100 static uint64_t readdir_attr_rfork_size_adouble(
3101 struct vfs_handle_struct *handle,
3102 const struct smb_filename *smb_fname)
3103 {
3104 struct adouble *ad = NULL;
3105 uint64_t rfork_size;
3106
3107 ad = ad_get(talloc_tos(), handle, smb_fname,
3108 ADOUBLE_RSRC);
3109 if (ad == NULL) {
3110 return 0;
3111 }
3112
3113 rfork_size = ad_getentrylen(ad, ADEID_RFORK);
3114 TALLOC_FREE(ad);
3115
3116 return rfork_size;
3117 }
3118
3119 static uint64_t readdir_attr_rfork_size_stream(
3120 struct vfs_handle_struct *handle,
3121 const struct smb_filename *smb_fname)
3122 {
3123 struct smb_filename *stream_name = NULL;
3124 int ret;
3125 uint64_t rfork_size;
3126
3127 stream_name = synthetic_smb_fname(talloc_tos(),
3128 smb_fname->base_name,
3129 AFPRESOURCE_STREAM_NAME,
3130 NULL, 0);
3131 if (stream_name == NULL) {
3132 return 0;
3133 }
3134
3135 ret = SMB_VFS_STAT(handle->conn, stream_name);
3136 if (ret != 0) {
3137 TALLOC_FREE(stream_name);
3138 return 0;
3139 }
3140
3141 rfork_size = stream_name->st.st_ex_size;
3142 TALLOC_FREE(stream_name);
3143
3144 return rfork_size;
3145 }
3146
3147 static uint64_t readdir_attr_rfork_size(struct vfs_handle_struct *handle,
3148 const struct smb_filename *smb_fname)
3149 {
3150 struct fruit_config_data *config = NULL;
3151 uint64_t rfork_size;
3152
3153 SMB_VFS_HANDLE_GET_DATA(handle, config,
3154 struct fruit_config_data,
3155 return 0);
3156
3157 switch (config->rsrc) {
3158 case FRUIT_RSRC_ADFILE:
3159 rfork_size = readdir_attr_rfork_size_adouble(handle,
3160 smb_fname);
3161 break;
3162
3163 case FRUIT_RSRC_XATTR:
3164 case FRUIT_RSRC_STREAM:
3165 rfork_size = readdir_attr_rfork_size_stream(handle,
3166 smb_fname);
3167 break;
3168
3169 default:
3170 DBG_ERR("Unexpected rsrc config [%d]\n", config->rsrc);
3171 rfork_size = 0;
3172 break;
3173 }
3174
3175 return rfork_size;
3176 }
3177
3178 static NTSTATUS readdir_attr_macmeta(struct vfs_handle_struct *handle,
3179 const struct smb_filename *smb_fname,
3180 struct readdir_attr_data *attr_data)
3181 {
3182 NTSTATUS status = NT_STATUS_OK;
3183 struct fruit_config_data *config = NULL;
3184 bool ok;
3185
3186 SMB_VFS_HANDLE_GET_DATA(handle, config,
3187 struct fruit_config_data,
3188 return NT_STATUS_UNSUCCESSFUL);
3189
3190
3191 /* Ensure we return a default value in the creation_date field */
3192 RSIVAL(&attr_data->attr_data.aapl.finder_info, 12, AD_DATE_START);
3193
3194 /*
3195 * Resource fork length
3196 */
3197
3198 if (config->readdir_attr_rsize) {
3199 uint64_t rfork_size;
3200
3201 rfork_size = readdir_attr_rfork_size(handle, smb_fname);
3202 attr_data->attr_data.aapl.rfork_size = rfork_size;
3203 }
3204
3205 /*
3206 * FinderInfo
3207 */
3208
3209 if (config->readdir_attr_finder_info) {
3210 ok = readdir_attr_meta_finderi(handle, smb_fname, attr_data);
3211 if (!ok) {
3212 status = NT_STATUS_INTERNAL_ERROR;
3213 }
3214 }
3215
3216 return status;
3217 }
3218
3219 static NTSTATUS remove_virtual_nfs_aces(struct security_descriptor *psd)
3220 {
3221 NTSTATUS status;
3222 uint32_t i;
3223
3224 if (psd->dacl == NULL) {
3225 return NT_STATUS_OK;
3226 }
3227
3228 for (i = 0; i < psd->dacl->num_aces; i++) {
3229 /* MS NFS style mode/uid/gid */
3230 int cmp = dom_sid_compare_domain(
3231 &global_sid_Unix_NFS,
3232 &psd->dacl->aces[i].trustee);
3233 if (cmp != 0) {
3234 /* Normal ACE entry. */
3235 continue;
3236 }
3237
3238 /*
3239 * security_descriptor_dacl_del()
3240 * *must* return NT_STATUS_OK as we know
3241 * we have something to remove.
3242 */
3243
3244 status = security_descriptor_dacl_del(psd,
3245 &psd->dacl->aces[i].trustee);
3246 if (!NT_STATUS_IS_OK(status)) {
3247 DBG_WARNING("failed to remove MS NFS style ACE: %s\n",
3248 nt_errstr(status));
3249 return status;
3250 }
3251
3252 /*
3253 * security_descriptor_dacl_del() may delete more
3254 * then one entry subsequent to this one if the
3255 * SID matches, but we only need to ensure that
3256 * we stay looking at the same element in the array.
3257 */
3258 i--;
3259 }
3260 return NT_STATUS_OK;
3261 }
3262
3263 /* Search MS NFS style ACE with UNIX mode */
3264 static NTSTATUS check_ms_nfs(vfs_handle_struct *handle,
3265 files_struct *fsp,
3266 struct security_descriptor *psd,
3267 mode_t *pmode,
3268 bool *pdo_chmod)
3269 {
3270 uint32_t i;
3271 struct fruit_config_data *config = NULL;
3272
3273 *pdo_chmod = false;
3274
3275 SMB_VFS_HANDLE_GET_DATA(handle, config,
3276 struct fruit_config_data,
3277 return NT_STATUS_UNSUCCESSFUL);
3278
3279 if (!global_fruit_config.nego_aapl) {
3280 return NT_STATUS_OK;
3281 }
3282 if (psd->dacl == NULL || !config->unix_info_enabled) {
3283 return NT_STATUS_OK;
3284 }
3285
3286 for (i = 0; i < psd->dacl->num_aces; i++) {
3287 if (dom_sid_compare_domain(
3288 &global_sid_Unix_NFS_Mode,
3289 &psd->dacl->aces[i].trustee) == 0) {
3290 *pmode = (mode_t)psd->dacl->aces[i].trustee.sub_auths[2];
3291 *pmode &= (S_IRWXU | S_IRWXG | S_IRWXO);
3292 *pdo_chmod = true;
3293
3294 DEBUG(10, ("MS NFS chmod request %s, %04o\n",
3295 fsp_str_dbg(fsp), (unsigned)(*pmode)));
3296 break;
3297 }
3298 }
3299
3300 /*
3301 * Remove any incoming virtual ACE entries generated by
3302 * fruit_fget_nt_acl().
3303 */
3304
3305 return remove_virtual_nfs_aces(psd);
3306 }
3307
3308 /****************************************************************************
3309 * VFS ops
3310 ****************************************************************************/
3311
3312 static int fruit_connect(vfs_handle_struct *handle,
3313 const char *service,
3314 const char *user)
3315 {
3316 int rc;
3317 char *list = NULL, *newlist = NULL;
3318 struct fruit_config_data *config;
3319
3320 DEBUG(10, ("fruit_connect\n"));
3321
3322 rc = SMB_VFS_NEXT_CONNECT(handle, service, user);
3323 if (rc < 0) {
3324 return rc;
3325 }
3326
3327 rc = init_fruit_config(handle);
3328 if (rc != 0) {
3329 return rc;
3330 }
3331
3332 SMB_VFS_HANDLE_GET_DATA(handle, config,
3333 struct fruit_config_data, return -1);
3334
3335 if (config->veto_appledouble) {
3336 list = lp_veto_files(talloc_tos(), SNUM(handle->conn));
3337
3338 if (list) {
3339 if (strstr(list, "/" ADOUBLE_NAME_PREFIX "*/") == NULL) {
3340 newlist = talloc_asprintf(
3341 list,
3342 "%s/" ADOUBLE_NAME_PREFIX "*/",
3343 list);
3344 lp_do_parameter(SNUM(handle->conn),
3345 "veto files",
3346 newlist);
3347 }
3348 } else {
3349 lp_do_parameter(SNUM(handle->conn),
3350 "veto files",
3351 "/" ADOUBLE_NAME_PREFIX "*/");
3352 }
3353
3354 TALLOC_FREE(list);
3355 }
3356
3357 if (config->encoding == FRUIT_ENC_NATIVE) {
3358 lp_do_parameter(SNUM(handle->conn),
3359 "catia:mappings",
3360 fruit_catia_maps);
3361 }
3362
3363 if (config->time_machine) {
3364 DBG_NOTICE("Enabling durable handles for Time Machine "
3365 "support on [%s]\n", service);
3366 lp_do_parameter(SNUM(handle->conn), "durable handles", "yes");
3367 lp_do_parameter(SNUM(handle->conn), "kernel oplocks", "no");
3368 lp_do_parameter(SNUM(handle->conn), "kernel share modes", "no");
3369 if (!lp_strict_sync(SNUM(handle->conn))) {
3370 DBG_WARNING("Time Machine without strict sync is not "
3371 "recommended!\n");
3372 }
3373 lp_do_parameter(SNUM(handle->conn), "posix locking", "no");
3374 }
3375
3376 return rc;
3377 }
3378
3379 static int fruit_fake_fd(void)
3380 {
3381 int pipe_fds[2];
3382 int fd;
3383 int ret;
3384
3385 /*
3386 * Return a valid fd, but ensure any attempt to use it returns
3387 * an error (EPIPE). Once we get a write on the handle, we open
3388 * the real fd.
3389 */
3390 ret = pipe(pipe_fds);
3391 if (ret != 0) {
3392 return -1;
3393 }
3394 fd = pipe_fds[0];
3395 close(pipe_fds[1]);
3396
3397 return fd;
3398 }
3399
3400 static int fruit_open_meta_stream(vfs_handle_struct *handle,
3401 struct smb_filename *smb_fname,
3402 files_struct *fsp,
3403 int flags,
3404 mode_t mode)
3405 {
3406 struct fruit_config_data *config = NULL;
3407 struct fio *fio = NULL;
3408 int open_flags = flags & ~O_CREAT;
3409 int fd;
3410
3411 DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
3412
3413 SMB_VFS_HANDLE_GET_DATA(handle, config,
3414 struct fruit_config_data, return -1);
3415
3416 fio = VFS_ADD_FSP_EXTENSION(handle, fsp, struct fio, NULL);
3417 fio->type = ADOUBLE_META;
3418 fio->config = config;
3419
3420 fd = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, open_flags, mode);
3421 if (fd != -1) {
3422 return fd;
3423 }
3424
3425 if (!(flags & O_CREAT)) {
3426 VFS_REMOVE_FSP_EXTENSION(handle, fsp);
3427 return -1;
3428 }
3429
3430 fd = fruit_fake_fd();
3431 if (fd == -1) {
3432 VFS_REMOVE_FSP_EXTENSION(handle, fsp);
3433 return -1;
3434 }
3435
3436 fio->fake_fd = true;
3437 fio->flags = flags;
3438 fio->mode = mode;
3439
3440 return fd;
3441 }
3442
3443 static int fruit_open_meta_netatalk(vfs_handle_struct *handle,
3444 struct smb_filename *smb_fname,
3445 files_struct *fsp,
3446 int flags,
3447 mode_t mode)
3448 {
3449 struct fruit_config_data *config = NULL;
3450 struct fio *fio = NULL;
3451 struct adouble *ad = NULL;
3452 bool meta_exists = false;
3453 int fd;
3454
3455 DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
3456
3457 ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_META);
3458 if (ad != NULL) {
3459 meta_exists = true;
3460 }
3461
3462 TALLOC_FREE(ad);
3463
3464 if (!meta_exists && !(flags & O_CREAT)) {
3465 errno = ENOENT;
3466 return -1;
3467 }
3468
3469 fd = fruit_fake_fd();
3470 if (fd == -1) {
3471 return -1;
3472 }
3473
3474 SMB_VFS_HANDLE_GET_DATA(handle, config,
3475 struct fruit_config_data, return -1);
3476
3477 fio = VFS_ADD_FSP_EXTENSION(handle, fsp, struct fio, NULL);
3478 fio->type = ADOUBLE_META;
3479 fio->config = config;
3480 fio->fake_fd = true;
3481 fio->flags = flags;
3482 fio->mode = mode;
3483
3484 return fd;
3485 }
3486
3487 static int fruit_open_meta(vfs_handle_struct *handle,
3488 struct smb_filename *smb_fname,
3489 files_struct *fsp, int flags, mode_t mode)
3490 {
3491 int fd;
3492 struct fruit_config_data *config = NULL;
3493
3494 DBG_DEBUG("path [%s]\n", smb_fname_str_dbg(smb_fname));
3495
3496 SMB_VFS_HANDLE_GET_DATA(handle, config,
3497 struct fruit_config_data, return -1);
3498
3499 switch (config->meta) {
3500 case FRUIT_META_STREAM:
3501 fd = fruit_open_meta_stream(handle, smb_fname,
3502 fsp, flags, mode);
3503 break;
3504
3505 case FRUIT_META_NETATALK:
3506 fd = fruit_open_meta_netatalk(handle, smb_fname,
3507 fsp, flags, mode);
3508 break;
3509
3510 default:
3511 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
3512 return -1;
3513 }
3514
3515 DBG_DEBUG("path [%s] fd [%d]\n", smb_fname_str_dbg(smb_fname), fd);
3516
3517 return fd;
3518 }
3519
3520 static int fruit_open_rsrc_adouble(vfs_handle_struct *handle,
3521 struct smb_filename *smb_fname,
3522 files_struct *fsp,
3523 int flags,
3524 mode_t mode)
3525 {
3526 int rc = 0;
3527 struct adouble *ad = NULL;
3528 struct smb_filename *smb_fname_base = NULL;
3529 struct fruit_config_data *config = NULL;
3530 int hostfd = -1;
3531
3532 SMB_VFS_HANDLE_GET_DATA(handle, config,
3533 struct fruit_config_data, return -1);
3534
3535 if ((!(flags & O_CREAT)) &&
3536 S_ISDIR(fsp->base_fsp->fsp_name->st.st_ex_mode))
3537 {
3538 /* sorry, but directories don't habe a resource fork */
3539 rc = -1;
3540 goto exit;
3541 }
3542
3543 rc = adouble_path(talloc_tos(), smb_fname, &smb_fname_base);
3544 if (rc != 0) {
3545 goto exit;
3546 }
3547
3548 /* We always need read/write access for the metadata header too */
3549 flags &= ~(O_RDONLY | O_WRONLY);
3550 flags |= O_RDWR;
3551
3552 hostfd = SMB_VFS_NEXT_OPEN(handle, smb_fname_base, fsp,
3553 flags, mode);
3554 if (hostfd == -1) {
3555 rc = -1;
3556 goto exit;
3557 }
3558
3559 if (flags & (O_CREAT | O_TRUNC)) {
3560 ad = ad_init(fsp, ADOUBLE_RSRC);
3561 if (ad == NULL) {
3562 rc = -1;
3563 goto exit;
3564 }
3565
3566 fsp->fh->fd = hostfd;
3567
3568 rc = ad_fset(handle, ad, fsp);
3569 fsp->fh->fd = -1;
3570 if (rc != 0) {
3571 rc = -1;
3572 goto exit;
3573 }
3574 TALLOC_FREE(ad);
3575 }
3576
3577 exit:
3578
3579 TALLOC_FREE(smb_fname_base);
3580
3581 DEBUG(10, ("fruit_open resource fork: rc=%d, fd=%d\n", rc, hostfd));
3582 if (rc != 0) {
3583 int saved_errno = errno;
3584 if (hostfd >= 0) {
3585 /*
3586 * BUGBUGBUG -- we would need to call
3587 * fd_close_posix here, but we don't have a
3588 * full fsp yet
3589 */
3590 fsp->fh->fd = hostfd;
3591 SMB_VFS_CLOSE(fsp);
3592 }
3593 hostfd = -1;
3594 errno = saved_errno;
3595 }
3596 return hostfd;
3597 }
3598
3599 static int fruit_open_rsrc_xattr(vfs_handle_struct *handle,
3600 struct smb_filename *smb_fname,
3601 files_struct *fsp,
3602 int flags,
3603 mode_t mode)
3604 {
3605 #ifdef HAVE_ATTROPEN
3606 int fd = -1;
3607
3608 fd = attropen(smb_fname->base_name,
3609 AFPRESOURCE_EA_NETATALK,
3610 flags,
3611 mode);
3612 if (fd == -1) {
3613 return -1;
3614 }
3615
3616 return fd;
3617
3618 #else
3619 errno = ENOSYS;
3620 return -1;
3621 #endif
3622 }
3623
3624 static int fruit_open_rsrc(vfs_handle_struct *handle,
3625 struct smb_filename *smb_fname,
3626 files_struct *fsp, int flags, mode_t mode)
3627 {
3628 int fd;
3629 struct fruit_config_data *config = NULL;
3630 struct fio *fio = NULL;
3631
3632 DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
3633
3634 SMB_VFS_HANDLE_GET_DATA(handle, config,
3635 struct fruit_config_data, return -1);
3636
3637 switch (config->rsrc) {
3638 case FRUIT_RSRC_STREAM:
3639 fd = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
3640 break;
3641
3642 case FRUIT_RSRC_ADFILE:
3643 fd = fruit_open_rsrc_adouble(handle, smb_fname,
3644 fsp, flags, mode);
3645 break;
3646
3647 case FRUIT_RSRC_XATTR:
3648 fd = fruit_open_rsrc_xattr(handle, smb_fname,
3649 fsp, flags, mode);
3650 break;
3651
3652 default:
3653 DBG_ERR("Unexpected rsrc config [%d]\n", config->rsrc);
3654 return -1;
3655 }
3656
3657 DBG_DEBUG("Path [%s] fd [%d]\n", smb_fname_str_dbg(smb_fname), fd);
3658
3659 if (fd == -1) {
3660 return -1;
3661 }
3662
3663 fio = VFS_ADD_FSP_EXTENSION(handle, fsp, struct fio, NULL);
3664 fio->type = ADOUBLE_RSRC;
3665 fio->config = config;
3666
3667 return fd;
3668 }
3669
3670 static int fruit_open(vfs_handle_struct *handle,
3671 struct smb_filename *smb_fname,
3672 files_struct *fsp, int flags, mode_t mode)
3673 {
3674 int fd;
3675
3676 DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
3677
3678 if (!is_ntfs_stream_smb_fname(smb_fname)) {
3679 return SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
3680 }
3681
3682 if (is_afpinfo_stream(smb_fname)) {
3683 fd = fruit_open_meta(handle, smb_fname, fsp, flags, mode);
3684 } else if (is_afpresource_stream(smb_fname)) {
3685 fd = fruit_open_rsrc(handle, smb_fname, fsp, flags, mode);
3686 } else {
3687 fd = SMB_VFS_NEXT_OPEN(handle, smb_fname, fsp, flags, mode);
3688 }
3689
3690 DBG_DEBUG("Path [%s] fd [%d]\n", smb_fname_str_dbg(smb_fname), fd);
3691
3692 return fd;
3693 }
3694
3695 static int fruit_close_meta(vfs_handle_struct *handle,
3696 files_struct *fsp)
3697 {
3698 int ret;
3699 struct fruit_config_data *config = NULL;
3700
3701 SMB_VFS_HANDLE_GET_DATA(handle, config,
3702 struct fruit_config_data, return -1);
3703
3704 switch (config->meta) {
3705 case FRUIT_META_STREAM:
3706 ret = SMB_VFS_NEXT_CLOSE(handle, fsp);
3707 break;
3708
3709 case FRUIT_META_NETATALK:
3710 ret = close(fsp->fh->fd);
3711 fsp->fh->fd = -1;
3712 break;
3713
3714 default:
3715 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
3716 return -1;
3717 }
3718
3719 return ret;
3720 }
3721
3722
3723 static int fruit_close_rsrc(vfs_handle_struct *handle,
3724 files_struct *fsp)
3725 {
3726 int ret;
3727 struct fruit_config_data *config = NULL;
3728
3729 SMB_VFS_HANDLE_GET_DATA(handle, config,
3730 struct fruit_config_data, return -1);
3731
3732 switch (config->rsrc) {
3733 case FRUIT_RSRC_STREAM:
3734 case FRUIT_RSRC_ADFILE:
3735 ret = SMB_VFS_NEXT_CLOSE(handle, fsp);
3736 break;
3737
3738 case FRUIT_RSRC_XATTR:
3739 ret = close(fsp->fh->fd);
3740 fsp->fh->fd = -1;
3741 break;
3742
3743 default:
3744 DBG_ERR("Unexpected rsrc config [%d]\n", config->rsrc);
3745 return -1;
3746 }
3747
3748 return ret;
3749 }
3750
3751 static int fruit_close(vfs_handle_struct *handle,
3752 files_struct *fsp)
3753 {
3754 int ret;
3755 int fd;
3756
3757 fd = fsp->fh->fd;
3758
3759 DBG_DEBUG("Path [%s] fd [%d]\n", smb_fname_str_dbg(fsp->fsp_name), fd);
3760
3761 if (!is_ntfs_stream_smb_fname(fsp->fsp_name)) {
3762 return SMB_VFS_NEXT_CLOSE(handle, fsp);
3763 }
3764
3765 if (is_afpinfo_stream(fsp->fsp_name)) {
3766 ret = fruit_close_meta(handle, fsp);
3767 } else if (is_afpresource_stream(fsp->fsp_name)) {
3768 ret = fruit_close_rsrc(handle, fsp);
3769 } else {
3770 ret = SMB_VFS_NEXT_CLOSE(handle, fsp);
3771 }
3772
3773 return ret;
3774 }
3775
3776 static int fruit_rename(struct vfs_handle_struct *handle,
3777 const struct smb_filename *smb_fname_src,
3778 const struct smb_filename *smb_fname_dst)
3779 {
3780 int rc = -1;
3781 struct fruit_config_data *config = NULL;
3782 struct smb_filename *src_adp_smb_fname = NULL;
3783 struct smb_filename *dst_adp_smb_fname = NULL;
3784
3785 SMB_VFS_HANDLE_GET_DATA(handle, config,
3786 struct fruit_config_data, return -1);
3787
3788 if (!VALID_STAT(smb_fname_src->st)) {
3789 DBG_ERR("Need valid stat for [%s]\n",
3790 smb_fname_str_dbg(smb_fname_src));
3791 return -1;
3792 }
3793
3794 rc = SMB_VFS_NEXT_RENAME(handle, smb_fname_src, smb_fname_dst);
3795 if (rc != 0) {
3796 return -1;
3797 }
3798
3799 if ((config->rsrc != FRUIT_RSRC_ADFILE) ||
3800 (!S_ISREG(smb_fname_src->st.st_ex_mode)))
3801 {
3802 return 0;
3803 }
3804
3805 rc = adouble_path(talloc_tos(), smb_fname_src, &src_adp_smb_fname);
3806 if (rc != 0) {
3807 goto done;
3808 }
3809
3810 rc = adouble_path(talloc_tos(), smb_fname_dst, &dst_adp_smb_fname);
3811 if (rc != 0) {
3812 goto done;
3813 }
3814
3815 DBG_DEBUG("%s -> %s\n",
3816 smb_fname_str_dbg(src_adp_smb_fname),
3817 smb_fname_str_dbg(dst_adp_smb_fname));
3818
3819 rc = SMB_VFS_NEXT_RENAME(handle, src_adp_smb_fname, dst_adp_smb_fname);
3820 if (errno == ENOENT) {
3821 rc = 0;
3822 }
3823
3824 done:
3825 TALLOC_FREE(src_adp_smb_fname);
3826 TALLOC_FREE(dst_adp_smb_fname);
3827 return rc;
3828 }
3829
3830 static int fruit_unlink_meta_stream(vfs_handle_struct *handle,
3831 const struct smb_filename *smb_fname)
3832 {
3833 return SMB_VFS_NEXT_UNLINK(handle, smb_fname);
3834 }
3835
3836 static int fruit_unlink_meta_netatalk(vfs_handle_struct *handle,
3837 const struct smb_filename *smb_fname)
3838 {
3839 return SMB_VFS_REMOVEXATTR(handle->conn,
3840 smb_fname,
3841 AFPINFO_EA_NETATALK);
3842 }
3843
3844 static int fruit_unlink_meta(vfs_handle_struct *handle,
3845 const struct smb_filename *smb_fname)
3846 {
3847 struct fruit_config_data *config = NULL;
3848 int rc;
3849
3850 SMB_VFS_HANDLE_GET_DATA(handle, config,
3851 struct fruit_config_data, return -1);
3852
3853 switch (config->meta) {
3854 case FRUIT_META_STREAM:
3855 rc = fruit_unlink_meta_stream(handle, smb_fname);
3856 break;
3857
3858 case FRUIT_META_NETATALK:
3859 rc = fruit_unlink_meta_netatalk(handle, smb_fname);
3860 break;
3861
3862 default:
3863 DBG_ERR("Unsupported meta config [%d]\n", config->meta);
3864 return -1;
3865 }
3866
3867 return rc;
3868 }
3869
3870 static int fruit_unlink_rsrc_stream(vfs_handle_struct *handle,
3871 const struct smb_filename *smb_fname,
3872 bool force_unlink)
3873 {
3874 int ret;
3875
3876 if (!force_unlink) {
3877 struct smb_filename *smb_fname_cp = NULL;
3878 off_t size;
3879
3880 smb_fname_cp = cp_smb_filename(talloc_tos(), smb_fname);
3881 if (smb_fname_cp == NULL) {
3882 return -1;
3883 }
3884
3885 /*
3886 * 0 byte resource fork streams are not listed by
3887 * vfs_streaminfo, as a result stream cleanup/deletion of file
3888 * deletion doesn't remove the resourcefork stream.
3889 */
3890
3891 ret = SMB_VFS_NEXT_STAT(handle, smb_fname_cp);
3892 if (ret != 0) {
3893 TALLOC_FREE(smb_fname_cp);
3894 DBG_ERR("stat [%s] failed [%s]\n",
3895 smb_fname_str_dbg(smb_fname_cp), strerror(errno));
3896 return -1;
3897 }
3898
3899 size = smb_fname_cp->st.st_ex_size;
3900 TALLOC_FREE(smb_fname_cp);
3901
3902 if (size > 0) {
3903 /* OS X ignores resource fork stream delete requests */
3904 return 0;
3905 }
3906 }
3907
3908 ret = SMB_VFS_NEXT_UNLINK(handle, smb_fname);
3909 if ((ret != 0) && (errno == ENOENT) && force_unlink) {
3910 ret = 0;
3911 }
3912
3913 return ret;
3914 }
3915
3916 static int fruit_unlink_rsrc_adouble(vfs_handle_struct *handle,
3917 const struct smb_filename *smb_fname,
3918 bool force_unlink)
3919 {
3920 int rc;
3921 struct adouble *ad = NULL;
3922 struct smb_filename *adp_smb_fname = NULL;
3923
3924 if (!force_unlink) {
3925 ad = ad_get(talloc_tos(), handle, smb_fname,
3926 ADOUBLE_RSRC);
3927 if (ad == NULL) {
3928 errno = ENOENT;
3929 return -1;
3930 }
3931
3932
3933 /*
3934 * 0 byte resource fork streams are not listed by
3935 * vfs_streaminfo, as a result stream cleanup/deletion of file
3936 * deletion doesn't remove the resourcefork stream.
3937 */
3938
3939 if (ad_getentrylen(ad, ADEID_RFORK) > 0) {
3940 /* OS X ignores resource fork stream delete requests */
3941 TALLOC_FREE(ad);
3942 return 0;
3943 }
3944
3945 TALLOC_FREE(ad);
3946 }
3947
3948 rc = adouble_path(talloc_tos(), smb_fname, &adp_smb_fname);
3949 if (rc != 0) {
3950 return -1;
3951 }
3952
3953 rc = SMB_VFS_NEXT_UNLINK(handle, adp_smb_fname);
3954 TALLOC_FREE(adp_smb_fname);
3955 if ((rc != 0) && (errno == ENOENT) && force_unlink) {
3956 rc = 0;
3957 }
3958
3959 return rc;
3960 }
3961
3962 static int fruit_unlink_rsrc_xattr(vfs_handle_struct *handle,
3963 const struct smb_filename *smb_fname,
3964 bool force_unlink)
3965 {
3966 /*
3967 * OS X ignores resource fork stream delete requests, so nothing to do
3968 * here. Removing the file will remove the xattr anyway, so we don't
3969 * have to take care of removing 0 byte resource forks that could be
3970 * left behind.
3971 */
3972 return 0;
3973 }
3974
3975 static int fruit_unlink_rsrc(vfs_handle_struct *handle,
3976 const struct smb_filename *smb_fname,
3977 bool force_unlink)
3978 {
3979 struct fruit_config_data *config = NULL;
3980 int rc;
3981
3982 SMB_VFS_HANDLE_GET_DATA(handle, config,
3983 struct fruit_config_data, return -1);
3984
3985 switch (config->rsrc) {
3986 case FRUIT_RSRC_STREAM:
3987 rc = fruit_unlink_rsrc_stream(handle, smb_fname, force_unlink);
3988 break;
3989
3990 case FRUIT_RSRC_ADFILE:
3991 rc = fruit_unlink_rsrc_adouble(handle, smb_fname, force_unlink);
3992 break;
3993
3994 case FRUIT_RSRC_XATTR:
3995 rc = fruit_unlink_rsrc_xattr(handle, smb_fname, force_unlink);
3996 break;
3997
3998 default:
3999 DBG_ERR("Unsupported rsrc config [%d]\n", config->rsrc);
4000 return -1;
4001 }
4002
4003 return rc;
4004 }
4005
4006 static int fruit_unlink(vfs_handle_struct *handle,
4007 const struct smb_filename *smb_fname)
4008 {
4009 int rc;
4010 struct fruit_config_data *config = NULL;
4011 struct smb_filename *rsrc_smb_fname = NULL;
4012
4013 SMB_VFS_HANDLE_GET_DATA(handle, config,
4014 struct fruit_config_data, return -1);
4015
4016 if (is_afpinfo_stream(smb_fname)) {
4017 return fruit_unlink_meta(handle, smb_fname);
4018 } else if (is_afpresource_stream(smb_fname)) {
4019 return fruit_unlink_rsrc(handle, smb_fname, false);
4020 } else if (is_ntfs_stream_smb_fname(smb_fname)) {
4021 return SMB_VFS_NEXT_UNLINK(handle, smb_fname);
4022 } else if (is_adouble_file(smb_fname->base_name)) {
4023 return SMB_VFS_NEXT_UNLINK(handle, smb_fname);
4024 }
4025
4026 /*
4027 * A request to delete the base file. Because 0 byte resource
4028 * fork streams are not listed by fruit_streaminfo,
4029 * delete_all_streams() can't remove 0 byte resource fork
4030 * streams, so we have to cleanup this here.
4031 */
4032 rsrc_smb_fname = synthetic_smb_fname(talloc_tos(),
4033 smb_fname->base_name,
4034 AFPRESOURCE_STREAM_NAME,
4035 NULL,
4036 smb_fname->flags);
4037 if (rsrc_smb_fname == NULL) {
4038 return -1;
4039 }
4040
4041 rc = fruit_unlink_rsrc(handle, rsrc_smb_fname, true);
4042 if ((rc != 0) && (errno != ENOENT)) {
4043 DBG_ERR("Forced unlink of [%s] failed [%s]\n",
4044 smb_fname_str_dbg(rsrc_smb_fname), strerror(errno));
4045 TALLOC_FREE(rsrc_smb_fname);
4046 return -1;
4047 }
4048 TALLOC_FREE(rsrc_smb_fname);
4049
4050 return SMB_VFS_NEXT_UNLINK(handle, smb_fname);
4051 }
4052
4053 static int fruit_chmod(vfs_handle_struct *handle,
4054 const struct smb_filename *smb_fname,
4055 mode_t mode)
4056 {
4057 int rc = -1;
4058 struct fruit_config_data *config = NULL;
4059 struct smb_filename *smb_fname_adp = NULL;
4060
4061 rc = SMB_VFS_NEXT_CHMOD(handle, smb_fname, mode);
4062 if (rc != 0) {
4063 return rc;
4064 }
4065
4066 SMB_VFS_HANDLE_GET_DATA(handle, config,
4067 struct fruit_config_data, return -1);
4068
4069 if (config->rsrc != FRUIT_RSRC_ADFILE) {
4070 return 0;
4071 }
4072
4073 if (!VALID_STAT(smb_fname->st)) {
4074 return 0;
4075 }
4076
4077 if (!S_ISREG(smb_fname->st.st_ex_mode)) {
4078 return 0;
4079 }
4080
4081 rc = adouble_path(talloc_tos(), smb_fname, &smb_fname_adp);
4082 if (rc != 0) {
4083 return -1;
4084 }
4085
4086 DEBUG(10, ("fruit_chmod: %s\n", smb_fname_adp->base_name));
4087
4088 rc = SMB_VFS_NEXT_CHMOD(handle, smb_fname_adp, mode);
4089 if (errno == ENOENT) {
4090 rc = 0;
4091 }
4092
4093 TALLOC_FREE(smb_fname_adp);
4094 return rc;
4095 }
4096
4097 static int fruit_chown(vfs_handle_struct *handle,
4098 const struct smb_filename *smb_fname,
4099 uid_t uid,
4100 gid_t gid)
4101 {
4102 int rc = -1;
4103 struct fruit_config_data *config = NULL;
4104 struct smb_filename *adp_smb_fname = NULL;
4105
4106 rc = SMB_VFS_NEXT_CHOWN(handle, smb_fname, uid, gid);
4107 if (rc != 0) {
4108 return rc;
4109 }
4110
4111 SMB_VFS_HANDLE_GET_DATA(handle, config,
4112 struct fruit_config_data, return -1);
4113
4114 if (config->rsrc != FRUIT_RSRC_ADFILE) {
4115 return 0;
4116 }
4117
4118 if (!VALID_STAT(smb_fname->st)) {
4119 return 0;
4120 }
4121
4122 if (!S_ISREG(smb_fname->st.st_ex_mode)) {
4123 return 0;
4124 }
4125
4126 rc = adouble_path(talloc_tos(), smb_fname, &adp_smb_fname);
4127 if (rc != 0) {
4128 goto done;
4129 }
4130
4131 DEBUG(10, ("fruit_chown: %s\n", adp_smb_fname->base_name));
4132
4133 rc = SMB_VFS_NEXT_CHOWN(handle, adp_smb_fname, uid, gid);
4134 if (errno == ENOENT) {
4135 rc = 0;
4136 }
4137
4138 done:
4139 TALLOC_FREE(adp_smb_fname);
4140 return rc;
4141 }
4142
4143 static int fruit_rmdir(struct vfs_handle_struct *handle,
4144 const struct smb_filename *smb_fname)
4145 {
4146 DIR *dh = NULL;
4147 struct dirent *de;
4148 struct fruit_config_data *config;
4149
4150 SMB_VFS_HANDLE_GET_DATA(handle, config,
4151 struct fruit_config_data, return -1);
4152
4153 if (config->rsrc != FRUIT_RSRC_ADFILE) {
4154 goto exit_rmdir;
4155 }
4156
4157 /*
4158 * Due to there is no way to change bDeleteVetoFiles variable
4159 * from this module, need to clean up ourselves
4160 */
4161
4162 dh = SMB_VFS_OPENDIR(handle->conn, smb_fname, NULL, 0);
4163 if (dh == NULL) {
4164 goto exit_rmdir;
4165 }
4166
4167 while ((de = SMB_VFS_READDIR(handle->conn, dh, NULL)) != NULL) {
4168 struct adouble *ad = NULL;
4169 char *p = NULL;
4170 struct smb_filename *ad_smb_fname = NULL;
4171 int ret;
4172
4173 if (!is_adouble_file(de->d_name)) {
4174 continue;
4175 }
4176
4177 p = talloc_asprintf(talloc_tos(), "%s/%s",
4178 smb_fname->base_name, de->d_name);
4179 if (p == NULL) {
4180 DBG_ERR("talloc_asprintf failed\n");
4181 return -1;
4182 }
4183
4184 ad_smb_fname = synthetic_smb_fname(talloc_tos(), p,
4185 NULL, NULL,
4186 smb_fname->flags);
4187 TALLOC_FREE(p);
4188 if (ad_smb_fname == NULL) {
4189 DBG_ERR("synthetic_smb_fname failed\n");
4190 return -1;
4191 }
4192
4193 /*
4194 * Check whether it's a valid AppleDouble file, if
4195 * yes, delete it, ignore it otherwise.
4196 */
4197 ad = ad_get(talloc_tos(), handle, ad_smb_fname, ADOUBLE_RSRC);
4198 if (ad == NULL) {
4199 TALLOC_FREE(ad_smb_fname);
4200 TALLOC_FREE(p);
4201 continue;
4202 }
4203 TALLOC_FREE(ad);
4204
4205 ret = SMB_VFS_NEXT_UNLINK(handle, ad_smb_fname);
4206 if (ret != 0) {
4207 DBG_ERR("Deleting [%s] failed\n",
4208 smb_fname_str_dbg(ad_smb_fname));
4209 }
4210 TALLOC_FREE(ad_smb_fname);
4211 }
4212
4213 exit_rmdir:
4214 if (dh) {
4215 SMB_VFS_CLOSEDIR(handle->conn, dh);
4216 }
4217 return SMB_VFS_NEXT_RMDIR(handle, smb_fname);
4218 }
4219
4220 static ssize_t fruit_pread_meta_stream(vfs_handle_struct *handle,
4221 files_struct *fsp, void *data,
4222 size_t n, off_t offset)
4223 {
4224 ssize_t nread;
4225 int ret;
4226
4227 nread = SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
4228 if (nread == -1 || nread == n) {
4229 return nread;
4230 }
4231
4232 DBG_ERR("Removing [%s] after short read [%zd]\n",
4233 fsp_str_dbg(fsp), nread);
4234
4235 ret = SMB_VFS_NEXT_UNLINK(handle, fsp->fsp_name);
4236 if (ret != 0) {
4237 DBG_ERR("Removing [%s] failed\n", fsp_str_dbg(fsp));
4238 return -1;
4239 }
4240
4241 errno = EINVAL;
4242 return -1;
4243 }
4244
4245 static ssize_t fruit_pread_meta_adouble(vfs_handle_struct *handle,
4246 files_struct *fsp, void *data,
4247 size_t n, off_t offset)
4248 {
4249 AfpInfo *ai = NULL;
4250 struct adouble *ad = NULL;
4251 char afpinfo_buf[AFP_INFO_SIZE];
4252 char *p = NULL;
4253 ssize_t nread;
4254
4255 ai = afpinfo_new(talloc_tos());
4256 if (ai == NULL) {
4257 return -1;
4258 }
4259
4260 ad = ad_fget(talloc_tos(), handle, fsp, ADOUBLE_META);
4261 if (ad == NULL) {
4262 nread = -1;
4263 goto fail;
4264 }
4265
4266 p = ad_get_entry(ad, ADEID_FINDERI);
4267 if (p == NULL) {
4268 DBG_ERR("No ADEID_FINDERI for [%s]\n", fsp_str_dbg(fsp));
4269 nread = -1;
4270 goto fail;
4271 }
4272
4273 memcpy(&ai->afpi_FinderInfo[0], p, ADEDLEN_FINDERI);
4274
4275 nread = afpinfo_pack(ai, afpinfo_buf);
4276 if (nread != AFP_INFO_SIZE) {
4277 nread = -1;
4278 goto fail;
4279 }
4280
4281 memcpy(data, afpinfo_buf, n);
4282 nread = n;
4283
4284 fail:
4285 TALLOC_FREE(ai);
4286 return nread;
4287 }
4288
4289 static ssize_t fruit_pread_meta(vfs_handle_struct *handle,
4290 files_struct *fsp, void *data,
4291 size_t n, off_t offset)
4292 {
4293 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4294 ssize_t nread;
4295 ssize_t to_return;
4296
4297 /*
4298 * OS X has a off-by-1 error in the offset calculation, so we're
4299 * bug compatible here. It won't hurt, as any relevant real
4300 * world read requests from the AFP_AfpInfo stream will be
4301 * offset=0 n=60. offset is ignored anyway, see below.
4302 */
4303 if ((offset < 0) || (offset >= AFP_INFO_SIZE + 1)) {
4304 return 0;
4305 }
4306
4307 if (fio == NULL) {
4308 DBG_ERR("Failed to fetch fsp extension");
4309 return -1;
4310 }
4311
4312 /* Yes, macOS always reads from offset 0 */
4313 offset = 0;
4314 to_return = MIN(n, AFP_INFO_SIZE);
4315
4316 switch (fio->config->meta) {
4317 case FRUIT_META_STREAM:
4318 nread = fruit_pread_meta_stream(handle, fsp, data,
4319 to_return, offset);
4320 break;
4321
4322 case FRUIT_META_NETATALK:
4323 nread = fruit_pread_meta_adouble(handle, fsp, data,
4324 to_return, offset);
4325 break;
4326
4327 default:
4328 DBG_ERR("Unexpected meta config [%d]\n", fio->config->meta);
4329 return -1;
4330 }
4331
4332 if (nread == -1 && fio->created) {
4333 AfpInfo *ai = NULL;
4334 char afpinfo_buf[AFP_INFO_SIZE];
4335
4336 ai = afpinfo_new(talloc_tos());
4337 if (ai == NULL) {
4338 return -1;
4339 }
4340
4341 nread = afpinfo_pack(ai, afpinfo_buf);
4342 TALLOC_FREE(ai);
4343 if (nread != AFP_INFO_SIZE) {
4344 return -1;
4345 }
4346
4347 memcpy(data, afpinfo_buf, to_return);
4348 return to_return;
4349 }
4350
4351 return nread;
4352 }
4353
4354 static ssize_t fruit_pread_rsrc_stream(vfs_handle_struct *handle,
4355 files_struct *fsp, void *data,
4356 size_t n, off_t offset)
4357 {
4358 return SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
4359 }
4360
4361 static ssize_t fruit_pread_rsrc_xattr(vfs_handle_struct *handle,
4362 files_struct *fsp, void *data,
4363 size_t n, off_t offset)
4364 {
4365 return SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
4366 }
4367
4368 static ssize_t fruit_pread_rsrc_adouble(vfs_handle_struct *handle,
4369 files_struct *fsp, void *data,
4370 size_t n, off_t offset)
4371 {
4372 struct adouble *ad = NULL;
4373 ssize_t nread;
4374
4375 ad = ad_fget(talloc_tos(), handle, fsp, ADOUBLE_RSRC);
4376 if (ad == NULL) {
4377 return -1;
4378 }
4379
4380 nread = SMB_VFS_NEXT_PREAD(handle, fsp, data, n,
4381 offset + ad_getentryoff(ad, ADEID_RFORK));
4382
4383 TALLOC_FREE(ad);
4384 return nread;
4385 }
4386
4387 static ssize_t fruit_pread_rsrc(vfs_handle_struct *handle,
4388 files_struct *fsp, void *data,
4389 size_t n, off_t offset)
4390 {
4391 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4392 ssize_t nread;
4393
4394 if (fio == NULL) {
4395 errno = EINVAL;
4396 return -1;
4397 }
4398
4399 switch (fio->config->rsrc) {
4400 case FRUIT_RSRC_STREAM:
4401 nread = fruit_pread_rsrc_stream(handle, fsp, data, n, offset);
4402 break;
4403
4404 case FRUIT_RSRC_ADFILE:
4405 nread = fruit_pread_rsrc_adouble(handle, fsp, data, n, offset);
4406 break;
4407
4408 case FRUIT_RSRC_XATTR:
4409 nread = fruit_pread_rsrc_xattr(handle, fsp, data, n, offset);
4410 break;
4411
4412 default:
4413 DBG_ERR("Unexpected rsrc config [%d]\n", fio->config->rsrc);
4414 return -1;
4415 }
4416
4417 return nread;
4418 }
4419
4420 static ssize_t fruit_pread(vfs_handle_struct *handle,
4421 files_struct *fsp, void *data,
4422 size_t n, off_t offset)
4423 {
4424 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4425 ssize_t nread;
4426
4427 DBG_DEBUG("Path [%s] offset=%"PRIdMAX", size=%zd\n",
4428 fsp_str_dbg(fsp), (intmax_t)offset, n);
4429
4430 if (fio == NULL) {
4431 return SMB_VFS_NEXT_PREAD(handle, fsp, data, n, offset);
4432 }
4433
4434 if (fio->type == ADOUBLE_META) {
4435 nread = fruit_pread_meta(handle, fsp, data, n, offset);
4436 } else {
4437 nread = fruit_pread_rsrc(handle, fsp, data, n, offset);
4438 }
4439
4440 DBG_DEBUG("Path [%s] nread [%zd]\n", fsp_str_dbg(fsp), nread);
4441 return nread;
4442 }
4443
4444 static bool fruit_must_handle_aio_stream(struct fio *fio)
4445 {
4446 if (fio == NULL) {
4447 return false;
4448 };
4449
4450 if (fio->type == ADOUBLE_META) {
4451 return true;
4452 }
4453
4454 if ((fio->type == ADOUBLE_RSRC) &&
4455 (fio->config->rsrc == FRUIT_RSRC_ADFILE))
4456 {
4457 return true;
4458 }
4459
4460 return false;
4461 }
4462
4463 struct fruit_pread_state {
4464 ssize_t nread;
4465 struct vfs_aio_state vfs_aio_state;
4466 };
4467
4468 static void fruit_pread_done(struct tevent_req *subreq);
4469
4470 static struct tevent_req *fruit_pread_send(
4471 struct vfs_handle_struct *handle,
4472 TALLOC_CTX *mem_ctx,
4473 struct tevent_context *ev,
4474 struct files_struct *fsp,
4475 void *data,
4476 size_t n, off_t offset)
4477 {
4478 struct tevent_req *req = NULL;
4479 struct tevent_req *subreq = NULL;
4480 struct fruit_pread_state *state = NULL;
4481 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4482
4483 req = tevent_req_create(mem_ctx, &state,
4484 struct fruit_pread_state);
4485 if (req == NULL) {
4486 return NULL;
4487 }
4488
4489 if (fruit_must_handle_aio_stream(fio)) {
4490 state->nread = SMB_VFS_PREAD(fsp, data, n, offset);
4491 if (state->nread != n) {
4492 if (state->nread != -1) {
4493 errno = EIO;
4494 }
4495 tevent_req_error(req, errno);
4496 return tevent_req_post(req, ev);
4497 }
4498 tevent_req_done(req);
4499 return tevent_req_post(req, ev);
4500 }
4501
4502 subreq = SMB_VFS_NEXT_PREAD_SEND(state, ev, handle, fsp,
4503 data, n, offset);
4504 if (tevent_req_nomem(req, subreq)) {
4505 return tevent_req_post(req, ev);
4506 }
4507 tevent_req_set_callback(subreq, fruit_pread_done, req);
4508 return req;
4509 }
4510
4511 static void fruit_pread_done(struct tevent_req *subreq)
4512 {
4513 struct tevent_req *req = tevent_req_callback_data(
4514 subreq, struct tevent_req);
4515 struct fruit_pread_state *state = tevent_req_data(
4516 req, struct fruit_pread_state);
4517
4518 state->nread = SMB_VFS_PREAD_RECV(subreq, &state->vfs_aio_state);
4519 TALLOC_FREE(subreq);
4520
4521 if (tevent_req_error(req, state->vfs_aio_state.error)) {
4522 return;
4523 }
4524 tevent_req_done(req);
4525 }
4526
4527 static ssize_t fruit_pread_recv(struct tevent_req *req,
4528 struct vfs_aio_state *vfs_aio_state)
4529 {
4530 struct fruit_pread_state *state = tevent_req_data(
4531 req, struct fruit_pread_state);
4532
4533 if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
4534 return -1;
4535 }
4536
4537 *vfs_aio_state = state->vfs_aio_state;
4538 return state->nread;
4539 }
4540
4541 static ssize_t fruit_pwrite_meta_stream(vfs_handle_struct *handle,
4542 files_struct *fsp, const void *data,
4543 size_t n, off_t offset)
4544 {
4545 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4546 AfpInfo *ai = NULL;
4547 size_t nwritten;
4548 int ret;
4549 bool ok;
4550
4551 DBG_DEBUG("Path [%s] offset=%"PRIdMAX", size=%zd\n",
4552 fsp_str_dbg(fsp), (intmax_t)offset, n);
4553
4554 if (fio == NULL) {
4555 return -1;
4556 }
4557
4558 if (fio->fake_fd) {
4559 int fd;
4560
4561 ret = SMB_VFS_NEXT_CLOSE(handle, fsp);
4562 if (ret != 0) {
4563 DBG_ERR("Close [%s] failed: %s\n",
4564 fsp_str_dbg(fsp), strerror(errno));
4565 fsp->fh->fd = -1;
4566 return -1;
4567 }
4568
4569 fd = SMB_VFS_NEXT_OPEN(handle,
4570 fsp->fsp_name,
4571 fsp,
4572 fio->flags,
4573 fio->mode);
4574 if (fd == -1) {
4575 DBG_ERR("On-demand create [%s] in write failed: %s\n",
4576 fsp_str_dbg(fsp), strerror(errno));
4577 return -1;
4578 }
4579 fsp->fh->fd = fd;
4580 fio->fake_fd = false;
4581 }
4582
4583 ai = afpinfo_unpack(talloc_tos(), data);
4584 if (ai == NULL) {
4585 return -1;
4586 }
4587
4588 if (ai_empty_finderinfo(ai)) {
4589 /*
4590 * Writing an all 0 blob to the metadata stream results in the
4591 * stream being removed on a macOS server. This ensures we
4592 * behave the same and it verified by the "delete AFP_AfpInfo by
4593 * writing all 0" test.
4594 */
4595 ret = SMB_VFS_NEXT_FTRUNCATE(handle, fsp, 0);
4596 if (ret != 0) {
4597 DBG_ERR("SMB_VFS_NEXT_FTRUNCATE on [%s] failed\n",
4598 fsp_str_dbg(fsp));
4599 return -1;
4600 }
4601
4602 ok = set_delete_on_close(
4603 fsp,
4604 true,
4605 handle->conn->session_info->security_token,
4606 handle->conn->session_info->unix_token);
4607 if (!ok) {
4608 DBG_ERR("set_delete_on_close on [%s] failed\n",
4609 fsp_str_dbg(fsp));
4610 return -1;
4611 }
4612 return n;
4613 }
4614
4615 nwritten = SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
4616 if (nwritten != n) {
4617 return -1;
4618 }
4619
4620 return n;
4621 }
4622
4623 static ssize_t fruit_pwrite_meta_netatalk(vfs_handle_struct *handle,
4624 files_struct *fsp, const void *data,
4625 size_t n, off_t offset)
4626 {
4627 struct adouble *ad = NULL;
4628 AfpInfo *ai = NULL;
4629 char *p = NULL;
4630 int ret;
4631 bool ok;
4632
4633 ai = afpinfo_unpack(talloc_tos(), data);
4634 if (ai == NULL) {
4635 return -1;
4636 }
4637
4638 ad = ad_fget(talloc_tos(), handle, fsp, ADOUBLE_META);
4639 if (ad == NULL) {
4640 ad = ad_init(talloc_tos(), ADOUBLE_META);
4641 if (ad == NULL) {
4642 return -1;
4643 }
4644 }
4645 p = ad_get_entry(ad, ADEID_FINDERI);
4646 if (p == NULL) {
4647 DBG_ERR("No ADEID_FINDERI for [%s]\n", fsp_str_dbg(fsp));
4648 TALLOC_FREE(ad);
4649 return -1;
4650 }
4651
4652 memcpy(p, &ai->afpi_FinderInfo[0], ADEDLEN_FINDERI);
4653
4654 ret = ad_fset(handle, ad, fsp);
4655 if (ret != 0) {
4656 DBG_ERR("ad_pwrite [%s] failed\n", fsp_str_dbg(fsp));
4657 TALLOC_FREE(ad);
4658 return -1;
4659 }
4660
4661 TALLOC_FREE(ad);
4662
4663 if (!ai_empty_finderinfo(ai)) {
4664 return n;
4665 }
4666
4667 /*
4668 * Writing an all 0 blob to the metadata stream results in the stream
4669 * being removed on a macOS server. This ensures we behave the same and
4670 * it verified by the "delete AFP_AfpInfo by writing all 0" test.
4671 */
4672
4673 ok = set_delete_on_close(
4674 fsp,
4675 true,
4676 handle->conn->session_info->security_token,
4677 handle->conn->session_info->unix_token);
4678 if (!ok) {
4679 DBG_ERR("set_delete_on_close on [%s] failed\n",
4680 fsp_str_dbg(fsp));
4681 return -1;
4682 }
4683
4684 return n;
4685 }
4686
4687 static ssize_t fruit_pwrite_meta(vfs_handle_struct *handle,
4688 files_struct *fsp, const void *data,
4689 size_t n, off_t offset)
4690 {
4691 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4692 ssize_t nwritten;
4693 uint8_t buf[AFP_INFO_SIZE];
4694 size_t to_write;
4695 size_t to_copy;
4696 int cmp;
4697
4698 if (fio == NULL) {
4699 DBG_ERR("Failed to fetch fsp extension");
4700 return -1;
4701 }
4702
4703 if (n < 3) {
4704 errno = EINVAL;
4705 return -1;
4706 }
4707
4708 if (offset != 0 && n < 60) {
4709 errno = EINVAL;
4710 return -1;
4711 }
4712
4713 cmp = memcmp(data, "AFP", 3);
4714 if (cmp != 0) {
4715 errno = EINVAL;
4716 return -1;
4717 }
4718
4719 if (n <= AFP_OFF_FinderInfo) {
4720 /*
4721 * Nothing to do here really, just return
4722 */
4723 return n;
4724 }
4725
4726 offset = 0;
4727
4728 to_copy = n;
4729 if (to_copy > AFP_INFO_SIZE) {
4730 to_copy = AFP_INFO_SIZE;
4731 }
4732 memcpy(buf, data, to_copy);
4733
4734 to_write = n;
4735 if (to_write != AFP_INFO_SIZE) {
4736 to_write = AFP_INFO_SIZE;
4737 }
4738
4739 switch (fio->config->meta) {
4740 case FRUIT_META_STREAM:
4741 nwritten = fruit_pwrite_meta_stream(handle,
4742 fsp,
4743 buf,
4744 to_write,
4745 offset);
4746 break;
4747
4748 case FRUIT_META_NETATALK:
4749 nwritten = fruit_pwrite_meta_netatalk(handle,
4750 fsp,
4751 buf,
4752 to_write,
4753 offset);
4754 break;
4755
4756 default:
4757 DBG_ERR("Unexpected meta config [%d]\n", fio->config->meta);
4758 return -1;
4759 }
4760
4761 if (nwritten != to_write) {
4762 return -1;
4763 }
4764
4765 /*
4766 * Return the requested amount, verified against macOS SMB server
4767 */
4768 return n;
4769 }
4770
4771 static ssize_t fruit_pwrite_rsrc_stream(vfs_handle_struct *handle,
4772 files_struct *fsp, const void *data,
4773 size_t n, off_t offset)
4774 {
4775 return SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
4776 }
4777
4778 static ssize_t fruit_pwrite_rsrc_xattr(vfs_handle_struct *handle,
4779 files_struct *fsp, const void *data,
4780 size_t n, off_t offset)
4781 {
4782 return SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
4783 }
4784
4785 static ssize_t fruit_pwrite_rsrc_adouble(vfs_handle_struct *handle,
4786 files_struct *fsp, const void *data,
4787 size_t n, off_t offset)
4788 {
4789 struct adouble *ad = NULL;
4790 ssize_t nwritten;
4791 int ret;
4792
4793 ad = ad_fget(talloc_tos(), handle, fsp, ADOUBLE_RSRC);
4794 if (ad == NULL) {
4795 DBG_ERR("ad_get [%s] failed\n", fsp_str_dbg(fsp));
4796 return -1;
4797 }
4798
4799 nwritten = SMB_VFS_NEXT_PWRITE(handle, fsp, data, n,
4800 offset + ad_getentryoff(ad, ADEID_RFORK));
4801 if (nwritten != n) {
4802 DBG_ERR("Short write on [%s] [%zd/%zd]\n",
4803 fsp_str_dbg(fsp), nwritten, n);
4804 TALLOC_FREE(ad);
4805 return -1;
4806 }
4807
4808 if ((n + offset) > ad_getentrylen(ad, ADEID_RFORK)) {
4809 ad_setentrylen(ad, ADEID_RFORK, n + offset);
4810 ret = ad_fset(handle, ad, fsp);
4811 if (ret != 0) {
4812 DBG_ERR("ad_pwrite [%s] failed\n", fsp_str_dbg(fsp));
4813 TALLOC_FREE(ad);
4814 return -1;
4815 }
4816 }
4817
4818 TALLOC_FREE(ad);
4819 return n;
4820 }
4821
4822 static ssize_t fruit_pwrite_rsrc(vfs_handle_struct *handle,
4823 files_struct *fsp, const void *data,
4824 size_t n, off_t offset)
4825 {
4826 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4827 ssize_t nwritten;
4828
4829 if (fio == NULL) {
4830 DBG_ERR("Failed to fetch fsp extension");
4831 return -1;
4832 }
4833
4834 switch (fio->config->rsrc) {
4835 case FRUIT_RSRC_STREAM:
4836 nwritten = fruit_pwrite_rsrc_stream(handle, fsp, data, n, offset);
4837 break;
4838
4839 case FRUIT_RSRC_ADFILE:
4840 nwritten = fruit_pwrite_rsrc_adouble(handle, fsp, data, n, offset);
4841 break;
4842
4843 case FRUIT_RSRC_XATTR:
4844 nwritten = fruit_pwrite_rsrc_xattr(handle, fsp, data, n, offset);
4845 break;
4846
4847 default:
4848 DBG_ERR("Unexpected rsrc config [%d]\n", fio->config->rsrc);
4849 return -1;
4850 }
4851
4852 return nwritten;
4853 }
4854
4855 static ssize_t fruit_pwrite(vfs_handle_struct *handle,
4856 files_struct *fsp, const void *data,
4857 size_t n, off_t offset)
4858 {
4859 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4860 ssize_t nwritten;
4861
4862 DBG_DEBUG("Path [%s] offset=%"PRIdMAX", size=%zd\n",
4863 fsp_str_dbg(fsp), (intmax_t)offset, n);
4864
4865 if (fio == NULL) {
4866 return SMB_VFS_NEXT_PWRITE(handle, fsp, data, n, offset);
4867 }
4868
4869 if (fio->type == ADOUBLE_META) {
4870 nwritten = fruit_pwrite_meta(handle, fsp, data, n, offset);
4871 } else {
4872 nwritten = fruit_pwrite_rsrc(handle, fsp, data, n, offset);
4873 }
4874
4875 DBG_DEBUG("Path [%s] nwritten=%zd\n", fsp_str_dbg(fsp), nwritten);
4876 return nwritten;
4877 }
4878
4879 struct fruit_pwrite_state {
4880 ssize_t nwritten;
4881 struct vfs_aio_state vfs_aio_state;
4882 };
4883
4884 static void fruit_pwrite_done(struct tevent_req *subreq);
4885
4886 static struct tevent_req *fruit_pwrite_send(
4887 struct vfs_handle_struct *handle,
4888 TALLOC_CTX *mem_ctx,
4889 struct tevent_context *ev,
4890 struct files_struct *fsp,
4891 const void *data,
4892 size_t n, off_t offset)
4893 {
4894 struct tevent_req *req = NULL;
4895 struct tevent_req *subreq = NULL;
4896 struct fruit_pwrite_state *state = NULL;
4897 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
4898
4899 req = tevent_req_create(mem_ctx, &state,
4900 struct fruit_pwrite_state);
4901 if (req == NULL) {
4902 return NULL;
4903 }
4904
4905 if (fruit_must_handle_aio_stream(fio)) {
4906 state->nwritten = SMB_VFS_PWRITE(fsp, data, n, offset);
4907 if (state->nwritten != n) {
4908 if (state->nwritten != -1) {
4909 errno = EIO;
4910 }
4911 tevent_req_error(req, errno);
4912 return tevent_req_post(req, ev);
4913 }
4914 tevent_req_done(req);
4915 return tevent_req_post(req, ev);
4916 }
4917
4918 subreq = SMB_VFS_NEXT_PWRITE_SEND(state, ev, handle, fsp,
4919 data, n, offset);
4920 if (tevent_req_nomem(req, subreq)) {
4921 return tevent_req_post(req, ev);
4922 }
4923 tevent_req_set_callback(subreq, fruit_pwrite_done, req);
4924 return req;
4925 }
4926
4927 static void fruit_pwrite_done(struct tevent_req *subreq)
4928 {
4929 struct tevent_req *req = tevent_req_callback_data(
4930 subreq, struct tevent_req);
4931 struct fruit_pwrite_state *state = tevent_req_data(
4932 req, struct fruit_pwrite_state);
4933
4934 state->nwritten = SMB_VFS_PWRITE_RECV(subreq, &state->vfs_aio_state);
4935 TALLOC_FREE(subreq);
4936
4937 if (tevent_req_error(req, state->vfs_aio_state.error)) {
4938 return;
4939 }
4940 tevent_req_done(req);
4941 }
4942
4943 static ssize_t fruit_pwrite_recv(struct tevent_req *req,
4944 struct vfs_aio_state *vfs_aio_state)
4945 {
4946 struct fruit_pwrite_state *state = tevent_req_data(
4947 req, struct fruit_pwrite_state);
4948
4949 if (tevent_req_is_unix_error(req, &vfs_aio_state->error)) {
4950 return -1;
4951 }
4952
4953 *vfs_aio_state = state->vfs_aio_state;
4954 return state->nwritten;
4955 }
4956
4957 /**
4958 * Helper to stat/lstat the base file of an smb_fname.
4959 */
4960 static int fruit_stat_base(vfs_handle_struct *handle,
4961 struct smb_filename *smb_fname,
4962 bool follow_links)
4963 {
4964 char *tmp_stream_name;
4965 int rc;
4966
4967 tmp_stream_name = smb_fname->stream_name;
4968 smb_fname->stream_name = NULL;
4969 if (follow_links) {
4970 rc = SMB_VFS_NEXT_STAT(handle, smb_fname);
4971 } else {
4972 rc = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
4973 }
4974 smb_fname->stream_name = tmp_stream_name;
4975
4976 DBG_DEBUG("fruit_stat_base [%s] dev [%ju] ino [%ju]\n",
4977 smb_fname->base_name,
4978 (uintmax_t)smb_fname->st.st_ex_dev,
4979 (uintmax_t)smb_fname->st.st_ex_ino);
4980 return rc;
4981 }
4982
4983 static int fruit_stat_meta_stream(vfs_handle_struct *handle,
4984 struct smb_filename *smb_fname,
4985 bool follow_links)
4986 {
4987 int ret;
4988 ino_t ino;
4989
4990 ret = fruit_stat_base(handle, smb_fname, false);
4991 if (ret != 0) {
4992 return -1;
4993 }
4994
4995 ino = fruit_inode(&smb_fname->st, smb_fname->stream_name);
4996
4997 if (follow_links) {
4998 ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
4999 } else {
5000 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
5001 }
5002
5003 smb_fname->st.st_ex_ino = ino;
5004
5005 return ret;
5006 }
5007
5008 static int fruit_stat_meta_netatalk(vfs_handle_struct *handle,
5009 struct smb_filename *smb_fname,
5010 bool follow_links)
5011 {
5012 struct adouble *ad = NULL;
5013
5014 ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_META);
5015 if (ad == NULL) {
5016 DBG_INFO("fruit_stat_meta %s: %s\n",
5017 smb_fname_str_dbg(smb_fname), strerror(errno));
5018 errno = ENOENT;
5019 return -1;
5020 }
5021 TALLOC_FREE(ad);
5022
5023 /* Populate the stat struct with info from the base file. */
5024 if (fruit_stat_base(handle, smb_fname, follow_links) == -1) {
5025 return -1;
5026 }
5027 smb_fname->st.st_ex_size = AFP_INFO_SIZE;
5028 smb_fname->st.st_ex_ino = fruit_inode(&smb_fname->st,
5029 smb_fname->stream_name);
5030 return 0;
5031 }
5032
5033 static int fruit_stat_meta(vfs_handle_struct *handle,
5034 struct smb_filename *smb_fname,
5035 bool follow_links)
5036 {
5037 struct fruit_config_data *config = NULL;
5038 int ret;
5039
5040 SMB_VFS_HANDLE_GET_DATA(handle, config,
5041 struct fruit_config_data, return -1);
5042
5043 switch (config->meta) {
5044 case FRUIT_META_STREAM:
5045 ret = fruit_stat_meta_stream(handle, smb_fname, follow_links);
5046 break;
5047
5048 case FRUIT_META_NETATALK:
5049 ret = fruit_stat_meta_netatalk(handle, smb_fname, follow_links);
5050 break;
5051
5052 default:
5053 DBG_ERR("Unexpected meta config [%d]\n", config->meta);
5054 return -1;
5055 }
5056
5057 return ret;
5058 }
5059
5060 static int fruit_stat_rsrc_netatalk(vfs_handle_struct *handle,
5061 struct smb_filename *smb_fname,
5062 bool follow_links)
5063 {
5064 struct adouble *ad = NULL;
5065 int ret;
5066
5067 ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_RSRC);
5068 if (ad == NULL) {
5069 errno = ENOENT;
5070 return -1;
5071 }
5072
5073 /* Populate the stat struct with info from the base file. */
5074 ret = fruit_stat_base(handle, smb_fname, follow_links);
5075 if (ret != 0) {
5076 TALLOC_FREE(ad);
5077 return -1;
5078 }
5079
5080 smb_fname->st.st_ex_size = ad_getentrylen(ad, ADEID_RFORK);
5081 smb_fname->st.st_ex_ino = fruit_inode(&smb_fname->st,
5082 smb_fname->stream_name);
5083 TALLOC_FREE(ad);
5084 return 0;
5085 }
5086
5087 static int fruit_stat_rsrc_stream(vfs_handle_struct *handle,
5088 struct smb_filename *smb_fname,
5089 bool follow_links)
5090 {
5091 int ret;
5092
5093 if (follow_links) {
5094 ret = SMB_VFS_NEXT_STAT(handle, smb_fname);
5095 } else {
5096 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
5097 }
5098
5099 return ret;
5100 }
5101
5102 static int fruit_stat_rsrc_xattr(vfs_handle_struct *handle,
5103 struct smb_filename *smb_fname,
5104 bool follow_links)
5105 {
5106 #ifdef HAVE_ATTROPEN
5107 int ret;
5108 int fd = -1;
5109
5110 /* Populate the stat struct with info from the base file. */
5111 ret = fruit_stat_base(handle, smb_fname, follow_links);
5112 if (ret != 0) {
5113 return -1;
5114 }
5115
5116 fd = attropen(smb_fname->base_name,
5117 AFPRESOURCE_EA_NETATALK,
5118 O_RDONLY);
5119 if (fd == -1) {
5120 return 0;
5121 }
5122
5123 ret = sys_fstat(fd, &smb_fname->st, false);
5124 if (ret != 0) {
5125 close(fd);
5126 DBG_ERR("fstat [%s:%s] failed\n", smb_fname->base_name,
5127 AFPRESOURCE_EA_NETATALK);
5128 return -1;
5129 }
5130 close(fd);
5131 fd = -1;
5132
5133 smb_fname->st.st_ex_ino = fruit_inode(&smb_fname->st,
5134 smb_fname->stream_name);
5135
5136 return ret;
5137
5138 #else
5139 errno = ENOSYS;
5140 return -1;
5141 #endif
5142 }
5143
5144 static int fruit_stat_rsrc(vfs_handle_struct *handle,
5145 struct smb_filename *smb_fname,
5146 bool follow_links)
5147 {
5148 struct fruit_config_data *config = NULL;
5149 int ret;
5150
5151 DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
5152
5153 SMB_VFS_HANDLE_GET_DATA(handle, config,
5154 struct fruit_config_data, return -1);
5155
5156 switch (config->rsrc) {
5157 case FRUIT_RSRC_STREAM:
5158 ret = fruit_stat_rsrc_stream(handle, smb_fname, follow_links);
5159 break;
5160
5161 case FRUIT_RSRC_XATTR:
5162 ret = fruit_stat_rsrc_xattr(handle, smb_fname, follow_links);
5163 break;
5164
5165 case FRUIT_RSRC_ADFILE:
5166 ret = fruit_stat_rsrc_netatalk(handle, smb_fname, follow_links);
5167 break;
5168
5169 default:
5170 DBG_ERR("Unexpected rsrc config [%d]\n", config->rsrc);
5171 return -1;
5172 }
5173
5174 return ret;
5175 }
5176
5177 static int fruit_stat(vfs_handle_struct *handle,
5178 struct smb_filename *smb_fname)
5179 {
5180 int rc = -1;
5181
5182 DEBUG(10, ("fruit_stat called for %s\n",
5183 smb_fname_str_dbg(smb_fname)));
5184
5185 if (!is_ntfs_stream_smb_fname(smb_fname)
5186 || is_ntfs_default_stream_smb_fname(smb_fname)) {
5187 rc = SMB_VFS_NEXT_STAT(handle, smb_fname);
5188 if (rc == 0) {
5189 update_btime(handle, smb_fname);
5190 }
5191 return rc;
5192 }
5193
5194 /*
5195 * Note if lp_posix_paths() is true, we can never
5196 * get here as is_ntfs_stream_smb_fname() is
5197 * always false. So we never need worry about
5198 * not following links here.
5199 */
5200
5201 if (is_afpinfo_stream(smb_fname)) {
5202 rc = fruit_stat_meta(handle, smb_fname, true);
5203 } else if (is_afpresource_stream(smb_fname)) {
5204 rc = fruit_stat_rsrc(handle, smb_fname, true);
5205 } else {
5206 return SMB_VFS_NEXT_STAT(handle, smb_fname);
5207 }
5208
5209 if (rc == 0) {
5210 update_btime(handle, smb_fname);
5211 smb_fname->st.st_ex_mode &= ~S_IFMT;
5212 smb_fname->st.st_ex_mode |= S_IFREG;
5213 smb_fname->st.st_ex_blocks =
5214 smb_fname->st.st_ex_size / STAT_ST_BLOCKSIZE + 1;
5215 }
5216 return rc;
5217 }
5218
5219 static int fruit_lstat(vfs_handle_struct *handle,
5220 struct smb_filename *smb_fname)
5221 {
5222 int rc = -1;
5223
5224 DEBUG(10, ("fruit_lstat called for %s\n",
5225 smb_fname_str_dbg(smb_fname)));
5226
5227 if (!is_ntfs_stream_smb_fname(smb_fname)
5228 || is_ntfs_default_stream_smb_fname(smb_fname)) {
5229 rc = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
5230 if (rc == 0) {
5231 update_btime(handle, smb_fname);
5232 }
5233 return rc;
5234 }
5235
5236 if (is_afpinfo_stream(smb_fname)) {
5237 rc = fruit_stat_meta(handle, smb_fname, false);
5238 } else if (is_afpresource_stream(smb_fname)) {
5239 rc = fruit_stat_rsrc(handle, smb_fname, false);
5240 } else {
5241 return SMB_VFS_NEXT_LSTAT(handle, smb_fname);
5242 }
5243
5244 if (rc == 0) {
5245 update_btime(handle, smb_fname);
5246 smb_fname->st.st_ex_mode &= ~S_IFMT;
5247 smb_fname->st.st_ex_mode |= S_IFREG;
5248 smb_fname->st.st_ex_blocks =
5249 smb_fname->st.st_ex_size / STAT_ST_BLOCKSIZE + 1;
5250 }
5251 return rc;
5252 }
5253
5254 static int fruit_fstat_meta_stream(vfs_handle_struct *handle,
5255 files_struct *fsp,
5256 SMB_STRUCT_STAT *sbuf)
5257 {
5258 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
5259 ino_t ino;
5260 int ret;
5261
5262 if (fio == NULL) {
5263 return -1;
5264 }
5265
5266 if (fio->fake_fd) {
5267 ret = fruit_stat_base(handle, fsp->base_fsp->fsp_name, false);
5268 if (ret != 0) {
5269 return -1;
5270 }
5271
5272 *sbuf = fsp->base_fsp->fsp_name->st;
5273 sbuf->st_ex_size = AFP_INFO_SIZE;
5274 sbuf->st_ex_ino = fruit_inode(sbuf, fsp->fsp_name->stream_name);
5275 return 0;
5276 }
5277
5278 ret = fruit_stat_base(handle, fsp->base_fsp->fsp_name, false);
5279 if (ret != 0) {
5280 return -1;
5281 }
5282 *sbuf = fsp->base_fsp->fsp_name->st;
5283
5284 ino = fruit_inode(sbuf, fsp->fsp_name->stream_name);
5285
5286 ret = SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
5287 if (ret != 0) {
5288 return -1;
5289 }
5290
5291 sbuf->st_ex_ino = ino;
5292 return 0;
5293 }
5294
5295 static int fruit_fstat_meta_netatalk(vfs_handle_struct *handle,
5296 files_struct *fsp,
5297 SMB_STRUCT_STAT *sbuf)
5298 {
5299 int ret;
5300
5301 ret = fruit_stat_base(handle, fsp->base_fsp->fsp_name, false);
5302 if (ret != 0) {
5303 return -1;
5304 }
5305
5306 *sbuf = fsp->base_fsp->fsp_name->st;
5307 sbuf->st_ex_size = AFP_INFO_SIZE;
5308 sbuf->st_ex_ino = fruit_inode(sbuf, fsp->fsp_name->stream_name);
5309
5310 return 0;
5311 }
5312
5313 static int fruit_fstat_meta(vfs_handle_struct *handle,
5314 files_struct *fsp,
5315 SMB_STRUCT_STAT *sbuf,
5316 struct fio *fio)
5317 {
5318 int ret;
5319
5320 DBG_DEBUG("Path [%s]\n", fsp_str_dbg(fsp));
5321
5322 switch (fio->config->meta) {
5323 case FRUIT_META_STREAM:
5324 ret = fruit_fstat_meta_stream(handle, fsp, sbuf);
5325 break;
5326
5327 case FRUIT_META_NETATALK:
5328 ret = fruit_fstat_meta_netatalk(handle, fsp, sbuf);
5329 break;
5330
5331 default:
5332 DBG_ERR("Unexpected meta config [%d]\n", fio->config->meta);
5333 return -1;
5334 }
5335
5336 DBG_DEBUG("Path [%s] ret [%d]\n", fsp_str_dbg(fsp), ret);
5337 return ret;
5338 }
5339
5340 static int fruit_fstat_rsrc_xattr(vfs_handle_struct *handle,
5341 files_struct *fsp,
5342 SMB_STRUCT_STAT *sbuf)
5343 {
5344 return SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
5345 }
5346
5347 static int fruit_fstat_rsrc_stream(vfs_handle_struct *handle,
5348 files_struct *fsp,
5349 SMB_STRUCT_STAT *sbuf)
5350 {
5351 return SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
5352 }
5353
5354 static int fruit_fstat_rsrc_adouble(vfs_handle_struct *handle,
5355 files_struct *fsp,
5356 SMB_STRUCT_STAT *sbuf)
5357 {
5358 struct adouble *ad = NULL;
5359 int ret;
5360
5361 /* Populate the stat struct with info from the base file. */
5362 ret = fruit_stat_base(handle, fsp->base_fsp->fsp_name, false);
5363 if (ret == -1) {
5364 return -1;
5365 }
5366
5367 ad = ad_get(talloc_tos(), handle,
5368 fsp->base_fsp->fsp_name,
5369 ADOUBLE_RSRC);
5370 if (ad == NULL) {
5371 DBG_ERR("ad_get [%s] failed [%s]\n",
5372 fsp_str_dbg(fsp), strerror(errno));
5373 return -1;
5374 }
5375
5376 *sbuf = fsp->base_fsp->fsp_name->st;
5377 sbuf->st_ex_size = ad_getentrylen(ad, ADEID_RFORK);
5378 sbuf->st_ex_ino = fruit_inode(sbuf, fsp->fsp_name->stream_name);
5379
5380 TALLOC_FREE(ad);
5381 return 0;
5382 }
5383
5384 static int fruit_fstat_rsrc(vfs_handle_struct *handle, files_struct *fsp,
5385 SMB_STRUCT_STAT *sbuf, struct fio *fio)
5386 {
5387 int ret;
5388
5389 switch (fio->config->rsrc) {
5390 case FRUIT_RSRC_STREAM:
5391 ret = fruit_fstat_rsrc_stream(handle, fsp, sbuf);
5392 break;
5393
5394 case FRUIT_RSRC_ADFILE:
5395 ret = fruit_fstat_rsrc_adouble(handle, fsp, sbuf);
5396 break;
5397
5398 case FRUIT_RSRC_XATTR:
5399 ret = fruit_fstat_rsrc_xattr(handle, fsp, sbuf);
5400 break;
5401
5402 default:
5403 DBG_ERR("Unexpected rsrc config [%d]\n", fio->config->rsrc);
5404 return -1;
5405 }
5406
5407 return ret;
5408 }
5409
5410 static int fruit_fstat(vfs_handle_struct *handle, files_struct *fsp,
5411 SMB_STRUCT_STAT *sbuf)
5412 {
5413 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
5414 int rc;
5415
5416 if (fio == NULL) {
5417 return SMB_VFS_NEXT_FSTAT(handle, fsp, sbuf);
5418 }
5419
5420 DBG_DEBUG("Path [%s]\n", fsp_str_dbg(fsp));
5421
5422 if (fio->type == ADOUBLE_META) {
5423 rc = fruit_fstat_meta(handle, fsp, sbuf, fio);
5424 } else {
5425 rc = fruit_fstat_rsrc(handle, fsp, sbuf, fio);
5426 }
5427
5428 if (rc == 0) {
5429 sbuf->st_ex_mode &= ~S_IFMT;
5430 sbuf->st_ex_mode |= S_IFREG;
5431 sbuf->st_ex_blocks = sbuf->st_ex_size / STAT_ST_BLOCKSIZE + 1;
5432 }
5433
5434 DBG_DEBUG("Path [%s] rc [%d] size [%"PRIdMAX"]\n",
5435 fsp_str_dbg(fsp), rc, (intmax_t)sbuf->st_ex_size);
5436 return rc;
5437 }
5438
5439 static NTSTATUS delete_invalid_meta_stream(
5440 vfs_handle_struct *handle,
5441 const struct smb_filename *smb_fname,
5442 TALLOC_CTX *mem_ctx,
5443 unsigned int *pnum_streams,
5444 struct stream_struct **pstreams,
5445 off_t size)
5446 {
5447 struct smb_filename *sname = NULL;
5448 int ret;
5449 bool ok;
5450
5451 ok = del_fruit_stream(mem_ctx, pnum_streams, pstreams, AFPINFO_STREAM);
5452 if (!ok) {
5453 return NT_STATUS_INTERNAL_ERROR;
5454 }
5455
5456 if (size == 0) {
5457 return NT_STATUS_OK;
5458 }
5459
5460 sname = synthetic_smb_fname(talloc_tos(),
5461 smb_fname->base_name,
5462 AFPINFO_STREAM_NAME,
5463 NULL, 0);
5464 if (sname == NULL) {
5465 return NT_STATUS_NO_MEMORY;
5466 }
5467
5468 ret = SMB_VFS_NEXT_UNLINK(handle, sname);
5469 TALLOC_FREE(sname);
5470 if (ret != 0) {
5471 DBG_ERR("Removing [%s] failed\n", smb_fname_str_dbg(sname));
5472 return map_nt_error_from_unix(errno);
5473 }
5474
5475 return NT_STATUS_OK;
5476 }
5477
5478 static NTSTATUS fruit_streaminfo_meta_stream(
5479 vfs_handle_struct *handle,
5480 struct files_struct *fsp,
5481 const struct smb_filename *smb_fname,
5482 TALLOC_CTX *mem_ctx,
5483 unsigned int *pnum_streams,
5484 struct stream_struct **pstreams)
5485 {
5486 struct stream_struct *stream = *pstreams;
5487 unsigned int num_streams = *pnum_streams;
5488 int i;
5489
5490 for (i = 0; i < num_streams; i++) {
5491 if (strequal_m(stream[i].name, AFPINFO_STREAM)) {
5492 break;
5493 }
5494 }
5495
5496 if (i == num_streams) {
5497 return NT_STATUS_OK;
5498 }
5499
5500 if (stream[i].size != AFP_INFO_SIZE) {
5501 DBG_ERR("Removing invalid AFPINFO_STREAM size [%jd] from [%s]\n",
5502 (intmax_t)stream[i].size, smb_fname_str_dbg(smb_fname));
5503
5504 return delete_invalid_meta_stream(handle,
5505 smb_fname,
5506 mem_ctx,
5507 pnum_streams,
5508 pstreams,
5509 stream[i].size);
5510 }
5511
5512
5513 return NT_STATUS_OK;
5514 }
5515
5516 static NTSTATUS fruit_streaminfo_meta_netatalk(
5517 vfs_handle_struct *handle,
5518 struct files_struct *fsp,
5519 const struct smb_filename *smb_fname,
5520 TALLOC_CTX *mem_ctx,
5521 unsigned int *pnum_streams,
5522 struct stream_struct **pstreams)
5523 {
5524 struct stream_struct *stream = *pstreams;
5525 unsigned int num_streams = *pnum_streams;
5526 struct adouble *ad = NULL;
5527 bool is_fi_empty;
5528 int i;
5529 bool ok;
5530
5531 /* Remove the Netatalk xattr from the list */
5532 ok = del_fruit_stream(mem_ctx, pnum_streams, pstreams,
5533 ":" NETATALK_META_XATTR ":$DATA");
5534 if (!ok) {
5535 return NT_STATUS_NO_MEMORY;
5536 }
5537
5538 /*
5539 * Check if there's a AFPINFO_STREAM from the VFS streams
5540 * backend and if yes, remove it from the list
5541 */
5542 for (i = 0; i < num_streams; i++) {
5543 if (strequal_m(stream[i].name, AFPINFO_STREAM)) {
5544 break;
5545 }
5546 }
5547
5548 if (i < num_streams) {
5549 DBG_WARNING("Unexpected AFPINFO_STREAM on [%s]\n",
5550 smb_fname_str_dbg(smb_fname));
5551
5552 ok = del_fruit_stream(mem_ctx, pnum_streams, pstreams,
5553 AFPINFO_STREAM);
5554 if (!ok) {
5555 return NT_STATUS_INTERNAL_ERROR;
5556 }
5557 }
5558
5559 ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_META);
5560 if (ad == NULL) {
5561 return NT_STATUS_OK;
5562 }
5563
5564 is_fi_empty = ad_empty_finderinfo(ad);
5565 TALLOC_FREE(ad);
5566
5567 if (is_fi_empty) {
5568 return NT_STATUS_OK;
5569 }
5570
5571 ok = add_fruit_stream(mem_ctx, pnum_streams, pstreams,
5572 AFPINFO_STREAM_NAME, AFP_INFO_SIZE,
5573 smb_roundup(handle->conn, AFP_INFO_SIZE));
5574 if (!ok) {
5575 return NT_STATUS_NO_MEMORY;
5576 }
5577
5578 return NT_STATUS_OK;
5579 }
5580
5581 static NTSTATUS fruit_streaminfo_meta(vfs_handle_struct *handle,
5582 struct files_struct *fsp,
5583 const struct smb_filename *smb_fname,
5584 TALLOC_CTX *mem_ctx,
5585 unsigned int *pnum_streams,
5586 struct stream_struct **pstreams)
5587 {
5588 struct fruit_config_data *config = NULL;
5589 NTSTATUS status;
5590
5591 SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
5592 return NT_STATUS_INTERNAL_ERROR);
5593
5594 switch (config->meta) {
5595 case FRUIT_META_NETATALK:
5596 status = fruit_streaminfo_meta_netatalk(handle, fsp, smb_fname,
5597 mem_ctx, pnum_streams,
5598 pstreams);
5599 break;
5600
5601 case FRUIT_META_STREAM:
5602 status = fruit_streaminfo_meta_stream(handle, fsp, smb_fname,
5603 mem_ctx, pnum_streams,
5604 pstreams);
5605 break;
5606
5607 default:
5608 return NT_STATUS_INTERNAL_ERROR;
5609 }
5610
5611 return status;
5612 }
5613
5614 static NTSTATUS fruit_streaminfo_rsrc_stream(
5615 vfs_handle_struct *handle,
5616 struct files_struct *fsp,
5617 const struct smb_filename *smb_fname,
5618 TALLOC_CTX *mem_ctx,
5619 unsigned int *pnum_streams,
5620 struct stream_struct **pstreams)
5621 {
5622 bool ok;
5623
5624 ok = filter_empty_rsrc_stream(pnum_streams, pstreams);
5625 if (!ok) {
5626 DBG_ERR("Filtering resource stream failed\n");
5627 return NT_STATUS_INTERNAL_ERROR;
5628 }
5629 return NT_STATUS_OK;
5630 }
5631
5632 static NTSTATUS fruit_streaminfo_rsrc_xattr(
5633 vfs_handle_struct *handle,
5634 struct files_struct *fsp,
5635 const struct smb_filename *smb_fname,
5636 TALLOC_CTX *mem_ctx,
5637 unsigned int *pnum_streams,
5638 struct stream_struct **pstreams)
5639 {
5640 bool ok;
5641
5642 ok = filter_empty_rsrc_stream(pnum_streams, pstreams);
5643 if (!ok) {
5644 DBG_ERR("Filtering resource stream failed\n");
5645 return NT_STATUS_INTERNAL_ERROR;
5646 }
5647 return NT_STATUS_OK;
5648 }
5649
5650 static NTSTATUS fruit_streaminfo_rsrc_adouble(
5651 vfs_handle_struct *handle,
5652 struct files_struct *fsp,
5653 const struct smb_filename *smb_fname,
5654 TALLOC_CTX *mem_ctx,
5655 unsigned int *pnum_streams,
5656 struct stream_struct **pstreams)
5657 {
5658 struct stream_struct *stream = *pstreams;
5659 unsigned int num_streams = *pnum_streams;
5660 struct adouble *ad = NULL;
5661 bool ok;
5662 size_t rlen;
5663 int i;
5664
5665 /*
5666 * Check if there's a AFPRESOURCE_STREAM from the VFS streams backend
5667 * and if yes, remove it from the list
5668 */
5669 for (i = 0; i < num_streams; i++) {
5670 if (strequal_m(stream[i].name, AFPRESOURCE_STREAM)) {
5671 break;
5672 }
5673 }
5674
5675 if (i < num_streams) {
5676 DBG_WARNING("Unexpected AFPRESOURCE_STREAM on [%s]\n",
5677 smb_fname_str_dbg(smb_fname));
5678
5679 ok = del_fruit_stream(mem_ctx, pnum_streams, pstreams,
5680 AFPRESOURCE_STREAM);
5681 if (!ok) {
5682 return NT_STATUS_INTERNAL_ERROR;
5683 }
5684 }
5685
5686 ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_RSRC);
5687 if (ad == NULL) {
5688 return NT_STATUS_OK;
5689 }
5690
5691 rlen = ad_getentrylen(ad, ADEID_RFORK);
5692 TALLOC_FREE(ad);
5693
5694 if (rlen == 0) {
5695 return NT_STATUS_OK;
5696 }
5697
5698 ok = add_fruit_stream(mem_ctx, pnum_streams, pstreams,
5699 AFPRESOURCE_STREAM_NAME, rlen,
5700 smb_roundup(handle->conn, rlen));
5701 if (!ok) {
5702 return NT_STATUS_NO_MEMORY;
5703 }
5704
5705 return NT_STATUS_OK;
5706 }
5707
5708 static NTSTATUS fruit_streaminfo_rsrc(vfs_handle_struct *handle,
5709 struct files_struct *fsp,
5710 const struct smb_filename *smb_fname,
5711 TALLOC_CTX *mem_ctx,
5712 unsigned int *pnum_streams,
5713 struct stream_struct **pstreams)
5714 {
5715 struct fruit_config_data *config = NULL;
5716 NTSTATUS status;
5717
5718 SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
5719 return NT_STATUS_INTERNAL_ERROR);
5720
5721 switch (config->rsrc) {
5722 case FRUIT_RSRC_STREAM:
5723 status = fruit_streaminfo_rsrc_stream(handle, fsp, smb_fname,
5724 mem_ctx, pnum_streams,
5725 pstreams);
5726 break;
5727
5728 case FRUIT_RSRC_XATTR:
5729 status = fruit_streaminfo_rsrc_xattr(handle, fsp, smb_fname,
5730 mem_ctx, pnum_streams,
5731 pstreams);
5732 break;
5733
5734 case FRUIT_RSRC_ADFILE:
5735 status = fruit_streaminfo_rsrc_adouble(handle, fsp, smb_fname,
5736 mem_ctx, pnum_streams,
5737 pstreams);
5738 break;
5739
5740 default:
5741 return NT_STATUS_INTERNAL_ERROR;
5742 }
5743
5744 return status;
5745 }
5746
5747 static void fruit_filter_empty_streams(unsigned int *pnum_streams,
5748 struct stream_struct **pstreams)
5749 {
5750 unsigned num_streams = *pnum_streams;
5751 struct stream_struct *streams = *pstreams;
5752 unsigned i = 0;
5753
5754 if (!global_fruit_config.nego_aapl) {
5755 return;
5756 }
5757
5758 while (i < num_streams) {
5759 struct smb_filename smb_fname = (struct smb_filename) {
5760 .stream_name = streams[i].name,
5761 };
5762
5763 if (is_ntfs_default_stream_smb_fname(&smb_fname)
5764 || streams[i].size > 0)
5765 {
5766 i++;
5767 continue;
5768 }
5769
5770 streams[i] = streams[num_streams - 1];
5771 num_streams--;
5772 }
5773
5774 *pnum_streams = num_streams;
5775 }
5776
5777 static NTSTATUS fruit_streaminfo(vfs_handle_struct *handle,
5778 struct files_struct *fsp,
5779 const struct smb_filename *smb_fname,
5780 TALLOC_CTX *mem_ctx,
5781 unsigned int *pnum_streams,
5782 struct stream_struct **pstreams)
5783 {
5784 struct fruit_config_data *config = NULL;
5785 NTSTATUS status;
5786
5787 SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
5788 return NT_STATUS_UNSUCCESSFUL);
5789
5790 DBG_DEBUG("Path [%s]\n", smb_fname_str_dbg(smb_fname));
5791
5792 status = SMB_VFS_NEXT_STREAMINFO(handle, fsp, smb_fname, mem_ctx,
5793 pnum_streams, pstreams);
5794 if (!NT_STATUS_IS_OK(status)) {
5795 return status;
5796 }
5797
5798 fruit_filter_empty_streams(pnum_streams, pstreams);
5799
5800 status = fruit_streaminfo_meta(handle, fsp, smb_fname,
5801 mem_ctx, pnum_streams, pstreams);
5802 if (!NT_STATUS_IS_OK(status)) {
5803 return status;
5804 }
5805
5806 status = fruit_streaminfo_rsrc(handle, fsp, smb_fname,
5807 mem_ctx, pnum_streams, pstreams);
5808 if (!NT_STATUS_IS_OK(status)) {
5809 return status;
5810 }
5811
5812 return NT_STATUS_OK;
5813 }
5814
5815 static int fruit_ntimes(vfs_handle_struct *handle,
5816 const struct smb_filename *smb_fname,
5817 struct smb_file_time *ft)
5818 {
5819 int rc = 0;
5820 struct adouble *ad = NULL;
5821 struct fruit_config_data *config = NULL;
5822
5823 SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
5824 return -1);
5825
5826 if ((config->meta != FRUIT_META_NETATALK) ||
5827 null_timespec(ft->create_time))
5828 {
5829 return SMB_VFS_NEXT_NTIMES(handle, smb_fname, ft);
5830 }
5831
5832 DEBUG(10,("set btime for %s to %s\n", smb_fname_str_dbg(smb_fname),
5833 time_to_asc(convert_timespec_to_time_t(ft->create_time))));
5834
5835 ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_META);
5836 if (ad == NULL) {
5837 goto exit;
5838 }
5839
5840 ad_setdate(ad, AD_DATE_CREATE | AD_DATE_UNIX,
5841 convert_time_t_to_uint32_t(ft->create_time.tv_sec));
5842
5843 rc = ad_set(handle, ad, smb_fname);
5844
5845 exit:
5846
5847 TALLOC_FREE(ad);
5848 if (rc != 0) {
5849 DEBUG(1, ("fruit_ntimes: %s\n", smb_fname_str_dbg(smb_fname)));
5850 return -1;
5851 }
5852 return SMB_VFS_NEXT_NTIMES(handle, smb_fname, ft);
5853 }
5854
5855 static int fruit_fallocate(struct vfs_handle_struct *handle,
5856 struct files_struct *fsp,
5857 uint32_t mode,
5858 off_t offset,
5859 off_t len)
5860 {
5861 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
5862
5863 if (fio == NULL) {
5864 return SMB_VFS_NEXT_FALLOCATE(handle, fsp, mode, offset, len);
5865 }
5866
5867 /* Let the pwrite code path handle it. */
5868 errno = ENOSYS;
5869 return -1;
5870 }
5871
5872 static int fruit_ftruncate_rsrc_xattr(struct vfs_handle_struct *handle,
5873 struct files_struct *fsp,
5874 off_t offset)
5875 {
5876 #ifdef HAVE_ATTROPEN
5877 return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, offset);
5878 #endif
5879 return 0;
5880 }
5881
5882 static int fruit_ftruncate_rsrc_adouble(struct vfs_handle_struct *handle,
5883 struct files_struct *fsp,
5884 off_t offset)
5885 {
5886 int rc;
5887 struct adouble *ad = NULL;
5888 off_t ad_off;
5889
5890 ad = ad_fget(talloc_tos(), handle, fsp, ADOUBLE_RSRC);
5891 if (ad == NULL) {
5892 DBG_DEBUG("ad_get [%s] failed [%s]\n",
5893 fsp_str_dbg(fsp), strerror(errno));
5894 return -1;
5895 }
5896
5897 ad_off = ad_getentryoff(ad, ADEID_RFORK);
5898
5899 rc = ftruncate(fsp->fh->fd, offset + ad_off);
5900 if (rc != 0) {
5901 TALLOC_FREE(ad);
5902 return -1;
5903 }
5904
5905 ad_setentrylen(ad, ADEID_RFORK, offset);
5906
5907 rc = ad_fset(handle, ad, fsp);
5908 if (rc != 0) {
5909 DBG_ERR("ad_fset [%s] failed [%s]\n",
5910 fsp_str_dbg(fsp), strerror(errno));
5911 TALLOC_FREE(ad);
5912 return -1;
5913 }
5914
5915 TALLOC_FREE(ad);
5916 return 0;
5917 }
5918
5919 static int fruit_ftruncate_rsrc_stream(struct vfs_handle_struct *handle,
5920 struct files_struct *fsp,
5921 off_t offset)
5922 {
5923 return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, offset);
5924 }
5925
5926 static int fruit_ftruncate_rsrc(struct vfs_handle_struct *handle,
5927 struct files_struct *fsp,
5928 off_t offset)
5929 {
5930 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
5931 int ret;
5932
5933 if (fio == NULL) {
5934 DBG_ERR("Failed to fetch fsp extension");
5935 return -1;
5936 }
5937
5938 switch (fio->config->rsrc) {
5939 case FRUIT_RSRC_XATTR:
5940 ret = fruit_ftruncate_rsrc_xattr(handle, fsp, offset);
5941 break;
5942
5943 case FRUIT_RSRC_ADFILE:
5944 ret = fruit_ftruncate_rsrc_adouble(handle, fsp, offset);
5945 break;
5946
5947 case FRUIT_RSRC_STREAM:
5948 ret = fruit_ftruncate_rsrc_stream(handle, fsp, offset);
5949 break;
5950
5951 default:
5952 DBG_ERR("Unexpected rsrc config [%d]\n", fio->config->rsrc);
5953 return -1;
5954 }
5955
5956
5957 return ret;
5958 }
5959
5960 static int fruit_ftruncate_meta(struct vfs_handle_struct *handle,
5961 struct files_struct *fsp,
5962 off_t offset)
5963 {
5964 if (offset > 60) {
5965 DBG_WARNING("ftruncate %s to %jd",
5966 fsp_str_dbg(fsp), (intmax_t)offset);
5967 /* OS X returns NT_STATUS_ALLOTTED_SPACE_EXCEEDED */
5968 errno = EOVERFLOW;
5969 return -1;
5970 }
5971
5972 /* OS X returns success but does nothing */
5973 DBG_INFO("ignoring ftruncate %s to %jd\n",
5974 fsp_str_dbg(fsp), (intmax_t)offset);
5975 return 0;
5976 }
5977
5978 static int fruit_ftruncate(struct vfs_handle_struct *handle,
5979 struct files_struct *fsp,
5980 off_t offset)
5981 {
5982 struct fio *fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
5983 int ret;
5984
5985 DBG_DEBUG("Path [%s] offset [%"PRIdMAX"]\n", fsp_str_dbg(fsp),
5986 (intmax_t)offset);
5987
5988 if (fio == NULL) {
5989 return SMB_VFS_NEXT_FTRUNCATE(handle, fsp, offset);
5990 }
5991
5992 if (fio->type == ADOUBLE_META) {
5993 ret = fruit_ftruncate_meta(handle, fsp, offset);
5994 } else {
5995 ret = fruit_ftruncate_rsrc(handle, fsp, offset);
5996 }
5997
5998 DBG_DEBUG("Path [%s] result [%d]\n", fsp_str_dbg(fsp), ret);
5999 return ret;
6000 }
6001
6002 static NTSTATUS fruit_create_file(vfs_handle_struct *handle,
6003 struct smb_request *req,
6004 uint16_t root_dir_fid,
6005 struct smb_filename *smb_fname,
6006 uint32_t access_mask,
6007 uint32_t share_access,
6008 uint32_t create_disposition,
6009 uint32_t create_options,
6010 uint32_t file_attributes,
6011 uint32_t oplock_request,
6012 struct smb2_lease *lease,
6013 uint64_t allocation_size,
6014 uint32_t private_flags,
6015 struct security_descriptor *sd,
6016 struct ea_list *ea_list,
6017 files_struct **result,
6018 int *pinfo,
6019 const struct smb2_create_blobs *in_context_blobs,
6020 struct smb2_create_blobs *out_context_blobs)
6021 {
6022 NTSTATUS status;
6023 struct fruit_config_data *config = NULL;
6024 files_struct *fsp = NULL;
6025 struct fio *fio = NULL;
6026 bool internal_open = (oplock_request & INTERNAL_OPEN_ONLY);
6027 int ret;
6028
6029 status = check_aapl(handle, req, in_context_blobs, out_context_blobs);
6030 if (!NT_STATUS_IS_OK(status)) {
6031 goto fail;
6032 }
6033
6034 SMB_VFS_HANDLE_GET_DATA(handle, config, struct fruit_config_data,
6035 return NT_STATUS_UNSUCCESSFUL);
6036
6037 if (is_apple_stream(smb_fname) && !internal_open) {
6038 ret = ad_convert(handle, smb_fname);
6039 if (ret != 0) {
6040 DBG_ERR("ad_convert() failed\n");
6041 return NT_STATUS_UNSUCCESSFUL;
6042 }
6043 }
6044
6045 status = SMB_VFS_NEXT_CREATE_FILE(
6046 handle, req, root_dir_fid, smb_fname,
6047 access_mask, share_access,
6048 create_disposition, create_options,
6049 file_attributes, oplock_request,
6050 lease,
6051 allocation_size, private_flags,
6052 sd, ea_list, result,
6053 pinfo, in_context_blobs, out_context_blobs);
6054 if (!NT_STATUS_IS_OK(status)) {
6055 return status;
6056 }
6057
6058 fsp = *result;
6059
6060 if (global_fruit_config.nego_aapl) {
6061 if (config->posix_rename && fsp->is_directory) {
6062 /*
6063 * Enable POSIX directory rename behaviour
6064 */
6065 fsp->posix_flags |= FSP_POSIX_FLAGS_RENAME;
6066 }
6067 }
6068
6069 /*
6070 * If this is a plain open for existing files, opening an 0
6071 * byte size resource fork MUST fail with
6072 * NT_STATUS_OBJECT_NAME_NOT_FOUND.
6073 *
6074 * Cf the vfs_fruit torture tests in test_rfork_create().
6075 */
6076 if (global_fruit_config.nego_aapl &&
6077 create_disposition == FILE_OPEN &&
6078 smb_fname->st.st_ex_size == 0 &&
6079 is_ntfs_stream_smb_fname(smb_fname) &&
6080 !(is_ntfs_default_stream_smb_fname(smb_fname)))
6081 {
6082 status = NT_STATUS_OBJECT_NAME_NOT_FOUND;
6083 goto fail;
6084 }
6085
6086 fio = (struct fio *)VFS_FETCH_FSP_EXTENSION(handle, fsp);
6087 if (fio != NULL && pinfo != NULL && *pinfo == FILE_WAS_CREATED) {
6088 fio->created = true;
6089 }
6090
6091 if (is_ntfs_stream_smb_fname(smb_fname)
6092 || fsp->is_directory) {
6093 return status;
6094 }
6095
6096 if ((config->locking == FRUIT_LOCKING_NETATALK) &&
6097 (fsp->op != NULL))
6098 {
6099 status = fruit_check_access(
6100 handle, *result,
6101 access_mask,
6102 share_access);
6103 if (!NT_STATUS_IS_OK(status)) {
6104 goto fail;
6105 }
6106 }
6107
6108 return status;
6109
6110 fail:
6111 DEBUG(10, ("fruit_create_file: %s\n", nt_errstr(status)));
6112
6113 if (fsp) {
6114 close_file(req, fsp, ERROR_CLOSE);
6115 *result = fsp = NULL;
6116 }
6117
6118 return status;
6119 }
6120
6121 static NTSTATUS fruit_readdir_attr(struct vfs_handle_struct *handle,
6122 const struct smb_filename *fname,
6123 TALLOC_CTX *mem_ctx,
6124 struct readdir_attr_data **pattr_data)
6125 {
6126 struct fruit_config_data *config = NULL;
6127 struct readdir_attr_data *attr_data;
6128 NTSTATUS status;
6129 int ret;
6130
6131 SMB_VFS_HANDLE_GET_DATA(handle, config,
6132 struct fruit_config_data,
6133 return NT_STATUS_UNSUCCESSFUL);
6134
6135 if (!global_fruit_config.nego_aapl) {
6136 return SMB_VFS_NEXT_READDIR_ATTR(handle, fname, mem_ctx, pattr_data);
6137 }
6138
6139 DEBUG(10, ("fruit_readdir_attr %s\n", fname->base_name));
6140
6141 ret = ad_convert(handle, fname);
6142 if (ret != 0) {
6143 DBG_ERR("ad_convert() failed\n");
6144 return NT_STATUS_UNSUCCESSFUL;
6145 }
6146
6147 *pattr_data = talloc_zero(mem_ctx, struct readdir_attr_data);
6148 if (*pattr_data == NULL) {
6149 return NT_STATUS_UNSUCCESSFUL;
6150 }
6151 attr_data = *pattr_data;
6152 attr_data->type = RDATTR_AAPL;
6153
6154 /*
6155 * Mac metadata: compressed FinderInfo, resource fork length
6156 * and creation date
6157 */
6158 status = readdir_attr_macmeta(handle, fname, attr_data);
6159 if (!NT_STATUS_IS_OK(status)) {
6160 /*
6161 * Error handling is tricky: if we return failure from
6162 * this function, the corresponding directory entry
6163 * will to be passed to the client, so we really just
6164 * want to error out on fatal errors.
6165 */
6166 if (!NT_STATUS_EQUAL(status, NT_STATUS_ACCESS_DENIED)) {
6167 goto fail;
6168 }
6169 }
6170
6171 /*
6172 * UNIX mode
6173 */
6174 if (config->unix_info_enabled) {
6175 attr_data->attr_data.aapl.unix_mode = fname->st.st_ex_mode;
6176 }
6177
6178 /*
6179 * max_access
6180 */
6181 if (!config->readdir_attr_max_access) {
6182 attr_data->attr_data.aapl.max_access = FILE_GENERIC_ALL;
6183 } else {
6184 status = smbd_calculate_access_mask(
6185 handle->conn,
6186 fname,
6187 false,
6188 SEC_FLAG_MAXIMUM_ALLOWED,
6189 &attr_data->attr_data.aapl.max_access);
6190 if (!NT_STATUS_IS_OK(status)) {
6191 goto fail;
6192 }
6193 }
6194
6195 return NT_STATUS_OK;
6196
6197 fail:
6198 DEBUG(1, ("fruit_readdir_attr %s, error: %s\n",
6199 fname->base_name, nt_errstr(status)));
6200 TALLOC_FREE(*pattr_data);
6201 return status;
6202 }
6203
6204 static NTSTATUS fruit_fget_nt_acl(vfs_handle_struct *handle,
6205 files_struct *fsp,
6206 uint32_t security_info,
6207 TALLOC_CTX *mem_ctx,
6208 struct security_descriptor **ppdesc)
6209 {
6210 NTSTATUS status;
6211 struct security_ace ace;
6212 struct dom_sid sid;
6213 struct fruit_config_data *config;
6214
6215 SMB_VFS_HANDLE_GET_DATA(handle, config,
6216 struct fruit_config_data,
6217 return NT_STATUS_UNSUCCESSFUL);
6218
6219 status = SMB_VFS_NEXT_FGET_NT_ACL(handle, fsp, security_info,
6220 mem_ctx, ppdesc);
6221 if (!NT_STATUS_IS_OK(status)) {
6222 return status;
6223 }
6224
6225 /*
6226 * Add MS NFS style ACEs with uid, gid and mode
6227 */
6228 if (!global_fruit_config.nego_aapl) {
6229 return NT_STATUS_OK;
6230 }
6231 if (!config->unix_info_enabled) {
6232 return NT_STATUS_OK;
6233 }
6234
6235 /* First remove any existing ACE's with NFS style mode/uid/gid SIDs. */
6236 status = remove_virtual_nfs_aces(*ppdesc);
6237 if (!NT_STATUS_IS_OK(status)) {
6238 DBG_WARNING("failed to remove MS NFS style ACEs\n");
6239 return status;
6240 }
6241
6242 /* MS NFS style mode */
6243 sid_compose(&sid, &global_sid_Unix_NFS_Mode, fsp->fsp_name->st.st_ex_mode);
6244 init_sec_ace(&ace, &sid, SEC_ACE_TYPE_ACCESS_DENIED, 0, 0);
6245 status = security_descriptor_dacl_add(*ppdesc, &ace);
6246 if (!NT_STATUS_IS_OK(status)) {
6247 DEBUG(1,("failed to add MS NFS style ACE\n"));
6248 return status;
6249 }
6250
6251 /* MS NFS style uid */
6252 sid_compose(&sid, &global_sid_Unix_NFS_Users, fsp->fsp_name->st.st_ex_uid);
6253 init_sec_ace(&ace, &sid, SEC_ACE_TYPE_ACCESS_DENIED, 0, 0);
6254 status = security_descriptor_dacl_add(*ppdesc, &ace);
6255 if (!NT_STATUS_IS_OK(status)) {
6256 DEBUG(1,("failed to add MS NFS style ACE\n"));
6257 return status;
6258 }
6259
6260 /* MS NFS style gid */
6261 sid_compose(&sid, &global_sid_Unix_NFS_Groups, fsp->fsp_name->st.st_ex_gid);
6262 init_sec_ace(&ace, &sid, SEC_ACE_TYPE_ACCESS_DENIED, 0, 0);
6263 status = security_descriptor_dacl_add(*ppdesc, &ace);
6264 if (!NT_STATUS_IS_OK(status)) {
6265 DEBUG(1,("failed to add MS NFS style ACE\n"));
6266 return status;
6267 }
6268
6269 return NT_STATUS_OK;
6270 }
6271
6272 static NTSTATUS fruit_fset_nt_acl(vfs_handle_struct *handle,
6273 files_struct *fsp,
6274 uint32_t security_info_sent,
6275 const struct security_descriptor *orig_psd)
6276 {
6277 NTSTATUS status;
6278 bool do_chmod;
6279 mode_t ms_nfs_mode = 0;
6280 int result;
6281 struct security_descriptor *psd = NULL;
6282 uint32_t orig_num_aces = 0;
6283
6284 if (orig_psd->dacl != NULL) {
6285 orig_num_aces = orig_psd->dacl->num_aces;
6286 }
6287
6288 psd = security_descriptor_copy(talloc_tos(), orig_psd);
6289 if (psd == NULL) {
6290 return NT_STATUS_NO_MEMORY;
6291 }
6292
6293 DBG_DEBUG("fruit_fset_nt_acl: %s\n", fsp_str_dbg(fsp));
6294
6295 status = check_ms_nfs(handle, fsp, psd, &ms_nfs_mode, &do_chmod);
6296 if (!NT_STATUS_IS_OK(status)) {
6297 DEBUG(1, ("fruit_fset_nt_acl: check_ms_nfs failed%s\n", fsp_str_dbg(fsp)));
6298 TALLOC_FREE(psd);
6299 return status;
6300 }
6301
6302 /*
6303 * If only ms_nfs ACE entries were sent, ensure we set the DACL
6304 * sent/present flags correctly now we've removed them.
6305 */
6306
6307 if (orig_num_aces != 0) {
6308 /*
6309 * Are there any ACE's left ?
6310 */
6311 if (psd->dacl->num_aces == 0) {
6312 /* No - clear the DACL sent/present flags. */
6313 security_info_sent &= ~SECINFO_DACL;
6314 psd->type &= ~SEC_DESC_DACL_PRESENT;
6315 }
6316 }
6317
6318 status = SMB_VFS_NEXT_FSET_NT_ACL(handle, fsp, security_info_sent, psd);
6319 if (!NT_STATUS_IS_OK(status)) {
6320 DEBUG(1, ("fruit_fset_nt_acl: SMB_VFS_NEXT_FSET_NT_ACL failed%s\n", fsp_str_dbg(fsp)));
6321 TALLOC_FREE(psd);
6322 return status;
6323 }
6324
6325 if (do_chmod) {
6326 if (fsp->fh->fd != -1) {
6327 result = SMB_VFS_FCHMOD(fsp, ms_nfs_mode);
6328 } else {
6329 result = SMB_VFS_CHMOD(fsp->conn,
6330 fsp->fsp_name,
6331 ms_nfs_mode);
6332 }
6333
6334 if (result != 0) {
6335 DEBUG(1, ("chmod: %s, result: %d, %04o error %s\n", fsp_str_dbg(fsp),
6336 result, (unsigned)ms_nfs_mode,
6337 strerror(errno)));
6338 status = map_nt_error_from_unix(errno);
6339 TALLOC_FREE(psd);
6340 return status;
6341 }
6342 }
6343
6344 TALLOC_FREE(psd);
6345 return NT_STATUS_OK;
6346 }
6347
6348 static struct vfs_offload_ctx *fruit_offload_ctx;
6349
6350 struct fruit_offload_read_state {
6351 struct vfs_handle_struct *handle;
6352 struct tevent_context *ev;
6353 files_struct *fsp;
6354 uint32_t fsctl;
6355 DATA_BLOB token;
6356 };
6357
6358 static void fruit_offload_read_done(struct tevent_req *subreq);
6359
6360 static struct tevent_req *fruit_offload_read_send(
6361 TALLOC_CTX *mem_ctx,
6362 struct tevent_context *ev,
6363 struct vfs_handle_struct *handle,
6364 files_struct *fsp,
6365 uint32_t fsctl,
6366 uint32_t ttl,
6367 off_t offset,
6368 size_t to_copy)
6369 {
6370 struct tevent_req *req = NULL;
6371 struct tevent_req *subreq = NULL;
6372 struct fruit_offload_read_state *state = NULL;
6373
6374 req = tevent_req_create(mem_ctx, &state,
6375 struct fruit_offload_read_state);
6376 if (req == NULL) {
6377 return NULL;
6378 }
6379 *state = (struct fruit_offload_read_state) {
6380 .handle = handle,
6381 .ev = ev,
6382 .fsp = fsp,
6383 .fsctl = fsctl,
6384 };
6385
6386 subreq = SMB_VFS_NEXT_OFFLOAD_READ_SEND(mem_ctx, ev, handle, fsp,
6387 fsctl, ttl, offset, to_copy);
6388 if (tevent_req_nomem(subreq, req)) {
6389 return tevent_req_post(req, ev);
6390 }
6391 tevent_req_set_callback(subreq, fruit_offload_read_done, req);
6392 return req;
6393 }
6394
6395 static void fruit_offload_read_done(struct tevent_req *subreq)
6396 {
6397 struct tevent_req *req = tevent_req_callback_data(
6398 subreq, struct tevent_req);
6399 struct fruit_offload_read_state *state = tevent_req_data(
6400 req, struct fruit_offload_read_state);
6401 NTSTATUS status;
6402
6403 status = SMB_VFS_NEXT_OFFLOAD_READ_RECV(subreq,
6404 state->handle,
6405 state,
6406 &state->token);
6407 TALLOC_FREE(subreq);
6408 if (tevent_req_nterror(req, status)) {
6409 return;
6410 }
6411
6412 if (state->fsctl != FSCTL_SRV_REQUEST_RESUME_KEY) {
6413 tevent_req_done(req);
6414 return;
6415 }
6416
6417 status = vfs_offload_token_ctx_init(state->fsp->conn->sconn->client,
6418 &fruit_offload_ctx);
6419 if (tevent_req_nterror(req, status)) {
6420 return;
6421 }
6422
6423 status = vfs_offload_token_db_store_fsp(fruit_offload_ctx,
6424 state->fsp,
6425 &state->token);
6426 if (tevent_req_nterror(req, status)) {
6427 return;
6428 }
6429
6430 tevent_req_done(req);
6431 return;
6432 }
6433
6434 static NTSTATUS fruit_offload_read_recv(struct tevent_req *req,
6435 struct vfs_handle_struct *handle,
6436 TALLOC_CTX *mem_ctx,
6437 DATA_BLOB *token)
6438 {
6439 struct fruit_offload_read_state *state = tevent_req_data(
6440 req, struct fruit_offload_read_state);
6441 NTSTATUS status;
6442
6443 if (tevent_req_is_nterror(req, &status)) {
6444 tevent_req_received(req);
6445 return status;
6446 }
6447
6448 token->length = state->token.length;
6449 token->data = talloc_move(mem_ctx, &state->token.data);
6450
6451 tevent_req_received(req);
6452 return NT_STATUS_OK;
6453 }
6454
6455 struct fruit_offload_write_state {
6456 struct vfs_handle_struct *handle;
6457 off_t copied;
6458 struct files_struct *src_fsp;
6459 struct files_struct *dst_fsp;
6460 bool is_copyfile;
6461 };
6462
6463 static void fruit_offload_write_done(struct tevent_req *subreq);
6464 static struct tevent_req *fruit_offload_write_send(struct vfs_handle_struct *handle,
6465 TALLOC_CTX *mem_ctx,
6466 struct tevent_context *ev,
6467 uint32_t fsctl,
6468 DATA_BLOB *token,
6469 off_t transfer_offset,
6470 struct files_struct *dest_fsp,
6471 off_t dest_off,
6472 off_t num)
6473 {
6474 struct tevent_req *req, *subreq;
6475 struct fruit_offload_write_state *state;
6476 NTSTATUS status;
6477 struct fruit_config_data *config;
6478 off_t src_off = transfer_offset;
6479 files_struct *src_fsp = NULL;
6480 off_t to_copy = num;
6481 bool copyfile_enabled = false;
6482
6483 DEBUG(10,("soff: %ju, doff: %ju, len: %ju\n",
6484 (uintmax_t)src_off, (uintmax_t)dest_off, (uintmax_t)num));
6485
6486 SMB_VFS_HANDLE_GET_DATA(handle, config,
6487 struct fruit_config_data,
6488 return NULL);
6489
6490 req = tevent_req_create(mem_ctx, &state,
6491 struct fruit_offload_write_state);
6492 if (req == NULL) {
6493 return NULL;
6494 }
6495 state->handle = handle;
6496 state->dst_fsp = dest_fsp;
6497
6498 switch (fsctl) {
6499 case FSCTL_SRV_COPYCHUNK:
6500 case FSCTL_SRV_COPYCHUNK_WRITE:
6501 copyfile_enabled = config->copyfile_enabled;
6502 break;
6503 default:
6504 break;
6505 }
6506
6507 /*
6508 * Check if this a OS X copyfile style copychunk request with
6509 * a requested chunk count of 0 that was translated to a
6510 * offload_write_send VFS call overloading the parameters src_off
6511 * = dest_off = num = 0.
6512 */
6513 if (copyfile_enabled && num == 0 && src_off == 0 && dest_off == 0) {
6514 status = vfs_offload_token_db_fetch_fsp(
6515 fruit_offload_ctx, token, &src_fsp);
6516 if (tevent_req_nterror(req, status)) {
6517 return tevent_req_post(req, ev);
6518 }
6519 state->src_fsp = src_fsp;
6520
6521 status = vfs_stat_fsp(src_fsp);
6522 if (tevent_req_nterror(req, status)) {
6523 return tevent_req_post(req, ev);
6524 }
6525
6526 to_copy = src_fsp->fsp_name->st.st_ex_size;
6527 state->is_copyfile = true;
6528 }
6529
6530 subreq = SMB_VFS_NEXT_OFFLOAD_WRITE_SEND(handle,
6531 mem_ctx,
6532 ev,
6533 fsctl,
6534 token,
6535 transfer_offset,
6536 dest_fsp,
6537 dest_off,
6538 to_copy);
6539 if (tevent_req_nomem(subreq, req)) {
6540 return tevent_req_post(req, ev);
6541 }
6542
6543 tevent_req_set_callback(subreq, fruit_offload_write_done, req);
6544 return req;
6545 }
6546
6547 static void fruit_offload_write_done(struct tevent_req *subreq)
6548 {
6549 struct tevent_req *req = tevent_req_callback_data(
6550 subreq, struct tevent_req);
6551 struct fruit_offload_write_state *state = tevent_req_data(
6552 req, struct fruit_offload_write_state);
6553 NTSTATUS status;
6554 unsigned int num_streams = 0;
6555 struct stream_struct *streams = NULL;
6556 unsigned int i;
6557 struct smb_filename *src_fname_tmp = NULL;
6558 struct smb_filename *dst_fname_tmp = NULL;
6559
6560 status = SMB_VFS_NEXT_OFFLOAD_WRITE_RECV(state->handle,
6561 subreq,
6562 &state->copied);
6563 TALLOC_FREE(subreq);
6564 if (tevent_req_nterror(req, status)) {
6565 return;
6566 }
6567
6568 if (!state->is_copyfile) {
6569 tevent_req_done(req);
6570 return;
6571 }
6572
6573 /*
6574 * Now copy all remaining streams. We know the share supports
6575 * streams, because we're in vfs_fruit. We don't do this async
6576 * because streams are few and small.
6577 */
6578 status = vfs_streaminfo(state->handle->conn, state->src_fsp,
6579 state->src_fsp->fsp_name,
6580 req, &num_streams, &streams);
6581 if (tevent_req_nterror(req, status)) {
6582 return;
6583 }
6584
6585 if (num_streams == 1) {
6586 /* There is always one stream, ::$DATA. */
6587 tevent_req_done(req);
6588 return;
6589 }
6590
6591 for (i = 0; i < num_streams; i++) {
6592 DEBUG(10, ("%s: stream: '%s'/%zu\n",
6593 __func__, streams[i].name, (size_t)streams[i].size));
6594
6595 src_fname_tmp = synthetic_smb_fname(
6596 req,
6597 state->src_fsp->fsp_name->base_name,
6598 streams[i].name,
6599 NULL,
6600 state->src_fsp->fsp_name->flags);
6601 if (tevent_req_nomem(src_fname_tmp, req)) {
6602 return;
6603 }
6604
6605 if (is_ntfs_default_stream_smb_fname(src_fname_tmp)) {
6606 TALLOC_FREE(src_fname_tmp);
6607 continue;
6608 }
6609
6610 dst_fname_tmp = synthetic_smb_fname(
6611 req,
6612 state->dst_fsp->fsp_name->base_name,
6613 streams[i].name,
6614 NULL,
6615 state->dst_fsp->fsp_name->flags);
6616 if (tevent_req_nomem(dst_fname_tmp, req)) {
6617 TALLOC_FREE(src_fname_tmp);
6618 return;
6619 }
6620
6621 status = copy_file(req,
6622 state->handle->conn,
6623 src_fname_tmp,
6624 dst_fname_tmp,
6625 OPENX_FILE_CREATE_IF_NOT_EXIST,
6626 0, false);
6627 if (!NT_STATUS_IS_OK(status)) {
6628 DEBUG(1, ("%s: copy %s to %s failed: %s\n", __func__,
6629 smb_fname_str_dbg(src_fname_tmp),
6630 smb_fname_str_dbg(dst_fname_tmp),
6631 nt_errstr(status)));
6632 TALLOC_FREE(src_fname_tmp);
6633 TALLOC_FREE(dst_fname_tmp);
6634 tevent_req_nterror(req, status);
6635 return;
6636 }
6637
6638 TALLOC_FREE(src_fname_tmp);
6639 TALLOC_FREE(dst_fname_tmp);
6640 }
6641
6642 TALLOC_FREE(streams);
6643 TALLOC_FREE(src_fname_tmp);
6644 TALLOC_FREE(dst_fname_tmp);
6645 tevent_req_done(req);
6646 }
6647
6648 static NTSTATUS fruit_offload_write_recv(struct vfs_handle_struct *handle,
6649 struct tevent_req *req,
6650 off_t *copied)
6651 {
6652 struct fruit_offload_write_state *state = tevent_req_data(
6653 req, struct fruit_offload_write_state);
6654 NTSTATUS status;
6655
6656 if (tevent_req_is_nterror(req, &status)) {
6657 DEBUG(1, ("server side copy chunk failed: %s\n",
6658 nt_errstr(status)));
6659 *copied = 0;
6660 tevent_req_received(req);
6661 return status;
6662 }
6663
6664 *copied = state->copied;
6665 tevent_req_received(req);
6666
6667 return NT_STATUS_OK;
6668 }
6669
6670 static char *fruit_get_bandsize_line(char **lines, int numlines)
6671 {
6672 static regex_t re;
6673 static bool re_initialized = false;
6674 int i;
6675 int ret;
6676
6677 if (!re_initialized) {
6678 ret = regcomp(&re, "^[[:blank:]]*<key>band-size</key>$", 0);
6679 if (ret != 0) {
6680 return NULL;
6681 }
6682 re_initialized = true;
6683 }
6684
6685 for (i = 0; i < numlines; i++) {
6686 regmatch_t matches[1];
6687
6688 ret = regexec(&re, lines[i], 1, matches, 0);
6689 if (ret == 0) {
6690 /*
6691 * Check if the match was on the last line, sa we want
6692 * the subsequent line.
6693 */
6694 if (i + 1 == numlines) {
6695 return NULL;
6696 }
6697 return lines[i + 1];
6698 }
6699 if (ret != REG_NOMATCH) {
6700 return NULL;
6701 }
6702 }
6703
6704 return NULL;
6705 }
6706
6707 static bool fruit_get_bandsize_from_line(char *line, size_t *_band_size)
6708 {
6709 static regex_t re;
6710 static bool re_initialized = false;
6711 regmatch_t matches[2];
6712 uint64_t band_size;
6713 int ret;
6714 bool ok;
6715
6716 if (!re_initialized) {
6717 ret = regcomp(&re,
6718 "^[[:blank:]]*"
6719 "<integer>\\([[:digit:]]*\\)</integer>$",
6720 0);
6721 if (ret != 0) {
6722 return false;
6723 }
6724 re_initialized = true;
6725 }
6726
6727 ret = regexec(&re, line, 2, matches, 0);
6728 if (ret != 0) {
6729 DBG_ERR("regex failed [%s]\n", line);
6730 return false;
6731 }
6732
6733 line[matches[1].rm_eo] = '\0';
6734
6735 ok = conv_str_u64(&line[matches[1].rm_so], &band_size);
6736 if (!ok) {
6737 return false;
6738 }
6739 *_band_size = (size_t)band_size;
6740 return true;
6741 }
6742
6743 /*
6744 * This reads and parses an Info.plist from a TM sparsebundle looking for the
6745 * "band-size" key and value.
6746 */
6747 static bool fruit_get_bandsize(vfs_handle_struct *handle,
6748 const char *dir,
6749 size_t *band_size)
6750 {
6751 #define INFO_PLIST_MAX_SIZE 64*1024
6752 char *plist = NULL;
6753 struct smb_filename *smb_fname = NULL;
6754 files_struct *fsp = NULL;
6755 uint8_t *file_data = NULL;
6756 char **lines = NULL;
6757 char *band_size_line = NULL;
6758 size_t plist_file_size;
6759 ssize_t nread;
6760 int numlines;
6761 int ret;
6762 bool ok = false;
6763 NTSTATUS status;
6764
6765 plist = talloc_asprintf(talloc_tos(),
6766 "%s/%s/Info.plist",
6767 handle->conn->connectpath,
6768 dir);
6769 if (plist == NULL) {
6770 ok = false;
6771 goto out;
6772 }
6773
6774 smb_fname = synthetic_smb_fname(talloc_tos(), plist, NULL, NULL, 0);
6775 if (smb_fname == NULL) {
6776 ok = false;
6777 goto out;
6778 }
6779
6780 ret = SMB_VFS_NEXT_LSTAT(handle, smb_fname);
6781 if (ret != 0) {
6782 DBG_INFO("Ignoring Sparsebundle without Info.plist [%s]\n", dir);
6783 ok = true;
6784 goto out;
6785 }
6786
6787 plist_file_size = smb_fname->st.st_ex_size;
6788
6789 if (plist_file_size > INFO_PLIST_MAX_SIZE) {
6790 DBG_INFO("%s is too large, ignoring\n", plist);
6791 ok = true;
6792 goto out;
6793 }
6794
6795 status = SMB_VFS_NEXT_CREATE_FILE(
6796 handle, /* conn */
6797 NULL, /* req */
6798 0, /* root_dir_fid */
6799 smb_fname, /* fname */
6800 FILE_GENERIC_READ, /* access_mask */
6801 FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */
6802 FILE_OPEN, /* create_disposition */
6803 0, /* create_options */
6804 0, /* file_attributes */
6805 INTERNAL_OPEN_ONLY, /* oplock_request */
6806 NULL, /* lease */
6807 0, /* allocation_size */
6808 0, /* private_flags */
6809 NULL, /* sd */
6810 NULL, /* ea_list */
6811 &fsp, /* result */
6812 NULL, /* psbuf */
6813 NULL, NULL); /* create context */
6814 if (!NT_STATUS_IS_OK(status)) {
6815 DBG_INFO("Opening [%s] failed [%s]\n",
6816 smb_fname_str_dbg(smb_fname), nt_errstr(status));
6817 ok = false;
6818 goto out;
6819 }
6820
6821 file_data = talloc_array(talloc_tos(), uint8_t, plist_file_size);
6822 if (file_data == NULL) {
6823 ok = false;
6824 goto out;
6825 }
6826
6827 nread = SMB_VFS_NEXT_PREAD(handle, fsp, file_data, plist_file_size, 0);
6828 if (nread != plist_file_size) {
6829 DBG_ERR("Short read on [%s]: %zu/%zd\n",
6830 fsp_str_dbg(fsp), nread, plist_file_size);
6831 ok = false;
6832 goto out;
6833
6834 }
6835
6836 status = close_file(NULL, fsp, NORMAL_CLOSE);
6837 fsp = NULL;
6838 if (!NT_STATUS_IS_OK(status)) {
6839 DBG_ERR("close_file failed: %s\n", nt_errstr(status));
6840 ok = false;
6841 goto out;
6842 }
6843
6844 lines = file_lines_parse((char *)file_data,
6845 plist_file_size,
6846 &numlines,
6847 talloc_tos());
6848 if (lines == NULL) {
6849 ok = false;
6850 goto out;
6851 }
6852
6853 band_size_line = fruit_get_bandsize_line(lines, numlines);
6854 if (band_size_line == NULL) {
6855 DBG_ERR("Didn't find band-size key in [%s]\n",
6856 smb_fname_str_dbg(smb_fname));
6857 ok = false;
6858 goto out;
6859 }
6860
6861 ok = fruit_get_bandsize_from_line(band_size_line, band_size);
6862 if (!ok) {
6863 DBG_ERR("fruit_get_bandsize_from_line failed\n");
6864 goto out;
6865 }
6866
6867 DBG_DEBUG("Parsed band-size [%zu] for [%s]\n", *band_size, plist);
6868
6869 out:
6870 if (fsp != NULL) {
6871 status = close_file(NULL, fsp, NORMAL_CLOSE);
6872 if (!NT_STATUS_IS_OK(status)) {
6873 DBG_ERR("close_file failed: %s\n", nt_errstr(status));
6874 }
6875 fsp = NULL;
6876 }
6877 TALLOC_FREE(plist);
6878 TALLOC_FREE(smb_fname);
6879 TALLOC_FREE(file_data);
6880 TALLOC_FREE(lines);
6881 return ok;
6882 }
6883
6884 struct fruit_disk_free_state {
6885 off_t total_size;
6886 };
6887
6888 static bool fruit_get_num_bands(vfs_handle_struct *handle,
6889 char *bundle,
6890 size_t *_nbands)
6891 {
6892 char *path = NULL;
6893 struct smb_filename *bands_dir = NULL;
6894 DIR *d = NULL;
6895 struct dirent *e = NULL;
6896 size_t nbands;
6897 int ret;
6898
6899 path = talloc_asprintf(talloc_tos(),
6900 "%s/%s/bands",
6901 handle->conn->connectpath,
6902 bundle);
6903 if (path == NULL) {
6904 return false;
6905 }
6906
6907 bands_dir = synthetic_smb_fname(talloc_tos(),
6908 path,
6909 NULL,
6910 NULL,
6911 0);
6912 TALLOC_FREE(path);
6913 if (bands_dir == NULL) {
6914 return false;
6915 }
6916
6917 d = SMB_VFS_NEXT_OPENDIR(handle, bands_dir, NULL, 0);
6918 if (d == NULL) {
6919 TALLOC_FREE(bands_dir);
6920 return false;
6921 }
6922
6923 nbands = 0;
6924
6925 for (e = SMB_VFS_NEXT_READDIR(handle, d, NULL);
6926 e != NULL;
6927 e = SMB_VFS_NEXT_READDIR(handle, d, NULL))
6928 {
6929 if (ISDOT(e->d_name) || ISDOTDOT(e->d_name)) {
6930 continue;
6931 }
6932 nbands++;
6933 }
6934
6935 ret = SMB_VFS_NEXT_CLOSEDIR(handle, d);
6936 if (ret != 0) {
6937 TALLOC_FREE(bands_dir);
6938 return false;
6939 }
6940
6941 DBG_DEBUG("%zu bands in [%s]\n", nbands, smb_fname_str_dbg(bands_dir));
6942
6943 TALLOC_FREE(bands_dir);
6944
6945 *_nbands = nbands;
6946 return true;
6947 }
6948
6949 static bool fruit_tmsize_do_dirent(vfs_handle_struct *handle,
6950 struct fruit_disk_free_state *state,
6951 struct dirent *e)
6952 {
6953 bool ok;
6954 char *p = NULL;
6955 size_t sparsebundle_strlen = strlen("sparsebundle");
6956 size_t bandsize = 0;
6957 size_t nbands;
6958 off_t tm_size;
6959
6960 p = strstr(e->d_name, "sparsebundle");
6961 if (p == NULL) {
6962 return true;
6963 }
6964
6965 if (p[sparsebundle_strlen] != '\0') {
6966 return true;
6967 }
6968
6969 DBG_DEBUG("Processing sparsebundle [%s]\n", e->d_name);
6970
6971 ok = fruit_get_bandsize(handle, e->d_name, &bandsize);
6972 if (!ok) {
6973 /*
6974 * Beware of race conditions: this may be an uninitialized
6975 * Info.plist that a client is just creating. We don't want let
6976 * this to trigger complete failure.
6977 */
6978 DBG_ERR("Processing sparsebundle [%s] failed\n", e->d_name);
6979 return true;
6980 }
6981
6982 ok = fruit_get_num_bands(handle, e->d_name, &nbands);
6983 if (!ok) {
6984 /*
6985 * Beware of race conditions: this may be a backup sparsebundle
6986 * in an early stage lacking a bands subdirectory. We don't want
6987 * let this to trigger complete failure.
6988 */
6989 DBG_ERR("Processing sparsebundle [%s] failed\n", e->d_name);
6990 return true;
6991 }
6992
6993 if (bandsize > SIZE_MAX/nbands) {
6994 DBG_ERR("tmsize overflow: bandsize [%zu] nbands [%zu]\n",
6995 bandsize, nbands);
6996 return false;
6997 }
6998 tm_size = bandsize * nbands;
6999
7000 if (state->total_size + tm_size < state->total_size) {
7001 DBG_ERR("tmsize overflow: bandsize [%zu] nbands [%zu]\n",
7002 bandsize, nbands);
7003 return false;
7004 }
7005
7006 state->total_size += tm_size;
7007
7008 DBG_DEBUG("[%s] tm_size [%jd] total_size [%jd]\n",
7009 e->d_name, (intmax_t)tm_size, (intmax_t)state->total_size);
7010
7011 return true;
7012 }
7013
7014 /**
7015 * Calculate used size of a TimeMachine volume
7016 *
7017 * This assumes that the volume is used only for TimeMachine.
7018 *
7019 * - readdir(basedir of share), then
7020 * - for every element that matches regex "^\(.*\)\.sparsebundle$" :
7021 * - parse "\1.sparsebundle/Info.plist" and read the band-size XML key
7022 * - count band files in "\1.sparsebundle/bands/"
7023 * - calculate used size of all bands: band_count * band_size
7024 **/
7025 static uint64_t fruit_disk_free(vfs_handle_struct *handle,
7026 const struct smb_filename *smb_fname,
7027 uint64_t *_bsize,
7028 uint64_t *_dfree,
7029 uint64_t *_dsize)
7030 {
7031 struct fruit_config_data *config = NULL;
7032 struct fruit_disk_free_state state = {0};
7033 DIR *d = NULL;
7034 struct dirent *e = NULL;
7035 uint64_t dfree;
7036 uint64_t dsize;
7037 int ret;
7038 bool ok;
7039
7040 SMB_VFS_HANDLE_GET_DATA(handle, config,
7041 struct fruit_config_data,
7042 return UINT64_MAX);
7043
7044 if (!config->time_machine ||
7045 config->time_machine_max_size == 0)
7046 {
7047 return SMB_VFS_NEXT_DISK_FREE(handle,
7048 smb_fname,
7049 _bsize,
7050 _dfree,
7051 _dsize);
7052 }
7053
7054 d = SMB_VFS_NEXT_OPENDIR(handle, smb_fname, NULL, 0);
7055 if (d == NULL) {
7056 return UINT64_MAX;
7057 }
7058
7059 for (e = SMB_VFS_NEXT_READDIR(handle, d, NULL);
7060 e != NULL;
7061 e = SMB_VFS_NEXT_READDIR(handle, d, NULL))
7062 {
7063 ok = fruit_tmsize_do_dirent(handle, &state, e);
7064 if (!ok) {
7065 SMB_VFS_NEXT_CLOSEDIR(handle, d);
7066 return UINT64_MAX;
7067 }
7068 }
7069
7070 ret = SMB_VFS_NEXT_CLOSEDIR(handle, d);
7071 if (ret != 0) {
7072 return UINT64_MAX;
7073 }
7074
7075 dsize = config->time_machine_max_size / 512;
7076 dfree = dsize - (state.total_size / 512);
7077 if (dfree > dsize) {
7078 dfree = 0;
7079 }
7080
7081 *_bsize = 512;
7082 *_dsize = dsize;
7083 *_dfree = dfree;
7084 return dfree / 2;
7085 }
7086
7087 static struct vfs_fn_pointers vfs_fruit_fns = {
7088 .connect_fn = fruit_connect,
7089 .disk_free_fn = fruit_disk_free,
7090
7091 /* File operations */
7092 .chmod_fn = fruit_chmod,
7093 .chown_fn = fruit_chown,
7094 .unlink_fn = fruit_unlink,
7095 .rename_fn = fruit_rename,
7096 .rmdir_fn = fruit_rmdir,
7097 .open_fn = fruit_open,
7098 .close_fn = fruit_close,
7099 .pread_fn = fruit_pread,
7100 .pwrite_fn = fruit_pwrite,
7101 .pread_send_fn = fruit_pread_send,
7102 .pread_recv_fn = fruit_pread_recv,
7103 .pwrite_send_fn = fruit_pwrite_send,
7104 .pwrite_recv_fn = fruit_pwrite_recv,
7105 .stat_fn = fruit_stat,
7106 .lstat_fn = fruit_lstat,
7107 .fstat_fn = fruit_fstat,
7108 .streaminfo_fn = fruit_streaminfo,
7109 .ntimes_fn = fruit_ntimes,
7110 .ftruncate_fn = fruit_ftruncate,
7111 .fallocate_fn = fruit_fallocate,
7112 .create_file_fn = fruit_create_file,
7113 .readdir_attr_fn = fruit_readdir_attr,
7114 .offload_read_send_fn = fruit_offload_read_send,
7115 .offload_read_recv_fn = fruit_offload_read_recv,
7116 .offload_write_send_fn = fruit_offload_write_send,
7117 .offload_write_recv_fn = fruit_offload_write_recv,
7118
7119 /* NT ACL operations */
7120 .fget_nt_acl_fn = fruit_fget_nt_acl,
7121 .fset_nt_acl_fn = fruit_fset_nt_acl,
7122 };
7123
7124 static_decl_vfs;
7125 NTSTATUS vfs_fruit_init(TALLOC_CTX *ctx)
7126 {
7127 NTSTATUS ret = smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "fruit",
7128 &vfs_fruit_fns);
7129 if (!NT_STATUS_IS_OK(ret)) {
7130 return ret;
7131 }
7132
7133 vfs_fruit_debug_level = debug_add_class("fruit");
7134 if (vfs_fruit_debug_level == -1) {
7135 vfs_fruit_debug_level = DBGC_VFS;
7136 DEBUG(0, ("%s: Couldn't register custom debugging class!\n",
7137 "vfs_fruit_init"));
7138 } else {
7139 DEBUG(10, ("%s: Debug class number of '%s': %d\n",
7140 "vfs_fruit_init","fruit",vfs_fruit_debug_level));
7141 }
7142
7143 return ret;
7144 }
Samba GIT mirror