base/SOURCES/autofs-5.0.9-amd-lookup-update-lookup-file-to-handle-amd-keys.patch

autofs-5.0.9 - amd lookup update lookup file to handle amd keys

From: Ian Kent <raven@themaw.net>

Update file map lookup to handle map key matching for amd format
maps.
---
 modules/lookup_file.c |  287 +++++++++++++++++++++++++++++++++++--------------
 1 file changed, 206 insertions(+), 81 deletions(-)

diff --git a/modules/lookup_file.c b/modules/lookup_file.c
index 512e3ef..7c982c6 100644
--- a/modules/lookup_file.c
+++ b/modules/lookup_file.c
@@ -702,9 +702,22 @@ int lookup_read_map(struct autofs_point *ap, time_t age, void *context)
 		} else {
 			char *s_key; 
 
-			s_key = sanitize_path(key, k_len, ap->type, ap->logopt);
-			if (!s_key)
-				continue;
+			if (source->flags & MAP_FLAG_FORMAT_AMD) {
+				if (!strcmp(key, "/defaults")) {
+					cache_writelock(mc);
+					cache_update(mc, source, key, mapent, age);
+					cache_unlock(mc);
+					continue;
+				}
+				/* Don't fail on "/" in key => type == 0 */
+				s_key = sanitize_path(key, k_len, 0, ap->logopt);
+				if (!s_key)
+					continue;
+			} else {
+				s_key = sanitize_path(key, k_len, ap->type, ap->logopt);
+				if (!s_key)
+					continue;
+			}
 
 			cache_writelock(mc);
 			cache_update(mc, source, s_key, mapent, age);
@@ -724,12 +737,75 @@ int lookup_read_map(struct autofs_point *ap, time_t age, void *context)
 	return NSS_STATUS_SUCCESS;
 }
 
