/*
- * $Id: file.c,v 1.133 2010-02-08 10:29:22 franklahm Exp $
- *
* Copyright (c) 1990,1993 Regents of The University of Michigan.
* All Rights Reserved. See COPYRIGHT.
*/
#include <atalk/unix.h>
#include "directory.h"
+#include "dircache.h"
#include "desktop.h"
#include "volume.h"
#include "fork.h"
}
/* 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)
+void *get_finderinfo(const struct vol *vol, const char *upath, struct adouble *adp, void *data, int islink)
{
struct extmap *em;
void *ad_finder = NULL;
memcpy((char *)data + FINDERINFO_FRFLAGOFF, &ashort, sizeof(ashort));
}
}
+
+ if (islink){
+ u_int16_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 ));
(1 << FILPBIT_FNUM) |\
(1 << FILPBIT_UNIXPR)))
-/* -------------------------- */
-u_int32_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;
+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) {
case CNID_ERR_PARAM:
LOG(log_error, logtype_afpd, "get_id: Incorrect parameters passed to cnid_add");
afp_errno = AFPERR_PARAM;
- return CNID_INVALID;
+ goto exit;
case CNID_ERR_PATH:
afp_errno = AFPERR_PARAM;
- return CNID_INVALID;
+ goto exit;
default:
+ /* Close CNID backend if "dbd" and switch to temp in-memory "tdb" */
+ /* 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)) { /* (3) */
+ cnid_close(vol->v_cdb);
+ free(vol->v_cnidscheme);
+ vol->v_cnidscheme = strdup("tdb");
+
+ int flags = CNID_FLAG_MEMORY;
+ if ((vol->v_flags & AFPVOL_NODEV)) {
+ flags |= CNID_FLAG_NODEV;
+ }
+ LOG(log_error, logtype_afpd, "Reopen volume %s using in memory temporary CNID DB.",
+ 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;
+ vol->v_flags |= AFPVOL_RO;
+#ifdef SERVERTEXT
+ /* kill ourself with SIGUSR2 aka msg pending */
+ setmessage("Something wrong with the volume's CNID DB, using temporary CNID DB instead."
+ "Check server messages for details. Switching to read-only mode.");
+ kill(getpid(), SIGUSR2);
+#endif
+ goto restart; /* not try again with the temp CNID db */
+ } else {
+#ifdef SERVERTEXT
+ setmessage("Something wrong with the volume's CNID DB, using temporary CNID DB failed too!"
+ "Check server messages for details, can't recover from this state!");
+#endif
+ }
+ }
afp_errno = AFPERR_MISC;
- return CNID_INVALID;
+ 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);
}
}
}
+
+exit:
+ first = 0;
return dbcnid;
}
struct stat *st;
struct maccess ma;
-#ifdef DEBUG
- LOG(log_debug9, logtype_afpd, "begin getmetadata:");
-#endif /* DEBUG */
-
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_FNUM))) {
- if (!path->id)
- id = get_id(vol, adp, st, dir->d_did, upath, strlen(upath));
- else
+ if (!path->id) {
+ struct dir *cachedfile;
+ int len = strlen(upath);
+ if ((cachedfile = dircache_search_by_name(vol, dir, upath, len, st->st_ctime)) != NULL)
+ id = cachedfile->d_did;
+ else {
+ id = get_id(vol, adp, st, dir->d_did, upath, len);
+
+ /* Add it to the cache */
+ LOG(log_debug, logtype_afpd, "getmetadata: caching: did:%u, \"%s\", cnid:%u",
+ ntohl(dir->d_did), upath, ntohl(id));
+
+ /* Get macname from unixname first */
+ if (path->m_name == NULL) {
+ if ((path->m_name = utompath(vol, upath, id, utf8_encoding())) == NULL) {
+ LOG(log_error, logtype_afpd, "getmetadata: utompath error");
+ exit(EXITERR_SYS);
+ }
+ }
+
+ if ((cachedfile = dir_new(path->m_name, upath, vol, dir->d_did, id, NULL, st->st_ctime)) == NULL) {
+ LOG(log_error, logtype_afpd, "getmetadata: error from dir_new");
+ exit(EXITERR_SYS);
+ }
+
+ if ((dircache_add(cachedfile)) != 0) {
+ LOG(log_error, logtype_afpd, "getmetadata: fatal dircache error");
+ exit(EXITERR_SYS);
+ }
+ }
+ } else {
id = path->id;
+ }
+
if (id == CNID_INVALID)
return afp_errno;
+
if (!path->m_name) {
path->m_name = utompath(vol, upath, id, utf8_encoding());
}
#endif
memcpy(data, &ashort, sizeof( ashort ));
data += sizeof( ashort );
+ LOG(log_debug, logtype_afpd, "metadata('%s'): AFP Attributes: %04x",
+ path->u_name, ntohs(ashort));
break;
case FILPBIT_PDID :
memcpy(data, &dir->d_did, sizeof( u_int32_t ));
data += sizeof( u_int32_t );
+ LOG(log_debug, logtype_afpd, "metadata('%s'): Parent DID: %u",
+ path->u_name, ntohl(dir->d_did));
break;
case FILPBIT_CDATE :
break;
case FILPBIT_FINFO :
- get_finderinfo(vol, upath, adp, (char *)data);
+ get_finderinfo(vol, upath, adp, (char *)data,S_ISLNK(st->st_mode));
data += ADEDLEN_FINDERI;
break;
case FILPBIT_FNUM :
memcpy(data, &id, sizeof( id ));
data += sizeof( id );
+ LOG(log_debug, logtype_afpd, "metadata('%s'): CNID: %u",
+ path->u_name, ntohl(id));
break;
case FILPBIT_DFLEN :
int opened = 0;
int rc;
-#ifdef DEBUG
- LOG(log_debug9, logtype_default, "begin getfilparams:");
-#endif /* DEBUG */
-
opened = PARAM_NEED_ADP(bitmap);
adp = NULL;
if ( adp ) {
ad_close_metadata( adp);
}
-#ifdef DEBUG
- LOG(log_debug9, logtype_afpd, "end getfilparams:");
-#endif /* DEBUG */
return( rc );
}
case FILPBIT_FINFO :
change_mdate = 1;
memcpy(finder_buf, buf, 32 );
+ if (memcmp(buf,"slnkrhap",8)==0 && !S_ISLNK(path->st.st_mode)){
+ // SLFINFO
+ 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;
+ erc = symlink(buf, path->u_name);
+ if (!erc)
+ of_stat(path);
+ }
+ }
+ close(fp);
+ }
+ if (erc!=0){
+ err=AFPERR_BITMAP;
+ goto setfilparam_done;
+ }
+ }
buf += 32;
break;
case FILPBIT_UNIXPR :
* - change of modification date
* - UNIX privs (Bug-ID #2863424)
*/
- if ( (f_bitmap & ~(1<<FILPBIT_MDATE | 1<<FILPBIT_UNIXPR))) {
+ if (!vol_noadouble(vol) && (f_bitmap & ~(1<<FILPBIT_MDATE | 1<<FILPBIT_UNIXPR))) {
LOG(log_debug, logtype_afpd, "setfilparams: need adouble access");
- return vol_noadouble(vol) ? AFP_OK : AFPERR_ACCESS;
+ return AFPERR_ACCESS;
}
LOG(log_debug, logtype_afpd, "setfilparams: no adouble perms, but only FILPBIT_MDATE and/or FILPBIT_UNIXPR");
isad = 0;
* renamefile and copyfile take the old and new unix pathnames
* and the new mac name.
*
+ * sdir_fd source dir fd to which src path is relative (for openat et al semantics)
+ * passing -1 means this is not used, src path is a full path
* src the source path
* dst the dest filename in current dir
* newname the dest mac name
* adp adouble struct of src file, if open, or & zeroed one
*
*/
-int renamefile(const struct vol *vol, char *src, char *dst, char *newname, struct adouble *adp)
+int renamefile(const struct vol *vol, int sdir_fd, char *src, char *dst, char *newname, struct adouble *adp)
{
int rc;
-#ifdef DEBUG
- LOG(log_debug9, logtype_afpd, "begin renamefile:");
-#endif /* DEBUG */
-
- if ( unix_rename( src, dst ) < 0 ) {
+ if ( unix_rename( sdir_fd, src, -1, dst ) < 0 ) {
switch ( errno ) {
case ENOENT :
return( AFPERR_NOOBJ );
/* FIXME warning in syslog so admin'd know there's a conflict ?*/
return AFPERR_OLOCK; /* little lie */
}
- if (AFP_OK != ( rc = copyfile(vol, vol, src, dst, newname, NULL )) ) {
+ if (AFP_OK != ( rc = copyfile(vol, vol, sdir_fd, src, dst, newname, NULL )) ) {
/* on error copyfile delete dest */
return( rc );
}
- return deletefile(vol, src, 0);
+ return deletefile(vol, sdir_fd, src, 0);
default :
return( AFPERR_PARAM );
}
}
- if (vol->vfs->vfs_renamefile(vol, src, dst) < 0 ) {
+ if (vol->vfs->vfs_renamefile(vol, sdir_fd, src, dst) < 0 ) {
int err;
err = errno;
* we know we are on the same device
*/
if (err) {
- unix_rename( dst, src );
+ unix_rename(-1, dst, sdir_fd, src );
/* return the first error */
switch ( err) {
case ENOENT :
ad_flush( adp );
ad_close( adp, ADFLAGS_HF );
}
-#ifdef DEBUG
- LOG(log_debug9, logtype_afpd, "end renamefile:");
-#endif /* DEBUG */
return( AFP_OK );
}
}
denyreadset = (getforkmode(adp, ADEID_DFORK, AD_FILELOCK_DENY_RD) != 0 ||
getforkmode(adp, ADEID_RFORK, AD_FILELOCK_DENY_RD) != 0 );
- ad_close( adp, ADFLAGS_DF |ADFLAGS_HF );
+
if (denyreadset) {
- return AFPERR_DENYCONF;
+ retvalue = AFPERR_DENYCONF;
+ goto copy_exit;
}
newname = obj->newtmp;
p = ctoupath( s_vol, curdir, newname );
if (!p) {
- return AFPERR_PARAM;
-
+ retvalue = AFPERR_PARAM;
+ goto copy_exit;
}
+
#ifdef FORCE_UIDGID
/* FIXME svid != dvid && dvid's user can't read svid */
#endif
if (NULL == ( d_vol = getvolbyvid( dvid )) ) {
- return( AFPERR_PARAM );
+ retvalue = AFPERR_PARAM;
+ goto copy_exit;
}
- if (d_vol->v_flags & AFPVOL_RO)
- return AFPERR_VLOCK;
+ if (d_vol->v_flags & AFPVOL_RO) {
+ retvalue = AFPERR_VLOCK;
+ goto copy_exit;
+ }
if (NULL == ( dir = dirlookup( d_vol, ddid )) ) {
- return afp_errno;
+ retvalue = afp_errno;
+ goto copy_exit;
}
if (( s_path = cname( d_vol, dir, &ibuf )) == NULL ) {
- return get_afp_errno(AFPERR_NOOBJ);
+ retvalue = get_afp_errno(AFPERR_NOOBJ);
+ goto copy_exit;
}
+
if ( *s_path->m_name != '\0' ) {
- path_error(s_path, AFPERR_PARAM);
+ retvalue =path_error(s_path, AFPERR_NOOBJ);
+ goto copy_exit;
}
/* one of the handful of places that knows about the path type */
if (copy_path_name(d_vol, newname, ibuf) < 0) {
- return( AFPERR_PARAM );
+ 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()))) {
- return( AFPERR_PARAM );
+ retvalue =AFPERR_PARAM;
+ goto copy_exit;
}
- if ( (err = copyfile(s_vol, d_vol, p, upath , newname, adp)) < 0 ) {
- return err;
+
+ if ( (err = copyfile(s_vol, d_vol, -1, p, upath , newname, adp)) < 0 ) {
+ retvalue = err;
+ goto copy_exit;
}
curdir->offcnt++;
setvoltime(obj, d_vol );
+copy_exit:
+ ad_close( adp, ADFLAGS_DF |ADFLAGS_HF );
return( retvalue );
}
* because we are doing it elsewhere.
* currently if newname is NULL then adp is NULL.
*/
-int copyfile(const struct vol *s_vol, const struct vol*d_vol,
- char *src, char *dst, char *newname, struct adouble *adp)
+int copyfile(const struct vol *s_vol,
+ const struct vol *d_vol,
+ int sfd,
+ char *src,
+ char *dst,
+ char *newname,
+ struct adouble *adp)
{
struct adouble ads, add;
int err = 0;
int stat_result;
struct stat st;
-#ifdef DEBUG
- LOG(log_debug9, logtype_afpd, "begin copyfile:");
-#endif /* DEBUG */
+ LOG(log_debug, logtype_afpd, "copyfile(sfd:%d,s:'%s',d:'%s',n:'%s')",
+ sfd, src, dst, newname);
if (adp == NULL) {
ad_init(&ads, s_vol->v_adouble, s_vol->v_ad_options);
adp = &ads;
}
- ad_init(&add, d_vol->v_adouble, d_vol->v_ad_options);
+
adflags = ADFLAGS_DF;
if (newname) {
adflags |= ADFLAGS_HF;
}
- if (ad_open(src , adflags | ADFLAGS_NOHF, O_RDONLY, 0, adp) < 0) {
+ if (ad_openat(sfd, src, adflags | ADFLAGS_NOHF, O_RDONLY, 0, adp) < 0) {
ret_err = errno;
goto done;
}
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) {
ret_err = errno;
ad_close( adp, adflags );
if (EEXIST != ret_err) {
- deletefile(d_vol, dst, 0);
+ deletefile(d_vol, -1, dst, 0);
goto done;
}
return AFPERR_EXIST;
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, src, dst);
+ err = d_vol->vfs->vfs_copyfile(d_vol, sfd, src, dst);
}
}
}
if (ret_err) {
- deletefile(d_vol, dst, 0);
+ deletefile(d_vol, -1, dst, 0);
}
else if (stat_result == 0) {
/* set dest modification date to src date */
*/
}
-#ifdef DEBUG
- LOG(log_debug9, logtype_afpd, "end copyfile:");
-#endif /* DEBUG */
-
done:
switch ( ret_err ) {
case 0:
}
return 0;
}
-
-int deletefile(const struct vol *vol, char *file, int checkAttrib)
+/*
+ * dirfd can be used for unlinkat semantics
+ */
+int deletefile(const struct vol *vol, int dirfd, char *file, int checkAttrib)
{
struct adouble ad;
- struct adouble *adp = &ad;
+ struct adouble *adp = NULL;
int adflags, err = AFP_OK;
+ int meta = 0;
-#ifdef DEBUG
- LOG(log_debug9, logtype_afpd, "begin deletefile:");
-#endif /* DEBUG */
+ LOG(log_debug, logtype_afpd, "deletefile('%s')", file);
- /* try to open both forks at once */
- adflags = ADFLAGS_DF|ADFLAGS_HF;
+ ad_init(&ad, vol->v_adouble, vol->v_ad_options);
if (checkAttrib) {
/* was EACCESS error try to get only metadata */
- ad_init(&ad, vol->v_adouble, vol->v_ad_options);
/* 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_metadata( file, ADFLAGS_OPENFORKS, &ad) == 0 ) {
- ad_close( &ad, adflags );
+ if ( ad_metadataat(dirfd, file, ADFLAGS_OPENFORKS, &ad) == 0 ) {
if ((err = check_attrib(&ad))) {
+ ad_close_metadata(&ad);
return err;
}
+ meta = 1;
}
}
- while(1) {
- ad_init(&ad, vol->v_adouble, vol->v_ad_options); /* OK */
- if ( ad_open( file, adflags, O_RDONLY, 0, &ad ) < 0 ) {
- switch (errno) {
- case ENOENT:
- if (adflags == ADFLAGS_DF)
- return AFPERR_NOOBJ;
-
- /* that failed. now try to open just the data fork */
- adflags = ADFLAGS_DF;
- continue;
-
- case EACCES:
- adp = NULL; /* maybe it's a file with no write mode for us */
- break; /* was return AFPERR_ACCESS;*/
- case EROFS:
- return AFPERR_VLOCK;
- default:
- return( AFPERR_PARAM );
- }
+ /* 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 ) {
+ switch (errno) {
+ case ENOENT:
+ err = AFPERR_NOOBJ;
+ goto end;
+ case EACCES: /* maybe it's a file with no write mode for us */
+ break; /* was return AFPERR_ACCESS;*/
+ case EROFS:
+ err = AFPERR_VLOCK;
+ goto end;
+ default:
+ err = AFPERR_PARAM;
+ goto end;
}
- break; /* from the while */
+ }
+ else {
+ adp = &ad;
}
- if (adp && (adflags & ADFLAGS_HF) ) {
+ if ( adp && ad_reso_fileno( adp ) != -1 ) { /* there's a resource fork */
+ adflags |= ADFLAGS_HF;
/* 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.
* FIXME it doesn't work for RFORK open read only and fork open without deny mode
*/
if (ad_tmplock(&ad, ADEID_RFORK, ADLOCK_WR |ADLOCK_FILELOCK, 0, 0, 0) < 0 ) {
- ad_close( &ad, adflags );
- return( AFPERR_BUSY );
+ err = AFPERR_BUSY;
+ goto end;
}
}
if (adp && ad_tmplock( &ad, ADEID_DFORK, ADLOCK_WR, 0, 0, 0 ) < 0) {
err = AFPERR_BUSY;
- }
- else if (!(err = vol->vfs->vfs_deletefile(vol, file)) && !(err = netatalk_unlink( file )) ) {
+ } else if (!(err = vol->vfs->vfs_deletefile(vol, dirfd, file)) && !(err = netatalk_unlinkat(dirfd, file )) ) {
cnid_t id;
- if (checkAttrib && (id = cnid_get(vol->v_cdb, curdir->d_did, file, strlen(file))))
- {
+ if (checkAttrib && (id = cnid_get(vol->v_cdb, curdir->d_did, file, strlen(file)))) {
cnid_delete(vol->v_cdb, id);
}
}
+
+end:
+ if (meta)
+ ad_close_metadata(&ad);
+
if (adp)
ad_close( &ad, adflags ); /* ad_close removes locks if any */
-#ifdef DEBUG
- LOG(log_debug9, logtype_afpd, "end deletefile:");
-#endif /* DEBUG */
-
return err;
}
cnid_t did = param->did;
cnid_t aint;
- if ( stat(de->d_name, &path.st)<0 )
+ if ( lstat(de->d_name, &path.st)<0 )
return 0;
/* update or add to cnid */
}
/* FIXME use of_statdir ? */
- if (stat(name, &st)) {
+ if (lstat(name, &st)) {
return -1;
}
}
if (NULL == ( dir = dirlookup( vol, id )) ) {
+ if (afp_errno == AFPERR_NOOBJ) {
+ err = AFPERR_NOOBJ;
+ goto delete;
+ }
return( AFPERR_PARAM );
}
err = AFP_OK;
- if ((movecwd(vol, dir) < 0) || (stat(upath, &st) < 0)) {
+ if ((movecwd(vol, dir) < 0) || (lstat(upath, &st) < 0)) {
switch (errno) {
case EACCES:
case EPERM:
else if (S_ISDIR(st.st_mode)) /* directories are bad */
return AFPERR_BADTYPE;
+delete:
if (cnid_delete(vol->v_cdb, fileid)) {
switch (errno) {
case EROFS:
}
/* now, quickly rename the file. we error if we can't. */
- if ((err = renamefile(vol, p, temp, temp, adsp)) != AFP_OK)
+ if ((err = renamefile(vol, -1, p, temp, temp, adsp)) != AFP_OK)
goto err_exchangefile;
of_rename(vol, s_of, sdir, spath, curdir, temp);
/* rename destination to source */
- if ((err = renamefile(vol, upath, p, spath, addp)) != AFP_OK)
+ if ((err = renamefile(vol, -1, upath, p, spath, addp)) != AFP_OK)
goto err_src_to_tmp;
of_rename(vol, d_of, curdir, path->m_name, sdir, spath);
/* rename temp to destination */
- if ((err = renamefile(vol, temp, upath, path->m_name, adsp)) != AFP_OK)
+ if ((err = renamefile(vol, -1, temp, upath, path->m_name, adsp)) != AFP_OK)
goto err_dest_to_src;
of_rename(vol, s_of, curdir, temp, curdir, path->m_name);
/* 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 ((did && ( (crossdev && stat( upath, &srcst) < 0) ||
+ 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))
||
- (sid && ( (crossdev && stat(p, &destst) < 0) ||
+ (sid && ( (crossdev && lstat(p, &destst) < 0) ||
cnid_update(vol->v_cdb, sid, &destst, sdir->d_did,supath, slen) < 0))
) {
switch (errno) {
* properly. */
err_temp_to_dest:
/* rename dest to temp */
- renamefile(vol, upath, temp, temp, adsp);
+ renamefile(vol, -1, upath, temp, temp, adsp);
of_rename(vol, s_of, curdir, upath, curdir, temp);
err_dest_to_src:
/* rename source back to dest */
- renamefile(vol, p, upath, path->m_name, addp);
+ renamefile(vol, -1, p, upath, path->m_name, addp);
of_rename(vol, d_of, sdir, spath, curdir, path->m_name);
err_src_to_tmp:
/* rename temp back to source */
- renamefile(vol, temp, p, spath, adsp);
+ renamefile(vol, -1, temp, p, spath, adsp);
of_rename(vol, s_of, curdir, temp, sdir, spath);
err_exchangefile:
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;
}