#include <nfs-plugin.h>
/*
- * Walk through a set of FS locations and build a set of export options.
+ * Find the export entry for the parent of "pathname".
+ * Caller must not free returned exportent.
+ */
+static struct exportent *lookup_parent_export(char *dom,
+ const char *pathname, struct addrinfo *ai)
+{
+ char *parent, *slash;
+ nfs_export *result;
+
+ parent = strdup(pathname);
+ if (parent == NULL) {
+ xlog(D_GENERAL, "%s: failed to allocate parent path buffer",
+ __func__);
+ goto out_default;
+ }
+ xlog(D_CALL, "%s: pathname = '%s'", __func__, pathname);
+
+again:
+ /* shorten pathname by one component */
+ slash = strrchr(parent, '/');
+ if (slash == NULL) {
+ xlog(D_GENERAL, "%s: no slash found in pathname",
+ __func__);
+ goto out_default;
+ }
+ *slash = '\0';
+
+ if (strlen(parent) == 0) {
+ result = lookup_export(dom, "/", ai);
+ if (result == NULL) {
+ xlog(L_ERROR, "%s: no root export found.", __func__);
+ goto out_default;
+ }
+ goto out;
+ }
+
+ result = lookup_export(dom, parent, ai);
+ if (result == NULL) {
+ xlog(D_GENERAL, "%s: lookup_export(%s) found nothing",
+ __func__, parent);
+ goto again;
+ }
+
+out:
+ xlog(D_CALL, "%s: found export for %s", __func__, parent);
+ free(parent);
+ return &result->m_export;
+
+out_default:
+ free(parent);
+ return mkexportent("*", "/", "insecure");
+}
+
+/*
+ * Walk through a set of FS locations and build an e_fslocdata string.
* Returns true if all went to plan; otherwise, false.
*/
-static _Bool
-locations_to_options(struct jp_ops *ops, nfs_fsloc_set_t locations,
- char *options, size_t remaining, int *ttl)
+static bool locations_to_fslocdata(struct jp_ops *ops,
+ nfs_fsloc_set_t locations, char *fslocdata,
+ size_t remaining, int *ttl)
{
char *server, *last_path, *rootpath, *ptr;
_Bool seen = false;
last_path = NULL;
rootpath = NULL;
server = NULL;
- ptr = options;
+ ptr = fslocdata;
*ttl = 0;
for (;;) {
goto out_false;
}
if ((size_t)len >= remaining) {
- xlog(D_GENERAL, "%s: options buffer overflow", __func__);
+ xlog(D_GENERAL, "%s: fslocdata buffer overflow", __func__);
goto out_false;
}
remaining -= (size_t)len;
ptr += len;
} else {
if (last_path == NULL)
- len = snprintf(ptr, remaining, "refer=%s@%s",
+ len = snprintf(ptr, remaining, "%s@%s",
rootpath, server);
else
len = snprintf(ptr, remaining, ":%s@%s",
goto out_false;
}
if ((size_t)len >= remaining) {
- xlog(D_GENERAL, "%s: options buffer overflow",
+ xlog(D_GENERAL, "%s: fslocdata buffer overflow",
__func__);
goto out_false;
}
free(server);
}
- xlog(D_CALL, "%s: options='%s', ttl=%d",
- __func__, options, *ttl);
+ xlog(D_CALL, "%s: fslocdata='%s', ttl=%d",
+ __func__, fslocdata, *ttl);
return seen;
out_false:
}
/*
- * Walk through the set of FS locations and build an exportent.
- * Returns pointer to an exportent if "junction" refers to a junction.
- *
- * Returned exportent points to static memory.
+ * Duplicate the junction's parent's export options and graft in
+ * the fslocdata we constructed from the locations list.
*/
-static struct exportent *do_locations_to_export(struct jp_ops *ops,
- nfs_fsloc_set_t locations, const char *junction,
- char *options, size_t options_len)
+static struct exportent *create_junction_exportent(struct exportent *parent,
+ const char *junction, const char *fslocdata, int ttl)
{
- struct exportent *exp;
- int ttl;
-
- if (!locations_to_options(ops, locations, options, options_len, &ttl))
- return NULL;
-
- exp = mkexportent("*", (char *)junction, options);
- if (exp == NULL) {
- xlog(L_ERROR, "%s: Failed to construct exportent", __func__);
- return NULL;
+ static struct exportent *eep;
+
+ eep = (struct exportent *)malloc(sizeof(*eep));
+ if (eep == NULL)
+ goto out_nomem;
+
+ dupexportent(eep, parent);
+ strcpy(eep->e_path, junction);
+ eep->e_hostname = strdup(parent->e_hostname);
+ if (eep->e_hostname == NULL) {
+ free(eep);
+ goto out_nomem;
}
+ free(eep->e_uuid);
+ eep->e_uuid = NULL;
+ eep->e_ttl = (unsigned int)ttl;
+
+ free(eep->e_fslocdata);
+ eep->e_fslocdata = strdup(fslocdata);
+ if (eep->e_fslocdata == NULL) {
+ free(eep->e_hostname);
+ free(eep);
+ goto out_nomem;
+ }
+ eep->e_fslocmethod = FSLOC_REFER;
+ return eep;
- exp->e_uuid = NULL;
- exp->e_ttl = ttl;
- return exp;
+out_nomem:
+ xlog(L_ERROR, "%s: No memory", __func__);
+ return NULL;
}
/*
- * Convert set of FS locations to an exportent. Returns pointer to
- * an exportent if "junction" refers to a junction.
- *
- * Returned exportent points to static memory.
+ * Walk through the set of FS locations and build an exportent.
+ * Returns pointer to an exportent if "junction" refers to a junction.
*/
static struct exportent *locations_to_export(struct jp_ops *ops,
- nfs_fsloc_set_t locations, const char *junction)
+ nfs_fsloc_set_t locations, const char *junction,
+ struct exportent *parent)
{
- struct exportent *exp;
- char *options;
+ static char fslocdata[BUFSIZ];
+ int ttl;
- options = malloc(BUFSIZ);
- if (options == NULL) {
- xlog(D_GENERAL, "%s: failed to allocate options buffer",
- __func__);
+ fslocdata[0] = '\0';
+ if (!locations_to_fslocdata(ops, locations,
+ fslocdata, sizeof(fslocdata), &ttl))
return NULL;
- }
- options[0] = '\0';
-
- exp = do_locations_to_export(ops, locations, junction,
- options, BUFSIZ);
-
- free(options);
- return exp;
+ return create_junction_exportent(parent, junction, fslocdata, ttl);
}
/*
* Retrieve locations information in "junction" and dump it to the
* kernel. Returns pointer to an exportent if "junction" refers
* to a junction.
- *
- * Returned exportent points to static memory.
*/
-static struct exportent *invoke_junction_ops(void *handle,
- const char *junction)
+static struct exportent *invoke_junction_ops(void *handle, char *dom,
+ const char *junction, struct addrinfo *ai)
{
+ struct exportent *parent, *exp = NULL;
nfs_fsloc_set_t locations;
- struct exportent *exp;
enum jp_status status;
struct jp_ops *ops;
char *error;
}
status = ops->jp_get_locations(junction, &locations);
- if (status != JP_OK) {
- xlog(D_GENERAL, "%s: failed to resolve %s: %s",
- __func__, junction, ops->jp_error(status));
- return NULL;
+ switch (status) {
+ case JP_OK:
+ break;
+ case JP_NOTJUNCTION:
+ xlog(D_GENERAL, "%s: %s is not a junction",
+ __func__, junction);
+ goto out;
+ default:
+ xlog(L_WARNING, "Dangling junction %s: %s",
+ junction, ops->jp_error(status));
+ goto out;
}
- exp = locations_to_export(ops, locations, junction);
+ parent = lookup_parent_export(dom, junction, ai);
+ if (parent == NULL)
+ goto out;
+
+ exp = locations_to_export(ops, locations, junction, parent);
ops->jp_put_locations(locations);
+
+out:
ops->jp_done();
return exp;
}
* Load the junction plug-in, then try to resolve "pathname".
* Returns pointer to an initialized exportent if "junction"
* refers to a junction, or NULL if not.
- *
- * Returned exportent points to static memory.
*/
-static struct exportent *lookup_junction(const char *pathname)
+static struct exportent *lookup_junction(char *dom, const char *pathname,
+ struct addrinfo *ai)
{
struct exportent *exp;
void *handle;
}
(void)dlerror(); /* Clear any error */
- exp = invoke_junction_ops(handle, pathname);
+ exp = invoke_junction_ops(handle, dom, pathname, ai);
/* We could leave it loaded to make junction resolution
* faster next time. However, if we want to replace the
(void)dlclose(handle);
return exp;
}
+
+static void lookup_nonexport(FILE *f, char *dom, char *path,
+ struct addrinfo *ai)
+{
+ struct exportent *eep;
+
+ eep = lookup_junction(dom, path, ai);
+ dump_to_cache(f, dom, path, eep);
+ if (eep == NULL)
+ return;
+ exportent_release(eep);
+ free(eep);
+}
#else /* !HAVE_NFS_PLUGIN_H */
-static inline struct exportent *lookup_junction(const char *UNUSED(pathname))
+static void lookup_nonexport(FILE *f, char *dom, char *path,
+ struct addrinfo *UNUSED(ai))
{
- return NULL;
+ dump_to_cache(f, dom, path, NULL);
}
#endif /* !HAVE_NFS_PLUGIN_H */
" or fsid= required", path);
dump_to_cache(f, dom, path, NULL);
}
- } else {
- dump_to_cache(f, dom, path, lookup_junction(path));
- }
+ } else
+ lookup_nonexport(f, dom, path, ai);
+
out:
xlog(D_CALL, "nfsd_export: found %p path %s", found, path ? path : NULL);
if (dom) free(dom);