libexport.a: replace xlog(L_FATAL) in client_check()
[nfs-utils.git] / support / export / client.c
index 33dfdb0..aa28fcf 100644 (file)
 #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, };
 
@@ -118,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);
@@ -127,14 +129,11 @@ 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;
@@ -207,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) {
@@ -265,13 +254,19 @@ client_compose(struct in_addr addr)
        return 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(char *client, char *name)
+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'))
@@ -284,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;
@@ -299,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);
@@ -329,99 +323,163 @@ 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 */
 
+/**
+ * client_check - check if IP address information matches a cached nfs_client
+ * @clp: pointer to a cached nfs_client record
+ * @hp: pointer to hostent containing host IP information
+ *
+ * Returns 1 if the address information matches the cached nfs_client,
+ * otherwise zero.
+ */
+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(D_GENERAL, "%s: unrecognized client type: %d",
+                               __func__, clp->m_type);
        }
+
        return 0;
 }