Make sure we don't load a module but then later can't find it

If a module name contains a '/', it can happen that we find the
module (like 'dist/Fstab.lns'), load it and then later can't find it under
the invalid module name containing the slash, leading to an endless loop of
loding the same module over and over again.

We avoid this by making sure there is no '/' in the module name before
looking for the module file. Other forms of invalid module names should not
cause similar problems as we will simply fail to find the corresponding
file.

Fixes hercules-team#522

Author: lutter

src/syntax.c

@@ -1962,6 +1962,13 @@ static char *module_filename(struct augeas *aug, const char *modname) {
     char *filename = NULL;
     char *name = module_basename(modname);
 
+    /* Module names that contain slashes can fool us into finding and
+     * loading a module in another directory, but once loaded we won't find
+     * it under MODNAME so that we will later try and load it over and
+     * over */
+    if (index(modname, '/') != NULL)
+        goto error;
+
     while ((dir = argz_next(aug->modpathz, aug->nmodpath, dir)) != NULL) {
         int len = strlen(name) + strlen(dir) + 2;
         struct stat st;

src/transform.c

@@ -800,6 +800,9 @@ int transform_validate(struct augeas *aug, struct tree *xfm) {
     return 0;
  error:
     xfm_error(xfm, aug->error->details);
+    /* We recorded this error in the tree, clear it so that future
+     * operations report this exact same error (against the wrong lens) */
+    reset_error(aug->error);
     return -1;
 }
 

tests/test-api.c

@@ -735,6 +735,40 @@ static void testLoadBadPath(CuTest *tc) {
     aug_close(aug);
 }
 
+/* If a lens is set to a partial path which happens to actually resolve to
+   a file when appended to the loadpath, we went into an infinite loop of
+   loading a module, but then not realizing that it had actually been
+   loaded, reloading it over and over again.
+   See https://github.com/hercules-team/augeas/issues/522
+*/
+static void testLoadBadLens(CuTest *tc) {
+    struct augeas *aug;
+    int r;
+    char *lp;
+
+    // This setup depends on the fact that
+    //   loadpath == abs_top_srcdir + "/lenses"
+    r = asprintf(&lp, "%s:%s", loadpath, abs_top_srcdir);
+    CuAssert(tc, "failed to allocate loadpath", (r >= 0));
+
+    aug = aug_init(root, lp, AUG_NO_STDINC|AUG_NO_LOAD);
+    CuAssertPtrNotNull(tc, aug);
+    CuAssertIntEquals(tc, AUG_NOERROR, aug_error(aug));
+
+    r = aug_set(aug, "/augeas/load/Fstab/lens", "lenses/Fstab.lns");
+    CuAssertRetSuccess(tc, r);
+
+    r = aug_load(aug);
+    CuAssertRetSuccess(tc, r);
+
+    // We used to record the error to load the lens above against every
+    // lens that we tried to load after it.
+    r = aug_match(aug, "/augeas//error", NULL);
+    CuAssertIntEquals(tc, 1, r);
+
+    free(lp);
+}
+
 /* Test the aug_ns_* functions */
 static void testAugNs(CuTest *tc) {
     struct augeas *aug;
@@ -804,6 +838,7 @@ int main(void) {
     SUITE_ADD_TEST(suite, testRm);
     SUITE_ADD_TEST(suite, testLoadFile);
     SUITE_ADD_TEST(suite, testLoadBadPath);
+    SUITE_ADD_TEST(suite, testLoadBadLens);
     SUITE_ADD_TEST(suite, testAugNs);
 
     abs_top_srcdir = getenv("abs_top_srcdir");