X-Git-Url: https://git.decadent.org.uk/gitweb/?p=nfs-utils.git;a=blobdiff_plain;f=utils%2Fmountd%2Fcache.c;h=737927c78e8549c83ccf358b0f1636f353d303b6;hp=d2ae4563d31a1ebe855e34053ac99cda6c56cc09;hb=6eba4e22ce2b10bcfb19fbb253f7e235afbaa406;hpb=a99b7846e2abec5e26ab6b764b921d79559e0a0f diff --git a/utils/mountd/cache.c b/utils/mountd/cache.c index d2ae456..737927c 100644 --- a/utils/mountd/cache.c +++ b/utils/mountd/cache.c @@ -29,7 +29,6 @@ #include "nfslib.h" #include "exportfs.h" #include "mountd.h" -#include "xmalloc.h" #include "fsloc.h" #include "pseudoflavors.h" @@ -81,10 +80,9 @@ static void auth_unix_ip(FILE *f) */ char *cp; char class[20]; - char ipaddr[INET6_ADDRSTRLEN]; + char ipaddr[INET6_ADDRSTRLEN + 1]; char *client = NULL; struct addrinfo *tmp = NULL; - struct addrinfo *ai = NULL; if (readline(fileno(f), &lbuf, &lbuflen) != 1) return; @@ -96,7 +94,7 @@ static void auth_unix_ip(FILE *f) strcmp(class, "nfsd") != 0) return; - if (qword_get(&cp, ipaddr, sizeof(ipaddr)) <= 0) + if (qword_get(&cp, ipaddr, sizeof(ipaddr) - 1) <= 0) return; tmp = host_pton(ipaddr); @@ -107,23 +105,29 @@ static void auth_unix_ip(FILE *f) /* addr is a valid, interesting address, find the domain name... */ if (!use_ipaddr) { + struct addrinfo *ai = NULL; + ai = client_resolve(tmp->ai_addr); - client = client_compose(ai); - freeaddrinfo(ai); + if (ai) { + client = client_compose(ai); + freeaddrinfo(ai); + } } - freeaddrinfo(tmp); - qword_print(f, "nfsd"); qword_print(f, ipaddr); - qword_printuint(f, time(0) + DEFAULT_TTL); - if (use_ipaddr) + qword_printtimefrom(f, DEFAULT_TTL); + if (use_ipaddr) { + memmove(ipaddr + 1, ipaddr, strlen(ipaddr) + 1); + ipaddr[0] = '$'; qword_print(f, ipaddr); - else if (client) + } else if (client) qword_print(f, *client?client:"DEFAULT"); qword_eol(f); xlog(D_CALL, "auth_unix_ip: client %p '%s'", client, client?client: "DEFAULT"); free(client); + freeaddrinfo(tmp); + } static void auth_unix_gid(FILE *f) @@ -177,7 +181,7 @@ static void auth_unix_gid(FILE *f) } } qword_printuint(f, uid); - qword_printuint(f, time(0) + DEFAULT_TTL); + qword_printtimefrom(f, DEFAULT_TTL); if (rv >= 0) { qword_printuint(f, ngroups); for (i=0; imnt_dir; } +static int is_subdirectory(char *child, char *parent) +{ + size_t l = strlen(parent); + + if (strcmp(parent, "/") == 0) + return 1; + + return strcmp(child, parent) == 0 + || (strncmp(child, parent, l) == 0 && child[l] == '/'); +} + +static int path_matches(nfs_export *exp, char *path) +{ + if (exp->m_export.e_flags & NFSEXP_CROSSMOUNT) + return is_subdirectory(path, exp->m_export.e_path); + return strcmp(path, exp->m_export.e_path) == 0; +} + +static int +export_matches(nfs_export *exp, char *dom, char *path, struct addrinfo *ai) +{ + return path_matches(exp, path) && client_matches(exp, dom, ai); +} + /* True iff e1 is a child of e2 and e2 has crossmnt set: */ static bool subexport(struct exportent *e1, struct exportent *e2) { char *p1 = e1->e_path, *p2 = e2->e_path; - int l2 = strlen(p2); + size_t l2 = strlen(p2); return e2->e_flags & NFSEXP_CROSSMOUNT - && strncmp(p1, p2, l2) == 0 - && p1[l2] == '/'; + && strncmp(p1, p2, l2) == 0 + && p1[l2] == '/'; } struct parsed_fsid { @@ -360,15 +388,17 @@ struct parsed_fsid { unsigned int minor; unsigned int major; unsigned int fsidnum; - int uuidlen; + size_t uuidlen; char *fhuuid; }; -int parse_fsid(int fsidtype, int fsidlen, char *fsid, struct parsed_fsid *parsed) +static int parse_fsid(int fsidtype, int fsidlen, char *fsid, + struct parsed_fsid *parsed) { unsigned int dev; unsigned long long inode64; + memset(parsed, 0, sizeof(*parsed)); parsed->fsidtype = fsidtype; switch(fsidtype) { case FSID_DEV: /* 4 bytes: 2 major, 2 minor, 4 inode */ @@ -495,6 +525,21 @@ static bool match_fsid(struct parsed_fsid *parsed, nfs_export *exp, char *path) return false; } +static struct addrinfo *lookup_client_addr(char *dom) +{ + struct addrinfo *ret; + struct addrinfo *tmp; + + dom++; /* skip initial "$" */ + + tmp = host_pton(dom); + if (tmp == NULL) + return NULL; + ret = client_resolve(tmp->ai_addr); + freeaddrinfo(tmp); + return ret; +} + static void nfsd_fh(FILE *f) { /* request are: @@ -538,6 +583,12 @@ static void nfsd_fh(FILE *f) auth_reload(); + if (is_ipaddr_client(dom)) { + ai = lookup_client_addr(dom); + if (!ai) + goto out; + } + /* Now determine export point for this fsid/domain */ for (i=0 ; i < MCL_MAXTYPES; i++) { nfs_export *next_exp; @@ -568,7 +619,8 @@ static void nfsd_fh(FILE *f) next_exp = exp->m_next; } - if (!use_ipaddr && !client_member(dom, exp->m_client->m_hostname)) + if (!is_ipaddr_client(dom) + && !namelist_client_matches(exp, dom)) continue; if (exp->m_export.e_mountpoint && !is_mountpoint(exp->m_export.e_mountpoint[0]? @@ -578,29 +630,29 @@ static void nfsd_fh(FILE *f) if (!match_fsid(&parsed, exp, path)) continue; - if (use_ipaddr) { - if (ai == NULL) { - struct addrinfo *tmp; - tmp = host_pton(dom); - if (tmp == NULL) - goto out; - ai = client_resolve(tmp->ai_addr); - freeaddrinfo(tmp); - } - if (!client_check(exp->m_client, ai)) - continue; - } + if (is_ipaddr_client(dom) + && !ipaddr_client_matches(exp, ai)) + continue; if (!found || subexport(&exp->m_export, found)) { found = &exp->m_export; free(found_path); found_path = strdup(path); if (found_path == NULL) goto out; - } else if (strcmp(found->e_path, exp->m_export.e_path) + } else if (strcmp(found->e_path, exp->m_export.e_path) != 0 && !subexport(found, &exp->m_export)) { xlog(L_WARNING, "%s and %s have same filehandle for %s, using first", found_path, path, dom); + } else { + /* same path, if one is V4ROOT, choose the other */ + if (found->e_flags & NFSEXP_V4ROOT) { + found = &exp->m_export; + free(found_path); + found_path = strdup(path); + if (found_path == NULL) + goto out; + } } } } @@ -685,6 +737,7 @@ static void write_secinfo(FILE *f, struct exportent *ep, int flag_mask) /* There was no sec= option */ return; } + fix_pseudoflavor_flags(ep); qword_print(f, "secinfo"); qword_printint(f, p - ep->e_secinfo); for (p = ep->e_secinfo; p->flav; p++) { @@ -702,7 +755,7 @@ static int dump_to_cache(FILE *f, char *domain, char *path, struct exportent *ex int different_fs = strcmp(path, exp->e_path) != 0; int flag_mask = different_fs ? ~NFSEXP_FSID : ~0; - qword_printuint(f, time(0) + exp->e_ttl); + qword_printtimefrom(f, exp->e_ttl); qword_printint(f, exp->e_flags & flag_mask); qword_printint(f, exp->e_anonuid); qword_printint(f, exp->e_anongid); @@ -722,39 +775,10 @@ static int dump_to_cache(FILE *f, char *domain, char *path, struct exportent *ex qword_printhex(f, u, 16); } } else - qword_printuint(f, time(0) + DEFAULT_TTL); + qword_printtimefrom(f, DEFAULT_TTL); return qword_eol(f); } -static int is_subdirectory(char *child, char *parent) -{ - int l = strlen(parent); - - return strcmp(child, parent) == 0 - || (strncmp(child, parent, l) == 0 && child[l] == '/'); -} - -static int path_matches(nfs_export *exp, char *path) -{ - if (exp->m_export.e_flags & NFSEXP_CROSSMOUNT) - return is_subdirectory(path, exp->m_export.e_path); - return strcmp(path, exp->m_export.e_path) == 0; -} - -static int -client_matches(nfs_export *exp, char *dom, struct addrinfo *ai) -{ - if (use_ipaddr) - return client_check(exp->m_client, ai); - return client_member(dom, exp->m_client->m_hostname); -} - -static int -export_matches(nfs_export *exp, char *dom, char *path, struct addrinfo *ai) -{ - return path_matches(exp, path) && client_matches(exp, dom, ai); -} - static nfs_export * lookup_export(char *dom, char *path, struct addrinfo *ai) { @@ -772,10 +796,14 @@ lookup_export(char *dom, char *path, struct addrinfo *ai) found_type = i; continue; } - - /* Always prefer non-V4ROOT mounts */ - if (found->m_export.e_flags & NFSEXP_V4ROOT) + /* Always prefer non-V4ROOT exports */ + if (exp->m_export.e_flags & NFSEXP_V4ROOT) continue; + if (found->m_export.e_flags & NFSEXP_V4ROOT) { + found = exp; + found_type = i; + continue; + } /* If one is a CROSSMOUNT, then prefer the longest path */ if (((found->m_export.e_flags & NFSEXP_CROSSMOUNT) || @@ -802,6 +830,317 @@ lookup_export(char *dom, char *path, struct addrinfo *ai) return found; } +#ifdef HAVE_NFS_PLUGIN_H +#include +#include +#include + +/* + * 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_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 = fslocdata; + *ttl = 0; + + for (;;) { + enum jp_status status; + int len; + + status = ops->jp_get_next_location(locations, &server, + &rootpath, ttl); + if (status == JP_EMPTY) + break; + if (status != JP_OK) { + xlog(D_GENERAL, "%s: failed to parse location: %s", + __func__, ops->jp_error(status)); + goto out_false; + } + xlog(D_GENERAL, "%s: Location: %s:%s", + __func__, server, rootpath); + + if (last_path && strcmp(rootpath, last_path) == 0) { + len = snprintf(ptr, remaining, "+%s", server); + if (len < 0) { + xlog(D_GENERAL, "%s: snprintf: %m", __func__); + goto out_false; + } + if ((size_t)len >= remaining) { + 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, "%s@%s", + rootpath, server); + else + len = snprintf(ptr, remaining, ":%s@%s", + rootpath, server); + if (len < 0) { + xlog(D_GENERAL, "%s: snprintf: %m", __func__); + goto out_false; + } + if ((size_t)len >= remaining) { + xlog(D_GENERAL, "%s: fslocdata buffer overflow", + __func__); + goto out_false; + } + remaining -= (size_t)len; + ptr += len; + last_path = rootpath; + } + + seen = true; + free(rootpath); + free(server); + } + + xlog(D_CALL, "%s: fslocdata='%s', ttl=%d", + __func__, fslocdata, *ttl); + return seen; + +out_false: + free(rootpath); + free(server); + return false; +} + +/* + * Duplicate the junction's parent's export options and graft in + * the fslocdata we constructed from the locations list. + */ +static struct exportent *create_junction_exportent(struct exportent *parent, + const char *junction, const char *fslocdata, int ttl) +{ + 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; + +out_nomem: + xlog(L_ERROR, "%s: No memory", __func__); + return NULL; +} + +/* + * 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, + struct exportent *parent) +{ + static char fslocdata[BUFSIZ]; + int ttl; + + fslocdata[0] = '\0'; + if (!locations_to_fslocdata(ops, locations, + fslocdata, sizeof(fslocdata), &ttl)) + return NULL; + 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. + */ +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; + enum jp_status status; + struct jp_ops *ops; + char *error; + + ops = (struct jp_ops *)dlsym(handle, "nfs_junction_ops"); + error = dlerror(); + if (error != NULL) { + xlog(D_GENERAL, "%s: dlsym(jp_junction_ops): %s", + __func__, error); + return NULL; + } + if (ops->jp_api_version != JP_API_VERSION) { + xlog(D_GENERAL, "%s: unrecognized junction API version: %u", + __func__, ops->jp_api_version); + return NULL; + } + + status = ops->jp_init(false); + if (status != JP_OK) { + xlog(D_GENERAL, "%s: failed to resolve %s: %s", + __func__, junction, ops->jp_error(status)); + return NULL; + } + + status = ops->jp_get_locations(junction, &locations); + 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; + } + + 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. + */ +static struct exportent *lookup_junction(char *dom, const char *pathname, + struct addrinfo *ai) +{ + struct exportent *exp; + struct link_map *map; + void *handle; + + handle = dlopen("libnfsjunct.so", RTLD_NOW); + if (handle == NULL) { + xlog(D_GENERAL, "%s: dlopen: %s", __func__, dlerror()); + return NULL; + } + + if (dlinfo(handle, RTLD_DI_LINKMAP, &map) == 0) + xlog(D_GENERAL, "%s: loaded plug-in %s", + __func__, map->l_name); + + (void)dlerror(); /* Clear any error */ + + 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 + * library, that would require restarting mountd. */ + (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 void lookup_nonexport(FILE *f, char *dom, char *path, + struct addrinfo *UNUSED(ai)) +{ + dump_to_cache(f, dom, path, NULL); +} +#endif /* !HAVE_NFS_PLUGIN_H */ + static void nfsd_export(FILE *f) { /* requests are: @@ -834,13 +1173,9 @@ static void nfsd_export(FILE *f) auth_reload(); - if (use_ipaddr) { - struct addrinfo *tmp; - tmp = host_pton(dom); - if (tmp == NULL) - goto out; - ai = client_resolve(tmp->ai_addr); - freeaddrinfo(tmp); + if (is_ipaddr_client(dom)) { + ai = lookup_client_addr(dom); + if (!ai) goto out; } @@ -853,9 +1188,9 @@ static void nfsd_export(FILE *f) " or fsid= required", path); dump_to_cache(f, dom, path, NULL); } - } else { - dump_to_cache(f, dom, path, NULL); - } + } 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); @@ -1015,7 +1350,7 @@ int cache_export(nfs_export *exp, char *path) qword_print(f, "nfsd"); qword_print(f, host_ntop(get_addrlist(exp->m_client, 0), buf, sizeof(buf))); - qword_printuint(f, time(0) + exp->m_export.e_ttl); + qword_printtimefrom(f, exp->m_export.e_ttl); qword_print(f, exp->m_client->m_hostname); err = qword_eol(f);