#include <atalk/unix.h>
#include <atalk/globals.h>
#include <atalk/fce_api.h>
+#include <atalk/netatalk_conf.h>
+#include <atalk/spotlight.h>
#include "directory.h"
#include "dircache.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, int islink)
{
- struct extmap *em;
+ struct extmap *em;
void *ad_finder = NULL;
int chk_ext = 0;
-
+
if (adp)
ad_finder = ad_entry(adp, ADEID_FINDERI);
}
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;
+ if (islink && !vol_syml_opt(vol)) {
+ 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. */
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 > UTF8FILELEN_EARLY) /* FIXME safeguard, anyway if no ascii char it's game over*/
aint = UTF8FILELEN_EARLY;
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) {
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 */
+ if (!(vol->v_flags & AFPVOL_TM)) {
+ vol->v_flags |= AFPVOL_RO;
+ 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);
+ }
+ goto restart; /* now 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;
goto exit;
}
}
- else if (adp && (adcnid != dbcnid)) { /* 4 */
+ else if (adp && adcnid && (adcnid != dbcnid)) { /* 4 */
/* Update the ressource fork. For a folder adp is always null */
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);
+ if (ad_flush(adp) != 0)
+ LOG(log_error, logtype_afpd, "get_id(\"%s\"): can't flush", fullpathname(upath));
}
}
}
}
/* -------------------------- */
-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;
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;
/* 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");
return AFPERR_MISC;
}
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,
- struct path *path, struct dir *dir,
- char *buf, size_t *buflen )
+int getfilparams(const AFPObj *obj, struct vol *vol, uint16_t bitmap, struct path *path,
+ struct dir *dir, char *buf, size_t *buflen, int in_enumerate)
{
struct adouble ad, *adp;
int opened = 0;
int rc;
+ int flags; /* uninitialized ok */
LOG(log_debug, logtype_afpd, "getfilparams(\"%s\")", path->u_name);
if (opened) {
char *upath;
- int flags = (bitmap & (1 << FILPBIT_ATTR)) ? ADFLAGS_CHECK_OF : 0;
+ /*
+ * Dont check for and resturn open fork attributes when enumerating
+ * This saves a lot of syscalls, the client will hopefully only use the result
+ * in FPGetFileParms where we return the correct value
+ */
+ flags = (!in_enumerate &&(bitmap & (1 << FILPBIT_ATTR))) ? ADFLAGS_CHECK_OF : 0;
adp = of_ad(vol, path, &ad);
upath = path->u_name;
}
}
}
- rc = getmetadata(vol, bitmap, path, dir, buf, buflen, adp);
- ad_close_metadata( adp);
+ rc = getmetadata(obj, vol, bitmap, path, dir, buf, buflen, adp);
+
+ if (opened)
+ ad_close(adp, ADFLAGS_HF | flags);
return( rc );
}
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;
if (NULL == ( s_path = cname( vol, dir, &ibuf )) )
return get_afp_errno(AFPERR_PARAM);
-
if ( *s_path->m_name == '\0' )
return( AFPERR_BADTYPE );
upath = s_path->u_name;
- ad_init(&ad, vol->v_adouble, vol->v_ad_options);
+ ad_init(&ad, vol);
/* if upath is deleted we already in trouble anyway */
- if ((of = of_findname(s_path))) {
+ if ((of = of_findname(vol, s_path))) {
if (creatf)
return AFPERR_BUSY;
else
return AFPERR_EXIST;
}
- if ( creatf)
- openf = O_RDWR|O_CREAT|O_TRUNC;
+ 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 = O_RDWR|O_CREAT|O_EXCL;
+ openf = ADFLAGS_RDWR | ADFLAGS_CREATE | ADFLAGS_EXCL;
- if ( ad_open(&ad, upath, ADFLAGS_DF | ADFLAGS_HF | ADFLAGS_NOHF,
- openf, 0666, openf, 0666) < 0 ) {
+ if (ad_open(&ad, upath, ADFLAGS_DF | ADFLAGS_HF | ADFLAGS_NOHF | openf, 0666) < 0) {
switch ( errno ) {
case EROFS:
return AFPERR_VLOCK;
return( AFPERR_ACCESS );
case EDQUOT:
case ENOSPC :
+ LOG(log_info, logtype_afpd, "afp_createfile: DISK FULL");
return( AFPERR_DFULL );
default :
return( AFPERR_PARAM );
}
}
if ( ad_meta_fileno( &ad ) == -1 ) { /* Hard META / HF */
- /* on noadouble volumes, just creating the data fork is ok */
- if (vol_noadouble(vol)) {
- ad_close( &ad, ADFLAGS_DF );
- goto createfile_done;
- }
/* FIXME with hard create on an existing file, we already
* corrupted the data file.
*/
return AFPERR_MISC;
}
- (void)get_id(vol, &ad, &st, dir->d_did, upath, strlen(upath));
+ cnid_t id;
+ if ((id = get_id(vol, &ad, &st, dir->d_did, upath, strlen(upath))) == CNID_INVALID) {
+ LOG(log_error, logtype_afpd, "afp_createfile(\"%s\"): CNID error", upath);
+ goto createfile_iderr;
+ }
+ (void)ad_setid(&ad, st.st_dev, st.st_ino, id, dir->d_did, vol->v_stamp);
+createfile_iderr:
ad_flush(&ad);
ad_close(&ad, ADFLAGS_DF|ADFLAGS_HF );
- fce_register_new_file(s_path);
+ fce_register(FCE_FILE_CREATE, fullpathname(upath), NULL, fce_file);
+ sl_index_file(path);
-createfile_done:
curdir->d_offcnt++;
-
setvoltime(obj, vol );
return (retvalue);
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 = S_ISLNK(path->st.st_mode);
+ int fp;
+ ssize_t len;
+ char symbuf[MAXPATHLEN+1];
#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;
}
break;
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 (memcmp(buf,"slnkrhap",8) == 0
+ && !(S_ISLNK(path->st.st_mode))
+ && !(vol->v_flags & AFPVOL_FOLLOWSYM)) {
+ /* request to turn this into a symlink */
+ if ((fp = open(path->u_name, O_RDONLY)) == -1) {
+ err = AFPERR_MISC;
+ goto setfilparam_done;
+ }
+ len = read(fp, symbuf, MAXPATHLEN);
+ close(fp);
+ if (!(len > 0)) {
+ err = AFPERR_MISC;
+ goto setfilparam_done;
}
- if (erc!=0){
- err=AFPERR_BITMAP;
+ if (unlink(path->u_name) != 0) {
+ err = AFPERR_MISC;
goto setfilparam_done;
}
+ symbuf[len] = 0;
+ if (symlink(symbuf, path->u_name) != 0) {
+ err = AFPERR_MISC;
+ goto setfilparam_done;
+ }
+ of_stat(vol, path);
+ symlinked = 1;
}
+ memcpy(finder_buf, buf, 32 );
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 */
achar = *buf;
buf += 2;
/* Keep special case to support crlf translations */
/* second try with adouble open
*/
- if ( ad_open(adp, upath, ADFLAGS_HF, O_RDWR | O_CREAT, 0666) < 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;
}
isad = 0;
} else if ((ad_get_MD_flags( adp ) & O_CREAT) ) {
ad_setname(adp, path->m_name);
+ cnid_t id;
+ if ((id = get_id(vol, adp, &path->st, curdir->d_did, upath, strlen(upath))) == CNID_INVALID) {
+ LOG(log_error, logtype_afpd, "afp_createfile(\"%s\"): CNID error", upath);
+ return AFPERR_MISC;
+ }
+ (void)ad_setid(adp, path->st.st_dev, path->st.st_ino, id, curdir->d_did, vol->v_stamp);
}
bit = 0;
}
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) {
* adp adouble struct of src file, if open, or & zeroed one
*
*/
-int renamefile(const struct vol *vol, int sdir_fd, char *src, char *dst, char *newname, struct adouble *adp)
+int renamefile(struct vol *vol, struct dir *ddir, int sdir_fd, char *src, char *dst, char *newname, struct adouble *adp)
{
int rc;
/* FIXME warning in syslog so admin'd know there's a conflict ?*/
return AFPERR_OLOCK; /* little lie */
}
- if (AFP_OK != ( rc = copyfile(vol, vol, sdir_fd, src, dst, newname, NULL )) ) {
+ if (AFP_OK != ( rc = copyfile(vol, vol, ddir, sdir_fd, src, dst, newname, NULL )) ) {
/* on error copyfile delete dest */
return( rc );
}
}
/* don't care if we can't open the newly renamed ressource fork */
- if (ad_open(adp, dst, ADFLAGS_HF, O_RDWR) == 0) {
+ 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(adp, s_path->u_name, ADFLAGS_DF | ADFLAGS_HF | ADFLAGS_NOHF, O_RDONLY, O_RDONLY) < 0) {
+ if (ad_open(adp, s_path->u_name, ADFLAGS_DF | ADFLAGS_HF | ADFLAGS_NOHF | ADFLAGS_RDONLY | ADFLAGS_SETSHRMD) < 0) {
return AFPERR_DENYCONF;
}
+#ifdef HAVE_FSHARE_T
+ fshare_t shmd;
+ shmd.f_access = F_RDACC;
+ shmd.f_deny = F_NODNY;
+ if (fcntl(ad_data_fileno(adp), F_SHARE, &shmd) != 0) {
+ retvalue = AFPERR_DENYCONF;
+ goto copy_exit;
+ }
+ if (AD_RSRC_OPEN(adp) && fcntl(ad_reso_fileno(adp), F_SHARE, &shmd) != 0) {
+ retvalue = AFPERR_DENYCONF;
+ goto copy_exit;
+ }
+#endif
denyreadset = (ad_testlock(adp, ADEID_DFORK, AD_FILELOCK_DENY_RD) != 0 ||
ad_testlock(adp, ADEID_RFORK, AD_FILELOCK_DENY_RD) != 0 );
/* 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;
}
- if ( (err = copyfile(s_vol, d_vol, -1, p, upath , newname, adp)) < 0 ) {
+ if ( (err = copyfile(s_vol, d_vol, curdir, -1, p, upath , newname, adp)) < 0 ) {
retvalue = err;
goto copy_exit;
}
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.
* currently if newname is NULL then adp is NULL.
*/
-int copyfile(const struct vol *s_vol,
- const struct vol *d_vol,
+int copyfile(struct vol *s_vol,
+ struct vol *d_vol,
+ struct dir *d_dir,
int sfd,
char *src,
char *dst,
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_HF | ADFLAGS_NOHF | ADFLAGS_RF | ADFLAGS_NORF;
- if (ad_openat(adp, sfd, src, adflags | ADFLAGS_NOHF, O_RDONLY, O_RDONLY) < 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_META_OPEN(adp))
/* no resource fork, don't create one for dst file */
adflags &= ~ADFLAGS_HF;
- }
+
+ if (!AD_RSRC_OPEN(adp))
+ /* no resource fork, don't create one for dst file */
+ 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(&add, dst, adflags, O_RDWR|O_CREAT|O_EXCL, st.st_mode, O_RDWR|O_CREAT|O_EXCL, st.st_mode) < 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 */
- ad_copy_header(&add, adp);
- ad_setname(&add, newname);
- ad_flush( &add );
+ if (AD_META_OPEN(&add)) {
+ if (AD_META_OPEN(adp))
+ ad_copy_header(&add, adp);
+ ad_setname(&add, dst);
+ cnid_t id;
+ struct stat stdest;
+ if (fstat(ad_meta_fileno(&add), &stdest) != 0) {
+ ret_err = errno;
+ goto error;
+ }
+ if ((id = get_id(d_vol, &add, &stdest, d_dir->d_did, dst, strlen(dst))) == CNID_INVALID) {
+ ret_err = EINVAL;
+ goto error;
+ }
+ (void)ad_setid(&add, stdest.st_dev, stdest.st_ino, id, d_dir->d_did, d_vol->v_stamp);
+ ad_flush(&add);
}
+
+error:
ad_close( adp, adflags );
if (ad_close( &add, adflags ) <0) {
case EDQUOT:
case EFBIG:
case ENOSPC:
+ LOG(log_info, logtype_afpd, "copyfile: DISK FULL");
return AFPERR_DFULL;
case ENOENT:
return AFPERR_NOOBJ;
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
*/
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(&ad, dirfd, file, adflags |ADFLAGS_HF|ADFLAGS_NOHF, O_RDONLY, O_RDONLY) < 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 (ostat(de->d_name, &path.st, vol_syml_opt(vol)) < 0)
return 0;
/* update or add to cnid */
}
/* FIXME use of_statdir ? */
- if (lstat(name, &st)) {
+ if (ostat(name, &st, vol_syml_opt(vol))) {
return -1;
}
/* ------------------------------
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;
memset(&path, 0, sizeof(path));
path.u_name = upath;
- if ( of_stat(&path) < 0 ) {
+ if (of_stat(vol, &path) < 0 ) {
#ifdef ESTALE
/* with nfs and our working directory is deleted */
if (errno == ESTALE) {
/* 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, 0))) {
return err;
}
*rbuflen = buflen + sizeof(bitmap);
}
err = AFP_OK;
- if ((movecwd(vol, dir) < 0) || (lstat(upath, &st) < 0)) {
+ if ((movecwd(vol, dir) < 0) || (ostat(upath, &st, vol_syml_opt(vol)) < 0)) {
switch (errno) {
case EACCES:
case EPERM:
}
/* ------------------------------ */
-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;
}
- if ((*of = of_findname(path))) {
+ if ((*of = of_findname(vol, path))) {
/* reuse struct adouble so it won't break locks */
adp = (*of)->of_ad;
}
else {
- ret = ad_open(adp, path->u_name, ADFLAGS_HF, O_RDONLY);
+ 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;
-
- uid_t uid;
- gid_t gid;
+ uint32_t sid, did;
+ uint16_t vid;
*rbuflen = 0;
ibuf += 2;
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;
}
* NOTE: the temp file will be in the dest file's directory. it
* will also be inaccessible from AFP. */
memcpy(temp, APPLETEMP, sizeof(APPLETEMP));
- if (!mktemp(temp)) {
+ int fd;
+ if ((fd = mkstemp(temp)) == -1) {
err = AFPERR_MISC;
goto err_exchangefile;
}
-
+ close(fd);
+
if (crossdev) {
/* FIXME we need to close fork for copy, both s_of and d_of are null */
ad_close(adsp, ADFLAGS_HF);
}
/* now, quickly rename the file. we error if we can't. */
- if ((err = renamefile(vol, -1, p, temp, temp, adsp)) != AFP_OK)
+ if ((err = renamefile(vol, curdir, -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, -1, upath, p, spath, addp)) != AFP_OK)
+ if ((err = renamefile(vol, curdir, -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, -1, temp, upath, path->m_name, adsp)) != AFP_OK)
+ if ((err = renamefile(vol, curdir, -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);
if (did)
cnid_delete(vol->v_cdb, did);
- if ((did && ( (crossdev && lstat( upath, &srcst) < 0) ||
+ if ((did && ( (crossdev && ostat(upath, &srcst, vol_syml_opt(vol)) < 0) ||
cnid_update(vol->v_cdb, did, &srcst, curdir->d_did,upath, dlen) < 0))
||
- (sid && ( (crossdev && lstat(p, &destst) < 0) ||
+ (sid && ( (crossdev && ostat(p, &destst, vol_syml_opt(vol)) < 0) ||
cnid_update(vol->v_cdb, sid, &destst, sdir->d_did,supath, slen) < 0))
) {
switch (errno) {
/* change perms, src gets dest perm and vice versa */
- uid = geteuid();
- gid = getegid();
- if (seteuid(0)) {
- LOG(log_error, logtype_afpd, "seteuid failed %s", strerror(errno));
- err = AFP_OK; /* ignore error */
- goto err_temp_to_dest;
- }
+ become_root();
/*
* we need to exchange ACL entries as well
setfilunixmode(vol, path, srcst.st_mode);
setfilowner(vol, srcst.st_uid, srcst.st_gid, path);
- if ( setegid(gid) < 0 || seteuid(uid) < 0) {
- LOG(log_error, logtype_afpd, "can't seteuid back %s", strerror(errno));
- exit(EXITERR_SYS);
- }
+ unbecome_root();
err = AFP_OK;
goto err_exchangefile;
* properly. */
err_temp_to_dest:
/* rename dest to temp */
- renamefile(vol, -1, upath, temp, temp, adsp);
+ renamefile(vol, curdir, -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, -1, p, upath, path->m_name, addp);
+ renamefile(vol, curdir, -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, -1, temp, p, spath, adsp);
+ renamefile(vol, curdir, -1, temp, p, spath, adsp);
of_rename(vol, s_of, curdir, temp, sdir, spath);
err_exchangefile:
projects / netatalk.git / blobdiff