src/util.c

#include "fmacros.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#include <math.h>
#include <unistd.h>
#include <sys/time.h>

#include "util.h"

/* Glob-style pattern matching. */
int stringmatchlen(const char *pattern, int patternLen,
        const char *string, int stringLen, int nocase)
{
    while(patternLen) {
        switch(pattern[0]) {
        case '*':
            while (pattern[1] == '*') {
                pattern++;
                patternLen--;
            }
            if (patternLen == 1)
                return 1; /* match */
            while(stringLen) {
                if (stringmatchlen(pattern+1, patternLen-1,
                            string, stringLen, nocase))
                    return 1; /* match */
                string++;
                stringLen--;
            }
            return 0; /* no match */
            break;
        case '?':
            if (stringLen == 0)
                return 0; /* no match */
            string++;
            stringLen--;
            break;
        case '[':
        {
            int not, match;

            pattern++;
            patternLen--;
            not = pattern[0] == '^';
            if (not) {
                pattern++;
                patternLen--;
            }
            match = 0;
            while(1) {
                if (pattern[0] == '\\') {
                    pattern++;
                    patternLen--;
                    if (pattern[0] == string[0])
                        match = 1;
                } else if (pattern[0] == ']') {
                    break;
                } else if (patternLen == 0) {
                    pattern--;
                    patternLen++;
                    break;
                } else if (pattern[1] == '-' && patternLen >= 3) {
                    int start = pattern[0];
                    int end = pattern[2];
                    int c = string[0];
                    if (start > end) {
                        int t = start;
                        start = end;
                        end = t;
                    }
                    if (nocase) {
                        start = tolower(start);
                        end = tolower(end);
                        c = tolower(c);
                    }
                    pattern += 2;
                    patternLen -= 2;
                    if (c >= start && c <= end)
                        match = 1;
                } else {
                    if (!nocase) {
                        if (pattern[0] == string[0])
                            match = 1;
                    } else {
                        if (tolower((int)pattern[0]) == tolower((int)string[0]))
                            match = 1;
                    }
                }
                pattern++;
                patternLen--;
            }
            if (not)
                match = !match;
            if (!match)
                return 0; /* no match */
            string++;
            stringLen--;
            break;
        }
        case '\\':
            if (patternLen >= 2) {
                pattern++;
                patternLen--;
            }
            /* fall through */
        default:
            if (!nocase) {
                if (pattern[0] != string[0])
                    return 0; /* no match */
            } else {
                if (tolower((int)pattern[0]) != tolower((int)string[0]))
                    return 0; /* no match */
            }
            string++;
            stringLen--;
            break;
        }
        pattern++;
        patternLen--;
        if (stringLen == 0) {
            while(*pattern == '*') {
                pattern++;
                patternLen--;
            }
            break;
        }
    }
    if (patternLen == 0 && stringLen == 0)
        return 1;
    return 0;
}

int stringmatch(const char *pattern, const char *string, int nocase) {
    return stringmatchlen(pattern,strlen(pattern),string,strlen(string),nocase);
}

/* Convert a string representing an amount of memory into the number of
 * bytes, so for instance memtoll("1Gi") will return 1073741824 that is
 * (1024*1024*1024).
 *
 * On parsing error, if *err is not NULL, it's set to 1, otherwise it's
 * set to 0 */
long long memtoll(const char *p, int *err) {
    const char *u;
    char buf[128];
    long mul; /* unit multiplier */
    long long val;
    unsigned int digits;

    if (err) *err = 0;
    /* Search the first non digit character. */
    u = p;
    if (*u == '-') u++;
    while(*u && isdigit(*u)) u++;
    if (*u == '\0' || !strcasecmp(u,"b")) {
        mul = 1;
    } else if (!strcasecmp(u,"k")) {
        mul = 1000;
    } else if (!strcasecmp(u,"kb")) {
        mul = 1024;
    } else if (!strcasecmp(u,"m")) {
        mul = 1000*1000;
    } else if (!strcasecmp(u,"mb")) {
        mul = 1024*1024;
    } else if (!strcasecmp(u,"g")) {
        mul = 1000L*1000*1000;
    } else if (!strcasecmp(u,"gb")) {
        mul = 1024L*1024*1024;
    } else {
        if (err) *err = 1;
        mul = 1;
    }
    digits = u-p;
    if (digits >= sizeof(buf)) {
        if (err) *err = 1;
        return LLONG_MAX;
    }
    memcpy(buf,p,digits);
    buf[digits] = '\0';
    val = strtoll(buf,NULL,10);
    return val*mul;
}

