#include <atalk/logger.h>
#include <atalk/adouble.h>
#include <atalk/util.h>
+#include <atalk/unix.h>
#include <atalk/ea.h>
#include <atalk/bstrlib.h>
#include <atalk/bstradd.h>
/* Forward declarations */
static int ad_mkrf(const char *path);
-static int ad_header_read(const char *path, struct adouble *ad, struct stat *hst);
+static int ad_header_read(const char *path, struct adouble *ad, const struct stat *hst);
static int ad_header_upgrade(struct adouble *ad, const char *name);
static int ad_mkrf_ea(const char *path);
-static int ad_header_read_ea(const char *path, struct adouble *ad, struct stat *hst);
+static int ad_header_read_ea(const char *path, struct adouble *ad, const struct stat *hst);
static int ad_header_upgrade_ea(struct adouble *ad, const char *name);
static int ad_reso_size(const char *path, int adflags, struct adouble *ad);
static int ad_mkrf_osx(const char *path);
* 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, struct stat *hst)
+static int ad_header_read(const char *path _U_, struct adouble *ad, const struct stat *hst)
{
char *buf = ad->ad_data;
uint16_t nentries;
struct stat st;
/* read the header */
- if ((header_len = adf_pread( ad->ad_mdp, buf, AD_DATASZ, 0)) < 0) {
+ if ((header_len = adf_pread( ad->ad_mdp, buf, AD_DATASZ2, 0)) < 0) {
return -1;
}
if (header_len < AD_HEADER_LEN) {
}
/* 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, struct stat *hst)
+static int ad_header_read_osx(const char *path _U_, struct adouble *ad, const struct stat *hst)
{
EC_INIT;
struct adouble adosx;
EC_EXIT;
}
-static int ad_header_read_ea(const char *path, struct adouble *ad, struct stat *hst _U_)
+static int ad_header_read_ea(const char *path, struct adouble *ad, const struct stat *hst _U_)
{
uint16_t nentries;
int len;
return oflags;
}
+static char emptyfilad[32] = {0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0};
+
+static char emptydirad[32] = {0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,1,0,
+ 0,0,0,0,0,0,0,0,
+ 0,0,0,0,0,0,0,0};
+
+static int ad_conv_v22ea_hf(const char *path, const struct stat *sp, const struct vol *vol)
+{
+ EC_INIT;
+ struct adouble adv2;
+ struct adouble adea;
+ const char *adpath;
+ int adflags;
+ uint32_t ctime, mtime, afpinfo = 0;
+ char *emptyad;
+
+ LOG(log_debug, logtype_default,"ad_conv_v22ea_hf(\"%s\"): BEGIN", fullpathname(path));
+
+ ad_init(&adea, vol);
+ ad_init_old(&adv2, AD_VERSION2, adea.ad_options);
+ adflags = S_ISDIR(sp->st_mode) ? ADFLAGS_DIR : 0;
+
+ /* Open and lock adouble:v2 file */
+ EC_ZERO( ad_open(&adv2, path, adflags | ADFLAGS_HF | ADFLAGS_RDWR) );
+ EC_NEG1_LOG( ad_tmplock(&adv2, ADEID_RFORK, ADLOCK_WR | ADLOCK_FILELOCK, 0, 0, 0) );
+ EC_NEG1_LOG( adv2.ad_ops->ad_header_read(path, &adv2, sp) );
+
+ /* Check if it's a non-empty header */
+ if (S_ISREG(sp->st_mode))
+ emptyad = &emptyfilad[0];
+ else
+ emptyad = &emptydirad[0];
+
+ if (ad_getentrylen(&adv2, ADEID_COMMENT) != 0)
+ goto copy;
+ if (ad_getentryoff(&adv2, ADEID_FINDERI)
+ && (ad_getentrylen(&adv2, ADEID_FINDERI) == ADEDLEN_FINDERI)
+ && (memcmp(ad_entry(&adv2, ADEID_FINDERI), emptyad, ADEDLEN_FINDERI) != 0))
+ goto copy;
+ if (ad_getentryoff(&adv2, ADEID_FILEDATESI)) {
+ EC_ZERO_LOG( ad_getdate(&adv2, AD_DATE_CREATE | AD_DATE_UNIX, &ctime) );
+ EC_ZERO_LOG( ad_getdate(&adv2, AD_DATE_MODIFY | AD_DATE_UNIX, &mtime) );
+ if ((ctime != mtime) || (mtime != sp->st_mtime))
+ goto copy;
+ }
+ if (ad_getentryoff(&adv2, ADEID_AFPFILEI)) {
+ if (memcmp(ad_entry(&adv2, ADEID_AFPFILEI), &afpinfo, ADEDLEN_AFPFILEI) != 0)
+ goto copy;
+ }
+
+ LOG(log_debug, logtype_default,"ad_conv_v22ea_hf(\"%s\"): default adouble", fullpathname(path), ret);
+ goto EC_CLEANUP;
+
+copy:
+ /* Create a adouble:ea meta EA */
+ LOG(log_debug, logtype_default,"ad_conv_v22ea_hf(\"%s\"): copying adouble", fullpathname(path), ret);
+ EC_ZERO_LOG( ad_open(&adea, path, adflags | ADFLAGS_HF | ADFLAGS_RDWR | ADFLAGS_CREATE) );
+ EC_ZERO_LOG( ad_copy_header(&adea, &adv2) );
+ ad_flush(&adea);
+
+EC_CLEANUP:
+ EC_ZERO_LOG( ad_close(&adv2, ADFLAGS_HF | ADFLAGS_SETSHRMD) );
+ EC_ZERO_LOG( ad_close(&adea, ADFLAGS_HF | ADFLAGS_SETSHRMD) );
+ LOG(log_debug, logtype_default,"ad_conv_v22ea_hf(\"%s\"): END: %d", fullpathname(path), ret);
+ EC_EXIT;
+}
+
+static int ad_conv_v22ea_rf(const char *path, const struct stat *sp, const struct vol *vol)
+{
+ EC_INIT;
+ struct adouble adv2;
+ struct adouble adea;
+
+ LOG(log_debug, logtype_default,"ad_conv_v22ea_rf(\"%s\"): BEGIN", fullpathname(path));
+
+ if (S_ISDIR(sp->st_mode))
+ return 0;
+
+ ad_init(&adea, vol);
+ ad_init_old(&adv2, AD_VERSION2, adea.ad_options);
+
+ /* Open and lock adouble:v2 file */
+ EC_ZERO( ad_open(&adv2, path, ADFLAGS_HF | ADFLAGS_RF | ADFLAGS_RDWR) );
+ if (adv2.ad_rlen > 0) {
+ EC_NEG1_LOG( ad_tmplock(&adv2, ADEID_RFORK, ADLOCK_WR | ADLOCK_FILELOCK, 0, 0, 0) );
+
+ /* Create a adouble:ea resource fork */
+ EC_ZERO_LOG( ad_open(&adea, path, ADFLAGS_HF | ADFLAGS_RF | ADFLAGS_RDWR | ADFLAGS_CREATE, 0666) );
+
+ EC_ZERO_LOG( copy_fork(ADEID_RFORK, &adea, &adv2) );
+ adea.ad_rlen = adv2.ad_rlen;
+ ad_flush(&adea);
+ }
+
+EC_CLEANUP:
+ EC_ZERO_LOG( ad_close(&adv2, ADFLAGS_HF | ADFLAGS_RF) );
+ EC_ZERO_LOG( ad_close(&adea, ADFLAGS_HF | ADFLAGS_RF) );
+ LOG(log_debug, logtype_default,"ad_conv_v22ea_rf(\"%s\"): END: %d", fullpathname(path), ret);
+ EC_EXIT;
+}
+
static int ad_open_df(const char *path, int adflags, mode_t mode, struct adouble *ad)
{
EC_INIT;
EC_EXIT;
}
-/*!
- * Open ressource fork
- *
- * Only for adouble:ea, a nullop otherwise because adouble:v2 has the ressource fork as part
- * of the adouble file which is openend by ADFLAGS_HF.
- */
-static int ad_open_rf(const char *path, int adflags, int mode, struct adouble *ad)
+static int ad_open_rf_v2(const char *path, int adflags, int mode, struct adouble *ad)
+{
+ /*
+ * ad_open_hf_v2() does the work, but if it failed and adflags are ADFLAGS_NOHF | ADFLAGS_RF
+ * ad_open_hf_v2() didn't give an error, but we're supposed to return a reso fork fd
+ */
+ if (!AD_RSRC_OPEN(ad) && !(adflags & ADFLAGS_NORF))
+ return -1;
+ return 0;
+}
+
+static int ad_open_rf_ea(const char *path, int adflags, int mode, struct adouble *ad)
{
EC_INIT;
int oflags;
struct stat st;
#endif
- if (ad->ad_vers != AD_VERSION_EA)
- return 0;
-
LOG(log_debug, logtype_default, "ad_open_rf(\"%s\"): BEGIN", fullpathname(path));
oflags = O_NOFOLLOW | (ad2openflags(ad, ADFLAGS_RF, adflags) & ~O_CREAT);
EC_EXIT;
}
+/*!
+ * Open ressource fork
+ */
+static int ad_open_rf(const char *path, int adflags, int mode, struct adouble *ad)
+{
+ int ret = 0;
+
+ switch (ad->ad_vers) {
+ case AD_VERSION2:
+ ret = ad_open_rf_v2(path, adflags, mode, ad);
+ break;
+ case AD_VERSION_EA:
+ ret = ad_open_rf_ea(path, adflags, mode, ad);
+ break;
+ default:
+ ret = -1;
+ break;
+ }
+
+ return ret;
+}
+
/***********************************************************************************
* API functions
********************************************************************************* */
/* Checking for open forks requires sharemode lock support (ie RDWR instead of RDONLY) */
adflags |= ADFLAGS_SETSHRMD;
+ if (adflags & ADFLAGS_SETSHRMD)
+ /* sharemode locks are stored in the data fork */
+ adflags |= ADFLAGS_DF;
+
if (ad->ad_vers == AD_VERSION2) {
- if (adflags & ADFLAGS_SETSHRMD)
- /* sharemode locks are stored in the data fork, adouble:v2 needs this extra handling here */
- adflags |= ADFLAGS_DF;
if (adflags & ADFLAGS_RF)
adflags |= ADFLAGS_HF;
if (adflags & ADFLAGS_NORF)
return ret;
}
+
+int ad_convert(const char *path, const struct stat *sp, const struct vol *vol)
+{
+ EC_INIT;
+ const char *adpath;
+ int adflags = S_ISDIR(sp->st_mode) ? ADFLAGS_DIR : 0;
+
+ LOG(log_debug, logtype_default,"ad_convert(\"%s\"): BEGIN", fullpathname(path));
+
+ if (!(vol->v_adouble == AD_VERSION_EA) || (vol->v_flags & AFPVOL_NOV2TOEACONV))
+ goto EC_CLEANUP;
+
+ EC_ZERO( ad_conv_v22ea_hf(path, sp, vol) );
+ EC_ZERO( ad_conv_v22ea_rf(path, sp, vol) );
+
+ EC_NULL( adpath = ad_path(path, adflags) );
+ LOG(log_debug, logtype_default,"ad_conv_v22ea_hf(\"%s\"): deleting adouble:v2 file: \"%s\"",
+ path, fullpathname(adpath));
+
+ become_root();
+ EC_ZERO_LOG( unlink(adpath) );
+ unbecome_root();
+
+EC_CLEANUP:
+ LOG(log_debug, logtype_default,"ad_convert(\"%s\"): END: %d", fullpathname(path), ret);
+ EC_EXIT;
+}
+
+/* build a resource fork mode from the data fork mode:
+ * remove X mode and extend header to RW if R or W (W if R for locking),
+ */
+mode_t ad_hf_mode(mode_t mode)
+{
+ mode &= ~(S_IXUSR | S_IXGRP | S_IXOTH);
+ /* fnctl lock need write access */
+ if ((mode & S_IRUSR))
+ mode |= S_IWUSR;
+ if ((mode & S_IRGRP))
+ mode |= S_IWGRP;
+ if ((mode & S_IROTH))
+ mode |= S_IWOTH;
+
+ /* if write mode set add read mode */
+ if ((mode & S_IWUSR))
+ mode |= S_IRUSR;
+ if ((mode & S_IWGRP))
+ mode |= S_IRGRP;
+ if ((mode & S_IWOTH))
+ mode |= S_IROTH;
+
+ return mode;
+}
projects / netatalk.git / blobdiff