powerel7
/
base
2
0
Fork 0
Code Issues Pull Requests Releases Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
646 Commits
1 Branch
0 Tags
390 MiB
 
 
 
 
 
 
Tree: b558cfd63a
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'b558cfd63a'
${ noResults }
base/SOURCES/autofs-5.0.9-amd-lookup-upd...

410 lines
12 KiB
Raw Blame History

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;