Adding upstream version 2:4.20.0+dfsg.upstream/2%4.20.0+dfsg

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 2856 insertions, 0 deletions

diff --git a/source3/lib/adouble.c b/source3/lib/adouble.c
new file mode 100644
index 0000000..1e8dbc4
--- /dev/null
+++ b/source3/lib/adouble.c
@@ -0,0 +1,2856 @@
+/*
+ * Samba AppleDouble helpers
+ *
+ * Copyright (C) Ralph Boehme, 2019
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "includes.h"
+#include "adouble.h"
+#include "MacExtensions.h"
+#include "string_replace.h"
+#include "smbd/smbd.h"
+#include "system/filesys.h"
+#include "libcli/security/security.h"
+#include "lib/util_macstreams.h"
+#include "auth.h"
+
+/*
+   "._" AppleDouble Header File Layout:
+
+         MAGIC          0x00051607
+         VERSION        0x00020000
+         FILLER         0
+         COUNT          2
+     .-- AD ENTRY[0]    Finder Info Entry (must be first)
+  .--+-- AD ENTRY[1]    Resource Fork Entry (must be last)
+  |  |   /////////////
+  |  '-> FINDER INFO    Fixed Size Data (32 Bytes)
+  |      ~~~~~~~~~~~~~  2 Bytes Padding
+  |      EXT ATTR HDR   Fixed Size Data (36 Bytes)
+  |      /////////////
+  |      ATTR ENTRY[0] --.
+  |      ATTR ENTRY[1] --+--.
+  |      ATTR ENTRY[2] --+--+--.
+  |         ...          |  |  |
+  |      ATTR ENTRY[N] --+--+--+--.
+  |      ATTR DATA 0   <-'  |  |  |
+  |      ////////////       |  |  |
+  |      ATTR DATA 1   <----'  |  |
+  |      /////////////         |  |
+  |      ATTR DATA 2   <-------'  |
+  |      /////////////            |
+  |         ...                   |
+  |      ATTR DATA N   <----------'
+  |      /////////////
+  |         ...          Attribute Free Space
+  |
+  '----> RESOURCE FORK
+            ...          Variable Sized Data
+            ...
+*/
+
+/* Number of actually used entries */
+#define ADEID_NUM_XATTR      8
+#define ADEID_NUM_DOT_UND    2
+#define ADEID_NUM_RSRC_XATTR 1
+
+/* Sizes of relevant entry bits */
+#define ADEDLEN_MAGIC       4
+#define ADEDLEN_VERSION     4
+#define ADEDLEN_FILLER      16
+#define AD_FILLER_TAG       "Netatalk        " /* should be 16 bytes */
+#define AD_FILLER_TAG_OSX   "Mac OS X        " /* should be 16 bytes */
+#define ADEDLEN_NENTRIES    2
+#define AD_HEADER_LEN       (ADEDLEN_MAGIC + ADEDLEN_VERSION + \
+			     ADEDLEN_FILLER + ADEDLEN_NENTRIES) /* 26 */
+#define AD_ENTRY_LEN_EID    4
+#define AD_ENTRY_LEN_OFF    4
+#define AD_ENTRY_LEN_LEN    4
+#define AD_ENTRY_LEN (AD_ENTRY_LEN_EID + AD_ENTRY_LEN_OFF + AD_ENTRY_LEN_LEN)
+
+/* Offsets */
+#define ADEDOFF_MAGIC         0
+#define ADEDOFF_VERSION       (ADEDOFF_MAGIC + ADEDLEN_MAGIC)
+#define ADEDOFF_FILLER        (ADEDOFF_VERSION + ADEDLEN_VERSION)
+#define ADEDOFF_NENTRIES      (ADEDOFF_FILLER + ADEDLEN_FILLER)
+
+#define ADEDOFF_FINDERI_XATTR    (AD_HEADER_LEN + \
+				  (ADEID_NUM_XATTR * AD_ENTRY_LEN))
+#define ADEDOFF_COMMENT_XATTR    (ADEDOFF_FINDERI_XATTR    + ADEDLEN_FINDERI)
+#define ADEDOFF_FILEDATESI_XATTR (ADEDOFF_COMMENT_XATTR    + ADEDLEN_COMMENT)
+#define ADEDOFF_AFPFILEI_XATTR   (ADEDOFF_FILEDATESI_XATTR + \
+				  ADEDLEN_FILEDATESI)
+#define ADEDOFF_PRIVDEV_XATTR    (ADEDOFF_AFPFILEI_XATTR   + ADEDLEN_AFPFILEI)
+#define ADEDOFF_PRIVINO_XATTR    (ADEDOFF_PRIVDEV_XATTR    + ADEDLEN_PRIVDEV)
+#define ADEDOFF_PRIVSYN_XATTR    (ADEDOFF_PRIVINO_XATTR    + ADEDLEN_PRIVINO)
+#define ADEDOFF_PRIVID_XATTR     (ADEDOFF_PRIVSYN_XATTR    + ADEDLEN_PRIVSYN)
+
+#define ADEDOFF_FINDERI_DOT_UND  (AD_HEADER_LEN + \
+				  (ADEID_NUM_DOT_UND * AD_ENTRY_LEN))
+#define ADEDOFF_RFORK_DOT_UND    (ADEDOFF_FINDERI_DOT_UND + ADEDLEN_FINDERI)
+
+#define AD_DATASZ_XATTR (AD_HEADER_LEN + \
+			 (ADEID_NUM_XATTR * AD_ENTRY_LEN) + \
+			 ADEDLEN_FINDERI + ADEDLEN_COMMENT + \
+			 ADEDLEN_FILEDATESI + ADEDLEN_AFPFILEI + \
+			 ADEDLEN_PRIVDEV + ADEDLEN_PRIVINO + \
+			 ADEDLEN_PRIVSYN + ADEDLEN_PRIVID)
+
+#if AD_DATASZ_XATTR != 402
+#error bad size for AD_DATASZ_XATTR
+#endif
+
+#define AD_DATASZ_DOT_UND (AD_HEADER_LEN + \
+			   (ADEID_NUM_DOT_UND * AD_ENTRY_LEN) + \
+			   ADEDLEN_FINDERI)
+#if AD_DATASZ_DOT_UND != 82
+#error bad size for AD_DATASZ_DOT_UND
+#endif
+
+#define AD_XATTR_HDR_MAGIC    0x41545452 /* 'ATTR' */
+#define AD_XATTR_MAX_ENTRIES  1024 /* Some arbitrarily enforced limit */
+#define AD_XATTR_HDR_SIZE     36
+#define AD_XATTR_MAX_HDR_SIZE 65536
+#define ADX_ENTRY_FIXED_SIZE  (4+4+2+1)
+
+/*
+ * Both struct ad_xattr_header and struct ad_xattr_entry describe the in memory
+ * representation as well as the on-disk format.
+ *
+ * The ad_xattr_header follows the FinderInfo data in the FinderInfo entry if
+ * the length of the FinderInfo entry is larger then 32 bytes. It is then
+ * preceded with 2 bytes padding.
+ *
+ * Cf: https://opensource.apple.com/source/xnu/xnu-4570.1.46/bsd/vfs/vfs_xattr.c
+ */
+
+struct ad_xattr_header {
+	uint32_t adx_magic;        /* ATTR_HDR_MAGIC */
+	uint32_t adx_debug_tag;    /* for debugging == file id of owning file */
+	uint32_t adx_total_size;   /* file offset of end of attribute header + entries + data */
+	uint32_t adx_data_start;   /* file offset to attribute data area */
+	uint32_t adx_data_length;  /* length of attribute data area */
+	uint32_t adx_reserved[3];
+	uint16_t adx_flags;
+	uint16_t adx_num_attrs;
+};
+
+/* On-disk entries are aligned on 4 byte boundaries */
+struct ad_xattr_entry {
+	uint32_t adx_offset;    /* file offset to data */
+	uint32_t adx_length;    /* size of attribute data */
+	uint16_t adx_flags;
+	uint8_t  adx_namelen;	/* included the NULL terminator */
+	char    *adx_name;      /* NULL-terminated UTF-8 name */
+};
+
+struct ad_entry {
+	size_t ade_off;
+	size_t ade_len;
+};
+
+struct adouble {
+	files_struct             *ad_fsp;
+	bool                      ad_opened;
+	adouble_type_t            ad_type;
+	uint32_t                  ad_magic;
+	uint32_t                  ad_version;
+	uint8_t                   ad_filler[ADEDLEN_FILLER];
+	struct ad_entry           ad_eid[ADEID_MAX];
+	char                     *ad_data;
+	char                     *ad_rsrc_data;
+	struct ad_xattr_header    adx_header;
+	struct ad_xattr_entry    *adx_entries;
+	char                     *adx_data;
+};
+
+struct ad_entry_order {
+	uint32_t id, offset, len;
+};
+
+/* Netatalk AppleDouble metadata xattr */
+static const
+struct ad_entry_order entry_order_meta_xattr[ADEID_NUM_XATTR + 1] = {
+	{ADEID_FINDERI,    ADEDOFF_FINDERI_XATTR,    ADEDLEN_FINDERI},
+	{ADEID_COMMENT,    ADEDOFF_COMMENT_XATTR,    0},
+	{ADEID_FILEDATESI, ADEDOFF_FILEDATESI_XATTR, ADEDLEN_FILEDATESI},
+	{ADEID_AFPFILEI,   ADEDOFF_AFPFILEI_XATTR,   ADEDLEN_AFPFILEI},
+	{ADEID_PRIVDEV,    ADEDOFF_PRIVDEV_XATTR,    0},
+	{ADEID_PRIVINO,    ADEDOFF_PRIVINO_XATTR,    0},
+	{ADEID_PRIVSYN,    ADEDOFF_PRIVSYN_XATTR,    0},
+	{ADEID_PRIVID,     ADEDOFF_PRIVID_XATTR,     0},
+	{0, 0, 0}
+};
+
+/* AppleDouble resource fork file (the ones prefixed by "._") */
+static const
+struct ad_entry_order entry_order_dot_und[ADEID_NUM_DOT_UND + 1] = {
+	{ADEID_FINDERI,    ADEDOFF_FINDERI_DOT_UND,  ADEDLEN_FINDERI},
+	{ADEID_RFORK,      ADEDOFF_RFORK_DOT_UND,    0},
+	{0, 0, 0}
+};
+
+/* Conversion from enumerated id to on-disk AppleDouble id */
+#define AD_EID_DISK(a) (set_eid[a])
+static const uint32_t set_eid[] = {
+	0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+	AD_DEV, AD_INO, AD_SYN, AD_ID
+};
+
+static char empty_resourcefork[] = {
+	0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E,
+	0x54, 0x68, 0x69, 0x73, 0x20, 0x72, 0x65, 0x73,
+	0x6F, 0x75, 0x72, 0x63, 0x65, 0x20, 0x66, 0x6F,
+	0x72, 0x6B, 0x20, 0x69, 0x6E, 0x74, 0x65, 0x6E,
+	0x74, 0x69, 0x6F, 0x6E, 0x61, 0x6C, 0x6C, 0x79,
+	0x20, 0x6C, 0x65, 0x66, 0x74, 0x20, 0x62, 0x6C,
+	0x61, 0x6E, 0x6B, 0x20, 0x20, 0x20, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1E,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x1C, 0x00, 0x1E, 0xFF, 0xFF
+};
+
+size_t ad_getentrylen(const struct adouble *ad, int eid)
+{
+	return ad->ad_eid[eid].ade_len;
+}
+
+size_t ad_getentryoff(const struct adouble *ad, int eid)
+{
+	return ad->ad_eid[eid].ade_off;
+}
+
+size_t ad_setentrylen(struct adouble *ad, int eid, size_t len)
+{
+	return ad->ad_eid[eid].ade_len = len;
+}
+
+size_t ad_setentryoff(struct adouble *ad, int eid, size_t off)
+{
+	return ad->ad_eid[eid].ade_off = off;
+}
+
+/*
+ * All entries besides FinderInfo and resource fork must fit into the
+ * buffer. FinderInfo is special as it may be larger then the default 32 bytes
+ * if it contains marshalled xattrs, which we will fixup that in
+ * ad_convert(). The first 32 bytes however must also be part of the buffer.
+ *
+ * The resource fork is never accessed directly by the ad_data buf.
+ */
+static bool ad_entry_check_size(uint32_t eid,
+				size_t bufsize,
+				uint32_t off,
+				uint32_t got_len)
+{
+	struct {
+		off_t expected_len;
+		bool fixed_size;
+		bool minimum_size;
+	} ad_checks[] = {
+		[ADEID_DFORK] = {-1, false, false}, /* not applicable */
+		[ADEID_RFORK] = {-1, false, false}, /* no limit */
+		[ADEID_NAME] = {ADEDLEN_NAME, false, false},
+		[ADEID_COMMENT] = {ADEDLEN_COMMENT, false, false},
+		[ADEID_ICONBW] = {ADEDLEN_ICONBW, true, false},
+		[ADEID_ICONCOL] = {ADEDLEN_ICONCOL, false, false},
+		[ADEID_FILEI] = {ADEDLEN_FILEI, true, false},
+		[ADEID_FILEDATESI] = {ADEDLEN_FILEDATESI, true, false},
+		[ADEID_FINDERI] = {ADEDLEN_FINDERI, false, true},
+		[ADEID_MACFILEI] = {ADEDLEN_MACFILEI, true, false},
+		[ADEID_PRODOSFILEI] = {ADEDLEN_PRODOSFILEI, true, false},
+		[ADEID_MSDOSFILEI] = {ADEDLEN_MSDOSFILEI, true, false},
+		[ADEID_SHORTNAME] = {ADEDLEN_SHORTNAME, false, false},
+		[ADEID_AFPFILEI] = {ADEDLEN_AFPFILEI, true, false},
+		[ADEID_DID] = {ADEDLEN_DID, true, false},
+		[ADEID_PRIVDEV] = {ADEDLEN_PRIVDEV, true, false},
+		[ADEID_PRIVINO] = {ADEDLEN_PRIVINO, true, false},
+		[ADEID_PRIVSYN] = {ADEDLEN_PRIVSYN, true, false},
+		[ADEID_PRIVID] = {ADEDLEN_PRIVID, true, false},
+	};
+
+	if (eid >= ADEID_MAX) {
+		return false;
+	}
+	if (got_len == 0) {
+		/* Entry present, but empty, allow */
+		return true;
+	}
+	if (ad_checks[eid].expected_len == 0) {
+		/*
+		 * Shouldn't happen: implicitly initialized to zero because
+		 * explicit initializer missing.
+		 */
+		return false;
+	}
+	if (ad_checks[eid].expected_len == -1) {
+		/* Unused or no limit */
+		return true;
+	}
+	if (ad_checks[eid].fixed_size) {
+		if (ad_checks[eid].expected_len != got_len) {
+			/* Wrong size for fixed size entry. */
+			return false;
+		}
+	} else {
+		if (ad_checks[eid].minimum_size) {
+			if (got_len < ad_checks[eid].expected_len) {
+				/*
+				 * Too small for variable sized entry with
+				 * minimum size.
+				 */
+				return false;
+			}
+		} else {
+			if (got_len > ad_checks[eid].expected_len) {
+				/* Too big for variable sized entry. */
+				return false;
+			}
+		}
+	}
+	if (off + got_len < off) {
+		/* wrap around */
+		return false;
+	}
+	if (off + got_len > bufsize) {
+		/* overflow */
+		return false;
+	}
+	return true;
+}
+
+/**
+ * Return a pointer to an AppleDouble entry
+ *
+ * Returns NULL if the entry is not present
+ **/
+char *ad_get_entry(const struct adouble *ad, int eid)
+{
+	size_t bufsize = talloc_get_size(ad->ad_data);
+	off_t off = ad_getentryoff(ad, eid);
+	size_t len = ad_getentrylen(ad, eid);
+	bool valid;
+
+	valid = ad_entry_check_size(eid, bufsize, off, len);
+	if (!valid) {
+		return NULL;
+	}
+
+	if (off == 0 || len == 0) {
+		return NULL;
+	}
+
+	return ad->ad_data + off;
+}
+
+/**
+ * Get a date
+ **/
+int ad_getdate(const struct adouble *ad, unsigned int dateoff, uint32_t *date)
+{
+	bool xlate = (dateoff & AD_DATE_UNIX);
+	char *p = NULL;
+
+	dateoff &= AD_DATE_MASK;
+	p = ad_get_entry(ad, ADEID_FILEDATESI);
+	if (p == NULL) {
+		return -1;
+	}
+
+	if (dateoff > AD_DATE_ACCESS) {
+	    return -1;
+	}
+
+	memcpy(date, p + dateoff, sizeof(uint32_t));
+
+	if (xlate) {
+		*date = AD_DATE_TO_UNIX(*date);
+	}
+	return 0;
+}
+
+/**
+ * Set a date
+ **/
+int ad_setdate(struct adouble *ad, unsigned int dateoff, uint32_t date)
+{
+	bool xlate = (dateoff & AD_DATE_UNIX);
+	char *p = NULL;
+
+	p = ad_get_entry(ad, ADEID_FILEDATESI);
+	if (p == NULL) {
+		return -1;
+	}
+
+	dateoff &= AD_DATE_MASK;
+	if (xlate) {
+		date = AD_DATE_FROM_UNIX(date);
+	}
+
+	if (dateoff > AD_DATE_ACCESS) {
+		return -1;
+	}
+
+	memcpy(p + dateoff, &date, sizeof(date));
+
+	return 0;
+}
+
+
+/**
+ * Map on-disk AppleDouble id to enumerated id
+ **/
+static uint32_t get_eid(uint32_t eid)
+{
+	if (eid <= 15) {
+		return eid;
+	}
+
+	switch (eid) {
+	case AD_DEV:
+		return ADEID_PRIVDEV;
+	case AD_INO:
+		return ADEID_PRIVINO;
+	case AD_SYN:
+		return ADEID_PRIVSYN;
+	case AD_ID:
+		return ADEID_PRIVID;
+	default:
+		break;
+	}
+
+	return 0;
+}
+
+/*
+ * Move resourcefork data in an AppleDouble file
+ *
+ * This is supposed to make room in an AppleDouble file by moving the
+ * resourcefork data behind the space required for packing additional xattr data
+ * in the extended FinderInfo entry.
+ *
+ * When we're called we're expecting an AppleDouble file with just two entries
+ * (FinderInfo an Resourcefork) and the resourcefork is expected at a fixed
+ * offset of ADEDOFF_RFORK_DOT_UND.
+ */
+static bool ad_pack_move_reso(struct vfs_handle_struct *handle,
+			      struct adouble *ad,
+			      files_struct *fsp)
+{
+	size_t reso_len;
+	size_t reso_off;
+	size_t n;
+	bool ok;
+
+	reso_len = ad_getentrylen(ad, ADEID_RFORK);
+	reso_off = ad_getentryoff(ad, ADEID_RFORK);
+
+	if (reso_len == 0) {
+		return true;
+	}
+
+	if (ad->ad_rsrc_data == NULL) {
+		/*
+		 * This buffer is already set when converting a resourcefork
+		 * stream from vfs_streams_depot backend via ad_unconvert(). It
+		 * is NULL with vfs_streams_xattr where the resourcefork stream
+		 * is stored in an AppleDouble sidecar file vy vfs_fruit.
+		 */
+		ad->ad_rsrc_data = talloc_size(ad, reso_len);
+		if (ad->ad_rsrc_data == NULL) {
+			return false;
+		}
+
+		n = SMB_VFS_NEXT_PREAD(handle,
+				       fsp,
+				       ad->ad_rsrc_data,
+				       reso_len,
+				       ADEDOFF_RFORK_DOT_UND);
+		if (n != reso_len) {
+			DBG_ERR("Read on [%s] failed\n",
+				fsp_str_dbg(fsp));
+			ok = false;
+			goto out;
+		}
+	}
+
+	n = SMB_VFS_NEXT_PWRITE(handle,
+				fsp,
+				ad->ad_rsrc_data,
+				reso_len,
+				reso_off);
+	if (n != reso_len) {
+		DBG_ERR("Write on [%s] failed\n",
+			fsp_str_dbg(fsp));
+		ok = false;
+		goto out;
+	}
+
+	ok = true;
+out:
+	return ok;
+}
+
+static bool ad_pack_xattrs(struct vfs_handle_struct *handle,
+			   struct adouble *ad,
+			   files_struct *fsp)
+{
+	struct ad_xattr_header *h = &ad->adx_header;
+	size_t oldsize;
+	uint32_t off;
+	uint32_t data_off;
+	uint16_t i;
+	bool ok;
+
+	if (ad->adx_entries == NULL) {
+		/* No xattrs, nothing to pack */
+		return true;
+	}
+
+	if (fsp == NULL) {
+		DBG_ERR("fsp unexpectedly NULL\n");
+		return false;
+	}
+
+	oldsize = talloc_get_size(ad->ad_data);
+	if (oldsize < AD_XATTR_MAX_HDR_SIZE) {
+		ad->ad_data = talloc_realloc(ad,
+					     ad->ad_data,
+					     char,
+					     AD_XATTR_MAX_HDR_SIZE);
+		if (ad->ad_data == NULL) {
+			return false;
+		}
+		memset(ad->ad_data + oldsize,
+		       0,
+		       AD_XATTR_MAX_HDR_SIZE - oldsize);
+	}
+
+	/*
+	 * First, let's calculate the start of the xattr data area which will be
+	 * after the xattr header + header entries.
+	 */
+
+	data_off = ad_getentryoff(ad, ADEID_FINDERI);
+	data_off += ADEDLEN_FINDERI + AD_XATTR_HDR_SIZE;
+	/* 2 bytes padding */
+	data_off += 2;
+
+	for (i = 0; i < h->adx_num_attrs; i++) {
+		struct ad_xattr_entry *e = &ad->adx_entries[i];
+
+		/* Align on 4 byte boundary */
+		data_off = (data_off + 3) & ~3;
+
+		data_off += e->adx_namelen + ADX_ENTRY_FIXED_SIZE;
+		if (data_off >= AD_XATTR_MAX_HDR_SIZE) {
+			return false;
+		}
+	}
+
+	off = ad_getentryoff(ad, ADEID_FINDERI);
+	off +=  ADEDLEN_FINDERI + AD_XATTR_HDR_SIZE;
+	/* 2 bytes padding */
+	off += 2;
+
+	for (i = 0; i < h->adx_num_attrs; i++) {
+		struct ad_xattr_entry *e = &ad->adx_entries[i];
+
+		/* Align on 4 byte boundary */
+		off = (off + 3) & ~3;
+
+		e->adx_offset = data_off;
+		data_off += e->adx_length;
+
+		DBG_DEBUG("%zu(%s){%zu}: off [%zu] adx_length [%zu] "
+			  "adx_data_off [%zu]\n",
+			  (size_t)i,
+			  e->adx_name,
+			  (size_t)e->adx_namelen,
+			  (size_t)off,
+			  (size_t)e->adx_length,
+			  (size_t)e->adx_offset);
+
+		if (off + 4 >= AD_XATTR_MAX_HDR_SIZE) {
+			return false;
+		}
+		RSIVAL(ad->ad_data, off, e->adx_offset);
+		off += 4;
+
+		if (off + 4 >= AD_XATTR_MAX_HDR_SIZE) {
+			return false;
+		}
+		RSIVAL(ad->ad_data, off, e->adx_length);
+		off += 4;
+
+		if (off + 2 >= AD_XATTR_MAX_HDR_SIZE) {
+			return false;
+		}
+		RSSVAL(ad->ad_data, off, e->adx_flags);
+		off += 2;
+
+		if (off + 1 >= AD_XATTR_MAX_HDR_SIZE) {
+			return false;
+		}
+		SCVAL(ad->ad_data, off, e->adx_namelen);
+		off += 1;
+
+		if (off + e->adx_namelen >= AD_XATTR_MAX_HDR_SIZE) {
+			return false;
+		}
+		memcpy(ad->ad_data + off, e->adx_name, e->adx_namelen);
+		off += e->adx_namelen;
+	}
+
+	h->adx_data_start = off;
+	h->adx_data_length = talloc_get_size(ad->adx_data);
+	h->adx_total_size = h->adx_data_start + h->adx_data_length;
+
+	if (talloc_get_size(ad->ad_data) < h->adx_total_size) {
+		ad->ad_data = talloc_realloc(ad,
+					     ad->ad_data,
+					     char,
+					     h->adx_total_size);
+		if (ad->ad_data == NULL) {
+			return false;
+		}
+	}
+
+	memcpy(ad->ad_data + h->adx_data_start,
+	       ad->adx_data,
+	       h->adx_data_length);
+
+	ad_setentrylen(ad,
+		       ADEID_FINDERI,
+		       h->adx_total_size - ad_getentryoff(ad, ADEID_FINDERI));
+
+	ad_setentryoff(ad,
+		       ADEID_RFORK,
+		       ad_getentryoff(ad, ADEID_FINDERI) +
+		       ad_getentrylen(ad, ADEID_FINDERI));
+
+	memcpy(ad->ad_data + ADEDOFF_FILLER, AD_FILLER_TAG_OSX, ADEDLEN_FILLER);
+
+	/*
+	 * Rewind, then update the header fields.
+	 */
+
+	off = ad_getentryoff(ad, ADEID_FINDERI) + ADEDLEN_FINDERI;
+	/* 2 bytes padding */
+	off += 2;
+
+	RSIVAL(ad->ad_data, off, AD_XATTR_HDR_MAGIC);
+	off += 4;
+	RSIVAL(ad->ad_data, off, 0);
+	off += 4;
+	RSIVAL(ad->ad_data, off, h->adx_total_size);
+	off += 4;
+	RSIVAL(ad->ad_data, off, h->adx_data_start);
+	off += 4;
+	RSIVAL(ad->ad_data, off, h->adx_data_length);
+	off += 4;
+
+	/* adx_reserved and adx_flags */
+	memset(ad->ad_data + off, 0, 3 * 4 + 2);
+	off += 3 * 4 + 2;
+
+	RSSVAL(ad->ad_data, off, h->adx_num_attrs);
+	off += 2;
+
+	ok = ad_pack_move_reso(handle, ad, fsp);
+	if (!ok) {
+		DBG_ERR("Moving resourcefork of [%s] failed\n",
+			fsp_str_dbg(fsp));
+		return false;
+	}
+
+	return true;
+}
+
+/**
+ * Pack AppleDouble structure into data buffer
+ **/
+static bool ad_pack(struct vfs_handle_struct *handle,
+		    struct adouble *ad,
+		    files_struct *fsp)
+{
+	uint32_t       eid;
+	uint16_t       nent;
+	uint32_t       bufsize;
+	uint32_t       offset = 0;
+	bool ok;
+
+	bufsize = talloc_get_size(ad->ad_data);
+	if (bufsize < AD_DATASZ_DOT_UND) {
+		DBG_ERR("bad buffer size [0x%" PRIx32 "]\n", bufsize);
+		return false;
+	}
+
+	if (offset + ADEDLEN_MAGIC < offset ||
+			offset + ADEDLEN_MAGIC >= bufsize) {
+		return false;
+	}
+	RSIVAL(ad->ad_data, offset, ad->ad_magic);
+	offset += ADEDLEN_MAGIC;
+
+	if (offset + ADEDLEN_VERSION < offset ||
+			offset + ADEDLEN_VERSION >= bufsize) {
+		return false;
+	}
+	RSIVAL(ad->ad_data, offset, ad->ad_version);
+	offset += ADEDLEN_VERSION;
+
+	if (offset + ADEDLEN_FILLER < offset ||
+			offset + ADEDLEN_FILLER >= bufsize) {
+		return false;
+	}
+	if (ad->ad_type == ADOUBLE_RSRC) {
+		memcpy(ad->ad_data + offset, AD_FILLER_TAG, ADEDLEN_FILLER);
+	}
+	offset += ADEDLEN_FILLER;
+
+	if (offset + ADEDLEN_NENTRIES < offset ||
+			offset + ADEDLEN_NENTRIES >= bufsize) {
+		return false;
+	}
+	offset += ADEDLEN_NENTRIES;
+
+	ok = ad_pack_xattrs(handle, ad, fsp);
+	if (!ok) {
+		return false;
+	}
+
+	for (eid = 0, nent = 0; eid < ADEID_MAX; eid++) {
+		if (ad->ad_eid[eid].ade_off == 0) {
+			/*
+			 * ade_off is also used as indicator whether a
+			 * specific entry is used or not
+			 */
+			continue;
+		}
+
+		if (offset + AD_ENTRY_LEN_EID < offset ||
+				offset + AD_ENTRY_LEN_EID >= bufsize) {
+			return false;
+		}
+		RSIVAL(ad->ad_data, offset, AD_EID_DISK(eid));
+		offset += AD_ENTRY_LEN_EID;
+
+		if (offset + AD_ENTRY_LEN_OFF < offset ||
+				offset + AD_ENTRY_LEN_OFF >= bufsize) {
+			return false;
+		}
+		RSIVAL(ad->ad_data, offset, ad->ad_eid[eid].ade_off);
+		offset += AD_ENTRY_LEN_OFF;
+
+		if (offset + AD_ENTRY_LEN_LEN < offset ||
+				offset + AD_ENTRY_LEN_LEN >= bufsize) {
+			return false;
+		}
+		RSIVAL(ad->ad_data, offset, ad->ad_eid[eid].ade_len);
+		offset += AD_ENTRY_LEN_LEN;
+
+		nent++;
+	}
+
+	if (ADEDOFF_NENTRIES + 2 >= bufsize) {
+		return false;
+	}
+	RSSVAL(ad->ad_data, ADEDOFF_NENTRIES, nent);
+
+	return true;
+}
+
+static bool ad_unpack_xattrs(struct adouble *ad)
+{
+	struct ad_xattr_header *h = &ad->adx_header;
+	size_t bufsize = talloc_get_size(ad->ad_data);
+	const char *p = ad->ad_data;
+	uint32_t hoff;
+	uint32_t i;
+
+	if (ad->ad_type != ADOUBLE_RSRC) {
+		return false;
+	}
+
+	if (ad_getentrylen(ad, ADEID_FINDERI) <= ADEDLEN_FINDERI) {
+		return true;
+	}
+
+	/*
+	 * Ensure the buffer ad->ad_data was allocated by ad_alloc() for an
+	 * ADOUBLE_RSRC type (._ AppleDouble file on-disk).
+	 */
+	if (bufsize != AD_XATTR_MAX_HDR_SIZE) {
+		return false;
+	}
+
+	/* 2 bytes padding */
+	hoff = ad_getentryoff(ad, ADEID_FINDERI) + ADEDLEN_FINDERI + 2;
+
+	h->adx_magic       = RIVAL(p, hoff + 0);
+	h->adx_debug_tag   = RIVAL(p, hoff + 4); /* Not used -> not checked */
+	h->adx_total_size  = RIVAL(p, hoff + 8);
+	h->adx_data_start  = RIVAL(p, hoff + 12);
+	h->adx_data_length = RIVAL(p, hoff + 16);
+	h->adx_flags       = RSVAL(p, hoff + 32); /* Not used -> not checked */
+	h->adx_num_attrs   = RSVAL(p, hoff + 34);
+
+	if (h->adx_magic != AD_XATTR_HDR_MAGIC) {
+		DBG_ERR("Bad magic: 0x%" PRIx32 "\n", h->adx_magic);
+		return false;
+	}
+
+	if (h->adx_total_size > ad_getentryoff(ad, ADEID_RFORK)) {
+		DBG_ERR("Bad total size: 0x%" PRIx32 "\n", h->adx_total_size);
+		return false;
+	}
+	if (h->adx_total_size > AD_XATTR_MAX_HDR_SIZE) {
+		DBG_ERR("Bad total size: 0x%" PRIx32 "\n", h->adx_total_size);
+		return false;
+	}
+
+	if (h->adx_data_start < (hoff + AD_XATTR_HDR_SIZE)) {
+		DBG_ERR("Bad start: 0x%" PRIx32 "\n", h->adx_data_start);
+		return false;
+	}
+
+	if ((h->adx_data_start + h->adx_data_length) < h->adx_data_start) {
+		DBG_ERR("Bad length: %" PRIu32 "\n", h->adx_data_length);
+		return false;
+	}
+	if ((h->adx_data_start + h->adx_data_length) >
+	    ad->adx_header.adx_total_size)
+	{
+		DBG_ERR("Bad length: %" PRIu32 "\n", h->adx_data_length);
+		return false;
+	}
+
+	if (h->adx_num_attrs > AD_XATTR_MAX_ENTRIES) {
+		DBG_ERR("Bad num xattrs: %" PRIu16 "\n", h->adx_num_attrs);
+		return false;
+	}
+
+	if (h->adx_num_attrs == 0) {
+		return true;
+	}
+
+	ad->adx_entries = talloc_zero_array(
+		ad, struct ad_xattr_entry, h->adx_num_attrs);
+	if (ad->adx_entries == NULL) {
+		return false;
+	}
+
+	hoff += AD_XATTR_HDR_SIZE;
+
+	for (i = 0; i < h->adx_num_attrs; i++) {
+		struct ad_xattr_entry *e = &ad->adx_entries[i];
+
+		hoff = (hoff + 3) & ~3;
+
+		e->adx_offset  = RIVAL(p, hoff + 0);
+		e->adx_length  = RIVAL(p, hoff + 4);
+		e->adx_flags   = RSVAL(p, hoff + 8);
+		e->adx_namelen = *(p + hoff + 10);
+
+		if (e->adx_offset >= ad->adx_header.adx_total_size) {
+			DBG_ERR("Bad adx_offset: %" PRIx32 "\n",
+				e->adx_offset);
+			return false;
+		}
+
+		if ((e->adx_offset + e->adx_length) < e->adx_offset) {
+			DBG_ERR("Bad adx_length: %" PRIx32 "\n",
+				e->adx_length);
+			return false;
+		}
+
+		if ((e->adx_offset + e->adx_length) >
+		    ad->adx_header.adx_total_size)
+		{
+			DBG_ERR("Bad adx_length: %" PRIx32 "\n",
+				e->adx_length);
+			return false;
+		}
+
+		if (e->adx_namelen == 0) {
+			DBG_ERR("Bad adx_namelen: %" PRIx32 "\n",
+				e->adx_namelen);
+			return false;
+		}
+		if ((hoff + 11 + e->adx_namelen) < hoff + 11) {
+			DBG_ERR("Bad adx_namelen: %" PRIx32 "\n",
+				e->adx_namelen);
+			return false;
+		}
+		if ((hoff + 11 + e->adx_namelen) >
+		    ad->adx_header.adx_data_start)
+		{
+			DBG_ERR("Bad adx_namelen: %" PRIx32 "\n",
+				e->adx_namelen);
+			return false;
+		}
+
+		e->adx_name = talloc_strndup(ad->adx_entries,
+					     p + hoff + 11,
+					     e->adx_namelen);
+		if (e->adx_name == NULL) {
+			return false;
+		}
+
+		DBG_DEBUG("xattr [%s] offset [0x%x] size [0x%x]\n",
+			  e->adx_name, e->adx_offset, e->adx_length);
+		dump_data(10, (uint8_t *)(ad->ad_data + e->adx_offset),
+			  e->adx_length);
+
+		hoff += 11 + e->adx_namelen;
+	}
+
+	return true;
+}
+
+/**
+ * Unpack an AppleDouble blob into a struct adoble
+ **/
+static bool ad_unpack(struct adouble *ad, const size_t nentries,
+		      size_t filesize)
+{
+	size_t bufsize = talloc_get_size(ad->ad_data);
+	size_t adentries, i;
+	uint32_t eid, len, off;
+	bool ok;
+
+	/*
+	 * The size of the buffer ad->ad_data is checked when read, so
+	 * we wouldn't have to check our own offsets, a few extra
+	 * checks won't hurt though. We have to check the offsets we
+	 * read from the buffer anyway.
+	 */
+
+	if (bufsize < (AD_HEADER_LEN + (AD_ENTRY_LEN * nentries))) {
+		DBG_NOTICE("Bad size\n");
+		return false;
+	}
+
+	ad->ad_magic = RIVAL(ad->ad_data, 0);
+	ad->ad_version = RIVAL(ad->ad_data, ADEDOFF_VERSION);
+	if ((ad->ad_magic != AD_MAGIC) || (ad->ad_version != AD_VERSION)) {
+		DBG_NOTICE("Wrong magic or version\n");
+		return false;
+	}
+
+	memcpy(ad->ad_filler, ad->ad_data + ADEDOFF_FILLER, ADEDLEN_FILLER);
+
+	adentries = RSVAL(ad->ad_data, ADEDOFF_NENTRIES);
+	if (adentries != nentries) {
+		DBG_NOTICE("Invalid number of entries: %zu\n", adentries);
+		return false;
+	}
+
+	/* now, read in the entry bits */
+	for (i = 0; i < adentries; i++) {
+		eid = RIVAL(ad->ad_data, AD_HEADER_LEN + (i * AD_ENTRY_LEN));
+		eid = get_eid(eid);
+		off = RIVAL(ad->ad_data, AD_HEADER_LEN + (i * AD_ENTRY_LEN) + 4);
+		len = RIVAL(ad->ad_data, AD_HEADER_LEN + (i * AD_ENTRY_LEN) + 8);
+
+		if (!eid || eid >= ADEID_MAX) {
+			DBG_NOTICE("Bogus eid %d\n", eid);
+			return false;
+		}
+
+		/*
+		 * All entries other than the resource fork are
+		 * expected to be read into the ad_data buffer, so
+		 * ensure the specified offset is within that bound
+		 */
+		if ((off > bufsize) && (eid != ADEID_RFORK)) {
+			DBG_NOTICE("Bogus eid %d: off: %" PRIu32
+				   ", len: %" PRIu32 "\n",
+				   eid,
+				   off,
+				   len);
+			return false;
+		}
+
+		ok = ad_entry_check_size(eid, bufsize, off, len);
+		if (!ok) {
+			DBG_NOTICE("Bogus eid [%" PRIu32 "] bufsize [%zu] "
+				   "off [%" PRIu32 "] len [%" PRIu32 "]\n",
+				   eid,
+				   bufsize,
+				   off,
+				   len);
+			return false;
+		}
+
+		/*
+		 * That would be obviously broken
+		 */
+		if (off > filesize) {
+			DBG_NOTICE("Bogus eid %d: off: %" PRIu32
+				   ", len: %" PRIu32 "\n",
+				   eid,
+				   off,
+				   len);
+			return false;
+		}
+
+		/*
+		 * Check for any entry that has its end beyond the
+		 * filesize.
+		 */
+		if (off + len < off) {
+			DBG_NOTICE("offset wrap in eid %d: off: %" PRIu32
+				   ", len: %" PRIu32 "\n",
+				   eid,
+				   off,
+				   len);
+			return false;
+
+		}
+		if (off + len > filesize) {
+			/*
+			 * If this is the resource fork entry, we fix
+			 * up the length, for any other entry we bail
+			 * out.
+			 */
+			if (eid != ADEID_RFORK) {
+				DBG_NOTICE("Bogus eid %d: off: %" PRIu32
+					   ", len: %" PRIu32 "\n",
+					   eid,
+					   off,
+					   len);
+				return false;
+			}
+
+			/*
+			 * Fixup the resource fork entry by limiting
+			 * the size to entryoffset - filesize.
+			 */
+			len = filesize - off;
+			DBG_NOTICE("Limiting ADEID_RFORK: off: %" PRIu32
+				   ", len: %" PRIu32 "\n",
+				   off,
+				   len);
+		}
+
+		ad->ad_eid[eid].ade_off = off;
+		ad->ad_eid[eid].ade_len = len;
+	}
+
+	if (ad->ad_type == ADOUBLE_RSRC) {
+		ok = ad_unpack_xattrs(ad);
+		if (!ok) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+static bool ad_convert_move_reso(vfs_handle_struct *handle,
+				 struct adouble *ad,
+				 const struct smb_filename *smb_fname)
+{
+	char *buf = NULL;
+	size_t rforklen;
+	size_t rforkoff;
+	ssize_t n;
+	int ret;
+
+	rforklen = ad_getentrylen(ad, ADEID_RFORK);
+	if (rforklen == 0) {
+		return true;
+	}
+
+	buf = talloc_size(ad, rforklen);
+	if (buf == NULL) {
+		/*
+		 * This allocates a buffer for reading the resource fork data in
+		 * one big swoop. Resource forks won't be larger then, say, 64
+		 * MB, I swear, so just doing the allocation with the talloc
+		 * limit as safeguard seems safe.
+		 */
+		DBG_ERR("Failed to allocate %zu bytes for rfork\n",
+			rforklen);
+		return false;
+	}
+
+	rforkoff = ad_getentryoff(ad, ADEID_RFORK);
+
+	n = SMB_VFS_PREAD(ad->ad_fsp, buf, rforklen, rforkoff);
+	if (n != rforklen) {
+		DBG_ERR("Reading %zu bytes from rfork [%s] failed: %s\n",
+			rforklen, fsp_str_dbg(ad->ad_fsp), strerror(errno));
+		return false;
+	}
+
+	rforkoff = ADEDOFF_RFORK_DOT_UND;
+
+	n = SMB_VFS_PWRITE(ad->ad_fsp, buf, rforklen, rforkoff);
+	if (n != rforklen) {
+		DBG_ERR("Writing %zu bytes to rfork [%s] failed: %s\n",
+			rforklen, fsp_str_dbg(ad->ad_fsp), strerror(errno));
+		return false;
+	}
+
+	ad_setentryoff(ad, ADEID_RFORK, ADEDOFF_RFORK_DOT_UND);
+
+	ret = ad_fset(handle, ad, ad->ad_fsp);
+	if (ret != 0) {
+		DBG_ERR("ad_fset on [%s] failed\n", fsp_str_dbg(ad->ad_fsp));
+		return false;
+	}
+
+	return true;
+}
+
+static bool ad_convert_xattr(vfs_handle_struct *handle,
+			     struct adouble *ad,
+			     const struct smb_filename *smb_fname,
+			     const char *catia_mappings,
+			     bool *converted_xattr)
+{
+	static struct char_mappings **string_replace_cmaps = NULL;
+	uint16_t i;
+	int saved_errno = 0;
+	NTSTATUS status;
+	int rc;
+	bool ok;
+
+	*converted_xattr = false;
+
+	if (ad_getentrylen(ad, ADEID_FINDERI) == ADEDLEN_FINDERI) {
+		return true;
+	}
+
+	if (string_replace_cmaps == NULL) {
+		const char **mappings = NULL;
+
+		mappings = str_list_make_v3_const(
+			talloc_tos(), catia_mappings, NULL);
+		if (mappings == NULL) {
+			return false;
+		}
+		string_replace_cmaps = string_replace_init_map(
+			handle->conn->sconn, mappings);
+		TALLOC_FREE(mappings);
+	}
+
+	for (i = 0; i < ad->adx_header.adx_num_attrs; i++) {
+		struct ad_xattr_entry *e = &ad->adx_entries[i];
+		char *mapped_name = NULL;
+		char *tmp = NULL;
+		struct smb_filename *stream_name = NULL;
+		files_struct *fsp = NULL;
+		ssize_t nwritten;
+
+		status = string_replace_allocate(handle->conn,
+						 e->adx_name,
+						 string_replace_cmaps,
+						 talloc_tos(),
+						 &mapped_name,
+						 vfs_translate_to_windows);
+		if (!NT_STATUS_IS_OK(status) &&
+		    !NT_STATUS_EQUAL(status, NT_STATUS_NONE_MAPPED))
+		{
+			DBG_ERR("string_replace_allocate failed\n");
+			ok = false;
+			goto fail;
+		}
+
+		tmp = mapped_name;
+		mapped_name = talloc_asprintf(talloc_tos(), ":%s", tmp);
+		TALLOC_FREE(tmp);
+		if (mapped_name == NULL) {
+			ok = false;
+			goto fail;
+		}
+
+		stream_name = synthetic_smb_fname(talloc_tos(),
+						  smb_fname->base_name,
+						  mapped_name,
+						  NULL,
+						  smb_fname->twrp,
+						  smb_fname->flags);
+		TALLOC_FREE(mapped_name);
+		if (stream_name == NULL) {
+			DBG_ERR("synthetic_smb_fname failed\n");
+			ok = false;
+			goto fail;
+		}
+
+		DBG_DEBUG("stream_name: %s\n", smb_fname_str_dbg(stream_name));
+
+		status = openat_pathref_fsp(handle->conn->cwd_fsp, stream_name);
+		if (!NT_STATUS_IS_OK(status) &&
+		    !NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND))
+		{
+			ok = false;
+			goto fail;
+		}
+
+		status = SMB_VFS_CREATE_FILE(
+			handle->conn,			/* conn */
+			NULL,				/* req */
+			NULL,				/* dirfsp */
+			stream_name,			/* fname */
+			FILE_GENERIC_WRITE,		/* access_mask */
+			FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, /* share_access */
+			FILE_OPEN_IF,			/* create_disposition */
+			0,				/* create_options */
+			0,				/* file_attributes */
+			INTERNAL_OPEN_ONLY,		/* oplock_request */
+			NULL,				/* lease */
+			0,				/* allocation_size */
+			0,				/* private_flags */
+			NULL,				/* sd */
+			NULL,				/* ea_list */
+			&fsp,				/* result */
+			NULL,				/* psbuf */
+			NULL, NULL);			/* create context */
+		TALLOC_FREE(stream_name);
+		if (!NT_STATUS_IS_OK(status)) {
+			DBG_ERR("SMB_VFS_CREATE_FILE failed\n");
+			ok = false;
+			goto fail;
+		}
+
+		nwritten = SMB_VFS_PWRITE(fsp,
+					  ad->ad_data + e->adx_offset,
+					  e->adx_length,
+					  0);
+		if (nwritten == -1) {
+			DBG_ERR("SMB_VFS_PWRITE failed\n");
+			saved_errno = errno;
+			close_file_free(NULL, &fsp, ERROR_CLOSE);
+			errno = saved_errno;
+			ok = false;
+			goto fail;
+		}
+
+		status = close_file_free(NULL, &fsp, NORMAL_CLOSE);
+		if (!NT_STATUS_IS_OK(status)) {
+			ok = false;
+			goto fail;
+		}
+		fsp = NULL;
+	}
+
+	ad->adx_header.adx_num_attrs = 0;
+	TALLOC_FREE(ad->adx_entries);
+
+	ad_setentrylen(ad, ADEID_FINDERI, ADEDLEN_FINDERI);
+
+	rc = ad_fset(handle, ad, ad->ad_fsp);
+	if (rc != 0) {
+		DBG_ERR("ad_fset on [%s] failed: %s\n",
+			fsp_str_dbg(ad->ad_fsp), strerror(errno));
+		ok = false;
+		goto fail;
+	}
+
+	ok = ad_convert_move_reso(handle, ad, smb_fname);
+	if (!ok) {
+		goto fail;
+	}
+
+	*converted_xattr = true;
+	ok = true;
+
+fail:
+	return ok;
+}
+
+static bool ad_convert_finderinfo(vfs_handle_struct *handle,
+				  struct adouble *ad,
+				  const struct smb_filename *smb_fname)
+{
+	char *p_ad = NULL;
+	AfpInfo *ai = NULL;
+	DATA_BLOB aiblob;
+	struct smb_filename *stream_name = NULL;
+	files_struct *fsp = NULL;
+	size_t size;
+	ssize_t nwritten;
+	NTSTATUS status;
+	int saved_errno = 0;
+	int cmp;
+
+	cmp = memcmp(ad->ad_filler, AD_FILLER_TAG_OSX, ADEDLEN_FILLER);
+	if (cmp != 0) {
+		return true;
+	}
+
+	p_ad = ad_get_entry(ad, ADEID_FINDERI);
+	if (p_ad == NULL) {
+		return false;
+	}
+
+	ai = afpinfo_new(talloc_tos());
+	if (ai == NULL) {
+		return false;
+	}
+
+	memcpy(ai->afpi_FinderInfo, p_ad, ADEDLEN_FINDERI);
+
+	aiblob = data_blob_talloc(talloc_tos(), NULL, AFP_INFO_SIZE);
+	if (aiblob.data == NULL) {
+		TALLOC_FREE(ai);
+		return false;
+	}
+
+	size = afpinfo_pack(ai, (char *)aiblob.data);
+	TALLOC_FREE(ai);
+	if (size != AFP_INFO_SIZE) {
+		return false;
+	}
+
+	stream_name = synthetic_smb_fname(talloc_tos(),
+					  smb_fname->base_name,
+					  AFPINFO_STREAM,
+					  NULL,
+					  smb_fname->twrp,
+					  smb_fname->flags);
+	if (stream_name == NULL) {
+		data_blob_free(&aiblob);
+		DBG_ERR("synthetic_smb_fname failed\n");
+		return false;
+	}
+
+	DBG_DEBUG("stream_name: %s\n", smb_fname_str_dbg(stream_name));
+
+	status = openat_pathref_fsp(handle->conn->cwd_fsp, stream_name);
+	if (!NT_STATUS_IS_OK(status) &&
+	    !NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND))
+	{
+		return false;
+	}
+
+	status = SMB_VFS_CREATE_FILE(
+		handle->conn,			/* conn */
+		NULL,				/* req */
+		NULL,				/* dirfsp */
+		stream_name,			/* fname */
+		FILE_GENERIC_WRITE,		/* access_mask */
+		FILE_SHARE_READ | FILE_SHARE_WRITE, /* share_access */
+		FILE_OPEN_IF,			/* create_disposition */
+		0,				/* create_options */
+		0,				/* file_attributes */
+		INTERNAL_OPEN_ONLY,		/* oplock_request */
+		NULL,				/* lease */
+		0,				/* allocation_size */
+		0,				/* private_flags */
+		NULL,				/* sd */
+		NULL,				/* ea_list */
+		&fsp,				/* result */
+		NULL,				/* psbuf */
+		NULL, NULL);			/* create context */
+	TALLOC_FREE(stream_name);
+	if (!NT_STATUS_IS_OK(status)) {
+		DBG_ERR("SMB_VFS_CREATE_FILE failed\n");
+		return false;
+	}
+
+	nwritten = SMB_VFS_PWRITE(fsp,
+				  aiblob.data,
+				  aiblob.length,
+				  0);
+	if (nwritten == -1) {
+		DBG_ERR("SMB_VFS_PWRITE failed\n");
+		saved_errno = errno;
+		close_file_free(NULL, &fsp, ERROR_CLOSE);
+		errno = saved_errno;
+		return false;
+	}
+
+	status = close_file_free(NULL, &fsp, NORMAL_CLOSE);
+	if (!NT_STATUS_IS_OK(status)) {
+		return false;
+	}
+	fsp = NULL;
+
+	return true;
+}
+
+static bool ad_convert_truncate(vfs_handle_struct *handle,
+				struct adouble *ad,
+				const struct smb_filename *smb_fname)
+{
+	int rc;
+	off_t newlen;
+
+	newlen = ADEDOFF_RFORK_DOT_UND + ad_getentrylen(ad, ADEID_RFORK);
+
+	rc = SMB_VFS_FTRUNCATE(ad->ad_fsp, newlen);
+	if (rc != 0) {
+		return false;
+	}
+
+	return true;
+}
+
+static bool ad_convert_blank_rfork(vfs_handle_struct *handle,
+				   struct adouble *ad,
+				   uint32_t flags,
+				   bool *blank)
+{
+	size_t rforklen = sizeof(empty_resourcefork);
+	char buf[rforklen];
+	ssize_t nread;
+	int cmp;
+	int rc;
+
+	*blank = false;
+
+	if (!(flags & AD_CONV_WIPE_BLANK)) {
+		return true;
+	}
+
+	if (ad_getentrylen(ad, ADEID_RFORK) != rforklen) {
+		return true;
+	}
+
+	nread = SMB_VFS_PREAD(ad->ad_fsp, buf, rforklen, ADEDOFF_RFORK_DOT_UND);
+	if (nread != rforklen) {
+		DBG_ERR("Reading %zu bytes from rfork [%s] failed: %s\n",
+			rforklen, fsp_str_dbg(ad->ad_fsp), strerror(errno));
+		return false;
+	}
+
+	cmp = memcmp(buf, empty_resourcefork, rforklen);
+	if (cmp != 0) {
+		return true;
+	}
+
+	ad_setentrylen(ad, ADEID_RFORK, 0);
+
+	rc = ad_fset(handle, ad, ad->ad_fsp);
+	if (rc != 0) {
+		DBG_ERR("ad_fset on [%s] failed\n", fsp_str_dbg(ad->ad_fsp));
+		return false;
+	}
+
+	*blank = true;
+	return true;
+}
+
+static bool ad_convert_delete_adfile(vfs_handle_struct *handle,
+				struct adouble *ad,
+				const struct smb_filename *smb_fname,
+				uint32_t flags)
+{
+	struct smb_filename *parent_fname = NULL;
+	struct smb_filename *at_fname = NULL;
+	struct smb_filename *ad_name = NULL;
+	NTSTATUS status;
+	int rc;
+
+	if (ad_getentrylen(ad, ADEID_RFORK) > 0) {
+		return true;
+	}
+
+	if (!(flags & AD_CONV_DELETE)) {
+		return true;
+	}
+
+	rc = adouble_path(talloc_tos(), smb_fname, &ad_name);
+	if (rc != 0) {
+		return false;
+	}
+
+	status = parent_pathref(talloc_tos(),
+				handle->conn->cwd_fsp,
+				ad_name,
+				&parent_fname,
+				&at_fname);
+	TALLOC_FREE(ad_name);
+	if (!NT_STATUS_IS_OK(status)) {
+		return false;
+	}
+
+	rc = SMB_VFS_NEXT_UNLINKAT(handle,
+			parent_fname->fsp,
+			at_fname,
+			0);
+	if (rc != 0) {
+		DBG_ERR("Unlinking [%s/%s] failed: %s\n",
+			smb_fname_str_dbg(parent_fname),
+			smb_fname_str_dbg(at_fname), strerror(errno));
+		TALLOC_FREE(parent_fname);
+		return false;
+	}
+
+	DBG_WARNING("Unlinked [%s/%s] after conversion\n",
+		    smb_fname_str_dbg(parent_fname),
+		    smb_fname_str_dbg(at_fname));
+	TALLOC_FREE(parent_fname);
+
+	return true;
+}
+
+/**
+ * Convert from Apple's ._ file to Netatalk
+ *
+ * Apple's AppleDouble may contain a FinderInfo entry longer then 32
+ * bytes containing packed xattrs.
+ *
+ * @return -1 in case an error occurred, 0 if no conversion was done, 1
+ * otherwise
+ **/
+int ad_convert(struct vfs_handle_struct *handle,
+		const struct smb_filename *smb_fname,
+		const char *catia_mappings,
+		uint32_t flags)
+{
+	struct adouble *ad = NULL;
+	bool ok;
+	bool converted_xattr = false;
+	bool blank;
+	int ret;
+
+	ad = ad_get(talloc_tos(), handle, smb_fname, ADOUBLE_RSRC);
+	if (ad == NULL) {
+		return 0;
+	}
+
+	ok = ad_convert_xattr(handle,
+			      ad,
+			      smb_fname,
+			      catia_mappings,
+			      &converted_xattr);
+	if (!ok) {
+		ret = -1;
+		goto done;
+	}
+
+	ok = ad_convert_blank_rfork(handle, ad, flags, &blank);
+	if (!ok) {
+		ret = -1;
+		goto done;
+	}
+
+	if (converted_xattr || blank) {
+		ok = ad_convert_truncate(handle, ad, smb_fname);
+		if (!ok) {
+			ret = -1;
+			goto done;
+		}
+	}
+
+	ok = ad_convert_finderinfo(handle, ad, smb_fname);
+	if (!ok) {
+		DBG_ERR("Failed to convert [%s]\n",
+			smb_fname_str_dbg(smb_fname));
+		ret = -1;
+		goto done;
+	}
+
+	ok = ad_convert_delete_adfile(handle,
+			ad,
+			smb_fname,
+			flags);
+	if (!ok) {
+		ret = -1;
+		goto done;
+	}
+
+	ret = 0;
+done:
+	TALLOC_FREE(ad);
+	return ret;
+}
+
+static bool ad_unconvert_open_ad(TALLOC_CTX *mem_ctx,
+				 struct vfs_handle_struct *handle,
+				 struct smb_filename *smb_fname,
+				 struct smb_filename *adpath,
+				 files_struct **_fsp)
+{
+	files_struct *fsp = NULL;
+	NTSTATUS status;
+	int ret;
+
+	status = openat_pathref_fsp(handle->conn->cwd_fsp, adpath);
+	if (!NT_STATUS_IS_OK(status) &&
+	    !NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
+		return false;
+	}
+
+	status = SMB_VFS_CREATE_FILE(
+		handle->conn,
+		NULL,				/* req */
+		NULL,				/* dirfsp */
+		adpath,
+		FILE_READ_DATA|FILE_WRITE_DATA,
+		FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
+		FILE_OPEN_IF,
+		0,				/* create_options */
+		0,				/* file_attributes */
+		INTERNAL_OPEN_ONLY,
+		NULL,				/* lease */
+		0,				/* allocation_size */
+		0,				/* private_flags */
+		NULL,				/* sd */
+		NULL,				/* ea_list */
+		&fsp,
+		NULL,				/* info */
+		NULL, NULL);			/* create context */
+	if (!NT_STATUS_IS_OK(status)) {
+		DBG_ERR("SMB_VFS_CREATE_FILE [%s] failed: %s\n",
+			smb_fname_str_dbg(adpath), nt_errstr(status));
+		return false;
+	}
+
+	if (fsp->fsp_name->st.st_ex_uid != smb_fname->st.st_ex_uid ||
+	    fsp->fsp_name->st.st_ex_gid != smb_fname->st.st_ex_gid)
+	{
+		ret = SMB_VFS_FCHOWN(fsp,
+				     smb_fname->st.st_ex_uid,
+				     smb_fname->st.st_ex_gid);
+		if (ret != 0) {
+			DBG_ERR("SMB_VFS_FCHOWN [%s] failed: %s\n",
+				fsp_str_dbg(fsp), nt_errstr(status));
+			close_file_free(NULL, &fsp, NORMAL_CLOSE);
+			return false;
+		}
+	}
+
+	*_fsp = fsp;
+	return true;
+}
+
+static bool ad_unconvert_get_streams(struct vfs_handle_struct *handle,
+				     struct smb_filename *smb_fname,
+				     TALLOC_CTX *mem_ctx,
+				     unsigned int *num_streams,
+				     struct stream_struct **streams)
+{
+	files_struct *fsp = NULL;
+	NTSTATUS status;
+
+	status = openat_pathref_fsp(handle->conn->cwd_fsp, smb_fname);
+	if (!NT_STATUS_IS_OK(status)) {
+		return false;
+	}
+
+	status = SMB_VFS_CREATE_FILE(
+		handle->conn,				/* conn */
+		NULL,					/* req */
+		NULL,					/* dirfsp */
+		smb_fname,				/* fname */
+		FILE_READ_ATTRIBUTES,			/* access_mask */
+		(FILE_SHARE_READ | FILE_SHARE_WRITE |	/* share_access */
+			FILE_SHARE_DELETE),
+		FILE_OPEN,				/* create_disposition*/
+		0,					/* create_options */
+		0,					/* file_attributes */
+		INTERNAL_OPEN_ONLY,			/* oplock_request */
+		NULL,					/* lease */
+		0,					/* allocation_size */
+		0,					/* private_flags */
+		NULL,					/* sd */
+		NULL,					/* ea_list */
+		&fsp,					/* result */
+		NULL,					/* pinfo */
+		NULL, NULL);				/* create context */
+	if (!NT_STATUS_IS_OK(status)) {
+		DBG_ERR("Opening [%s] failed: %s\n",
+			smb_fname_str_dbg(smb_fname),
+			nt_errstr(status));
+		return false;
+	}
+
+	status = vfs_fstreaminfo(fsp,
+				mem_ctx,
+				num_streams,
+				streams);
+	if (!NT_STATUS_IS_OK(status)) {
+		close_file_free(NULL, &fsp, NORMAL_CLOSE);
+		DBG_ERR("streaminfo on [%s] failed: %s\n",
+			smb_fname_str_dbg(smb_fname),
+			nt_errstr(status));
+		return false;
+	}
+
+	status = close_file_free(NULL, &fsp, NORMAL_CLOSE);
+	if (!NT_STATUS_IS_OK(status)) {
+		DBG_ERR("close_file [%s] failed: %s\n",
+			smb_fname_str_dbg(smb_fname),
+			nt_errstr(status));
+		return false;
+	}
+
+	return true;
+}
+
+struct ad_collect_state {
+	bool have_adfile;
+	size_t adx_data_off;
+	char *rsrc_data_buf;
+};
+
+static bool ad_collect_one_stream(struct vfs_handle_struct *handle,
+				  struct char_mappings **cmaps,
+				  struct smb_filename *smb_fname,
+				  const struct stream_struct *stream,
+				  struct adouble *ad,
+				  struct ad_collect_state *state)
+{
+	struct smb_filename *sname = NULL;
+	files_struct *fsp = NULL;
+	struct ad_xattr_entry *e = NULL;
+	char *mapped_name = NULL;
+	char *p = NULL;
+	size_t needed_size;
+	ssize_t nread;
+	NTSTATUS status;
+	bool ok;
+
+	sname = synthetic_smb_fname(ad,
+				    smb_fname->base_name,
+				    stream->name,
+				    NULL,
+				    smb_fname->twrp,
+				    0);
+	if (sname == NULL) {
+		return false;
+	}
+
+	if (is_ntfs_default_stream_smb_fname(sname)) {
+		TALLOC_FREE(sname);
+		return true;
+	}
+
+	DBG_DEBUG("Collecting stream [%s]\n", smb_fname_str_dbg(sname));
+
+	status = openat_pathref_fsp(handle->conn->cwd_fsp, sname);
+	if (!NT_STATUS_IS_OK(status)) {
+		ok = false;
+		goto out;
+	}
+
+	status = SMB_VFS_CREATE_FILE(
+		handle->conn,
+		NULL,				/* req */
+		NULL,				/* dirfsp */
+		sname,
+		FILE_READ_DATA|DELETE_ACCESS,
+		FILE_SHARE_READ,
+		FILE_OPEN,
+		0,				/* create_options */
+		0,				/* file_attributes */
+		INTERNAL_OPEN_ONLY,		/* oplock_request */
+		NULL,				/* lease */
+		0,				/* allocation_size */
+		0,				/* private_flags */
+		NULL,				/* sd */
+		NULL,				/* ea_list */
+		&fsp,
+		NULL,				/* info */
+		NULL, NULL);			/* create context */
+	if (!NT_STATUS_IS_OK(status)) {
+		DBG_ERR("SMB_VFS_CREATE_FILE [%s] failed\n",
+			smb_fname_str_dbg(sname));
+		ok = false;
+		goto out;
+	}
+
+	if (is_afpinfo_stream(stream->name)) {
+		char buf[AFP_INFO_SIZE];
+
+		if (stream->size != AFP_INFO_SIZE) {
+			DBG_ERR("Bad size [%zd] on [%s]\n",
+				(ssize_t)stream->size,
+				smb_fname_str_dbg(sname));
+			ok = false;
+			goto out;
+		}
+
+		nread = SMB_VFS_PREAD(fsp, buf, stream->size, 0);
+		if (nread != AFP_INFO_SIZE) {
+			DBG_ERR("Bad size [%zd] on [%s]\n",
+				(ssize_t)stream->size,
+				smb_fname_str_dbg(sname));
+			ok = false;
+			goto out;
+		}
+
+		memcpy(ad->ad_data + ADEDOFF_FINDERI_DOT_UND,
+		       buf + AFP_OFF_FinderInfo,
+		       AFP_FinderSize);
+
+		ok = set_delete_on_close(fsp,
+					 true,
+					 fsp->conn->session_info->security_token,
+					 fsp->conn->session_info->unix_token);
+		if (!ok) {
+			DBG_ERR("Deleting [%s] failed\n",
+				smb_fname_str_dbg(sname));
+			ok = false;
+			goto out;
+		}
+		ok = true;
+		goto out;
+	}
+
+	if (is_afpresource_stream(stream->name)) {
+		ad->ad_rsrc_data = talloc_size(ad, stream->size);
+		if (ad->ad_rsrc_data == NULL) {
+			ok = false;
+			goto out;
+		}
+
+		nread = SMB_VFS_PREAD(fsp,
+				      ad->ad_rsrc_data,
+				      stream->size,
+				      0);
+		if (nread != stream->size) {
+			DBG_ERR("Bad size [%zd] on [%s]\n",
+				(ssize_t)stream->size,
+				smb_fname_str_dbg(sname));
+			ok = false;
+			goto out;
+		}
+
+		ad_setentrylen(ad, ADEID_RFORK, stream->size);
+
+		if (!state->have_adfile) {
+			/*
+			 * We have a resource *stream* but no AppleDouble
+			 * sidecar file, this means the share is configured with
+			 * fruit:resource=stream. So we should delete the
+			 * resource stream.
+			 */
+			ok = set_delete_on_close(
+				fsp,
+				true,
+				fsp->conn->session_info->security_token,
+				fsp->conn->session_info->unix_token);
+			if (!ok) {
+				DBG_ERR("Deleting [%s] failed\n",
+					smb_fname_str_dbg(sname));
+				ok = false;
+				goto out;
+			}
+		}
+		ok = true;
+		goto out;
+	}
+
+	ad->adx_entries = talloc_realloc(ad,
+					 ad->adx_entries,
+					 struct ad_xattr_entry,
+					 ad->adx_header.adx_num_attrs + 1);
+	if (ad->adx_entries == NULL) {
+		ok = false;
+		goto out;
+	}
+
+	e = &ad->adx_entries[ad->adx_header.adx_num_attrs];
+	*e = (struct ad_xattr_entry) {
+		.adx_length = stream->size,
+	};
+	e->adx_name = talloc_strdup(ad, stream->name + 1);
+	if (e->adx_name == NULL) {
+		ok = false;
+		goto out;
+	}
+	p = strchr(e->adx_name, ':');
+	if (p != NULL) {
+		*p = '\0';
+	}
+
+	status = string_replace_allocate(handle->conn,
+					 e->adx_name,
+					 cmaps,
+					 ad,
+					 &mapped_name,
+					 vfs_translate_to_unix);
+	if (!NT_STATUS_IS_OK(status) &&
+	    !NT_STATUS_EQUAL(status, NT_STATUS_NONE_MAPPED))
+	{
+		DBG_ERR("string_replace_allocate failed\n");
+		ok = false;
+		goto out;
+	}
+
+	e->adx_name = mapped_name;
+	e->adx_namelen = strlen(e->adx_name) + 1,
+
+	DBG_DEBUG("%u: name (%s) size (%zu)\n",
+		  ad->adx_header.adx_num_attrs,
+		  e->adx_name,
+		  (size_t)e->adx_length);
+
+	ad->adx_header.adx_num_attrs++;
+
+	needed_size = state->adx_data_off + stream->size;
+	if (needed_size > talloc_get_size(ad->adx_data)) {
+		ad->adx_data = talloc_realloc(ad,
+					      ad->adx_data,
+					      char,
+					      needed_size);
+		if (ad->adx_data == NULL) {
+			ok = false;
+			goto out;
+		}
+	}
+
+	nread = SMB_VFS_PREAD(fsp,
+			      ad->adx_data + state->adx_data_off,
+			      stream->size,
+			      0);
+	if (nread != stream->size) {
+		DBG_ERR("Bad size [%zd] on [%s]\n",
+			(ssize_t)stream->size,
+			smb_fname_str_dbg(sname));
+		ok = false;
+		goto out;
+	}
+	state->adx_data_off += nread;
+
+	ok = set_delete_on_close(fsp,
+				 true,
+				 fsp->conn->session_info->security_token,
+				 fsp->conn->session_info->unix_token);
+	if (!ok) {
+		DBG_ERR("Deleting [%s] failed\n",
+			smb_fname_str_dbg(sname));
+		ok = false;
+		goto out;
+	}
+
+out:
+	TALLOC_FREE(sname);
+	if (fsp != NULL) {
+		status = close_file_free(NULL, &fsp, NORMAL_CLOSE);
+		if (!NT_STATUS_IS_OK(status)) {
+			DBG_ERR("close_file [%s] failed: %s\n",
+				smb_fname_str_dbg(smb_fname),
+				nt_errstr(status));
+			ok = false;
+		}
+	}
+
+	return ok;
+}
+
+/**
+ * Convert filesystem metadata to AppleDouble file
+ **/
+bool ad_unconvert(TALLOC_CTX *mem_ctx,
+		  struct vfs_handle_struct *handle,
+		  const char *catia_mappings,
+		  struct smb_filename *smb_fname,
+		  bool *converted)
+{
+	static struct char_mappings **cmaps = NULL;
+	TALLOC_CTX *frame = talloc_stackframe();
+	struct ad_collect_state state;
+	struct stream_struct *streams = NULL;
+	struct smb_filename *adpath = NULL;
+	struct adouble *ad = NULL;
+	unsigned int num_streams = 0;
+	size_t to_convert = 0;
+	bool have_rsrc = false;
+	files_struct *fsp = NULL;
+	size_t i;
+	NTSTATUS status;
+	int ret;
+	bool ok;
+
+	*converted = false;
+
+	if (cmaps == NULL) {
+		const char **mappings = NULL;
+
+		mappings = str_list_make_v3_const(
+			frame, catia_mappings, NULL);
+		if (mappings == NULL) {
+			ok = false;
+			goto out;
+		}
+		cmaps = string_replace_init_map(mem_ctx, mappings);
+		TALLOC_FREE(mappings);
+	}
+
+	ok = ad_unconvert_get_streams(handle,
+				      smb_fname,
+				      frame,
+				      &num_streams,
+				      &streams);
+	if (!ok) {
+		goto out;
+	}
+
+	for (i = 0; i < num_streams; i++) {
+		if (strcasecmp_m(streams[i].name, "::$DATA") == 0) {
+			continue;
+		}
+		to_convert++;
+		if (is_afpresource_stream(streams[i].name)) {
+			have_rsrc = true;
+		}
+	}
+
+	if (to_convert == 0) {
+		ok = true;
+		goto out;
+	}
+
+	state = (struct ad_collect_state) {
+		.adx_data_off = 0,
+	};
+
+	ret = adouble_path(frame, smb_fname, &adpath);
+	if (ret != 0) {
+		ok = false;
+		goto out;
+	}
+
+	ret = SMB_VFS_STAT(handle->conn, adpath);
+	if (ret == 0) {
+		state.have_adfile = true;
+	} else {
+		if (errno != ENOENT) {
+			ok = false;
+			goto out;
+		}
+		state.have_adfile = false;
+	}
+
+	if (to_convert == 1 && have_rsrc && state.have_adfile) {
+		/*
+		 * So we have just a single stream, the resource fork stream
+		 * from an AppleDouble file. Fine, that means there's nothing to
+		 * convert.
+		 */
+		ok = true;
+		goto out;
+	}
+
+	ad = ad_init(frame, ADOUBLE_RSRC);
+	if (ad == NULL) {
+		ok = false;
+		goto out;
+	}
+
+	for (i = 0; i < num_streams; i++) {
+		ok = ad_collect_one_stream(handle,
+					   cmaps,
+					   smb_fname,
+					   &streams[i],
+					   ad,
+					   &state);
+		if (!ok) {
+			goto out;
+		}
+	}
+
+	ok = ad_unconvert_open_ad(frame, handle, smb_fname, adpath, &fsp);
+	if (!ok) {
+		DBG_ERR("Failed to open adfile [%s]\n",
+			smb_fname_str_dbg(smb_fname));
+		goto out;
+	}
+
+	ret = ad_fset(handle, ad, fsp);
+	if (ret != 0) {
+		ok = false;
+		goto out;
+	}
+
+	*converted = true;
+	ok = true;
+
+out:
+	if (fsp != NULL) {
+		status = close_file_free(NULL, &fsp, NORMAL_CLOSE);
+		if (!NT_STATUS_IS_OK(status)) {
+			DBG_ERR("close_file_free() [%s] failed: %s\n",
+				smb_fname_str_dbg(smb_fname),
+				nt_errstr(status));
+			ok = false;
+		}
+	}
+	TALLOC_FREE(frame);
+	return ok;
+}
+
+/**
+ * Read and parse Netatalk AppleDouble metadata xattr
+ **/
+static ssize_t ad_read_meta(vfs_handle_struct *handle,
+			    struct adouble *ad,
+			    const struct smb_filename *smb_fname)
+{
+	int      rc = 0;
+	ssize_t  ealen;
+	bool     ok;
+	struct files_struct *fsp = smb_fname->fsp;
+
+	DEBUG(10, ("reading meta xattr for %s\n", smb_fname->base_name));
+
+	fsp = metadata_fsp(fsp);
+
+	ealen = SMB_VFS_FGETXATTR(fsp,
+				  AFPINFO_EA_NETATALK,
+				  ad->ad_data,
+				  AD_DATASZ_XATTR);
+
+	if (ealen == -1) {
+		switch (errno) {
+		case ENOATTR:
+		case ENOENT:
+			if (errno == ENOATTR) {
+				errno = ENOENT;
+			}
+			rc = -1;
+			goto exit;
+		default:
+			DEBUG(2, ("error reading meta xattr: %s\n",
+				  strerror(errno)));
+			rc = -1;
+			goto exit;
+		}
+	}
+	if (ealen != AD_DATASZ_XATTR) {
+		DEBUG(2, ("bad size %zd\n", ealen));
+		errno = EINVAL;
+		rc = -1;
+		goto exit;
+	}
+
+	/* Now parse entries */
+	ok = ad_unpack(ad, ADEID_NUM_XATTR, AD_DATASZ_XATTR);
+	if (!ok) {
+		DBG_WARNING(
+			"Invalid AppleDouble xattr metadata (%s) in file: %s - "
+			"Consider deleting the corrupted file.\n",
+			smb_fname->base_name,
+			ad->ad_fsp->fsp_name->base_name);
+		errno = EINVAL;
+		rc = -1;
+		goto exit;
+	}
+
+	if (!ad_getentryoff(ad, ADEID_FINDERI)
+	    || !ad_getentryoff(ad, ADEID_COMMENT)
+	    || !ad_getentryoff(ad, ADEID_FILEDATESI)
+	    || !ad_getentryoff(ad, ADEID_AFPFILEI)
+	    || !ad_getentryoff(ad, ADEID_PRIVDEV)
+	    || !ad_getentryoff(ad, ADEID_PRIVINO)
+	    || !ad_getentryoff(ad, ADEID_PRIVSYN)
+	    || !ad_getentryoff(ad, ADEID_PRIVID)) {
+		DEBUG(2, ("invalid AppleDouble metadata xattr\n"));
+		errno = EINVAL;
+		rc = -1;
+		goto exit;
+	}
+
+exit:
+	DEBUG(10, ("reading meta xattr for %s, rc: %d\n",
+		smb_fname->base_name, rc));
+
+	if (rc != 0) {
+		ealen = -1;
+		if (errno == EINVAL) {
+			become_root();
+			(void)SMB_VFS_FREMOVEXATTR(fsp,
+						   AFPINFO_EA_NETATALK);
+			unbecome_root();
+			errno = ENOENT;
+		}
+	}
+	return ealen;
+}
+
+static NTSTATUS adouble_open_rsrc_fsp(const struct files_struct *dirfsp,
+				      const struct smb_filename *smb_base_fname,
+				      int in_flags,
+				      mode_t mode,
+				      struct files_struct **_ad_fsp)
+{
+	int rc = 0;
+	struct adouble *ad = NULL;
+	struct smb_filename *adp_smb_fname = NULL;
+	struct files_struct *ad_fsp = NULL;
+	NTSTATUS status;
+	struct vfs_open_how how = { .flags = in_flags, .mode = mode, };
+
+	rc = adouble_path(talloc_tos(),
+			  smb_base_fname,
+			  &adp_smb_fname);
+	if (rc != 0) {
+		return NT_STATUS_NO_MEMORY;
+	}
+
+	status = create_internal_fsp(dirfsp->conn,
+				     adp_smb_fname,
+				     &ad_fsp);
+	if (!NT_STATUS_IS_OK(status)) {
+		return status;
+	}
+
+#ifdef O_PATH
+	how.flags &= ~(O_PATH);
+#endif
+	if (how.flags & (O_CREAT | O_TRUNC | O_WRONLY)) {
+		/* We always need read/write access for the metadata header too */
+		how.flags &= ~(O_WRONLY);
+		how.flags |= O_RDWR;
+	}
+
+	status = fd_openat(dirfsp,
+			   adp_smb_fname,
+			   ad_fsp,
+			   &how);
+	if (!NT_STATUS_IS_OK(status)) {
+		file_free(NULL, ad_fsp);
+		return status;
+	}
+
+	if (how.flags & (O_CREAT | O_TRUNC)) {
+		ad = ad_init(talloc_tos(), ADOUBLE_RSRC);
+		if (ad == NULL) {
+			file_free(NULL, ad_fsp);
+			return NT_STATUS_NO_MEMORY;
+		}
+
+		rc = ad_fset(ad_fsp->conn->vfs_handles, ad, ad_fsp);
+		if (rc != 0) {
+			file_free(NULL, ad_fsp);
+			return NT_STATUS_IO_DEVICE_ERROR;
+		}
+		TALLOC_FREE(ad);
+	}
+
+	*_ad_fsp = ad_fsp;
+	return NT_STATUS_OK;
+}
+
+NTSTATUS adouble_open_from_base_fsp(const struct files_struct *dirfsp,
+				    struct files_struct *base_fsp,
+				    adouble_type_t type,
+				    int flags,
+				    mode_t mode,
+				    struct files_struct **_ad_fsp)
+{
+	*_ad_fsp = NULL;
+
+	SMB_ASSERT(base_fsp != NULL);
+	SMB_ASSERT(!fsp_is_alternate_stream(base_fsp));
+
+	switch (type) {
+	case ADOUBLE_META:
+		return NT_STATUS_INTERNAL_ERROR;
+	case ADOUBLE_RSRC:
+		return adouble_open_rsrc_fsp(dirfsp,
+					     base_fsp->fsp_name,
+					     flags,
+					     mode,
+					     _ad_fsp);
+	}
+
+	return NT_STATUS_INTERNAL_ERROR;
+}
+
+/*
+ * Here's the deal: for ADOUBLE_META we can do without an fd as we can issue
+ * path based xattr calls. For ADOUBLE_RSRC however we need a full-fledged fd
+ * for file IO on the ._ file.
+ */
+static int ad_open(vfs_handle_struct *handle,
+		   struct adouble *ad,
+		   files_struct *fsp,
+		   const struct smb_filename *smb_fname,
+		   int flags,
+		   mode_t mode)
+{
+	NTSTATUS status;
+
+	DBG_DEBUG("Path [%s] type [%s]\n", smb_fname->base_name,
+		  ad->ad_type == ADOUBLE_META ? "meta" : "rsrc");
+
+	if (ad->ad_type == ADOUBLE_META) {
+		return 0;
+	}
+
+	if (fsp != NULL) {
+		ad->ad_fsp = fsp;
+		ad->ad_opened = false;
+		return 0;
+	}
+
+	status = adouble_open_rsrc_fsp(handle->conn->cwd_fsp,
+				       smb_fname,
+				       flags,
+				       mode,
+				       &ad->ad_fsp);
+	if (!NT_STATUS_IS_OK(status)) {
+		errno = map_errno_from_nt_status(status);
+		return -1;
+	}
+	ad->ad_opened = true;
+
+	DBG_DEBUG("Path [%s] type [%s]\n",
+		  smb_fname->base_name,
+		  ad->ad_type == ADOUBLE_META ? "meta" : "rsrc");
+
+	return 0;
+}
+
+static ssize_t ad_read_rsrc_adouble(vfs_handle_struct *handle,
+				    struct adouble *ad,
+				    const struct smb_filename *smb_fname)
+{
+	size_t to_read;
+	ssize_t len;
+	int ret;
+	bool ok;
+
+	ret = SMB_VFS_NEXT_FSTAT(handle, ad->ad_fsp, &ad->ad_fsp->fsp_name->st);
+	if (ret != 0) {
+		DBG_ERR("fstat [%s] failed: %s\n",
+			fsp_str_dbg(ad->ad_fsp), strerror(errno));
+		return -1;
+	}
+
+	to_read = ad->ad_fsp->fsp_name->st.st_ex_size;
+	if (to_read > AD_XATTR_MAX_HDR_SIZE) {
+		to_read = AD_XATTR_MAX_HDR_SIZE;
+	}
+
+	len = SMB_VFS_NEXT_PREAD(handle,
+				 ad->ad_fsp,
+				 ad->ad_data,
+				 to_read,
+				 0);
+	if (len != to_read)  {
+		DBG_NOTICE("%s %s: bad size: %zd\n",
+			   smb_fname->base_name, strerror(errno), len);
+		return -1;
+	}
+
+	/* Now parse entries */
+	ok = ad_unpack(ad,
+		       ADEID_NUM_DOT_UND,
+		       ad->ad_fsp->fsp_name->st.st_ex_size);
+	if (!ok) {
+		DBG_WARNING("Invalid AppleDouble resource (%s) in file: %s - "
+			    "Consider deleting the corrupted file.\n",
+			    smb_fname->base_name,
+			    ad->ad_fsp->fsp_name->base_name);
+		errno = EINVAL;
+		return -1;
+	}
+
+	if ((ad_getentryoff(ad, ADEID_FINDERI) != ADEDOFF_FINDERI_DOT_UND)
+	    || (ad_getentrylen(ad, ADEID_FINDERI) < ADEDLEN_FINDERI)
+	    || (ad_getentryoff(ad, ADEID_RFORK) < ADEDOFF_RFORK_DOT_UND))
+	{
+		DBG_WARNING("Invalid AppleDouble resource (%s) in file: %s - "
+			    "Consider deleting the corrupted file.\n",
+			    smb_fname->base_name,
+			    ad->ad_fsp->fsp_name->base_name);
+		errno = EINVAL;
+		return -1;
+	}
+
+	return len;
+}
+
+/**
+ * Read and parse resource fork, either ._ AppleDouble file or xattr
+ **/
+static ssize_t ad_read_rsrc(vfs_handle_struct *handle,
+			    struct adouble *ad,
+			    const struct smb_filename *smb_fname)
+{
+	return ad_read_rsrc_adouble(handle, ad, smb_fname);
+}
+
+/**
+ * Read and unpack an AppleDouble metadata xattr or resource
+ **/
+static ssize_t ad_read(vfs_handle_struct *handle,
+		       struct adouble *ad,
+		       const struct smb_filename *smb_fname)
+{
+	switch (ad->ad_type) {
+	case ADOUBLE_META:
+		return ad_read_meta(handle, ad, smb_fname);
+	case ADOUBLE_RSRC:
+		return ad_read_rsrc(handle, ad, smb_fname);
+	default:
+		return -1;
+	}
+}
+
+static int adouble_destructor(struct adouble *ad)
+{
+	NTSTATUS status;
+
+	if (!ad->ad_opened) {
+		return 0;
+	}
+
+	SMB_ASSERT(ad->ad_fsp != NULL);
+
+	status = fd_close(ad->ad_fsp);
+	if (!NT_STATUS_IS_OK(status)) {
+		DBG_ERR("Closing [%s] failed: %s\n",
+			fsp_str_dbg(ad->ad_fsp), nt_errstr(status));
+	}
+	file_free(NULL, ad->ad_fsp);
+	ad->ad_fsp = NULL;
+	ad->ad_opened = false;
+
+	return 0;
+}
+
+/**
+ * Allocate a struct adouble without initialiing it
+ *
+ * The struct is either hang of the fsp extension context or if fsp is
+ * NULL from ctx.
+ *
+ * @param[in] ctx        talloc context
+ * @param[in] handle     vfs handle
+ * @param[in] type       type of AppleDouble, ADOUBLE_META or ADOUBLE_RSRC
+ *
+ * @return               adouble handle
+ **/
+static struct adouble *ad_alloc(TALLOC_CTX *ctx,
+				adouble_type_t type)
+{
+	int rc = 0;
+	size_t adsize = 0;
+	struct adouble *ad;
+
+	switch (type) {
+	case ADOUBLE_META:
+		adsize = AD_DATASZ_XATTR;
+		break;
+	case ADOUBLE_RSRC:
+		/*
+		 * AppleDouble ._ file case, optimize for fewer (but larger)
+		 * IOs. Two cases:
+		 *
+		 * - without xattrs size of the header is exactly
+		 *   AD_DATASZ_DOT_UND (82) bytes
+		 *
+		 * - with embedded xattrs it can be larger, up to
+		 *   AD_XATTR_MAX_HDR_SIZE
+		 *
+		 * Larger headers are not supported, but this is a reasonable
+		 * limit that is also employed by the macOS client.
+		 *
+		 * We used the largest possible size to be able to read the full
+		 * header with one IO.
+		 */
+		adsize = AD_XATTR_MAX_HDR_SIZE;
+		break;
+	default:
+		return NULL;
+	}
+
+	ad = talloc_zero(ctx, struct adouble);
+	if (ad == NULL) {
+		rc = -1;
+		goto exit;
+	}
+
+	if (adsize) {
+		ad->ad_data = talloc_zero_array(ad, char, adsize);
+		if (ad->ad_data == NULL) {
+			rc = -1;
+			goto exit;
+		}
+	}
+
+	ad->ad_type = type;
+	ad->ad_magic = AD_MAGIC;
+	ad->ad_version = AD_VERSION;
+
+	talloc_set_destructor(ad, adouble_destructor);
+
+exit:
+	if (rc != 0) {
+		TALLOC_FREE(ad);
+	}
+	return ad;
+}
+
+/**
+ * Allocate and initialize a new struct adouble
+ *
+ * @param[in] ctx        talloc context
+ * @param[in] type       type of AppleDouble, ADOUBLE_META or ADOUBLE_RSRC
+ *
+ * @return               adouble handle, initialized
+ **/
+struct adouble *ad_init(TALLOC_CTX *ctx, adouble_type_t type)
+{
+	int rc = 0;
+	const struct ad_entry_order  *eid;
+	struct adouble *ad = NULL;
+	time_t t = time(NULL);
+
+	switch (type) {
+	case ADOUBLE_META:
+		eid = entry_order_meta_xattr;
+		break;
+	case ADOUBLE_RSRC:
+		eid = entry_order_dot_und;
+		break;
+	default:
+		return NULL;
+	}
+
+	ad = ad_alloc(ctx, type);
+	if (ad == NULL) {
+		return NULL;
+	}
+
+	while (eid->id) {
+		ad->ad_eid[eid->id].ade_off = eid->offset;
+		ad->ad_eid[eid->id].ade_len = eid->len;
+		eid++;
+	}
+
+	/* put something sane in the date fields */
+	ad_setdate(ad, AD_DATE_CREATE | AD_DATE_UNIX, t);
+	ad_setdate(ad, AD_DATE_MODIFY | AD_DATE_UNIX, t);
+	ad_setdate(ad, AD_DATE_ACCESS | AD_DATE_UNIX, t);
+	ad_setdate(ad, AD_DATE_BACKUP, htonl(AD_DATE_START));
+
+	if (rc != 0) {
+		TALLOC_FREE(ad);
+	}
+	return ad;
+}
+
+static struct adouble *ad_get_internal(TALLOC_CTX *ctx,
+				       vfs_handle_struct *handle,
+				       files_struct *fsp,
+				       const struct smb_filename *smb_fname,
+				       adouble_type_t type)
+{
+	int rc = 0;
+	ssize_t len;
+	struct adouble *ad = NULL;
+	int mode;
+
+	if (fsp != NULL) {
+		if (fsp_is_alternate_stream(fsp)) {
+			smb_fname = fsp->base_fsp->fsp_name;
+		} else {
+			smb_fname = fsp->fsp_name;
+		}
+	}
+
+	DEBUG(10, ("ad_get(%s) called for %s\n",
+		   type == ADOUBLE_META ? "meta" : "rsrc",
+		   smb_fname != NULL ? smb_fname->base_name : "???"));
+
+	ad = ad_alloc(ctx, type);
+	if (ad == NULL) {
+		rc = -1;
+		goto exit;
+	}
+
+	/* Try rw first so we can use the fd in ad_convert() */
+	mode = O_RDWR;
+
+	rc = ad_open(handle, ad, fsp, smb_fname, mode, 0);
+	if (rc == -1 && ((errno == EROFS) || (errno == EACCES))) {
+		mode = O_RDONLY;
+		rc = ad_open(handle, ad, fsp, smb_fname, mode, 0);
+	}
+	if (rc == -1) {
+		DBG_DEBUG("ad_open [%s] error [%s]\n",
+			  smb_fname->base_name, strerror(errno));
+		goto exit;
+
+	}
+
+	len = ad_read(handle, ad, smb_fname);
+	if (len == -1) {
+		DEBUG(10, ("error reading AppleDouble for %s\n",
+			smb_fname->base_name));
+		rc = -1;
+		goto exit;
+	}
+
+exit:
+	DEBUG(10, ("ad_get(%s) for %s returning %d\n",
+		  type == ADOUBLE_META ? "meta" : "rsrc",
+		  smb_fname->base_name, rc));
+
+	if (rc != 0) {
+		TALLOC_FREE(ad);
+	}
+	return ad;
+}
+
+/**
+ * Return AppleDouble data for a file
+ *
+ * @param[in] ctx      talloc context
+ * @param[in] handle   vfs handle
+ * @param[in] smb_fname pathname to file or directory
+ * @param[in] type     type of AppleDouble, ADOUBLE_META or ADOUBLE_RSRC
+ *
+ * @return             talloced struct adouble or NULL on error
+ **/
+struct adouble *ad_get(TALLOC_CTX *ctx,
+			      vfs_handle_struct *handle,
+			      const struct smb_filename *smb_fname,
+			      adouble_type_t type)
+{
+	return ad_get_internal(ctx, handle, NULL, smb_fname, type);
+}
+
+/**
+ * Return AppleDouble data for a file
+ *
+ * @param[in] ctx      talloc context
+ * @param[in] handle   vfs handle
+ * @param[in] fsp      fsp to use for IO
+ * @param[in] type     type of AppleDouble, ADOUBLE_META or ADOUBLE_RSRC
+ *
+ * @return             talloced struct adouble or NULL on error
+ **/
+struct adouble *ad_fget(TALLOC_CTX *ctx, vfs_handle_struct *handle,
+			files_struct *fsp, adouble_type_t type)
+{
+	return ad_get_internal(ctx, handle, fsp, NULL, type);
+}
+
+/**
+ * Set AppleDouble metadata on a file or directory
+ *
+ * @param[in] ad      adouble handle
+ * @param[in] fsp     file handle
+ *
+ * @return            status code, 0 means success
+ **/
+int ad_fset(struct vfs_handle_struct *handle,
+	    struct adouble *ad,
+	    files_struct *fsp)
+{
+	int rc = -1;
+	ssize_t len;
+	bool ok;
+
+	DBG_DEBUG("Path [%s]\n", fsp_str_dbg(fsp));
+
+	ok = ad_pack(handle, ad, fsp);
+	if (!ok) {
+		return -1;
+	}
+
+	switch (ad->ad_type) {
+	case ADOUBLE_META:
+		rc = SMB_VFS_NEXT_FSETXATTR(handle,
+				   fsp->base_fsp ? fsp->base_fsp : fsp,
+				   AFPINFO_EA_NETATALK,
+				   ad->ad_data,
+				   AD_DATASZ_XATTR, 0);
+		break;
+	case ADOUBLE_RSRC:
+		len = SMB_VFS_NEXT_PWRITE(handle,
+					  fsp,
+					  ad->ad_data,
+					  ad_getentryoff(ad, ADEID_RFORK),
+					  0);
+		if (len != ad_getentryoff(ad, ADEID_RFORK)) {
+			DBG_ERR("short write on %s: %zd\n", fsp_str_dbg(fsp), len);
+			return -1;
+		}
+		rc = 0;
+		break;
+
+	default:
+		return -1;
+	}
+
+	DBG_DEBUG("Path [%s] rc [%d]\n", fsp_str_dbg(fsp), rc);
+
+	return rc;
+}
+
+bool is_adouble_file(const char *path)
+{
+	const char *p = NULL;
+	int match;
+
+	p = strrchr(path, '/');
+	if (p == NULL) {
+		p = path;
+	} else {
+		p++;
+	}
+
+	match = strncmp(p,
+			ADOUBLE_NAME_PREFIX,
+			strlen(ADOUBLE_NAME_PREFIX));
+	if (match != 0) {
+		return false;
+	}
+	return true;
+}
+
+/**
+ * Prepend "._" to a basename
+ * Return a new struct smb_filename with stream_name == NULL.
+ **/
+int adouble_path(TALLOC_CTX *ctx,
+		 const struct smb_filename *smb_fname_in,
+		 struct smb_filename **pp_smb_fname_out)
+{
+	char *parent;
+	const char *base;
+	struct smb_filename *smb_fname = NULL;
+
+	smb_fname = cp_smb_filename_nostream(ctx, smb_fname_in);
+	if (smb_fname == NULL) {
+		return -1;
+	}
+
+	/* We're replacing base_name. */
+	TALLOC_FREE(smb_fname->base_name);
+
+	SET_STAT_INVALID(smb_fname->st);
+
+	if (!parent_dirname(smb_fname, smb_fname_in->base_name,
+				&parent, &base)) {
+		TALLOC_FREE(smb_fname);
+		return -1;
+	}
+
+	if (ISDOT(parent)) {
+		smb_fname->base_name = talloc_asprintf(smb_fname,
+					"._%s", base);
+	} else {
+		smb_fname->base_name = talloc_asprintf(smb_fname,
+					"%s/._%s", parent, base);
+	}
+	if (smb_fname->base_name == NULL) {
+		TALLOC_FREE(smb_fname);
+		return -1;
+	}
+
+	*pp_smb_fname_out = smb_fname;
+
+	return 0;
+}
+
+/**
+ * Allocate and initialize an AfpInfo struct
+ **/
+AfpInfo *afpinfo_new(TALLOC_CTX *ctx)
+{
+	AfpInfo *ai = talloc_zero(ctx, AfpInfo);
+	if (ai == NULL) {
+		return NULL;
+	}
+	ai->afpi_Signature = AFP_Signature;
+	ai->afpi_Version = AFP_Version;
+	ai->afpi_BackupTime = AD_DATE_START;
+	return ai;
+}
+
+/**
+ * Pack an AfpInfo struct into a buffer
+ *
+ * Buffer size must be at least AFP_INFO_SIZE
+ * Returns size of packed buffer
+ **/
+ssize_t afpinfo_pack(const AfpInfo *ai, char *buf)
+{
+	memset(buf, 0, AFP_INFO_SIZE);
+
+	RSIVAL(buf, 0, ai->afpi_Signature);
+	RSIVAL(buf, 4, ai->afpi_Version);
+	RSIVAL(buf, 12, ai->afpi_BackupTime);
+	memcpy(buf + 16, ai->afpi_FinderInfo, sizeof(ai->afpi_FinderInfo));
+
+	return AFP_INFO_SIZE;
+}
+
+/**
+ * Unpack a buffer into a AfpInfo structure
+ *
+ * Buffer size must be at least AFP_INFO_SIZE
+ * Returns allocated AfpInfo struct
+ **/
+AfpInfo *afpinfo_unpack(TALLOC_CTX *ctx, const void *data, bool validate)
+{
+	AfpInfo *ai = talloc_zero(ctx, AfpInfo);
+	if (ai == NULL) {
+		return NULL;
+	}
+
+	ai->afpi_Signature = RIVAL(data, 0);
+	ai->afpi_Version = RIVAL(data, 4);
+	ai->afpi_BackupTime = RIVAL(data, 12);
+	memcpy(ai->afpi_FinderInfo, (const char *)data + 16,
+	       sizeof(ai->afpi_FinderInfo));
+
+	if (validate) {
+		if (ai->afpi_Signature != AFP_Signature
+		    || ai->afpi_Version != AFP_Version)
+		{
+			DEBUG(1, ("Bad AfpInfo signature or version\n"));
+			TALLOC_FREE(ai);
+		}
+	} else {
+		ai->afpi_Signature = AFP_Signature;
+		ai->afpi_Version = AFP_Version;
+	}
+
+	return ai;
+}