/* Convert a long long into a string. Returns the number of
 * characters needed to represent the number, that can be shorter if passed
 * buffer length is not enough to store the whole number. */
int ll2string(char *s, size_t len, long long value) {
    char buf[32], *p;
    unsigned long long v;
    size_t l;

    if (len == 0) return 0;
    v = (value < 0) ? -value : value;
    p = buf+31; /* point to the last character */
    do {
        *p-- = '0'+(v%10);
        v /= 10;
    } while(v);
    if (value < 0) *p-- = '-';
    p++;
    l = 32-(p-buf);
    if (l+1 > len) l = len-1; /* Make sure it fits, including the nul term */
    memcpy(s,p,l);
    s[l] = '\0';
    return l;
}

/* Convert a string into a long long. Returns 1 if the string could be parsed
 * into a (non-overflowing) long long, 0 otherwise. The value will be set to
 * the parsed value when appropriate. */
int string2ll(const char *s, size_t slen, long long *value) {
    const char *p = s;
    size_t plen = 0;
    int negative = 0;
    unsigned long long v;

    if (plen == slen)
        return 0;

    /* Special case: first and only digit is 0. */
    if (slen == 1 && p[0] == '0') {
        if (value != NULL) *value = 0;
        return 1;
    }

    if (p[0] == '-') {
        negative = 1;
        p++; plen++;

        /* Abort on only a negative sign. */
        if (plen == slen)
            return 0;
    }

    /* First digit should be 1-9, otherwise the string should just be 0. */
    if (p[0] >= '1' && p[0] <= '9') {
        v = p[0]-'0';
        p++; plen++;
    } else if (p[0] == '0' && slen == 1) {
        *value = 0;
        return 1;
    } else {
        return 0;
    }

    while (plen < slen && p[0] >= '0' && p[0] <= '9') {
        if (v > (ULLONG_MAX / 10)) /* Overflow. */
            return 0;
        v *= 10;

        if (v > (ULLONG_MAX - (p[0]-'0'))) /* Overflow. */
            return 0;
        v += p[0]-'0';

        p++; plen++;
    }

    /* Return if not all bytes were used. */
    if (plen < slen)
        return 0;

    if (negative) {
        if (v > ((unsigned long long)(-(LLONG_MIN+1))+1)) /* Overflow. */
            return 0;
        if (value != NULL) *value = -v;
    } else {
        if (v > LLONG_MAX) /* Overflow. */
            return 0;
        if (value != NULL) *value = v;
    }
    return 1;
}

/* Convert a string into a long. Returns 1 if the string could be parsed into a
 * (non-overflowing) long, 0 otherwise. The value will be set to the parsed
 * value when appropriate. */
int string2l(const char *s, size_t slen, long *lval) {
    long long llval;

    if (!string2ll(s,slen,&llval))
        return 0;

    if (llval < LONG_MIN || llval > LONG_MAX)
        return 0;

    *lval = (long)llval;
    return 1;
}

/* Convert a double to a string representation. Returns the number of bytes
 * required. The representation should always be parsable by stdtod(3). */
