X-Git-Url: https://git.decadent.org.uk/gitweb/?p=nfs-utils.git;a=blobdiff_plain;f=support%2Fexport%2Fclient.c;h=bf2a35995a1d00536c74d0f9c1745549e05e6619;hp=3884795c0f58e12147ec443947753ad620c9961c;hb=a39b43b81a8e7b70310f250c5ffd77816577cd6c;hpb=553caba3865667724291106d919e7c3fdf9534aa diff --git a/support/export/client.c b/support/export/client.c index 3884795..bf2a359 100644 --- a/support/export/client.c +++ b/support/export/client.c @@ -6,13 +6,16 @@ * Copyright (C) 1995, 1996 Olaf Kirch */ -#include "config.h" +#ifdef HAVE_CONFIG_H +#include +#endif #include #include #include #include #include +#include #include #include "xmalloc.h" #include "misc.h" @@ -25,9 +28,10 @@ #if !defined(__GLIBC__) || __GLIBC__ < 2 extern int innetgr(char *netgr, char *host, char *, char *); #endif + +static char *add_name(char *old, const char *add); static void client_init(nfs_client *clp, const char *hname, struct hostent *hp); -static int client_checkaddr(nfs_client *clp, struct in_addr addr); nfs_client *clientlist[MCL_MAXTYPES] = { NULL, }; @@ -115,6 +119,7 @@ client_dup(nfs_client *clp, struct hostent *hp) new = (nfs_client *) xmalloc(sizeof(*new)); memcpy(new, clp, sizeof(*new)); new->m_type = MCL_FQDN; + new->m_hostname = NULL; client_init(new, (char *) hp->h_name, hp); client_add(new); @@ -124,21 +129,20 @@ client_dup(nfs_client *clp, struct hostent *hp) static void client_init(nfs_client *clp, const char *hname, struct hostent *hp) { - if (hp) { - strncpy(clp->m_hostname, hp->h_name, - sizeof (clp->m_hostname) - 1); - } else { - strncpy(clp->m_hostname, hname, - sizeof (clp->m_hostname) - 1); - } - clp->m_hostname[sizeof (clp->m_hostname) - 1] = '\0'; + xfree(clp->m_hostname); + if (hp) + clp->m_hostname = xstrdup(hp->h_name); + else + clp->m_hostname = xstrdup(hname); clp->m_exported = 0; clp->m_count = 0; if (clp->m_type == MCL_SUBNETWORK) { char *cp = strchr(clp->m_hostname, '/'); + static char slash32[] = "/32"; + if(!cp) cp = slash32; *cp = '\0'; clp->m_addrlist[0].s_addr = inet_addr(clp->m_hostname); if (strchr(cp + 1, '.')) { @@ -202,53 +206,43 @@ client_freeall(void) head = clientlist + i; while (*head) { *head = (clp = *head)->m_next; + xfree(clp->m_hostname); xfree(clp); } } } -nfs_client * -client_find(struct hostent *hp) +struct hostent * +client_resolve(struct in_addr addr) { - nfs_client *clp; - int i; + struct hostent *he = NULL; - for (i = 0; i < MCL_MAXTYPES; i++) { - for (clp = clientlist[i]; clp; clp = clp->m_next) { - if (!client_check(clp, hp)) - continue; -#ifdef notdef - if (clp->m_type == MCL_FQDN) - return clp; - return client_dup(clp, hp); -#else - return clp; -#endif - } - } - return NULL; + if (clientlist[MCL_WILDCARD] || clientlist[MCL_NETGROUP]) + he = get_reliable_hostbyaddr((const char*)&addr, sizeof(addr), AF_INET); + if (he == NULL) + he = get_hostent((const char*)&addr, sizeof(addr), AF_INET); + + return he; } -/* - * Find client name given an IP address - * This is found by gathering all known names that match that IP address, - * sorting them and joining them with '+' +/** + * client_compose - Make a list of cached hostnames that match an IP address + * @he: pointer to hostent containing IP address information to match * + * Gather all known client hostnames that match the IP address, and sort + * the result into a comma-separated list. + * + * Returns a '\0'-terminated ASCII string containing a comma-separated + * sorted list of client hostnames, or NULL if no client records matched + * the IP address or memory could not be allocated. Caller must free the + * returned string with free(3). */ -static char *add_name(char *old, char *add); - char * -client_compose(struct in_addr addr) +client_compose(struct hostent *he) { - struct hostent *he = NULL; char *name = NULL; int i; - if (clientlist[MCL_WILDCARD] || clientlist[MCL_NETGROUP]) - he = get_reliable_hostbyaddr((const char*)&addr, sizeof(addr), AF_INET); - if (he == NULL) - he = get_hostent((const char*)&addr, sizeof(addr), AF_INET); - for (i = 0 ; i < MCL_MAXTYPES; i++) { nfs_client *clp; for (clp = clientlist[i]; clp ; clp = clp->m_next) { @@ -260,13 +254,19 @@ client_compose(struct in_addr addr) return name; } -int -client_member(char *client, char *name) +/** + * client_member - check if @name is contained in the list @client + * @client: '\0'-terminated ASCII string containing + * comma-separated list of hostnames + * @name: '\0'-terminated ASCII string containing hostname to look for + * + * Returns 1 if @name was found in @client, otherwise zero is returned. + */ +int +client_member(const char *client, const char *name) { - /* check if "client" (a ',' separated list of names) - * contains 'name' as a member - */ - int l = strlen(name); + size_t l = strlen(name); + while (*client) { if (strncmp(client, name, l) == 0 && (client[l] == ',' || client[l] == '\0')) @@ -279,14 +279,13 @@ client_member(char *client, char *name) return 0; } - -int -name_cmp(char *a, char *b) +static int +name_cmp(const char *a, const char *b) { /* compare strings a and b, but only upto ',' in a */ while (*a && *b && *a != ',' && *a == *b) a++, b++; - if (!*b && (!*a || !a == ',') ) + if (!*b && (!*a || *a == ',')) return 0; if (!*b) return 1; if (!*a || *a == ',') return -1; @@ -294,9 +293,9 @@ name_cmp(char *a, char *b) } static char * -add_name(char *old, char *add) +add_name(char *old, const char *add) { - int len = strlen(add)+2; + size_t len = strlen(add) + 2; char *new; char *cp; if (old) len += strlen(old); @@ -324,99 +323,158 @@ add_name(char *old, char *add) strcat(new, ","); strcat(new, cp); } + free(old); return new; } /* - * Match a host (given its hostent record) to a client record. This - * is usually called from mountd. + * Check each address listed in @hp against each address + * stored in @clp. Return 1 if a match is found, otherwise + * zero. */ -int -client_check(nfs_client *clp, struct hostent *hp) +static int +check_fqdn(const nfs_client *clp, const struct hostent *hp) { - char *hname = (char *) hp->h_name; - char *cname = clp->m_hostname; - char **ap; + struct in_addr addr; + char **ap; + int i; - switch (clp->m_type) { - case MCL_FQDN: - case MCL_SUBNETWORK: - for (ap = hp->h_addr_list; *ap; ap++) { - if (client_checkaddr(clp, *(struct in_addr *) *ap)) - return 1; - } - return 0; - case MCL_WILDCARD: - if (wildmat(hname, cname)) - return 1; - else { - for (ap = hp->h_aliases; *ap; ap++) - if (wildmat(*ap, cname)) - return 1; - } - return 0; - case MCL_NETGROUP: -#ifdef HAVE_INNETGR - { - char *dot; - int match; - struct hostent *nhp = NULL; - struct sockaddr_in addr; - - /* First, try to match the hostname without - * splitting off the domain */ - if (innetgr(cname+1, hname, NULL, NULL)) + for (ap = hp->h_addr_list; *ap; ap++) { + addr = *(struct in_addr *)*ap; + + for (i = 0; i < clp->m_naddr; i++) + if (clp->m_addrlist[i].s_addr == addr.s_addr) return 1; + } + return 0; +} - /* If hname is ip address convert to FQDN */ - if (inet_aton(hname, &addr.sin_addr) && - (nhp = gethostbyaddr((const char *)&(addr.sin_addr), - sizeof(addr.sin_addr), AF_INET))) { - hname = (char *)nhp->h_name; - if (innetgr(cname+1, hname, NULL, NULL)) - return 1; - } +/* + * Check each address listed in @hp against the subnetwork or + * host address stored in @clp. Return 1 if an address in @hp + * matches the host address stored in @clp, otherwise zero. + */ +static int +check_subnetwork(const nfs_client *clp, const struct hostent *hp) +{ + struct in_addr addr; + char **ap; - /* Okay, strip off the domain (if we have one) */ - if ((dot = strchr(hname, '.')) == NULL) - return 0; + for (ap = hp->h_addr_list; *ap; ap++) { + addr = *(struct in_addr *)*ap; - *dot = '\0'; - match = innetgr(cname+1, hname, NULL, NULL); - *dot = '.'; + if (!((clp->m_addrlist[0].s_addr ^ addr.s_addr) & + clp->m_addrlist[1].s_addr)) + return 1; + } + return 0; +} - return match; - } -#else - return 0; -#endif - case MCL_ANONYMOUS: +/* + * Check if a wildcard nfs_client record matches the canonical name + * or the aliases of a host. Return 1 if a match is found, otherwise + * zero. + */ +static int +check_wildcard(const nfs_client *clp, const struct hostent *hp) +{ + char *cname = clp->m_hostname; + char *hname = hp->h_name; + char **ap; + + if (wildmat(hname, cname)) return 1; - case MCL_GSS: - return 0; - default: - xlog(L_FATAL, "internal: bad client type %d", clp->m_type); + + /* See if hname aliases listed in /etc/hosts or nis[+] + * match the requested wildcard */ + for (ap = hp->h_aliases; *ap; ap++) { + if (wildmat(*ap, cname)) + return 1; } return 0; } +/* + * Check if @hp's hostname or aliases fall in a given netgroup. + * Return 1 if @hp represents a host in the netgroup, otherwise zero. + */ +#ifdef HAVE_INNETGR +static int +check_netgroup(const nfs_client *clp, const struct hostent *hp) +{ + const char *netgroup = clp->m_hostname + 1; + const char *hname = hp->h_name; + struct hostent *nhp = NULL; + struct sockaddr_in addr; + int match, i; + char *dot; + + /* First, try to match the hostname without + * splitting off the domain */ + if (innetgr(netgroup, hname, NULL, NULL)) + return 1; + + /* See if hname aliases listed in /etc/hosts or nis[+] + * match the requested netgroup */ + for (i = 0; hp->h_aliases[i]; i++) { + if (innetgr(netgroup, hp->h_aliases[i], NULL, NULL)) + return 1; + } + + /* If hname is ip address convert to FQDN */ + if (inet_aton(hname, &addr.sin_addr) && + (nhp = gethostbyaddr((const char *)&(addr.sin_addr), + sizeof(addr.sin_addr), AF_INET))) { + hname = nhp->h_name; + if (innetgr(netgroup, hname, NULL, NULL)) + return 1; + } + + /* Okay, strip off the domain (if we have one) */ + dot = strchr(hname, '.'); + if (dot == NULL) + return 0; + + *dot = '\0'; + match = innetgr(netgroup, hname, NULL, NULL); + *dot = '.'; + + return match; +} +#else /* !HAVE_INNETGR */ static int -client_checkaddr(nfs_client *clp, struct in_addr addr) +check_netgroup(__attribute__((unused)) const nfs_client *clp, + __attribute__((unused)) const struct hostent *hp) { - int i; + return 0; +} +#endif /* !HAVE_INNETGR */ +/* + * Match a host (given its hostent record) to a client record. This + * is usually called from mountd. + */ +int +client_check(nfs_client *clp, struct hostent *hp) +{ switch (clp->m_type) { case MCL_FQDN: - for (i = 0; i < clp->m_naddr; i++) { - if (clp->m_addrlist[i].s_addr == addr.s_addr) - return 1; - } - return 0; + return check_fqdn(clp, hp); case MCL_SUBNETWORK: - return !((clp->m_addrlist[0].s_addr ^ addr.s_addr) - & clp->m_addrlist[1].s_addr); + return check_subnetwork(clp, hp); + case MCL_WILDCARD: + return check_wildcard(clp, hp); + case MCL_NETGROUP: + return check_netgroup(clp, hp); + case MCL_ANONYMOUS: + return 1; + case MCL_GSS: + return 0; + default: + xlog(L_FATAL, "internal: bad client type %d", clp->m_type); } + return 0; } @@ -443,5 +501,12 @@ client_gettype(char *ident) if (*sp == '\\' && sp[1]) sp++; } - return MCL_FQDN; + /* check for N.N.N.N */ + sp = ident; + if(!isdigit(*sp) || strtoul(sp, &sp, 10) > 255 || *sp != '.') return MCL_FQDN; + sp++; if(!isdigit(*sp) || strtoul(sp, &sp, 10) > 255 || *sp != '.') return MCL_FQDN; + sp++; if(!isdigit(*sp) || strtoul(sp, &sp, 10) > 255 || *sp != '.') return MCL_FQDN; + sp++; if(!isdigit(*sp) || strtoul(sp, &sp, 10) > 255 || *sp != '\0') return MCL_FQDN; + /* we lie here a bit. but technically N.N.N.N == N.N.N.N/32 :) */ + return MCL_SUBNETWORK; }