hostlist: update to copy in pdsh

src/libgendersllnl/hostlist.c

@@ -1,5 +1,5 @@
 /*****************************************************************************\
- *  $Id: hostlist.c,v 1.8 2008-01-29 19:09:11 chu11 Exp $
+ *  $LSDId: hostlist.c 11882 2012-10-03 17:31:41Z grondo $
  *****************************************************************************
  *  Copyright (C) 2002 The Regents of the University of California.
  *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
@@ -350,21 +350,6 @@ static void _error(char *file, int line, char *msg, ...)
     return;
 }
 
-static int _advance_past_brackets (char *tok, char **str)
-{
-    /* if _single_ opening bracket exists b/w tok and str, push str
-     * past first closing bracket to next seperator */
-    if (   memchr(tok, '[', *str - tok) != NULL
-        && memchr(tok, ']', *str - tok) == NULL ) {
-        char *q = strchr(*str, ']');
-        if (q && memchr(*str, '[', q - *str) == NULL) {
-            *str = q + 1;
-            return (1);
-        }
-    }
-
-    return 0;
-}
 
 /* 
  * Helper function for host list string parsing routines 
@@ -375,13 +360,16 @@ static int _advance_past_brackets (char *tok, char **str)
  * (with modifications to support bracketed hostlists, i.e.:
  *  xxx[xx,xx,xx] is a single token)
  *
+ * _next_tok now handles multiple brackets within the same token,
+ * e.g.  node[01-30]-[1-2,6].
  */
 static char * _next_tok(char *sep, char **str)
 {
     char *tok;
+    int level = 0;
 
     /* push str past any leading separators */
-    while (**str != '\0' && strchr(sep, **str) != '\0')
+    while (**str != '\0' && strchr(sep, **str))
         (*str)++;
 
     if (**str == '\0')
@@ -390,19 +378,15 @@ static char * _next_tok(char *sep, char **str)
     /* assign token ptr */
     tok = *str;
 
-    /*
-     * Advance str past any separators, but if a separator occurs between
-     *  brackets, e.g. foo[0-3,5], then advance str past closing brackets and
-     *  try again.
-     */
-    do {
-        /* push str past token and leave pointing to first separator */
-        while (**str != '\0' && strchr(sep, **str) == '\0')
-            (*str)++;
-    } while (_advance_past_brackets (tok, str));
-
+    while ( **str != '\0' &&
+	    (level != 0 || strchr(sep, **str) == NULL) ) {
+      if ( **str == '[' ) level++;
+      else if ( **str == ']' ) level--;
+      (*str)++;
+    }
+
    /* nullify consecutive separators and push str beyond them */
-    while (**str != '\0' && strchr(sep, **str) != '\0')
+    while (**str != '\0' && strchr(sep, **str) != NULL)
         *(*str)++ = '\0';
 
     return tok;
@@ -479,22 +463,16 @@ static int host_prefix_end(const char *hostname)
     return idx;
 }
 