int d2string(char *buf, size_t len, double value) {
    if (isnan(value)) {
        len = snprintf(buf,len,"nan");
    } else if (isinf(value)) {
        if (value < 0)
            len = snprintf(buf,len,"-inf");
        else
            len = snprintf(buf,len,"inf");
    } else if (value == 0) {
        /* See: http://en.wikipedia.org/wiki/Signed_zero, "Comparisons". */
        if (1.0/value < 0)
            len = snprintf(buf,len,"-0");
        else
            len = snprintf(buf,len,"0");
    } else {
#if (DBL_MANT_DIG >= 52) && (LLONG_MAX == 0x7fffffffffffffffLL)
        /* Check if the float is in a safe range to be casted into a
         * long long. We are assuming that long long is 64 bit here.
         * Also we are assuming that there are no implementations around where
         * double has precision < 52 bit.
         *
         * Under this assumptions we test if a double is inside an interval
         * where casting to long long is safe. Then using two castings we
         * make sure the decimal part is zero. If all this is true we use
         * integer printing function that is much faster. */
        double min = -4503599627370495; /* (2^52)-1 */
        double max = 4503599627370496; /* -(2^52) */
        if (val > min && val < max && value == ((double)((long long)value)))
            len = ll2string(buf,len,(long long)value);
        else
#endif
            len = snprintf(buf,len,"%.17g",value);
    }

    return len;
}

/* Generate the Redis "Run ID", a SHA1-sized random number that identifies a
 * given execution of Redis, so that if you are talking with an instance
 * having run_id == A, and you reconnect and it has run_id == B, you can be
 * sure that it is either a different instance or it was restarted. */
void getRandomHexChars(char *p, unsigned int len) {
    FILE *fp = fopen("/dev/urandom","r");
    char *charset = "0123456789abcdef";
    unsigned int j;

    if (fp == NULL || fread(p,len,1,fp) == 0) {
        /* If we can't read from /dev/urandom, do some reasonable effort
         * in order to create some entropy, since this function is used to
         * generate run_id and cluster instance IDs */
        char *x = p;
        unsigned int l = len;
        struct timeval tv;
        pid_t pid = getpid();

        /* Use time and PID to fill the initial array. */
        gettimeofday(&tv,NULL);
        if (l >= sizeof(tv.tv_usec)) {
            memcpy(x,&tv.tv_usec,sizeof(tv.tv_usec));
            l -= sizeof(tv.tv_usec);
            x += sizeof(tv.tv_usec);
        }
        if (l >= sizeof(tv.tv_sec)) {
            memcpy(x,&tv.tv_sec,sizeof(tv.tv_sec));
            l -= sizeof(tv.tv_sec);
            x += sizeof(tv.tv_sec);
        }
        if (l >= sizeof(pid)) {
            memcpy(x,&pid,sizeof(pid));
            l -= sizeof(pid);
            x += sizeof(pid);
        }
        /* Finally xor it with rand() output, that was already seeded with
         * time() at startup. */
        for (j = 0; j < len; j++)
            p[j] ^= rand();
    }
    /* Turn it into hex digits taking just 4 bits out of 8 for every byte. */
    for (j = 0; j < len; j++)
        p[j] = charset[p[j] & 0x0F];
    fclose(fp);
}

#ifdef UTIL_TEST_MAIN
#include <assert.h>

