/*
- * $Id: ad_open.c,v 1.46 2009-09-11 13:26:05 franklahm Exp $
+ * $Id: ad_open.c,v 1.60.2.1 2010-01-02 10:22:33 franklahm Exp $
*
* Copyright (c) 1999 Adrian Sun (asun@u.washington.edu)
* Copyright (c) 1990,1991 Regents of The University of Michigan.
if (!path || ad->ad_flags != AD_VERSION2)
return 0;
+ LOG(log_maxdebug, logtype_default, "ad_update: checking whether '%s' needs an upgrade.", path);
+
if (!(ad->ad_md->adf_flags & O_RDWR)) {
/* we were unable to open the file read write the last time */
return 0;
}
#endif /* AD_VERSION == AD_VERSION2 */
-/* --------------------------- */
-#ifdef ATACC
-mode_t ad_hf_mode (mode_t mode)
-{
- /* we always need RW mode for file owner */
-#if 0
- mode |= S_IRUSR;
-#endif
- 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;
-}
-
-#endif
-
/* -------------------------------------
read in the entries
*/
&& (ad->ad_version != AD_VERSION2)
#endif /* AD_VERSION == AD_VERSION2 */
)) {
- errno = EIO;
LOG(log_debug, logtype_default, "ad_open: can't parse AppleDouble header.");
+ errno = EIO;
return -1;
}
buf += AD_HEADER_LEN;
if (len > header_len - AD_HEADER_LEN) {
- errno = EIO;
LOG(log_debug, logtype_default, "ad_header_read: can't read entry info.");
+ errno = EIO;
return -1;
}
if (!ad_getentryoff(ad, ADEID_RFORK)
|| (ad_getentryoff(ad, ADEID_RFORK) > sizeof(ad->ad_data))
) {
- errno = EIO;
LOG(log_debug, logtype_default, "ad_header_read: problem with rfork entry offset.");
+ errno = EIO;
return -1;
}
if (ad_getentryoff(ad, ADEID_RFORK) > header_len) {
- errno = EIO;
LOG(log_debug, logtype_default, "ad_header_read: can't read in entries.");
+ errno = EIO;
return -1;
}
* FIXME: should do something for pathname > MAXPATHLEN
*/
char *
-ad_path( path, adflags )
- const char *path;
- int adflags;
+ad_path( const char *path, int adflags)
{
static char pathbuf[ MAXPATHLEN + 1];
- char c, *slash, buf[MAXPATHLEN + 1];
- size_t l;
+ const char *slash;
+ size_t l ;
- l = strlcpy(buf, path, MAXPATHLEN +1);
if ( adflags & ADFLAGS_DIR ) {
- strcpy( pathbuf, buf);
- if ( *buf != '\0' && l < MAXPATHLEN) {
+ l = strlcpy( pathbuf, path, sizeof(pathbuf));
+
+ if ( l && l < MAXPATHLEN) {
pathbuf[l++] = '/';
- pathbuf[l] = 0;
}
- slash = ".Parent";
+ strlcpy(pathbuf +l, ".AppleDouble/.Parent", sizeof(pathbuf) -l);
} else {
- if (NULL != ( slash = strrchr( buf, '/' )) ) {
- c = *++slash;
- *slash = '\0';
- strcpy( pathbuf, buf);
- *slash = c;
+ if (NULL != ( slash = strrchr( path, '/' )) ) {
+ slash++;
+ l = slash - path;
+ /* XXX we must return NULL here and test in the caller */
+ if (l > MAXPATHLEN)
+ l = MAXPATHLEN;
+ memcpy( pathbuf, path, l);
} else {
- pathbuf[ 0 ] = '\0';
- slash = buf;
+ l = 0;
+ slash = path;
}
+ l += strlcpy( pathbuf +l, ".AppleDouble/", sizeof(pathbuf) -l);
+ strlcpy( pathbuf + l, slash, sizeof(pathbuf) -l);
}
- strlcat( pathbuf, ".AppleDouble/", MAXPATHLEN +1);
- strlcat( pathbuf, slash, MAXPATHLEN +1);
return( pathbuf );
}
*
*/
char *
-ad_path_sfm( path, adflags )
- const char *path;
- int adflags;
+ad_path_sfm( const char *path, int adflags)
{
static char pathbuf[ MAXPATHLEN + 1];
char c, *slash, buf[MAXPATHLEN + 1];
#define DEFMASK 07700 /* be conservative */
char
-*ad_dir(path)
- const char *path;
+*ad_dir(const char *path)
{
static char modebuf[ MAXPATHLEN + 1];
char *slash;
- size_t len;
-
- if ( (len = strlen( path )) >= MAXPATHLEN ) {
- errno = ENAMETOOLONG;
- return NULL; /* can't do it */
- }
-
/*
* For a path with directories in it, remove the final component
* (path or subdirectory name) to get the name we want to stat.
* For a path which is just a filename, use "." instead.
*/
- strcpy( modebuf, path );
- slash = strrchr( modebuf, '/' );
- /* is last char a '/' */
- if (slash && slash[1] == 0) {
- while (modebuf < slash && slash[-1] == '/') {
- --slash;
+ slash = strrchr( path, '/' );
+ if (slash) {
+ size_t len;
+
+ len = slash - path;
+ if (len >= MAXPATHLEN) {
+ errno = ENAMETOOLONG;
+ return NULL; /* can't do it */
}
- if (modebuf < slash) {
+ memcpy( modebuf, path, len );
+ modebuf[len] = '\0';
+ /* is last char a '/' ? */
+ if (slash[1] == 0) {
+ slash = modebuf+ len;
+ /* remove them */
+ while (modebuf < slash && slash[-1] == '/') {
+ --slash;
+ }
+ if (modebuf == slash) {
+ goto use_cur;
+ }
+ *slash = '\0';
+ while (modebuf < slash && *slash != '/') {
+ --slash;
+ }
+ if (modebuf == slash) {
+ goto use_cur;
+ }
*slash = '\0'; /* remove pathname component */
- slash = strrchr( modebuf, '/' );
}
+ return modebuf;
}
- if (slash) {
- *slash = '\0'; /* remove pathname component */
- } else {
- modebuf[0] = '.'; /* use current directory */
- modebuf[1] = '\0';
- }
+use_cur:
+ modebuf[0] = '.'; /* use current directory */
+ modebuf[1] = '\0';
return modebuf;
}
if (!p) {
return -1;
}
-
- return stat( p, stbuf );
+//FIXME!
+ return lstat( p, stbuf );
}
/* ----------------
return access right of path parent directory
*/
int
-ad_mode( path, mode )
- const char *path;
- int mode;
+ad_mode( const char *path, int mode)
{
struct stat stbuf;
ad_mode_st(path, &mode, &stbuf);
* Use mkdir() with mode bits taken from ad_mode().
*/
int
-ad_mkdir( path, mode )
- const char *path;
- int mode;
+ad_mkdir( const char *path, int mode)
{
int ret;
int st_invalid;
struct stat stbuf;
#ifdef DEBUG
- LOG(log_info, logtype_default, "ad_mkdir: Creating directory with mode %d", mode);
-#endif /* DEBUG */
+ LOG(log_debug9, logtype_default, "ad_mkdir: Creating directory with mode %d", mode);
+#endif
st_invalid = ad_mode_st(path, &mode, &stbuf);
ret = mkdir( path, mode );
void ad_init(struct adouble *ad, int flags, int options)
{
- memset( ad, 0, sizeof( struct adouble ) );
+ ad->ad_inited = 0;
ad->ad_flags = flags;
if (flags == AD_VERSION2_OSX) {
ad->ad_ops = &ad_osx;
+ ad->ad_md = &ad->ad_resource_fork;
}
else if (flags == AD_VERSION1_SFM) {
ad->ad_ops = &ad_sfm;
+ ad->ad_md = &ad->ad_metadata_fork;
}
else {
ad->ad_ops = &ad_adouble;
+ ad->ad_md = &ad->ad_resource_fork;
}
ad->ad_options = options;
+
+ ad_data_fileno(ad) = -1;
+ ad_reso_fileno(ad) = -1;
+ ad_meta_fileno(ad) = -1;
+ /* following can be read even if there's no
+ * meda data.
+ */
+ memset(ad->ad_eid, 0, sizeof( ad->ad_eid ));
+ ad->ad_rlen = 0;
}
/* -------------------
* It's not possible to open the header file O_RDONLY -- the read
* will fail and return an error. this refcounts things now.
*/
-int ad_open( path, adflags, oflags, mode, ad )
- const char *path;
- int adflags, oflags, mode;
- struct adouble *ad;
+int ad_open( const char *path, int adflags, int oflags, int mode, struct adouble *ad)
{
struct stat st_dir;
struct stat st_meta;
+ struct stat st_link;
struct stat *pst = NULL;
char *ad_p;
int hoflags, admode;
int open_df = 0;
if (ad->ad_inited != AD_INITED) {
- ad_data_fileno(ad) = -1;
- ad_reso_fileno(ad) = -1;
- adf_lock_init(&ad->ad_data_fork);
- adf_lock_init(&ad->ad_resource_fork);
- if (ad->ad_flags != AD_VERSION1_SFM) {
- ad->ad_md = &ad->ad_resource_fork;
- }
- else {
- adf_lock_init(&ad->ad_metadata_fork);
- ad->ad_md = &ad->ad_metadata_fork;
- ad_meta_fileno(ad) = -1;
- }
ad->ad_inited = AD_INITED;
ad->ad_refcount = 1;
ad->ad_open_forks = 0;
ad->ad_adflags = adflags;
+ ad->ad_resource_fork.adf_refcount = 0;
+ ad->ad_data_fork.adf_refcount = 0;
+ ad->ad_data_fork.adf_syml=0;
}
else {
ad->ad_open_forks = ((ad->ad_data_fork.adf_refcount > 0) ? ATTRBIT_DOPEN : 0);
admode = mode;
}
}
- ad->ad_data_fork.adf_fd =open( path, hoflags, admode );
+ lstat(path,&st_link);
+ if (S_ISLNK(st_link.st_mode) && (oflags == O_RDONLY)) {
+ int lsz;
+ ad->ad_data_fork.adf_syml=(char *)malloc(PATH_MAX+1);
+ lsz=readlink(path,ad->ad_data_fork.adf_syml,PATH_MAX);
+ if (lsz<=0) {
+ free(ad->ad_data_fork.adf_syml);
+ return -1;
+ }
+ ad->ad_data_fork.adf_syml[lsz]=0;
+ ad->ad_data_fork.adf_syml=(char *)realloc(ad->ad_data_fork.adf_syml,lsz+1);
+ ad->ad_data_fork.adf_fd=0;
+ }else{
+
+ ad->ad_data_fork.adf_fd =open( path, hoflags | O_NOFOLLOW, admode );
+
if (ad->ad_data_fork.adf_fd < 0 ) {
if ((errno == EACCES || errno == EROFS) && !(oflags & O_RDWR)) {
hoflags = oflags;
- ad->ad_data_fork.adf_fd = open( path, hoflags, admode );
+ ad->ad_data_fork.adf_fd = open( path, hoflags | O_NOFOLLOW, admode );
+ }
}
}
if ( ad->ad_data_fork.adf_fd < 0)
/* just created, set owner if admin (root) */
ad_chown(path, &st_dir);
}
+ adf_lock_init(&ad->ad_data_fork);
}
else {
/* the file is already open... but */
goto sfm;
}
+ memset(ad->ad_eid, 0, sizeof( ad->ad_eid ));
+ ad->ad_rlen = 0;
ad_p = ad->ad_ops->ad_path( path, adflags );
- hoflags = oflags & ~O_CREAT;
+ hoflags = oflags & ~(O_CREAT | O_EXCL);
if (!(adflags & ADFLAGS_RDONLY)) {
hoflags = (hoflags & ~(O_RDONLY | O_WRONLY)) | O_RDWR;
}
- ad->ad_md->adf_fd = open( ad_p, hoflags, 0 );
+ ad->ad_md->adf_fd = open( ad_p, hoflags | O_NOFOLLOW, 0 );
if (ad->ad_md->adf_fd < 0 ) {
if ((errno == EACCES || errno == EROFS) && !(oflags & O_RDWR)) {
- hoflags = oflags & ~O_CREAT;
- ad->ad_md->adf_fd = open( ad_p, hoflags, 0 );
+ hoflags = oflags & ~(O_CREAT | O_EXCL);
+ ad->ad_md->adf_fd = open( ad_p, hoflags | O_NOFOLLOW, 0 );
}
}
else {
return ad_error(ad, adflags);
}
- } else if (fstat(ad->ad_md->adf_fd, &st_meta) == 0 && st_meta.st_size == 0) {
- /* for 0 length files, treat them as new. */
- ad->ad_md->adf_flags = hoflags| O_TRUNC;
} else {
ad->ad_md->adf_flags = hoflags;
+ if (fstat(ad->ad_md->adf_fd, &st_meta) == 0 && st_meta.st_size == 0) {
+ /* for 0 length files, treat them as new. */
+ ad->ad_md->adf_flags |= O_TRUNC;
+ }
+ else {
+ /* we have valid data in st_meta stat structure, reused it
+ in ad_header_read
+ */
+ pst = &st_meta;
+ }
}
AD_SET(ad->ad_md->adf_off);
- memset(ad->ad_eid, 0, sizeof( ad->ad_eid ));
- ad->ad_md->adf_refcount++;
+ ad->ad_md->adf_refcount = 1;
+ adf_lock_init(ad->ad_md);
if ((ad->ad_md->adf_flags & ( O_TRUNC | O_CREAT ))) {
/*
* This is a new adouble header file. Initialize the structure,
ad_p = ad->ad_ops->ad_path( path, ADFLAGS_RF );
- hoflags = (oflags & ~(O_RDONLY | O_WRONLY)) | O_RDWR;
- ad->ad_resource_fork.adf_fd = open( ad_p, hoflags, admode );
admode = mode;
st_invalid = ad_mode_st(ad_p, &admode, &st_dir);
admode = mode;
}
+ hoflags = (oflags & ~(O_RDONLY | O_WRONLY)) | O_RDWR;
+ ad->ad_resource_fork.adf_fd = open( ad_p, hoflags, admode );
+
if (ad->ad_resource_fork.adf_fd < 0 ) {
if ((errno == EACCES || errno == EROFS) && !(oflags & O_RDWR)) {
hoflags = oflags;
errno = err;
return -1;
}
-
+ adf_lock_init(&ad->ad_resource_fork);
AD_SET(ad->ad_resource_fork.adf_off);
ad->ad_resource_fork.adf_flags = hoflags;
if ((oflags & O_CREAT) && !st_invalid) {
uid_t uid;
int ret, err;
int dir = flags & ADFLAGS_DIR;
-
+ int adouble = 0;
+
+ if (!(flags & ADFLAGS_NOADOUBLE)) {
+ adouble = O_CREAT;
+ }
+
/* Open with O_CREAT, thus enumarating a dir will create missing adouble files, see: */
/* http://marc.info/?l=netatalk-devel&m=124039156832408&w=2 */
- if ((ret = ad_open(name, ADFLAGS_HF | dir, O_RDWR | O_CREAT, 0666, adp)) < 0 && errno == EACCES) {
+ if ((ret = ad_open(name, ADFLAGS_HF | dir, O_RDWR | adouble, 0666, adp)) < 0 && errno == EACCES) {
uid = geteuid();
if (seteuid(0)) {
LOG(log_error, logtype_default, "ad_metadata(%s): seteuid failed %s", name, strerror(errno));
}
if (!ret && (ADFLAGS_OPENFORKS & flags)) {
- u_int16_t attrbits = adp->ad_open_forks;
-
/*
we need to check if the file is open by another process.
it's slow so we only do it if we have to:
- it's requested.
- we don't already have the answer!
*/
-
- if (!(attrbits & ATTRBIT_ROPEN)) {
- attrbits |= ad_testlock(adp, ADEID_RFORK, AD_FILELOCK_OPEN_RD) > 0? ATTRBIT_ROPEN : 0;
- attrbits |= ad_testlock(adp, ADEID_RFORK, AD_FILELOCK_OPEN_WR) > 0? ATTRBIT_ROPEN : 0;
- }
-
- if (!(attrbits & ATTRBIT_DOPEN)) {
- attrbits |= ad_testlock(adp, ADEID_DFORK, AD_FILELOCK_OPEN_RD) > 0? ATTRBIT_DOPEN : 0;
- attrbits |= ad_testlock(adp, ADEID_DFORK, AD_FILELOCK_OPEN_WR) > 0? ATTRBIT_DOPEN : 0;
- }
- adp->ad_open_forks = attrbits;
+ adp->ad_open_forks |= ad_openforks(adp, adp->ad_open_forks);
}
return ret;
}
memcpy(ad_entry(ad, ADEID_FINDERI) + FINDERINFO_FRFLAGOFF, &ashort, sizeof(ashort));
}
- if (stat(path, &st) < 0) {
+ if (lstat(path, &st) < 0) {
return -1;
}
projects / netatalk.git / blobdiff