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.
1151 Commits
1 Branch
0 Tags
390 MiB
 
 
 
 
 
 
Tree: ac30bf6d31
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'ac30bf6d31'
${ noResults }
base/SOURCES/autofs-5.0.8-amd-lookup-upd...

406 lines
11 KiB
Raw Blame History

autofs-5.0.8 - amd lookup update lookup hesiod to handle amd keys
From: Ian Kent <raven@themaw.net>
Warning, this is completely untested.
I don't have a hesiod test environment so I can't test this at all.
If we do in fact have hesiod users then I'll need to work with them
to fix any reported problems.
---
modules/lookup_hesiod.c | 330 +++++++++++++++++++++++++++++++++++++++---------
1 file changed, 270 insertions(+), 60 deletions(-)
--- autofs-5.0.7.orig/modules/lookup_hesiod.c
+++ autofs-5.0.7/modules/lookup_hesiod.c
@@ -20,12 +20,15 @@
#include "automount.h"
#include "nsswitch.h"
-#define MAPFMT_DEFAULT "hesiod"
+#define MAPFMT_DEFAULT "hesiod"
+#define AMD_MAP_PREFIX "hesiod."
+#define AMD_MAP_PREFIX_LEN 7
#define MODPREFIX "lookup(hesiod): "
#define HESIOD_LEN 512
struct lookup_context {
+ const char *mapname;
struct parse_mod *parser;
void *hesiod_context;
};
@@ -50,6 +53,7 @@ int lookup_init(const char *mapfmt, int
logerr(MODPREFIX "malloc: %s", estr);
return 1;
}
+ memset(ctxt, 0, sizeof(struct lookup_context));
/* Initialize the resolver. */
res_init();
@@ -66,6 +70,20 @@ int lookup_init(const char *mapfmt, int
if (!mapfmt)
mapfmt = MAPFMT_DEFAULT;
+ if (!strcmp(mapfmt, "amd")) {
+ /* amd formated hesiod maps have a map name */
+ const char *mapname = argv[0];
+ if (strncmp(mapname, AMD_MAP_PREFIX, AMD_MAP_PREFIX_LEN)) {
+ logerr(MODPREFIX
+ "incorrect prefix for hesiod map %s", mapname);
+ free(ctxt);
+ return 1;
+ }
+ ctxt->mapname = mapname;
+ argc--;
+ argv++;
+ }
+
/* Open the parser, if we can. */
ctxt->parser = open_parse(mapfmt, MODPREFIX, argc - 1, argv + 1);
if (!ctxt->parser) {
@@ -97,16 +115,203 @@ int lookup_read_map(struct autofs_point
* it's an ERR filesystem, it's an error message we should log. Otherwise,
* assume it's something we know how to deal with already (generic).
*/
+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;
+ char **hes_result;
+ char **record, *best_record = NULL, *p;
+ int priority, lowest_priority = INT_MAX;
+ int ret, status;
+
+ mc = source->mc;
+
+ status = pthread_mutex_lock(&hesiod_mutex);
+ if (status)
+ fatal(status);
+
+ hes_result = hesiod_resolve(ctxt->hesiod_context, key, "filsys");
+ if (!hes_result || !hes_result[0]) {
+ int err = errno;
+ error(ap->logopt,
+ MODPREFIX "key \"%s\" not found in map", key);
+ status = pthread_mutex_unlock(&hesiod_mutex);
+ if (status)
+ fatal(status);
+ if (err == HES_ER_NOTFOUND)
+ return CHE_MISSING;
+ else
+ return CHE_FAIL;
+ }
+
+ /* autofs doesn't support falling back to alternate records, so just
+ find the record with the lowest priority and hope it works.
+ -- Aaron Ucko <amu@alum.mit.edu> 2002-03-11 */
+ for (record = hes_result; *record; ++record) {
+ p = strrchr(*record, ' ');
+ if ( p && isdigit(p[1]) ) {
+ priority = atoi(p+1);
+ } else {
+ priority = INT_MAX - 1;
+ }
+ if (priority < lowest_priority) {
+ lowest_priority = priority;
+ best_record = *record;
+ }
+ }
+
+ cache_writelock(mc);
+ ret = cache_update(mc, source, key, best_record, time(NULL));
+ cache_unlock(mc);
+ if (ret == CHE_FAIL) {
+ hesiod_free_list(ctxt->hesiod_context, hes_result);
+ status = pthread_mutex_unlock(&hesiod_mutex);
+ if (status)
+ fatal(status);
+ return ret;
+ }
+
+ debug(ap->logopt,
+ MODPREFIX "lookup for \"%s\" gave \"%s\"",
+ key, best_record);
+
+ hesiod_free_list(ctxt->hesiod_context, hes_result);
+
+ status = pthread_mutex_unlock(&hesiod_mutex);
+ if (status)
+ fatal(status);
+
+ return ret;
+}
+
+static int lookup_one_amd(struct autofs_point *ap,
+ struct map_source *source,
+ const char *key, int key_len,
+ struct lookup_context *ctxt)
+{
+ struct mapent_cache *mc;
+ char *hesiod_base;
+ char **hes_result;
+ char *lkp_key;
+ int status, ret;
+
+ mc = source->mc;
+
+ hesiod_base = conf_amd_get_hesiod_base();
+ if (!hesiod_base)
+ return CHE_FAIL;
+
+ lkp_key = malloc(key_len + strlen(ctxt->mapname) - 7 + 2);
+ if (!lkp_key) {
+ free(hesiod_base);
+ return CHE_FAIL;
+ }
+
+ strcpy(lkp_key, key);
+ strcat(lkp_key, ".");
+ strcat(lkp_key, ctxt->mapname + AMD_MAP_PREFIX_LEN);
+
+ status = pthread_mutex_lock(&hesiod_mutex);
+ if (status)
+ fatal(status);
+
+ hes_result = hesiod_resolve(ctxt->hesiod_context, lkp_key, hesiod_base);
+ if (!hes_result || !hes_result[0]) {
+ int err = errno;
+ if (err == HES_ER_NOTFOUND)
+ ret = CHE_MISSING;
+ else
+ ret = CHE_FAIL;
+ goto done;
+ }
+
+ cache_writelock(mc);
+ ret = cache_update(mc, source, lkp_key, *hes_result, time(NULL));
+ cache_unlock(mc);
+
+ if (hes_result)
+ hesiod_free_list(ctxt->hesiod_context, hes_result);
+done:
+ free(lkp_key);
+
+ status = pthread_mutex_unlock(&hesiod_mutex);
+ if (status)
+ fatal(status);
+
+ return ret;
+}
+
+static int match_amd_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_amd(ap, source, key, key_len, ctxt);
+ if (ret == CHE_OK || ret == CHE_UPDATED)
+ return ret;
+
+ 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_amd(ap, source, match, len, ctxt);
+ free(match);
+ if (ret == CHE_OK || ret == CHE_UPDATED)
+ goto done;
+ }
+
+ /* Lastly try the wildcard */
+ ret = lookup_one_amd(ap, source, "*", 1, ctxt);
+done:
+ free(lkp_key);
+ 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;
- struct map_source *source;
struct mapent_cache *mc;
+ char buf[MAX_ERR_BUF];
+ struct map_source *source;
struct mapent *me;
- char **hes_result;
- int status, rv;
- char **record, *best_record = NULL, *p;
- int priority, lowest_priority = INT_MAX;
+ char key[KEY_MAX_LEN + 1];
+ size_t key_len;
+ char *lkp_key;
+ size_t len;
+ char *mapent;
+ int rv;
source = ap->entry->current;
ap->entry->current = NULL;
@@ -118,6 +323,19 @@ int lookup_mount(struct autofs_point *ap
MODPREFIX "looking up root=\"%s\", name=\"%s\"",
ap->path, name);
+ 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;
+ expandamdent(name, key, NULL);
+ key[key_len] = '\0';
+ debug(ap->logopt, MODPREFIX "expanded key: \"%s\"", key);
+ }
+
/* Check if we recorded a mount fail for this key anywhere */
me = lookup_source_mapent(ap, name, LKP_DISTINCT);
if (me) {
@@ -144,69 +362,61 @@ int lookup_mount(struct autofs_point *ap
}
}
- chdir("/"); /* If this is not here the filesystem stays
- busy, for some reason... */
-
- status = pthread_mutex_lock(&hesiod_mutex);
- if (status)
- fatal(status);
-
- hes_result = hesiod_resolve(ctxt->hesiod_context, name, "filsys");
- if (!hes_result || !hes_result[0]) {
- /* Note: it is not clear to me how to distinguish between
- * the "no search results" case and other failures. --JM */
- error(ap->logopt,
- MODPREFIX "key \"%s\" not found in map", name);
- status = pthread_mutex_unlock(&hesiod_mutex);
- if (status)
- fatal(status);
- return NSS_STATUS_NOTFOUND;
+ /* If this is not here the filesystem stays busy, for some reason... */
+ if (chdir("/"))
+ warn(ap->logopt,
+ MODPREFIX "failed to set working directory to \"/\"");
+
+ len = key_len;
+ if (!(source->flags & MAP_FLAG_FORMAT_AMD))
+ lkp_key = strdup(key);
+ else {
+ rv = lookup_one_amd(ap, source, "/defaults", 9, ctxt);
+ if (rv == CHE_FAIL)
+ warn(ap->logopt,
+ MODPREFIX "failed to lookup \"/defaults\" entry");
+
+ if (!ap->pref)
+ lkp_key = strdup(key);
+ else {
+ len += strlen(ap->pref);
+ lkp_key = malloc(len + 1);
+ if (lkp_key) {
+ strcpy(lkp_key, ap->pref);
+ strcat(lkp_key, name);
+ }
+ }
}
- /* autofs doesn't support falling back to alternate records, so just
- find the record with the lowest priority and hope it works.
- -- Aaron Ucko <amu@alum.mit.edu> 2002-03-11 */
- for (record = hes_result; *record; ++record) {
- p = strrchr(*record, ' ');
- if ( p && isdigit(p[1]) ) {
- priority = atoi(p+1);
- } else {
- priority = INT_MAX - 1;
- }
- if (priority < lowest_priority) {
- lowest_priority = priority;
- best_record = *record;
- }
+ if (!lkp_key) {
+ char *estr = strerror_r(errno, buf, MAX_ERR_BUF);
+ error(ap->logopt, "malloc: %s", estr);
+ return NSS_STATUS_UNKNOWN;
}
- cache_writelock(mc);
- rv = cache_update(mc, source, name, best_record, time(NULL));
- cache_unlock(mc);
- if (rv == CHE_FAIL)
- return NSS_STATUS_UNAVAIL;
+ if (source->flags & MAP_FLAG_FORMAT_AMD)
+ rv = match_amd_key(ap, source, lkp_key, len, ctxt);
+ else
+ rv = lookup_one(ap, source, lkp_key, len, ctxt);
- debug(ap->logopt,
- MODPREFIX "lookup for \"%s\" gave \"%s\"",
- name, best_record);
+ if (rv == CHE_FAIL) {
+ free(lkp_key);
+ return NSS_STATUS_UNAVAIL;
+ }
- rv = ctxt->parser->parse_mount(ap, name, name_len, best_record,
- ctxt->parser->context);
+ me = match_cached_key(ap, MODPREFIX, source, lkp_key);
+ free(lkp_key);
+ if (!me)
+ return NSS_STATUS_NOTFOUND;
- hesiod_free_list(ctxt->hesiod_context, hes_result);
+ if (!me->mapent)
+ return NSS_STATUS_UNAVAIL;
- status = pthread_mutex_unlock(&hesiod_mutex);
- if (status)
- fatal(status);
+ mapent = strdup(me->mapent);
- if (rv) {
- /* 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;
- }
+ rv = ctxt->parser->parse_mount(ap, key, key_len,
+ mapent, ctxt->parser->context);
+ free(mapent);
/*
* Unavailable due to error such as module load fail