void test_string2ll(void) {
    char buf[32];
    long long v;

    /* May not start with +. */
    strcpy(buf,"+1");
    assert(string2ll(buf,strlen(buf),&v) == 0);

    /* Leading space. */
    strcpy(buf," 1");
    assert(string2ll(buf,strlen(buf),&v) == 0);

    /* Trailing space. */
    strcpy(buf,"1 ");
    assert(string2ll(buf,strlen(buf),&v) == 0);

    /* May not start with 0. */
    strcpy(buf,"01");
    assert(string2ll(buf,strlen(buf),&v) == 0);

    strcpy(buf,"-1");
    assert(string2ll(buf,strlen(buf),&v) == 1);
    assert(v == -1);

    strcpy(buf,"0");
    assert(string2ll(buf,strlen(buf),&v) == 1);
    assert(v == 0);

    strcpy(buf,"1");
    assert(string2ll(buf,strlen(buf),&v) == 1);
    assert(v == 1);

    strcpy(buf,"99");
    assert(string2ll(buf,strlen(buf),&v) == 1);
    assert(v == 99);

    strcpy(buf,"-99");
    assert(string2ll(buf,strlen(buf),&v) == 1);
    assert(v == -99);

    strcpy(buf,"-9223372036854775808");
    assert(string2ll(buf,strlen(buf),&v) == 1);
    assert(v == LLONG_MIN);

    strcpy(buf,"-9223372036854775809"); /* overflow */
    assert(string2ll(buf,strlen(buf),&v) == 0);

    strcpy(buf,"9223372036854775807");
    assert(string2ll(buf,strlen(buf),&v) == 1);
    assert(v == LLONG_MAX);

    strcpy(buf,"9223372036854775808"); /* overflow */
    assert(string2ll(buf,strlen(buf),&v) == 0);
}

void test_string2l(void) {
    char buf[32];
    long v;

    /* May not start with +. */
    strcpy(buf,"+1");
    assert(string2l(buf,strlen(buf),&v) == 0);

    /* May not start with 0. */
    strcpy(buf,"01");
    assert(string2l(buf,strlen(buf),&v) == 0);

    strcpy(buf,"-1");
    assert(string2l(buf,strlen(buf),&v) == 1);
    assert(v == -1);

    strcpy(buf,"0");
    assert(string2l(buf,strlen(buf),&v) == 1);
    assert(v == 0);

    strcpy(buf,"1");
    assert(string2l(buf,strlen(buf),&v) == 1);
    assert(v == 1);

    strcpy(buf,"99");
    assert(string2l(buf,strlen(buf),&v) == 1);
    assert(v == 99);

    strcpy(buf,"-99");
    assert(string2l(buf,strlen(buf),&v) == 1);
    assert(v == -99);

#if LONG_MAX != LLONG_MAX
    strcpy(buf,"-2147483648");
    assert(string2l(buf,strlen(buf),&v) == 1);
    assert(v == LONG_MIN);

    strcpy(buf,"-2147483649"); /* overflow */
    assert(string2l(buf,strlen(buf),&v) == 0);

    strcpy(buf,"2147483647");
    assert(string2l(buf,strlen(buf),&v) == 1);
    assert(v == LONG_MAX);

    strcpy(buf,"2147483648"); /* overflow */
    assert(string2l(buf,strlen(buf),&v) == 0);
#endif
}

