Cleanup.
Remove adv1tov2.
# Makefile.am for bin/
-SUBDIRS = ad adv1tov2 afppasswd cnid megatron uniconv misc
+SUBDIRS = ad afppasswd cnid megatron uniconv misc
if USE_APPLETALK
SUBDIRS += aecho getzones nbp pap psorder
extern int ad_cp(int argc, char **argv);
extern int ad_rm(int argc, char **argv);
extern int ad_mv(int argc, char **argv);
+extern int ad_find(int argc, char **argv);
/* ad_util.c */
extern int openvol(const char *path, afpvol_t *vol);
break;
}
ad_init(&ad, dvolume.volinfo.v_adouble, dvolume.volinfo.v_ad_options);
- if (ad_open_metadata(to.p_path, ADFLAGS_DIR, O_RDWR | O_CREAT, &ad) != 0) {
+ if (ad_open(&ad, to.p_path, ADFLAGS_HF | ADFLAGS_DIR, O_RDWR | O_CREAT, 0666) != 0) {
ERROR("Error opening adouble for: %s", to.p_path);
}
ad_setid( &ad, st.st_dev, st.st_ino, did, pdid, dvolume.db_stamp);
break;
}
ad_init(&ad, dvolume.volinfo.v_adouble, dvolume.volinfo.v_ad_options);
- if (ad_open_metadata(to.p_path, 0, O_RDWR | O_CREAT, &ad) != 0) {
+ if (ad_open(&ad, to.p_path, ADFLAGS_HF, O_RDWR | O_CREAT) != 0) {
ERROR("Error opening adouble for: %s", to.p_path);
}
ad_setid( &ad, st.st_dev, st.st_ino, cnid, did, dvolume.db_stamp);
struct adouble ad;
ad_init(&ad, dvolume.volinfo.v_adouble, dvolume.volinfo.v_ad_options);
- if (ad_open_metadata(to, S_ISDIR(sb.st_mode) ? ADFLAGS_DIR : 0, O_RDWR, &ad) != 0) {
+ if (ad_open(&ad, to, S_ISDIR(sb.st_mode) ? (ADFLAGS_DIR | ADFLAGS_HF) : ADFLAGS_HF, O_RDWR) != 0) {
SLOG("Error opening adouble for: %s", to);
return 1;
}
+++ /dev/null
-Makefile
-Makefile.in
-adv1tov2
-.deps
-.libs
-.gitignore
-adv1tov2.o
+++ /dev/null
-# Makefile.am for bin/adv1tov2/
-
-INCLUDES = -I$(top_srcdir)/include -I$(top_srcdir)/sys
-
-bin_PROGRAMS = adv1tov2
-
-adv1tov2_SOURCES = adv1tov2.c
-adv1tov2_LDADD = $(top_builddir)/libatalk/libatalk.la
+++ /dev/null
-/*
- * $Id: adv1tov2.c,v 1.5 2009-10-14 01:38:28 didg Exp $
- * v1tov2: given a root directory, run down and convert all the
- * files/directories into appledouble v2.
- */
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif /* HAVE_CONFIG_H */
-
-#include <atalk/adouble.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <dirent.h>
-#ifdef HAVE_FCNTL_H
-#include <fcntl.h>
-#endif /* HAVE_FCNTL_H */
-#ifdef HAVE_UNISTD_H
-#include <unistd.h>
-#endif /* HAVE_UNISTD_H */
-#include <ctype.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <sys/param.h>
-#include <errno.h>
-#include <string.h>
-
-#include <atalk/util.h>
-
-#if AD_VERSION == AD_VERSION2
-#if 0
-/* translate characters */
-static void xlate(char *name, int flags) {
- static const char hexdig[] = "0123456789abcdef";
- char upath[MAXPATHLEN + 1];
- char *m, *u;
- int doit = 0;
-
- m = name;
- u = upath;
- while (*m != '\0') {
- if (isascii(*m) && !isprint(*m)) {
- doit = 1;
- *u++ = ':';
- *u++ = hexdig[(*m & 0xf0) >> 4];
- *u++ = hexdig[*m & 0x0f];
- } else
- *u++ = *m;
- m++;
- }
-
- if (doit) {
- *u = '\0';
- rename(name, upath);
- if ((flags & ADFLAGS_DIR) == 0)
- rename(ad_path(name, flags), ad_path(upath, flags)); /* rename rfork */
- }
-}
-#endif
-
-/* ----------------------------- */
-char *fullpathname(const char *name)
-{
- static char wd[ MAXPATHLEN + 1];
-
- if ( getcwd( wd , MAXPATHLEN) ) {
- strlcat(wd, "/", MAXPATHLEN);
- strlcat(wd, name, MAXPATHLEN);
- }
- else {
- strlcpy(wd, name, MAXPATHLEN);
- }
- return wd;
-}
-
-#define MAXDESCEND 0xFFFF
-/* recursively descend subdirectories.
- * oh the stack space we use up! */
-static void descend(DIR *dp)
-{
- DIR *dpnew;
- struct dirent *de;
- struct stat st;
- struct adouble ad;
- int flags;
- static int count = 0;
-
- ad_init(&ad, AD_VERSION2, 0);
- if (count++ > MAXDESCEND) {
- fprintf(stderr, "FAILURE: too many subdirectories! possible infinite recursion.");
- return;
- }
-
- putc('(', stderr);
- for (de = readdir(dp); de; de = readdir(dp)) {
- if (de->d_name[0] == '.')
- continue;
-
- if (stat(de->d_name, &st) < 0) {
- fprintf(stderr, "FAILURE: can't stat %s\n", de->d_name);
- continue;
- }
-
- /* go down subdirectory */
- flags = ADFLAGS_HF;
- if (S_ISDIR(st.st_mode) && (dpnew = opendir(de->d_name))) {
- chdir(de->d_name);
- descend(dpnew);
- closedir(dpnew);
- chdir("..");
- flags |= ADFLAGS_DIR;
- }
-
- if (ad_open(de->d_name, flags, O_RDWR, 0, &ad) < 0) {
- if (errno != ENOENT)
- fprintf(stderr, "\nFAILURE: can't convert %s, %s\n", fullpathname(de->d_name), strerror(errno));
- continue;
- }
- ad_close(&ad, ADFLAGS_HF);
- fputc('.', stderr);
- }
- putc(')', stderr);
-}
-
-
-int main(int argc, char **argv)
-{
- DIR *dp;
- struct adouble ad;
-
- ad_init(&ad, AD_VERSION2, 0);
- if (argc != 2) {
- fprintf(stderr, "%s <directory>\n", *argv);
- return -1;
- }
-
- /* convert main directory */
- if (ad_open(argv[1], ADFLAGS_HF | ADFLAGS_DIR, O_RDWR, 0,
- &ad) < 0) {
- fprintf(stderr, "FAILURE: can't convert %s\n", argv[1]);
- return -1;
- }
-
- ad_close(&ad, ADFLAGS_HF);
- if ((dp = opendir(argv[1])) == NULL) {
- fprintf(stderr, "%s: unable to open %s\n", *argv, argv[1]);
- return -1;
- }
-
- chdir(argv[1]);
- descend(dp);
- closedir(dp);
- chdir("..");
-
- putc('\n', stderr);
- return 0;
-}
-
-#else /* AD_VERSION == AD_VERSION2 */
-int main(int argc, char **argv)
-{
- fprintf(stderr, "%s not built for v2 AppleDouble files.\n", *argv);
- return -1;
-}
-#endif /* AD_VERSION == AD_VERSION2 */
if ((c = getoption(buf, "-port")))
options->port = strdup(c);
+#ifndef NO_DDP
if ((c = getoption(buf, "-ddpaddr")))
atalk_aton(c, &options->ddpaddr);
+#endif
if ((c = getoption(buf, "-signature")) && (opt = strdup(c)))
options->signatureopt = opt;
} else
adp = of->of_ad;
- if (ad_open(upath,
+ if (ad_open(adp, upath,
ADFLAGS_HF | ( (isadir) ? ADFLAGS_DIR : 0),
O_CREAT | O_RDWR,
- 0666,
- adp) < 0 ) {
+ 0666) < 0 ) {
return( AFPERR_ACCESS );
}
} else
adp = of->of_ad;
- if ( ad_open_metadata( upath, (isadir) ? ADFLAGS_DIR : 0, 0, adp) < 0 ) {
+ if ( ad_open(adp, upath, ADFLAGS_HF | (isadir) ? ADFLAGS_DIR : 0, 0) < 0 ) {
switch ( errno ) {
case ENOENT :
return( AFPERR_NOITEM );
/* get_id needs adp for reading CNID from adouble file */
ad_init(&ad, vol->v_adouble, vol->v_ad_options);
- if ((ad_open_metadata(path->u_name, ADFLAGS_DIR, 0, &ad)) == 0) /* 1 */
+ if ((ad_open(&ad, path->u_name, ADFLAGS_HF | ADFLAGS_DIR)) == 0) /* 1 */
adp = &ad;
/* Get CNID */
}
ad_init(&ad, vol->v_adouble, vol->v_ad_options);
- if (ad_open_metadata( upath, ADFLAGS_DIR, O_CREAT, &ad) < 0) {
+ if (ad_open(&ad, upath, ADFLAGS_HF | ADFLAGS_DIR, O_CREAT, 0777) != 0) {
/*
* Check to see what we're trying to set. If it's anything
* but ACCESS, UID, or GID, give an error. If it's any of those
}
ad_init(&ad, vol->v_adouble, vol->v_ad_options);
- if (ad_open_metadata( ".", ADFLAGS_DIR, O_CREAT, &ad ) < 0) {
+ if (ad_open(&ad, ".", ADFLAGS_HF | ADFLAGS_DIR, O_CREAT, 0777) < 0) {
if (vol_noadouble(vol))
goto createdir_done;
return( AFPERR_ACCESS );
ad_init(&ad, vol->v_adouble, vol->v_ad_options);
- if (!ad_open_metadata( dst, ADFLAGS_DIR, 0, &ad)) {
+ if (ad_open(&ad, dst, ADFLAGS_HF | ADFLAGS_DIR) == 0) {
ad_setname(&ad, newname);
ad_flush( &ad);
ad_close_metadata( &ad);
because open syscall is not called */
openf = O_RDWR|O_CREAT|O_EXCL;
- if ( ad_open( upath, ADFLAGS_DF|ADFLAGS_HF|ADFLAGS_NOHF,
- openf, 0666, &ad) < 0 ) {
+ if ( ad_open(&ad, upath, ADFLAGS_DF | ADFLAGS_HF | ADFLAGS_NOHF,
+ openf, 0666, openf, 0666) < 0 ) {
switch ( errno ) {
case EROFS:
return AFPERR_VLOCK;
/* second try with adouble open
*/
- if ( ad_open_metadata( upath, 0, O_CREAT, adp) < 0) {
+ if ( ad_open(adp, upath, ADFLAGS_HF, O_RDWR | O_CREAT, 0666) < 0) {
LOG(log_debug, logtype_afpd, "setfilparams: ad_open_metadata error");
/*
* For some things, we don't need an adouble header:
/* don't care if we can't open the newly renamed ressource fork
*/
- if (!ad_open( dst, ADFLAGS_HF, O_RDWR, 0666, adp)) {
+ if (ad_open(adp, dst, ADFLAGS_HF, O_RDWR) == 0) {
ad_setname(adp, newname);
ad_flush( adp );
ad_close( adp, ADFLAGS_HF );
adp = of_ad(s_vol, s_path, &ad);
- if (ad_open(s_path->u_name , ADFLAGS_DF |ADFLAGS_HF | ADFLAGS_NOHF, O_RDONLY, 0, adp) < 0) {
+ if (ad_open(adp, s_path->u_name, ADFLAGS_DF | ADFLAGS_HF | ADFLAGS_NOHF, O_RDONLY, O_RDONLY) < 0) {
return AFPERR_DENYCONF;
}
denyreadset = (getforkmode(adp, ADEID_DFORK, AD_FILELOCK_DENY_RD) != 0 ||
adflags |= ADFLAGS_HF;
}
- if (ad_openat(sfd, src, adflags | ADFLAGS_NOHF, O_RDONLY, 0, adp) < 0) {
+ if (ad_openat(adp, sfd, src, adflags | ADFLAGS_NOHF, O_RDONLY) < 0) {
ret_err = errno;
goto done;
}
}
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) {
+ 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) {
ret_err = errno;
ad_close( adp, adflags );
if (EEXIST != ret_err) {
/* try to open both forks at once */
adflags = ADFLAGS_DF;
- if ( ad_openat(dirfd, file, adflags |ADFLAGS_HF|ADFLAGS_NOHF, O_RDONLY, 0, &ad ) < 0 ) {
+ if ( ad_openat(&ad, dirfd, file, adflags |ADFLAGS_HF|ADFLAGS_NOHF, O_RDONLY) < 0 ) {
switch (errno) {
case ENOENT:
err = AFPERR_NOOBJ;
adp = (*of)->of_ad;
}
else {
- ret = ad_open( path->u_name, ADFLAGS_HF, O_RDONLY, 0, adp);
+ ret = ad_open(adp, path->u_name, ADFLAGS_HF, O_RDONLY);
/* META and HF */
if ( !ret && ad_reso_fileno(adp) != -1 && !(adp->ad_resource_fork.adf_flags & ( O_RDWR | O_WRONLY))) {
/* from AFP spec.
ret = AFPERR_NOOBJ;
if (access & OPENACC_WR) {
/* try opening in read-write mode */
- if (ad_open(upath, adflags, O_RDWR, 0, ofork->of_ad) < 0) {
+ if (ad_open(ofork->of_ad, upath, adflags, O_RDWR, O_RDWR) < 0) {
switch ( errno ) {
case EROFS:
ret = AFPERR_VLOCK;
case ENOENT:
if (fork == OPENFORK_DATA) {
/* try to open only the data fork */
- if (ad_open(upath, ADFLAGS_DF, O_RDWR, 0, ofork->of_ad) < 0) {
+ if (ad_open(ofork->of_ad, upath, ADFLAGS_DF, O_RDWR) < 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(upath, adflags, O_RDWR | O_CREAT, 0666, ofork->of_ad) < 0)
+ if (ad_open(ofork->of_ad, upath, adflags, O_RDWR | O_CREAT, 0666, O_RDWR | O_CREAT, 0666) < 0)
goto openfork_err;
ofork->of_flags |= AFPFORK_OPEN;
}
} else {
/* try opening in read-only mode */
ret = AFPERR_NOOBJ;
- if (ad_open(upath, adflags, O_RDONLY, 0, ofork->of_ad) < 0) {
+ if (ad_open(ofork->of_ad, upath, adflags, O_RDONLY, O_RDONLY) < 0) {
switch ( errno ) {
case EROFS:
ret = AFPERR_VLOCK;
case ENOENT:
/* see if client asked for a read only data fork */
if (fork == OPENFORK_DATA) {
- if (ad_open(upath, ADFLAGS_DF, O_RDONLY, 0, ofork->of_ad) < 0) {
+ if (ad_open(ofork->of_ad, upath, ADFLAGS_DF, O_RDONLY) < 0) {
goto openfork_err;
}
adflags = ADFLAGS_DF;
#include <atalk/asp.h>
#include <atalk/nbp.h>
#include <atalk/unicode.h>
+#include <atalk/util.h>
#include "globals.h" /* includes <netdb.h> */
#include "status.h"
* .Parent file here if it doesn't exist. */
ad_init(&ad, vol->v_adouble, vol->v_ad_options);
- if ( ad_open_metadata( vol->v_path, ADFLAGS_DIR, O_CREAT, &ad) < 0 ) {
+ if (ad_open(&ad, vol->v_path, ADFLAGS_HF | ADFLAGS_DIR, O_RDWR | O_CREAT, 0666) != 0 ) {
isad = 0;
vol->v_ctime = AD_DATE_FROM_UNIX(st->st_mtime);
return AFPERR_BITMAP;
ad_init(&ad, vol->v_adouble, vol->v_ad_options);
- if ( ad_open( vol->v_path, ADFLAGS_HF|ADFLAGS_DIR, O_RDWR,
- 0666, &ad) < 0 ) {
+ if ( ad_open(&ad, vol->v_path, ADFLAGS_HF|ADFLAGS_DIR, O_RDWR) < 0 ) {
if (errno == EROFS)
return AFPERR_VLOCK;
if ( !ret && folder->hide) {
/* Hide it */
ad_init(&ad, vol->v_adouble, vol->v_ad_options);
- if (ad_open_metadata( p, ADFLAGS_DIR, O_CREAT, &ad) < 0) {
- free (p);
+ if (ad_open(&ad, p, ADFLAGS_DIR, O_RDWR | O_CREAT, 0666) != 0) {
+ free(p);
free(q);
return (-1);
}
*/
static int check_adfile(const char *fname, const struct stat *st)
{
- int ret, adflags;
+ int ret;
+ int adflags = ADFLAGS_HF;
struct adouble ad;
- char *adname;
+ const char *adname;
if (dbd_flags & DBD_FLAGS_CLEANUP)
return 0;
if (S_ISREG(st->st_mode))
- adflags = 0;
- else
- adflags = ADFLAGS_DIR;
+ adflags |= ADFLAGS_DIR;
adname = myvolinfo->ad_path(fname, adflags);
/* Create ad file */
ad_init(&ad, myvolinfo->v_adouble, myvolinfo->v_ad_options);
- if ((ret = ad_open_metadata( fname, adflags, O_CREAT, &ad)) != 0) {
+ if ((ret = ad_open(&ad, fname, adflags, O_CREAT | O_RDWR, 0666)) != 0) {
dbd_log( LOGSTD, "Error creating AppleDouble file '%s/%s': %s",
cwdbuf, adname, strerror(errno));
#endif
} else {
ad_init(&ad, myvolinfo->v_adouble, myvolinfo->v_ad_options);
- if (ad_open_metadata( fname, adflags, O_RDONLY, &ad) != 0) {
+ if (ad_open(&ad, fname, adflags, O_RDONLY) != 0) {
dbd_log( LOGSTD, "Error opening AppleDouble file for '%s/%s'", cwdbuf, fname);
return -1;
}
/* Create ad dir and set name */
ad_init(&ad, myvolinfo->v_adouble, myvolinfo->v_ad_options);
- if (ad_open_metadata( ".", ADFLAGS_DIR, O_CREAT, &ad) != 0) {
+ if (ad_open(&ad, ".", ADFLAGS_HF | ADFLAGS_DIR, O_CREAT | O_RDWR, 0777) != 0) {
dbd_log( LOGSTD, "Error creating AppleDouble dir in %s: %s", cwdbuf, strerror(errno));
return -1;
}
ad_cnid = 0;
if ( (myvolinfo->v_flags & AFPVOL_CACHE) && ADFILE_OK) {
ad_init(&ad, myvolinfo->v_adouble, myvolinfo->v_ad_options);
- if (ad_open_metadata( name, adflags, O_RDWR, &ad) != 0) {
+ if (ad_open(&ad, name, adflags, O_RDWR) != 0) {
if (dbd_flags & DBD_FLAGS_CLEANUP)
return 0;
dbd_log(LOGSTD, "Writing CNID data for '%s/%s' to AppleDouble file",
cwdbuf, name, ntohl(db_cnid));
ad_init(&ad, myvolinfo->v_adouble, myvolinfo->v_ad_options);
- if (ad_open_metadata( name, adflags, O_RDWR, &ad) != 0) {
+ if (ad_open(&ad, name, adflags, O_RDWR) != 0) {
dbd_log(LOGSTD, "Error opening AppleDouble file for '%s/%s': %s",
cwdbuf, name, strerror(errno));
return 0;
dbd_log(LOGSTD, "Writing CNID data for '%s/%s' to AppleDouble file",
cwdbuf, name, ntohl(db_cnid));
ad_init(&ad, myvolinfo->v_adouble, myvolinfo->v_ad_options);
- if (ad_open_metadata( name, adflags, O_RDWR, &ad) != 0) {
+ if (ad_open(&ad, name, adflags, O_RDWR) != 0) {
dbd_log(LOGSTD, "Error opening AppleDouble file for '%s/%s': %s",
cwdbuf, name, strerror(errno));
return 0;
return -1;
}
- nametmp = rqst->name;
+ nametmp = (char *)rqst->name;
if ((b = readt(cur_fd, rqst, sizeof(struct cnid_dbd_rqst), 1, CNID_DBD_TIMEOUT))
!= sizeof(struct cnid_dbd_rqst)) {
if (b)
return 0;
}
rqst->name = nametmp;
- if (rqst->namelen && readt(cur_fd, rqst->name, rqst->namelen, 1, CNID_DBD_TIMEOUT)
+ if (rqst->namelen && readt(cur_fd, (char *)rqst->name, rqst->namelen, 1, CNID_DBD_TIMEOUT)
!= rqst->namelen) {
LOG(log_error, logtype_cnid, "error reading message name: %s", strerror(errno));
invalidate_fd(cur_fd);
}
/* We set this to make life easier for logging. None of the other stuff
needs zero terminated strings. */
- rqst->name[rqst->namelen] = '\0';
+ ((char *)(rqst->name))[rqst->namelen] = '\0';
LOG(log_maxdebug, logtype_cnid, "comm_rcv: got %u bytes", b + rqst->namelen);
rply->name = resbuf;
rply->namelen = 0;
- key.data = rqst->name;
+ key.data = (char *)rqst->name;
key.size = rqst->namelen;
if ((results = dbif_search(dbd, &key, resbuf)) < 0) {
struct adouble;
struct adouble_fops {
- char *(*ad_path)(const char *, int);
- int (*ad_mkrf)(char *);
+ const char *(*ad_path)(const char *, int);
+ int (*ad_mkrf)(const char *);
int (*ad_rebuild_header)(struct adouble *);
int (*ad_header_read)(struct adouble *, struct stat *);
- int (*ad_header_upgrade)(struct adouble *, char *);
+ int (*ad_header_upgrade)(struct adouble *, const char *);
};
struct adouble {
#define ADFLAGS_HF (1<<2)
#define ADFLAGS_DIR (1<<3)
#define ADFLAGS_NOHF (1<<4) /* not an error if no ressource fork */
-#define ADFLAGS_RDONLY (1<<5) /* don't try readwrite */
-#define ADFLAGS_OPENFORKS (1<<6) /* check for open fork in ad_metadata function */
+#define ADFLAGS_OPENFORKS (1<<5) /* check for open fork in ad_metadata function */
#define ADVOL_NODEV (1 << 0)
#define ADVOL_CACHE (1 << 1)
extern int ad_setfuid (const uid_t );
extern uid_t ad_getfuid (void );
extern char *ad_dir (const char *);
-extern char *ad_path (const char *, int);
-extern char *ad_path_ea (const char *, int);
+extern const char *ad_path (const char *, int);
+extern const char *ad_path_ea (const char *, int);
extern int ad_mode (const char *, int);
extern int ad_mkdir (const char *, int);
extern void ad_init (struct adouble *, int, int );
-extern int ad_open (const char *, int, int, int, struct adouble *);
-extern int ad_openat (int dirfd, const char *, int, int, int, struct adouble *);
+extern int ad_open (struct adouble *ad, const char *path, int adflags, ...);
+extern int ad_openat (struct adouble *, int dirfd, const char *path, int adflags, ...);
extern int ad_refresh (struct adouble *);
extern int ad_stat (const char *, struct stat *);
extern int ad_metadata (const char *, int, struct adouble *);
extern int ad_metadataat (int, const char *, int, struct adouble *);
+#if 0
#define ad_open_metadata(name, flags, mode, adp)\
ad_open(name, ADFLAGS_HF | (flags), O_RDWR |(mode), 0666, (adp))
+#endif
#define ad_close_metadata(adp) ad_close( (adp), ADFLAGS_HF)
char *volpath; /* Volume path this particular CNID db refers to. */
void *_private; /* back-end speficic data */
- cnid_t (*cnid_add) (struct _cnid_db *cdb, const struct stat *st, const cnid_t did,
- char *name, const size_t, cnid_t hint);
+ cnid_t (*cnid_add) (struct _cnid_db *cdb, const struct stat *st, cnid_t did,
+ const char *name, size_t, cnid_t hint);
int (*cnid_delete) (struct _cnid_db *cdb, cnid_t id);
- cnid_t (*cnid_get) (struct _cnid_db *cdb, const cnid_t did, char *name, const size_t);
- cnid_t (*cnid_lookup) (struct _cnid_db *cdb, const struct stat *st, const cnid_t did,
- char *name, const size_t);
+ cnid_t (*cnid_get) (struct _cnid_db *cdb, cnid_t did, const char *name, size_t);
+ cnid_t (*cnid_lookup) (struct _cnid_db *cdb, const struct stat *st, cnid_t did,
+ const char *name, size_t);
cnid_t (*cnid_nextid) (struct _cnid_db *cdb);
char * (*cnid_resolve) (struct _cnid_db *cdb, cnid_t *id, void *buffer, size_t len);
- int (*cnid_update) (struct _cnid_db *cdb, const cnid_t id, const struct stat *st,
- const cnid_t did, char *name, const size_t len);
+ int (*cnid_update) (struct _cnid_db *cdb, cnid_t id, const struct stat *st,
+ cnid_t did, const char *name, size_t len);
void (*cnid_close) (struct _cnid_db *cdb);
int (*cnid_getstamp) (struct _cnid_db *cdb, void *buffer, const size_t len);
- cnid_t (*cnid_rebuild_add) (struct _cnid_db *, const struct stat *, const cnid_t,
- char *, const size_t, cnid_t);
- int (*cnid_find) (struct _cnid_db *cdb, char *name, size_t namelen,
+ cnid_t (*cnid_rebuild_add) (struct _cnid_db *, const struct stat *, cnid_t,
+ const char *, size_t, cnid_t);
+ int (*cnid_find) (struct _cnid_db *cdb, const char *name, size_t namelen,
void *buffer, size_t buflen);
};
typedef struct _cnid_db cnid_db;
ino_t ino;
uint32_t type;
cnid_t did;
- char *name;
+ const char *name;
size_t namelen;
};
/* lock file path. this should be re-organized a bit. */
#if ! defined (_PATH_LOCKDIR)
# if defined (FHS_COMPATIBILITY) || defined (__NetBSD__)
-# define _PATH_LOCKDIR "/var/run/"
+# define _PATH_LOCKDIR /var/run/
# elif defined (BSD4_4)
# ifdef MACOSX_SERVER
-# define _PATH_LOCKDIR "/var/run/"
+# define _PATH_LOCKDIR /var/run/
# else
-# define _PATH_LOCKDIR "/var/spool/lock/"
+# define _PATH_LOCKDIR /var/spool/lock/
# endif
# elif defined (linux)
-# define _PATH_LOCKDIR "/var/lock/"
+# define _PATH_LOCKDIR /var/lock/
# else
-# define _PATH_LOCKDIR "/var/spool/locks/"
+# define _PATH_LOCKDIR /var/spool/locks/
# endif
#endif
#define _PATH_ATALKDEBUG "/tmp/atalkd.debug"
#define _PATH_ATALKDTMP "atalkd.tmp"
#if defined (FHS_COMPATIBILITY) || defined (__NetBSD__)
-# define _PATH_ATALKDLOCK ATALKPATHCAT(_PATH_LOCKDIR,"atalkd.pid")
+# define _PATH_ATALKDLOCK ATALKPATHCAT("_PATH_LOCKDIR","atalkd.pid")
#else
-# define _PATH_ATALKDLOCK ATALKPATHCAT(_PATH_LOCKDIR,"atalkd")
+# define _PATH_ATALKDLOCK ATALKPATHCAT("_PATH_LOCKDIR","atalkd")
#endif
/*
*/
#define _PATH_TMPPAGEORDER "/tmp/psorderXXXXXX"
#if defined (FHS_COMPATIBILITY) || defined (__NetBSD__)
-# define _PATH_PAPDLOCK ATALKPATHCAT(_PATH_LOCKDIR,"papd.pid")
+# define _PATH_PAPDLOCK ATALKPATHCAT("_PATH_LOCKDIR","papd.pid")
#else
-# define _PATH_PAPDLOCK ATALKPATHCAT(_PATH_LOCKDIR,"papd")
+# define _PATH_PAPDLOCK ATALKPATHCAT("_PATH_LOCKDIR","papd")
#endif
/*
*/
#define _PATH_AFPTKT "/tmp/AFPtktXXXXXX"
#if defined (FHS_COMPATIBILITY) || defined (__NetBSD__)
-# define _PATH_AFPDLOCK ATALKPATHCAT(_PATH_LOCKDIR,"afpd.pid")
+# define _PATH_AFPDLOCK ATALKPATHCAT("_PATH_LOCKDIR","afpd.pid")
#else
-# define _PATH_AFPDLOCK ATALKPATHCAT(_PATH_LOCKDIR,"afpd")
+# define _PATH_AFPDLOCK ATALKPATHCAT("_PATH_LOCKDIR","afpd")
#endif
/*
* cnid_metad paths
*/
#if defined (FHS_COMPATIBILITY) || defined (__NetBSD__)
-# define _PATH_CNID_METAD_LOCK ATALKPATHCAT(_PATH_LOCKDIR,"cnid_metad.pid")
+# define _PATH_CNID_METAD_LOCK ATALKPATHCAT("_PATH_LOCKDIR","cnid_metad.pid")
#else
-# define _PATH_CNID_METAD_LOCK ATALKPATHCAT(_PATH_LOCKDIR,"cnid_metad")
+# define _PATH_CNID_METAD_LOCK ATALKPATHCAT("_PATH_LOCKDIR","cnid_metad")
#endif
#endif /* atalk/paths.h */
#define UUID_BINSIZE 16
#define UUID_STRINGSIZE 36
-typedef unsigned char *uuidp_t;
+typedef const unsigned char *uuidp_t;
typedef unsigned char atalk_uuid_t[UUID_BINSIZE];
typedef enum {UUID_USER = 1, UUID_GROUP, UUID_LOCAL} uuidtype_t;
* Interface
********************************************************/
-extern int getuuidfromname( const char *name, uuidtype_t type, uuidp_t uuid);
-extern int getnamefromuuid( const uuidp_t uuidp, char **name, uuidtype_t *type);
-extern const char *uuid_bin2string(unsigned char *uuid);
-extern void uuid_string2bin( const char *uuidstring, uuidp_t uuid);
+extern int getuuidfromname( const char *name, uuidtype_t type, unsigned char *uuid);
+extern int getnamefromuuid( uuidp_t uuidp, char **name, uuidtype_t *type);
+extern const char *uuid_bin2string(const unsigned char *uuid);
+extern void uuid_string2bin( const char *uuidstring, unsigned char *uuid);
#endif /* AFP_UUID_H */
int v_adouble; /* default adouble format */
int v_ad_options;
int v_vfs_ea;
- char *(*ad_path)(const char *, int);
+ const char *(*ad_path)(const char *, int);
char *v_dbd_host;
char *v_dbd_port;
};
char *v_veto;
int v_adouble; /* adouble format: v1, v2, sfm ... */
int v_ad_options; /* adouble option NODEV, NOCACHE, etc.. */
- char *(*ad_path)(const char *, int);
+ const char *(*ad_path)(const char *, int);
struct _cnid_db *v_cdb;
char v_stamp[ADEDLEN_PRIVSYN];
VolSpace v_limitsize; /* Size limit, if any, in MiB */
typedef struct cacheduser {
unsigned long uid; /* for future use */
uuidtype_t type;
- uuidp_t uuid;
+ unsigned char *uuid;
char *name;
time_t creationtime;
struct cacheduser *prev;
int add_cachebyname( const char *inname, const uuidp_t inuuid, const uuidtype_t type, const unsigned long uid _U_) {
int ret = 0;
char *name = NULL;
- uuidp_t uuid;
+ unsigned char *uuid;
cacheduser_t *cacheduser = NULL;
cacheduser_t *entry;
unsigned char hash;
/*
* Caller provides buffer uuid for result
*/
-int search_cachebyname( const char *name, uuidtype_t type, uuidp_t uuid) {
+int search_cachebyname( const char *name, uuidtype_t type, unsigned char *uuid) {
int ret;
unsigned char hash;
cacheduser_t *entry;
int add_cachebyuuid( uuidp_t inuuid, const char *inname, uuidtype_t type, const unsigned long uid _U_) {
int ret = 0;
char *name = NULL;
- uuidp_t uuid;
+ unsigned char *uuid;
cacheduser_t *cacheduser = NULL;
cacheduser_t *entry;
unsigned char hash;
* uuid: if found copies uuid into this buffer
* returns 0 on success, !=0 if not found or on errors
*/
-extern int search_cachebyname( const char *name, uuidtype_t type, uuidp_t uuid);
+extern int search_cachebyname( const char *name, uuidtype_t type, unsigned char *uuid);
/*
* inname: name
* convert ascii string that can include dashes to binary uuid.
* caller must provide a buffer.
*/
-void uuid_string2bin( const char *uuidstring, uuidp_t uuid) {
+void uuid_string2bin( const char *uuidstring, unsigned char *uuid) {
int nibble = 1;
int i = 0;
unsigned char c, val = 0;
*
* Returns pointer to static buffer.
*/
-const char *uuid_bin2string(unsigned char *uuid) {
+const char *uuid_bin2string(const unsigned char *uuid) {
static char uuidstring[UUID_STRINGSIZE + 1];
int i = 0;
* uuid: pointer to uuid_t storage that the caller must provide
* returns 0 on success !=0 on errror
*/
-int getuuidfromname( const char *name, uuidtype_t type, uuidp_t uuid) {
+int getuuidfromname( const char *name, uuidtype_t type, unsigned char *uuid) {
int ret = 0;
#ifdef HAVE_LDAP
char *uuid_string = NULL;
*
* Caller must free name appropiately.
*/
-int getnamefromuuid(const uuidp_t uuidp, char **name, uuidtype_t *type) {
+int getnamefromuuid(uuidp_t uuidp, char **name, uuidtype_t *type) {
int ret;
ret = search_cachebyuuid( uuidp, name, type);
#include <sys/param.h>
#include <stdlib.h>
#include <string.h>
+#include <stdarg.h>
#include <atalk/logger.h>
#include <atalk/adouble.h>
static uid_t default_uid = -1;
/* Forward declarations */
-static int ad_mkrf(char *path);
+static int ad_mkrf(const char *path);
static int ad_header_read(struct adouble *ad, struct stat *hst);
-static int ad_header_upgrade(struct adouble *ad, char *name);
+static int ad_header_upgrade(struct adouble *ad, const char *name);
-static int ad_mkrf_ea(char *path);
+static int ad_mkrf_ea(const char *path);
static int ad_header_read_ea(struct adouble *ad, struct stat *hst);
-static int ad_header_upgrade_ea(struct adouble *ad, char *name);
+static int ad_header_upgrade_ea(struct adouble *ad, const char *name);
static struct adouble_fops ad_adouble = {
&ad_path,
return 0;
}
-static int ad_mkrf(char *path)
+static int ad_mkrf(const char *path)
{
char *slash;
/*
return 0;
}
-static int ad_mkrf_ea(char *path _U_)
+static int ad_mkrf_ea(const char *path _U_)
{
AFP_PANIC("ad_mkrf_ea: dont use");
return 0;
}
/* --------------------------- */
-static int ad_header_upgrade(struct adouble *ad _U_, char *name _U_)
+static int ad_header_upgrade(struct adouble *ad _U_, const char *name _U_)
{
return 0;
}
-static int ad_header_upgrade_ea(struct adouble *ad _U_, char *name _U_)
+static int ad_header_upgrade_ea(struct adouble *ad _U_, const char *name _U_)
{
AFP_PANIC("ad_header_upgrade_ea: dont use");
return 0;
struct stat st_dir;
struct stat st_meta;
struct stat *pst = NULL;
- char *ad_p;
+ const char *ad_p;
int hoflags, admode;
int st_invalid = -1;
ad_p = ad->ad_ops->ad_path( path, adflags );
- hoflags = oflags & ~(O_CREAT | O_EXCL);
- if (!(adflags & ADFLAGS_RDONLY)) {
- hoflags = (hoflags & ~(O_RDONLY | O_WRONLY)) | O_RDWR;
- }
- ad->ad_md->adf_fd = open( ad_p, hoflags | O_NOFOLLOW, 0 );
- if (ad->ad_md->adf_fd < 0 ) {
- if ((errno == EACCES || errno == EROFS) && !(oflags & O_RDWR)) {
- hoflags = oflags & ~(O_CREAT | O_EXCL);
- ad->ad_md->adf_fd = open( ad_p, hoflags | O_NOFOLLOW, 0 );
- }
- }
+ hoflags = (oflags & ~(O_CREAT | O_EXCL)) | O_NOFOLLOW;
+
+ ad->ad_md->adf_fd = open(ad_p, hoflags, 0);
if ( ad->ad_md->adf_fd < 0 ) {
if (errno == ENOENT && (oflags & O_CREAT) ) {
* We're expecting to create a new adouble header file here
* if ((oflags & O_CREAT) ==> (oflags & O_RDWR)
*/
- LOG(log_debug, logtype_default, "ad_open(\"%s/%s\"): creating adouble file",
- getcwdpath(), ad_p);
+ LOG(log_debug, logtype_default, "ad_open(\"%s\"): creating adouble file",
+ abspath(path));
admode = mode;
errno = 0;
st_invalid = ad_mode_st(ad_p, &admode, &st_dir);
admode = ad_hf_mode(admode);
}
/* retry with O_CREAT */
- ad->ad_md->adf_fd = open( ad_p, oflags,admode );
+ ad->ad_md->adf_fd = open(ad_p, oflags, admode);
if ( ad->ad_md->adf_fd < 0 ) {
return -1;
}
* API functions
********************************************************************************* */
-char *ad_path_ea( const char *path, int adflags _U_)
+const char *ad_path_ea( const char *path, int adflags _U_)
{
return path;
}
*
* FIXME: should do something for pathname > MAXPATHLEN
*/
-char *ad_path( const char *path, int adflags)
+const char *ad_path( const char *path, int adflags)
{
static char pathbuf[ MAXPATHLEN + 1];
const char *slash;
strlcat(buf, "DIR", 64);
first = 0;
}
- if (adflags & ADFLAGS_RDONLY) {
- if (!first)
- strlcat(buf, "|", 64);
- strlcat(buf, "RDONLY", 64);
- first = 0;
- }
if (adflags & ADFLAGS_OPENFORKS) {
if (!first)
strlcat(buf, "|", 64);
* ad_init(&ad, vol->v_adouble, vol->v_ad_options);
* @endcode
*
- * @param path Path to file or directory
- *
- * @param adflags ADFLAGS_DF: open data fork \n
- * ADFLAGS_RF: open ressource fork \n
- * ADFLAGS_HF: open header (metadata) file \n
- * ADFLAGS_NOHF: it's not an error if header file couldn't be created \n
- * ADFLAGS_DIR: if path is a directory you MUST or ADFLAGS_DIR to adflags \n
- * ADFLAGS_RDONLY: open read only \n
- * ADFLAGS_OPENFORKS: check for open forks from other processes
+ * Open a files data fork, metadata fork or ressource fork.
+ * For each fork to be opened specify the open flags and mode in case you want to create it
+ * (O_CREAT in open flags). The order in which forks are opened is:
+ * 1. ADFLAGS_DF
+ * 2. ADFLAGS_HF
+ * 3. ADFLAGS_RF
+ * The variable arguments must be passed according to this order.
*
- * @param oflags flags passed through to open syscall
- * @param mode passed to open with O_CREAT
- * @param ad pointer to struct adouble
+ * @param ad (rw) pointer to struct adouble
+ * @param path (r) Path to file or directory
+ * @param adflags (r) ADFLAGS_DF: open data fork \n
+ * ADFLAGS_RF: open ressource fork \n
+ * ADFLAGS_HF: open header (metadata) file \n
+ * ADFLAGS_NOHF: it's not an error if header file couldn't be created \n
+ * ADFLAGS_DIR: if path is a directory you MUST or ADFLAGS_DIR to adflags \n
+ * ADFLAGS_RDONLY: dont upgrade mode from r to rw with adouble:v2 headerfile \n
+ * ADFLAGS_OPENFORKS: check for open forks from other processes
*
* @returns 0 on success, any other value indicates an error
*/
-int ad_open(const char *path, int adflags, int oflags, int mode, struct adouble *ad)
+static int vad_open(struct adouble *ad, const char *path, int adflags, va_list args)
{
int ret = 0;
+ int oflags;
+ int mode;
- LOG(log_debug, logtype_default, "ad_open(\"%s\", %s, %s, 0%04o)",
- abspath(path), adflags2logstr(adflags), oflags2logstr(oflags), mode);
+ LOG(log_debug, logtype_default, "ad_open(\"%s\", %s)",
+ abspath(path), adflags2logstr(adflags));
if (ad->ad_inited != AD_INITED)
AFP_PANIC("ad_open: not initialized");
}
if ((adflags & ADFLAGS_DF) && !(ad->ad_adflags & ADFLAGS_DF)) {
+ oflags = va_arg(args, int);
+ if (oflags & O_CREAT)
+ mode = va_arg(args, int);
if (ad_open_df(path, adflags, oflags, mode, ad) != 0) {
ret = -1;
goto exit;
}
if ((adflags & ADFLAGS_HF) && !(ad->ad_adflags & ADFLAGS_HF)) {
+ oflags = va_arg(args, int);
+ if (oflags & O_CREAT)
+ mode = va_arg(args, int);
if (ad_open_hf(path, adflags, oflags, mode, ad) != 0) {
ret = -1;
goto exit;
}
if ((adflags & ADFLAGS_RF) && !(ad->ad_adflags & ADFLAGS_RF)) {
+ oflags = va_arg(args, int);
+ if (oflags & O_CREAT)
+ mode = va_arg(args, int);
if (ad_open_rf(path, adflags, oflags, mode, ad) != 0) {
ret = -1;
goto exit;
return ret;
}
+int ad_open(struct adouble *ad, const char *path, int adflags, ...)
+{
+ int ret;
+ va_list args;
+
+ va_start(args, adflags);
+ ret = vad_open(ad, path, adflags, args);
+ va_end(args);
+ return ret;
+}
+
/*!
* @brief open metadata, possibly as root
*
* Return only metadata but try very hard ie at first try as user, then try as root.
- * Caller must pass ADFLAGS_DIR for directories.
*
* @param name name of file/dir
* @param flags ADFLAGS_DIR: name is a directory \n
{
uid_t uid;
int ret, err, dir;
- int create = O_RDONLY;
dir = flags & ADFLAGS_DIR;
- if ((ret = ad_open(name, ADFLAGS_HF | dir, create, 0666, adp)) < 0 && errno == EACCES) {
+ if ((ret = ad_open(adp, name, ADFLAGS_HF | dir, O_RDONLY)) < 0 && errno == EACCES) {
uid = geteuid();
if (seteuid(0)) {
LOG(log_error, logtype_default, "ad_metadata(%s): seteuid failed %s", name, strerror(errno));
return -1;
}
/* we are root open read only */
- ret = ad_open(name, ADFLAGS_HF|ADFLAGS_RDONLY| dir, O_RDONLY, 0, adp);
+ ret = ad_open(adp, name, ADFLAGS_HF | dir, O_RDONLY);
err = errno;
if ( seteuid(uid) < 0) {
LOG(log_error, logtype_default, "ad_metadata: can't seteuid back");
return ad->ad_ops->ad_header_read(ad, NULL);
}
-int ad_openat(int dirfd, /* dir fd openat like */
+int ad_openat(struct adouble *ad,
+ int dirfd, /* dir fd openat like */
const char *path,
- int adflags,
- int oflags,
- int mode,
- struct adouble *ad)
+ int adflags, ...)
{
int ret = 0;
int cwdfd = -1;
+ va_list args;
if (dirfd != -1) {
if ((cwdfd = open(".", O_RDONLY) == -1) || (fchdir(dirfd) != 0)) {
}
}
- if (ad_open(path, adflags, oflags, mode, ad) < 0) {
+ va_start(args, adflags);
+
+ if (vad_open(ad, path, adflags, args) < 0) {
ret = -1;
goto exit;
}
+ va_end(args);
+
if (dirfd != -1) {
if (fchdir(cwdfd) != 0) {
- LOG(log_error, logtype_afpd, "ad_openat: cant chdir back, exiting");
- exit(EXITERR_SYS);
+ AFP_PANIC("ad_openat: cant chdir back");
}
}
#include <string.h>
#include <sys/param.h>
+#include <errno.h>
#include <atalk/adouble.h>
#include <atalk/ea.h>
extern void cnid_cdb_close (struct _cnid_db *);
/* cnid_add.c */
-extern cnid_t cnid_cdb_add (struct _cnid_db *, const struct stat *, const cnid_t,
- char *, const size_t, cnid_t);
+extern cnid_t cnid_cdb_add (struct _cnid_db *, const struct stat *, cnid_t,
+ const char *, size_t, cnid_t);
extern int cnid_cdb_getstamp (struct _cnid_db *, void *, const size_t );
/* cnid_get.c */
-extern cnid_t cnid_cdb_get (struct _cnid_db *, const cnid_t, char *, const size_t);
+extern cnid_t cnid_cdb_get (struct _cnid_db *, cnid_t, const char *, size_t);
extern char *cnid_cdb_resolve (struct _cnid_db *, cnid_t *, void *, size_t );
-extern cnid_t cnid_cdb_lookup (struct _cnid_db *, const struct stat *, const cnid_t,
- char *, const size_t);
+extern cnid_t cnid_cdb_lookup (struct _cnid_db *, const struct stat *, cnid_t,
+ const char *, size_t);
/* cnid_update.c */
-extern int cnid_cdb_update (struct _cnid_db *, const cnid_t, const struct stat *,
- const cnid_t, char *, size_t);
+extern int cnid_cdb_update (struct _cnid_db *, cnid_t, const struct stat *,
+ cnid_t, const char *, size_t);
/* cnid_delete.c */
extern int cnid_cdb_delete (struct _cnid_db *, const cnid_t);
extern int cnid_cdb_unlock (void *);
extern cnid_t cnid_cdb_rebuild_add (struct _cnid_db *, const struct stat *,
- const cnid_t, char *, const size_t, cnid_t);
+ cnid_t, const char *, size_t, cnid_t);
#endif /* include/atalk/cnid_cdb.h */
/*
- * $Id: cnid_cdb_add.c,v 1.8 2009-11-20 17:22:11 didg Exp $
- *
* Copyright (c) 1999. Adrian Sun (asun@zoology.washington.edu)
* All Rights Reserved. See COPYRIGHT.
*
#ifdef CNID_BACKEND_CDB
#include "cnid_cdb_private.h"
-extern int cnid_cdb_update(struct _cnid_db *cdb, const cnid_t id, const struct stat *st,
- const cnid_t did, char *name, const size_t len);
-
+extern int cnid_cdb_update(struct _cnid_db *cdb, cnid_t id, const struct stat *st,
+ cnid_t did, const char *name, size_t len);
#define tid NULL
/* ------------------------ */
cnid_t cnid_cdb_add(struct _cnid_db *cdb, const struct stat *st,
- const cnid_t did, char *name, const size_t len,
- cnid_t hint)
+ cnid_t did, const char *name, size_t len, cnid_t hint)
{
CNID_private *db;
DBT key, data;
-/*
- * $Id: cnid_cdb_get.c,v 1.5 2009-10-29 13:38:16 didg Exp $
- */
-
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif /* HAVE_CONFIG_H */
#include "cnid_cdb_private.h"
/* Return CNID for a given did/name. */
-cnid_t cnid_cdb_get(struct _cnid_db *cdb, const cnid_t did, char *name,
- const size_t len)
+cnid_t cnid_cdb_get(struct _cnid_db *cdb, cnid_t did, const char *name, size_t len)
{
char start[CNID_DID_LEN + MAXPATHLEN + 1], *buf;
CNID_private *db;
-/*
- * $Id: cnid_cdb_lookup.c,v 1.6 2009-11-20 17:22:11 didg Exp $
- */
-
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif /* HAVE_CONFIG_H */
/* This returns the CNID corresponding to a particular file. It will
* also fix up the various databases if there's a problem. */
-cnid_t cnid_cdb_lookup(struct _cnid_db *cdb, const struct stat *st, const cnid_t did,
- char *name, const size_t len)
+cnid_t cnid_cdb_lookup(struct _cnid_db *cdb, const struct stat *st, cnid_t did,
+ const char *name, size_t len)
{
unsigned char *buf;
CNID_private *db;
static char *old_dbfiles[] = {"cnid.db", NULL};
-/* -----------------------
- * bandaid for LanTest performance pb. for now not used, cf. ifdef 0 below
-*/
-static int my_yield(void)
-{
- struct timeval t;
- int ret;
-
- t.tv_sec = 0;
- t.tv_usec = 1000;
- ret = select(0, NULL, NULL, NULL, &t);
- return 0;
-}
-
/* --------------- */
static int didname(DB *dbp _U_, const DBT *pkey _U_, const DBT *pdata, DBT *skey)
{
}
}
- db_env_set_func_yield(my_yield);
return cdb;
fail_appinit:
return CNID_INVALID;
}
-/* ------------------------ */
cnid_t cnid_cdb_rebuild_add(struct _cnid_db *cdb, const struct stat *st,
- const cnid_t did, char *name, const size_t len,
- cnid_t hint)
+ cnid_t did, const char *name, size_t len, cnid_t hint)
{
CNID_private *db;
DBT key, data;
-/*
- * $Id: cnid_cdb_update.c,v 1.4 2009-11-20 17:22:11 didg Exp $
- */
-
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif /* HAVE_CONFIG_H */
/* cnid_update: takes the given cnid and updates the metadata. To
* handle the did/name data, there are a bunch of functions to get
* and set the various fields. */
-int cnid_cdb_update(struct _cnid_db *cdb, const cnid_t id, const struct stat *st,
- const cnid_t did, char *name, const size_t len
- /*, const char *info, const int infolen*/)
+int cnid_cdb_update(struct _cnid_db *cdb, cnid_t id, const struct stat *st,
+ cnid_t did, const char *name, size_t len)
{
unsigned char *buf;
CNID_private *db;
vecs = 1;
if (rqst->namelen) {
- iov[1].iov_base = rqst->name;
+ iov[1].iov_base = (char *)rqst->name;
iov[1].iov_len = rqst->namelen;
towrite += rqst->namelen;
vecs++;
/* ---------------------- */
cnid_t cnid_dbd_add(struct _cnid_db *cdb, const struct stat *st,
- const cnid_t did, char *name, const size_t len,
- cnid_t hint)
+ cnid_t did, const char *name, size_t len, cnid_t hint)
{
CNID_private *db;
struct cnid_dbd_rqst rqst;
}
/* ---------------------- */
-cnid_t cnid_dbd_get(struct _cnid_db *cdb, const cnid_t did, char *name, const size_t len)
+cnid_t cnid_dbd_get(struct _cnid_db *cdb, cnid_t did, const char *name, size_t len)
{
CNID_private *db;
struct cnid_dbd_rqst rqst;
}
/* ---------------------- */
-cnid_t cnid_dbd_lookup(struct _cnid_db *cdb, const struct stat *st, const cnid_t did,
- char *name, const size_t len)
+cnid_t cnid_dbd_lookup(struct _cnid_db *cdb, const struct stat *st, cnid_t did,
+ const char *name, size_t len)
{
CNID_private *db;
struct cnid_dbd_rqst rqst;
}
/* ---------------------- */
-int cnid_dbd_find(struct _cnid_db *cdb, char *name, size_t namelen, void *buffer, size_t buflen)
+int cnid_dbd_find(struct _cnid_db *cdb, const char *name, size_t namelen, void *buffer, size_t buflen)
{
CNID_private *db;
struct cnid_dbd_rqst rqst;
}
/* ---------------------- */
-int cnid_dbd_update(struct _cnid_db *cdb, const cnid_t id, const struct stat *st,
- const cnid_t did, char *name, const size_t len)
+int cnid_dbd_update(struct _cnid_db *cdb, cnid_t id, const struct stat *st,
+ cnid_t did, const char *name, size_t len)
{
CNID_private *db;
struct cnid_dbd_rqst rqst;
/* ---------------------- */
cnid_t cnid_dbd_rebuild_add(struct _cnid_db *cdb, const struct stat *st,
- const cnid_t did, char *name, const size_t len,
- cnid_t hint)
+ cnid_t did, const char *name, size_t len, cnid_t hint)
{
CNID_private *db;
struct cnid_dbd_rqst rqst;
extern struct _cnid_module cnid_dbd_module;
extern struct _cnid_db *cnid_dbd_open (struct cnid_open_args *args);
extern void cnid_dbd_close (struct _cnid_db *);
-extern cnid_t cnid_dbd_add (struct _cnid_db *, const struct stat *, const cnid_t,
- char *, const size_t, cnid_t);
-extern cnid_t cnid_dbd_get (struct _cnid_db *, const cnid_t, char *, const size_t);
+extern cnid_t cnid_dbd_add (struct _cnid_db *, const struct stat *, cnid_t,
+ const char *, size_t, cnid_t);
+extern cnid_t cnid_dbd_get (struct _cnid_db *, cnid_t, const char *, size_t);
extern char *cnid_dbd_resolve (struct _cnid_db *, cnid_t *, void *, size_t );
extern int cnid_dbd_getstamp (struct _cnid_db *, void *, const size_t );
-extern cnid_t cnid_dbd_lookup (struct _cnid_db *, const struct stat *, const cnid_t,
- char *, const size_t);
-extern int cnid_dbd_find (struct _cnid_db *cdb, char *name, size_t namelen,
+extern cnid_t cnid_dbd_lookup (struct _cnid_db *, const struct stat *, cnid_t,
+ const char *, size_t);
+extern int cnid_dbd_find (struct _cnid_db *cdb, const char *name, size_t namelen,
void *buffer, size_t buflen);
-extern int cnid_dbd_update (struct _cnid_db *, const cnid_t, const struct stat *,
- const cnid_t, char *, size_t);
+extern int cnid_dbd_update (struct _cnid_db *, cnid_t, const struct stat *,
+ cnid_t, const char *, size_t);
extern int cnid_dbd_delete (struct _cnid_db *, const cnid_t);
extern cnid_t cnid_dbd_rebuild_add(struct _cnid_db *, const struct stat *,
- const cnid_t, char *, const size_t, cnid_t);
+ cnid_t, const char *, size_t, cnid_t);
/* FIXME: These functions could be static in cnid_dbd.c */
/* ------------------------ */
cnid_t cnid_last_add(struct _cnid_db *cdb, const struct stat *st,
- const cnid_t did _U_, char *name _U_, const size_t len _U_, cnid_t hint _U_)
+ cnid_t did _U_, const char *name _U_, size_t len _U_, cnid_t hint _U_)
{
/* FIXME: it relies on fact, that this is never called twice for the same file/dir. */
}
-
/* Return CNID for a given did/name. */
-cnid_t cnid_last_get(struct _cnid_db *cdb _U_, const cnid_t did _U_, char *name _U_, const size_t len _U_)
+cnid_t cnid_last_get(struct _cnid_db *cdb _U_, cnid_t did _U_, const char *name _U_, size_t len _U_)
{
/* FIXME: it relies on fact, that this is never called twice for the same file/dir. */
/* Propably we should look through DID tree. */
}
-
/* */
-cnid_t cnid_last_lookup(struct _cnid_db *cdb _U_, const struct stat *st _U_, const cnid_t did _U_,
- char *name _U_, const size_t len _U_)
+cnid_t cnid_last_lookup(struct _cnid_db *cdb _U_, const struct stat *st _U_, cnid_t did _U_,
+ const char *name _U_, size_t len _U_)
{
/* FIXME: this function doesn't work in [last] scheme ! */
/* Should be never called or CNID should be somewhat refactored again. */
}
-int cnid_last_update(struct _cnid_db *cdb _U_, const cnid_t id _U_, const struct stat *st _U_,
- const cnid_t did _U_, char *name _U_, const size_t len _U_)
+int cnid_last_update(struct _cnid_db *cdb _U_, cnid_t id _U_, const struct stat *st _U_,
+ cnid_t did _U_, const char *name _U_, size_t len _U_)
{
return 0;
}
extern struct _cnid_module cnid_last_module;
extern struct _cnid_db *cnid_last_open (struct cnid_open_args *args);
extern void cnid_last_close (struct _cnid_db *);
-extern cnid_t cnid_last_add (struct _cnid_db *, const struct stat *, const cnid_t,
- char *, const size_t, cnid_t);
-extern cnid_t cnid_last_get (struct _cnid_db *, const cnid_t, char *, const size_t);
+extern cnid_t cnid_last_add (struct _cnid_db *, const struct stat *, cnid_t,
+ const char *, size_t, cnid_t);
+extern cnid_t cnid_last_get (struct _cnid_db *, cnid_t, const char *, size_t);
extern char *cnid_last_resolve (struct _cnid_db *, cnid_t *, void *, size_t);
-extern cnid_t cnid_last_lookup (struct _cnid_db *, const struct stat *, const cnid_t, char *, const size_t);
-extern int cnid_last_update (struct _cnid_db *, const cnid_t, const struct stat *,
- const cnid_t, char *, size_t);
-extern int cnid_last_delete (struct _cnid_db *, const cnid_t);
+extern cnid_t cnid_last_lookup (struct _cnid_db *, const struct stat *, cnid_t, const char *, size_t);
+extern int cnid_last_update (struct _cnid_db *, cnid_t, const struct stat *,
+ cnid_t, const char *, size_t);
+extern int cnid_last_delete (struct _cnid_db *, cnid_t);
#endif /* include/atalk/cnid_last.h */
extern void cnid_tdb_close (struct _cnid_db *);
/* cnid_add.c */
-extern cnid_t cnid_tdb_add (struct _cnid_db *, const struct stat *, const cnid_t,
- char *, const size_t, cnid_t);
+extern cnid_t cnid_tdb_add (struct _cnid_db *, const struct stat *, cnid_t,
+ const char *, size_t, cnid_t);
/* cnid_get.c */
-extern cnid_t cnid_tdb_get (struct _cnid_db *, const cnid_t, char *, const size_t);
+extern cnid_t cnid_tdb_get (struct _cnid_db *, cnid_t, const char *, size_t);
extern char *cnid_tdb_resolve (struct _cnid_db *, cnid_t *, void *, size_t);
-extern cnid_t cnid_tdb_lookup (struct _cnid_db *, const struct stat *, const cnid_t, char *, const size_t);
+extern cnid_t cnid_tdb_lookup (struct _cnid_db *, const struct stat *, cnid_t, const char *, size_t);
/* cnid_update.c */
-extern int cnid_tdb_update (struct _cnid_db *, const cnid_t, const struct stat *,
- const cnid_t, char *, size_t);
+extern int cnid_tdb_update (struct _cnid_db *, cnid_t, const struct stat *,
+ cnid_t, const char *, size_t);
/* cnid_delete.c */
extern int cnid_tdb_delete (struct _cnid_db *, const cnid_t);
/*
- * $Id: cnid_tdb_add.c,v 1.4 2009-11-20 17:37:14 didg Exp $
- *
* Copyright (c) 1999. Adrian Sun (asun@zoology.washington.edu)
* All Rights Reserved. See COPYRIGHT.
*
/* ------------------------ */
cnid_t cnid_tdb_add(struct _cnid_db *cdb, const struct stat *st,
- const cnid_t did, char *name, const size_t len, cnid_t hint)
+ cnid_t did, const char *name, size_t len, cnid_t hint)
{
const struct stat *lstp;
cnid_t id;
-/*
- * $Id: cnid_tdb_get.c,v 1.4 2009-11-20 17:37:14 didg Exp $
- */
-
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "cnid_tdb.h"
/* Return CNID for a given did/name. */
-cnid_t cnid_tdb_get(struct _cnid_db *cdb, const cnid_t did, char *name, const size_t len)
+cnid_t cnid_tdb_get(struct _cnid_db *cdb, cnid_t did, const char *name, size_t len)
{
char start[CNID_DID_LEN + MAXPATHLEN + 1], *buf;
struct _cnid_tdb_private *db;
-/*
- * $Id: cnid_tdb_lookup.c,v 1.6 2009-11-21 11:12:49 didg Exp $
- */
-
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "cnid_tdb.h"
#include <atalk/logger.h>
-cnid_t cnid_tdb_lookup(struct _cnid_db *cdb, const struct stat *st, const cnid_t did, char *name, const size_t len)
+cnid_t cnid_tdb_lookup(struct _cnid_db *cdb, const struct stat *st, cnid_t did, const char *name, size_t len)
{
char *buf;
struct _cnid_tdb_private *db;
/*
- * $Id: cnid_tdb_open.c,v 1.8 2010-03-31 09:47:32 franklahm Exp $
- *
* Copyright (c) 1999. Adrian Sun (asun@zoology.washington.edu)
* All Rights Reserved. See COPYRIGHT.
*
-/*
- * $Id: cnid_tdb_update.c,v 1.6 2009-11-21 11:12:49 didg Exp $
- */
-
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "cnid_tdb.h"
#include <atalk/logger.h>
-int cnid_tdb_update(struct _cnid_db *cdb, const cnid_t id, const struct stat *st,
- const cnid_t did, char *name, const size_t len
- /*, const char *info, const int infolen */ )
+int cnid_tdb_update(struct _cnid_db *cdb, cnid_t id, const struct stat *st,
+ cnid_t did, const char *name, size_t len)
{
struct _cnid_tdb_private *db;
TDB_DATA key, data, altdata;
noinst_LTLIBRARIES = libcompat.la
libcompat_la_SOURCES = \
- mktemp.c \
getusershell.c \
- strcasecmp.c \
- strstr.c \
- strdup.c \
- inet_aton.c \
rquota_xdr.c \
- pselect.c \
- snprintf.c
+ pselect.c
*/
char *ea_path(const struct ea * restrict ea, const char * restrict eaname, int macname)
{
- char *adname;
+ const char *adname;
static char pathbuf[MAXPATHLEN + 1];
/* get name of a adouble file from uname */
if (errno == ENOENT) {
/* Possibly the .AppleDouble folder didn't exist, we create it and try again */
ad_init(&ad, vol->v_adouble, vol->v_ad_options);
- if ((ad_open(dst, ADFLAGS_HF, O_RDWR | O_CREAT, 0666, &ad)) != 0) {
+ if ((ad_open(&ad, dst, ADFLAGS_HF, O_RDWR | O_CREAT, 0666)) != 0) {
LOG(log_error, logtype_afpd, "ea_renamefile('%s/%s'): ad_open error: '%s'", src, dst, dst);
ret = AFPERR_MISC;
goto exit;
if (errno == ENOENT) {
/* Possibly the .AppleDouble folder didn't exist, we create it and try again */
ad_init(&ad, vol->v_adouble, vol->v_ad_options);
- if ((ad_open(dst, ADFLAGS_HF, O_RDWR | O_CREAT, 0666, &ad)) != 0) {
+ if ((ad_open(&ad, dst, ADFLAGS_HF, O_RDWR | O_CREAT, 0666)) != 0) {
LOG(log_error, logtype_afpd, "ea_copyfile('%s/%s'): ad_open error: '%s'", src, dst, dst);
ret = AFPERR_MISC;
goto exit;
static int RF_chown_adouble(VFS_FUNC_ARGS_CHOWN)
{
struct stat st;
- char *ad_p;
+ const char *ad_p;
ad_p = vol->ad_path(path, ADFLAGS_HF );
/* ----------------- */
static int RF_setdirunixmode_adouble(VFS_FUNC_ARGS_SETDIRUNIXMODE)
{
- char *adouble = vol->ad_path(name, ADFLAGS_DIR );
+ const char *adouble = vol->ad_path(name, ADFLAGS_DIR );
int dropbox = vol->v_flags;
if (dir_rx_set(mode)) {
{
int dropbox = vol->v_flags;
mode_t hf_mode = ad_hf_mode(mode);
- char *adouble = vol->ad_path(name, ADFLAGS_DIR );
- char *adouble_p = ad_dir(adouble);
+ const char *adouble = vol->ad_path(name, ADFLAGS_DIR );
+ const char *adouble_p = ad_dir(adouble);
if (dir_rx_set(mode)) {
if (stickydirmode(ad_dir(adouble), DIRBITS | mode, dropbox, vol->v_umask) < 0)
* use a diff one, it's not a pb,ie it's not the same file, yet.
*/
ad_init(&ad, vol->v_adouble, vol->v_ad_options);
- if (!ad_open(dst, ADFLAGS_HF, O_RDWR | O_CREAT, 0666, &ad)) {
+ if (ad_open(&ad, dst, ADFLAGS_HF, O_RDWR | O_CREAT, 0666) == 0) {
ad_close(&ad, ADFLAGS_HF);
if (!unix_rename(dirfd, adsrc, -1, vol->ad_path(dst, 0 )) )
err = 0;