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;

 }