/*
- * $Id: volume.c,v 1.67 2006-09-19 23:00:50 didg Exp $
+ * $Id: volume.c,v 1.105 2009-11-24 11:40:11 didg Exp $
*
* Copyright (c) 1990,1993 Regents of The University of Michigan.
* All Rights Reserved. See COPYRIGHT.
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
-#include <dirent.h>
#include <pwd.h>
#include <grp.h>
#include <utime.h>
#include <atalk/adouble.h>
#include <atalk/afp.h>
#include <atalk/util.h>
+#include <atalk/volinfo.h>
#include <atalk/logger.h>
+#include <atalk/vfs.h>
#ifdef CNID_DB
#include <atalk/cnid.h>
#endif /* CNID_DB*/
#include "file.h"
#include "volume.h"
#include "unix.h"
+#include "mangle.h"
#include "fork.h"
+#include "hash.h"
extern int afprun(int root, char *cmd, int *outfd);
#define VOLOPT_FORCEUID 19 /* force uid for username x */
#define VOLOPT_FORCEGID 20 /* force gid for group x */
-#define VOLOPT_UMASK 21
-#define VOLOPT_DFLTPERM 22
-#else
-#define VOLOPT_UMASK 19
-#define VOLOPT_DFLTPERM 20
#endif /* FORCE_UIDGID */
+#define VOLOPT_UMASK 21
+#define VOLOPT_ALLOWED_HOSTS 22
+#define VOLOPT_DENIED_HOSTS 23
+#define VOLOPT_DPERM 24 /* dperm default directories perms */
+#define VOLOPT_FPERM 25 /* fperm default files perms */
+#define VOLOPT_DFLTPERM 26 /* perm */
+#define VOLOPT_EA_VFS 27 /* Extended Attributes vfs indirection */
+
#define VOLOPT_MAX (VOLOPT_DFLTPERM +1)
#define VOLOPT_NUM (VOLOPT_MAX + 1)
#define VOLPASSLEN 8
#define VOLOPT_DEFAULT ":DEFAULT:"
#define VOLOPT_DEFAULT_LEN 9
- struct vol_option {
- char *c_value;
- int i_value;
- };
+
+struct vol_option {
+ char *c_value;
+ int i_value;
+};
typedef struct _special_folder {
const char *name;
const char *name;
} _vol_opt_name;
+
+/* Keep in sync with libatalk/util/volinfo.c ! */
static const _vol_opt_name vol_opt_names[] = {
{AFPVOL_A2VOL, "PRODOS"}, /* prodos volume */
{AFPVOL_CRLF, "CRLF"}, /* cr/lf translation */
{AFPVOL_NODEV, "NODEV"}, /* always use 0 for device number in cnid calls */
{AFPVOL_CASEINSEN, "CASEINSENSITIVE"}, /* volume is case insensitive */
{AFPVOL_EILSEQ, "ILLEGALSEQ"}, /* encode illegal sequence */
- {AFPVOL_CACHE, "CACHEID"}, /* Use adouble v2 CNID caching, default don't use it */
+ {AFPVOL_CACHE, "CACHEID"}, /* Use adouble v2 CNID caching. Default: yes */
+ {AFPVOL_ACLS, "ACLS"}, /* Vol supports ACLs */
+ {AFPVOL_TM, "TM"}, /* Set "kSupportsTMLockSteal" is volume attributes */
{0, NULL}
};
static void handle_special_folders (const struct vol *);
static int savevoloptions (const struct vol *);
static void deletevol(struct vol *vol);
+static void volume_free(struct vol *vol);
-static __inline__ void volfree(struct vol_option *options,
+static void volfree(struct vol_option *options,
const struct vol_option *save)
{
int i;
static char *volxlate(AFPObj *obj, char *dest, size_t destlen,
char *src, struct passwd *pwd, char *path, char *volname)
{
- char *p, *q;
+ char *p, *r;
+ const char *q;
int len;
char *ret;
} else if (obj->proto == AFPPROTO_DSI) {
DSI *dsi = obj->handle;
-
- len = sprintf(dest, "%s:%u", inet_ntoa(dsi->client.sin_addr),
- ntohs(dsi->client.sin_port));
+ len = sprintf(dest, "%s:%u",
+ getip_string((struct sockaddr *)&dsi->client),
+ getip_port((struct sockaddr *)&dsi->client));
dest += len;
destlen -= len;
}
} else if (is_var(p, "$d")) {
q = path;
} else if (is_var(p, "$f")) {
- if ((q = strchr(pwd->pw_gecos, ',')))
- *q = '\0';
+ if ((r = strchr(pwd->pw_gecos, ',')))
+ *r = '\0';
q = pwd->pw_gecos;
} else if (is_var(p, "$g")) {
struct group *grp = getgrgid(pwd->pw_gid);
} else if (obj->proto == AFPPROTO_DSI) {
DSI *dsi = obj->handle;
-
- q = inet_ntoa(dsi->client.sin_addr);
- }
+ q = getip_string((struct sockaddr *)&dsi->client);
+ }
} else if (is_var(p, "$s")) {
if (obj->Obj)
q = obj->Obj;
} else
q = obj->options.hostname;
} else if (is_var(p, "$u")) {
- q = obj->username;
+ char* sep = NULL;
+ if ( obj->options.ntseparator && (sep = strchr(obj->username, obj->options.ntseparator[0])) != NULL)
+ q = sep+1;
+ else
+ q = obj->username;
} else if (is_var(p, "$v")) {
if (volname) {
q = volname;
options[VOLOPT_ADOUBLE].i_value = AD_VERSION2;
else if (strcasecmp(val + 1, "osx") == 0)
options[VOLOPT_ADOUBLE].i_value = AD_VERSION2_OSX;
- else if (strcasecmp(val + 1, "ads") == 0)
- options[VOLOPT_ADOUBLE].i_value = AD_VERSION1_ADS;
+ else if (strcasecmp(val + 1, "sfm") == 0)
+ options[VOLOPT_ADOUBLE].i_value = AD_VERSION1_SFM;
#endif
} else if (optionok(tmp, "options:", val)) {
char *p;
options[VOLOPT_ROOTPREEXEC].i_value = 1;
else if (strcasecmp(p, "upriv") == 0)
options[VOLOPT_FLAGS].i_value |= AFPVOL_UNIX_PRIV;
+ else if (strcasecmp(p, "acls") == 0)
+ options[VOLOPT_FLAGS].i_value |= AFPVOL_ACLS;
else if (strcasecmp(p, "nodev") == 0)
options[VOLOPT_FLAGS].i_value |= AFPVOL_NODEV;
else if (strcasecmp(p, "caseinsensitive") == 0)
options[VOLOPT_FLAGS].i_value |= AFPVOL_CASEINSEN;
else if (strcasecmp(p, "illegalseq") == 0)
options[VOLOPT_FLAGS].i_value |= AFPVOL_EILSEQ;
- else if (strcasecmp(p, "cachecnid") == 0)
- options[VOLOPT_FLAGS].i_value |= AFPVOL_CACHE;
+ else if (strcasecmp(p, "nocnidcache") == 0)
+ options[VOLOPT_FLAGS].i_value &= ~AFPVOL_CACHE;
+ else if (strcasecmp(p, "tm") == 0)
+ options[VOLOPT_FLAGS].i_value |= AFPVOL_TM;
p = strtok(NULL, ",");
}
} else if (optionok(tmp, "umask:", val)) {
options[VOLOPT_UMASK].i_value = (int)strtol(val +1, NULL, 8);
+ } else if (optionok(tmp, "dperm:", val)) {
+ options[VOLOPT_DPERM].i_value = (int)strtol(val+1, NULL, 8);
+ } else if (optionok(tmp, "fperm:", val)) {
+ options[VOLOPT_FPERM].i_value = (int)strtol(val+1, NULL, 8);
} else if (optionok(tmp, "perm:", val)) {
options[VOLOPT_DFLTPERM].i_value = (int)strtol(val+1, NULL, 8);
} else if (optionok(tmp, "mapchars:",val)) {
} else if (optionok(tmp, "postexec:", val)) {
setoption(options, save, VOLOPT_POSTEXEC, val);
+ } else if (optionok(tmp, "allowed_hosts:", val)) {
+ setoption(options, save, VOLOPT_ALLOWED_HOSTS, val);
+
+ } else if (optionok(tmp, "denied_hosts:", val)) {
+ setoption(options, save, VOLOPT_DENIED_HOSTS, val);
+
+ } else if (optionok(tmp, "ea:", val)) {
+ if (strcasecmp(val + 1, "ad") == 0) /* the default anyway */
+ options[VOLOPT_EA_VFS].i_value = AFPVOL_EA_AD;
+ else if (strcasecmp(val + 1, "sys") == 0)
+ options[VOLOPT_EA_VFS].i_value = AFPVOL_EA_SYS;
+
} else {
/* ignore unknown options */
LOG(log_debug, logtype_afpd, "ignoring unknown volume option: %s", tmp);
{
struct vol *volume;
for ( volume = Volumes; volume; volume = volume->v_next ) {
- if (volume->v_hide && !strcasecmp_w( volume->v_name, name ) ) {
+ if (volume->v_hide && !strcasecmp_w( volume->v_name, name ) ) {
volume->v_hide = 0;
return;
}
)
{
struct vol *volume;
- int vlen;
+ int suffixlen, vlen, tmpvlen, u8mvlen, macvlen;
int hide = 0;
- ucs2_t tmpname[512];
+ char tmpname[AFPVOL_U8MNAMELEN+1];
+ ucs2_t u8mtmpname[(AFPVOL_U8MNAMELEN+1)*2], mactmpname[(AFPVOL_MACNAMELEN+1)*2];
+ char suffix[6]; /* max is #FFFF */
+ u_int16_t flags;
if ( name == NULL || *name == '\0' ) {
if ((name = strrchr( path, '/' )) == NULL) {
return -1;
}
+ /* suffix for mangling use (lastvid + 1) */
+ /* because v_vid has not been decided yet. */
+ suffixlen = sprintf(suffix, "%c%X", MANGLE_CHAR, lastvid + 1 );
+
vlen = strlen( name );
- if ( vlen > AFPVOL_NAMELEN ) {
- vlen = AFPVOL_NAMELEN;
- name[AFPVOL_NAMELEN] = '\0';
+
+ /* Unicode Volume Name */
+ /* Firstly convert name from unixcharset to UTF8-MAC */
+ flags = CONV_IGNORE;
+ tmpvlen = convert_charset(obj->options.unixcharset, CH_UTF8_MAC, 0, name, vlen, tmpname, AFPVOL_U8MNAMELEN, &flags);
+ if (tmpvlen <= 0) {
+ strcpy(tmpname, "???");
+ tmpvlen = 3;
+ }
+
+ /* Do we have to mangle ? */
+ if ( (flags & CONV_REQMANGLE) || (tmpvlen > obj->options.volnamelen)) {
+ if (tmpvlen + suffixlen > obj->options.volnamelen) {
+ flags = CONV_FORCE;
+ tmpvlen = convert_charset(obj->options.unixcharset, CH_UTF8_MAC, 0, name, vlen, tmpname, obj->options.volnamelen - suffixlen, &flags);
+ tmpname[tmpvlen >= 0 ? tmpvlen : 0] = 0;
+ }
+ strcat(tmpname, suffix);
+ tmpvlen = strlen(tmpname);
}
- /* convert name to UCS2 first */
- if ( 0 >= ( vlen = convert_string(obj->options.unixcharset, CH_UCS2, name, vlen, tmpname, 512)) )
+ /* Secondly convert name from UTF8-MAC to UCS2 */
+ if ( 0 >= ( u8mvlen = convert_string(CH_UTF8_MAC, CH_UCS2, tmpname, tmpvlen, u8mtmpname, AFPVOL_U8MNAMELEN*2)) )
return -1;
+ LOG(log_debug, logtype_afpd, "createvol: Volume '%s' -> UTF8-MAC Name: '%s'", name, tmpname);
+
+ /* Maccharset Volume Name */
+ /* Firsty convert name from unixcharset to maccharset */
+ flags = CONV_IGNORE;
+ tmpvlen = convert_charset(obj->options.unixcharset, obj->options.maccharset, 0, name, vlen, tmpname, AFPVOL_U8MNAMELEN, &flags);
+ if (tmpvlen <= 0) {
+ strcpy(tmpname, "???");
+ tmpvlen = 3;
+ }
+
+ /* Do we have to mangle ? */
+ if ( (flags & CONV_REQMANGLE) || (tmpvlen > AFPVOL_MACNAMELEN)) {
+ if (tmpvlen + suffixlen > AFPVOL_MACNAMELEN) {
+ flags = CONV_FORCE;
+ tmpvlen = convert_charset(obj->options.unixcharset, obj->options.maccharset, 0, name, vlen, tmpname, AFPVOL_MACNAMELEN - suffixlen, &flags);
+ tmpname[tmpvlen >= 0 ? tmpvlen : 0] = 0;
+ }
+ strcat(tmpname, suffix);
+ tmpvlen = strlen(tmpname);
+ }
+
+ /* Secondly convert name from maccharset to UCS2 */
+ if ( 0 >= ( macvlen = convert_string(obj->options.maccharset, CH_UCS2, tmpname, tmpvlen, mactmpname, AFPVOL_U8MNAMELEN*2)) )
+ return -1;
+
+ LOG(log_debug, logtype_afpd, "createvol: Volume '%s' -> Longname: '%s'", name, tmpname);
+
+ /* check duplicate */
for ( volume = Volumes; volume; volume = volume->v_next ) {
- if ( strcasecmp_w( volume->v_name, tmpname ) == 0 ) {
+ if (( strcasecmp_w( volume->v_u8mname, u8mtmpname ) == 0 ) || ( strcasecmp_w( volume->v_macname, mactmpname ) == 0 )){
if (volume->v_deleted) {
volume->v_new = hide = 1;
}
}
}
-
if (!( volume = (struct vol *)calloc(1, sizeof( struct vol ))) ) {
LOG(log_error, logtype_afpd, "creatvol: malloc: %s", strerror(errno) );
return -1;
}
- if ( NULL == ( volume->v_name = strdup_w(tmpname))) {
+ if ( NULL == ( volume->v_localname = strdup(name))) {
+ LOG(log_error, logtype_afpd, "creatvol: malloc: %s", strerror(errno) );
+ free(volume);
+ return -1;
+ }
+
+ if ( NULL == ( volume->v_u8mname = strdup_w(u8mtmpname))) {
+ LOG(log_error, logtype_afpd, "creatvol: malloc: %s", strerror(errno) );
+ volume_free(volume);
+ free(volume);
+ return -1;
+ }
+ if ( NULL == ( volume->v_macname = strdup_w(mactmpname))) {
LOG(log_error, logtype_afpd, "creatvol: malloc: %s", strerror(errno) );
+ volume_free(volume);
free(volume);
return -1;
}
if (!( volume->v_path = (char *)malloc( strlen( path ) + 1 )) ) {
LOG(log_error, logtype_afpd, "creatvol: malloc: %s", strerror(errno) );
- free(volume->v_name);
+ volume_free(volume);
free(volume);
return -1;
}
+
+ volume->v_name = utf8_encoding()?volume->v_u8mname:volume->v_macname;
volume->v_hide = hide;
strcpy( volume->v_path, path );
/* os X start at 1 and use network order ie. 1 2 3 */
volume->v_vid = ++lastvid;
volume->v_vid = htons(volume->v_vid);
+ volume->v_vfs_ea = AFPVOL_EA_AD;
/* handle options */
if (options) {
/* shift in some flags */
volume->v_flags = options[VOLOPT_FLAGS].i_value;
+
+ if (options[VOLOPT_EA_VFS].i_value != AFPVOL_EA_AD)
+ volume->v_vfs_ea = options[VOLOPT_EA_VFS].i_value;
volume->v_ad_options = 0;
if ((volume->v_flags & AFPVOL_NODEV))
if (options[VOLOPT_UMASK].i_value)
volume->v_umask = (mode_t)options[VOLOPT_UMASK].i_value;
+ if (options[VOLOPT_DPERM].i_value)
+ volume->v_dperm = (mode_t)options[VOLOPT_DPERM].i_value;
+
+ if (options[VOLOPT_FPERM].i_value)
+ volume->v_fperm = (mode_t)options[VOLOPT_FPERM].i_value;
+
if (options[VOLOPT_DFLTPERM].i_value)
volume->v_perm = (mode_t)options[VOLOPT_DFLTPERM].i_value;
else
volume->v_adouble = AD_VERSION;
+ /* Mac to Unix conversion flags*/
+ volume->v_mtou_flags = 0;
+ if (!(volume->v_flags & AFPVOL_NOHEX))
+ volume->v_mtou_flags |= CONV_ESCAPEHEX;
+ if (!(volume->v_flags & AFPVOL_USEDOTS))
+ volume->v_mtou_flags |= CONV_ESCAPEDOTS;
+ if ((volume->v_flags & AFPVOL_EILSEQ))
+ volume->v_mtou_flags |= CONV__EILSEQ;
+
+ if ((volume->v_casefold & AFPVOL_MTOUUPPER))
+ volume->v_mtou_flags |= CONV_TOUPPER;
+ else if ((volume->v_casefold & AFPVOL_MTOULOWER))
+ volume->v_mtou_flags |= CONV_TOLOWER;
+
+ /* Unix to Mac conversion flags*/
+ volume->v_utom_flags = CONV_IGNORE | CONV_UNESCAPEHEX;
+ if ((volume->v_casefold & AFPVOL_UTOMUPPER))
+ volume->v_utom_flags |= CONV_TOUPPER;
+ else if ((volume->v_casefold & AFPVOL_UTOMLOWER))
+ volume->v_utom_flags |= CONV_TOLOWER;
+
+ if ((volume->v_flags & AFPVOL_EILSEQ))
+ volume->v_utom_flags |= CONV__EILSEQ;
+
initvol_vfs(volume);
+
#ifdef FORCE_UIDGID
if (options[VOLOPT_FORCEUID].c_value) {
volume->v_forceuid = strdup(options[VOLOPT_FORCEUID].c_value);
volume->v_root_postexec = volxlate(obj, NULL, MAXPATHLEN, options[VOLOPT_ROOTPOSTEXEC].c_value, pwd, path, name);
}
}
+ volume->v_dperm |= volume->v_perm;
+ volume->v_fperm |= volume->v_perm;
volume->v_next = Volumes;
Volumes = volume;
}
/* ---------------- */
-static char *myfgets( buf, size, fp )
-char *buf;
-int size;
-FILE *fp;
+static char *myfgets( char *buf, int size, FILE *fp)
{
char *p;
int c;
p = buf;
- while ((EOF != ( c = getc( fp )) ) && ( size > 0 )) {
+ while ((EOF != ( c = getc( fp )) ) && ( size > 1 )) {
if ( c == '\n' || c == '\r' ) {
+ if (p != buf && *(p -1) == '\\') {
+ p--;
+ size++;
+ continue;
+ }
*p++ = '\n';
break;
} else {
#endif
-static int accessvol(args, name)
-const char *args;
-const char *name;
+static int accessvol(const char *args, const char *name)
{
char buf[MAXPATHLEN + 1], *p;
struct group *gr;
return 0;
}
-static void setextmap( ext, type, creator, user)
-char *ext, *type, *creator;
-int user;
+static int hostaccessvol(int type, const char *volname, const char *args, const AFPObj *obj)
+{
+ int mask_int;
+ char buf[MAXPATHLEN + 1], *p, *b;
+ DSI *dsi = obj->handle;
+ struct sockaddr_storage client;
+
+ if (!args)
+ return -1;
+
+ strlcpy(buf, args, sizeof(buf));
+ if ((p = strtok_r(buf, ",", &b)) == NULL) /* nothing, return okay */
+ return -1;
+
+ if (obj->proto != AFPPROTO_DSI)
+ return -1;
+
+ while (p) {
+ int ret;
+ char *ipaddr, *mask_char;
+ struct addrinfo hints, *ai;
+
+ ipaddr = strtok(p, "/");
+ mask_char = strtok(NULL,"/");
+
+ /* Get address from string with getaddrinfo */
+ memset(&hints, 0, sizeof hints);
+ hints.ai_family = AF_UNSPEC;
+ hints.ai_socktype = SOCK_STREAM;
+ if ((ret = getaddrinfo(ipaddr, NULL, &hints, &ai)) != 0) {
+ LOG(log_error, logtype_afpd, "hostaccessvol: getaddrinfo: %s\n", gai_strerror(ret));
+ continue;
+ }
+
+ /* netmask */
+ if (mask_char != NULL)
+ mask_int = atoi(mask_char); /* apply_ip_mask does range checking on it */
+ else {
+ if (ai->ai_family == AF_INET) /* IPv4 */
+ mask_int = 32;
+ else /* IPv6 */
+ mask_int = 128;
+ }
+
+ /* Apply mask to addresses */
+ client = dsi->client;
+ apply_ip_mask((struct sockaddr *)&client, mask_int);
+ apply_ip_mask(ai->ai_addr, mask_int);
+
+ if (compare_ip((struct sockaddr *)&client, ai->ai_addr) == 0) {
+ if (type == VOLOPT_DENIED_HOSTS)
+ LOG(log_info, logtype_afpd, "AFP access denied for client IP '%s' to volume '%s' by denied list",
+ getip_string((struct sockaddr *)&client), volname);
+ freeaddrinfo(ai);
+ return 1;
+ }
+
+ /* next address */
+ freeaddrinfo(ai);
+ p = strtok_r(NULL, ",", &b);
+ }
+
+ if (type == VOLOPT_ALLOWED_HOSTS)
+ LOG(log_info, logtype_afpd, "AFP access denied for client IP '%s' to volume '%s', not in allowed list",
+ getip_string((struct sockaddr *)&dsi->client), volname);
+ return 0;
+}
+
+static void setextmap(char *ext, char *type, char *creator, int user)
{
struct extmap *em;
int cnt;
* [codepage:<file>] [casefold:<num>]
* <extension> TYPE [CREATOR]
*/
-static int readvolfile(obj, p1, p2, user, pwent)
-AFPObj *obj;
-struct afp_volume_name *p1;
-char *p2;
-int user;
-struct passwd *pwent;
+static int readvolfile(AFPObj *obj, struct afp_volume_name *p1, char *p2, int user, struct passwd *pwent)
{
FILE *fp;
char path[ MAXPATHLEN + 1], tmp[ MAXPATHLEN + 1],
- volname[ AFPVOL_NAMELEN + 1 ], buf[ BUFSIZ ],
+ volname[ AFPVOL_U8MNAMELEN + 1 ], buf[ BUFSIZ ],
type[ 5 ], creator[ 5 ];
char *u, *p;
struct passwd *pw;
}
memset(save_options, 0, sizeof(save_options));
+
+ /* Enable some default options for all volumes */
+ save_options[VOLOPT_FLAGS].i_value |= AFPVOL_CACHE;
+
while ( myfgets( buf, sizeof( buf ), fp ) != NULL ) {
initline( strlen( buf ), buf );
parseline( sizeof( path ) - 1, path );
allow -> either no list (-1), or in list (1)
deny -> either no list (-1), or not in list (0) */
if (accessvol(options[VOLOPT_ALLOW].c_value, obj->username) &&
- (accessvol(options[VOLOPT_DENY].c_value, obj->username) < 1)) {
+ (accessvol(options[VOLOPT_DENY].c_value, obj->username) < 1) &&
+ hostaccessvol(VOLOPT_ALLOWED_HOSTS, volname, options[VOLOPT_ALLOWED_HOSTS].c_value, obj) &&
+ (hostaccessvol(VOLOPT_DENIED_HOSTS, volname, options[VOLOPT_DENIED_HOSTS].c_value, obj) < 1)) {
/* handle read-only behaviour. semantics:
* 1) neither the rolist nor the rwlist exist -> rw
/* ------------------------------- */
static void volume_free(struct vol *vol)
{
- free(vol->v_name);
- vol->v_name = NULL;
+ free(vol->v_localname);
+ vol->v_localname = NULL;
+ free(vol->v_u8mname);
+ vol->v_u8mname = NULL;
+ free(vol->v_macname);
+ vol->v_macname = NULL;
free(vol->v_path);
free(vol->v_password);
free(vol->v_veto);
for ( vol = Volumes, ovol = NULL; vol; vol = nvol) {
nvol = vol->v_next;
- if (vol->v_name == NULL) {
+ if (vol->v_localname == NULL) {
if (Volumes == vol) {
Volumes = nvol;
ovol = Volumes;
}
}
-static int getvolspace( vol, bfree, btotal, xbfree, xbtotal, bsize )
-struct vol *vol;
-u_int32_t *bfree, *btotal, *bsize;
-VolSpace *xbfree, *xbtotal;
+static int getvolspace(struct vol *vol,
+ u_int32_t *bfree, u_int32_t *btotal,
+ VolSpace *xbfree, VolSpace *xbtotal, u_int32_t *bsize)
{
int spaceflag, rc;
u_int32_t maxsize;
}
/* ----------------------- */
-static int getvolparams( bitmap, vol, st, buf, buflen )
-u_int16_t bitmap;
-struct vol *vol;
-struct stat *st;
-char *buf;
-int *buflen;
+static int getvolparams( u_int16_t bitmap, struct vol *vol, struct stat *st, char *buf, size_t *buflen)
{
struct adouble ad;
int bit = 0, isad = 1;
char *data, *nameoff = NULL;
char *slash;
+ LOG(log_debug, logtype_afpd, "getvolparams: Volume '%s'", vol->v_localname);
+
/* courtesy of jallison@whistle.com:
* For MacOS8.x support we need to create the
* .Parent file here if it doesn't exist. */
isad = 0;
vol->v_ctime = AD_DATE_FROM_UNIX(st->st_mtime);
- } else if (ad_get_HF_flags( &ad ) & O_CREAT) {
+ } else if (ad_get_MD_flags( &ad ) & O_CREAT) {
slash = strrchr( vol->v_path, '/' );
if(slash)
slash++;
ad_getentrylen( &ad, ADEID_NAME ));
}
vol_setdate(vol->v_vid, &ad, st->st_mtime);
- ad_flush_metadata(&ad);
+ ad_flush(&ad);
}
else {
if (ad_getdate(&ad, AD_DATE_CREATE, &aint) < 0)
(1<<VOLPBIT_XBFREE)|(1<<VOLPBIT_XBTOTAL) |
(1<<VOLPBIT_BSIZE)) ) != 0 ) {
if ( getvolspace( vol, &bfree, &btotal, &xbfree, &xbtotal,
- &bsize) < 0 ) {
+ &bsize) != AFP_OK ) {
if ( isad ) {
ad_close( &ad, ADFLAGS_HF );
}
ashort |= VOLPBIT_ATTR_RO;
}
ashort |= VOLPBIT_ATTR_CATSEARCH;
+ ashort |= VOLPBIT_ATTR_EXT_ATTRS;
if (afp_version >= 30) {
ashort |= VOLPBIT_ATTR_UTF8;
- if (vol->v_flags & AFPVOL_UNIX_PRIV)
- ashort |= VOLPBIT_ATTR_UNIXPRIV;
+ if (vol->v_flags & AFPVOL_UNIX_PRIV)
+ ashort |= VOLPBIT_ATTR_UNIXPRIV;
+ if (vol->v_flags & AFPVOL_TM)
+ ashort |= VOLPBIT_ATTR_TM;
+ }
+ if (afp_version >= 32) {
+ if (vol->v_flags & AFPVOL_ACLS)
+ ashort |= VOLPBIT_ATTR_ACLS;
}
ashort = htons(ashort);
memcpy(data, &ashort, sizeof( ashort ));
if ( nameoff ) {
ashort = htons( data - buf );
memcpy(nameoff, &ashort, sizeof( ashort ));
- /* name is always in mac charset, FIXME mangle if length > 27 char */
- aint = ucs2_to_charset( vol->v_maccharset, vol->v_name, data+1, 255);
+ /* name is always in mac charset */
+ aint = ucs2_to_charset( vol->v_maccharset, vol->v_macname, data+1, AFPVOL_MACNAMELEN + 1);
if ( aint <= 0 ) {
*buflen = 0;
return AFPERR_MISC;
}
/* ------------------------- */
-static int stat_vol(u_int16_t bitmap, struct vol *vol, char *rbuf, int *rbuflen)
+static int stat_vol(u_int16_t bitmap, struct vol *vol, char *rbuf, size_t *rbuflen)
{
struct stat st;
- int buflen, ret;
+ int ret;
+ size_t buflen;
if ( stat( vol->v_path, &st ) < 0 ) {
*rbuflen = 0;
}
/* ------------------------------- */
-int afp_getsrvrparms(obj, ibuf, ibuflen, rbuf, rbuflen )
-AFPObj *obj;
-char *ibuf _U_, *rbuf;
-int ibuflen _U_, *rbuflen;
+int afp_getsrvrparms(AFPObj *obj, char *ibuf _U_, size_t ibuflen _U_, char *rbuf, size_t *rbuflen)
{
struct timeval tv;
struct stat st;
if (volume->v_hide) {
continue; /* config file changed but the volume was mounted */
}
- len = ucs2_to_charset_allocate((utf8_encoding()?CH_UTF8_MAC:obj->options.maccharset),
- &namebuf, volume->v_name);
+
+ if (utf8_encoding()) {
+ len = ucs2_to_charset_allocate(CH_UTF8_MAC, &namebuf, volume->v_u8mname);
+ } else {
+ len = ucs2_to_charset_allocate(obj->options.maccharset, &namebuf, volume->v_macname);
+ }
+
if (len == (size_t)-1)
continue;
*rbuflen = data - rbuf;
data = rbuf;
- if ( gettimeofday( &tv, 0 ) < 0 ) {
+ if ( gettimeofday( &tv, NULL ) < 0 ) {
LOG(log_error, logtype_afpd, "afp_getsrvrparms(%s): gettimeofday: %s", volume->v_path, strerror(errno) );
*rbuflen = 0;
return AFPERR_PARAM;
return( AFP_OK );
}
+/* ------------------------- */
+static int volume_codepage(AFPObj *obj, struct vol *volume)
+{
+ struct charset_functions *charset;
+ /* Codepages */
+
+ if (!volume->v_volcodepage)
+ volume->v_volcodepage = strdup("UTF8");
+
+ if ( (charset_t) -1 == ( volume->v_volcharset = add_charset(volume->v_volcodepage)) ) {
+ LOG (log_error, logtype_afpd, "Setting codepage %s as volume codepage failed", volume->v_volcodepage);
+ return -1;
+ }
+
+ if ( NULL == (charset = find_charset_functions(volume->v_volcodepage)) || charset->flags & CHARSET_ICONV ) {
+ LOG (log_warning, logtype_afpd, "WARNING: volume encoding %s is *not* supported by netatalk, expect problems !!!!", volume->v_volcodepage);
+ }
+
+ if (!volume->v_maccodepage)
+ volume->v_maccodepage = strdup(obj->options.maccodepage);
+
+ if ( (charset_t) -1 == ( volume->v_maccharset = add_charset(volume->v_maccodepage)) ) {
+ LOG (log_error, logtype_afpd, "Setting codepage %s as mac codepage failed", volume->v_maccodepage);
+ return -1;
+ }
+
+ if ( NULL == ( charset = find_charset_functions(volume->v_maccodepage)) || ! (charset->flags & CHARSET_CLIENT) ) {
+ LOG (log_error, logtype_afpd, "Fatal error: mac charset %s not supported", volume->v_maccodepage);
+ return -1;
+ }
+ volume->v_kTextEncoding = htonl(charset->kTextEncoding);
+ return 0;
+}
+
+/* ------------------------- */
+static int volume_openDB(struct vol *volume)
+{
+ int flags = 0;
+
+ if ((volume->v_flags & AFPVOL_NODEV)) {
+ flags |= CNID_FLAG_NODEV;
+ }
+
+ if (volume->v_cnidscheme == NULL) {
+ volume->v_cnidscheme = strdup(DEFAULT_CNID_SCHEME);
+ LOG(log_info, logtype_afpd, "Volume %s use CNID scheme %s.", volume->v_path, volume->v_cnidscheme);
+ }
+ if (volume->v_dbpath)
+ volume->v_cdb = cnid_open (volume->v_dbpath, volume->v_umask, volume->v_cnidscheme, flags);
+ else
+ volume->v_cdb = cnid_open (volume->v_path, volume->v_umask, volume->v_cnidscheme, flags);
+ return (!volume->v_cdb)?-1:0;
+}
+
/* -------------------------
* we are the user here
*/
-int afp_openvol(obj, ibuf, ibuflen, rbuf, rbuflen )
-AFPObj *obj;
-char *ibuf, *rbuf;
-int ibuflen _U_, *rbuflen;
+int afp_openvol(AFPObj *obj, char *ibuf, size_t ibuflen _U_, char *rbuf, size_t *rbuflen)
{
struct stat st;
char *volname;
char *p;
+
struct vol *volume;
struct dir *dir;
int len, ret;
char path[ MAXPATHLEN + 1];
char *vol_uname;
char *vol_mname;
-
+ char *volname_tmp;
+
ibuf += 2;
memcpy(&bitmap, ibuf, sizeof( bitmap ));
bitmap = ntohs( bitmap );
ibuf += sizeof( bitmap );
+
+ *rbuflen = 0;
if (( bitmap & (1<<VOLPBIT_VID)) == 0 ) {
- *rbuflen = 0;
return AFPERR_BITMAP;
}
len = (unsigned char)*ibuf++;
volname = obj->oldtmp;
- namelen = convert_string( (utf8_encoding()?CH_UTF8_MAC:obj->options.maccharset), CH_UCS2,
- ibuf, len, volname, sizeof(obj->oldtmp));
- if ( namelen <= 0){
- *rbuflen = 0;
+
+ if ((volname_tmp = strchr(volname,'+')) != NULL)
+ volname = volname_tmp+1;
+
+ if (utf8_encoding()) {
+ namelen = convert_string(CH_UTF8_MAC, CH_UCS2, ibuf, len, volname, sizeof(obj->oldtmp));
+ } else {
+ namelen = convert_string(obj->options.maccharset, CH_UCS2, ibuf, len, volname, sizeof(obj->oldtmp));
+ }
+
+ if ( namelen <= 0) {
return AFPERR_PARAM;
}
}
if ( volume == NULL ) {
- *rbuflen = 0;
return AFPERR_PARAM;
}
/* check for a volume password */
if (volume->v_password && strncmp(ibuf, volume->v_password, VOLPASSLEN)) {
- *rbuflen = 0;
return AFPERR_ACCESS;
}
return stat_vol(bitmap, volume, rbuf, rbuflen);
}
- /* initialize volume variables
- * FIXME file size
- */
- if (afp_version >= 30) {
- volume->max_filename = 255;
- }
- else {
- volume->max_filename = MACFILELEN;
- }
-
- volume->v_dir = volume->v_root = NULL;
- volume->v_hash = NULL;
-
- volume->v_flags |= AFPVOL_OPEN;
- volume->v_cdb = NULL;
-
if (volume->v_root_preexec) {
if ((ret = afprun(1, volume->v_root_preexec, NULL)) && volume->v_root_preexec_close) {
LOG(log_error, logtype_afpd, "afp_openvol(%s): root preexec : %d", volume->v_path, ret );
- ret = AFPERR_MISC;
- goto openvol_err;
+ return AFPERR_MISC;
}
}
if (volume->v_preexec) {
if ((ret = afprun(0, volume->v_preexec, NULL)) && volume->v_preexec_close) {
LOG(log_error, logtype_afpd, "afp_openvol(%s): preexec : %d", volume->v_path, ret );
- ret = AFPERR_MISC;
- goto openvol_err;
+ return AFPERR_MISC;
}
}
if ( stat( volume->v_path, &st ) < 0 ) {
- ret = AFPERR_PARAM;
- goto openvol_err;
+ return AFPERR_PARAM;
}
if ( chdir( volume->v_path ) < 0 ) {
- ret = AFPERR_PARAM;
- goto openvol_err;
+ return AFPERR_PARAM;
}
- len = convert_string_allocate( CH_UCS2, (utf8_encoding()?CH_UTF8_MAC:obj->options.maccharset),
- volume->v_name, namelen, &vol_mname);
- if ( !vol_mname || len <= 0) {
- ret = AFPERR_MISC;
- goto openvol_err;
- }
-
if ( NULL == getcwd(path, MAXPATHLEN)) {
/* shouldn't be fatal but it will fail later */
LOG(log_error, logtype_afpd, "afp_openvol(%s): volume pathlen too long", volume->v_path);
+ return AFPERR_MISC;
+ }
+
+ if (volume_codepage(obj, volume) < 0) {
+ ret = AFPERR_MISC;
+ goto openvol_err;
+ }
+
+ /* initialize volume variables
+ * FIXME file size
+ */
+ if (utf8_encoding()) {
+ volume->max_filename = 255;
+ }
+ else {
+ volume->max_filename = MACFILELEN;
+ }
+
+ volume->v_dir = volume->v_root = NULL;
+ volume->v_hash = NULL;
+
+ volume->v_flags |= AFPVOL_OPEN;
+ volume->v_cdb = NULL;
+
+ if (utf8_encoding()) {
+ len = convert_string_allocate(CH_UCS2, CH_UTF8_MAC, volume->v_u8mname, namelen, &vol_mname);
+ } else {
+ len = convert_string_allocate(CH_UCS2, obj->options.maccharset, volume->v_macname, namelen, &vol_mname);
+ }
+ if ( !vol_mname || len <= 0) {
ret = AFPERR_MISC;
goto openvol_err;
- }
+ }
if ((vol_uname = strrchr(path, '/')) == NULL)
vol_uname = path;
dir->d_color = DIRTREE_COLOR_BLACK; /* root node is black */
dir->d_m_name_ucs2 = strdup_w(volume->v_name);
volume->v_dir = volume->v_root = dir;
+ volume->v_curdir = NULL;
volume->v_hash = dirhash();
curdir = volume->v_dir;
- if (volume->v_cnidscheme == NULL) {
- volume->v_cnidscheme = strdup(DEFAULT_CNID_SCHEME);
- LOG(log_warning, logtype_afpd, "Warning: No CNID scheme for volume %s. Using default.",
- volume->v_path);
- }
- if (volume->v_dbpath)
- volume->v_cdb = cnid_open (volume->v_dbpath, volume->v_umask, volume->v_cnidscheme, (volume->v_flags & AFPVOL_NODEV));
- else
- volume->v_cdb = cnid_open (volume->v_path, volume->v_umask, volume->v_cnidscheme, (volume->v_flags & AFPVOL_NODEV));
- if (volume->v_cdb == NULL) {
+ if (volume_openDB(volume) < 0) {
LOG(log_error, logtype_afpd, "Fatal error: cannot open CNID or invalid CNID backend for %s: %s",
volume->v_path, volume->v_cnidscheme);
ret = AFPERR_MISC;
goto openvol_err;
}
- /* Codepages */
-
- if (!volume->v_volcodepage)
- volume->v_volcodepage = strdup("UTF8");
-
- if ( (charset_t) -1 == ( volume->v_volcharset = add_charset(volume->v_volcodepage)) ) {
- LOG (log_error, logtype_afpd, "Setting codepage %s as volume codepage failed", volume->v_volcodepage);
- ret = AFPERR_MISC;
- goto openvol_err;
- }
-
- if ( NULL == ( volume->v_vol = find_charset_functions(volume->v_volcodepage)) || volume->v_vol->flags & CHARSET_ICONV ) {
- LOG (log_warning, logtype_afpd, "WARNING: volume encoding %s is *not* supported by netatalk, expect problems !!!!", volume->v_volcodepage);
- }
-
- if (!volume->v_maccodepage)
- volume->v_maccodepage = strdup(obj->options.maccodepage);
-
- if ( (charset_t) -1 == ( volume->v_maccharset = add_charset(volume->v_maccodepage)) ) {
- LOG (log_error, logtype_afpd, "Setting codepage %s as mac codepage failed", volume->v_maccodepage);
- ret = AFPERR_MISC;
- goto openvol_err;
- }
-
- if ( NULL == ( volume->v_mac = find_charset_functions(volume->v_maccodepage)) || ! (volume->v_mac->flags & CHARSET_CLIENT) ) {
- LOG (log_error, logtype_afpd, "Fatal error: mac charset %s not supported", volume->v_maccodepage);
- ret = AFPERR_MISC;
- goto openvol_err;
- }
-
ret = stat_vol(bitmap, volume, rbuf, rbuflen);
if (ret == AFP_OK) {
closevol(vol);
if (vol->v_deleted) {
- showvol(vol->v_name);
+ showvol(vol->v_name);
volume_free(vol);
volume_unlink(vol);
free(vol);
}
/* ------------------------- */
-int afp_closevol(obj, ibuf, ibuflen, rbuf, rbuflen )
-AFPObj *obj _U_;
-char *ibuf, *rbuf _U_;
-int ibuflen _U_, *rbuflen;
+int afp_closevol(AFPObj *obj _U_, char *ibuf, size_t ibuflen _U_, char *rbuf _U_, size_t *rbuflen)
{
struct vol *vol;
u_int16_t vid;
char *p;
struct extmap *em;
- if (NULL == ( p = strrchr( path, '.' )) ) {
+ if (!Extmap_cnt || NULL == ( p = strrchr( path, '.' )) ) {
return( Defextmap );
}
p++;
- if (!*p || !Extmap_cnt) {
+ if (!*p) {
return( Defextmap );
}
em = bsearch(p, Extmap, Extmap_cnt, sizeof(struct extmap), ext_cmp_key);
/* --------------------------
poll if a volume is changed by other processes.
+ return
+ 0 no attention msg sent
+ 1 attention msg sent
+ -1 error (socket closed)
+
+ Note: if attention return -1 no packet has been
+ sent because the buffer is full, we don't care
+ either there's no reader or there's a lot of
+ traffic and another pollvoltime will follow
*/
-int pollvoltime(obj)
-AFPObj *obj;
+int pollvoltime(AFPObj *obj)
+
{
struct vol *vol;
struct timeval tv;
if (!(afp_version > 21 && obj->options.server_notif))
return 0;
- if ( gettimeofday( &tv, 0 ) < 0 )
+ if ( gettimeofday( &tv, NULL ) < 0 )
return 0;
for ( vol = Volumes; vol; vol = vol->v_next ) {
}
/* ------------------------- */
-void setvoltime(obj, vol )
-AFPObj *obj;
-struct vol *vol;
+void setvoltime(AFPObj *obj, struct vol *vol)
{
struct timeval tv;
* the afpd processes would come closer)
* [RS] */
- if ( gettimeofday( &tv, 0 ) < 0 ) {
+ if ( gettimeofday( &tv, NULL ) < 0 ) {
LOG(log_error, logtype_afpd, "setvoltime(%s): gettimeofday: %s", vol->v_path, strerror(errno) );
return;
}
/* a little granularity */
if (vol->v_mtime < tv.tv_sec) {
vol->v_mtime = tv.tv_sec;
- /* or finder doesn't update free space */
+ /* or finder doesn't update free space
+ * XXX is it still true with newer OSX?
+ */
if (afp_version > 21 && obj->options.server_notif) {
obj->attention(obj->handle, AFPATTN_NOTIFY | AFPATTN_VOLCHANGED);
}
}
/* ------------------------- */
-int afp_getvolparams(obj, ibuf, ibuflen, rbuf, rbuflen )
-AFPObj *obj _U_;
-char *ibuf, *rbuf;
-int ibuflen _U_, *rbuflen;
+int afp_getvolparams(AFPObj *obj _U_, char *ibuf, size_t ibuflen _U_,char *rbuf, size_t *rbuflen)
{
struct vol *vol;
u_int16_t vid, bitmap;
}
/* ------------------------- */
-int afp_setvolparams(obj, ibuf, ibuflen, rbuf, rbuflen )
-AFPObj *obj _U_;
-char *ibuf, *rbuf _U_;
-int ibuflen _U_, *rbuflen;
+int afp_setvolparams(AFPObj *obj _U_, char *ibuf, size_t ibuflen _U_, char *rbuf _U_, size_t *rbuflen)
{
struct adouble ad;
struct vol *vol;
memcpy(&aint, ibuf, sizeof(aint));
ad_setdate(&ad, AD_DATE_BACKUP, aint);
- ad_flush(&ad, ADFLAGS_HF);
+ ad_flush(&ad);
ad_close(&ad, ADFLAGS_HF);
return( AFP_OK );
}
memcpy(ad_entry(&ad, ADEID_FINDERI) + FINDERINFO_FRFLAGOFF,&attr, sizeof(attr));
}
- ad_flush( &ad, ADFLAGS_HF );
+ ad_flush( &ad );
ad_close( &ad, ADFLAGS_HF );
}
free(p);
case AD_VERSION2_OSX:
strlcat(buf, "ADOUBLE_VER:osx\n", sizeof(buf));
break;
- case AD_VERSION1_ADS:
- strlcat(buf, "ADOUBLE_VER:ads\n", sizeof(buf));
+ case AD_VERSION1_SFM:
+ strlcat(buf, "ADOUBLE_VER:sfm\n", sizeof(buf));
break;
}
strlcat(buf, Cnid_srv, sizeof(buf));
strlcat(buf, "\n", sizeof(buf));
- snprintf(item, sizeof(item), "CNIDDBDPORT:%u\n", Cnid_port);
- strlcat(buf, item, sizeof(buf));
+ strlcat(buf, "CNIDDBDPORT:", sizeof(buf));
+ strlcat(buf, Cnid_port, sizeof(buf));
+ strlcat(buf, "\n", sizeof(buf));
strcpy(item, "CNID_DBPATH:");
if (vol->v_dbpath)
LOG(log_debug, logtype_afpd,"Error writing .volinfo file: buffer too small, %s", buf);
- if (write( fd, buf, strlen(buf)) < 0) {
+ if (write( fd, buf, strlen(buf)) < 0 || ftruncate(fd, strlen(buf)) < 0 ) {
LOG(log_debug, logtype_afpd,"Error writing .volinfo file: %s", strerror(errno));
- goto done;
}
- ftruncate(fd, strlen(buf));
-done:
lock.l_type = F_UNLCK;
fcntl(fd, F_SETLK, &lock);
close (fd);
projects / netatalk.git / blobdiff