return 0;
}
-/* ----------------------------------- */
-static int new_ad_header(struct adouble *ad, const char *path, struct stat *stp, int adflags)
+
+/**
+ * Initialize offset pointers
+ */
+int ad_init_offsets(struct adouble *ad)
{
const struct entry *eid;
- uint16_t ashort;
- struct stat st;
-
- LOG(log_debug, logtype_ad, "new_ad_header(\"%s\")", path);
- if (ad->ad_magic == AD_MAGIC) {
- LOG(log_debug, logtype_ad, "new_ad_header(\"%s\"): already initialized", path);
+ if (ad->ad_magic == AD_MAGIC)
return 0;
- }
ad->ad_magic = AD_MAGIC;
ad->ad_version = ad->ad_vers & 0x0f0000;
eid++;
}
- /* put something sane in the directory finderinfo */
- if (stp == NULL) {
- stp = &st;
- if (lstat(path, &st) != 0)
- return -1;
- }
+ /*
+ * Ensure the resource fork offset is always set
+ */
+#ifndef HAVE_EAFD
+ if (ad->ad_vers == AD_VERSION_EA)
+ ad_setentryoff(ad, ADEID_RFORK, ADEDOFF_RFORK_OSX);
+#endif
- if ((adflags & ADFLAGS_DIR)) {
- /* set default view */
- ashort = htons(FINDERINFO_CLOSEDVIEW);
- memcpy(ad_entry(ad, ADEID_FINDERI) + FINDERINFO_FRVIEWOFF, &ashort, sizeof(ashort));
- } else {
- /* set default creator/type fields */
- memcpy(ad_entry(ad, ADEID_FINDERI) + FINDERINFO_FRTYPEOFF,"\0\0\0\0", 4);
- memcpy(ad_entry(ad, ADEID_FINDERI) + FINDERINFO_FRCREATOFF,"\0\0\0\0", 4);
- }
+ return 0;
+}
+
+/* ----------------------------------- */
+static int new_ad_header(struct adouble *ad, const char *path, struct stat *stp, int adflags)
+{
+ const struct entry *eid;
+ uint16_t ashort;
+ struct stat st;
+
+ LOG(log_debug, logtype_ad, "new_ad_header(\"%s\")", path);
+
+ if (ad_init_offsets(ad) != 0)
+ return -1;
+
+ /* set default creator/type fields */
+ memcpy(ad_entry(ad, ADEID_FINDERI) + FINDERINFO_FRTYPEOFF,"\0\0\0\0", 4);
+ memcpy(ad_entry(ad, ADEID_FINDERI) + FINDERINFO_FRCREATOFF,"\0\0\0\0", 4);
/* make things invisible */
if ((ad->ad_options & ADVOL_INVDOTS)
}
/* put something sane in the date fields */
+ if (stp == NULL) {
+ stp = &st;
+ if (lstat(path, &st) != 0)
+ return -1;
+ }
ad_setdate(ad, AD_DATE_CREATE | AD_DATE_UNIX, stp->st_mtime);
ad_setdate(ad, AD_DATE_MODIFY | AD_DATE_UNIX, stp->st_mtime);
ad_setdate(ad, AD_DATE_ACCESS | AD_DATE_UNIX, stp->st_mtime);
return 0;
}
-/* -------------------------------------
- read in the entries
-*/
-static void parse_entries(struct adouble *ad, char *buf, uint16_t nentries)
+/**
+ * Read an AppleDouble buffer, returns 0 on success, -1 if an entry was malformatted
+ **/
+static int parse_entries(struct adouble *ad, char *buf, uint16_t nentries)
{
uint32_t eid, len, off;
- int warning = 0;
+ int ret = 0;
/* now, read in the entry bits */
for (; nentries > 0; nentries-- ) {
len = ntohl( len );
buf += sizeof( len );
- if (eid
- && eid < ADEID_MAX
- && off < sizeof(ad->ad_data)
- && (off + len <= sizeof(ad->ad_data) || eid == ADEID_RFORK)) {
- ad->ad_eid[ eid ].ade_off = off;
- ad->ad_eid[ eid ].ade_len = len;
- } else if (!warning) {
- warning = 1;
- LOG(log_warning, logtype_ad, "parse_entries: bogus eid: %d", eid);
+ ad->ad_eid[eid].ade_off = off;
+ ad->ad_eid[eid].ade_len = len;
+
+ if (!eid
+ || eid > ADEID_MAX
+ || off >= sizeof(ad->ad_data)
+ || ((eid != ADEID_RFORK) && (off + len > sizeof(ad->ad_data))))
+ {
+ ret = -1;
+ LOG(log_warning, logtype_ad, "parse_entries: bogus eid: %u, off: %u, len: %u",
+ (uint)eid, (uint)off, (uint)len);
}
}
+
+ return ret;
}
/* this reads enough of the header so that we can figure out all of
* NOTE: we're assuming that the resource fork is kept at the end of
* the file. also, mmapping won't work for the hfs fs until it
* understands how to mmap header files. */
-static int ad_header_read(const char *path _U_, struct adouble *ad, const struct stat *hst)
+static int ad_header_read(const char *path, struct adouble *ad, const struct stat *hst)
{
char *buf = ad->ad_data;
uint16_t nentries;
/* figure out all of the entry offsets and lengths. if we aren't
* able to read a resource fork entry, bail. */
nentries = len / AD_ENTRY_LEN;
- parse_entries(ad, buf, nentries);
+ if (parse_entries(ad, buf, nentries) != 0) {
+ LOG(log_warning, logtype_ad, "ad_header_read(%s): malformed AppleDouble",
+ path ? fullpathname(path) : "");
+ errno = EIO;
+ return -1;
+ }
if (!ad_getentryoff(ad, ADEID_RFORK)
|| (ad_getentryoff(ad, ADEID_RFORK) > sizeof(ad->ad_data))
) {
EC_FAIL;
}
- if (strncmp(buf + ADEDOFF_FILLER, "Mac OS X", strlen("Mac OS X")) == 0)
+ if (strncmp(buf + ADEDOFF_FILLER,
+ AD_FILLER_NETATALK,
+ strlen(AD_FILLER_NETATALK)) != 0)
/*
* It's a split fork created by OS X, it's not our "own" ._ file
* and thus not a valid header in this context.
return 0;
}
+/**
+ * Convert from Apple's ._ file to Netatalk
+ *
+ * Apple's AppleDouble may contain a FinderInfo entry longer then 32 bytes
+ * containing packed xattrs. Netatalk can't deal with that, so we
+ * simply discard the packed xattrs.
+ *
+ * As we call ad_open() which might result in a recursion, just to be sure
+ * use static variable in_conversion to check for that.
+ *
+ * Returns -1 in case an error occured, 0 if no conversion was done, 1 otherwise
+ **/
+static int ad_convert_osx(const char *path, struct adouble *ad)
+{
+ EC_INIT;
+ static bool in_conversion = false;
+ char *map;
+ int finderlen = ad_getentrylen(ad, ADEID_FINDERI);
+ ssize_t origlen;
+
+ if (in_conversion || finderlen == ADEDLEN_FINDERI)
+ return 0;
+ in_conversion = true;
+
+ LOG(log_debug, logtype_ad, "Converting OS X AppleDouble %s, FinderInfo length: %d",
+ fullpathname(path), finderlen);
+
+ origlen = ad_getentryoff(ad, ADEID_RFORK) + ad_getentrylen(ad, ADEID_RFORK);
+
+ map = mmap(NULL, origlen, PROT_READ | PROT_WRITE, MAP_SHARED, ad_reso_fileno(ad), 0);
+ if (map == MAP_FAILED) {
+ LOG(log_error, logtype_ad, "mmap AppleDouble: %s\n", strerror(errno));
+ EC_FAIL;
+ }
+
+ memmove(map + ad_getentryoff(ad, ADEID_FINDERI) + ADEDLEN_FINDERI,
+ map + ad_getentryoff(ad, ADEID_RFORK),
+ ad_getentrylen(ad, ADEID_RFORK));
+
+ ad_setentrylen(ad, ADEID_FINDERI, ADEDLEN_FINDERI);
+ ad->ad_rlen = ad_getentrylen(ad, ADEID_RFORK);
+ ad_setentryoff(ad, ADEID_RFORK, ad_getentryoff(ad, ADEID_FINDERI) + ADEDLEN_FINDERI);
+
+ EC_ZERO_LOG( ftruncate(ad_reso_fileno(ad),
+ ad_getentryoff(ad, ADEID_RFORK)
+ + ad_getentrylen(ad, ADEID_RFORK)) );
+
+ (void)ad_rebuild_adouble_header_osx(ad, map);
+ munmap(map, origlen);
+
+ /* Create a metadata EA if one doesn't exit */
+ if (strlen(path) < 3)
+ EC_EXIT_STATUS(0);
+ struct adouble adea;
+ ad_init_old(&adea, AD_VERSION_EA, ad->ad_options);
+
+ if (ad_open(&adea, path + 2, ADFLAGS_HF | ADFLAGS_RDWR | ADFLAGS_CREATE, 0666) < 0) {
+ LOG(log_error, logtype_ad, "create metadata: %s\n", strerror(errno));
+ EC_FAIL;
+ }
+ if (adea.ad_mdp->adf_flags & O_CREAT) {
+ memcpy(ad_entry(&adea, ADEID_FINDERI),
+ ad_entry(ad, ADEID_FINDERI),
+ ADEDLEN_FINDERI);
+ ad_flush(&adea);
+ }
+ ad_close(&adea, ADFLAGS_HF);
+
+EC_CLEANUP:
+ in_conversion = false;
+ if (ret != 0)
+ return -1;
+ return 1;
+}
+
/* Read an ._ file, only uses the resofork, finderinfo is taken from EA */
-static int ad_header_read_osx(const char *path _U_, struct adouble *ad, const struct stat *hst)
+static int ad_header_read_osx(const char *path, struct adouble *ad, const struct stat *hst)
{
EC_INIT;
struct adouble adosx;
- char *buf = &adosx.ad_data[0];
+ char *buf;
uint16_t nentries;
int len;
ssize_t header_len;
struct stat st;
+ int retry_read = 0;
+reread:
+ LOG(log_debug, logtype_ad, "ad_header_read_osx: %s", path ? fullpathname(path) : "");
+ ad_init_old(&adosx, AD_VERSION_EA, ad->ad_options);
+ buf = &adosx.ad_data[0];
memset(buf, 0, sizeof(adosx.ad_data));
+ adosx.ad_rfp->adf_fd = ad_reso_fileno(ad);
/* read the header */
EC_NEG1( header_len = adf_pread(ad->ad_rfp, buf, AD_DATASZ_OSX, 0) );
}
nentries = len / AD_ENTRY_LEN;
- parse_entries(&adosx, buf, nentries);
+ if (parse_entries(&adosx, buf, nentries) != 0) {
+ LOG(log_warning, logtype_ad, "ad_header_read(%s): malformed AppleDouble",
+ path ? fullpathname(path) : "");
+ }
+
+ if (ad_getentrylen(&adosx, ADEID_FINDERI) != ADEDLEN_FINDERI) {
+ LOG(log_warning, logtype_ad, "Convert OS X to Netatalk AppleDouble: %s",
+ path ? fullpathname(path) : "");
+
+ if (retry_read > 0) {
+ LOG(log_error, logtype_ad, "ad_header_read_osx: %s, giving up", path ? fullpathname(path) : "");
+ errno = EIO;
+ EC_FAIL;
+ }
+ retry_read++;
+ if (ad_convert_osx(path, &adosx) == 1) {
+ goto reread;
+ }
+ errno = EIO;
+ EC_FAIL;
+ }
if (ad_getentryoff(&adosx, ADEID_RFORK) == 0
|| ad_getentryoff(&adosx, ADEID_RFORK) > sizeof(ad->ad_data)
static int ad_header_read_ea(const char *path, struct adouble *ad, const struct stat *hst _U_)
{
+ EC_INIT;
uint16_t nentries;
int len;
ssize_t header_len;
if (ad_meta_fileno(ad) != -1)
header_len = sys_fgetxattr(ad_meta_fileno(ad), AD_EA_META, ad->ad_data, AD_DATASZ_EA);
else
- header_len = sys_lgetxattr(path, AD_EA_META, ad->ad_data, AD_DATASZ_EA);
- if (header_len < 1) {
+ header_len = sys_getxattr(path, AD_EA_META, ad->ad_data, AD_DATASZ_EA);
+ if (header_len < 1) {
LOG(log_debug, logtype_ad, "ad_header_read_ea: %s", strerror(errno));
- return -1;
+ EC_FAIL;
}
- if (header_len < AD_HEADER_LEN) {
- LOG(log_error, logtype_ad, "ad_header_read_ea(\"%s\"): bogus AppleDouble header.", fullpathname(path));
- errno = EIO;
- return -1;
+ if (header_len < AD_DATASZ_EA) {
+ LOG(log_error, logtype_ad, "ad_header_read_ea(\"%s\"): short metadata EA", fullpathname(path));
+ errno = EINVAL;
+ EC_FAIL;
}
memcpy(&ad->ad_magic, buf, sizeof( ad->ad_magic ));
if ((ad->ad_magic != AD_MAGIC) || (ad->ad_version != AD_VERSION2)) {
LOG(log_error, logtype_ad, "ad_header_read_ea(\"%s\"): wrong magic or version", fullpathname(path));
- errno = EIO;
- return -1;
+ errno = EINVAL;
+ EC_FAIL;
}
memcpy(&nentries, buf + ADEDOFF_NENTRIES, sizeof( nentries ));
nentries = ntohs( nentries );
-
- /* Protect against bogus nentries */
- len = nentries * AD_ENTRY_LEN;
- if (len + AD_HEADER_LEN > sizeof(ad->ad_data))
- len = sizeof(ad->ad_data) - AD_HEADER_LEN;
- if (len > header_len - AD_HEADER_LEN) {
- LOG(log_error, logtype_ad, "ad_header_read_ea(\"%s\"): can't read entry info.", fullpathname(path));
- errno = EIO;
- return -1;
+ if (nentries != ADEID_NUM_EA) {
+ LOG(log_error, logtype_ad, "ad_header_read_ea(\"%s\"): invalid number of entries: %d", fullpathname(path), nentries);
+ errno = EINVAL;
+ EC_FAIL;
}
- nentries = len / AD_ENTRY_LEN;
/* Now parse entries */
- parse_entries(ad, buf + AD_HEADER_LEN, nentries);
+ if (parse_entries(ad, buf + AD_HEADER_LEN, nentries)) {
+ LOG(log_warning, logtype_ad, "ad_header_read(%s): malformed AppleDouble",
+ path ? fullpathname(path) : "");
+ errno = EINVAL;
+ EC_FAIL;
+ }
- return 0;
+ if (nentries != ADEID_NUM_EA
+ || !ad_entry(ad, ADEID_FINDERI)
+ || !ad_entry(ad, ADEID_COMMENT)
+ || !ad_entry(ad, ADEID_FILEDATESI)
+ || !ad_entry(ad, ADEID_AFPFILEI)
+ || !ad_entry(ad, ADEID_PRIVDEV)
+ || !ad_entry(ad, ADEID_PRIVINO)
+ || !ad_entry(ad, ADEID_PRIVSYN)
+ || !ad_entry(ad, ADEID_PRIVID)) {
+ LOG(log_error, logtype_ad, "ad_header_read_ea(\"%s\"): invalid metadata EA", fullpathname(path));
+ errno = EINVAL;
+ EC_FAIL;
+ }
+
+ /*
+ * Ensure the resource fork offset is always set
+ */
+#ifndef HAVE_EAFD
+ if (ad->ad_vers == AD_VERSION_EA)
+ ad_setentryoff(ad, ADEID_RFORK, ADEDOFF_RFORK_OSX);
+#endif
+
+EC_CLEANUP:
+ if (ret != 0 && errno == EINVAL) {
+ become_root();
+ (void)sys_removexattr(path, AD_EA_META);
+ unbecome_root();
+ LOG(log_error, logtype_ad, "ad_header_read_ea(\"%s\"): deleted invalid metadata EA", fullpathname(path), nentries);
+ errno = ENOENT;
+ }
+ EC_EXIT;
}
/*!
errno = ENOENT;
EC_FAIL;
}
+ if ((adflags & ADFLAGS_CREATE) && (ad->ad_options & ADVOL_RO)) {
+ errno = EROFS;
+ EC_FAIL;
+ }
LOG(log_debug, logtype_ad, "ad_open_hf_ea(\"%s\"): creating metadata EA", path);
{
int ret = 0;
- memset(ad->ad_eid, 0, sizeof( ad->ad_eid ));
+ ad->ad_meta_refcount++;
switch (ad->ad_vers) {
case AD_VERSION2:
break;
}
- if (ret == 0)
- ad->ad_meta_refcount++;
- else
+ if (ret != 0) {
+ ad->ad_meta_refcount--;
ret = ad_error(ad, adflags);
+ }
return ret;
}
EC_FAIL;
}
ad->ad_rfp->adf_flags &= ~( O_TRUNC | O_CREAT );
+ ad->ad_reso_refcount++;
ad->ad_rfp->adf_refcount++;
EC_NEG1_LOG( ad->ad_rlen = ad_reso_size(path, adflags, ad));
goto EC_CLEANUP;
/* Read the adouble header */
LOG(log_debug, logtype_ad, "ad_open_rf(\"%s\"): reading adouble rfork: \"%s\"",
path, rfpath);
- EC_NEG1_LOG( ad_header_read_osx(NULL, ad, &st) );
+ EC_NEG1_LOG( ad_header_read_osx(rfpath, ad, &st) );
}
#endif
#ifdef HAVE_EAFD
return 0;
#else
- return ADEDOFF_RFORK_OSX;
+ return ad->ad_eid[eid].ade_off;
#endif
default:
return ad->ad_eid[eid].ade_off;
* - we remember open fds for files because me must avoid a single close releasing fcntl locks for other
* fds of the same file
*
+ * BUGS:
+ *
+ * * on Solaris (HAVE_EAFD) ADFLAGS_RF doesn't work without
+ * ADFLAGS_HF, because it checks whether ad_meta_fileno() is already
+ * openend. As a workaround pass ADFLAGS_SETSHRMD.
+ *
* @returns 0 on success, any other value indicates an error
*/
int ad_open(struct adouble *ad, const char *path, int adflags, ...)
int cwdfd = -1;
if (dirfd != -1) {
- if ((cwdfd = open(".", O_RDONLY) == -1) || (fchdir(dirfd) != 0)) {
+ if (((cwdfd = open(".", O_RDONLY)) == -1) || (fchdir(dirfd) != 0)) {
ret = -1;
goto exit;
}
mode_t mode = 0;
if (dirfd != -1) {
- if ((cwdfd = open(".", O_RDONLY) == -1) || (fchdir(dirfd) != 0))
+ if (((cwdfd = open(".", O_RDONLY)) == -1) || (fchdir(dirfd) != 0))
EC_FAIL;
}
projects / netatalk.git / blobdiff