#include <atalk/logger.h>
#include <atalk/util.h>
#include <atalk/cnid.h>
+#include <atalk/bstrlib.h>
#include <atalk/bstradd.h>
#include <atalk/globals.h>
#include <atalk/netatalk_conf.h>
+#include <atalk/ea.h>
#include "fork.h"
#include "file.h"
vol = ofork->of_vol;
dir = dirlookup(vol, ofork->of_did);
- if (NULL == (path.u_name = mtoupath(vol, of_name(ofork), dir->d_did, utf8_encoding()))) {
+ if (NULL == (path.u_name = mtoupath(vol, of_name(ofork), dir->d_did, utf8_encoding(obj)))) {
return( AFPERR_MISC );
}
path.m_name = of_name(ofork);
return 0;
}
-static int fork_setmode(struct adouble *adp, int eid, int access, int ofrefnum)
+static int fork_setmode(const AFPObj *obj, struct adouble *adp, int eid, int access, int ofrefnum)
{
int ret;
int readset;
int denyreadset;
int denywriteset;
+#ifdef HAVE_FSHARE_T
+ fshare_t shmd;
+
+ if (obj->options.flags & OPTION_SHARE_RESERV) {
+ shmd.f_access = (access & OPENACC_RD ? F_RDACC : 0) | (access & OPENACC_WR ? F_WRACC : 0);
+ if (shmd.f_access == 0)
+ /* we must give an access mode, otherwise fcntl will complain */
+ shmd.f_access = F_RDACC;
+ shmd.f_deny = (access & OPENACC_DRD ? F_RDDNY : F_NODNY) | (access & OPENACC_DWR) ? F_WRDNY : 0;
+ shmd.f_id = ofrefnum;
+
+ int fd = (eid == ADEID_DFORK) ? ad_data_fileno(adp) : ad_reso_fileno(adp);
+
+ if (fd != -1 && fd != AD_SYMLINK && fcntl(fd, F_SHARE, &shmd) != 0) {
+ LOG(log_debug, logtype_afpd, "fork_setmode: fcntl: %s", strerror(errno));
+ errno = EACCES;
+ return -1;
+ }
+ }
+#endif
+
if (! (access & (OPENACC_WR | OPENACC_RD | OPENACC_DWR | OPENACC_DRD))) {
return ad_lock(adp, eid, ADLOCK_RD | ADLOCK_FILELOCK, AD_FILELOCK_OPEN_NONE, 1, ofrefnum);
}
struct stat *st;
uint16_t bshort;
struct path *s_path;
- struct stat xxx;
ibuf++;
fork = *ibuf++;
LOG(log_error, logtype_afpd, "afp_openfork(%s): %s", s_path->m_name, strerror(errno));
return AFPERR_PARAM;
}
- /* FIXME should we check it first ? */
+
upath = s_path->u_name;
+ path = s_path->m_name;
+ st = &s_path->st;
+
if (!vol_unix_priv(vol)) {
if (check_access(obj, vol, upath, access ) < 0) {
return AFPERR_ACCESS;
}
}
- st = &s_path->st;
- /* XXX: this probably isn't the best way to do this. the already
- open bits should really be set if the fork is opened by any
- program, not just this one. however, that's problematic to do
- if we can't write lock files somewhere. opened is also passed to
- ad_open so that we can keep file locks together.
- FIXME: add the fork we are opening?
- */
- if ((opened = of_findname(s_path))) {
+ if ((opened = of_findname(vol, s_path))) {
adsame = opened->of_ad;
}
- if ( fork == OPENFORK_DATA ) {
+ adflags = ADFLAGS_SETSHRMD;
+
+ if (fork == OPENFORK_DATA) {
eid = ADEID_DFORK;
- adflags = ADFLAGS_DF | ADFLAGS_HF | ADFLAGS_NOHF;
+ adflags |= ADFLAGS_DF;
} else {
eid = ADEID_RFORK;
- adflags = ADFLAGS_RF | ADFLAGS_HF | ADFLAGS_NOHF;
- if (!(access & OPENACC_WR))
- adflags |= ADFLAGS_NORF;
+ adflags |= ADFLAGS_RF;
}
- path = s_path->m_name;
- if (( ofork = of_alloc(vol, curdir, path, &ofrefnum, eid,
- adsame, st)) == NULL ) {
- return( AFPERR_NFILE );
+ if (access & OPENACC_WR) {
+ adflags |= ADFLAGS_RDWR;
+ if (fork != OPENFORK_DATA)
+ /*
+ * We only try to create the resource
+ * fork if the user wants to open it for write acess.
+ */
+ adflags |= ADFLAGS_CREATE;
+ } else {
+ adflags |= ADFLAGS_RDONLY;
}
+ if ((ofork = of_alloc(vol, curdir, path, &ofrefnum, eid, adsame, st)) == NULL)
+ return AFPERR_NFILE;
+
LOG(log_debug, logtype_afpd, "afp_openfork(\"%s\", %s, %s)",
fullpathname(s_path->u_name),
(fork == OPENFORK_DATA) ? "data" : "reso",
!(access & OPENACC_WR) ? "O_RDONLY" : "O_RDWR");
ret = AFPERR_NOOBJ;
+
+ /* First ad_open(), opens data or ressource fork */
+ if (ad_open(ofork->of_ad, upath, adflags, 0666) < 0) {
+ switch (errno) {
+ case EROFS:
+ ret = AFPERR_VLOCK;
+ case EACCES:
+ goto openfork_err;
+ case ENOENT:
+ goto openfork_err;
+ case EMFILE :
+ case ENFILE :
+ ret = AFPERR_NFILE;
+ goto openfork_err;
+ case EISDIR :
+ ret = AFPERR_BADTYPE;
+ goto openfork_err;
+ default:
+ LOG(log_error, logtype_afpd, "afp_openfork(%s): ad_open: %s", s_path->m_name, strerror(errno) );
+ ret = AFPERR_PARAM;
+ goto openfork_err;
+ }
+ }
+
+ /*
+ * Create metadata if we open rw, otherwise only open existing metadata
+ */
if (access & OPENACC_WR) {
- /* try opening in read-write mode */
- if (ad_open(ofork->of_ad, upath,
- adflags | ADFLAGS_RDWR | ADFLAGS_SETSHRMD) < 0) {
- switch ( errno ) {
- case EROFS:
- ret = AFPERR_VLOCK;
- case EACCES:
- goto openfork_err;
- case ENOENT:
- if (fork == OPENFORK_DATA) {
- /* try to open only the data fork */
- if (ad_open(ofork->of_ad, upath,
- ADFLAGS_DF | ADFLAGS_RDWR | ADFLAGS_SETSHRMD) < 0) {
- goto openfork_err;
- }
- adflags = ADFLAGS_DF;
- } else {
- /* here's the deal. we only try to create the resource
- * fork if the user wants to open it for write acess. */
- if (ad_open(ofork->of_ad, upath,
- adflags | ADFLAGS_RDWR | ADFLAGS_SETSHRMD | ADFLAGS_CREATE, 0666) < 0)
- goto openfork_err;
- ofork->of_flags |= AFPFORK_META;
- }
- break;
- case EMFILE :
- case ENFILE :
- ret = AFPERR_NFILE;
- goto openfork_err;
- case EISDIR :
- ret = AFPERR_BADTYPE;
- goto openfork_err;
- default:
- LOG(log_error, logtype_afpd, "afp_openfork(%s): ad_open: %s", s_path->m_name, strerror(errno) );
- ret = AFPERR_PARAM;
+ adflags = ADFLAGS_HF | ADFLAGS_RDWR | ADFLAGS_CREATE;
+ } else {
+ adflags = ADFLAGS_HF | ADFLAGS_RDONLY;
+ }
+
+ if (ad_open(ofork->of_ad, upath, adflags, 0666) == 0) {
+ ofork->of_flags |= AFPFORK_META;
+ if (ad_get_MD_flags(ofork->of_ad) & O_CREAT) {
+ LOG(log_debug, logtype_afpd, "afp_openfork(\"%s\"): setting CNID", upath);
+ cnid_t id;
+ if ((id = get_id(vol, ofork->of_ad, st, dir->d_did, upath, strlen(upath))) == CNID_INVALID) {
+ LOG(log_error, logtype_afpd, "afp_createfile(\"%s\"): CNID error", upath);
goto openfork_err;
}
- }
- else {
- /* the ressource fork is open too */
- ofork->of_flags |= AFPFORK_META;
+ (void)ad_setid(ofork->of_ad, st->st_dev, st->st_ino, id, dir->d_did, vol->v_stamp);
+ ad_flush(ofork->of_ad);
}
} else {
- /* try opening in read-only mode */
- ret = AFPERR_NOOBJ;
- if (ad_open(ofork->of_ad, upath, adflags | ADFLAGS_RDONLY | ADFLAGS_SETSHRMD) < 0) {
- switch ( errno ) {
- case EROFS:
- ret = AFPERR_VLOCK;
- goto openfork_err;
- case EACCES:
- goto openfork_err;
- case ENOENT:
- /* see if client asked for a read only data fork */
- if (fork == OPENFORK_DATA) {
- if (ad_open(ofork->of_ad, upath, ADFLAGS_DF | ADFLAGS_RDONLY | ADFLAGS_SETSHRMD) < 0) {
- goto openfork_err;
- }
- adflags = ADFLAGS_DF;
- }
- /* else we don't set AFPFORK_META because there's no ressource fork file
- * We need to check AFPFORK_META in afp_closefork(). eg fork open read-only
- * then create in open read-write.
- * FIXME , it doesn't play well with byte locking example:
- * ressource fork open read only
- * locking set on it (no effect, there's no file!)
- * ressource fork open read write now
- */
- break;
- case EMFILE :
- case ENFILE :
- ret = AFPERR_NFILE;
- goto openfork_err;
- case EISDIR :
- ret = AFPERR_BADTYPE;
- goto openfork_err;
- default:
- LOG(log_error, logtype_afpd, "afp_openfork(\"%s\"): %s",
- fullpathname(s_path->m_name), strerror(errno) );
- goto openfork_err;
- }
- } else {
- ofork->of_flags |= AFPFORK_META;
+ switch (errno) {
+ case EACCES:
+ case ENOENT:
+ /* no metadata? We don't care! */
+ break;
+ case EROFS:
+ ret = AFPERR_VLOCK;
+ case EMFILE :
+ case ENFILE :
+ ret = AFPERR_NFILE;
+ goto openfork_err;
+ case EISDIR :
+ ret = AFPERR_BADTYPE;
+ goto openfork_err;
+ default:
+ LOG(log_error, logtype_afpd, "afp_openfork(%s): ad_open: %s", s_path->m_name, strerror(errno) );
+ ret = AFPERR_PARAM;
+ goto openfork_err;
}
}
ad_getattr(ofork->of_ad, &bshort);
if ((bshort & htons(ATTRBIT_NOWRITE)) && (access & OPENACC_WR)) {
ad_close( ofork->of_ad, adflags | ADFLAGS_SETSHRMD);
- of_dealloc( ofork );
+ of_dealloc(ofork);
ofrefnum = 0;
memcpy(rbuf, &ofrefnum, sizeof(ofrefnum));
return(AFPERR_OLOCK);
if ((eid == ADEID_DFORK)
|| (ad_reso_fileno(ofork->of_ad) != -1)
|| (ofork->of_ad->ad_vers == AD_VERSION_EA)) {
- ret = fork_setmode(ofork->of_ad, eid, access, ofrefnum);
+ ret = fork_setmode(obj, ofork->of_ad, eid, access, ofrefnum);
/* can we access the fork? */
if (ret < 0) {
ofork->of_flags |= AFPFORK_ERROR;
ret = errno;
ad_close( ofork->of_ad, adflags | ADFLAGS_SETSHRMD);
- of_dealloc( ofork );
+ of_dealloc(ofork);
switch (ret) {
case EAGAIN: /* return data anyway */
case EACCES:
if ((access & OPENACC_RD))
ofork->of_flags |= AFPFORK_ACCRD;
+ LOG(log_debug, logtype_afpd, "afp_openfork(\"%s\"): fork: %" PRIu16,
+ fullpathname(s_path->m_name), ofork->of_refnum);
+
memcpy(rbuf, &ofrefnum, sizeof(ofrefnum));
return( AFP_OK );
openfork_err:
- of_dealloc( ofork );
+ of_dealloc(ofork);
if (errno == EACCES)
return (access & OPENACC_WR) ? AFPERR_LOCK : AFPERR_ACCESS;
return ret;
}
-int afp_setforkparams(AFPObj *obj _U_, char *ibuf, size_t ibuflen, char *rbuf _U_, size_t *rbuflen)
+int afp_setforkparams(AFPObj *obj, char *ibuf, size_t ibuflen, char *rbuf _U_, size_t *rbuflen)
{
struct ofork *ofork;
off_t size;
is64 = 0;
if ((bitmap & ( (1<<FILPBIT_EXTDFLEN) | (1<<FILPBIT_EXTRFLEN) ))) {
- if (afp_version >= 30) {
+ if (obj->afp_version >= 30) {
is64 = 4;
}
else
ad_tmplock(ofork->of_ad, eid, ADLOCK_WR, size, st_size -size, ofork->of_refnum) < 0) {
goto afp_setfork_err;
}
- err = ad_rtruncate(ofork->of_ad, size);
+
+ err = ad_rtruncate(ofork->of_ad, mtoupath(ofork->of_vol, of_name(ofork), ofork->of_did, utf8_encoding(obj)), size);
if (st_size > size)
ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, size, st_size -size, ofork->of_refnum);
if (err < 0)
case EDQUOT:
case EFBIG:
case ENOSPC:
+ LOG(log_error, logtype_afpd, "afp_setforkparams: DISK FULL");
return AFPERR_DFULL;
default:
return AFPERR_PARAM;
#undef UNLOCKBIT
-static ssize_t read_file(struct ofork *ofork, int eid,
- off_t offset, u_char nlmask,
- u_char nlchar, char *rbuf,
- size_t *rbuflen)
+/*!
+ * Read *rbuflen bytes from fork at offset
+ *
+ * @param ofork (r) fork handle
+ * @param eid (r) data fork or ressource fork entry id
+ * @param offset (r) offset
+ * @param rbuf (r) data buffer
+ * @param rbuflen (rw) in: number of bytes to read, out: bytes read
+ *
+ * @return AFP status code
+ */
+static int read_file(const struct ofork *ofork, int eid, off_t offset, char *rbuf, size_t *rbuflen)
{
ssize_t cc;
- int eof = 0;
- char *p, *q;
cc = ad_read(ofork->of_ad, eid, offset, rbuf, *rbuflen);
if ( cc < 0 ) {
*rbuflen = 0;
return( AFPERR_PARAM );
}
- if ( (size_t)cc < *rbuflen ) {
- eof = 1;
- }
-
- /*
- * Do Newline check.
- */
- if ( nlmask != 0 ) {
- for ( p = rbuf, q = p + cc; p < q; ) {
- if (( *p++ & nlmask ) == nlchar ) {
- break;
- }
- }
- if ( p != q ) {
- cc = p - rbuf;
- eof = 0;
- }
- }
-
*rbuflen = cc;
- if ( eof ) {
- return( AFPERR_EOF );
- }
+
+ if ((size_t)cc < *rbuflen)
+ return AFPERR_EOF;
return AFP_OK;
}
-/* -----------------------------
- * with ddp, afp_read can return fewer bytes than in reqcount
- * so return EOF only if read actually past end of file not
- * if offset +reqcount > size of file
- * e.g.:
- * getfork size ==> 10430
- * read fork offset 0 size 10752 ???? ==> 4264 bytes (without EOF)
- * read fork offset 4264 size 6128 ==> 4264 (without EOF)
- * read fork offset 9248 size 1508 ==> 1182 (EOF)
- * 10752 is a bug in Mac 7.5.x finder
- *
- * with dsi, should we check that reqcount < server quantum?
- */
static int read_fork(AFPObj *obj, char *ibuf, size_t ibuflen _U_, char *rbuf, size_t *rbuflen, int is64)
{
- struct ofork *ofork;
- off_t offset, saveoff, reqcount, savereqcount;
- ssize_t cc, err;
- int eid;
- uint16_t ofrefnum;
- u_char nlmask, nlchar;
+ DSI *dsi = obj->dsi;
+ struct ofork *ofork;
+ off_t offset, saveoff, reqcount, savereqcount, size;
+ ssize_t cc, err;
+ int eid;
+ uint16_t ofrefnum;
+
+ /* we break the AFP spec here by not supporting nlmask and nlchar anymore */
ibuf += 2;
memcpy(&ofrefnum, ibuf, sizeof( ofrefnum ));
err = AFPERR_ACCESS;
goto afp_read_err;
}
- offset = get_off_t(&ibuf, is64);
- reqcount = get_off_t(&ibuf, is64);
-
- LOG(log_debug, logtype_afpd,
- "afp_read(off: %" PRIu64 ", size: %" PRIu64 ", fork: %s)", offset, reqcount,
- (ofork->of_flags & AFPFORK_DATA) ? "d" : "r");
-
- if (is64) {
- nlmask = nlchar = 0;
- }
- else {
- nlmask = *ibuf++;
- nlchar = *ibuf++;
- }
- /* if we wanted to be picky, we could add in the following
- * bit: if (afp_version == 11 && !(nlmask == 0xFF || !nlmask))
- */
- if (reqcount < 0 || offset < 0) {
- err = AFPERR_PARAM;
- goto afp_read_err;
- }
if ( ofork->of_flags & AFPFORK_DATA) {
eid = ADEID_DFORK;
goto afp_read_err;
}
+ offset = get_off_t(&ibuf, is64);
+ reqcount = get_off_t(&ibuf, is64);
+
/* zero request count */
err = AFP_OK;
if (!reqcount) {
goto afp_read_err;
}
- LOG(log_debug, logtype_afpd, "afp_read(name: \"%s\", offset: %jd, reqcount: %jd)",
- of_name(ofork), (intmax_t)offset, (intmax_t)reqcount);
+ AFP_READ_START((long)reqcount);
- savereqcount = reqcount;
- saveoff = offset;
- if (ad_tmplock(ofork->of_ad, eid, ADLOCK_RD, saveoff, savereqcount,ofork->of_refnum) < 0) {
- err = AFPERR_LOCK;
+ /* reqcount isn't always truthful. we need to deal with that. */
+ size = ad_size(ofork->of_ad, eid);
+
+ LOG(log_debug, logtype_afpd,
+ "afp_read(fork: %" PRIu16 " [%s], off: %" PRIu64 ", len: %" PRIu64 ", size: %" PRIu64 ")",
+ ofork->of_refnum, (ofork->of_flags & AFPFORK_DATA) ? "data" : "reso", offset, reqcount, size);
+
+ if (offset >= size) {
+ err = AFPERR_EOF;
goto afp_read_err;
}
- *rbuflen = MIN(reqcount, *rbuflen);
- LOG(log_debug, logtype_afpd, "afp_read(name: \"%s\", offset: %jd, reqcount: %jd): reading %jd bytes from file",
- of_name(ofork), (intmax_t)offset, (intmax_t)reqcount, (intmax_t)*rbuflen);
-
- err = read_file(ofork, eid, offset, nlmask, nlchar, rbuf, rbuflen);
- if (err < 0)
- goto afp_read_done;
- LOG(log_debug, logtype_afpd, "afp_read(name: \"%s\", offset: %jd, reqcount: %jd): got %jd bytes from file",
- of_name(ofork), (intmax_t)offset, (intmax_t)reqcount, (intmax_t)*rbuflen);
+ /* subtract off the offset */
+ if (reqcount + offset > size) {
+ reqcount = size - offset;
+ err = AFPERR_EOF;
+ }
- /* dsi can stream requests. we can only do this if we're not checking
- * for an end-of-line character. oh well. */
- if ((*rbuflen < reqcount) && !nlmask) {
- DSI *dsi = obj->dsi;
- off_t size;
+ savereqcount = reqcount;
+ saveoff = offset;
- /* reqcount isn't always truthful. we need to deal with that. */
- size = ad_size(ofork->of_ad, eid);
+ if (reqcount < 0 || offset < 0) {
+ err = AFPERR_PARAM;
+ goto afp_read_err;
+ }
- /* subtract off the offset */
- size -= offset;
- if (reqcount > size) {
- reqcount = size;
- err = AFPERR_EOF;
+ if (obj->options.flags & OPTION_AFP_READ_LOCK) {
+ if (ad_tmplock(ofork->of_ad, eid, ADLOCK_RD, offset, reqcount, ofork->of_refnum) < 0) {
+ err = AFPERR_LOCK;
+ goto afp_read_err;
}
+ }
- offset += *rbuflen;
-
- /* dsi_readinit() returns size of next read buffer. by this point,
- * we know that we're sending some data. if we fail, something
- * horrible happened. */
- if ((cc = dsi_readinit(dsi, rbuf, *rbuflen, reqcount, err)) < 0)
- goto afp_read_exit;
- *rbuflen = cc;
- /* due to the nature of afp packets, we have to exit if we get
- an error. we can't do this with translation on. */
#ifdef WITH_SENDFILE
- int fd;
-
- fd = ad_readfile_init(ofork->of_ad, eid, &offset, 0);
-
- if (dsi_stream_read_file(dsi, fd, offset, dsi->datasize) < 0) {
- if (errno == EINVAL || errno == ENOSYS)
- goto afp_read_loop;
- else {
- LOG(log_error, logtype_afpd, "afp_read(%s): ad_readfile: %s", of_name(ofork), strerror(errno));
- goto afp_read_exit;
- }
+ if (!(eid == ADEID_DFORK && ad_data_fileno(ofork->of_ad) == AD_SYMLINK) &&
+ !(obj->options.flags & OPTION_NOSENDFILE)) {
+ int fd = ad_readfile_init(ofork->of_ad, eid, &offset, 0);
+ if (dsi_stream_read_file(dsi, fd, offset, reqcount, err) < 0) {
+ LOG(log_error, logtype_afpd, "afp_read(%s): ad_readfile: %s",
+ of_name(ofork), strerror(errno));
+ goto afp_read_exit;
}
-
- dsi_readdone(dsi);
goto afp_read_done;
-
- afp_read_loop:
+ }
#endif
- /* fill up our buffer. */
- while (*rbuflen > 0) {
- cc = read_file(ofork, eid, offset, nlmask, nlchar, rbuf,rbuflen);
- if (cc < 0)
- goto afp_read_exit;
-
- offset += *rbuflen;
- /* dsi_read() also returns buffer size of next allocation */
- cc = dsi_read(dsi, rbuf, *rbuflen); /* send it off */
- if (cc < 0)
- goto afp_read_exit;
- *rbuflen = cc;
- }
- dsi_readdone(dsi);
+ *rbuflen = MIN(reqcount, dsi->server_quantum);
+
+ cc = read_file(ofork, eid, offset, ibuf, rbuflen);
+ if (cc < 0) {
+ err = cc;
goto afp_read_done;
+ }
+
+ LOG(log_debug, logtype_afpd,
+ "afp_read(name: \"%s\", offset: %jd, reqcount: %jd): got %jd bytes from file",
+ of_name(ofork), (intmax_t)offset, (intmax_t)reqcount, (intmax_t)*rbuflen);
+
+ offset += *rbuflen;
+
+ /*
+ * dsi_readinit() returns size of next read buffer. by this point,
+ * we know that we're sending some data. if we fail, something
+ * horrible happened.
+ */
+ if ((cc = dsi_readinit(dsi, ibuf, *rbuflen, reqcount, err)) < 0)
+ goto afp_read_exit;
+ *rbuflen = cc;
+
+ while (*rbuflen > 0) {
+ /*
+ * This loop isn't really entered anymore, we've already
+ * sent the whole requested block in dsi_readinit().
+ */
+ cc = read_file(ofork, eid, offset, ibuf, rbuflen);
+ if (cc < 0)
+ goto afp_read_exit;
- afp_read_exit:
- LOG(log_error, logtype_afpd, "afp_read(%s): %s", of_name(ofork), strerror(errno));
- dsi_readdone(dsi);
- ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, savereqcount,ofork->of_refnum);
- obj->exit(EXITERR_CLNT);
+ offset += *rbuflen;
+ /* dsi_read() also returns buffer size of next allocation */
+ cc = dsi_read(dsi, ibuf, *rbuflen); /* send it off */
+ if (cc < 0)
+ goto afp_read_exit;
+ *rbuflen = cc;
}
+ dsi_readdone(dsi);
+ goto afp_read_done;
+
+afp_read_exit:
+ LOG(log_error, logtype_afpd, "afp_read(%s): %s", of_name(ofork), strerror(errno));
+ dsi_readdone(dsi);
+ if (obj->options.flags & OPTION_AFP_READ_LOCK)
+ ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, savereqcount, ofork->of_refnum);
+ obj->exit(EXITERR_CLNT);
afp_read_done:
- ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, savereqcount,ofork->of_refnum);
+ if (obj->options.flags & OPTION_AFP_READ_LOCK)
+ ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, savereqcount, ofork->of_refnum);
+
+ AFP_READ_DONE();
return err;
afp_read_err:
return( err );
}
-int afp_closefork(AFPObj *obj _U_, char *ibuf, size_t ibuflen _U_, char *rbuf _U_, size_t *rbuflen)
+int afp_closefork(AFPObj *obj, char *ibuf, size_t ibuflen _U_, char *rbuf _U_, size_t *rbuflen)
{
struct ofork *ofork;
uint16_t ofrefnum;
return( AFPERR_PARAM );
}
- LOG(log_debug, logtype_afpd, "afp_closefork(fork: %s)",
- (ofork->of_flags & AFPFORK_DATA) ? "d" : "r");
+ LOG(log_debug, logtype_afpd, "afp_closefork(fork: %" PRIu16 " [%s])",
+ ofork->of_refnum, (ofork->of_flags & AFPFORK_DATA) ? "data" : "rsrc");
- if ( of_closefork( ofork ) < 0 ) {
- LOG(log_error, logtype_afpd, "afp_closefork(%s): of_closefork: %s", of_name(ofork), strerror(errno) );
+ if (of_closefork(obj, ofork) < 0 ) {
+ LOG(log_error, logtype_afpd, "afp_closefork: of_closefork: %s", strerror(errno) );
return( AFPERR_PARAM );
}
off_t offset, char *rbuf,
size_t rbuflen)
{
- char *p, *q;
ssize_t cc;
LOG(log_debug, logtype_afpd, "write_file(off: %ju, size: %zu)",
case EDQUOT :
case EFBIG :
case ENOSPC :
+ LOG(log_error, logtype_afpd, "write_file: DISK FULL");
return( AFPERR_DFULL );
case EACCES:
return AFPERR_ACCESS;
}
-/* FPWrite. NOTE: on an error, we always use afp_write_err as
+/*
+ * FPWrite. NOTE: on an error, we always use afp_write_err as
* the client may have sent us a bunch of data that's not reflected
- * in reqcount et al. */
+ * in reqcount et al.
+ */
static int write_fork(AFPObj *obj, char *ibuf, size_t ibuflen _U_, char *rbuf, size_t *rbuflen, int is64)
{
struct ofork *ofork;
- off_t offset, saveoff, reqcount, oldsize, newsize;
+ off_t offset, saveoff, reqcount, oldsize, newsize;
int endflag, eid, err = AFP_OK;
- uint16_t ofrefnum;
- ssize_t cc;
+ uint16_t ofrefnum;
+ ssize_t cc;
+ DSI *dsi = obj->dsi;
+ char *rcvbuf = (char *)dsi->commands;
+ size_t rcvbuflen = dsi->server_quantum;
/* figure out parameters */
ibuf++;
goto afp_write_err;
}
- LOG(log_debug, logtype_afpd, "afp_write(off: %" PRIu64 ", size: %" PRIu64 ", fork: %s)",
- offset, reqcount, (ofork->of_flags & AFPFORK_DATA) ? "d" : "r");
+ LOG(log_debug, logtype_afpd, "afp_write(fork: %" PRIu16 " [%s], off: %" PRIu64 ", size: %" PRIu64 ")",
+ ofork->of_refnum, (ofork->of_flags & AFPFORK_DATA) ? "data" : "reso", offset, reqcount);
if ((ofork->of_flags & AFPFORK_ACCWR) == 0) {
err = AFPERR_ACCESS;
/* offset can overflow on 64-bit capable filesystems.
* report disk full if that's going to happen. */
if (sum_neg(is64, offset, reqcount)) {
+ LOG(log_error, logtype_afpd, "write_fork: DISK FULL");
err = AFPERR_DFULL;
goto afp_write_err;
}
goto afp_write_err;
}
+ AFP_WRITE_START((long)reqcount);
+
saveoff = offset;
- if (ad_tmplock(ofork->of_ad, eid, ADLOCK_WR, saveoff,
- reqcount, ofork->of_refnum) < 0) {
- err = AFPERR_LOCK;
- goto afp_write_err;
+ if (obj->options.flags & OPTION_AFP_READ_LOCK) {
+ if (ad_tmplock(ofork->of_ad, eid, ADLOCK_WR, saveoff, reqcount, ofork->of_refnum) < 0) {
+ err = AFPERR_LOCK;
+ goto afp_write_err;
+ }
}
- DSI *dsi = obj->dsi;
- /* find out what we have already and write it out. */
- cc = dsi_writeinit(dsi, rbuf, *rbuflen);
-
- if (!cc || (cc = write_file(ofork, eid, offset, rbuf, cc)) < 0) {
- dsi_writeflush(dsi);
- *rbuflen = 0;
- ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, reqcount, ofork->of_refnum);
- return cc;
+ /* find out what we have already */
+ if ((cc = dsi_writeinit(dsi, rcvbuf, rcvbuflen)) > 0) {
+ ssize_t written;
+ if ((written = write_file(ofork, eid, offset, rcvbuf, cc)) != cc) {
+ dsi_writeflush(dsi);
+ *rbuflen = 0;
+ if (obj->options.flags & OPTION_AFP_READ_LOCK)
+ ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, reqcount, ofork->of_refnum);
+ if (written > 0)
+ /* It's used for the read size and as error code in write_file(), ugh */
+ written = AFPERR_MISC;
+ return written;
+ }
}
offset += cc;
-#if 0 /*def HAVE_SENDFILE_WRITE*/
- if (!(obj->options.flags & OPTION_DEBUG)) {
- if ((cc = ad_writefile(ofork->of_ad, eid, dsi->socket,
- offset, dsi->datasize)) < 0) {
+#ifdef WITH_RECVFILE
+ if (obj->options.flags & OPTION_RECVFILE) {
+ LOG(log_maxdebug, logtype_afpd, "afp_write(fork: %" PRIu16 " [%s], off: %" PRIu64 ", size: %" PRIu32 ")",
+ ofork->of_refnum, (ofork->of_flags & AFPFORK_DATA) ? "data" : "reso", offset, dsi->datasize);
+
+ if ((cc = ad_recvfile(ofork->of_ad, eid, dsi->socket, offset, dsi->datasize, obj->options.splice_size)) < dsi->datasize) {
switch (errno) {
- case EDQUOT :
- case EFBIG :
- case ENOSPC :
+ case EDQUOT:
+ case EFBIG:
+ case ENOSPC:
cc = AFPERR_DFULL;
+ dsi_writeflush(dsi);
break;
- default :
- LOG(log_error, logtype_afpd, "afp_write: ad_writefile: %s", strerror(errno) );
+ case ENOSYS:
goto afp_write_loop;
+ default:
+ /* Low level error, can't do much to back up */
+ cc = AFPERR_MISC;
+ LOG(log_error, logtype_afpd, "afp_write: ad_writefile: %s", strerror(errno));
}
- dsi_writeflush(dsi);
*rbuflen = 0;
- ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff,
- reqcount, ofork->of_refnum);
+ if (obj->options.flags & OPTION_AFP_READ_LOCK)
+ ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, reqcount, ofork->of_refnum);
return cc;
}
offset += cc;
goto afp_write_done;
}
-#endif /* 0, was HAVE_SENDFILE_WRITE */
+#endif
+afp_write_loop:
/* loop until everything gets written. currently
* dsi_write handles the end case by itself. */
- while ((cc = dsi_write(dsi, rbuf, *rbuflen))) {
- if ((cc = write_file(ofork, eid, offset, rbuf, cc)) < 0) {
+ while ((cc = dsi_write(dsi, rcvbuf, rcvbuflen))) {
+
+ if ((cc = write_file(ofork, eid, offset, rcvbuf, cc)) < 0) {
dsi_writeflush(dsi);
*rbuflen = 0;
- ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff,
- reqcount, ofork->of_refnum);
+ if (obj->options.flags & OPTION_AFP_READ_LOCK)
+ ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, reqcount, ofork->of_refnum);
return cc;
}
+
+ LOG(log_debug, logtype_afpd, "afp_write: wrote: %jd, offset: %jd",
+ (intmax_t)cc, (intmax_t)offset);
+
offset += cc;
}
- ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, reqcount, ofork->of_refnum);
+afp_write_done:
+ if (obj->options.flags & OPTION_AFP_READ_LOCK)
+ ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, reqcount, ofork->of_refnum);
if ( ad_meta_fileno( ofork->of_ad ) != -1 ) /* META */
ofork->of_flags |= AFPFORK_DIRTY;
ofork->of_vol->v_appended += (newsize > oldsize) ? (newsize - oldsize) : 0;
*rbuflen = set_off_t (offset, rbuf, is64);
+ AFP_WRITE_DONE();
return( AFP_OK );
afp_write_err:
- dsi_writeinit(obj->dsi, rbuf, *rbuflen);
- dsi_writeflush(obj->dsi);
+ dsi_writeinit(dsi, rcvbuf, rcvbuflen);
+ dsi_writeflush(dsi);
if (err != AFP_OK) {
*rbuflen = 0;
projects / netatalk.git / blobdiff