X-Git-Url: https://arthur.barton.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=etc%2Fafpd%2Fafp_config.c;h=291148c3458eeeca77432d751f5813128620d198;hb=465246e257d9aff9855e3e35d8fd5983db932b45;hp=bbed20a88a0573e49269c46398bcf301b6742174;hpb=f09999a8db03917a6324cde8747d35ef7d44c1b1;p=netatalk.git diff --git a/etc/afpd/afp_config.c b/etc/afpd/afp_config.c index bbed20a8..291148c3 100644 --- a/etc/afpd/afp_config.c +++ b/etc/afpd/afp_config.c @@ -1,6 +1,4 @@ /* - * $Id: afp_config.c,v 1.11 2001-12-15 18:34:39 jmarcus Exp $ - * * Copyright (c) 1997 Adrian Sun (asun@zoology.washington.edu) * All Rights Reserved. See COPYRIGHT. */ @@ -13,32 +11,19 @@ #include #include #include - -/* STDC check */ -#if STDC_HEADERS #include -#else /* STDC_HEADERS */ -#ifndef HAVE_STRCHR -#define strchr index -#define strrchr index -#endif /* HAVE_STRCHR */ -char *strchr (), *strrchr (); -#ifndef HAVE_MEMCPY -#define memcpy(d,s,n) bcopy ((s), (d), (n)) -#define memmove(d,s,n) bcopy ((s), (d), (n)) -#endif /* ! HAVE_MEMCPY */ -#endif /* STDC_HEADERS */ - -#ifdef HAVE_UNISTD_H #include -#endif /* HAVE_UNISTD_H */ #include -#include - #include #include #include +#ifdef USE_SRVLOC +#include +#endif /* USE_SRVLOC */ + +#include +#include #include #include #include @@ -46,15 +31,17 @@ char *strchr (), *strrchr (); #include #include #include -#ifdef USE_SRVLOC -#include -static char srvloc_url[512]; -#endif /* USE_SRVLOC */ -#include "globals.h" +#ifdef HAVE_LDAP +#include +#endif + +#include #include "afp_config.h" #include "uam_auth.h" #include "status.h" +#include "volume.h" +#include "afp_zeroconf.h" #define LINESIZE 1024 @@ -93,48 +80,113 @@ void configfree(AFPConfig *configs, const AFPConfig *config) } free(p); } + + /* the master loaded the volumes for zeroconf, get rid of that */ + unload_volumes_and_extmap(); } #ifdef USE_SRVLOC -static void SRVLOC_callback(SLPHandle hslp, SLPError errcode, void *cookie) { +static void SRVLOC_callback(SLPHandle hslp _U_, SLPError errcode, void *cookie) { *(SLPError*)cookie = errcode; } + +static char hex[17] = "0123456789abcdef"; + +static char * srvloc_encode(const struct afp_options *options, const char *name) +{ + static char buf[512]; + char *conv_name; + unsigned char *p; + unsigned int i = 0; +#ifndef NO_DDP + char *Obj, *Type = "", *Zone = ""; +#endif + + /* Convert name to maccharset */ + if ((size_t)-1 ==(convert_string_allocate( options->unixcharset, options->maccharset, + name, -1, &conv_name)) ) + return (char*)name; + + /* Escape characters */ + p = conv_name; + while (*p && i<(sizeof(buf)-4)) { + if (*p == '@') + break; + else if (isspace(*p)) { + buf[i++] = '%'; + buf[i++] = '2'; + buf[i++] = '0'; + p++; + } + else if ((!isascii(*p)) || *p <= 0x2f || *p == 0x3f ) { + buf[i++] = '%'; + buf[i++] = hex[*p >> 4]; + buf[i++] = hex[*p++ & 15]; + } + else { + buf[i++] = *p++; + } + } + buf[i] = '\0'; + +#ifndef NO_DDP + /* Add ZONE, */ + if (nbp_name(options->server, &Obj, &Type, &Zone )) { + LOG(log_error, logtype_afpd, "srvloc_encode: can't parse %s", options->server ); + } + else { + snprintf( buf+i, sizeof(buf)-i-1 ,"&ZONE=%s", Zone); + } +#endif + free (conv_name); + + return buf; +} #endif /* USE_SRVLOC */ -#ifdef USE_SRVLOC static void dsi_cleanup(const AFPConfig *config) { +#ifdef USE_SRVLOC SLPError err; SLPError callbackerr; SLPHandle hslp; + DSI *dsi = (DSI *)config->obj.handle; + + /* Do nothing if we didn't register. */ + if (!dsi || dsi->srvloc_url[0] == '\0') + return; + err = SLPOpen("en", SLP_FALSE, &hslp); if (err != SLP_OK) { - syslog(LOG_ERR, "Error opening SRVLOC handle"); + LOG(log_error, logtype_afpd, "dsi_cleanup: Error opening SRVLOC handle"); goto srvloc_dereg_err; } err = SLPDereg(hslp, - srvloc_url, + dsi->srvloc_url, SRVLOC_callback, &callbackerr); if (err != SLP_OK) { - syslog(LOG_ERR, "Error unregistering %s from SRVLOC", srvloc_url); + LOG(log_error, logtype_afpd, "dsi_cleanup: Error unregistering %s from SRVLOC", dsi->srvloc_url); goto srvloc_dereg_err; } if (callbackerr != SLP_OK) { - syslog(LOG_ERR, "Error in callback while trying to unregister %s from SRVLOC (%i)", srvloc_url, callbackerr); + LOG(log_error, logtype_afpd, "dsi_cleanup: Error in callback while trying to unregister %s from SRVLOC (%d)", dsi->srvloc_url, callbackerr); goto srvloc_dereg_err; } srvloc_dereg_err: + dsi->srvloc_url[0] = '\0'; SLPClose(hslp); -} #endif /* USE_SRVLOC */ +} #ifndef NO_DDP static void asp_cleanup(const AFPConfig *config) { + /* we need to stop tickle handler */ + asp_stop_tickle(); nbp_unrgstr(config->obj.Obj, config->obj.Type, config->obj.Zone, &config->obj.options.ddpaddr); } @@ -148,8 +200,8 @@ static int asp_start(AFPConfig *config, AFPConfig *configs, if (!(asp = asp_getsession(config->obj.handle, server_children, config->obj.options.tickleval))) { - syslog( LOG_ERR, "main: asp_getsession: %s", strerror(errno) ); - exit( 1 ); + LOG(log_error, logtype_afpd, "main: asp_getsession: %s", strerror(errno) ); + exit( EXITERR_CLNT ); } if (asp->child) { @@ -162,25 +214,30 @@ static int asp_start(AFPConfig *config, AFPConfig *configs, } #endif /* no afp/asp */ -static int dsi_start(AFPConfig *config, AFPConfig *configs, - server_child *server_children) +static afp_child_t *dsi_start(AFPConfig *config, AFPConfig *configs, + server_child *server_children) { - DSI *dsi; + DSI *dsi = config->obj.handle; + afp_child_t *child = NULL; - if (!(dsi = dsi_getsession(config->obj.handle, server_children, - config->obj.options.tickleval))) { - syslog( LOG_ERR, "main: dsi_getsession: %s", strerror(errno) ); - exit( 1 ); + if (!(child = dsi_getsession(dsi, + server_children, + config->obj.options.tickleval))) { + LOG(log_error, logtype_afpd, "dsi_start: session error: %s", strerror(errno)); + return NULL; } /* we've forked. */ - if (dsi->child) { + if (parent_or_child == 1) { configfree(configs, config); + config->obj.ipc_fd = child->ipc_fds[1]; + close(child->ipc_fds[0]); /* Close parent IPC fd */ + free(child); afp_over_dsi(&config->obj); /* start a session */ exit (0); } - return 0; + return child; } #ifndef NO_DDP @@ -191,18 +248,19 @@ static AFPConfig *ASPConfigInit(const struct afp_options *options, ATP atp; ASP asp; char *Obj, *Type = "AFPServer", *Zone = "*"; + char *convname = NULL; if ((config = (AFPConfig *) calloc(1, sizeof(AFPConfig))) == NULL) return NULL; if ((atp = atp_open(ATADDR_ANYPORT, &options->ddpaddr)) == NULL) { - syslog( LOG_ERR, "main: atp_open: %s", strerror(errno) ); + LOG(log_error, logtype_afpd, "main: atp_open: %s", strerror(errno) ); free(config); return NULL; } if ((asp = asp_init( atp )) == NULL) { - syslog( LOG_ERR, "main: asp_init: %s", strerror(errno) ); + LOG(log_error, logtype_afpd, "main: asp_init: %s", strerror(errno) ); atp_close(atp); free(config); return NULL; @@ -210,10 +268,20 @@ static AFPConfig *ASPConfigInit(const struct afp_options *options, /* register asp server */ Obj = (char *) options->hostname; - if (nbp_name(options->server, &Obj, &Type, &Zone )) { - syslog( LOG_ERR, "main: can't parse %s", options->server ); + if (options->server && (size_t)-1 ==(convert_string_allocate( options->unixcharset, options->maccharset, + options->server, strlen(options->server), &convname)) ) { + if ((convname = strdup(options->server)) == NULL ) { + LOG(log_error, logtype_afpd, "malloc: %s", strerror(errno) ); + goto serv_free_return; + } + } + + if (nbp_name(convname, &Obj, &Type, &Zone )) { + LOG(log_error, logtype_afpd, "main: can't parse %s", options->server ); goto serv_free_return; } + if (convname) + free (convname); /* dup Obj, Type and Zone as they get assigned to a single internal * buffer by nbp_name */ @@ -234,17 +302,17 @@ static AFPConfig *ASPConfigInit(const struct afp_options *options, /* make sure we're not registered */ nbp_unrgstr(Obj, Type, Zone, &options->ddpaddr); if (nbp_rgstr( atp_sockaddr( atp ), Obj, Type, Zone ) < 0 ) { - syslog( LOG_ERR, "Can't register %s:%s@%s", Obj, Type, Zone ); + LOG(log_error, logtype_afpd, "Can't register %s:%s@%s", Obj, Type, Zone ); free(config->obj.Obj); free(config->obj.Type); free(config->obj.Zone); goto serv_free_return; } - syslog( LOG_INFO, "%s:%s@%s started on %u.%u:%u (%s)", Obj, Type, Zone, - ntohs( atp_sockaddr( atp )->sat_addr.s_net ), - atp_sockaddr( atp )->sat_addr.s_node, - atp_sockaddr( atp )->sat_port, VERSION ); + LOG(log_info, logtype_afpd, "%s:%s@%s started on %u.%u:%u (%s)", Obj, Type, Zone, + ntohs( atp_sockaddr( atp )->sat_addr.s_net ), + atp_sockaddr( atp )->sat_addr.s_node, + atp_sockaddr( atp )->sat_port, VERSION ); config->fd = atp_fileno(atp); config->obj.handle = asp; @@ -275,81 +343,111 @@ static AFPConfig *DSIConfigInit(const struct afp_options *options, AFPConfig *config; DSI *dsi; char *p, *q; -#ifdef USE_SRVLOC - SLPError err; - SLPError callbackerr; - SLPHandle hslp; - struct servent *afpovertcp; -#endif /* USE_SRVLOC */ if ((config = (AFPConfig *) calloc(1, sizeof(AFPConfig))) == NULL) { - syslog( LOG_ERR, "DSIConfigInit: malloc(config): %s", strerror(errno) ); + LOG(log_error, logtype_afpd, "DSIConfigInit: malloc(config): %s", strerror(errno) ); return NULL; } + LOG(log_debug, logtype_afpd, "DSIConfigInit: hostname: %s, ip/port: %s/%s, ", + options->hostname, + options->ipaddr ? options->ipaddr : "default", + options->port ? options->port : "548"); + if ((dsi = dsi_init(protocol, "afpd", options->hostname, options->ipaddr, options->port, options->flags & OPTION_PROXY, options->server_quantum)) == NULL) { - syslog( LOG_ERR, "main: dsi_init: %s", strerror(errno) ); + LOG(log_error, logtype_afpd, "main: dsi_init: %s", strerror(errno) ); free(config); return NULL; } + dsi->dsireadbuf = options->dsireadbuf; if (options->flags & OPTION_PROXY) { - syslog(LOG_INFO, "ASIP proxy initialized for %s:%d (%s)", - inet_ntoa(dsi->server.sin_addr), ntohs(dsi->server.sin_port), - VERSION); + LOG(log_note, logtype_afpd, "AFP/TCP proxy initialized for %s:%d (%s)", + getip_string((struct sockaddr *)&dsi->server), getip_port((struct sockaddr *)&dsi->server), VERSION); } else { - syslog(LOG_INFO, "ASIP started on %s:%d(%d) (%s)", - inet_ntoa(dsi->server.sin_addr), ntohs(dsi->server.sin_port), - dsi->serversock, VERSION); + LOG(log_note, logtype_afpd, "AFP/TCP started, advertising %s:%d (%s)", + getip_string((struct sockaddr *)&dsi->server), getip_port((struct sockaddr *)&dsi->server), VERSION); } #ifdef USE_SRVLOC - err = SLPOpen("en", SLP_FALSE, &hslp); - if (err != SLP_OK) { - syslog(LOG_ERR, "Error opening SRVLOC handle"); - goto srvloc_reg_err; - } - - /* XXX We don't want to tack on the port number if we don't have to. Why? - * Well, this seems to break MacOS < 10. If the user _really_ wants to - * use a non-default port, they can, but be aware, this server might not - * show up int the Network Browser. */ - afpovertcp = getservbyname("afpovertcp", "tcp"); - if (dsi->server.sin_port == afpovertcp->s_port) { - snprintf(srvloc_url, sizeof(srvloc_url), "afp://%s/?NAME=%s", inet_ntoa(dsi->server.sin_addr), options->hostname); - } - else { - snprintf(srvloc_url, sizeof(srvloc_url), "afp://%s:%d/?NAME=%s", inet_ntoa(dsi->server.sin_addr), ntohs(dsi->server.sin_port), options->hostname); - } - - err = SLPReg(hslp, - srvloc_url, - SLP_LIFETIME_MAXIMUM, - "", - "", - SLP_TRUE, - SRVLOC_callback, - &callbackerr); - if (err != SLP_OK) { - syslog(LOG_ERR, "Error registering %s with SRVLOC", srvloc_url); - goto srvloc_reg_err; - } - - if (callbackerr != SLP_OK) { - syslog(LOG_ERR, "Error in callback trying to register %s with SRVLOC", srvloc_url); - goto srvloc_reg_err; - } - - syslog(LOG_INFO, "Sucessfully registered %s with SRVLOC", srvloc_url); + dsi->srvloc_url[0] = '\0'; /* Mark that we haven't registered. */ + if (!(options->flags & OPTION_NOSLP)) { + SLPError err; + SLPError callbackerr; + SLPHandle hslp; + unsigned int afp_port; + int l; + char *srvloc_hostname; + const char *hostname; + + err = SLPOpen("en", SLP_FALSE, &hslp); + if (err != SLP_OK) { + LOG(log_error, logtype_afpd, "DSIConfigInit: Error opening SRVLOC handle"); + goto srvloc_reg_err; + } + + /* XXX We don't want to tack on the port number if we don't have to. + * Why? + * Well, this seems to break MacOS < 10. If the user _really_ wants to + * use a non-default port, they can, but be aware, this server might + * not show up int the Network Browser. + */ + afp_port = getip_port((struct sockaddr *)&dsi->server); + /* If specified use the FQDN to register with srvloc, otherwise use IP. */ + p = NULL; + if (options->fqdn) { + hostname = options->fqdn; + p = strchr(hostname, ':'); + } + else + hostname = getip_string((struct sockaddr *)&dsi->server); + + srvloc_hostname = srvloc_encode(options, (options->server ? options->server : options->hostname)); + + if ((p) || afp_port == 548) { + l = snprintf(dsi->srvloc_url, sizeof(dsi->srvloc_url), "afp://%s/?NAME=%s", hostname, srvloc_hostname); + } + else { + l = snprintf(dsi->srvloc_url, sizeof(dsi->srvloc_url), "afp://%s:%d/?NAME=%s", hostname, afp_port, srvloc_hostname); + } + + if (l == -1 || l >= (int)sizeof(dsi->srvloc_url)) { + LOG(log_error, logtype_afpd, "DSIConfigInit: Hostname is too long for SRVLOC"); + dsi->srvloc_url[0] = '\0'; + goto srvloc_reg_err; + } + + err = SLPReg(hslp, + dsi->srvloc_url, + SLP_LIFETIME_MAXIMUM, + "afp", + "", + SLP_TRUE, + SRVLOC_callback, + &callbackerr); + if (err != SLP_OK) { + LOG(log_error, logtype_afpd, "DSIConfigInit: Error registering %s with SRVLOC", dsi->srvloc_url); + dsi->srvloc_url[0] = '\0'; + goto srvloc_reg_err; + } + + if (callbackerr != SLP_OK) { + LOG(log_error, logtype_afpd, "DSIConfigInit: Error in callback trying to register %s with SRVLOC", dsi->srvloc_url); + dsi->srvloc_url[0] = '\0'; + goto srvloc_reg_err; + } + + LOG(log_info, logtype_afpd, "Sucessfully registered %s with SRVLOC", dsi->srvloc_url); + config->server_cleanup = dsi_cleanup; srvloc_reg_err: - SLPClose(hslp); + SLPClose(hslp); + } #endif /* USE_SRVLOC */ - config->fd = dsi->serversock; config->obj.handle = dsi; config->obj.config = config; @@ -366,16 +464,13 @@ srvloc_reg_err: (*refcount)++; config->server_start = dsi_start; -#ifdef USE_SRVLOC - config->server_cleanup = dsi_cleanup; -#endif /* USE_SRVLOC */ return config; } /* allocate server configurations. this should really store the last * entry in config->last or something like that. that would make * supporting multiple dsi transports easier. */ -static AFPConfig *AFPConfigInit(const struct afp_options *options, +static AFPConfig *AFPConfigInit(struct afp_options *options, const struct afp_options *defoptions) { AFPConfig *config = NULL, *next = NULL; @@ -383,7 +478,7 @@ static AFPConfig *AFPConfigInit(const struct afp_options *options, if ((refcount = (unsigned char *) calloc(1, sizeof(unsigned char))) == NULL) { - syslog( LOG_ERR, "AFPConfigInit: calloc(refcount): %s", strerror(errno) ); + LOG(log_error, logtype_afpd, "AFPConfigInit: calloc(refcount): %s", strerror(errno) ); return NULL; } @@ -394,6 +489,10 @@ static AFPConfig *AFPConfigInit(const struct afp_options *options, config->defoptions = defoptions; #endif /* NO_DDP */ + + /* set signature */ + set_signature(options); + /* handle dsi transports and dsi proxies. we only proxy * for DSI connections. */ @@ -434,17 +533,29 @@ AFPConfig *configinit(struct afp_options *cmdline) { FILE *fp; char buf[LINESIZE + 1], *p, have_option = 0; + size_t len; struct afp_options options; - AFPConfig *config, *first = NULL; + AFPConfig *config=NULL, *first = NULL; /* if config file doesn't exist, load defaults */ if ((fp = fopen(cmdline->configfile, "r")) == NULL) + { + LOG(log_debug, logtype_afpd, "ConfigFile %s not found, assuming defaults", + cmdline->configfile); return AFPConfigInit(cmdline, cmdline); + } /* scan in the configuration file */ + len = 0; while (!feof(fp)) { - if (!fgets(buf, sizeof(buf), fp) || buf[0] == '#') + if (!fgets(&buf[len], LINESIZE - len, fp) || buf[len] == '#') continue; + len = strlen(buf); + if ( len >= 2 && buf[len-2] == '\\' ) { + len -= 2; + continue; + } else + len = 0; /* a little pre-processing to get rid of spaces and end-of-lines */ p = buf; @@ -459,7 +570,7 @@ AFPConfig *configinit(struct afp_options *cmdline) if (!afp_options_parseline(p, &options)) continue; - /* this should really get a head and a tail to simplify things. */ + /* AFPConfigInit can return two linked configs due to DSI and ASP */ if (!first) { if ((first = AFPConfigInit(&options, cmdline))) config = first->next ? first->next : first; @@ -468,10 +579,22 @@ AFPConfig *configinit(struct afp_options *cmdline) } } +#ifdef HAVE_LDAP + /* Parse afp_ldap.conf */ + acl_ldap_readconfig(_PATH_ACL_LDAPCONF); +#endif /* HAVE_LDAP */ + + LOG(log_debug, logtype_afpd, "Finished parsing Config File"); fclose(fp); if (!have_option) - return AFPConfigInit(cmdline, cmdline); + first = AFPConfigInit(cmdline, cmdline); + + /* Now register with zeroconf, we also need the volumes for that */ + if (! (first->obj.options.flags & OPTION_NOZEROCONF)) { + load_volumes(&first->obj); + zeroconf_register(first); + } return first; }