-/* 
- * create a hostname_t object from a string hostname
- */
-static hostname_t hostname_create(const char *hostname)
+static hostname_t hostname_create_with_suffix (const char *hostname, int idx)
 {
     hostname_t hn = NULL;
-    char *p = '\0';
-    int idx = 0;
+    char *p = "\0";
 
     assert(hostname != NULL);
 
     if (!(hn = (hostname_t) malloc(sizeof(*hn))))
         out_of_memory("hostname create");
 
-    idx = host_prefix_end(hostname);
-
     if (!(hn->hostname = strdup(hostname))) {
         free(hn);
         out_of_memory("hostname create");
@@ -531,6 +509,17 @@ static hostname_t hostname_create(const char *hostname)
     }
 
     return hn;
+
+}
+
+
+/* 
+ * create a hostname_t object from a string hostname
+ */
+static hostname_t hostname_create(const char *hostname)
+{
+    int idx = host_prefix_end (hostname);
+    return hostname_create_with_suffix (hostname, idx);
 }
 
 /* free a hostname object
@@ -901,27 +890,98 @@ static hostrange_t hostrange_intersect(hostrange_t h1, hostrange_t h2)
     return new;
 }
 
-/* return 1 if hostname hn is within the hostrange hr
- *        0 if not.
+/* return offset of hn if it is in the hostlist or
+ *        -1 if not.
  */
 static int hostrange_hn_within(hostrange_t hr, hostname_t hn)
 {
-    int retval = 0;
+    int len_hr;
+    int len_hn;
+    int width;
 
-    if (hr->singlehost && (strcmp(hn->hostname, hr->prefix) == 0))
-        return 1;
+    if (hr->singlehost) {
+        /*
+         *  If the current hostrange [hr] is a `singlehost' (no valid
+         *   numeric suffix (lo and hi)), then the hostrange [hr]
+         *   stores just one host with name == hr->prefix.
+         *
+         *  Thus the full hostname in [hn] must match hr->prefix, in
+         *   which case we return true. Otherwise, there is no
+         *   possibility that [hn] matches [hr].
+         */
+        if (strcmp (hn->hostname, hr->prefix) == 0)
+            return 0;
+        else
+            return -1;
+    }
 
-    if (strcmp(hr->prefix, hn->prefix) == 0) {
-        if (!hostname_suffix_is_valid(hn)) {
-            if (hr->singlehost)
-                retval = 1;
-        } else if (hn->num <= hr->hi && hn->num >= hr->lo) {
-            int width = hostname_suffix_width(hn);
-            int num = hn->num;
-            retval = _width_equiv(hr->lo, &hr->width, num, &width);
-        }
+    /*
+     *  Now we know [hr] is not a "singlehost", so hostname
+     *   better have a valid numeric suffix, or there is no
+     *   way we can match
+     */
+    if (!hostname_suffix_is_valid (hn))
+        return -1;
+
+    len_hn = strlen (hn->prefix);
+
+    /*
+     *  If hostrange and hostname prefixes don't match to at least
+     *   the length of the hostname object (which will have the min
+     *   possible prefix length), then there is no way the hostname
+     *   falls within the range [hr].
+     */
+    if (strncmp (hr->prefix, hn->prefix, len_hn) != 0)
+        return -1;
+
+    /*
+     *  Now we know hostrange and hostname prefixes match up to the
+     *   length of the hostname prefix.  If the hostrange and hostname
+     *   prefix lengths do not match (specifically if the hostname prefix
+     *   length is less than the hostrange prefix length) and the
+     *   hostrange prefix contains trailing digits, then it might be
+     *   the case that the hostrange was created by forcing the prefix
+     *   to contain digits a la f00[1-2]. So we try adjusting the
+     *   hostname with the longer prefix and calling this function
+     *   again with the new hostname. (Yes, this is ugly, sorry)
+     */
+    len_hr = strlen (hr->prefix);
+    width = hostname_suffix_width (hn);
+
+    if ((len_hn < len_hr)
+         && (width > 1)
+         && (isdigit (hr->prefix [len_hr - 1]))
+         && (hr->prefix [len_hn] == hn->suffix[0]) ) {
+        int rc;
+        /*
+         *  Create new hostname object with its prefix offset by one
+         */
+        hostname_t h = hostname_create_with_suffix (hn->hostname, len_hn);
+        /*
+         *  Recursive call :-o
+         */
+        rc = hostrange_hn_within (hr, h);
+        hostname_destroy (h);
+        return rc;
     }
-    return retval;
+
+
+    /*
+     *  Finally, check whether [hn], with a valid numeric suffix,
+     *   falls within the range of [hr] if [hn] and [hr] prefix are
+     *   identical.
+     */
+    if ((len_hr == len_hn)
+        && (strcmp (hn->prefix, hr->prefix) == 0)
+        && (hn->num <= hr->hi)
+        && (hn->num >= hr->lo)) {
+        int width = hostname_suffix_width (hn);
+        if (!_width_equiv(hr->lo, &hr->width, hn->num, &width))
+            return -1;
+        return (hn->num - hr->lo);
+    }
+
+    return -1;
 }
 
 
@@ -1836,8 +1896,8 @@ int hostlist_delete_nth(hostlist_t hl, int n)
     }
 
   done:
-    UNLOCK_HOSTLIST(hl);
     hl->nhosts--;
+    UNLOCK_HOSTLIST(hl);
     return 1;
 }
 
@@ -1863,17 +1923,15 @@ int hostlist_find(hostlist_t hl, const char *hostname)
     LOCK_HOSTLIST(hl);
 
     for (i = 0, count = 0; i < hl->nranges; i++) {
-        if (hostrange_hn_within(hl->hr[i], hn)) {
-            if (hostname_suffix_is_valid(hn) && !hl->hr[i]->singlehost)
-                ret = count + hn->num - hl->hr[i]->lo;
-            else
-                ret = count;
-            goto done;
-        } else
+        int offset = hostrange_hn_within(hl->hr[i], hn);
+        if (offset >= 0) {
+            ret = count + offset;
+            break;
+        }
+        else
             count += hostrange_count(hl->hr[i]);
     }
 
-  done:
     UNLOCK_HOSTLIST(hl);
     hostname_destroy(hn);
     return ret;
@@ -2087,7 +2145,7 @@ _get_bracketed_list(hostlist_t hl, int *start, const size_t n, char *buf)
     if ((len < 0) || (len > n))
         return n; /* truncated, buffer filled */
 
-    if (bracket_needed && len < n && len >= 0)
+    if (bracket_needed && len < n)
         buf[len++] = '[';
 
     do {
@@ -2453,7 +2511,7 @@ static int hostset_find_host(hostset_t set, const char *host)
     LOCK_HOSTLIST(set->hl);
     hn = hostname_create(host);
     for (i = 0; i < set->hl->nranges; i++) {
-        if (hostrange_hn_within(set->hl->hr[i], hn)) {
+        if (hostrange_hn_within(set->hl->hr[i], hn) >= 0) {
             retval = 1;
             goto done;
         }

src/libgendersllnl/hostlist.h

@@ -1,5 +1,7 @@
 /*****************************************************************************\
- *  $Id: hostlist.h,v 1.8 2008-01-29 19:09:12 chu11 Exp $
+ *  $Id$
+ *****************************************************************************
+ *  $LSDId: hostlist.h 7428 2008-05-23 16:08:31Z grondo $
  *****************************************************************************
  *  Copyright (C) 2002 The Regents of the University of California.
  *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
@@ -27,6 +29,8 @@
 #ifndef _HOSTLIST_H
 #define _HOSTLIST_H
 
+#include <unistd.h>
+
 /* Notes:
  *
  * If WITH_LSD_FATAL_ERROR_FUNC is defined, the linker will expect to