-- Added support for more than one front-end node to run slurmd on
    architectures where the slurmd does not execute on the compute nodes
    (e.g. BlueGene). New configuration paramters FrontendNode and FrontendAddr
    added. See "man slurm.conf" for more information.

Added flag to slurmdbd.conf TrackSlurmctldDown where if set will mark idle resources as down on a cluster when a slurmctld disconnects or is no longer reachable.

all compute nodes, and add update functionality

hostlist_deranged_string(): test for overflow
			    
This builds upon the preceding patch, exploiting that hostrange_to_string()
 * returns >= 0 when it has terminated the string with '\0', where  either 
   - n == 0 and it has not written anything or
   - it has written at most n > 0 characters, indicated by returning  n-1 >= 0;
 * returns a negative value to indicate truncation.

Hence hostrange_deranged_string() changed as follows:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * added 'len < n' as loop condition, to catch the case 'n == 0'
   (also exploiting that NUL-termination is only needed on error);
 * separator now is inserted after all non-first elements
   (to avoid having to undo the last separator);
 * as in preceding patch, replaced 'truncated' variable by a jump label.

hostrange_to_string(): truncation checks

 * turned 'truncated' variable into jump label;
 * loop changes so that the pre-condition is always len < n:
   - if len >= n inside the loop, the a jump to 'truncated' follows,
   - hence loop post-condition is also len < n, so that buf[len] = '\0' works;
 * consistently check ret=snprintf() for "ret < 0 || (len += ret) >= n",
   - if dims > 1, also tests to ensure that len + dims < n,
   - further overflow test after incrementing len for  separator;
 * moved separator test up (inserted when i > hr->lo)
   (to avoid having to undo the last separator).

hostrange_pop()/hostrange_shift(): test for overflow

hostrange_pop():				   
 * retrofitted out_of_memory() test after strdup;
 * tested for negative length/overflow before the while-loop,
   making sure that 'dims' characters also fit in;
 * second snprintf is not tested.

hostrange_shift(): 
 * analogous changes (second snprintf also not tested). 

host_prefix_end(): save variable, factor out common expressions

This saves one variable and factors out the condition common
to the if/else branches.06_hostlist__host_prefix_end.diff

 * return type of strlen is unsigned (size_t), hence strlen(hostname) >= 0;
 * both while-loops require idx >= 0, hence -1 is returned
   if strlen(hostname) == 0.

_get_bracketed_list(): simplify and look for overflow conditions
		       
 * initial test requires that len + 4 < n,
   - this ensures enough space for '[', ']', one digit and '\0',
   - simplifies many subsequent tests (e.g. for bracket_needed);
 * loop has been reorganized:
   - pre-condition:       len + 3 < n
   - loop run-condition:  len < n-1
   - post-condition:      len < n-1 (otherwise, it returns n);
 * therefore len < n after adding ']'
 * and thus len < n when calling buf[len] = '\0'.

hostrange_numstr(): overflow cases

This checks hostrange_numstr() for overflow cases:		    
 * requires n > dims (if dims=1, min 1 digit, else dim + '\0' digits);
   - this precondition simplifies many subsequent checks and
   - addresses if (len == n) then len++ means buf[len] = buf[n];
 * also checks return value of the snprintfs.

_hostrange_string()/hostlist_next(): test for overrun

This lets the two functions _hostrange_string/hostlist_next return NULL in case
there is an overflow condition.

Two possible overflow conditions were analyzed:
 * if len <= MAXHOSTNAMELEN + 15 and the '=' is the case, then len++ means
   that buf[len] = '\0' is the same as buf[MAXHOSTNAMELEN + 16], which would
   cause a segmentation violation - fixed by checking length beforehand;
 * also checks the return value of the snprintfs,
 * and requires 'dims' as minimum suffix length.

hostlist: let hostlist_get_base() depend on current dimensions

This patch saves one call to slurmdb_setup_cluster_dims(): exploiting
that the dimensions for which hostlist_get_base() is called are known
in all contexts in which the function is used.

hostlist: shorter conversion

This replaces the hostlist_parse_int_to_array() routine with a simpler and 
equivalent routine. I was wondering what the algorithm does, when suddenly
the flow became simpler.

Problem: we want to create an array 'out' of 'dims' dimensions where
         out[i], 0 <= i < dims, has the coefficients a_j of the polynomial

	 a_(dims-1) * B^(dims-1) + ... + a_1 * B + a_0

	 where B is the base of the polynomial 'in' and
	    a_0        = out[dims - 1]
	    a_1        = out[dims - 2]
	    ...
	    a_(dims-1) = a[0]

Using the Horner Scheme, 'in' is represented as
 * dims = 1:                                   a_0 = out[0]
 * dims = 2:                        a_1  * B + a_0 = out[0] * B + out[1]
 * dims = 3:            (a_2  * B + a_1) * B + a_0 
 * dims = 4: ((a_3 * B + a_2) * B + a_1) * B + a_0
   ...
 * dims = n: ((a_(n-1) * B + a_(n-2)) * B ... + a_1) * B + a_0

We can get a_0 = out[dims-1] as "in % B" and then derive a_1, a_2, ... by
first dividing by B, and then repeating the process.

If in is 0, all 'dims' coefficients are 0, if it is negative, all coefficients
are negative.