/* ----------------------------------------------------------------------- *
*
* lookup_hosts.c - module for Linux automount to mount the exports
* from a given host
*
* Copyright 2005 Ian Kent <raven@themaw.net>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139,
* USA; either version 2 of the License, or (at your option) any later
* version; incorporated herein by reference.
*
* ----------------------------------------------------------------------- */
#include <stdio.h>
#include <malloc.h>
#include <sys/param.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <netdb.h>
#define MODULE_LOOKUP
#include "automount.h"
#include "nsswitch.h"
#define MAPFMT_DEFAULT "sun"
#define MODPREFIX "lookup(hosts): "
pthread_mutex_t hostent_mutex = PTHREAD_MUTEX_INITIALIZER;
struct lookup_context {
struct parse_mod *parse;
};
int lookup_version = AUTOFS_LOOKUP_VERSION; /* Required by protocol */
int lookup_init(const char *mapfmt,
int argc, const char *const *argv, void **context)
{
struct lookup_context *ctxt;
char buf[MAX_ERR_BUF];
*context = NULL;
ctxt = malloc(sizeof(struct lookup_context));
if (!ctxt) {
char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
logerr(MODPREFIX "malloc: %s", estr);
return 1;
}
mapfmt = MAPFMT_DEFAULT;
ctxt->parse = open_parse(mapfmt, MODPREFIX, argc, argv);
if (!ctxt->parse) {
logerr(MODPREFIX "failed to open parse context");
free(ctxt);
return 1;
}
*context = ctxt;
return 0;
}
int lookup_reinit(const char *mapfmt,
int argc, const char *const *argv, void **context)
{
struct lookup_context *ctxt = (struct lookup_context *) *context;
int ret;
mapfmt = MAPFMT_DEFAULT;
ret = reinit_parse(ctxt->parse, mapfmt, MODPREFIX, argc, argv);
if (ret)
return 1;
return 0;
}
int lookup_read_master(struct master *master, time_t age, void *context)
{
return NSS_STATUS_UNKNOWN;
}
static char *get_exports(struct autofs_point *ap, const char *host)
{
char buf[MAX_ERR_BUF];
char *mapent;
struct exportinfo *exp, *this;
size_t hostlen = strlen(host);
size_t mapent_len;
int len, pos;
debug(ap->logopt, MODPREFIX "fetchng export list for %s", host);
exp = rpc_get_exports(host, 10, 0, RPC_CLOSE_NOLINGER);
this = exp;
mapent_len = 0;
while (this) {
mapent_len += hostlen + 2*(strlen(this->dir) + 2) + 3;
this = this->next;
}
mapent = malloc(mapent_len + 1);
if (!mapent) {
char *estr;
estr = strerror_r(errno, buf, MAX_ERR_BUF);
error(ap->logopt, MODPREFIX "malloc: %s", estr);
error(ap->logopt, MODPREFIX "exports lookup failed for %s", host);
rpc_exports_free(exp);
return NULL;
}
*mapent = 0;
pos = 0;
this = exp;
if (this) {
len = sprintf(mapent, "\"%s\" \"%s:%s\"",
this->dir, host, this->dir);
pos += len;
this = this->next;
}
while (this) {
len = sprintf(mapent + pos, " \"%s\" \"%s:%s\"",
this->dir, host, this->dir);
pos += len;
this = this->next;
}
rpc_exports_free(exp);
return mapent;
}
static int do_parse_mount(struct autofs_point *ap, struct map_source *source,
const char *name, int name_len, char *mapent,
struct lookup_context *ctxt)
{
int ret;
master_source_current_wait(ap->entry);
ap->entry->current = source;
ret = ctxt->parse->parse_mount(ap, name, name_len,
mapent, ctxt->parse->context);
if (ret) {
struct mapent_cache *mc = source->mc;
/* Don't update negative cache when re-connecting */
if (ap->flags & MOUNT_FLAG_REMOUNT)
return NSS_STATUS_TRYAGAIN;
cache_writelock(mc);
cache_update_negative(mc, source, name, ap->negative_timeout);
cache_unlock(mc);
return NSS_STATUS_TRYAGAIN;
}
return NSS_STATUS_SUCCESS;
}
static void update_hosts_mounts(struct autofs_point *ap,
struct map_source *source, time_t age,
struct lookup_context *ctxt)
{
struct mapent_cache *mc;
struct mapent *me;
char *mapent;
int ret;
mc = source->mc;
pthread_cleanup_push(cache_lock_cleanup, mc);
cache_writelock(mc);
me = cache_lookup_first(mc);
while (me) {
/* Hosts map entry not yet expanded or already expired */
if (!IS_MM(me))
goto next;
debug(ap->logopt, MODPREFIX "get list of exports for %s", me->key);
mapent = get_exports(ap, me->key);
if (mapent) {
cache_update(mc, source, me->key, mapent, age);
free(mapent);
}
next:
me = cache_lookup_next(mc, me);
}
pthread_cleanup_pop(1);
pthread_cleanup_push(cache_lock_cleanup, mc);
cache_readlock(mc);
me = cache_lookup_first(mc);
while (me) {
/*
* Hosts map entry not yet expanded, already expired
* or not the base of the tree
*/
if (!IS_MM(me) || !IS_MM_ROOT(me))
goto cont;
debug(ap->logopt, MODPREFIX
"attempt to update exports for %s", me->key);
master_source_current_wait(ap->entry);
ap->entry->current = source;
ap->flags |= MOUNT_FLAG_REMOUNT;
ret = ctxt->parse->parse_mount(ap, me->key, strlen(me->key),
me->mapent, ctxt->parse->context);
if (ret)
warn(ap->logopt, MODPREFIX
"failed to parse mount %s", me->mapent);
ap->flags &= ~MOUNT_FLAG_REMOUNT;
cont:
me = cache_lookup_next(mc, me);
}
pthread_cleanup_pop(1);
}
int lookup_read_map(struct autofs_point *ap, time_t age, void *context)
{
struct lookup_context *ctxt = (struct lookup_context *) context;
struct map_source *source;
struct mapent_cache *mc;
struct hostent *host;
int status;
source = ap->entry->current;
ap->entry->current = NULL;
master_source_current_signal(ap->entry);
mc = source->mc;
debug(ap->logopt, MODPREFIX "read hosts map");
/*
* If we don't need to create directories then there's no use
* reading the map. We always need to read the whole map for
* direct mounts in order to mount the triggers.
*/
if (!(ap->flags & MOUNT_FLAG_GHOST) && ap->type != LKP_DIRECT) {
debug(ap->logopt, MODPREFIX
"map not browsable, update existing host entries only");
update_hosts_mounts(ap, source, age, ctxt);
source->age = age;
return NSS_STATUS_SUCCESS;
}
status = pthread_mutex_lock(&hostent_mutex);
if (status) {
error(ap->logopt, MODPREFIX "failed to lock hostent mutex");
return NSS_STATUS_UNAVAIL;
}
sethostent(0);
while ((host = gethostent()) != NULL) {
pthread_cleanup_push(cache_lock_cleanup, mc);
cache_writelock(mc);
cache_update(mc, source, host->h_name, NULL, age);
cache_unlock(mc);
pthread_cleanup_pop(0);
}
endhostent();
status = pthread_mutex_unlock(&hostent_mutex);
if (status)
error(ap->logopt, MODPREFIX "failed to unlock hostent mutex");
update_hosts_mounts(ap, source, age, ctxt);
source->age = age;
return NSS_STATUS_SUCCESS;
}
int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *context)
{
struct lookup_context *ctxt = (struct lookup_context *) context;
struct map_source *source;
struct mapent_cache *mc;
struct mapent *me;
char *mapent = NULL;
int mapent_len;
time_t now = monotonic_time(NULL);
int ret;
source = ap->entry->current;
ap->entry->current = NULL;
master_source_current_signal(ap->entry);
mc = source->mc;
/* Check if we recorded a mount fail for this key anywhere */
me = lookup_source_mapent(ap, name, LKP_DISTINCT);
if (me) {
if (me->status >= monotonic_time(NULL)) {
cache_unlock(me->mc);
return NSS_STATUS_NOTFOUND;
} else {
struct mapent_cache *smc = me->mc;
struct mapent *sme;
if (me->mapent)
cache_unlock(smc);
else {
cache_unlock(smc);
cache_writelock(smc);
sme = cache_lookup_distinct(smc, name);
/* Negative timeout expired for non-existent entry. */
if (sme && !sme->mapent) {
if (cache_pop_mapent(sme) == CHE_FAIL)
cache_delete(smc, name);
}
cache_unlock(smc);
}
}
}
cache_readlock(mc);
me = cache_lookup_distinct(mc, name);
if (!me) {
cache_unlock(mc);
/*
* We haven't read the list of hosts into the
* cache so go straight to the lookup.
*/
if (!(ap->flags & MOUNT_FLAG_GHOST)) {
/*
* If name contains a '/' we're searching for an
* offset that doesn't exist in the export list
* so it's NOTFOUND otherwise this could be a
* lookup for a new host.
*/
if (*name != '/' && strchr(name, '/'))
return NSS_STATUS_NOTFOUND;
goto done;
}
if (*name == '/')
info(ap->logopt, MODPREFIX
"can't find path in hosts map %s", name);
else
info(ap->logopt, MODPREFIX
"can't find path in hosts map %s/%s",
ap->path, name);
debug(ap->logopt,
MODPREFIX "lookup failed - update exports list");
goto done;
}
/*
* Host map export entries are added to the cache as
* direct mounts. If the name we seek starts with a slash
* it must be a mount request for one of the exports.
*/
if (*name == '/') {
pthread_cleanup_push(cache_lock_cleanup, mc);
mapent_len = strlen(me->mapent);
mapent = malloc(mapent_len + 1);
if (mapent)
strcpy(mapent, me->mapent);
pthread_cleanup_pop(0);
}
cache_unlock(mc);
done:
debug(ap->logopt, MODPREFIX "%s -> %s", name, mapent);
if (!mapent) {
/* We need to get the exports list and update the cache. */
mapent = get_exports(ap, name);
/* Exports lookup failed so we're outa here */
if (!mapent)
return NSS_STATUS_UNAVAIL;
cache_writelock(mc);
cache_update(mc, source, name, mapent, now);
cache_unlock(mc);
}
ret = do_parse_mount(ap, source, name, name_len, mapent, ctxt);
free(mapent);
return ret;
}
int lookup_done(void *context)
{
struct lookup_context *ctxt = (struct lookup_context *) context;
int rv = close_parse(ctxt->parse);
free(ctxt);
return rv;
}