autofs-5.0.9 - amd lookup update lookup yp to handle amd keys
From: Ian Kent <raven@themaw.net>
---
modules/lookup_yp.c | 248 ++++++++++++++++++++++++++++++++++++++++++++-------
1 file changed, 216 insertions(+), 32 deletions(-)
diff --git a/modules/lookup_yp.c b/modules/lookup_yp.c
index ba97ccc..146e39e 100644
--- a/modules/lookup_yp.c
+++ b/modules/lookup_yp.c
@@ -36,9 +36,10 @@
#define MODPREFIX "lookup(yp): "
struct lookup_context {
- const char *domainname;
+ char *domainname;
const char *mapname;
unsigned long order;
+ unsigned int check_defaults;
struct parse_mod *parse;
};
@@ -113,7 +114,7 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
ctxt = malloc(sizeof(struct lookup_context));
if (!ctxt) {
char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
- logerr(MODPREFIX "%s", estr);
+ logerr(MODPREFIX "malloc: %s", estr);
return 1;
}
memset(ctxt, 0, sizeof(struct lookup_context));
@@ -124,17 +125,28 @@ int lookup_init(const char *mapfmt, int argc, const char *const *argv, void **co
return 1;
}
ctxt->mapname = argv[0];
-
- /* This should, but doesn't, take a const char ** */
- err = yp_get_default_domain((char **) &ctxt->domainname);
- if (err) {
- size_t len = strlen(ctxt->mapname);
- char *name = alloca(len + 1);
- memcpy(name, ctxt->mapname, len);
- name[len] = '\0';
- free(ctxt);
- logerr(MODPREFIX "map %s: %s", name, yperr_string(err));
- return 1;
+ ctxt->check_defaults = 1;
+
+ if (mapfmt && !strcmp(mapfmt, "amd"))
+ ctxt->domainname = conf_amd_get_nis_domain();
+
+ if (!ctxt->domainname) {
+ char *domainname;
+ /* This should, but doesn't, take a const char ** */
+ err = yp_get_default_domain(&domainname);
+ if (err) {
+ logerr(MODPREFIX
+ "map %s: %s", ctxt->mapname, yperr_string(err));
+ free(ctxt);
+ return 1;
+ }
+ ctxt->domainname = strdup(domainname);
+ if (!ctxt->domainname) {
+ char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
+ logerr(MODPREFIX "strdup: %s", estr);
+ free(ctxt);
+ return 1;
+ }
}
ctxt->order = get_map_order(ctxt->domainname, ctxt->mapname);
@@ -286,7 +298,12 @@ int yp_all_callback(int status, char *ypkey, int ypkeylen,
if (*ypkey == '+')
return 0;
- key = sanitize_path(ypkey, ypkeylen, ap->type, ap->logopt);
+ if (!(source->flags & MAP_FLAG_FORMAT_AMD))
+ key = sanitize_path(ypkey, ypkeylen, ap->type, ap->logopt);
+ else
+ /* Don't fail on "/" in key => type == 0 */
+ key = sanitize_path(ypkey, ypkeylen, 0, ap->logopt);
+
if (!key) {
error(logopt, MODPREFIX "invalid path %s", ypkey);
return 0;
@@ -372,6 +389,9 @@ int lookup_read_map(struct autofs_point *ap, time_t age, void *context)
}
source->age = age;
+ pthread_mutex_lock(&ap->entry->current_mutex);
+ ctxt->check_defaults = 0;
+ pthread_mutex_unlock(&ap->entry->current_mutex);
return NSS_STATUS_SUCCESS;
}
@@ -432,6 +452,66 @@ static int lookup_one(struct autofs_point *ap,
return ret;
}
+static int match_key(struct autofs_point *ap,
+ struct map_source *source,
+ const char *key, int key_len,
+ struct lookup_context *ctxt)
+{
+ char buf[MAX_ERR_BUF];
+ char *lkp_key;
+ char *prefix;
+ int ret;
+
+ ret = lookup_one(ap, source, key, strlen(key), ctxt);
+ if (ret < 0)
+ return ret;
+ if (ret == CHE_OK || ret == CHE_UPDATED)
+ return ret;
+
+ if (!(source->flags & MAP_FLAG_FORMAT_AMD))
+ return CHE_FAIL;
+
+ lkp_key = strdup(key);
+ if (!lkp_key) {
+ char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
+ error(ap->logopt, MODPREFIX "strdup: %s", estr);
+ return CHE_FAIL;
+ }
+
+ ret = CHE_MISSING;
+
+ /*
+ * Now strip successive directory components and try a
+ * match against map entries ending with a wildcard and
+ * finally try the wilcard entry itself.
+ */
+ while ((prefix = strrchr(lkp_key, '/'))) {
+ char *match;
+ size_t len;
+ *prefix = '\0';
+ len = strlen(lkp_key) + 3;
+ match = malloc(len);
+ if (!match) {
+ char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
+ error(ap->logopt, MODPREFIX "malloc: %s", estr);
+ ret = CHE_FAIL;
+ goto done;
+ }
+ len--;
+ strcpy(match, lkp_key);
+ strcat(match, "/*");
+ ret = lookup_one(ap, source, match, len, ctxt);
+ free(match);
+ if (ret < 0)
+ goto done;
+ if (ret == CHE_OK || ret == CHE_UPDATED)
+ goto done;
+ }
+done:
+ free(lkp_key);
+ return ret;
+}
+
static int lookup_wild(struct autofs_point *ap,
struct map_source *source, struct lookup_context *ctxt)
{
@@ -480,6 +560,52 @@ static int lookup_wild(struct autofs_point *ap,
return ret;
}
+static int lookup_amd_defaults(struct autofs_point *ap,
+ struct map_source *source,
+ struct lookup_context *ctxt)
+{
+ struct mapent_cache *mc = source->mc;
+ char *mapname;
+ char *mapent;
+ int mapent_len;
+ int ret;
+
+ mapname = malloc(strlen(ctxt->mapname) + 1);
+ if (!mapname)
+ return 0;
+
+ strcpy(mapname, ctxt->mapname);
+
+ ret = yp_match((char *) ctxt->domainname, mapname,
+ (char *) "/defaults", 9, &mapent, &mapent_len);
+
+ if (ret != YPERR_SUCCESS) {
+ if (ret == YPERR_MAP) {
+ char *usc;
+
+ while ((usc = strchr(mapname, '_')))
+ *usc = '.';
+
+ ret = yp_match((char *) ctxt->domainname, mapname,
+ "/defaults", 9, &mapent, &mapent_len);
+ }
+ }
+ free(mapname);
+
+ /* No /defaults entry */
+ if (ret == YPERR_KEY)
+ return CHE_OK;
+
+ if (ret != YPERR_SUCCESS)
+ return CHE_FAIL;
+
+ cache_writelock(mc);
+ ret = cache_update(mc, source, "/defaults", mapent, time(NULL));
+ cache_unlock(mc);
+
+ return ret;
+}
+
static int check_map_indirect(struct autofs_point *ap,
struct map_source *source,
char *key, int key_len,
@@ -492,8 +618,28 @@ static int check_map_indirect(struct autofs_point *ap,
mc = source->mc;
+ /* Only read map if it has been modified */
+ pthread_mutex_lock(&ap->entry->current_mutex);
+ map_order = get_map_order(ctxt->domainname, ctxt->mapname);
+ if (map_order > ctxt->order) {
+ ctxt->order = map_order;
+ source->stale = 1;
+ ctxt->check_defaults = 1;
+ }
+
+ if (source->flags & MAP_FLAG_FORMAT_AMD && ctxt->check_defaults) {
+ /* Check for a /defaults entry to update the map source */
+ if (lookup_amd_defaults(ap, source, ctxt) == CHE_FAIL) {
+ warn(ap->logopt, MODPREFIX
+ "error getting /defaults from map %s",
+ ctxt->mapname);
+ } else
+ ctxt->check_defaults = 0;
+ }
+ pthread_mutex_unlock(&ap->entry->current_mutex);
+
/* check map and if change is detected re-read map */
- ret = lookup_one(ap, source, key, key_len, ctxt);
+ ret = match_key(ap, source, key, key_len, ctxt);
if (ret == CHE_FAIL)
return NSS_STATUS_NOTFOUND;
@@ -503,7 +649,10 @@ static int check_map_indirect(struct autofs_point *ap,
* and belongs to this map return success and use the entry.
*/
cache_readlock(mc);
- exists = cache_lookup(mc, key);
+ if (source->flags & MAP_FLAG_FORMAT_AMD)
+ exists = match_cached_key(ap, MODPREFIX, source, key);
+ else
+ exists = cache_lookup(mc, key);
if (exists && exists->source == source) {
cache_unlock(mc);
return NSS_STATUS_SUCCESS;
@@ -517,15 +666,11 @@ static int check_map_indirect(struct autofs_point *ap,
return NSS_STATUS_UNAVAIL;
}
- /* Only read map if it has been modified */
- map_order = get_map_order(ctxt->domainname, ctxt->mapname);
- if (map_order > ctxt->order) {
- ctxt->order = map_order;
- source->stale = 1;
- }
-
cache_writelock(mc);
- exists = cache_lookup_distinct(mc, key);
+ if (source->flags & MAP_FLAG_FORMAT_AMD)
+ exists = match_cached_key(ap, MODPREFIX, source, key);
+ else
+ exists = cache_lookup_distinct(mc, key);
/* Not found in the map but found in the cache */
if (exists && exists->source == source && ret & CHE_MISSING) {
if (exists->mapent) {
@@ -578,9 +723,11 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
struct mapent_cache *mc;
char key[KEY_MAX_LEN + 1];
int key_len;
+ char *lkp_key;
char *mapent = NULL;
int mapent_len;
struct mapent *me;
+ char buf[MAX_ERR_BUF];
int status = 0;
int ret = 1;
@@ -592,9 +739,18 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
debug(ap->logopt, MODPREFIX "looking up %s", name);
- key_len = snprintf(key, KEY_MAX_LEN + 1, "%s", name);
- if (key_len > KEY_MAX_LEN)
- return NSS_STATUS_NOTFOUND;
+ if (!(source->flags & MAP_FLAG_FORMAT_AMD)) {
+ key_len = snprintf(key, KEY_MAX_LEN + 1, "%s", name);
+ if (key_len > KEY_MAX_LEN)
+ return NSS_STATUS_NOTFOUND;
+ } else {
+ key_len = expandamdent(name, NULL, NULL);
+ if (key_len > KEY_MAX_LEN)
+ return NSS_STATUS_NOTFOUND;
+ memset(key, 0, KEY_MAX_LEN + 1);
+ expandamdent(name, key, NULL);
+ debug(ap->logopt, MODPREFIX "expanded key: \"%s\"", key);
+ }
/* Check if we recorded a mount fail for this key anywhere */
me = lookup_source_mapent(ap, key, LKP_DISTINCT);
@@ -628,18 +784,26 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
* we never know about it.
*/
if (ap->type == LKP_INDIRECT && *key != '/') {
- char *lkp_key;
-
cache_readlock(mc);
me = cache_lookup_distinct(mc, key);
if (me && me->multi)
lkp_key = strdup(me->multi->key);
- else
+ else if (!ap->pref)
lkp_key = strdup(key);
+ else {
+ lkp_key = malloc(strlen(ap->pref) + strlen(key) + 1);
+ if (lkp_key) {
+ strcpy(lkp_key, ap->pref);
+ strcat(lkp_key, key);
+ }
+ }
cache_unlock(mc);
- if (!lkp_key)
+ if (!lkp_key) {
+ char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
+ error(ap->logopt, MODPREFIX "malloc: %s", estr);
return NSS_STATUS_UNKNOWN;
+ }
status = check_map_indirect(ap, source,
lkp_key, strlen(lkp_key), ctxt);
@@ -660,7 +824,25 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
cache_readlock(mc);
else
cache_writelock(mc);
- me = cache_lookup(mc, key);
+
+ if (!ap->pref)
+ lkp_key = strdup(key);
+ else {
+ lkp_key = malloc(strlen(ap->pref) + strlen(key) + 1);
+ if (lkp_key) {
+ strcpy(lkp_key, ap->pref);
+ strcat(lkp_key, key);
+ }
+ }
+
+ if (!lkp_key) {
+ char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
+ error(ap->logopt, MODPREFIX "malloc: %s", estr);
+ cache_unlock(mc);
+ return NSS_STATUS_UNKNOWN;
+ }
+
+ me = match_cached_key(ap, MODPREFIX, source, lkp_key);
/* Stale mapent => check for entry in alternate source or wildcard */
if (me && !me->mapent) {
while ((me = cache_lookup_key_next(me)))
@@ -687,6 +869,7 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
}
}
cache_unlock(mc);
+ free(lkp_key);
if (mapent) {
master_source_current_wait(ap->entry);
@@ -716,6 +899,7 @@ int lookup_done(void *context)
{
struct lookup_context *ctxt = (struct lookup_context *) context;
int rv = close_parse(ctxt->parse);
+ free(ctxt->domainname);
free(ctxt);
return rv;
}