+static int match_key(struct autofs_point *ap,
+		     struct map_source *source, char *map_key,
+		     const char *key, size_t key_len, const char *mapent)
+{
+	char buf[MAX_ERR_BUF];
+	struct mapent_cache *mc;
+	time_t age = time(NULL);
+	char *lkp_key;
+	char *prefix;
+	size_t map_key_len;
+	int ret, eq;
+
+	mc = source->mc;
+
+	/* exact match is a match for both autofs and amd */
+	eq = strcmp(map_key, key);
+	if (eq == 0) {
+		cache_writelock(mc);
+		ret = cache_update(mc, source, key, mapent, age);
+		cache_unlock(mc);
+		return ret;
+	}
+
+	if (!(source->flags & MAP_FLAG_FORMAT_AMD))
+		return CHE_FAIL;
+
+	map_key_len = strlen(map_key);
+
+	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_FAIL;
+
+	if (map_key_len > (strlen(lkp_key) + 2))
+		goto done;
+
+	/*
+	 * Now strip successive directory components and try a
+	 * match against map entries ending with a wildcard and
+	 * finally try the wilcard entry itself. If we get a match
+	 * then update the cache with the read key and its mapent.
+	*/
+	while ((prefix = strrchr(lkp_key, '/'))) {
+		size_t len;
+		*prefix = '\0';
+		len = strlen(lkp_key);
+		eq = strncmp(map_key, lkp_key, len);
+		if (!eq && map_key[len + 1] == '*') {
+			cache_writelock(mc);
+			ret = cache_update(mc, source, map_key, mapent, age);
+			cache_unlock(mc);
+			goto done;
+		}
+	}
+done:
+	free(lkp_key);
+	return ret;
+}
+
 static int lookup_one(struct autofs_point *ap,
 		      struct map_source *source,
 		      const char *key, int key_len,
 		      struct lookup_context *ctxt)
 {
-	struct mapent_cache *mc;
+	struct mapent_cache *mc = source->mc;
 	char mkey[KEY_MAX_LEN + 1];
 	char mapent[MAPENT_MAX_LEN + 1];
 	time_t age = time(NULL);
@@ -737,8 +813,6 @@ static int lookup_one(struct autofs_point *ap,
 	unsigned int k_len, m_len;
 	int entry, ret;
 
-	mc = source->mc;
-
 	f = open_fopen_r(ctxt->mapname);
 	if (!f) {
 		error(ap->logopt,
@@ -781,29 +855,38 @@ static int lookup_one(struct autofs_point *ap,
 				}
 			} else {
 				char *s_key; 
-				int eq;
 
-				s_key = sanitize_path(mkey, k_len, ap->type, ap->logopt);
-				if (!s_key)
-					continue;
+				if (source->flags & MAP_FLAG_FORMAT_AMD) {
+					if (!strcmp(mkey, "/defaults")) {
+						cache_writelock(mc);
+						cache_update(mc, source, mkey, mapent, age);
+						cache_unlock(mc);
+						continue;
+					}
+					/* Don't fail on "/" in key => type == 0 */
+					s_key = sanitize_path(mkey, k_len, 0, ap->logopt);
+					if (!s_key)
+						continue;
+				} else {
+					s_key = sanitize_path(mkey, k_len, ap->type, ap->logopt);
+					if (!s_key)
+						continue;
 
-				if (key_len != strlen(s_key)) {
-					free(s_key);
-					continue;
+					if (key_len != strlen(s_key)) {
+						free(s_key);
+						continue;
+					}
 				}
 
-				eq = strncmp(s_key, key, key_len);
-				if (eq != 0) {
+				ret = match_key(ap, source,
+						s_key, key, key_len, mapent);
+				if (ret == CHE_FAIL) {
 					free(s_key);
 					continue;
 				}
 
 				free(s_key);
 
-				cache_writelock(mc);
-				ret = cache_update(mc, source, key, mapent, age);
-				cache_unlock(mc);
-
 				fclose(f);
 
 				return ret;
@@ -897,7 +980,10 @@ static int check_map_indirect(struct autofs_point *ap,
 		return NSS_STATUS_NOTFOUND;
 
 	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) {
@@ -936,6 +1022,53 @@ static int check_map_indirect(struct autofs_point *ap,
 	return NSS_STATUS_SUCCESS;
 }
 
+static int map_update_needed(struct autofs_point *ap,
+			     struct map_source *source,
+			     struct lookup_context * ctxt)
+{
+	struct mapent_cache *mc;
+	struct mapent *me;
+	struct stat st;
+	int ret = 1;
+
+	mc = source->mc;
+
+	/*
+	 * We can skip the map lookup and cache update altogether
+	 * if we know the map hasn't been modified since it was
+	 * last read. If it has then we can mark the map stale
+	 * so a re-read is triggered following the lookup.
+	 */
+	if (stat(ctxt->mapname, &st)) {
+		error(ap->logopt, MODPREFIX
+		      "file map %s, could not stat", ctxt->mapname);
+		return -1;
+	}
+
+	cache_readlock(mc);
+	me = cache_lookup_first(mc);
+	if (me && st.st_mtime <= me->age) {
+		/*
+		 * If any map instances are present for this source
+		 * then either we have plus included entries or we
+		 * are looking through the list of nsswitch sources.
+		 * In either case, or if it's a "multi" source, we
+		 * cannot avoid reading through the map because we
+		 * must preserve the key order over multiple sources
+		 * or maps. But also, we can't know, at this point,
+		 * if a source instance has been changed since the
+		 * last time we checked it.
+		 */
+		if (!source->instance &&
+		    source->type && strcmp(source->type, "multi"))
+			ret = 0;
+	} else
+		source->stale = 1;
+	cache_unlock(mc);
+
+	return ret;
+}
+
 int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *context)
 {
 	struct lookup_context *ctxt = (struct lookup_context *) context;
@@ -944,8 +1077,10 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
 	struct mapent *me;
 	char key[KEY_MAX_LEN + 1];
 	int key_len;
+	char *lkp_key;
 	char *mapent = NULL;
 	char mapent_buf[MAPENT_MAX_LEN + 1];
+	char buf[MAX_ERR_BUF];
 	int status = 0;
 	int ret = 1;
 
@@ -967,9 +1102,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);
@@ -1003,50 +1147,35 @@ 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 != '/') {
-		struct stat st;
-		char *lkp_key;
+		int ret;
 
-		/*
-		 * We can skip the map lookup and cache update altogether
-		 * if we know the map hasn't been modified since it was
-		 * last read. If it has then we can mark the map stale
-		 * so a re-read is triggered following the lookup.
-		 */
-		if (stat(ctxt->mapname, &st)) {
-			error(ap->logopt, MODPREFIX
-			      "file map %s, could not stat", ctxt->mapname);
-			return NSS_STATUS_UNAVAIL;
-		}
+		ret = map_update_needed(ap, source, ctxt);
+		if (!ret)
+			goto do_cache_lookup;
+		/* Map isn't accessable, just try the cache */
+		if (ret < 0)
+			goto do_cache_lookup;
 
 		cache_readlock(mc);
-		me = cache_lookup_first(mc);
-		if (me && st.st_mtime <= me->age) {
-			/*
-			 * If any map instances are present for this source
-			 * then either we have plus included entries or we
-			 * are looking through the list of nsswitch sources.
-			 * In either case, or if it's a "multi" source, we
-			 * cannot avoid reading through the map because we
-			 * must preserve the key order over multiple sources
-			 * or maps. But also, we can't know, at this point,
-			 * if a source instance has been changed since the
-			 * last time we checked it.
-			 */
-			if (!source->instance &&
-			    source->type && strcmp(source->type, "multi"))
-				goto do_cache_lookup;
-		} else
-			source->stale = 1;
-
 		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);
@@ -1066,42 +1195,38 @@ int lookup_mount(struct autofs_point *ap, const char *name, int name_len, void *
 	 * when we're starting up so just take the readlock in that
 	 * case.
 	 */
+do_cache_lookup:
 	if (ap->flags & MOUNT_FLAG_REMOUNT)
 		cache_readlock(mc);
 	else
 		cache_writelock(mc);
-do_cache_lookup:
-	me = cache_lookup(mc, key);
-	/*
-	 * Stale mapent => check for entry in alternate source or wildcard.
-	 * Note, plus included direct mount map entries are included as an
-	 * instance (same map entry cache), not in a distinct source.
-	 */
-	if (me && (!me->mapent || 
-	   (me->source != source && *me->key != '/'))) {
-		while ((me = cache_lookup_key_next(me)))
-			if (me->source == source)
-				break;
-		if (!me)
-			me = cache_lookup_distinct(mc, "*");
+
+	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);
 	if (me && me->mapent) {
-		/*
-		 * If this is a lookup add wildcard match for later validation
-		 * checks and negative cache lookups.
-		 */
-		if (!(ap->flags & MOUNT_FLAG_REMOUNT) &&
-		    ap->type == LKP_INDIRECT && *me->key == '*') {
-			ret = cache_update(mc, source, key, me->mapent, me->age);
-			if (!(ret & (CHE_OK | CHE_UPDATED)))
-				me = NULL;
-		}
 		if (me && (me->source == source || *me->key == '/')) {
 			strcpy(mapent_buf, me->mapent);
 			mapent = mapent_buf;
 		}
 	}
 	cache_unlock(mc);
+	free(lkp_key);
 
 	if (!me)
 		return NSS_STATUS_NOTFOUND;