#include <atalk/cnid.h>
#include <atalk/bstradd.h>
#include <atalk/globals.h>
+#include <atalk/netatalk_conf.h>
+#include <atalk/ea.h>
#include "fork.h"
#include "file.h"
struct ofork *writtenfork;
#endif
-static int getforkparams(struct ofork *ofork, uint16_t bitmap, char *buf, size_t *buflen)
+static int getforkparams(const AFPObj *obj, struct ofork *ofork, uint16_t bitmap, char *buf, size_t *buflen)
{
struct path path;
struct stat *st;
return( AFPERR_BITMAP );
}
- if ( ad_reso_fileno( ofork->of_ad ) == -1 ) { /* META ? */
+ if (! AD_META_OPEN(ofork->of_ad)) {
adp = NULL;
} else {
adp = ofork->of_ad;
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.m_name = utompath(vol, of_name(ofork), dir->d_did, utf8_encoding(obj)))) {
return( AFPERR_MISC );
}
- path.m_name = of_name(ofork);
+ path.u_name = of_name(ofork);
path.id = 0;
st = &path.st;
if ( bitmap & ( (1<<FILPBIT_DFLEN) | (1<<FILPBIT_EXTDFLEN) |
}
}
}
- return getmetadata(vol, bitmap, &path, dir, buf, buflen, adp );
+ return getmetadata(obj, vol, bitmap, &path, dir, buf, buflen, adp );
}
static off_t get_off_t(char **ibuf, int is64)
int denyreadset;
int denywriteset;
+#ifdef HAVE_FSHARE_T
+ fshare_t shmd;
+
+ 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 != -2 && 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++;
return AFPERR_BADTYPE;
}
- LOG(log_debug, logtype_afpd, "afp_openfork(\"%s\", %s)",
- fullpathname(s_path->u_name), (fork & OPENFORK_RSCS) ? "RSRC" : "DATA");
-
/* stat() data fork st is set because it's not a dir */
switch ( s_path->st_errno ) {
case 0:
/* FIXME should we check it first ? */
upath = s_path->u_name;
if (!vol_unix_priv(vol)) {
- if (check_access(upath, access ) < 0) {
+ if (check_access(obj, vol, upath, access ) < 0) {
return AFPERR_ACCESS;
}
} else {
- if (file_access(s_path, access ) < 0) {
+ if (file_access(obj, vol, s_path, access ) < 0) {
return AFPERR_ACCESS;
}
}
if ( fork == OPENFORK_DATA ) {
eid = ADEID_DFORK;
- adflags = ADFLAGS_DF | ADFLAGS_HF ;
+ adflags = ADFLAGS_DF | ADFLAGS_HF | ADFLAGS_NOHF;
} else {
eid = ADEID_RFORK;
- adflags = ADFLAGS_RF | ADFLAGS_HF;
+ adflags = ADFLAGS_RF | ADFLAGS_HF | ADFLAGS_NOHF;
+ if (!(access & OPENACC_WR))
+ adflags |= ADFLAGS_NORF;
}
path = s_path->m_name;
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;
if (access & OPENACC_WR) {
/* try opening in read-write mode */
ret = AFPERR_VLOCK;
case EACCES:
goto openfork_err;
- break;
case ENOENT:
if (fork == OPENFORK_DATA) {
/* try to open only the data fork */
if (ad_open(ofork->of_ad, upath,
adflags | ADFLAGS_RDWR | ADFLAGS_SETSHRMD | ADFLAGS_CREATE, 0666) < 0)
goto openfork_err;
- ofork->of_flags |= AFPFORK_OPEN;
+ ofork->of_flags |= AFPFORK_META;
}
break;
case EMFILE :
case ENFILE :
ret = AFPERR_NFILE;
goto openfork_err;
- break;
case EISDIR :
ret = AFPERR_BADTYPE;
goto openfork_err;
- break;
default:
LOG(log_error, logtype_afpd, "afp_openfork(%s): ad_open: %s", s_path->m_name, strerror(errno) );
ret = AFPERR_PARAM;
goto openfork_err;
- break;
}
}
else {
/* the ressource fork is open too */
- ofork->of_flags |= AFPFORK_OPEN;
+ ofork->of_flags |= AFPFORK_META;
}
} else {
/* try opening in read-only mode */
ret = AFPERR_NOOBJ;
- /* we need w access for setting deny mode fcntl excl lock */
if (ad_open(ofork->of_ad, upath, adflags | ADFLAGS_RDONLY | ADFLAGS_SETSHRMD) < 0) {
switch ( errno ) {
case EROFS:
}
adflags = ADFLAGS_DF;
}
- /* else we don't set AFPFORK_OPEN because there's no ressource fork file
- * We need to check AFPFORK_OPEN in afp_closefork(). eg fork open read-only
+ /* 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
case ENFILE :
ret = AFPERR_NFILE;
goto openfork_err;
- break;
case EISDIR :
ret = AFPERR_BADTYPE;
goto openfork_err;
- break;
default:
LOG(log_error, logtype_afpd, "afp_openfork(\"%s\"): %s",
fullpathname(s_path->m_name), strerror(errno) );
goto openfork_err;
- break;
}
- }
- else {
- /* the ressource fork is open too */
- ofork->of_flags |= AFPFORK_OPEN;
+ } else {
+ ofork->of_flags |= AFPFORK_META;
}
}
}
}
- if ((ret = getforkparams(ofork, bitmap, rbuf + 2 * sizeof(int16_t), &buflen)) != AFP_OK) {
- ad_close( ofork->of_ad, adflags );
+ if ((ret = getforkparams(obj, ofork, bitmap, rbuf + 2 * sizeof(int16_t), &buflen)) != AFP_OK) {
+ ad_close( ofork->of_ad, adflags | ADFLAGS_SETSHRMD);
goto openfork_err;
}
if (ad_meta_fileno(ofork->of_ad) != -1) { /* META */
ad_getattr(ofork->of_ad, &bshort);
if ((bshort & htons(ATTRBIT_NOWRITE)) && (access & OPENACC_WR)) {
- ad_close( ofork->of_ad, adflags );
+ ad_close( ofork->of_ad, adflags | ADFLAGS_SETSHRMD);
of_dealloc( ofork );
ofrefnum = 0;
memcpy(rbuf, &ofrefnum, sizeof(ofrefnum));
/* don't try to lock non-existent rforks. */
if ((eid == ADEID_DFORK)
- || (ad_meta_fileno(ofork->of_ad) != -1)
- || (vol->v_adouble & AD_VERSION_EA)) { /* META */
-
+ || (ad_reso_fileno(ofork->of_ad) != -1)
+ || (ofork->of_ad->ad_vers == AD_VERSION_EA)) {
ret = fork_setmode(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 );
+ ad_close( ofork->of_ad, adflags | ADFLAGS_SETSHRMD);
of_dealloc( ofork );
switch (ret) {
case EAGAIN: /* return data anyway */
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
if (err < 0)
goto afp_setfork_err;
} else if (bitmap == (1<<FILPBIT_RFLEN) || bitmap == (1<<FILPBIT_EXTRFLEN)) {
- ad_refresh( ofork->of_ad );
+ ad_refresh(NULL, ofork->of_ad );
st_size = ad_size(ofork->of_ad, eid);
err = -2;
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);
if (st_size > size)
ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, size, st_size -size, ofork->of_refnum);
ibuf += sizeof(ofrefnum);
if (NULL == ( ofork = of_find( ofrefnum )) ) {
- LOG(log_error, logtype_afpd, "afp_bytelock: of_find(%d) could not locate fork", ofrefnum );
+ LOG(log_error, logtype_afpd, "byte_lock: of_find(%d) could not locate fork", ofrefnum );
return( AFPERR_PARAM );
}
offset = get_off_t(&ibuf, is64);
length = get_off_t(&ibuf, is64);
- /* FIXME AD_FILELOCK test is surely wrong */
if (length == -1)
length = BYTELOCK_MAX;
else if (!length || is_neg(is64, length)) {
#undef UNLOCKBIT
-/* --------------------------- */
-static int crlf(struct ofork *of)
-{
- struct extmap *em;
-
- if ( ad_meta_fileno( of->of_ad ) == -1 || !memcmp( ufinderi, ad_entry( of->of_ad, ADEID_FINDERI),8)) { /* META */
- /* no resource fork or no finderinfo, use our files extension mapping */
- if (!( em = getextmap( of_name(of) )) || memcmp( "TEXT", em->em_type, sizeof( em->em_type ))) {
- return 0;
- }
- /* file type is TEXT */
- return 1;
-
- } else if ( !memcmp( "TEXT", ad_entry( of->of_ad, ADEID_FINDERI ), 4 )) {
- return 1;
- }
- return 0;
-}
-
-
static ssize_t read_file(struct ofork *ofork, int eid,
off_t offset, u_char nlmask,
u_char nlchar, char *rbuf,
- size_t *rbuflen, const int xlate)
+ size_t *rbuflen)
{
ssize_t cc;
int eof = 0;
}
}
- /*
- * If this file is of type TEXT, then swap \012 to \015.
- */
- if (xlate) {
- for ( p = rbuf, q = p + cc; p < q; p++ ) {
- if ( *p == '\012' ) {
- *p = '\015';
- } else if ( *p == '\015' ) {
- *p = '\012';
- }
-
- }
- }
-
*rbuflen = cc;
if ( eof ) {
return( AFPERR_EOF );
struct ofork *ofork;
off_t offset, saveoff, reqcount, savereqcount;
ssize_t cc, err;
- int eid, xlate = 0;
+ int eid;
uint16_t ofrefnum;
u_char nlmask, nlchar;
if ( ofork->of_flags & AFPFORK_DATA) {
eid = ADEID_DFORK;
- xlate = (ofork->of_vol->v_flags & AFPVOL_CRLF) ? crlf(ofork) : 0;
} else if (ofork->of_flags & AFPFORK_RSRC) {
eid = ADEID_RFORK;
} else { /* fork wasn't opened. this should never really happen. */
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, xlate);
+ 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",
/* dsi can stream requests. we can only do this if we're not checking
* for an end-of-line character. oh well. */
- if ((obj->proto == AFPPROTO_DSI) && (*rbuflen < reqcount) && !nlmask) {
- DSI *dsi = obj->handle;
+ if ((*rbuflen < reqcount) && !nlmask) {
+ DSI *dsi = obj->dsi;
off_t size;
/* reqcount isn't always truthful. we need to deal with that. */
/* 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
- if (!(xlate)) {
- 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)
+ if (!(obj->options.flags & OPTION_NOSENDFILE)) {
+ int fd = ad_readfile_init(ofork->of_ad, eid, &offset, 0);
+ if (dsi_stream_read_file(dsi, fd, offset, dsi->datasize) < 0) {
+ switch (errno) {
+ case EINVAL:
+ case ENOSYS:
goto afp_read_loop;
- else {
+ default:
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, xlate);
+ cc = read_file(ofork, eid, offset, nlmask, nlchar, rbuf,rbuflen);
if (cc < 0)
goto afp_read_exit;
(ofork->of_flags & AFPFORK_RSRC)) {
/* read in the rfork length */
- ad_refresh(ofork->of_ad);
+ ad_refresh(NULL, ofork->of_ad);
/* set the date if we're dirty */
if ((ofork->of_flags & AFPFORK_DIRTY) && !gettimeofday(&tv, NULL)) {
LOG(log_debug, logtype_afpd, "afp_closefork(fork: %s)",
(ofork->of_flags & AFPFORK_DATA) ? "d" : "r");
+#ifdef HAVE_FSHARE_T
+ fshare_t shmd;
+ shmd.f_id = ofork->of_refnum;
+ if (AD_DATA_OPEN(ofork->of_ad))
+ fcntl(ad_data_fileno(ofork->of_ad), F_UNSHARE, &shmd);
+ if (AD_RSRC_OPEN(ofork->of_ad))
+ fcntl(ad_reso_fileno(ofork->of_ad), F_UNSHARE, &shmd);
+#endif
+
if ( of_closefork( ofork ) < 0 ) {
LOG(log_error, logtype_afpd, "afp_closefork(%s): of_closefork: %s", of_name(ofork), strerror(errno) );
return( AFPERR_PARAM );
static ssize_t write_file(struct ofork *ofork, int eid,
off_t offset, char *rbuf,
- size_t rbuflen, const int xlate)
+ size_t rbuflen)
{
char *p, *q;
ssize_t cc;
- /*
- * If this file is of type TEXT, swap \015 to \012.
- */
- if (xlate) {
- for ( p = rbuf, q = p + rbuflen; p < q; p++ ) {
- if ( *p == '\015' ) {
- *p = '\012';
- } else if ( *p == '\012' ) {
- *p = '\015';
- }
- }
- }
+ LOG(log_debug, logtype_afpd, "write_file(off: %ju, size: %zu)",
+ (uintmax_t)offset, rbuflen);
if (( cc = ad_write(ofork->of_ad, eid, offset, 0,
rbuf, rbuflen)) < 0 ) {
{
struct ofork *ofork;
off_t offset, saveoff, reqcount, oldsize, newsize;
- int endflag, eid, xlate = 0, err = AFP_OK;
+ int endflag, eid, err = AFP_OK;
uint16_t ofrefnum;
ssize_t cc;
if ( ofork->of_flags & AFPFORK_DATA) {
eid = ADEID_DFORK;
- xlate = (ofork->of_vol->v_flags & AFPVOL_CRLF) ? crlf(ofork) : 0;
} else if (ofork->of_flags & AFPFORK_RSRC) {
eid = ADEID_RFORK;
} else {
goto afp_write_err;
}
- /* this is yucky, but dsi can stream i/o and asp can't */
- switch (obj->proto) {
- case AFPPROTO_DSI:
- {
- DSI *dsi = obj->handle;
+ DSI *dsi = obj->dsi;
+ /* find out what we have already and write it out. */
+ cc = dsi_writeinit(dsi, rbuf, *rbuflen);
- /* 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, xlate)) < 0) {
- dsi_writeflush(dsi);
- *rbuflen = 0;
- ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, reqcount, ofork->of_refnum);
- return cc;
- }
- offset += cc;
+ 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;
+ }
-#if 0 /*def HAVE_SENDFILE_WRITE*/
- if (!(xlate || obj->options.flags & OPTION_DEBUG)) {
- if ((cc = ad_writefile(ofork->of_ad, eid, dsi->socket,
- offset, dsi->datasize)) < 0) {
- switch (errno) {
- case EDQUOT :
- case EFBIG :
- case ENOSPC :
- cc = AFPERR_DFULL;
- break;
- default :
- LOG(log_error, logtype_afpd, "afp_write: ad_writefile: %s", strerror(errno) );
- goto afp_write_loop;
- }
- dsi_writeflush(dsi);
- *rbuflen = 0;
- ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff,
- reqcount, ofork->of_refnum);
- return cc;
- }
+ offset += cc;
- offset += cc;
- goto afp_write_done;
+#if 0 /*def HAVE_SENDFILE_WRITE*/
+ if ((cc = ad_writefile(ofork->of_ad, eid, dsi->socket,
+ offset, dsi->datasize)) < 0) {
+ switch (errno) {
+ case EDQUOT:
+ case EFBIG:
+ case ENOSPC:
+ cc = AFPERR_DFULL;
+ break;
+ default:
+ LOG(log_error, logtype_afpd, "afp_write: ad_writefile: %s", strerror(errno) );
+ goto afp_write_loop;
}
+ dsi_writeflush(dsi);
+ *rbuflen = 0;
+ 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 */
- /* 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, xlate)) < 0) {
- dsi_writeflush(dsi);
- *rbuflen = 0;
- ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff,
- reqcount, ofork->of_refnum);
- return cc;
- }
- offset += cc;
+ /* 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) {
+ dsi_writeflush(dsi);
+ *rbuflen = 0;
+ ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff,
+ reqcount, ofork->of_refnum);
+ return cc;
}
- }
- break;
+ offset += cc;
}
ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, reqcount, ofork->of_refnum);
return( AFP_OK );
afp_write_err:
- if (obj->proto == AFPPROTO_DSI) {
- dsi_writeinit(obj->handle, rbuf, *rbuflen);
- dsi_writeflush(obj->handle);
- }
+ dsi_writeinit(obj->dsi, rbuf, *rbuflen);
+ dsi_writeflush(obj->dsi);
+
if (err != AFP_OK) {
*rbuflen = 0;
}
}
/* ---------------------------- */
-int afp_getforkparams(AFPObj *obj _U_, char *ibuf, size_t ibuflen _U_, char *rbuf, size_t *rbuflen)
+int afp_getforkparams(AFPObj *obj, char *ibuf, size_t ibuflen _U_, char *rbuf, size_t *rbuflen)
{
struct ofork *ofork;
int ret;
return( AFPERR_PARAM );
}
- if ( ad_meta_fileno( ofork->of_ad ) != -1 ) { /* META */
- if ( ad_refresh( ofork->of_ad ) < 0 ) {
+ if (AD_META_OPEN(ofork->of_ad)) {
+ if ( ad_refresh(NULL, ofork->of_ad ) < 0 ) {
LOG(log_error, logtype_afpd, "getforkparams(%s): ad_refresh: %s", of_name(ofork), strerror(errno) );
return( AFPERR_PARAM );
}
}
- if (AFP_OK != ( ret = getforkparams( ofork, bitmap,
- rbuf + sizeof( u_short ), &buflen ))) {
+ if (AFP_OK != (ret = getforkparams(obj, ofork, bitmap, rbuf + sizeof( u_short ), &buflen ))) {
return( ret );
}
projects / netatalk.git / blobdiff