int main(int argc, char **argv) {
    test_string2ll();
    test_string2l();
    return 0;
}
#endif
Commit	Line	Data
	1	#include "fmacros.h"
	2	#include <stdlib.h>
	3	#include <stdio.h>
	4	#include <string.h>
	5	#include <ctype.h>
	6	#include <limits.h>
	7	#include <math.h>
	8	#include <unistd.h>
	9	#include <sys/time.h>
	10
	11	#include "util.h"
	12
	13	/* Glob-style pattern matching. */
	14	int stringmatchlen(const char *pattern, int patternLen,
	15	const char *string, int stringLen, int nocase)
	16	{
	17	while(patternLen) {
	18	switch(pattern[0]) {
	19	case '*':
	20	while (pattern[1] == '*') {
	21	pattern++;
	22	patternLen--;
	23	}
	24	if (patternLen == 1)
	25	return 1; /* match */
	26	while(stringLen) {
	27	if (stringmatchlen(pattern+1, patternLen-1,
	28	string, stringLen, nocase))
	29	return 1; /* match */
	30	string++;
	31	stringLen--;
	32	}
	33	return 0; /* no match */
	34	break;
	35	case '?':
	36	if (stringLen == 0)
	37	return 0; /* no match */
	38	string++;
	39	stringLen--;
	40	break;
	41	case '[':
	42	{
	43	int not, match;
	44
	45	pattern++;
	46	patternLen--;
	47	not = pattern[0] == '^';
	48	if (not) {
	49	pattern++;
	50	patternLen--;
	51	}
	52	match = 0;
	53	while(1) {
	54	if (pattern[0] == '\\') {
	55	pattern++;
	56	patternLen--;
	57	if (pattern[0] == string[0])
	58	match = 1;
	59	} else if (pattern[0] == ']') {
	60	break;
	61	} else if (patternLen == 0) {
	62	pattern--;
	63	patternLen++;
	64	break;
	65	} else if (pattern[1] == '-' && patternLen >= 3) {
	66	int start = pattern[0];
	67	int end = pattern[2];
	68	int c = string[0];
	69	if (start > end) {
	70	int t = start;
	71	start = end;
	72	end = t;
	73	}
	74	if (nocase) {
	75	start = tolower(start);
	76	end = tolower(end);
	77	c = tolower(c);
	78	}
	79	pattern += 2;
	80	patternLen -= 2;
	81	if (c >= start && c <= end)
	82	match = 1;
	83	} else {
	84	if (!nocase) {
	85	if (pattern[0] == string[0])
	86	match = 1;
	87	} else {
	88	if (tolower((int)pattern[0]) == tolower((int)string[0]))
	89	match = 1;
	90	}
	91	}
	92	pattern++;
	93	patternLen--;
	94	}
	95	if (not)
	96	match = !match;
	97	if (!match)
	98	return 0; /* no match */
	99	string++;
	100	stringLen--;
	101	break;
	102	}
	103	case '\\':
	104	if (patternLen >= 2) {
	105	pattern++;
	106	patternLen--;
	107	}
	108	/* fall through */
	109	default:
	110	if (!nocase) {
	111	if (pattern[0] != string[0])
	112	return 0; /* no match */
	113	} else {
	114	if (tolower((int)pattern[0]) != tolower((int)string[0]))
	115	return 0; /* no match */
	116	}
	117	string++;
	118	stringLen--;
	119	break;
	120	}
	121	pattern++;
	122	patternLen--;
	123	if (stringLen == 0) {
	124	while(pattern == '') {
	125	pattern++;
	126	patternLen--;
	127	}
	128	break;
	129	}
	130	}
	131	if (patternLen == 0 && stringLen == 0)
	132	return 1;
	133	return 0;
	134	}
	135
	136	int stringmatch(const char pattern, const char string, int nocase) {
	137	return stringmatchlen(pattern,strlen(pattern),string,strlen(string),nocase);
	138	}
	139
	140	/* Convert a string representing an amount of memory into the number of
	141	* bytes, so for instance memtoll("1Gi") will return 1073741824 that is
	142	* (102410241024).
	143	*
	144	* On parsing error, if *err is not NULL, it's set to 1, otherwise it's
	145	* set to 0 */
	146	long long memtoll(const char p, int err) {
	147	const char *u;
	148	char buf[128];
	149	long mul; /* unit multiplier */
	150	long long val;
	151	unsigned int digits;
	152
	153	if (err) *err = 0;
	154	/* Search the first non digit character. */
	155	u = p;
	156	if (*u == '-') u++;
	157	while(u && isdigit(u)) u++;
	158	if (*u == '\0' \|\| !strcasecmp(u,"b")) {
	159	mul = 1;
	160	} else if (!strcasecmp(u,"k")) {
	161	mul = 1000;
	162	} else if (!strcasecmp(u,"kb")) {
	163	mul = 1024;
	164	} else if (!strcasecmp(u,"m")) {
	165	mul = 1000*1000;
	166	} else if (!strcasecmp(u,"mb")) {
	167	mul = 1024*1024;
	168	} else if (!strcasecmp(u,"g")) {
	169	mul = 1000L10001000;
	170	} else if (!strcasecmp(u,"gb")) {
	171	mul = 1024L10241024;
	172	} else {
	173	if (err) *err = 1;
	174	mul = 1;
	175	}
	176	digits = u-p;
	177	if (digits >= sizeof(buf)) {
	178	if (err) *err = 1;
	179	return LLONG_MAX;
	180	}
	181	memcpy(buf,p,digits);
	182	buf[digits] = '\0';
	183	val = strtoll(buf,NULL,10);
	184	return val*mul;
	185	}
	186
	187	/* Convert a long long into a string. Returns the number of
	188	* characters needed to represent the number, that can be shorter if passed
	189	* buffer length is not enough to store the whole number. */
	190	int ll2string(char *s, size_t len, long long value) {
	191	char buf[32], *p;
	192	unsigned long long v;
	193	size_t l;
	194
	195	if (len == 0) return 0;
	196	v = (value < 0) ? -value : value;
	197	p = buf+31; /* point to the last character */
	198	do {
	199	*p-- = '0'+(v%10);
	200	v /= 10;
	201	} while(v);
	202	if (value < 0) *p-- = '-';
	203	p++;
	204	l = 32-(p-buf);
	205	if (l+1 > len) l = len-1; /* Make sure it fits, including the nul term */
	206	memcpy(s,p,l);
	207	s[l] = '\0';
	208	return l;
	209	}
	210
	211	/* Convert a string into a long long. Returns 1 if the string could be parsed
	212	* into a (non-overflowing) long long, 0 otherwise. The value will be set to
	213	* the parsed value when appropriate. */
	214	int string2ll(const char s, size_t slen, long long value) {
	215	const char *p = s;
	216	size_t plen = 0;
	217	int negative = 0;
	218	unsigned long long v;
	219
	220	if (plen == slen)
	221	return 0;
	222
	223	/* Special case: first and only digit is 0. */
	224	if (slen == 1 && p[0] == '0') {
	225	if (value != NULL) *value = 0;
	226	return 1;
	227	}
	228
	229	if (p[0] == '-') {
	230	negative = 1;
	231	p++; plen++;
	232
	233	/* Abort on only a negative sign. */
	234	if (plen == slen)
	235	return 0;
	236	}
	237
	238	/* First digit should be 1-9, otherwise the string should just be 0. */
	239	if (p[0] >= '1' && p[0] <= '9') {
	240	v = p[0]-'0';
	241	p++; plen++;
	242	} else if (p[0] == '0' && slen == 1) {
	243	*value = 0;
	244	return 1;
	245	} else {
	246	return 0;
	247	}
	248
	249	while (plen < slen && p[0] >= '0' && p[0] <= '9') {
	250	if (v > (ULLONG_MAX / 10)) /* Overflow. */
	251	return 0;
	252	v *= 10;
	253
	254	if (v > (ULLONG_MAX - (p[0]-'0'))) /* Overflow. */
	255	return 0;
	256	v += p[0]-'0';
	257
	258	p++; plen++;
	259	}
	260
	261	/* Return if not all bytes were used. */
	262	if (plen < slen)
	263	return 0;
	264
	265	if (negative) {
	266	if (v > ((unsigned long long)(-(LLONG_MIN+1))+1)) /* Overflow. */
	267	return 0;
	268	if (value != NULL) *value = -v;
	269	} else {
	270	if (v > LLONG_MAX) /* Overflow. */
	271	return 0;
	272	if (value != NULL) *value = v;
	273	}
	274	return 1;
	275	}
	276
	277	/* Convert a string into a long. Returns 1 if the string could be parsed into a
	278	* (non-overflowing) long, 0 otherwise. The value will be set to the parsed
	279	* value when appropriate. */
	280	int string2l(const char s, size_t slen, long lval) {
	281	long long llval;
	282
	283	if (!string2ll(s,slen,&llval))
	284	return 0;
	285
	286	if (llval < LONG_MIN \|\| llval > LONG_MAX)
	287	return 0;
	288
	289	*lval = (long)llval;
	290	return 1;
	291	}
	292
	293	/* Convert a double to a string representation. Returns the number of bytes
	294	* required. The representation should always be parsable by stdtod(3). */
	295	int d2string(char *buf, size_t len, double value) {
	296	if (isnan(value)) {
	297	len = snprintf(buf,len,"nan");
	298	} else if (isinf(value)) {
	299	if (value < 0)
	300	len = snprintf(buf,len,"-inf");
	301	else
	302	len = snprintf(buf,len,"inf");
	303	} else if (value == 0) {
	304	/* See: http://en.wikipedia.org/wiki/Signed_zero, "Comparisons". */
	305	if (1.0/value < 0)
	306	len = snprintf(buf,len,"-0");
	307	else
	308	len = snprintf(buf,len,"0");
	309	} else {
	310	#if (DBL_MANT_DIG >= 52) && (LLONG_MAX == 0x7fffffffffffffffLL)
	311	/* Check if the float is in a safe range to be casted into a
	312	* long long. We are assuming that long long is 64 bit here.
	313	* Also we are assuming that there are no implementations around where
	314	* double has precision < 52 bit.
	315	*
	316	* Under this assumptions we test if a double is inside an interval
	317	* where casting to long long is safe. Then using two castings we
	318	* make sure the decimal part is zero. If all this is true we use
	319	* integer printing function that is much faster. */
	320	double min = -4503599627370495; /* (2^52)-1 */
	321	double max = 4503599627370496; /* -(2^52) */
	322	if (val > min && val < max && value == ((double)((long long)value)))
	323	len = ll2string(buf,len,(long long)value);
	324	else
	325	#endif
	326	len = snprintf(buf,len,"%.17g",value);
	327	}
	328
	329	return len;
	330	}
	331
	332	/* Generate the Redis "Run ID", a SHA1-sized random number that identifies a
	333	* given execution of Redis, so that if you are talking with an instance
	334	* having run_id == A, and you reconnect and it has run_id == B, you can be
	335	* sure that it is either a different instance or it was restarted. */
	336	void getRandomHexChars(char *p, unsigned int len) {
	337	FILE *fp = fopen("/dev/urandom","r");
	338	char *charset = "0123456789abcdef";
	339	unsigned int j;
	340
	341	if (fp == NULL \|\| fread(p,len,1,fp) == 0) {
	342	/* If we can't read from /dev/urandom, do some reasonable effort
	343	* in order to create some entropy, since this function is used to
	344	* generate run_id and cluster instance IDs */
	345	char *x = p;
	346	unsigned int l = len;
	347	struct timeval tv;
	348	pid_t pid = getpid();
	349
	350	/* Use time and PID to fill the initial array. */
	351	gettimeofday(&tv,NULL);
	352	if (l >= sizeof(tv.tv_usec)) {
	353	memcpy(x,&tv.tv_usec,sizeof(tv.tv_usec));
	354	l -= sizeof(tv.tv_usec);
	355	x += sizeof(tv.tv_usec);
	356	}
	357	if (l >= sizeof(tv.tv_sec)) {
	358	memcpy(x,&tv.tv_sec,sizeof(tv.tv_sec));
	359	l -= sizeof(tv.tv_sec);
	360	x += sizeof(tv.tv_sec);
	361	}
	362	if (l >= sizeof(pid)) {
	363	memcpy(x,&pid,sizeof(pid));
	364	l -= sizeof(pid);
	365	x += sizeof(pid);
	366	}
	367	/* Finally xor it with rand() output, that was already seeded with
	368	* time() at startup. */
	369	for (j = 0; j < len; j++)
	370	p[j] ^= rand();
	371	}
	372	/* Turn it into hex digits taking just 4 bits out of 8 for every byte. */
	373	for (j = 0; j < len; j++)
	374	p[j] = charset[p[j] & 0x0F];
	375	fclose(fp);
	376	}
	377
	378	#ifdef UTIL_TEST_MAIN
	379	#include <assert.h>
	380
	381	void test_string2ll(void) {
	382	char buf[32];
	383	long long v;
	384
	385	/* May not start with +. */
	386	strcpy(buf,"+1");
	387	assert(string2ll(buf,strlen(buf),&v) == 0);
	388
	389	/* Leading space. */
	390	strcpy(buf," 1");
	391	assert(string2ll(buf,strlen(buf),&v) == 0);
	392
	393	/* Trailing space. */
	394	strcpy(buf,"1 ");
	395	assert(string2ll(buf,strlen(buf),&v) == 0);
	396
	397	/* May not start with 0. */
	398	strcpy(buf,"01");
	399	assert(string2ll(buf,strlen(buf),&v) == 0);
	400
	401	strcpy(buf,"-1");
	402	assert(string2ll(buf,strlen(buf),&v) == 1);
	403	assert(v == -1);
	404
	405	strcpy(buf,"0");
	406	assert(string2ll(buf,strlen(buf),&v) == 1);
	407	assert(v == 0);
	408
	409	strcpy(buf,"1");
	410	assert(string2ll(buf,strlen(buf),&v) == 1);
	411	assert(v == 1);
	412
	413	strcpy(buf,"99");
	414	assert(string2ll(buf,strlen(buf),&v) == 1);
	415	assert(v == 99);
	416
	417	strcpy(buf,"-99");
	418	assert(string2ll(buf,strlen(buf),&v) == 1);
	419	assert(v == -99);
	420
	421	strcpy(buf,"-9223372036854775808");
	422	assert(string2ll(buf,strlen(buf),&v) == 1);
	423	assert(v == LLONG_MIN);
	424
	425	strcpy(buf,"-9223372036854775809"); /* overflow */
	426	assert(string2ll(buf,strlen(buf),&v) == 0);
	427
	428	strcpy(buf,"9223372036854775807");
	429	assert(string2ll(buf,strlen(buf),&v) == 1);
	430	assert(v == LLONG_MAX);
	431
	432	strcpy(buf,"9223372036854775808"); /* overflow */
	433	assert(string2ll(buf,strlen(buf),&v) == 0);
	434	}
	435
	436	void test_string2l(void) {
	437	char buf[32];
	438	long v;
	439
	440	/* May not start with +. */
	441	strcpy(buf,"+1");
	442	assert(string2l(buf,strlen(buf),&v) == 0);
	443
	444	/* May not start with 0. */
	445	strcpy(buf,"01");
	446	assert(string2l(buf,strlen(buf),&v) == 0);
	447
	448	strcpy(buf,"-1");
	449	assert(string2l(buf,strlen(buf),&v) == 1);
	450	assert(v == -1);
	451
	452	strcpy(buf,"0");
	453	assert(string2l(buf,strlen(buf),&v) == 1);
	454	assert(v == 0);
	455
	456	strcpy(buf,"1");
	457	assert(string2l(buf,strlen(buf),&v) == 1);
	458	assert(v == 1);
	459
	460	strcpy(buf,"99");
	461	assert(string2l(buf,strlen(buf),&v) == 1);
	462	assert(v == 99);
	463
	464	strcpy(buf,"-99");
	465	assert(string2l(buf,strlen(buf),&v) == 1);
	466	assert(v == -99);
	467
	468	#if LONG_MAX != LLONG_MAX
	469	strcpy(buf,"-2147483648");
	470	assert(string2l(buf,strlen(buf),&v) == 1);
	471	assert(v == LONG_MIN);
	472
	473	strcpy(buf,"-2147483649"); /* overflow */
	474	assert(string2l(buf,strlen(buf),&v) == 0);
	475
	476	strcpy(buf,"2147483647");
	477	assert(string2l(buf,strlen(buf),&v) == 1);
	478	assert(v == LONG_MAX);
	479
	480	strcpy(buf,"2147483648"); /* overflow */
	481	assert(string2l(buf,strlen(buf),&v) == 0);
	482	#endif
	483	}
	484
	485	int main(int argc, char **argv) {
	486	test_string2ll();
	487	test_string2l();
	488	return 0;
	489	}
	490	#endif