?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s3: libsmb: Cleanup in get_dc_list()
[Samba.git] / source3 / lib / adouble.c
blob42b2e808d66743a92b7c0028b88e65e4d09012a4
1 /*
2 * Samba AppleDouble helpers
3 *
4 * Copyright (C) Ralph Boehme, 2019
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 "adouble.h"
22 #include "MacExtensions.h"
23 #include "string_replace.h"
24 #include "smbd/smbd.h"
25 #include "system/filesys.h"
26 #include "libcli/security/security.h"
27 #include "lib/util_macstreams.h"
28 #include "auth.h"
29
30 /*
31 "._" AppleDouble Header File Layout:
32
33 MAGIC 0x00051607
34 VERSION 0x00020000
35 FILLER 0
36 COUNT 2
37 .-- AD ENTRY[0] Finder Info Entry (must be first)
38 .--+-- AD ENTRY[1] Resource Fork Entry (must be last)
39 | | /////////////
40 | '-> FINDER INFO Fixed Size Data (32 Bytes)
41 | ~~~~~~~~~~~~~ 2 Bytes Padding
42 | EXT ATTR HDR Fixed Size Data (36 Bytes)
43 | /////////////
44 | ATTR ENTRY[0] --.
45 | ATTR ENTRY[1] --+--.
46 | ATTR ENTRY[2] --+--+--.
47 | ... | | |
48 | ATTR ENTRY[N] --+--+--+--.
49 | ATTR DATA 0 <-' | | |
50 | //////////// | | |
51 | ATTR DATA 1 <----' | |
52 | ///////////// | |
53 | ATTR DATA 2 <-------' |
54 | ///////////// |
55 | ... |
56 | ATTR DATA N <----------'
57 | /////////////
58 | ... Attribute Free Space
59 |
60 '----> RESOURCE FORK
61 ... Variable Sized Data
62 ...
63 */
64
65 /* Number of actually used entries */
66 #define ADEID_NUM_XATTR 8
67 #define ADEID_NUM_DOT_UND 2
68 #define ADEID_NUM_RSRC_XATTR 1
69
70 /* Sizes of relevant entry bits */
71 #define ADEDLEN_MAGIC 4
72 #define ADEDLEN_VERSION 4
73 #define ADEDLEN_FILLER 16
74 #define AD_FILLER_TAG "Netatalk " /* should be 16 bytes */
75 #define AD_FILLER_TAG_OSX "Mac OS X " /* should be 16 bytes */
76 #define ADEDLEN_NENTRIES 2
77 #define AD_HEADER_LEN (ADEDLEN_MAGIC + ADEDLEN_VERSION + \
78 ADEDLEN_FILLER + ADEDLEN_NENTRIES) /* 26 */
79 #define AD_ENTRY_LEN_EID 4
80 #define AD_ENTRY_LEN_OFF 4
81 #define AD_ENTRY_LEN_LEN 4
82 #define AD_ENTRY_LEN (AD_ENTRY_LEN_EID + AD_ENTRY_LEN_OFF + AD_ENTRY_LEN_LEN)
83
84 /* Offsets */
85 #define ADEDOFF_MAGIC 0
86 #define ADEDOFF_VERSION (ADEDOFF_MAGIC + ADEDLEN_MAGIC)
87 #define ADEDOFF_FILLER (ADEDOFF_VERSION + ADEDLEN_VERSION)
88 #define ADEDOFF_NENTRIES (ADEDOFF_FILLER + ADEDLEN_FILLER)
89
90 #define ADEDOFF_FINDERI_XATTR (AD_HEADER_LEN + \
91 (ADEID_NUM_XATTR * AD_ENTRY_LEN))
92 #define ADEDOFF_COMMENT_XATTR (ADEDOFF_FINDERI_XATTR + ADEDLEN_FINDERI)
93 #define ADEDOFF_FILEDATESI_XATTR (ADEDOFF_COMMENT_XATTR + ADEDLEN_COMMENT)
94 #define ADEDOFF_AFPFILEI_XATTR (ADEDOFF_FILEDATESI_XATTR + \
95 ADEDLEN_FILEDATESI)
96 #define ADEDOFF_PRIVDEV_XATTR (ADEDOFF_AFPFILEI_XATTR + ADEDLEN_AFPFILEI)
97 #define ADEDOFF_PRIVINO_XATTR (ADEDOFF_PRIVDEV_XATTR + ADEDLEN_PRIVDEV)
98 #define ADEDOFF_PRIVSYN_XATTR (ADEDOFF_PRIVINO_XATTR + ADEDLEN_PRIVINO)
99 #define ADEDOFF_PRIVID_XATTR (ADEDOFF_PRIVSYN_XATTR + ADEDLEN_PRIVSYN)
100
101 #define ADEDOFF_FINDERI_DOT_UND (AD_HEADER_LEN + \
102 (ADEID_NUM_DOT_UND * AD_ENTRY_LEN))
103 #define ADEDOFF_RFORK_DOT_UND (ADEDOFF_FINDERI_DOT_UND + ADEDLEN_FINDERI)
104
105 #define AD_DATASZ_XATTR (AD_HEADER_LEN + \
106 (ADEID_NUM_XATTR * AD_ENTRY_LEN) + \
107 ADEDLEN_FINDERI + ADEDLEN_COMMENT + \
108 ADEDLEN_FILEDATESI + ADEDLEN_AFPFILEI + \
109 ADEDLEN_PRIVDEV + ADEDLEN_PRIVINO + \
110 ADEDLEN_PRIVSYN + ADEDLEN_PRIVID)
111
112 #if AD_DATASZ_XATTR != 402
113 #error bad size for AD_DATASZ_XATTR
114 #endif
115
116 #define AD_DATASZ_DOT_UND (AD_HEADER_LEN + \
117 (ADEID_NUM_DOT_UND * AD_ENTRY_LEN) + \
118 ADEDLEN_FINDERI)
119 #if AD_DATASZ_DOT_UND != 82
120 #error bad size for AD_DATASZ_DOT_UND
121 #endif
122
123 #define AD_XATTR_HDR_MAGIC 0x41545452 /* 'ATTR' */
124 #define AD_XATTR_MAX_ENTRIES 1024 /* Some arbitrarily enforced limit */
125 #define AD_XATTR_HDR_SIZE 36
126 #define AD_XATTR_MAX_HDR_SIZE 65536
127 #define ADX_ENTRY_FIXED_SIZE (4+4+2+1)
128
129 /*
130 * Both struct ad_xattr_header and struct ad_xattr_entry describe the in memory
131 * representation as well as the on-disk format.
132 *
133 * The ad_xattr_header follows the FinderInfo data in the FinderInfo entry if
134 * the length of the FinderInfo entry is larger then 32 bytes. It is then
135 * preceeded with 2 bytes padding.
136 *
137 * Cf: https://opensource.apple.com/source/xnu/xnu-4570.1.46/bsd/vfs/vfs_xattr.c
138 */
139
140 struct ad_xattr_header {
141 uint32_t adx_magic; /* ATTR_HDR_MAGIC */
142 uint32_t adx_debug_tag; /* for debugging == file id of owning file */
143 uint32_t adx_total_size; /* file offset of end of attribute header + entries + data */
144 uint32_t adx_data_start; /* file offset to attribute data area */
145 uint32_t adx_data_length; /* length of attribute data area */
146 uint32_t adx_reserved[3];
147 uint16_t adx_flags;
148 uint16_t adx_num_attrs;
149 };
150
151 /* On-disk entries are aligned on 4 byte boundaries */
152 struct ad_xattr_entry {
153 uint32_t adx_offset; /* file offset to data */
154 uint32_t adx_length; /* size of attribute data */
155 uint16_t adx_flags;
156 uint8_t adx_namelen; /* included the NULL terminator */
157 char *adx_name; /* NULL-terminated UTF-8 name */
158 };
159
160 struct ad_entry {
161 size_t ade_off;
162 size_t ade_len;
163 };
164
165 struct adouble {
166 files_struct *ad_fsp;
167 bool ad_opened;
168 adouble_type_t ad_type;
169 uint32_t ad_magic;
170 uint32_t ad_version;
171 uint8_t ad_filler[ADEDLEN_FILLER];
172 struct ad_entry ad_eid[ADEID_MAX];
173 char *ad_data;
174 char *ad_rsrc_data;
175 struct ad_xattr_header adx_header;
176 struct ad_xattr_entry *adx_entries;
177 char *adx_data;
178 };
179
180 struct ad_entry_order {
181 uint32_t id, offset, len;
182 };
183
184 /* Netatalk AppleDouble metadata xattr */
185 static const
186 struct ad_entry_order entry_order_meta_xattr[ADEID_NUM_XATTR + 1] = {
187 {ADEID_FINDERI, ADEDOFF_FINDERI_XATTR, ADEDLEN_FINDERI},
188 {ADEID_COMMENT, ADEDOFF_COMMENT_XATTR, 0},
189 {ADEID_FILEDATESI, ADEDOFF_FILEDATESI_XATTR, ADEDLEN_FILEDATESI},
190 {ADEID_AFPFILEI, ADEDOFF_AFPFILEI_XATTR, ADEDLEN_AFPFILEI},
191 {ADEID_PRIVDEV, ADEDOFF_PRIVDEV_XATTR, 0},
192 {ADEID_PRIVINO, ADEDOFF_PRIVINO_XATTR, 0},
193 {ADEID_PRIVSYN, ADEDOFF_PRIVSYN_XATTR, 0},
194 {ADEID_PRIVID, ADEDOFF_PRIVID_XATTR, 0},
195 {0, 0, 0}
196 };
197
198 /* AppleDouble resource fork file (the ones prefixed by "._") */
199 static const
200 struct ad_entry_order entry_order_dot_und[ADEID_NUM_DOT_UND + 1] = {
201 {ADEID_FINDERI, ADEDOFF_FINDERI_DOT_UND, ADEDLEN_FINDERI},
202 {ADEID_RFORK, ADEDOFF_RFORK_DOT_UND, 0},
203 {0, 0, 0}
204 };
205
206 /* Conversion from enumerated id to on-disk AppleDouble id */
207 #define AD_EID_DISK(a) (set_eid[a])
208 static const uint32_t set_eid[] = {
209 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
210 AD_DEV, AD_INO, AD_SYN, AD_ID
211 };
212
213 static char empty_resourcefork[] = {
214 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
215 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E,
216 0x54, 0x68, 0x69, 0x73, 0x20, 0x72, 0x65, 0x73,
217 0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x66, 0x6F,
218 0x72, 0x6B, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x6E,
219 0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x6C, 0x79,
220 0x20, 0x6C, 0x65, 0x66, 0x74, 0x20, 0x62, 0x6C,
221 0x61, 0x6E, 0x6B, 0x20, 0x20, 0x20, 0x00, 0x00,
222 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
223 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
224 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
225 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
226 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
227 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
228 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
229 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
230 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
231 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
232 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
233 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
234 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
235 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
236 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
237 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
238 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
239 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
240 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
241 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
242 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
243 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
244 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
245 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
246 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
247 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E,
248 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
249 0x00, 0x1C, 0x00, 0x1E, 0xFF, 0xFF
250 };
251
252 size_t ad_getentrylen(const struct adouble *ad, int eid)
253 {
254 return ad->ad_eid[eid].ade_len;
255 }
256
257 size_t ad_getentryoff(const struct adouble *ad, int eid)
258 {
259 return ad->ad_eid[eid].ade_off;
260 }
261
262 size_t ad_setentrylen(struct adouble *ad, int eid, size_t len)
263 {
264 return ad->ad_eid[eid].ade_len = len;
265 }
266
267 size_t ad_setentryoff(struct adouble *ad, int eid, size_t off)
268 {
269 return ad->ad_eid[eid].ade_off = off;
270 }
271
272 /**
273 * Return a pointer to an AppleDouble entry
274 *
275 * Returns NULL if the entry is not present
276 **/
277 char *ad_get_entry(const struct adouble *ad, int eid)
278 {
279 off_t off = ad_getentryoff(ad, eid);
280 size_t len = ad_getentrylen(ad, eid);
281
282 if (off == 0 || len == 0) {
283 return NULL;
284 }
285
286 return ad->ad_data + off;
287 }
288
289 /**
290 * Get a date
291 **/
292 int ad_getdate(const struct adouble *ad, unsigned int dateoff, uint32_t *date)
293 {
294 bool xlate = (dateoff & AD_DATE_UNIX);
295 char *p = NULL;
296
297 dateoff &= AD_DATE_MASK;
298 p = ad_get_entry(ad, ADEID_FILEDATESI);
299 if (p == NULL) {
300 return -1;
301 }
302
303 if (dateoff > AD_DATE_ACCESS) {
304 return -1;
305 }
306
307 memcpy(date, p + dateoff, sizeof(uint32_t));
308
309 if (xlate) {
310 *date = AD_DATE_TO_UNIX(*date);
311 }
312 return 0;
313 }
314
315 /**
316 * Set a date
317 **/
318 int ad_setdate(struct adouble *ad, unsigned int dateoff, uint32_t date)
319 {
320 bool xlate = (dateoff & AD_DATE_UNIX);
321 char *p = NULL;
322
323 p = ad_get_entry(ad, ADEID_FILEDATESI);
324 if (p == NULL) {
325 return -1;
326 }
327
328 dateoff &= AD_DATE_MASK;
329 if (xlate) {
330 date = AD_DATE_FROM_UNIX(date);
331 }
332
333 if (dateoff > AD_DATE_ACCESS) {
334 return -1;
335 }
336
337 memcpy(p + dateoff, &date, sizeof(date));
338
339 return 0;
340 }
341
342
343 /**
344 * Map on-disk AppleDouble id to enumerated id
345 **/
346 static uint32_t get_eid(uint32_t eid)
347 {
348 if (eid <= 15) {
349 return eid;
350 }
351
352 switch (eid) {
353 case AD_DEV:
354 return ADEID_PRIVDEV;
355 case AD_INO:
356 return ADEID_PRIVINO;
357 case AD_SYN:
358 return ADEID_PRIVSYN;
359 case AD_ID:
360 return ADEID_PRIVID;
361 default:
362 break;
363 }
364
365 return 0;
366 }
367
368 /*
369 * Move resourcefork data in an AppleDouble file
370 *
371 * This is supposed to make room in an AppleDouble file by moving the
372 * resourcefork data behind the space required for packing additional xattr data
373 * in the extended FinderInfo entry.
374 *
375 * When we're called we're expecting an AppleDouble file with just two entries
376 * (FinderInfo an Resourcefork) and the resourcefork is expected at a fixed
377 * offset of ADEDOFF_RFORK_DOT_UND.
378 */
379 static bool ad_pack_move_reso(struct vfs_handle_struct *handle,
380 struct adouble *ad,
381 files_struct *fsp)
382 {
383 size_t reso_len;
384 size_t reso_off;
385 size_t n;
386 bool ok;
387
388 reso_len = ad_getentrylen(ad, ADEID_RFORK);
389 reso_off = ad_getentryoff(ad, ADEID_RFORK);
390
391 if (reso_len == 0) {
392 return true;
393 }
394
395 if (ad->ad_rsrc_data == NULL) {
396 /*
397 * This buffer is already set when converting a resourcefork
398 * stream from vfs_streams_depot backend via ad_unconvert(). It
399 * is NULL with vfs_streams_xattr where the resourcefork stream
400 * is stored in an AppleDouble sidecar file vy vfs_fruit.
401 */
402 ad->ad_rsrc_data = talloc_size(ad, reso_len);
403 if (ad->ad_rsrc_data == NULL) {
404 return false;
405 }
406
407 n = SMB_VFS_NEXT_PREAD(handle,
408 fsp,
409 ad->ad_rsrc_data,
410 reso_len,
411 ADEDOFF_RFORK_DOT_UND);
412 if (n != reso_len) {
413 DBG_ERR("Read on [%s] failed\n",
414 fsp_str_dbg(fsp));
415 ok = false;
416 goto out;
417 }
418 }
419
420 n = SMB_VFS_NEXT_PWRITE(handle,
421 fsp,
422 ad->ad_rsrc_data,
423 reso_len,
424 reso_off);
425 if (n != reso_len) {
426 DBG_ERR("Write on [%s] failed\n",
427 fsp_str_dbg(fsp));
428 ok = false;
429 goto out;
430 }
431
432 ok = true;
433 out:
434 return ok;
435 }
436
437 static bool ad_pack_xattrs(struct vfs_handle_struct *handle,
438 struct adouble *ad,
439 files_struct *fsp)
440 {
441 struct ad_xattr_header *h = &ad->adx_header;
442 size_t oldsize;
443 uint32_t off;
444 uint32_t data_off;
445 uint16_t i;
446 bool ok;
447
448 if (ad->adx_entries == NULL) {
449 /* No xattrs, nothing to pack */
450 return true;
451 }
452
453 if (fsp == NULL) {
454 DBG_ERR("fsp unexpectedly NULL\n");
455 return false;
456 }
457
458 oldsize = talloc_get_size(ad->ad_data);
459 if (oldsize < AD_XATTR_MAX_HDR_SIZE) {
460 ad->ad_data = talloc_realloc(ad,
461 ad->ad_data,
462 char,
463 AD_XATTR_MAX_HDR_SIZE);
464 if (ad->ad_data == NULL) {
465 return false;
466 }
467 memset(ad->ad_data + oldsize,
468 0,
469 AD_XATTR_MAX_HDR_SIZE - oldsize);
470 }
471
472 /*
473 * First, let's calculate the start of the xattr data area which will be
474 * after the xattr header + header entries.
475 */
476
477 data_off = ad_getentryoff(ad, ADEID_FINDERI);
478 data_off += ADEDLEN_FINDERI + AD_XATTR_HDR_SIZE;
479 /* 2 bytes padding */
480 data_off += 2;
481
482 for (i = 0; i < h->adx_num_attrs; i++) {
483 struct ad_xattr_entry *e = &ad->adx_entries[i];
484
485 /* Align on 4 byte boundary */
486 data_off = (data_off + 3) & ~3;
487
488 data_off += e->adx_namelen + ADX_ENTRY_FIXED_SIZE;
489 if (data_off >= AD_XATTR_MAX_HDR_SIZE) {
490 return false;
491 }
492 }
493
494 off = ad_getentryoff(ad, ADEID_FINDERI);
495 off += ADEDLEN_FINDERI + AD_XATTR_HDR_SIZE;
496 /* 2 bytes padding */
497 off += 2;
498
499 for (i = 0; i < h->adx_num_attrs; i++) {
500 struct ad_xattr_entry *e = &ad->adx_entries[i];
501
502 /* Align on 4 byte boundary */
503 off = (off + 3) & ~3;
504
505 e->adx_offset = data_off;
506 data_off += e->adx_length;
507
508 DBG_DEBUG("%zu(%s){%zu}: off [%zu] adx_length [%zu] "
509 "adx_data_off [%zu]\n",
510 (size_t)i,
511 e->adx_name,
512 (size_t)e->adx_namelen,
513 (size_t)off,
514 (size_t)e->adx_length,
515 (size_t)e->adx_offset);
516
517 if (off + 4 >= AD_XATTR_MAX_HDR_SIZE) {
518 return false;
519 }
520 RSIVAL(ad->ad_data, off, e->adx_offset);
521 off += 4;
522
523 if (off + 4 >= AD_XATTR_MAX_HDR_SIZE) {
524 return false;
525 }
526 RSIVAL(ad->ad_data, off, e->adx_length);
527 off += 4;
528
529 if (off + 2 >= AD_XATTR_MAX_HDR_SIZE) {
530 return false;
531 }
532 RSSVAL(ad->ad_data, off, e->adx_flags);
533 off += 2;
534
535 if (off + 1 >= AD_XATTR_MAX_HDR_SIZE) {
536 return false;
537 }
538 SCVAL(ad->ad_data, off, e->adx_namelen);
539 off += 1;
540
541 if (off + e->adx_namelen >= AD_XATTR_MAX_HDR_SIZE) {
542 return false;
543 }
544 memcpy(ad->ad_data + off, e->adx_name, e->adx_namelen);
545 off += e->adx_namelen;
546 }
547
548 h->adx_data_start = off;
549 h->adx_data_length = talloc_get_size(ad->adx_data);
550 h->adx_total_size = h->adx_data_start + h->adx_data_length;
551
552 if (talloc_get_size(ad->ad_data) < h->adx_total_size) {
553 ad->ad_data = talloc_realloc(ad,
554 ad->ad_data,
555 char,
556 h->adx_total_size);
557 if (ad->ad_data == NULL) {
558 return false;
559 }
560 }
561
562 memcpy(ad->ad_data + h->adx_data_start,
563 ad->adx_data,
564 h->adx_data_length);
565
566 ad_setentrylen(ad,
567 ADEID_FINDERI,
568 h->adx_total_size - ad_getentryoff(ad, ADEID_FINDERI));
569
570 ad_setentryoff(ad,
571 ADEID_RFORK,
572 ad_getentryoff(ad, ADEID_FINDERI) +
573 ad_getentrylen(ad, ADEID_FINDERI));
574
575 memcpy(ad->ad_data + ADEDOFF_FILLER, AD_FILLER_TAG_OSX, ADEDLEN_FILLER);
576
577 /*
578 * Rewind, then update the header fields.
579 */
580
581 off = ad_getentryoff(ad, ADEID_FINDERI) + ADEDLEN_FINDERI;
582 /* 2 bytes padding */
583 off += 2;
584
585 RSIVAL(ad->ad_data, off, AD_XATTR_HDR_MAGIC);
586 off += 4;
587 RSIVAL(ad->ad_data, off, 0);
588 off += 4;
589 RSIVAL(ad->ad_data, off, h->adx_total_size);
590 off += 4;
591 RSIVAL(ad->ad_data, off, h->adx_data_start);
592 off += 4;
593 RSIVAL(ad->ad_data, off, h->adx_data_length);
594 off += 4;
595
596 /* adx_reserved and adx_flags */
597 memset(ad->ad_data + off, 0, 3 * 4 + 2);
598 off += 3 * 4 + 2;
599
600 RSSVAL(ad->ad_data, off, h->adx_num_attrs);
601 off += 2;
602
603 ok = ad_pack_move_reso(handle, ad, fsp);
604 if (!ok) {
605 DBG_ERR("Moving resourcefork of [%s] failed\n",
606 fsp_str_dbg(fsp));
607 return false;
608 }
609
610 return true;
611 }
612
613 /**
614 * Pack AppleDouble structure into data buffer
615 **/
616 static bool ad_pack(struct vfs_handle_struct *handle,
617 struct adouble *ad,
618 files_struct *fsp)
619 {
620 uint32_t eid;
621 uint16_t nent;
622 uint32_t bufsize;
623 uint32_t offset = 0;
624 bool ok;
625
626 bufsize = talloc_get_size(ad->ad_data);
627 if (bufsize < AD_DATASZ_DOT_UND) {
628 DBG_ERR("bad buffer size [0x%" PRIx32 "]\n", bufsize);
629 return false;
630 }
631
632 if (offset + ADEDLEN_MAGIC < offset ||
633 offset + ADEDLEN_MAGIC >= bufsize) {
634 return false;
635 }
636 RSIVAL(ad->ad_data, offset, ad->ad_magic);
637 offset += ADEDLEN_MAGIC;
638
639 if (offset + ADEDLEN_VERSION < offset ||
640 offset + ADEDLEN_VERSION >= bufsize) {
641 return false;
642 }
643 RSIVAL(ad->ad_data, offset, ad->ad_version);
644 offset += ADEDLEN_VERSION;
645
646 if (offset + ADEDLEN_FILLER < offset ||
647 offset + ADEDLEN_FILLER >= bufsize) {
648 return false;
649 }
650 if (ad->ad_type == ADOUBLE_RSRC) {
651 memcpy(ad->ad_data + offset, AD_FILLER_TAG, ADEDLEN_FILLER);
652 }
653 offset += ADEDLEN_FILLER;
654
655 if (offset + ADEDLEN_NENTRIES < offset ||
656 offset + ADEDLEN_NENTRIES >= bufsize) {
657 return false;
658 }
659 offset += ADEDLEN_NENTRIES;
660
661 ok = ad_pack_xattrs(handle, ad, fsp);
662 if (!ok) {
663 return false;
664 }
665
666 for (eid = 0, nent = 0; eid < ADEID_MAX; eid++) {
667 if (ad->ad_eid[eid].ade_off == 0) {
668 /*
669 * ade_off is also used as indicator whether a
670 * specific entry is used or not
671 */
672 continue;
673 }
674
675 if (offset + AD_ENTRY_LEN_EID < offset ||
676 offset + AD_ENTRY_LEN_EID >= bufsize) {
677 return false;
678 }
679 RSIVAL(ad->ad_data, offset, AD_EID_DISK(eid));
680 offset += AD_ENTRY_LEN_EID;
681
682 if (offset + AD_ENTRY_LEN_OFF < offset ||
683 offset + AD_ENTRY_LEN_OFF >= bufsize) {
684 return false;
685 }
686 RSIVAL(ad->ad_data, offset, ad->ad_eid[eid].ade_off);
687 offset += AD_ENTRY_LEN_OFF;
688
689 if (offset + AD_ENTRY_LEN_LEN < offset ||
690 offset + AD_ENTRY_LEN_LEN >= bufsize) {
691 return false;
692 }
693 RSIVAL(ad->ad_data, offset, ad->ad_eid[eid].ade_len);
694 offset += AD_ENTRY_LEN_LEN;
695
696 nent++;
697 }
698
699 if (ADEDOFF_NENTRIES + 2 >= bufsize) {
700 return false;
701 }
702 RSSVAL(ad->ad_data, ADEDOFF_NENTRIES, nent);
703
704 return true;
705 }
706
707 static bool ad_unpack_xattrs(struct adouble *ad)
708 {
709 struct ad_xattr_header *h = &ad->adx_header;
710 const char *p = ad->ad_data;
711 uint32_t hoff;
712 uint32_t i;
713
714 if (ad_getentrylen(ad, ADEID_FINDERI) <= ADEDLEN_FINDERI) {
715 return true;
716 }
717
718 /* 2 bytes padding */
719 hoff = ad_getentryoff(ad, ADEID_FINDERI) + ADEDLEN_FINDERI + 2;
720
721 h->adx_magic = RIVAL(p, hoff + 0);
722 h->adx_debug_tag = RIVAL(p, hoff + 4); /* Not used -> not checked */
723 h->adx_total_size = RIVAL(p, hoff + 8);
724 h->adx_data_start = RIVAL(p, hoff + 12);
725 h->adx_data_length = RIVAL(p, hoff + 16);
726 h->adx_flags = RSVAL(p, hoff + 32); /* Not used -> not checked */
727 h->adx_num_attrs = RSVAL(p, hoff + 34);
728
729 if (h->adx_magic != AD_XATTR_HDR_MAGIC) {
730 DBG_ERR("Bad magic: 0x%" PRIx32 "\n", h->adx_magic);
731 return false;
732 }
733
734 if (h->adx_total_size > ad_getentryoff(ad, ADEID_RFORK)) {
735 DBG_ERR("Bad total size: 0x%" PRIx32 "\n", h->adx_total_size);
736 return false;
737 }
738 if (h->adx_total_size > AD_XATTR_MAX_HDR_SIZE) {
739 DBG_ERR("Bad total size: 0x%" PRIx32 "\n", h->adx_total_size);
740 return false;
741 }
742
743 if (h->adx_data_start < (hoff + AD_XATTR_HDR_SIZE)) {
744 DBG_ERR("Bad start: 0x%" PRIx32 "\n", h->adx_data_start);
745 return false;
746 }
747
748 if ((h->adx_data_start + h->adx_data_length) < h->adx_data_start) {
749 DBG_ERR("Bad length: %" PRIu32 "\n", h->adx_data_length);
750 return false;
751 }
752 if ((h->adx_data_start + h->adx_data_length) >
753 ad->adx_header.adx_total_size)
754 {
755 DBG_ERR("Bad length: %" PRIu32 "\n", h->adx_data_length);
756 return false;
757 }
758
759 if (h->adx_num_attrs > AD_XATTR_MAX_ENTRIES) {
760 DBG_ERR("Bad num xattrs: %" PRIu16 "\n", h->adx_num_attrs);
761 return false;
762 }
763
764 if (h->adx_num_attrs == 0) {
765 return true;
766 }
767
768 ad->adx_entries = talloc_zero_array(
769 ad, struct ad_xattr_entry, h->adx_num_attrs);
770 if (ad->adx_entries == NULL) {
771 return false;
772 }
773
774 hoff += AD_XATTR_HDR_SIZE;
775
776 for (i = 0; i < h->adx_num_attrs; i++) {
777 struct ad_xattr_entry *e = &ad->adx_entries[i];
778
779 hoff = (hoff + 3) & ~3;
780
781 e->adx_offset = RIVAL(p, hoff + 0);
782 e->adx_length = RIVAL(p, hoff + 4);
783 e->adx_flags = RSVAL(p, hoff + 8);
784 e->adx_namelen = *(p + hoff + 10);
785
786 if (e->adx_offset >= ad->adx_header.adx_total_size) {
787 DBG_ERR("Bad adx_offset: %" PRIx32 "\n",
788 e->adx_offset);
789 return false;
790 }
791
792 if ((e->adx_offset + e->adx_length) < e->adx_offset) {
793 DBG_ERR("Bad adx_length: %" PRIx32 "\n",
794 e->adx_length);
795 return false;
796 }
797
798 if ((e->adx_offset + e->adx_length) >
799 ad->adx_header.adx_total_size)
800 {
801 DBG_ERR("Bad adx_length: %" PRIx32 "\n",
802 e->adx_length);
803 return false;
804 }
805
806 if (e->adx_namelen == 0) {
807 DBG_ERR("Bad adx_namelen: %" PRIx32 "\n",
808 e->adx_namelen);
809 return false;
810 }
811 if ((hoff + 11 + e->adx_namelen) < hoff + 11) {
812 DBG_ERR("Bad adx_namelen: %" PRIx32 "\n",
813 e->adx_namelen);
814 return false;
815 }
816 if ((hoff + 11 + e->adx_namelen) >
817 ad->adx_header.adx_data_start)
818 {
819 DBG_ERR("Bad adx_namelen: %" PRIx32 "\n",
820 e->adx_namelen);
821 return false;
822 }
823
824 e->adx_name = talloc_strndup(ad->adx_entries,
825 p + hoff + 11,
826 e->adx_namelen);
827 if (e->adx_name == NULL) {
828 return false;
829 }
830
831 DBG_DEBUG("xattr [%s] offset [0x%x] size [0x%x]\n",
832 e->adx_name, e->adx_offset, e->adx_length);
833 dump_data(10, (uint8_t *)(ad->ad_data + e->adx_offset),
834 e->adx_length);
835
836 hoff += 11 + e->adx_namelen;
837 }
838
839 return true;
840 }
841
842 /**
843 * Unpack an AppleDouble blob into a struct adoble
844 **/
845 static bool ad_unpack(struct adouble *ad, const size_t nentries,
846 size_t filesize)
847 {
848 size_t bufsize = talloc_get_size(ad->ad_data);
849 size_t adentries, i;
850 uint32_t eid, len, off;
851 bool ok;
852
853 /*
854 * The size of the buffer ad->ad_data is checked when read, so
855 * we wouldn't have to check our own offsets, a few extra
856 * checks won't hurt though. We have to check the offsets we
857 * read from the buffer anyway.
858 */
859
860 if (bufsize < (AD_HEADER_LEN + (AD_ENTRY_LEN * nentries))) {
861 DEBUG(1, ("bad size\n"));
862 return false;
863 }
864
865 ad->ad_magic = RIVAL(ad->ad_data, 0);
866 ad->ad_version = RIVAL(ad->ad_data, ADEDOFF_VERSION);
867 if ((ad->ad_magic != AD_MAGIC) || (ad->ad_version != AD_VERSION)) {
868 DEBUG(1, ("wrong magic or version\n"));
869 return false;
870 }
871
872 memcpy(ad->ad_filler, ad->ad_data + ADEDOFF_FILLER, ADEDLEN_FILLER);
873
874 adentries = RSVAL(ad->ad_data, ADEDOFF_NENTRIES);
875 if (adentries != nentries) {
876 DEBUG(1, ("invalid number of entries: %zu\n",
877 adentries));
878 return false;
879 }
880
881 /* now, read in the entry bits */
882 for (i = 0; i < adentries; i++) {
883 eid = RIVAL(ad->ad_data, AD_HEADER_LEN + (i * AD_ENTRY_LEN));
884 eid = get_eid(eid);
885 off = RIVAL(ad->ad_data, AD_HEADER_LEN + (i * AD_ENTRY_LEN) + 4);
886 len = RIVAL(ad->ad_data, AD_HEADER_LEN + (i * AD_ENTRY_LEN) + 8);
887
888 if (!eid || eid >= ADEID_MAX) {
889 DEBUG(1, ("bogus eid %d\n", eid));
890 return false;
891 }
892
893 /*
894 * All entries other than the resource fork are
895 * expected to be read into the ad_data buffer, so
896 * ensure the specified offset is within that bound
897 */
898 if ((off > bufsize) && (eid != ADEID_RFORK)) {
899 DEBUG(1, ("bogus eid %d: off: %" PRIu32 ", len: %" PRIu32 "\n",
900 eid, off, len));
901 return false;
902 }
903
904 /*
905 * All entries besides FinderInfo and resource fork
906 * must fit into the buffer. FinderInfo is special as
907 * it may be larger then the default 32 bytes (if it
908 * contains marshalled xattrs), but we will fixup that
909 * in ad_convert(). And the resource fork is never
910 * accessed directly by the ad_data buf (also see
911 * comment above) anyway.
912 */
913 if ((eid != ADEID_RFORK) &&
914 (eid != ADEID_FINDERI) &&
915 ((off + len) > bufsize)) {
916 DEBUG(1, ("bogus eid %d: off: %" PRIu32 ", len: %" PRIu32 "\n",
917 eid, off, len));
918 return false;
919 }
920
921 /*
922 * That would be obviously broken
923 */
924 if (off > filesize) {
925 DEBUG(1, ("bogus eid %d: off: %" PRIu32 ", len: %" PRIu32 "\n",
926 eid, off, len));
927 return false;
928 }
929
930 /*
931 * Check for any entry that has its end beyond the
932 * filesize.
933 */
934 if (off + len < off) {
935 DEBUG(1, ("offset wrap in eid %d: off: %" PRIu32
936 ", len: %" PRIu32 "\n",
937 eid, off, len));
938 return false;
939
940 }
941 if (off + len > filesize) {
942 /*
943 * If this is the resource fork entry, we fix
944 * up the length, for any other entry we bail
945 * out.
946 */
947 if (eid != ADEID_RFORK) {
948 DEBUG(1, ("bogus eid %d: off: %" PRIu32
949 ", len: %" PRIu32 "\n",
950 eid, off, len));
951 return false;
952 }
953
954 /*
955 * Fixup the resource fork entry by limiting
956 * the size to entryoffset - filesize.
957 */
958 len = filesize - off;
959 DEBUG(1, ("Limiting ADEID_RFORK: off: %" PRIu32
960 ", len: %" PRIu32 "\n", off, len));
961 }
962
963 ad->ad_eid[eid].ade_off = off;
964 ad->ad_eid[eid].ade_len = len;
965 }
966
967 ok = ad_unpack_xattrs(ad);
968 if (!ok) {
969 return false;
970 }
971
972 return true;
973 }
974
975 static bool ad_convert_move_reso(vfs_handle_struct *handle,
976 struct adouble *ad,
977 const struct smb_filename *smb_fname)
978 {
979 char *buf = NULL;
980 size_t rforklen;
981 size_t rforkoff;
982 ssize_t n;
983 int ret;
984
985 rforklen = ad_getentrylen(ad, ADEID_RFORK);
986 if (rforklen == 0) {
987 return true;
988 }
989
990 buf = talloc_size(ad, rforklen);
991 if (buf == NULL) {
992 /*
993 * This allocates a buffer for reading the resource fork data in
994 * one big swoop. Resource forks won't be larger then, say, 64
995 * MB, I swear, so just doing the allocation with the talloc
996 * limit as safeguard seems safe.
997 */
998 DBG_ERR("Failed to allocate %zu bytes for rfork\n",
999 rforklen);
1000 return false;
1001 }
1002
1003 rforkoff = ad_getentryoff(ad, ADEID_RFORK);
1004
1005 n = SMB_VFS_PREAD(ad->ad_fsp, buf, rforklen, rforkoff);
1006 if (n != rforklen) {
1007 DBG_ERR("Reading %zu bytes from rfork [%s] failed: %s\n",
1008 rforklen, fsp_str_dbg(ad->ad_fsp), strerror(errno));
1009 return false;
1010 }
1011
1012 rforkoff = ADEDOFF_RFORK_DOT_UND;
1013
1014 n = SMB_VFS_PWRITE(ad->ad_fsp, buf, rforklen, rforkoff);
1015 if (n != rforklen) {
1016 DBG_ERR("Writing %zu bytes to rfork [%s] failed: %s\n",
1017 rforklen, fsp_str_dbg(ad->ad_fsp), strerror(errno));
1018 return false;
1019 }
1020
1021 ad_setentryoff(ad, ADEID_RFORK, ADEDOFF_RFORK_DOT_UND);
1022
1023 ret = ad_fset(handle, ad, ad->ad_fsp);
1024 if (ret != 0) {
1025 DBG_ERR("ad_fset on [%s] failed\n", fsp_str_dbg(ad->ad_fsp));
1026 return false;
1027 }
1028
1029 return true;
1030 }
1031
1032 static bool ad_convert_xattr(vfs_handle_struct *handle,
1033 struct adouble *ad,
1034 const struct smb_filename *smb_fname,
1035 const char *catia_mappings,
1036 bool *converted_xattr)
1037 {
1038 static struct char_mappings **string_replace_cmaps = NULL;
1039 uint16_t i;
1040 int saved_errno = 0;
1041 NTSTATUS status;
1042 int rc;
1043 bool ok;
1044
1045 *converted_xattr = false;
1046
1047 if (ad_getentrylen(ad, ADEID_FINDERI) == ADEDLEN_FINDERI) {
1048 return true;
1049 }
1050
1051 if (string_replace_cmaps == NULL) {
1052 const char **mappings = NULL;
1053
1054 mappings = str_list_make_v3_const(
1055 talloc_tos(), catia_mappings, NULL);
1056 if (mappings == NULL) {
1057 return false;
1058 }
1059 string_replace_cmaps = string_replace_init_map(
1060 handle->conn->sconn, mappings);
1061 TALLOC_FREE(mappings);
1062 }
1063
1064 for (i = 0; i < ad->adx_header.adx_num_attrs; i++) {
1065 struct ad_xattr_entry *e = &ad->adx_entries[i];
1066 char *mapped_name = NULL;
1067 char *tmp = NULL;
1068 struct smb_filename *stream_name = NULL;
1069 files_struct *fsp = NULL;
1070 ssize_t nwritten;
1071
1072 status = string_replace_allocate(handle->conn,
1073 e->adx_name,
1074 string_replace_cmaps,
1075 talloc_tos(),
1076 &mapped_name,
1077 vfs_translate_to_windows);
1078 if (!NT_STATUS_IS_OK(status) &&
1079 !NT_STATUS_EQUAL(status, NT_STATUS_NONE_MAPPED))
1080 {
1081 DBG_ERR("string_replace_allocate failed\n");
1082 ok = false;
1083 goto fail;
1084 }
1085
1086 tmp = mapped_name;
1087 mapped_name = talloc_asprintf(talloc_tos(), ":%s", tmp);
1088 TALLOC_FREE(tmp);
1089 if (mapped_name == NULL) {
1090 ok = false;
1091 goto fail;
1092 }
1093
1094 stream_name = synthetic_smb_fname(talloc_tos(),
1095 smb_fname->base_name,
1096 mapped_name,
1097 NULL,
1098 smb_fname->twrp,
1099 smb_fname->flags);
1100 TALLOC_FREE(mapped_name);
1101 if (stream_name == NULL) {
1102 DBG_ERR("synthetic_smb_fname failed\n");
1103 ok = false;
1104 goto fail;
1105 }
1106
1107 DBG_DEBUG("stream_name: %s\n", smb_fname_str_dbg(stream_name));
1108
1109 status = SMB_VFS_CREATE_FILE(
1110 handle->conn, /* conn */
1111 NULL, /* req */
1112 &handle->conn->cwd_fsp, /* dirfsp */
1113 stream_name, /* fname */
1114 FILE_GENERIC_WRITE, /* access_mask */
1115 FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */
1116 FILE_OPEN_IF, /* create_disposition */
1117 0, /* create_options */
1118 0, /* file_attributes */
1119 INTERNAL_OPEN_ONLY, /* oplock_request */
1120 NULL, /* lease */
1121 0, /* allocation_size */
1122 0, /* private_flags */
1123 NULL, /* sd */
1124 NULL, /* ea_list */
1125 &fsp, /* result */
1126 NULL, /* psbuf */
1127 NULL, NULL); /* create context */
1128 TALLOC_FREE(stream_name);
1129 if (!NT_STATUS_IS_OK(status)) {
1130 DBG_ERR("SMB_VFS_CREATE_FILE failed\n");
1131 ok = false;
1132 goto fail;
1133 }
1134
1135 nwritten = SMB_VFS_PWRITE(fsp,
1136 ad->ad_data + e->adx_offset,
1137 e->adx_length,
1138 0);
1139 if (nwritten == -1) {
1140 DBG_ERR("SMB_VFS_PWRITE failed\n");
1141 saved_errno = errno;
1142 close_file(NULL, fsp, ERROR_CLOSE);
1143 errno = saved_errno;
1144 ok = false;
1145 goto fail;
1146 }
1147
1148 status = close_file(NULL, fsp, NORMAL_CLOSE);
1149 if (!NT_STATUS_IS_OK(status)) {
1150 ok = false;
1151 goto fail;
1152 }
1153 fsp = NULL;
1154 }
1155
1156 ad->adx_header.adx_num_attrs = 0;
1157 TALLOC_FREE(ad->adx_entries);
1158
1159 ad_setentrylen(ad, ADEID_FINDERI, ADEDLEN_FINDERI);
1160
1161 rc = ad_fset(handle, ad, ad->ad_fsp);
1162 if (rc != 0) {
1163 DBG_ERR("ad_fset on [%s] failed: %s\n",
1164 fsp_str_dbg(ad->ad_fsp), strerror(errno));
1165 ok = false;
1166 goto fail;
1167 }
1168
1169 ok = ad_convert_move_reso(handle, ad, smb_fname);
1170 if (!ok) {
1171 goto fail;
1172 }
1173
1174 *converted_xattr = true;
1175 ok = true;
1176
1177 fail:
1178 return ok;
1179 }
1180
1181 static bool ad_convert_finderinfo(vfs_handle_struct *handle,
1182 struct adouble *ad,
1183 const struct smb_filename *smb_fname)
1184 {
1185 char *p_ad = NULL;
1186 AfpInfo *ai = NULL;
1187 DATA_BLOB aiblob;
1188 struct smb_filename *stream_name = NULL;
1189 files_struct *fsp = NULL;
1190 size_t size;
1191 ssize_t nwritten;
1192 NTSTATUS status;
1193 int saved_errno = 0;
1194 int cmp;
1195
1196 cmp = memcmp(ad->ad_filler, AD_FILLER_TAG_OSX, ADEDLEN_FILLER);
1197 if (cmp != 0) {
1198 return true;
1199 }
1200
1201 p_ad = ad_get_entry(ad, ADEID_FINDERI);
1202 if (p_ad == NULL) {
1203 return false;
1204 }
1205
1206 ai = afpinfo_new(talloc_tos());
1207 if (ai == NULL) {
1208 return false;
1209 }
1210
1211 memcpy(ai->afpi_FinderInfo, p_ad, ADEDLEN_FINDERI);
1212
1213 aiblob = data_blob_talloc(talloc_tos(), NULL, AFP_INFO_SIZE);
1214 if (aiblob.data == NULL) {
1215 TALLOC_FREE(ai);
1216 return false;
1217 }
1218
1219 size = afpinfo_pack(ai, (char *)aiblob.data);
1220 TALLOC_FREE(ai);
1221 if (size != AFP_INFO_SIZE) {
1222 return false;
1223 }
1224
1225 stream_name = synthetic_smb_fname(talloc_tos(),
1226 smb_fname->base_name,
1227 AFPINFO_STREAM,
1228 NULL,
1229 smb_fname->twrp,
1230 smb_fname->flags);
1231 if (stream_name == NULL) {
1232 data_blob_free(&aiblob);
1233 DBG_ERR("synthetic_smb_fname failed\n");
1234 return false;
1235 }
1236
1237 DBG_DEBUG("stream_name: %s\n", smb_fname_str_dbg(stream_name));
1238
1239 status = SMB_VFS_CREATE_FILE(
1240 handle->conn, /* conn */
1241 NULL, /* req */
1242 &handle->conn->cwd_fsp, /* dirfsp */
1243 stream_name, /* fname */
1244 FILE_GENERIC_WRITE, /* access_mask */
1245 FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */
1246 FILE_OPEN_IF, /* create_disposition */
1247 0, /* create_options */
1248 0, /* file_attributes */
1249 INTERNAL_OPEN_ONLY, /* oplock_request */
1250 NULL, /* lease */
1251 0, /* allocation_size */
1252 0, /* private_flags */
1253 NULL, /* sd */
1254 NULL, /* ea_list */
1255 &fsp, /* result */
1256 NULL, /* psbuf */
1257 NULL, NULL); /* create context */
1258 TALLOC_FREE(stream_name);
1259 if (!NT_STATUS_IS_OK(status)) {
1260 DBG_ERR("SMB_VFS_CREATE_FILE failed\n");
1261 return false;
1262 }
1263
1264 nwritten = SMB_VFS_PWRITE(fsp,
1265 aiblob.data,
1266 aiblob.length,
1267 0);
1268 if (nwritten == -1) {
1269 DBG_ERR("SMB_VFS_PWRITE failed\n");
1270 saved_errno = errno;
1271 close_file(NULL, fsp, ERROR_CLOSE);
1272 errno = saved_errno;
1273 return false;
1274 }
1275
1276 status = close_file(NULL, fsp, NORMAL_CLOSE);
1277 if (!NT_STATUS_IS_OK(status)) {
1278 return false;
1279 }
1280 fsp = NULL;
1281
1282 return true;
1283 }
1284
1285 static bool ad_convert_truncate(vfs_handle_struct *handle,
1286 struct adouble *ad,
1287 const struct smb_filename *smb_fname)
1288 {
1289 int rc;
1290 off_t newlen;
1291
1292 newlen = ADEDOFF_RFORK_DOT_UND + ad_getentrylen(ad, ADEID_RFORK);
1293
1294 rc = SMB_VFS_FTRUNCATE(ad->ad_fsp, newlen);
1295 if (rc != 0) {
1296 return false;
1297 }
1298
1299 return true;
1300 }
1301
1302 static bool ad_convert_blank_rfork(vfs_handle_struct *handle,
1303 struct adouble *ad,
1304 uint32_t flags,
1305 bool *blank)
1306 {
1307 size_t rforklen = sizeof(empty_resourcefork);
1308 char buf[rforklen];
1309 ssize_t nread;
1310 int cmp;
1311 int rc;
1312
1313 *blank = false;
1314
1315 if (!(flags & AD_CONV_WIPE_BLANK)) {
1316 return true;
1317 }
1318
1319 if (ad_getentrylen(ad, ADEID_RFORK) != rforklen) {
1320 return true;
1321 }
1322
1323 nread = SMB_VFS_PREAD(ad->ad_fsp, buf, rforklen, ADEDOFF_RFORK_DOT_UND);
1324 if (nread != rforklen) {
1325 DBG_ERR("Reading %zu bytes from rfork [%s] failed: %s\n",
1326 rforklen, fsp_str_dbg(ad->ad_fsp), strerror(errno));
1327 return false;
1328 }
1329
1330 cmp = memcmp(buf, empty_resourcefork, rforklen);
1331 if (cmp != 0) {
1332 return true;
1333 }
1334
1335 ad_setentrylen(ad, ADEID_RFORK, 0);
1336
1337 rc = ad_fset(handle, ad, ad->ad_fsp);
1338 if (rc != 0) {
1339 DBG_ERR("ad_fset on [%s] failed\n", fsp_str_dbg(ad->ad_fsp));
1340 return false;
1341 }
1342
1343 *blank = true;
1344 return true;
1345 }
1346
1347 static bool ad_convert_delete_adfile(vfs_handle_struct *handle,
1348 struct adouble *ad,
1349 struct files_struct *dirfsp,
1350 const struct smb_filename *smb_fname,
1351 uint32_t flags)
1352 {
1353 struct smb_filename *ad_name = NULL;
1354 int rc;
1355
1356 if (ad_getentrylen(ad, ADEID_RFORK) > 0) {
1357 return true;
1358 }
1359
1360 if (!(flags & AD_CONV_DELETE)) {
1361 return true;
1362 }
1363
1364 rc = adouble_path(talloc_tos(), smb_fname, &ad_name);
1365 if (rc != 0) {
1366 return false;
1367 }
1368
1369 rc = SMB_VFS_NEXT_UNLINKAT(handle,
1370 dirfsp,
1371 ad_name,
1372 0);
1373 if (rc != 0) {
1374 DBG_ERR("Unlinking [%s] failed: %s\n",
1375 smb_fname_str_dbg(ad_name), strerror(errno));
1376 TALLOC_FREE(ad_name);
1377 return false;
1378 }
1379
1380 DBG_WARNING("Unlinked [%s] after conversion\n", smb_fname_str_dbg(ad_name));
1381 TALLOC_FREE(ad_name);
1382
1383 return true;
1384 }
1385
1386 /**
1387 * Convert from Apple's ._ file to Netatalk
1388 *
1389 * Apple's AppleDouble may contain a FinderInfo entry longer then 32
1390 * bytes containing packed xattrs.
1391 *
1392 * @return -1 in case an error occurred, 0 if no conversion was done, 1
1393 * otherwise
1394 **/
1395 int ad_convert(struct vfs_handle_struct *handle,
1396 struct files_struct *dirfsp,
1397 const struct smb_filename *smb_fname,
1398 const char *catia_mappings,
1399 uint32_t flags)
1400 {
1401 struct adouble *ad = NULL;
1402 bool ok;
1403 bool converted_xattr = false;
1404 bool blank;
1405 int ret;
1406
1407 ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_RSRC);
1408 if (ad == NULL) {
1409 return 0;
1410 }
1411
1412 ok = ad_convert_xattr(handle,
1413 ad,
1414 smb_fname,
1415 catia_mappings,
1416 &converted_xattr);
1417 if (!ok) {
1418 ret = -1;
1419 goto done;
1420 }
1421
1422 ok = ad_convert_blank_rfork(handle, ad, flags, &blank);
1423 if (!ok) {
1424 ret = -1;
1425 goto done;
1426 }
1427
1428 if (converted_xattr || blank) {
1429 ok = ad_convert_truncate(handle, ad, smb_fname);
1430 if (!ok) {
1431 ret = -1;
1432 goto done;
1433 }
1434 }
1435
1436 ok = ad_convert_finderinfo(handle, ad, smb_fname);
1437 if (!ok) {
1438 DBG_ERR("Failed to convert [%s]\n",
1439 smb_fname_str_dbg(smb_fname));
1440 ret = -1;
1441 goto done;
1442 }
1443
1444 ok = ad_convert_delete_adfile(handle,
1445 ad,
1446 dirfsp,
1447 smb_fname,
1448 flags);
1449 if (!ok) {
1450 ret = -1;
1451 goto done;
1452 }
1453
1454 ret = 0;
1455 done:
1456 TALLOC_FREE(ad);
1457 return ret;
1458 }
1459
1460 static bool ad_unconvert_open_ad(TALLOC_CTX *mem_ctx,
1461 struct vfs_handle_struct *handle,
1462 struct smb_filename *smb_fname,
1463 struct smb_filename *adpath,
1464 files_struct **_fsp)
1465 {
1466 files_struct *fsp = NULL;
1467 NTSTATUS status;
1468 int ret;
1469
1470 status = SMB_VFS_CREATE_FILE(
1471 handle->conn,
1472 NULL, /* req */
1473 &handle->conn->cwd_fsp, /* dirfsp */
1474 adpath,
1475 FILE_READ_DATA|FILE_WRITE_DATA,
1476 FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
1477 FILE_OPEN_IF,
1478 0, /* create_options */
1479 0, /* file_attributes */
1480 INTERNAL_OPEN_ONLY,
1481 NULL, /* lease */
1482 0, /* allocation_size */
1483 0, /* private_flags */
1484 NULL, /* sd */
1485 NULL, /* ea_list */
1486 &fsp,
1487 NULL, /* info */
1488 NULL, NULL); /* create context */
1489 if (!NT_STATUS_IS_OK(status)) {
1490 DBG_ERR("SMB_VFS_CREATE_FILE [%s] failed: %s\n",
1491 smb_fname_str_dbg(adpath), nt_errstr(status));
1492 return false;
1493 }
1494
1495 if (fsp->fsp_name->st.st_ex_uid != smb_fname->st.st_ex_uid ||
1496 fsp->fsp_name->st.st_ex_gid != smb_fname->st.st_ex_gid)
1497 {
1498 ret = SMB_VFS_FCHOWN(fsp,
1499 smb_fname->st.st_ex_uid,
1500 smb_fname->st.st_ex_gid);
1501 if (ret != 0) {
1502 DBG_ERR("SMB_VFS_FCHOWN [%s] failed: %s\n",
1503 fsp_str_dbg(fsp), nt_errstr(status));
1504 close_file(NULL, fsp, NORMAL_CLOSE);
1505 return false;
1506 }
1507 }
1508
1509 *_fsp = fsp;
1510 return true;
1511 }
1512
1513 static bool ad_unconvert_get_streams(struct vfs_handle_struct *handle,
1514 struct smb_filename *smb_fname,
1515 TALLOC_CTX *mem_ctx,
1516 unsigned int *num_streams,
1517 struct stream_struct **streams)
1518 {
1519 files_struct *fsp = NULL;
1520 NTSTATUS status;
1521
1522 status = SMB_VFS_CREATE_FILE(
1523 handle->conn, /* conn */
1524 NULL, /* req */
1525 &handle->conn->cwd_fsp, /* dirfsp */
1526 smb_fname, /* fname */
1527 FILE_READ_ATTRIBUTES, /* access_mask */
1528 (FILE_SHARE_READ | FILE_SHARE_WRITE | /* share_access */
1529 FILE_SHARE_DELETE),
1530 FILE_OPEN, /* create_disposition*/
1531 0, /* create_options */
1532 0, /* file_attributes */
1533 INTERNAL_OPEN_ONLY, /* oplock_request */
1534 NULL, /* lease */
1535 0, /* allocation_size */
1536 0, /* private_flags */
1537 NULL, /* sd */
1538 NULL, /* ea_list */
1539 &fsp, /* result */
1540 NULL, /* pinfo */
1541 NULL, NULL); /* create context */
1542 if (!NT_STATUS_IS_OK(status)) {
1543 DBG_ERR("Opening [%s] failed: %s\n",
1544 smb_fname_str_dbg(smb_fname),
1545 nt_errstr(status));
1546 return false;
1547 }
1548
1549 status = vfs_streaminfo(handle->conn,
1550 fsp,
1551 fsp->fsp_name,
1552 mem_ctx,
1553 num_streams,
1554 streams);
1555 if (!NT_STATUS_IS_OK(status)) {
1556 close_file(NULL, fsp, NORMAL_CLOSE);
1557 DBG_ERR("streaminfo on [%s] failed: %s\n",
1558 smb_fname_str_dbg(smb_fname),
1559 nt_errstr(status));
1560 return false;
1561 }
1562
1563 status = close_file(NULL, fsp, NORMAL_CLOSE);
1564 if (!NT_STATUS_IS_OK(status)) {
1565 DBG_ERR("close_file [%s] failed: %s\n",
1566 smb_fname_str_dbg(smb_fname),
1567 nt_errstr(status));
1568 return false;
1569 }
1570
1571 return true;
1572 }
1573
1574 struct ad_collect_state {
1575 bool have_adfile;
1576 size_t adx_data_off;
1577 char *rsrc_data_buf;
1578 };
1579
1580 static bool ad_collect_one_stream(struct vfs_handle_struct *handle,
1581 struct char_mappings **cmaps,
1582 struct smb_filename *smb_fname,
1583 const struct stream_struct *stream,
1584 struct adouble *ad,
1585 struct ad_collect_state *state)
1586 {
1587 struct smb_filename *sname = NULL;
1588 files_struct *fsp = NULL;
1589 struct ad_xattr_entry *e = NULL;
1590 char *mapped_name = NULL;
1591 char *p = NULL;
1592 size_t needed_size;
1593 ssize_t nread;
1594 NTSTATUS status;
1595 int ret;
1596 bool ok;
1597
1598 sname = synthetic_smb_fname(ad,
1599 smb_fname->base_name,
1600 stream->name,
1601 NULL,
1602 smb_fname->twrp,
1603 0);
1604 if (sname == NULL) {
1605 return false;
1606 }
1607
1608 if (is_ntfs_default_stream_smb_fname(sname)) {
1609 TALLOC_FREE(sname);
1610 return true;
1611 }
1612
1613 DBG_DEBUG("Collecting stream [%s]\n", smb_fname_str_dbg(sname));
1614
1615 ret = SMB_VFS_STAT(handle->conn, sname);
1616 if (ret != 0) {
1617 DBG_ERR("SMB_VFS_STAT [%s] failed\n", smb_fname_str_dbg(sname));
1618 ok = false;
1619 goto out;
1620 }
1621
1622 status = SMB_VFS_CREATE_FILE(
1623 handle->conn,
1624 NULL, /* req */
1625 &handle->conn->cwd_fsp, /* dirfsp */
1626 sname,
1627 FILE_READ_DATA|DELETE_ACCESS,
1628 FILE_SHARE_READ,
1629 FILE_OPEN,
1630 0, /* create_options */
1631 0, /* file_attributes */
1632 INTERNAL_OPEN_ONLY, /* oplock_request */
1633 NULL, /* lease */
1634 0, /* allocation_size */
1635 0, /* private_flags */
1636 NULL, /* sd */
1637 NULL, /* ea_list */
1638 &fsp,
1639 NULL, /* info */
1640 NULL, NULL); /* create context */
1641 if (!NT_STATUS_IS_OK(status)) {
1642 DBG_ERR("SMB_VFS_CREATE_FILE [%s] failed\n",
1643 smb_fname_str_dbg(sname));
1644 ok = false;
1645 goto out;
1646 }
1647
1648 if (is_afpinfo_stream(stream->name)) {
1649 char buf[AFP_INFO_SIZE];
1650
1651 if (stream->size != AFP_INFO_SIZE) {
1652 DBG_ERR("Bad size [%zd] on [%s]\n",
1653 (ssize_t)stream->size,
1654 smb_fname_str_dbg(sname));
1655 ok = false;
1656 goto out;
1657 }
1658
1659 nread = SMB_VFS_PREAD(fsp, buf, stream->size, 0);
1660 if (nread != AFP_INFO_SIZE) {
1661 DBG_ERR("Bad size [%zd] on [%s]\n",
1662 (ssize_t)stream->size,
1663 smb_fname_str_dbg(sname));
1664 ok = false;
1665 goto out;
1666 }
1667
1668 memcpy(ad->ad_data + ADEDOFF_FINDERI_DOT_UND,
1669 buf + AFP_OFF_FinderInfo,
1670 AFP_FinderSize);
1671
1672 ok = set_delete_on_close(fsp,
1673 true,
1674 fsp->conn->session_info->security_token,
1675 fsp->conn->session_info->unix_token);
1676 if (!ok) {
1677 DBG_ERR("Deleting [%s] failed\n",
1678 smb_fname_str_dbg(sname));
1679 ok = false;
1680 goto out;
1681 }
1682 ok = true;
1683 goto out;
1684 }
1685
1686 if (is_afpresource_stream(stream->name)) {
1687 ad->ad_rsrc_data = talloc_size(ad, stream->size);
1688 if (ad->ad_rsrc_data == NULL) {
1689 ok = false;
1690 goto out;
1691 }
1692
1693 nread = SMB_VFS_PREAD(fsp,
1694 ad->ad_rsrc_data,
1695 stream->size,
1696 0);
1697 if (nread != stream->size) {
1698 DBG_ERR("Bad size [%zd] on [%s]\n",
1699 (ssize_t)stream->size,
1700 smb_fname_str_dbg(sname));
1701 ok = false;
1702 goto out;
1703 }
1704
1705 ad_setentrylen(ad, ADEID_RFORK, stream->size);
1706
1707 if (!state->have_adfile) {
1708 /*
1709 * We have a resource *stream* but no AppleDouble
1710 * sidecar file, this means the share is configured with
1711 * fruit:resource=stream. So we should delete the
1712 * resource stream.
1713 */
1714 ok = set_delete_on_close(
1715 fsp,
1716 true,
1717 fsp->conn->session_info->security_token,
1718 fsp->conn->session_info->unix_token);
1719 if (!ok) {
1720 DBG_ERR("Deleting [%s] failed\n",
1721 smb_fname_str_dbg(sname));
1722 ok = false;
1723 goto out;
1724 }
1725 }
1726 ok = true;
1727 goto out;
1728 }
1729
1730 ad->adx_entries = talloc_realloc(ad,
1731 ad->adx_entries,
1732 struct ad_xattr_entry,
1733 ad->adx_header.adx_num_attrs + 1);
1734 if (ad->adx_entries == NULL) {
1735 ok = false;
1736 goto out;
1737 }
1738
1739 e = &ad->adx_entries[ad->adx_header.adx_num_attrs];
1740 *e = (struct ad_xattr_entry) {
1741 .adx_length = stream->size,
1742 };
1743 e->adx_name = talloc_strdup(ad, stream->name + 1);
1744 if (e->adx_name == NULL) {
1745 ok = false;
1746 goto out;
1747 }
1748 p = strchr(e->adx_name, ':');
1749 if (p != NULL) {
1750 *p = '\0';
1751 }
1752
1753 status = string_replace_allocate(handle->conn,
1754 e->adx_name,
1755 cmaps,
1756 ad,
1757 &mapped_name,
1758 vfs_translate_to_unix);
1759 if (!NT_STATUS_IS_OK(status) &&
1760 !NT_STATUS_EQUAL(status, NT_STATUS_NONE_MAPPED))
1761 {
1762 DBG_ERR("string_replace_allocate failed\n");
1763 ok = false;
1764 goto out;
1765 }
1766
1767 e->adx_name = mapped_name;
1768 e->adx_namelen = strlen(e->adx_name) + 1,
1769
1770 DBG_DEBUG("%u: name (%s) size (%zu)\n",
1771 ad->adx_header.adx_num_attrs,
1772 e->adx_name,
1773 (size_t)e->adx_length);
1774
1775 ad->adx_header.adx_num_attrs++;
1776
1777 needed_size = state->adx_data_off + stream->size;
1778 if (needed_size > talloc_get_size(ad->adx_data)) {
1779 ad->adx_data = talloc_realloc(ad,
1780 ad->adx_data,
1781 char,
1782 needed_size);
1783 if (ad->adx_data == NULL) {
1784 ok = false;
1785 goto out;
1786 }
1787 }
1788
1789 nread = SMB_VFS_PREAD(fsp,
1790 ad->adx_data + state->adx_data_off,
1791 stream->size,
1792 0);
1793 if (nread != stream->size) {
1794 DBG_ERR("Bad size [%zd] on [%s]\n",
1795 (ssize_t)stream->size,
1796 smb_fname_str_dbg(sname));
1797 ok = false;
1798 goto out;
1799 }
1800 state->adx_data_off += nread;
1801
1802 ok = set_delete_on_close(fsp,
1803 true,
1804 fsp->conn->session_info->security_token,
1805 fsp->conn->session_info->unix_token);
1806 if (!ok) {
1807 DBG_ERR("Deleting [%s] failed\n",
1808 smb_fname_str_dbg(sname));
1809 ok = false;
1810 goto out;
1811 }
1812
1813 out:
1814 TALLOC_FREE(sname);
1815 if (fsp != NULL) {
1816 status = close_file(NULL, fsp, NORMAL_CLOSE);
1817 if (!NT_STATUS_IS_OK(status)) {
1818 DBG_ERR("close_file [%s] failed: %s\n",
1819 smb_fname_str_dbg(smb_fname),
1820 nt_errstr(status));
1821 ok = false;
1822 }
1823 }
1824
1825 return ok;
1826 }
1827
1828 /**
1829 * Convert filesystem metadata to AppleDouble file
1830 **/
1831 bool ad_unconvert(TALLOC_CTX *mem_ctx,
1832 struct vfs_handle_struct *handle,
1833 const char *catia_mappings,
1834 struct smb_filename *smb_fname,
1835 bool *converted)
1836 {
1837 static struct char_mappings **cmaps = NULL;
1838 TALLOC_CTX *frame = talloc_stackframe();
1839 struct ad_collect_state state;
1840 struct stream_struct *streams = NULL;
1841 struct smb_filename *adpath = NULL;
1842 struct adouble *ad = NULL;
1843 unsigned int num_streams = 0;
1844 size_t to_convert = 0;
1845 bool have_rsrc = false;
1846 files_struct *fsp = NULL;
1847 size_t i;
1848 NTSTATUS status;
1849 int ret;
1850 bool ok;
1851
1852 *converted = false;
1853
1854 if (cmaps == NULL) {
1855 const char **mappings = NULL;
1856
1857 mappings = str_list_make_v3_const(
1858 frame, catia_mappings, NULL);
1859 if (mappings == NULL) {
1860 ok = false;
1861 goto out;
1862 }
1863 cmaps = string_replace_init_map(mem_ctx, mappings);
1864 TALLOC_FREE(mappings);
1865 }
1866
1867 ok = ad_unconvert_get_streams(handle,
1868 smb_fname,
1869 frame,
1870 &num_streams,
1871 &streams);
1872 if (!ok) {
1873 goto out;
1874 }
1875
1876 for (i = 0; i < num_streams; i++) {
1877 if (strcasecmp_m(streams[i].name, "::$DATA") == 0) {
1878 continue;
1879 }
1880 to_convert++;
1881 if (is_afpresource_stream(streams[i].name)) {
1882 have_rsrc = true;
1883 }
1884 }
1885
1886 if (to_convert == 0) {
1887 ok = true;
1888 goto out;
1889 }
1890
1891 state = (struct ad_collect_state) {
1892 .adx_data_off = 0,
1893 };
1894
1895 ret = adouble_path(frame, smb_fname, &adpath);
1896 if (ret != 0) {
1897 ok = false;
1898 goto out;
1899 }
1900
1901 ret = SMB_VFS_STAT(handle->conn, adpath);
1902 if (ret == 0) {
1903 state.have_adfile = true;
1904 } else {
1905 if (errno != ENOENT) {
1906 ok = false;
1907 goto out;
1908 }
1909 state.have_adfile = false;
1910 }
1911
1912 if (to_convert == 1 && have_rsrc && state.have_adfile) {
1913 /*
1914 * So we have just a single stream, the resource fork stream
1915 * from an AppleDouble file. Fine, that means there's nothing to
1916 * convert.
1917 */
1918 ok = true;
1919 goto out;
1920 }
1921
1922 ad = ad_init(frame, ADOUBLE_RSRC);
1923 if (ad == NULL) {
1924 ok = false;
1925 goto out;
1926 }
1927
1928 for (i = 0; i < num_streams; i++) {
1929 ok = ad_collect_one_stream(handle,
1930 cmaps,
1931 smb_fname,
1932 &streams[i],
1933 ad,
1934 &state);
1935 if (!ok) {
1936 goto out;
1937 }
1938 }
1939
1940 ok = ad_unconvert_open_ad(frame, handle, smb_fname, adpath, &fsp);
1941 if (!ok) {
1942 DBG_ERR("Failed to open adfile [%s]\n",
1943 smb_fname_str_dbg(smb_fname));
1944 goto out;
1945 }
1946
1947 ret = ad_fset(handle, ad, fsp);
1948 if (ret != 0) {
1949 ok = false;
1950 goto out;
1951 }
1952
1953 *converted = true;
1954 ok = true;
1955
1956 out:
1957 if (fsp != NULL) {
1958 status = close_file(NULL, fsp, NORMAL_CLOSE);
1959 if (!NT_STATUS_IS_OK(status)) {
1960 DBG_ERR("close_file [%s] failed: %s\n",
1961 smb_fname_str_dbg(smb_fname),
1962 nt_errstr(status));
1963 ok = false;
1964 }
1965 }
1966 TALLOC_FREE(frame);
1967 return ok;
1968 }
1969
1970 /**
1971 * Read and parse Netatalk AppleDouble metadata xattr
1972 **/
1973 static ssize_t ad_read_meta(vfs_handle_struct *handle,
1974 struct adouble *ad,
1975 const struct smb_filename *smb_fname)
1976 {
1977 int rc = 0;
1978 ssize_t ealen;
1979 bool ok;
1980
1981 DEBUG(10, ("reading meta xattr for %s\n", smb_fname->base_name));
1982
1983 ealen = SMB_VFS_GETXATTR(handle->conn, smb_fname,
1984 AFPINFO_EA_NETATALK, ad->ad_data,
1985 AD_DATASZ_XATTR);
1986 if (ealen == -1) {
1987 switch (errno) {
1988 case ENOATTR:
1989 case ENOENT:
1990 if (errno == ENOATTR) {
1991 errno = ENOENT;
1992 }
1993 rc = -1;
1994 goto exit;
1995 default:
1996 DEBUG(2, ("error reading meta xattr: %s\n",
1997 strerror(errno)));
1998 rc = -1;
1999 goto exit;
2000 }
2001 }
2002 if (ealen != AD_DATASZ_XATTR) {
2003 DEBUG(2, ("bad size %zd\n", ealen));
2004 errno = EINVAL;
2005 rc = -1;
2006 goto exit;
2007 }
2008
2009 /* Now parse entries */
2010 ok = ad_unpack(ad, ADEID_NUM_XATTR, AD_DATASZ_XATTR);
2011 if (!ok) {
2012 DEBUG(2, ("invalid AppleDouble metadata xattr\n"));
2013 errno = EINVAL;
2014 rc = -1;
2015 goto exit;
2016 }
2017
2018 if (!ad_getentryoff(ad, ADEID_FINDERI)
2019 || !ad_getentryoff(ad, ADEID_COMMENT)
2020 || !ad_getentryoff(ad, ADEID_FILEDATESI)
2021 || !ad_getentryoff(ad, ADEID_AFPFILEI)
2022 || !ad_getentryoff(ad, ADEID_PRIVDEV)
2023 || !ad_getentryoff(ad, ADEID_PRIVINO)
2024 || !ad_getentryoff(ad, ADEID_PRIVSYN)
2025 || !ad_getentryoff(ad, ADEID_PRIVID)) {
2026 DEBUG(2, ("invalid AppleDouble metadata xattr\n"));
2027 errno = EINVAL;
2028 rc = -1;
2029 goto exit;
2030 }
2031
2032 exit:
2033 DEBUG(10, ("reading meta xattr for %s, rc: %d\n",
2034 smb_fname->base_name, rc));
2035
2036 if (rc != 0) {
2037 ealen = -1;
2038 if (errno == EINVAL) {
2039 become_root();
2040 (void)SMB_VFS_REMOVEXATTR(handle->conn,
2041 smb_fname,
2042 AFPINFO_EA_NETATALK);
2043 unbecome_root();
2044 errno = ENOENT;
2045 }
2046 }
2047 return ealen;
2048 }
2049
2050 static int ad_open_rsrc(vfs_handle_struct *handle,
2051 const struct smb_filename *smb_fname,
2052 int flags,
2053 mode_t mode,
2054 files_struct **_fsp)
2055 {
2056 int ret;
2057 struct smb_filename *adp_smb_fname = NULL;
2058 files_struct *fsp = NULL;
2059 uint32_t access_mask;
2060 uint32_t share_access;
2061 uint32_t create_disposition;
2062 NTSTATUS status;
2063
2064 ret = adouble_path(talloc_tos(), smb_fname, &adp_smb_fname);
2065 if (ret != 0) {
2066 return -1;
2067 }
2068
2069 ret = SMB_VFS_STAT(handle->conn, adp_smb_fname);
2070 if (ret != 0) {
2071 TALLOC_FREE(adp_smb_fname);
2072 return -1;
2073 }
2074
2075 access_mask = FILE_GENERIC_READ;
2076 share_access = FILE_SHARE_READ | FILE_SHARE_WRITE;
2077 create_disposition = FILE_OPEN;
2078
2079 if (flags & O_RDWR) {
2080 access_mask |= FILE_GENERIC_WRITE;
2081 share_access &= ~FILE_SHARE_WRITE;
2082 }
2083
2084 status = SMB_VFS_CREATE_FILE(
2085 handle->conn, /* conn */
2086 NULL, /* req */
2087 &handle->conn->cwd_fsp, /* dirfsp */
2088 adp_smb_fname,
2089 access_mask,
2090 share_access,
2091 create_disposition,
2092 0, /* create_options */
2093 0, /* file_attributes */
2094 INTERNAL_OPEN_ONLY, /* oplock_request */
2095 NULL, /* lease */
2096 0, /* allocation_size */
2097 0, /* private_flags */
2098 NULL, /* sd */
2099 NULL, /* ea_list */
2100 &fsp,
2101 NULL, /* psbuf */
2102 NULL, NULL); /* create context */
2103 TALLOC_FREE(adp_smb_fname);
2104 if (!NT_STATUS_IS_OK(status)) {
2105 DBG_ERR("SMB_VFS_CREATE_FILE failed\n");
2106 return -1;
2107 }
2108
2109 *_fsp = fsp;
2110 return 0;
2111 }
2112
2113 /*
2114 * Here's the deal: for ADOUBLE_META we can do without an fd as we can issue
2115 * path based xattr calls. For ADOUBLE_RSRC however we need a full-fledged fd
2116 * for file IO on the ._ file.
2117 */
2118 static int ad_open(vfs_handle_struct *handle,
2119 struct adouble *ad,
2120 files_struct *fsp,
2121 const struct smb_filename *smb_fname,
2122 int flags,
2123 mode_t mode)
2124 {
2125 int ret;
2126
2127 DBG_DEBUG("Path [%s] type [%s]\n", smb_fname->base_name,
2128 ad->ad_type == ADOUBLE_META ? "meta" : "rsrc");
2129
2130 if (ad->ad_type == ADOUBLE_META) {
2131 return 0;
2132 }
2133
2134 if (fsp != NULL) {
2135 ad->ad_fsp = fsp;
2136 ad->ad_opened = false;
2137 return 0;
2138 }
2139
2140 ret = ad_open_rsrc(handle, smb_fname, flags, mode, &ad->ad_fsp);
2141 if (ret != 0) {
2142 return -1;
2143 }
2144 ad->ad_opened = true;
2145
2146 DBG_DEBUG("Path [%s] type [%s]\n",
2147 smb_fname->base_name,
2148 ad->ad_type == ADOUBLE_META ? "meta" : "rsrc");
2149
2150 return 0;
2151 }
2152
2153 static ssize_t ad_read_rsrc_adouble(vfs_handle_struct *handle,
2154 struct adouble *ad,
2155 const struct smb_filename *smb_fname)
2156 {
2157 size_t to_read;
2158 ssize_t len;
2159 int ret;
2160 bool ok;
2161
2162 ret = SMB_VFS_NEXT_FSTAT(handle, ad->ad_fsp, &ad->ad_fsp->fsp_name->st);
2163 if (ret != 0) {
2164 DBG_ERR("fstat [%s] failed: %s\n",
2165 fsp_str_dbg(ad->ad_fsp), strerror(errno));
2166 return -1;
2167 }
2168
2169 to_read = ad->ad_fsp->fsp_name->st.st_ex_size;
2170 if (to_read > AD_XATTR_MAX_HDR_SIZE) {
2171 to_read = AD_XATTR_MAX_HDR_SIZE;
2172 }
2173
2174 len = SMB_VFS_NEXT_PREAD(handle,
2175 ad->ad_fsp,
2176 ad->ad_data,
2177 to_read,
2178 0);
2179 if (len != to_read) {
2180 DBG_NOTICE("%s %s: bad size: %zd\n",
2181 smb_fname->base_name, strerror(errno), len);
2182 return -1;
2183 }
2184
2185 /* Now parse entries */
2186 ok = ad_unpack(ad,
2187 ADEID_NUM_DOT_UND,
2188 ad->ad_fsp->fsp_name->st.st_ex_size);
2189 if (!ok) {
2190 DBG_ERR("invalid AppleDouble resource %s\n",
2191 smb_fname->base_name);
2192 errno = EINVAL;
2193 return -1;
2194 }
2195
2196 if ((ad_getentryoff(ad, ADEID_FINDERI) != ADEDOFF_FINDERI_DOT_UND)
2197 || (ad_getentrylen(ad, ADEID_FINDERI) < ADEDLEN_FINDERI)
2198 || (ad_getentryoff(ad, ADEID_RFORK) < ADEDOFF_RFORK_DOT_UND))
2199 {
2200 DBG_ERR("invalid AppleDouble resource %s\n",
2201 smb_fname->base_name);
2202 errno = EINVAL;
2203 return -1;
2204 }
2205
2206 return len;
2207 }
2208
2209 /**
2210 * Read and parse resource fork, either ._ AppleDouble file or xattr
2211 **/
2212 static ssize_t ad_read_rsrc(vfs_handle_struct *handle,
2213 struct adouble *ad,
2214 const struct smb_filename *smb_fname)
2215 {
2216 return ad_read_rsrc_adouble(handle, ad, smb_fname);
2217 }
2218
2219 /**
2220 * Read and unpack an AppleDouble metadata xattr or resource
2221 **/
2222 static ssize_t ad_read(vfs_handle_struct *handle,
2223 struct adouble *ad,
2224 const struct smb_filename *smb_fname)
2225 {
2226 switch (ad->ad_type) {
2227 case ADOUBLE_META:
2228 return ad_read_meta(handle, ad, smb_fname);
2229 case ADOUBLE_RSRC:
2230 return ad_read_rsrc(handle, ad, smb_fname);
2231 default:
2232 return -1;
2233 }
2234 }
2235
2236 static int adouble_destructor(struct adouble *ad)
2237 {
2238 NTSTATUS status;
2239
2240 if (!ad->ad_opened) {
2241 return 0;
2242 }
2243
2244 SMB_ASSERT(ad->ad_fsp != NULL);
2245
2246 status = close_file(NULL, ad->ad_fsp, NORMAL_CLOSE);
2247 if (!NT_STATUS_IS_OK(status)) {
2248 DBG_ERR("Closing [%s] failed: %s\n",
2249 fsp_str_dbg(ad->ad_fsp), nt_errstr(status));
2250 }
2251
2252 return 0;
2253 }
2254
2255 /**
2256 * Allocate a struct adouble without initialiing it
2257 *
2258 * The struct is either hang of the fsp extension context or if fsp is
2259 * NULL from ctx.
2260 *
2261 * @param[in] ctx talloc context
2262 * @param[in] handle vfs handle
2263 * @param[in] type type of AppleDouble, ADOUBLE_META or ADOUBLE_RSRC
2264 *
2265 * @return adouble handle
2266 **/
2267 static struct adouble *ad_alloc(TALLOC_CTX *ctx,
2268 adouble_type_t type)
2269 {
2270 int rc = 0;
2271 size_t adsize = 0;
2272 struct adouble *ad;
2273
2274 switch (type) {
2275 case ADOUBLE_META:
2276 adsize = AD_DATASZ_XATTR;
2277 break;
2278 case ADOUBLE_RSRC:
2279 /*
2280 * AppleDouble ._ file case, optimize for fewer (but larger)
2281 * IOs. Two cases:
2282 *
2283 * - without xattrs size of the header is exactly
2284 * AD_DATASZ_DOT_UND (82) bytes
2285 *
2286 * - with embedded xattrs it can be larger, up to
2287 * AD_XATTR_MAX_HDR_SIZE
2288 *
2289 * Larger headers are not supported, but this is a reasonable
2290 * limit that is also employed by the macOS client.
2291 *
2292 * We used the largest possible size to be able to read the full
2293 * header with one IO.
2294 */
2295 adsize = AD_XATTR_MAX_HDR_SIZE;
2296 break;
2297 default:
2298 return NULL;
2299 }
2300
2301 ad = talloc_zero(ctx, struct adouble);
2302 if (ad == NULL) {
2303 rc = -1;
2304 goto exit;
2305 }
2306
2307 if (adsize) {
2308 ad->ad_data = talloc_zero_array(ad, char, adsize);
2309 if (ad->ad_data == NULL) {
2310 rc = -1;
2311 goto exit;
2312 }
2313 }
2314
2315 ad->ad_type = type;
2316 ad->ad_magic = AD_MAGIC;
2317 ad->ad_version = AD_VERSION;
2318
2319 talloc_set_destructor(ad, adouble_destructor);
2320
2321 exit:
2322 if (rc != 0) {
2323 TALLOC_FREE(ad);
2324 }
2325 return ad;
2326 }
2327
2328 /**
2329 * Allocate and initialize a new struct adouble
2330 *
2331 * @param[in] ctx talloc context
2332 * @param[in] type type of AppleDouble, ADOUBLE_META or ADOUBLE_RSRC
2333 *
2334 * @return adouble handle, initialized
2335 **/
2336 struct adouble *ad_init(TALLOC_CTX *ctx, adouble_type_t type)
2337 {
2338 int rc = 0;
2339 const struct ad_entry_order *eid;
2340 struct adouble *ad = NULL;
2341 time_t t = time(NULL);
2342
2343 switch (type) {
2344 case ADOUBLE_META:
2345 eid = entry_order_meta_xattr;
2346 break;
2347 case ADOUBLE_RSRC:
2348 eid = entry_order_dot_und;
2349 break;
2350 default:
2351 return NULL;
2352 }
2353
2354 ad = ad_alloc(ctx, type);
2355 if (ad == NULL) {
2356 return NULL;
2357 }
2358
2359 while (eid->id) {
2360 ad->ad_eid[eid->id].ade_off = eid->offset;
2361 ad->ad_eid[eid->id].ade_len = eid->len;
2362 eid++;
2363 }
2364
2365 /* put something sane in the date fields */
2366 ad_setdate(ad, AD_DATE_CREATE | AD_DATE_UNIX, t);
2367 ad_setdate(ad, AD_DATE_MODIFY | AD_DATE_UNIX, t);
2368 ad_setdate(ad, AD_DATE_ACCESS | AD_DATE_UNIX, t);
2369 ad_setdate(ad, AD_DATE_BACKUP, htonl(AD_DATE_START));
2370
2371 if (rc != 0) {
2372 TALLOC_FREE(ad);
2373 }
2374 return ad;
2375 }
2376
2377 static struct adouble *ad_get_internal(TALLOC_CTX *ctx,
2378 vfs_handle_struct *handle,
2379 files_struct *fsp,
2380 const struct smb_filename *smb_fname,
2381 adouble_type_t type)
2382 {
2383 int rc = 0;
2384 ssize_t len;
2385 struct adouble *ad = NULL;
2386 int mode;
2387
2388 if (fsp != NULL) {
2389 smb_fname = fsp->base_fsp->fsp_name;
2390 }
2391
2392 DEBUG(10, ("ad_get(%s) called for %s\n",
2393 type == ADOUBLE_META ? "meta" : "rsrc",
2394 smb_fname != NULL ? smb_fname->base_name : "???"));
2395
2396 ad = ad_alloc(ctx, type);
2397 if (ad == NULL) {
2398 rc = -1;
2399 goto exit;
2400 }
2401
2402 /* Try rw first so we can use the fd in ad_convert() */
2403 mode = O_RDWR;
2404
2405 rc = ad_open(handle, ad, fsp, smb_fname, mode, 0);
2406 if (rc == -1 && ((errno == EROFS) || (errno == EACCES))) {
2407 mode = O_RDONLY;
2408 rc = ad_open(handle, ad, fsp, smb_fname, mode, 0);
2409 }
2410 if (rc == -1) {
2411 DBG_DEBUG("ad_open [%s] error [%s]\n",
2412 smb_fname->base_name, strerror(errno));
2413 goto exit;
2414
2415 }
2416
2417 len = ad_read(handle, ad, smb_fname);
2418 if (len == -1) {
2419 DEBUG(10, ("error reading AppleDouble for %s\n",
2420 smb_fname->base_name));
2421 rc = -1;
2422 goto exit;
2423 }
2424
2425 exit:
2426 DEBUG(10, ("ad_get(%s) for %s returning %d\n",
2427 type == ADOUBLE_META ? "meta" : "rsrc",
2428 smb_fname->base_name, rc));
2429
2430 if (rc != 0) {
2431 TALLOC_FREE(ad);
2432 }
2433 return ad;
2434 }
2435
2436 /**
2437 * Return AppleDouble data for a file
2438 *
2439 * @param[in] ctx talloc context
2440 * @param[in] handle vfs handle
2441 * @param[in] smb_fname pathname to file or directory
2442 * @param[in] type type of AppleDouble, ADOUBLE_META or ADOUBLE_RSRC
2443 *
2444 * @return talloced struct adouble or NULL on error
2445 **/
2446 struct adouble *ad_get(TALLOC_CTX *ctx,
2447 vfs_handle_struct *handle,
2448 const struct smb_filename *smb_fname,
2449 adouble_type_t type)
2450 {
2451 return ad_get_internal(ctx, handle, NULL, smb_fname, type);
2452 }
2453
2454 /**
2455 * Return AppleDouble data for a file
2456 *
2457 * @param[in] ctx talloc context
2458 * @param[in] handle vfs handle
2459 * @param[in] fsp fsp to use for IO
2460 * @param[in] type type of AppleDouble, ADOUBLE_META or ADOUBLE_RSRC
2461 *
2462 * @return talloced struct adouble or NULL on error
2463 **/
2464 struct adouble *ad_fget(TALLOC_CTX *ctx, vfs_handle_struct *handle,
2465 files_struct *fsp, adouble_type_t type)
2466 {
2467 return ad_get_internal(ctx, handle, fsp, NULL, type);
2468 }
2469
2470 /**
2471 * Set AppleDouble metadata on a file or directory
2472 *
2473 * @param[in] ad adouble handle
2474 *
2475 * @param[in] smb_fname pathname to file or directory
2476 *
2477 * @return status code, 0 means success
2478 **/
2479 int ad_set(vfs_handle_struct *handle,
2480 struct adouble *ad,
2481 const struct smb_filename *smb_fname)
2482 {
2483 bool ok;
2484 int ret;
2485
2486 DBG_DEBUG("Path [%s]\n", smb_fname->base_name);
2487
2488 if (ad->ad_type != ADOUBLE_META) {
2489 DBG_ERR("ad_set on [%s] used with ADOUBLE_RSRC\n",
2490 smb_fname->base_name);
2491 return -1;
2492 }
2493
2494 ok = ad_pack(handle, ad, NULL);
2495 if (!ok) {
2496 return -1;
2497 }
2498
2499 ret = SMB_VFS_SETXATTR(handle->conn,
2500 smb_fname,
2501 AFPINFO_EA_NETATALK,
2502 ad->ad_data,
2503 AD_DATASZ_XATTR, 0);
2504
2505 DBG_DEBUG("Path [%s] ret [%d]\n", smb_fname->base_name, ret);
2506
2507 return ret;
2508 }
2509
2510 /**
2511 * Set AppleDouble metadata on a file or directory
2512 *
2513 * @param[in] ad adouble handle
2514 * @param[in] fsp file handle
2515 *
2516 * @return status code, 0 means success
2517 **/
2518 int ad_fset(struct vfs_handle_struct *handle,
2519 struct adouble *ad,
2520 files_struct *fsp)
2521 {
2522 int rc = -1;
2523 ssize_t len;
2524 bool ok;
2525
2526 DBG_DEBUG("Path [%s]\n", fsp_str_dbg(fsp));
2527
2528 if ((fsp == NULL)
2529 || (fsp->fh == NULL)
2530 || (fsp->fh->fd == -1))
2531 {
2532 smb_panic("bad fsp");
2533 }
2534
2535 ok = ad_pack(handle, ad, fsp);
2536 if (!ok) {
2537 return -1;
2538 }
2539
2540 switch (ad->ad_type) {
2541 case ADOUBLE_META:
2542 rc = SMB_VFS_NEXT_SETXATTR(handle,
2543 fsp->fsp_name,
2544 AFPINFO_EA_NETATALK,
2545 ad->ad_data,
2546 AD_DATASZ_XATTR, 0);
2547 break;
2548
2549 case ADOUBLE_RSRC:
2550 len = SMB_VFS_NEXT_PWRITE(handle,
2551 fsp,
2552 ad->ad_data,
2553 ad_getentryoff(ad, ADEID_RFORK),
2554 0);
2555 if (len != ad_getentryoff(ad, ADEID_RFORK)) {
2556 DBG_ERR("short write on %s: %zd", fsp_str_dbg(fsp), len);
2557 return -1;
2558 }
2559 rc = 0;
2560 break;
2561
2562 default:
2563 return -1;
2564 }
2565
2566 DBG_DEBUG("Path [%s] rc [%d]\n", fsp_str_dbg(fsp), rc);
2567
2568 return rc;
2569 }
2570
2571 bool is_adouble_file(const char *path)
2572 {
2573 const char *p = NULL;
2574 int match;
2575
2576 p = strrchr(path, '/');
2577 if (p == NULL) {
2578 p = path;
2579 } else {
2580 p++;
2581 }
2582
2583 match = strncmp(p,
2584 ADOUBLE_NAME_PREFIX,
2585 strlen(ADOUBLE_NAME_PREFIX));
2586 if (match != 0) {
2587 return false;
2588 }
2589 return true;
2590 }
2591
2592 /**
2593 * Prepend "._" to a basename
2594 * Return a new struct smb_filename with stream_name == NULL.
2595 **/
2596 int adouble_path(TALLOC_CTX *ctx,
2597 const struct smb_filename *smb_fname_in,
2598 struct smb_filename **pp_smb_fname_out)
2599 {
2600 char *parent;
2601 const char *base;
2602 struct smb_filename *smb_fname = cp_smb_filename(ctx,
2603 smb_fname_in);
2604
2605 if (smb_fname == NULL) {
2606 return -1;
2607 }
2608
2609 /* We need streamname to be NULL */
2610 TALLOC_FREE(smb_fname->stream_name);
2611
2612 /* And we're replacing base_name. */
2613 TALLOC_FREE(smb_fname->base_name);
2614
2615 SET_STAT_INVALID(smb_fname->st);
2616
2617 if (!parent_dirname(smb_fname, smb_fname_in->base_name,
2618 &parent, &base)) {
2619 TALLOC_FREE(smb_fname);
2620 return -1;
2621 }
2622
2623 smb_fname->base_name = talloc_asprintf(smb_fname,
2624 "%s/._%s", parent, base);
2625 if (smb_fname->base_name == NULL) {
2626 TALLOC_FREE(smb_fname);
2627 return -1;
2628 }
2629
2630 *pp_smb_fname_out = smb_fname;
2631
2632 return 0;
2633 }
2634
2635 /**
2636 * Allocate and initialize an AfpInfo struct
2637 **/
2638 AfpInfo *afpinfo_new(TALLOC_CTX *ctx)
2639 {
2640 AfpInfo *ai = talloc_zero(ctx, AfpInfo);
2641 if (ai == NULL) {
2642 return NULL;
2643 }
2644 ai->afpi_Signature = AFP_Signature;
2645 ai->afpi_Version = AFP_Version;
2646 ai->afpi_BackupTime = AD_DATE_START;
2647 return ai;
2648 }
2649
2650 /**
2651 * Pack an AfpInfo struct into a buffer
2652 *
2653 * Buffer size must be at least AFP_INFO_SIZE
2654 * Returns size of packed buffer
2655 **/
2656 ssize_t afpinfo_pack(const AfpInfo *ai, char *buf)
2657 {
2658 memset(buf, 0, AFP_INFO_SIZE);
2659
2660 RSIVAL(buf, 0, ai->afpi_Signature);
2661 RSIVAL(buf, 4, ai->afpi_Version);
2662 RSIVAL(buf, 12, ai->afpi_BackupTime);
2663 memcpy(buf + 16, ai->afpi_FinderInfo, sizeof(ai->afpi_FinderInfo));
2664
2665 return AFP_INFO_SIZE;
2666 }
2667
2668 /**
2669 * Unpack a buffer into a AfpInfo structure
2670 *
2671 * Buffer size must be at least AFP_INFO_SIZE
2672 * Returns allocated AfpInfo struct
2673 **/
2674 AfpInfo *afpinfo_unpack(TALLOC_CTX *ctx, const void *data)
2675 {
2676 AfpInfo *ai = talloc_zero(ctx, AfpInfo);
2677 if (ai == NULL) {
2678 return NULL;
2679 }
2680
2681 ai->afpi_Signature = RIVAL(data, 0);
2682 ai->afpi_Version = RIVAL(data, 4);
2683 ai->afpi_BackupTime = RIVAL(data, 12);
2684 memcpy(ai->afpi_FinderInfo, (const char *)data + 16,
2685 sizeof(ai->afpi_FinderInfo));
2686
2687 if (ai->afpi_Signature != AFP_Signature
2688 || ai->afpi_Version != AFP_Version) {
2689 DEBUG(1, ("Bad AfpInfo signature or version\n"));
2690 TALLOC_FREE(ai);
2691 }
2692
2693 return ai;
2694 }
Samba GIT mirror