/*
- * $Id: file.c,v 1.141 2010/03/12 15:16:49 franklahm Exp $
- *
* Copyright (c) 1990,1993 Regents of The University of Michigan.
* All Rights Reserved. See COPYRIGHT.
*/
#include <stdio.h>
#include <stdlib.h>
-/* STDC check */
-#if STDC_HEADERS
#include <string.h>
-#else /* STDC_HEADERS */
-#ifndef HAVE_STRCHR
-#define strchr index
-#define strrchr index
-#endif /* HAVE_STRCHR */
-char *strchr (), *strrchr ();
-
-#ifndef HAVE_MEMCPY
-#define memcpy(d,s,n) bcopy ((s), (d), (n))
-#define memmove(d,s,n) bcopy ((s), (d), (n))
-#endif /* ! HAVE_MEMCPY */
-#endif /* STDC_HEADERS */
-
#include <utime.h>
#include <errno.h>
#include <sys/param.h>
#include <atalk/util.h>
#include <atalk/cnid.h>
#include <atalk/unix.h>
+#include <atalk/globals.h>
+#include <atalk/fce_api.h>
+#include <atalk/netatalk_conf.h>
#include "directory.h"
#include "dircache.h"
#include "fork.h"
#include "file.h"
#include "filedir.h"
-#include "globals.h"
#include "unix.h"
/* the format for the finderinfo fields (from IM: Toolbox Essentials):
/* FIXME path : unix or mac name ? (for now it's unix name ) */
void *get_finderinfo(const struct vol *vol, const char *upath, struct adouble *adp, void *data, int islink)
{
- struct extmap *em;
void *ad_finder = NULL;
int chk_ext = 0;
-
+
if (adp)
ad_finder = ad_entry(adp, ADEID_FINDERI);
if (ad_finder) {
memcpy(data, ad_finder, ADEDLEN_FINDERI);
- /* default type ? */
- if (default_type(ad_finder))
- chk_ext = 1;
}
else {
memcpy(data, ufinderi, ADEDLEN_FINDERI);
- chk_ext = 1;
if (vol_inv_dots(vol) && *upath == '.') { /* make it invisible */
- u_int16_t ashort;
+ uint16_t ashort;
ashort = htons(FINDERINFO_INVISIBLE);
memcpy((char *)data + FINDERINFO_FRFLAGOFF, &ashort, sizeof(ashort));
}
if (islink){
- u_int16_t linkflag;
+ uint16_t linkflag;
memcpy(&linkflag, (char *)data + FINDERINFO_FRFLAGOFF, 2);
linkflag |= htons(FINDERINFO_ISALIAS);
memcpy((char *)data + FINDERINFO_FRFLAGOFF, &linkflag, 2);
memcpy((char *)data + FINDERINFO_FRTYPEOFF,"slnk",4);
memcpy((char *)data + FINDERINFO_FRCREATOFF,"rhap",4);
- chk_ext = 0;
}
- /** Only enter if no appledouble information and no finder information found. */
- if (chk_ext && (em = getextmap( upath ))) {
- memcpy(data, em->em_type, sizeof( em->em_type ));
- memcpy((char *)data + 4, em->em_creator, sizeof(em->em_creator));
- }
return data;
}
/* ---------------------
*/
-char *set_name(const struct vol *vol, char *data, cnid_t pid, char *name, cnid_t id, u_int32_t utf8)
+char *set_name(const struct vol *vol, char *data, cnid_t pid, char *name, cnid_t id, uint32_t utf8)
{
- u_int32_t aint;
+ uint32_t aint;
char *tp = NULL;
char *src = name;
aint = strlen( name );
if (!utf8) {
/* want mac name */
- if (utf8_encoding()) {
+ if (utf8_encoding(vol->v_obj)) {
/* but name is an utf8 mac name */
char *u, *m;
*data++ = aint;
}
else {
- u_int16_t temp;
+ uint16_t temp;
- if (aint > 255) /* FIXME safeguard, anyway if no ascii char it's game over*/
- aint = 255;
+ if (aint > UTF8FILELEN_EARLY) /* FIXME safeguard, anyway if no ascii char it's game over*/
+ aint = UTF8FILELEN_EARLY;
utf8 = vol->v_kTextEncoding;
memcpy(data, &utf8, sizeof(utf8));
(1 << FILPBIT_FNUM) |\
(1 << FILPBIT_UNIXPR)))
-/* -------------------------- */
-uint32_t get_id(struct vol *vol, struct adouble *adp, const struct stat *st,
- const cnid_t did, char *upath, const int len)
+/*!
+ * @brief Get CNID for did/upath args both from database and adouble file
+ *
+ * 1. Get the objects CNID as stored in its adouble file
+ * 2. Get the objects CNID from the database
+ * 3. If there's a problem with a "dbd" database, fallback to "tdb" in memory
+ * 4. In case 2 and 3 differ, store 3 in the adouble file
+ *
+ * @param vol (rw) volume
+ * @param adp (rw) adouble struct of object upath, might be NULL
+ * @param st (r) stat of upath, must NOT be NULL
+ * @param did (r) parent CNID of upath
+ * @param upath (r) name of object
+ * @param len (r) strlen of upath
+ */
+uint32_t get_id(struct vol *vol,
+ struct adouble *adp,
+ const struct stat *st,
+ const cnid_t did,
+ const char *upath,
+ const int len)
{
static int first = 1; /* mark if this func is called the first time */
- u_int32_t adcnid;
- u_int32_t dbcnid = CNID_INVALID;
+ uint32_t adcnid;
+ uint32_t dbcnid = CNID_INVALID;
restart:
if (vol->v_cdb != NULL) {
/* prime aint with what we think is the cnid, set did to zero for
catching moved files */
- adcnid = ad_getid(adp, st->st_dev, st->st_ino, 0, vol->v_stamp);
+ adcnid = ad_getid(adp, st->st_dev, st->st_ino, 0, vol->v_stamp); /* (1) */
- dbcnid = cnid_add(vol->v_cdb, st, did, upath, len, adcnid);
+ dbcnid = cnid_add(vol->v_cdb, st, did, upath, len, adcnid); /* (2) */
/* Throw errors if cnid_add fails. */
if (dbcnid == CNID_INVALID) {
switch (errno) {
/* we have to do it here for "dbd" because it uses "lazy opening" */
/* In order to not end in a loop somehow with goto restart below */
/* */
- if (first && (strcmp(vol->v_cnidscheme, "dbd") == 0)) {
+ if (first && (strcmp(vol->v_cnidscheme, "dbd") == 0)) { /* (3) */
cnid_close(vol->v_cdb);
free(vol->v_cnidscheme);
vol->v_cnidscheme = strdup("tdb");
vol->v_path);
vol->v_cdb = cnid_open(vol->v_path, vol->v_umask, "tdb", flags, NULL, NULL);
if (vol->v_cdb) {
- /* deactivate cnid caching/storing in AppleDouble files and set ro mode*/
- vol->v_flags &= ~AFPVOL_CACHE;
+ /* set ro mode*/
vol->v_flags |= AFPVOL_RO;
#ifdef SERVERTEXT
/* kill ourself with SIGUSR2 aka msg pending */
goto exit;
}
}
- else if (adp && (adcnid != dbcnid)) {
+ else if (adp && (adcnid != dbcnid)) { /* 4 */
/* Update the ressource fork. For a folder adp is always null */
- LOG(log_debug, logtype_afpd, "get_id: calling ad_setid. adcnid: %u, dbcnid: %u", htonl(adcnid), htonl(dbcnid));
+ LOG(log_debug, logtype_afpd, "get_id(%s/%s): calling ad_setid(old: %u, new: %u)",
+ getcwdpath(), upath, htonl(adcnid), htonl(dbcnid));
if (ad_setid(adp, st->st_dev, st->st_ino, dbcnid, did, vol->v_stamp)) {
ad_flush(adp);
}
}
/* -------------------------- */
-int getmetadata(struct vol *vol,
- u_int16_t bitmap,
- struct path *path, struct dir *dir,
- char *buf, size_t *buflen, struct adouble *adp)
+int getmetadata(const AFPObj *obj,
+ struct vol *vol,
+ uint16_t bitmap,
+ struct path *path, struct dir *dir,
+ char *buf, size_t *buflen, struct adouble *adp)
{
char *data, *l_nameoff = NULL, *upath;
char *utf_nameoff = NULL;
int bit = 0;
- u_int32_t aint;
+ uint32_t aint;
cnid_t id = 0;
- u_int16_t ashort;
+ uint16_t ashort;
u_char achar, fdType[4];
- u_int32_t utf8 = 0;
+ uint32_t utf8 = 0;
struct stat *st;
struct maccess ma;
+ LOG(log_debug, logtype_afpd, "getmetadata(\"%s\")", path->u_name);
+
upath = path->u_name;
st = &path->st;
data = buf;
if ( ((bitmap & ( (1 << FILPBIT_FINFO)|(1 << FILPBIT_LNAME)|(1 <<FILPBIT_PDINFO) ) ) && !path->m_name)
- || (bitmap & ( (1 << FILPBIT_LNAME) ) && utf8_encoding()) /* FIXME should be m_name utf8 filename */
+ || (bitmap & ( (1 << FILPBIT_LNAME) ) && utf8_encoding(obj)) /* FIXME should be m_name utf8 filename */
|| (bitmap & (1 << FILPBIT_FNUM))) {
if (!path->id) {
+ bstring fullpath;
struct dir *cachedfile;
int len = strlen(upath);
if ((cachedfile = dircache_search_by_name(vol, dir, upath, len)) != NULL)
/* Get macname from unixname first */
if (path->m_name == NULL) {
- if ((path->m_name = utompath(vol, upath, id, utf8_encoding())) == NULL) {
+ if ((path->m_name = utompath(vol, upath, id, utf8_encoding(obj))) == NULL) {
LOG(log_error, logtype_afpd, "getmetadata: utompath error");
- exit(EXITERR_SYS);
+ return AFPERR_MISC;
}
}
- if ((cachedfile = dir_new(path->m_name, upath, vol, dir->d_did, id, NULL)) == NULL) {
+ /* Build fullpath */
+ if (((fullpath = bstrcpy(dir->d_fullpath)) == NULL)
+ || (bconchar(fullpath, '/') != BSTR_OK)
+ || (bcatcstr(fullpath, upath)) != BSTR_OK) {
+ LOG(log_error, logtype_afpd, "getmetadata: fullpath: %s", strerror(errno));
+ return AFPERR_MISC;
+ }
+
+ if ((cachedfile = dir_new(path->m_name, upath, vol, dir->d_did, id, fullpath, st)) == NULL) {
LOG(log_error, logtype_afpd, "getmetadata: error from dir_new");
- exit(EXITERR_SYS);
+ return AFPERR_MISC;
}
- if ((dircache_add(cachedfile)) != 0) {
+
+ if ((dircache_add(vol, cachedfile)) != 0) {
LOG(log_error, logtype_afpd, "getmetadata: fatal dircache error");
- exit(EXITERR_SYS);
+ return AFPERR_MISC;
}
}
} else {
return afp_errno;
if (!path->m_name) {
- path->m_name = utompath(vol, upath, id, utf8_encoding());
+ path->m_name = utompath(vol, upath, id, utf8_encoding(vol->v_obj));
}
}
while ( bitmap != 0 ) {
/* FIXME do we want a visual clue if the file is read only
*/
struct maccess ma;
- accessmode( ".", &ma, dir , NULL);
+ accessmode(vol, ".", &ma, dir , NULL);
if ((ma.ma_user & AR_UWRITE)) {
- accessmode( upath, &ma, dir , st);
+ accessmode(vol, upath, &ma, dir , st);
if (!(ma.ma_user & AR_UWRITE)) {
ashort |= htons(ATTRBIT_NOWRITE);
}
break;
case FILPBIT_PDID :
- memcpy(data, &dir->d_did, sizeof( u_int32_t ));
- data += sizeof( u_int32_t );
+ memcpy(data, &dir->d_did, sizeof( uint32_t ));
+ data += sizeof( uint32_t );
LOG(log_debug, logtype_afpd, "metadata('%s'): Parent DID: %u",
path->u_name, ntohl(dir->d_did));
break;
case FILPBIT_LNAME :
l_nameoff = data;
- data += sizeof( u_int16_t );
+ data += sizeof( uint16_t );
break;
case FILPBIT_SNAME :
- memset(data, 0, sizeof(u_int16_t));
- data += sizeof( u_int16_t );
+ memset(data, 0, sizeof(uint16_t));
+ data += sizeof( uint16_t );
break;
case FILPBIT_FNUM :
to "pXYZ" when we created it. See IA, Ver 2.
<shirsch@adelphia.net> */
case FILPBIT_PDINFO :
- if (afp_version >= 30) { /* UTF8 name */
+ if (obj->afp_version >= 30) { /* UTF8 name */
utf8 = kTextEncodingUTF8;
utf_nameoff = data;
- data += sizeof( u_int16_t );
+ data += sizeof( uint16_t );
aint = 0;
memcpy(data, &aint, sizeof( aint ));
data += sizeof( aint );
break;
case FILPBIT_UNIXPR :
/* accessmode may change st_mode with ACLs */
- accessmode( upath, &ma, dir , st);
+ accessmode(obj, vol, upath, &ma, dir , st);
aint = htonl(st->st_uid);
memcpy( data, &aint, sizeof( aint ));
}
/* ----------------------- */
-int getfilparams(struct vol *vol,
- u_int16_t bitmap,
+int getfilparams(const AFPObj *obj,
+ struct vol *vol,
+ uint16_t bitmap,
struct path *path, struct dir *dir,
char *buf, size_t *buflen )
{
struct adouble ad, *adp;
int opened = 0;
int rc;
+ int flags;
+
+ LOG(log_debug, logtype_afpd, "getfilparams(\"%s\")", path->u_name);
opened = PARAM_NEED_ADP(bitmap);
adp = NULL;
if (opened) {
char *upath;
- int flags = (bitmap & (1 << FILPBIT_ATTR))?ADFLAGS_OPENFORKS:0;
+ flags = (bitmap & (1 << FILPBIT_ATTR)) ? ADFLAGS_CHECK_OF : 0;
adp = of_ad(vol, path, &ad);
upath = path->u_name;
- if ( ad_metadata( upath, flags|ADFLAGS_CREATE, adp) < 0 ) {
+ if ( ad_metadata( upath, flags, adp) < 0 ) {
switch (errno) {
case EACCES:
LOG(log_error, logtype_afpd, "getfilparams(%s): %s: check resource fork permission?",
}
}
}
- rc = getmetadata(vol, bitmap, path, dir, buf, buflen, adp);
- if ( adp ) {
- ad_close_metadata( adp);
- }
+ rc = getmetadata(obj, vol, bitmap, path, dir, buf, buflen, adp);
+ ad_close(adp, ADFLAGS_HF | flags);
return( rc );
}
/* ----------------------------- */
int afp_createfile(AFPObj *obj, char *ibuf, size_t ibuflen _U_, char *rbuf _U_, size_t *rbuflen)
{
- struct adouble ad, *adp;
+ struct adouble ad;
struct vol *vol;
struct dir *dir;
struct ofork *of = NULL;
char *path, *upath;
int creatf, did, openf, retvalue = AFP_OK;
- u_int16_t vid;
+ uint16_t vid;
struct path *s_path;
*rbuflen = 0;
memcpy(&vid, ibuf, sizeof( vid ));
ibuf += sizeof( vid );
- if (NULL == ( vol = getvolbyvid( vid )) ) {
+ if (NULL == ( vol = getvolbyvid( vid )) )
return( AFPERR_PARAM );
- }
if (vol->v_flags & AFPVOL_RO)
return AFPERR_VLOCK;
memcpy(&did, ibuf, sizeof( did));
ibuf += sizeof( did );
- if (NULL == ( dir = dirlookup( vol, did )) ) {
+ if (NULL == ( dir = dirlookup( vol, did )) )
return afp_errno;
- }
- if (NULL == ( s_path = cname( vol, dir, &ibuf )) ) {
+ if (NULL == ( s_path = cname( vol, dir, &ibuf )) )
return get_afp_errno(AFPERR_PARAM);
- }
-
- if ( *s_path->m_name == '\0' ) {
+ if ( *s_path->m_name == '\0' )
return( AFPERR_BADTYPE );
- }
upath = s_path->u_name;
+ ad_init(&ad, vol);
/* if upath is deleted we already in trouble anyway */
if ((of = of_findname(s_path))) {
- adp = of->of_ad;
- } else {
- ad_init(&ad, vol->v_adouble, vol->v_ad_options);
- adp = &ad;
- }
- if ( creatf) {
- /* on a hard create, fail if file exists and is open */
- if (of)
+ if (creatf)
return AFPERR_BUSY;
- openf = O_RDWR|O_CREAT|O_TRUNC;
- } else {
- /* on a soft create, if the file is open then ad_open won't fail
- because open syscall is not called
- */
- if (of) {
- return AFPERR_EXIST;
- }
- openf = O_RDWR|O_CREAT|O_EXCL;
+ else
+ return AFPERR_EXIST;
}
- if ( ad_open( upath, ADFLAGS_DF|ADFLAGS_HF|ADFLAGS_NOHF|ADFLAGS_CREATE,
- openf, 0666, adp) < 0 ) {
+ if (creatf)
+ openf = ADFLAGS_RDWR | ADFLAGS_CREATE | ADFLAGS_TRUNC;
+ else
+ /* on a soft create, if the file is open then ad_open won't fail
+ because open syscall is not called */
+ openf = ADFLAGS_RDWR | ADFLAGS_CREATE | ADFLAGS_EXCL;
+
+ if (ad_open(&ad, upath, ADFLAGS_DF | ADFLAGS_HF | ADFLAGS_NOHF | openf, 0666) < 0) {
switch ( errno ) {
case EROFS:
return AFPERR_VLOCK;
return( AFPERR_PARAM );
}
}
- if ( ad_reso_fileno( adp ) == -1 ) { /* Hard META / HF */
- /* on noadouble volumes, just creating the data fork is ok */
- if (vol_noadouble(vol)) {
- ad_close( adp, ADFLAGS_DF );
- goto createfile_done;
- }
+ if ( ad_meta_fileno( &ad ) == -1 ) { /* Hard META / HF */
/* FIXME with hard create on an existing file, we already
* corrupted the data file.
*/
netatalk_unlink( upath );
- ad_close( adp, ADFLAGS_DF );
+ ad_close( &ad, ADFLAGS_DF );
return AFPERR_ACCESS;
}
path = s_path->m_name;
- ad_setname(adp, path);
- ad_flush( adp);
- ad_close( adp, ADFLAGS_DF|ADFLAGS_HF );
-
-createfile_done:
- curdir->offcnt++;
+ ad_setname(&ad, path);
-#ifdef DROPKLUDGE
- if (vol->v_flags & AFPVOL_DROPBOX) {
- retvalue = matchfile2dirperms(upath, vol, did);
+ struct stat st;
+ if (lstat(upath, &st) != 0) {
+ LOG(log_error, logtype_afpd, "afp_createfile(\"%s\"): stat: %s",
+ upath, strerror(errno));
+ ad_close(&ad, ADFLAGS_DF|ADFLAGS_HF);
+ return AFPERR_MISC;
}
-#endif /* DROPKLUDGE */
+
+ (void)get_id(vol, &ad, &st, dir->d_did, upath, strlen(upath));
+
+ ad_flush(&ad);
+ ad_close(&ad, ADFLAGS_DF|ADFLAGS_HF );
+ fce_register_new_file(s_path);
+
+createfile_done:
+ curdir->d_offcnt++;
setvoltime(obj, vol );
struct dir *dir;
struct path *s_path;
int did, rc;
- u_int16_t vid, bitmap;
+ uint16_t vid, bitmap;
*rbuflen = 0;
ibuf += 2;
ibuf++;
}
- if (AFP_OK == ( rc = setfilparams(vol, s_path, bitmap, ibuf )) ) {
+ if (AFP_OK == ( rc = setfilparams(obj, vol, s_path, bitmap, ibuf )) ) {
setvoltime(obj, vol );
}
*/
extern struct path Cur_Path;
-int setfilparams(struct vol *vol,
- struct path *path, u_int16_t f_bitmap, char *buf )
+int setfilparams(const AFPObj *obj, struct vol *vol,
+ struct path *path, uint16_t f_bitmap, char *buf )
{
struct adouble ad, *adp;
struct extmap *em;
int bit, isad = 1, err = AFP_OK;
char *upath;
u_char achar, *fdType, xyy[4]; /* uninitialized, OK 310105 */
- u_int16_t ashort, bshort, oshort;
- u_int32_t aint;
- u_int32_t upriv;
- u_int16_t upriv_bit = 0;
-
- struct utimbuf ut;
-
+ uint16_t ashort, bshort, oshort;
+ uint32_t aint;
+ uint32_t upriv;
+ uint16_t upriv_bit = 0;
+ struct utimbuf ut;
int change_mdate = 0;
int change_parent_mdate = 0;
int newdate = 0;
struct timeval tv;
uid_t f_uid;
gid_t f_gid;
- u_int16_t bitmap = f_bitmap;
- u_int32_t cdate,bdate;
+ uint16_t bitmap = f_bitmap;
+ uint32_t cdate,bdate;
u_char finder_buf[32];
+ int symlinked = 0;
#ifdef DEBUG
LOG(log_debug9, logtype_afpd, "begin setfilparams:");
adp = of_ad(vol, path, &ad);
upath = path->u_name;
- if (!vol_unix_priv(vol) && check_access(upath, OPENACC_WR ) < 0) {
+ if (!vol_unix_priv(vol) && check_access(obj, vol, upath, OPENACC_WR ) < 0) {
return AFPERR_ACCESS;
}
case FILPBIT_FINFO :
change_mdate = 1;
memcpy(finder_buf, buf, 32 );
- if (memcmp(buf,"slnkrhap",8)==0 && !S_ISLNK(path->st.st_mode)){
- // SLFINFO
+ if (memcmp(buf, "slnkrhap", 8) == 0 && !S_ISLNK(path->st.st_mode)) {
int fp;
ssize_t len;
int erc=1;
char buf[PATH_MAX+1];
- if ((fp=open(path->u_name,O_RDONLY))>=0){
- if ((len=read(fp,buf,PATH_MAX+1))){
- if (unlink(path->u_name)==0){
- buf[len]=0;
+ if ((fp = open(path->u_name, O_RDONLY)) >= 0) {
+ if ((len = read(fp, buf, PATH_MAX+1))) {
+ if (unlink(path->u_name) == 0) {
+ buf[len] = 0;
erc = symlink(buf, path->u_name);
if (!erc)
of_stat(path);
}
close(fp);
}
- if (erc!=0){
+ if (erc != 0) {
err=AFPERR_BITMAP;
goto setfilparam_done;
}
+ symlinked = 1;
}
buf += 32;
break;
}
break;
case FILPBIT_PDINFO :
- if (afp_version < 30) { /* else it's UTF8 name */
+ if (obj->afp_version < 30) { /* else it's UTF8 name */
achar = *buf;
buf += 2;
/* Keep special case to support crlf translations */
/* second try with adouble open
*/
- if ( ad_open_metadata( upath, 0, O_CREAT, adp) < 0) {
+ if (ad_open(adp, upath, ADFLAGS_HF | ADFLAGS_RDWR | ADFLAGS_CREATE, 0666) < 0) {
LOG(log_debug, logtype_afpd, "setfilparams: ad_open_metadata error");
/*
* For some things, we don't need an adouble header:
* - change of modification date
* - UNIX privs (Bug-ID #2863424)
*/
- if (!vol_noadouble(vol) && (f_bitmap & ~(1<<FILPBIT_MDATE | 1<<FILPBIT_UNIXPR))) {
+ if (!symlinked && f_bitmap & ~(1<<FILPBIT_MDATE | 1<<FILPBIT_UNIXPR)) {
LOG(log_debug, logtype_afpd, "setfilparams: need adouble access");
return AFPERR_ACCESS;
}
LOG(log_debug, logtype_afpd, "setfilparams: no adouble perms, but only FILPBIT_MDATE and/or FILPBIT_UNIXPR");
isad = 0;
- } else if ((ad_get_HF_flags( adp ) & O_CREAT) ) {
+ } else if ((ad_get_MD_flags( adp ) & O_CREAT) ) {
ad_setname(adp, path->m_name);
}
ad_setdate(adp, AD_DATE_BACKUP, bdate);
break;
case FILPBIT_FINFO :
- if (default_type( ad_entry( adp, ADEID_FINDERI ))
- && (
- ((em = getextmap( path->m_name )) &&
- !memcmp(finder_buf, em->em_type, sizeof( em->em_type )) &&
- !memcmp(finder_buf + 4, em->em_creator,sizeof( em->em_creator)))
- || ((em = getdefextmap()) &&
- !memcmp(finder_buf, em->em_type, sizeof( em->em_type )) &&
- !memcmp(finder_buf + 4, em->em_creator,sizeof( em->em_creator)))
- )) {
- memcpy(finder_buf, ufinderi, 8 );
- }
memcpy(ad_entry( adp, ADEID_FINDERI ), finder_buf, 32 );
break;
case FILPBIT_UNIXPR :
}
break;
case FILPBIT_PDINFO :
- if (afp_version < 30) { /* else it's UTF8 name */
+ if (obj->afp_version < 30) { /* else it's UTF8 name */
memcpy(ad_entry( adp, ADEID_FINDERI ), fdType, 4 );
memcpy(ad_entry( adp, ADEID_FINDERI ) + 4, "pdos", 4 );
break;
}
if (isad) {
- ad_flush( adp);
- ad_close_metadata( adp);
-
+ ad_flush(adp);
+ ad_close(adp, ADFLAGS_HF);
}
if (change_parent_mdate && gettimeofday(&tv, NULL) == 0) {
{
int rc;
+ LOG(log_debug, logtype_afpd,
+ "renamefile: src[%d, \"%s\"] -> dst[\"%s\"]", sdir_fd, src, dst);
+
if ( unix_rename( sdir_fd, src, -1, dst ) < 0 ) {
switch ( errno ) {
case ENOENT :
}
}
- /* don't care if we can't open the newly renamed ressource fork
- */
- if (!ad_open( dst, ADFLAGS_HF, O_RDWR, 0666, adp)) {
+ /* don't care if we can't open the newly renamed ressource fork */
+ if (ad_open(adp, dst, ADFLAGS_HF | ADFLAGS_RDWR) == 0) {
ad_setname(adp, newname);
ad_flush( adp );
ad_close( adp, ADFLAGS_HF );
{
char type = *ibuf;
size_t plen = 0;
-u_int16_t len16;
-u_int32_t hint;
+uint16_t len16;
+uint32_t hint;
- if ( type != 2 && !(afp_version >= 30 && type == 3) ) {
+ if ( type != 2 && !(vol->v_obj->afp_version >= 30 && type == 3) ) {
return -1;
}
ibuf++;
switch (type) {
case 2:
if (( plen = (unsigned char)*ibuf++ ) != 0 ) {
- if (afp_version >= 30) {
+ if (vol->v_obj->afp_version >= 30) {
/* convert it to UTF8
*/
if ((plen = mtoUTF8(vol, ibuf, plen, newname, AFPOBJ_TMPSIZ)) == (size_t)-1)
struct dir *dir;
char *newname, *p, *upath;
struct path *s_path;
- u_int32_t sdid, ddid;
+ uint32_t sdid, ddid;
int err, retvalue = AFP_OK;
- u_int16_t svid, dvid;
+ uint16_t svid, dvid;
struct adouble ad, *adp;
int denyreadset;
adp = of_ad(s_vol, s_path, &ad);
- if (ad_open(s_path->u_name , ADFLAGS_DF |ADFLAGS_HF | ADFLAGS_NOHF, O_RDONLY, 0, adp) < 0) {
+ if (ad_open(adp, s_path->u_name, ADFLAGS_DF | ADFLAGS_HF | ADFLAGS_NOHF | ADFLAGS_RDONLY | ADFLAGS_SETSHRMD) < 0) {
return AFPERR_DENYCONF;
}
- denyreadset = (getforkmode(adp, ADEID_DFORK, AD_FILELOCK_DENY_RD) != 0 ||
- getforkmode(adp, ADEID_RFORK, AD_FILELOCK_DENY_RD) != 0 );
+ denyreadset = (ad_testlock(adp, ADEID_DFORK, AD_FILELOCK_DENY_RD) != 0 ||
+ ad_testlock(adp, ADEID_RFORK, AD_FILELOCK_DENY_RD) != 0 );
if (denyreadset) {
retvalue = AFPERR_DENYCONF;
goto copy_exit;
}
-#ifdef FORCE_UIDGID
- /* FIXME svid != dvid && dvid's user can't read svid */
-#endif
if (NULL == ( d_vol = getvolbyvid( dvid )) ) {
retvalue = AFPERR_PARAM;
goto copy_exit;
/* newname is always only a filename so curdir *is* its
* parent folder
*/
- if (NULL == (upath = mtoupath(d_vol, newname, curdir->d_did, utf8_encoding()))) {
+ if (NULL == (upath = mtoupath(d_vol, newname, curdir->d_did, utf8_encoding(d_vol->v_obj)))) {
retvalue =AFPERR_PARAM;
goto copy_exit;
}
retvalue = err;
goto copy_exit;
}
- curdir->offcnt++;
-
-#ifdef DROPKLUDGE
- if (vol->v_flags & AFPVOL_DROPBOX) {
- retvalue=matchfile2dirperms(upath, vol, ddid); /* FIXME sdir or ddid */
- }
-#endif /* DROPKLUDGE */
+ curdir->d_offcnt++;
setvoltime(obj, d_vol );
copy_exit:
- ad_close( adp, ADFLAGS_DF |ADFLAGS_HF );
+ ad_close( adp, ADFLAGS_DF |ADFLAGS_HF | ADFLAGS_SETSHRMD);
return( retvalue );
}
-/* ----------------------- */
-static int copy_all(const int dfd, const void *buf,
- size_t buflen)
-{
- ssize_t cc;
-
-#ifdef DEBUG
- LOG(log_debug9, logtype_afpd, "begin copy_all:");
-#endif /* DEBUG */
-
- while (buflen > 0) {
- if ((cc = write(dfd, buf, buflen)) < 0) {
- switch (errno) {
- case EINTR:
- continue;
- default:
- return -1;
- }
- }
- buflen -= cc;
- }
-
-#ifdef DEBUG
- LOG(log_debug9, logtype_afpd, "end copy_all:");
-#endif /* DEBUG */
-
- return 0;
-}
-
-/* --------------------------
- * copy only the fork data stream
-*/
-static int copy_fork(int eid, struct adouble *add, struct adouble *ads)
-{
- ssize_t cc;
- int err = 0;
- char filebuf[8192];
- int sfd, dfd;
-
- if (eid == ADEID_DFORK) {
- sfd = ad_data_fileno(ads);
- dfd = ad_data_fileno(add);
- }
- else {
- sfd = ad_reso_fileno(ads);
- dfd = ad_reso_fileno(add);
- }
-
- if ((off_t)-1 == lseek(sfd, ad_getentryoff(ads, eid), SEEK_SET))
- return -1;
-
- if ((off_t)-1 == lseek(dfd, ad_getentryoff(add, eid), SEEK_SET))
- return -1;
-
-#if 0 /* ifdef SENDFILE_FLAVOR_LINUX */
- /* doesn't work With 2.6 FIXME, only check for EBADFD ? */
- off_t offset = 0;
- size_t size;
- struct stat st;
- #define BUF 128*1024*1024
-
- if (fstat(sfd, &st) == 0) {
-
- while (1) {
- if ( offset >= st.st_size) {
- return 0;
- }
- size = (st.st_size -offset > BUF)?BUF:st.st_size -offset;
- if ((cc = sys_sendfile(dfd, sfd, &offset, size)) < 0) {
- switch (errno) {
- case ENOSYS:
- case EINVAL: /* there's no guarantee that all fs support sendfile */
- goto no_sendfile;
- default:
- return -1;
- }
- }
- }
- }
- no_sendfile:
- lseek(sfd, offset, SEEK_SET);
-#endif
-
- while (1) {
- if ((cc = read(sfd, filebuf, sizeof(filebuf))) < 0) {
- if (errno == EINTR)
- continue;
- err = -1;
- break;
- }
-
- if (!cc || ((err = copy_all(dfd, filebuf, cc)) < 0)) {
- break;
- }
- }
- return err;
-}
-
/* ----------------------------------
* if newname is NULL (from directory.c) we don't want to copy the resource fork.
* because we are doing it elsewhere.
sfd, src, dst, newname);
if (adp == NULL) {
- ad_init(&ads, s_vol->v_adouble, s_vol->v_ad_options);
+ ad_init(&ads, s_vol);
adp = &ads;
}
- adflags = ADFLAGS_DF;
- if (newname) {
- adflags |= ADFLAGS_HF;
- }
+ adflags = ADFLAGS_DF | ADFLAGS_RF | ADFLAGS_NORF;
- if (ad_openat(sfd, src, adflags | ADFLAGS_NOHF, O_RDONLY, 0, adp) < 0) {
+ if (ad_openat(adp, sfd, src, adflags | ADFLAGS_RDONLY) < 0) {
ret_err = errno;
goto done;
}
- if (ad_meta_fileno(adp) == -1 && ad_reso_fileno(adp) == -1) { /* META / HF */
+ if (!AD_RSRC_OPEN(adp))
/* no resource fork, don't create one for dst file */
- adflags &= ~ADFLAGS_HF;
- }
+ adflags &= ~ADFLAGS_RF;
stat_result = fstat(ad_data_fileno(adp), &st); /* saving stat exit code, thus saving us on one more stat later on */
st.st_mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
}
- ad_init(&add, d_vol->v_adouble, d_vol->v_ad_options);
- if (ad_open(dst , adflags, O_RDWR|O_CREAT|O_EXCL, st.st_mode, &add) < 0) {
+ ad_init(&add, d_vol);
+ if (ad_open(&add, dst, adflags | ADFLAGS_RDWR | ADFLAGS_CREATE | ADFLAGS_EXCL, st.st_mode | S_IRUSR | S_IWUSR) < 0) {
ret_err = errno;
ad_close( adp, adflags );
if (EEXIST != ret_err) {
}
return AFPERR_EXIST;
}
-
- /*
- * XXX if the source and the dest don't use the same resource type it's broken
- */
- if (ad_reso_fileno(adp) == -1 || 0 == (err = copy_fork(ADEID_RFORK, &add, adp))){
- /* copy the data fork */
- if ((err = copy_fork(ADEID_DFORK, &add, adp)) == 0) {
- err = d_vol->vfs->vfs_copyfile(d_vol, sfd, src, dst);
- }
- }
- if (err < 0) {
+ if ((err = copy_fork(ADEID_DFORK, &add, adp)) != 0)
+ LOG(log_error, logtype_afpd, "copyfile('%s'): %s", src, strerror(errno));
+
+ if (err == 0)
+ if ((err = d_vol->vfs->vfs_copyfile(d_vol, sfd, src, dst)) != 0)
+ LOG(log_error, logtype_afpd, "copyfile('%s'): %s", src, strerror(errno));
+
+ if (err < 0)
ret_err = errno;
- }
if (!ret_err && newname && (adflags & ADFLAGS_HF)) {
/* set the new name in the resource fork */
static int check_attrib(struct adouble *adp)
{
-u_int16_t bshort = 0;
+uint16_t bshort = 0;
ad_getattr(adp, &bshort);
/*
LOG(log_debug, logtype_afpd, "deletefile('%s')", file);
- ad_init(&ad, vol->v_adouble, vol->v_ad_options);
+ ad_init(&ad, vol);
if (checkAttrib) {
/* was EACCESS error try to get only metadata */
/* we never want to create a resource fork here, we are going to delete it
* moreover sometimes deletefile is called with a no existent file and
* ad_open would create a 0 byte resource fork
*/
- if ( ad_metadataat(dirfd, file, ADFLAGS_OPENFORKS, &ad) == 0 ) {
+ if ( ad_metadataat(dirfd, file, ADFLAGS_CHECK_OF, &ad) == 0 ) {
if ((err = check_attrib(&ad))) {
- ad_close_metadata(&ad);
+ ad_close(&ad, ADFLAGS_HF | ADFLAGS_CHECK_OF);
return err;
}
meta = 1;
/* try to open both forks at once */
adflags = ADFLAGS_DF;
- if ( ad_openat(dirfd, file, adflags |ADFLAGS_HF|ADFLAGS_NOHF, O_RDONLY, 0, &ad ) < 0 ) {
+ if (ad_openat(&ad, dirfd, file, adflags | ADFLAGS_RF | ADFLAGS_NORF | ADFLAGS_RDONLY) < 0 ) {
switch (errno) {
case ENOENT:
err = AFPERR_NOOBJ;
adp = &ad;
}
- if ( adp && ad_reso_fileno( adp ) != -1 ) { /* there's a resource fork */
- adflags |= ADFLAGS_HF;
+ if ( adp && AD_RSRC_OPEN(adp) != -1 ) { /* there's a resource fork */
+ adflags |= ADFLAGS_RF;
/* FIXME we have a pb here because we want to know if a file is open
* there's a 'priority inversion' if you can't open the ressource fork RW
* you can delete it if it's open because you can't get a write lock.
}
if (adp && ad_tmplock( &ad, ADEID_DFORK, ADLOCK_WR, 0, 0, 0 ) < 0) {
+ LOG(log_error, logtype_afpd, "deletefile('%s'): ad_tmplock error: %s", file, strerror(errno));
err = AFPERR_BUSY;
} else if (!(err = vol->vfs->vfs_deletefile(vol, dirfd, file)) && !(err = netatalk_unlinkat(dirfd, file )) ) {
cnid_t id;
end:
if (meta)
- ad_close_metadata(&ad);
+ ad_close(&ad, ADFLAGS_HF | ADFLAGS_CHECK_OF);
if (adp)
ad_close( &ad, adflags ); /* ad_close removes locks if any */
cnid_t did = param->did;
cnid_t aint;
- if ( lstat(de->d_name, &path.st)<0 )
+ if ( lstat(de->d_name, &path.st) < 0 )
return 0;
/* update or add to cnid */
aint = cnid_add(vol->v_cdb, &path.st, did, de->d_name, strlen(de->d_name), 0); /* ignore errors */
-#if AD_VERSION > AD_VERSION1
- if (aint != CNID_INVALID && !S_ISDIR(path.st.st_mode)) {
- struct adouble ad, *adp;
-
- path.st_errno = 0;
- path.st_valid = 1;
- path.u_name = de->d_name;
-
- adp = of_ad(vol, &path, &ad);
-
- if ( ad_open_metadata( de->d_name, 0, 0, adp ) < 0 ) {
- return 0;
- }
- if (ad_setid(adp, path.st.st_dev, path.st.st_ino, aint, did, vol->v_stamp)) {
- ad_flush(adp);
- }
- ad_close_metadata(adp);
- }
-#endif /* AD_VERSION > AD_VERSION1 */
-
return 0;
}
if (dirreenumerate(dir, &st)) {
/* we already did it once and the dir haven't been modified */
- return dir->offcnt;
+ return dir->d_offcnt;
}
data.vol = vol;
/* ------------------------------
resolve a file id */
-int afp_resolveid(AFPObj *obj _U_, char *ibuf, size_t ibuflen _U_, char *rbuf, size_t *rbuflen)
+int afp_resolveid(AFPObj *obj, char *ibuf, size_t ibuflen _U_, char *rbuf, size_t *rbuflen)
{
struct vol *vol;
struct dir *dir;
int err, retry=0;
size_t buflen;
cnid_t id, cnid;
- u_int16_t vid, bitmap;
+ uint16_t vid, bitmap;
static char buffer[12 + MAXPATHLEN + 1];
int len = 12 + MAXPATHLEN + 1;
/* directories are bad */
if (S_ISDIR(path.st.st_mode)) {
/* OS9 and OSX don't return the same error code */
- return (afp_version >=30)?AFPERR_NOID:AFPERR_BADTYPE;
+ return (obj->afp_version >=30)?AFPERR_NOID:AFPERR_BADTYPE;
}
memcpy(&bitmap, ibuf, sizeof(bitmap));
bitmap = ntohs( bitmap );
- if (NULL == (path.m_name = utompath(vol, upath, cnid, utf8_encoding()))) {
+ if (NULL == (path.m_name = utompath(vol, upath, cnid, utf8_encoding(obj)))) {
return AFPERR_NOID;
}
path.id = cnid;
- if (AFP_OK != (err = getfilparams(vol, bitmap, &path , curdir,
- rbuf + sizeof(bitmap), &buflen))) {
+ if (AFP_OK != (err = getfilparams(obj, vol, bitmap, &path , curdir,
+ rbuf + sizeof(bitmap), &buflen))) {
return err;
}
*rbuflen = buflen + sizeof(bitmap);
}
/* ------------------------------ */
-static struct adouble *find_adouble(struct path *path, struct ofork **of, struct adouble *adp)
+static struct adouble *find_adouble(const AFPObj *obj, struct vol *vol, struct path *path, struct ofork **of, struct adouble *adp)
{
int ret;
/* we use file_access both for legacy Mac perm and
* for unix privilege, rename will take care of folder perms
*/
- if (file_access(path, OPENACC_WR ) < 0) {
+ if (file_access(obj, vol, path, OPENACC_WR ) < 0) {
afp_errno = AFPERR_ACCESS;
return NULL;
}
adp = (*of)->of_ad;
}
else {
- ret = ad_open( path->u_name, ADFLAGS_HF, O_RDONLY, 0, adp);
+ ret = ad_open(adp, path->u_name, ADFLAGS_HF | ADFLAGS_RDWR);
/* META and HF */
if ( !ret && ad_reso_fileno(adp) != -1 && !(adp->ad_resource_fork.adf_flags & ( O_RDWR | O_WRONLY))) {
/* from AFP spec.
int crossdev;
int slen, dlen;
- u_int32_t sid, did;
- u_int16_t vid;
+ uint32_t sid, did;
+ uint16_t vid;
uid_t uid;
gid_t gid;
return AFPERR_PARAM ;
}
- ad_init(&ads, vol->v_adouble, vol->v_ad_options);
- if (!(adsp = find_adouble( path, &s_of, &ads))) {
+ ad_init(&ads, vol);
+ if (!(adsp = find_adouble(obj, vol, path, &s_of, &ads))) {
return afp_errno;
}
goto err_exchangefile;
}
- ad_init(&add, vol->v_adouble, vol->v_ad_options);
- if (!(addp = find_adouble( path, &d_of, &add))) {
+ ad_init(&add, vol);
+ if (!(addp = find_adouble(obj, vol, path, &d_of, &add))) {
err = afp_errno;
goto err_exchangefile;
}
/* id's need switching. src -> dest and dest -> src.
* we need to re-stat() if it was a cross device copy.
*/
- if (sid) {
- cnid_delete(vol->v_cdb, sid);
- }
- if (did) {
- cnid_delete(vol->v_cdb, did);
- }
+ if (sid)
+ cnid_delete(vol->v_cdb, sid);
+ if (did)
+ cnid_delete(vol->v_cdb, did);
+
if ((did && ( (crossdev && lstat( upath, &srcst) < 0) ||
cnid_update(vol->v_cdb, did, &srcst, curdir->d_did,upath, dlen) < 0))
||
ad_close(addp, ADFLAGS_HF);
}
+ struct dir *cached;
+ if ((cached = dircache_search_by_did(vol, sid)) != NULL)
+ (void)dir_remove(vol, cached);
+ if ((cached = dircache_search_by_did(vol, did)) != NULL)
+ (void)dir_remove(vol, cached);
+
return err;
}