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