mirror of
https://git.haproxy.org/git/haproxy.git/
synced 2025-09-24 07:11:20 +02:00
376 lines
8.7 KiB
C
376 lines
8.7 KiB
C
/*
|
|
* General purpose functions.
|
|
*
|
|
* Copyright 2000-2007 Willy Tarreau <w@1wt.eu>
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version
|
|
* 2 of the License, or (at your option) any later version.
|
|
*
|
|
*/
|
|
|
|
#include <netdb.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <netinet/in.h>
|
|
#include <arpa/inet.h>
|
|
|
|
#include <common/config.h>
|
|
#include <common/standard.h>
|
|
#include <proto/log.h>
|
|
|
|
/* enough to store 2^64-1 = 18446744073709551615 */
|
|
static char itoa_str[21];
|
|
|
|
/*
|
|
* copies at most <size-1> chars from <src> to <dst>. Last char is always
|
|
* set to 0, unless <size> is 0. The number of chars copied is returned
|
|
* (excluding the terminating zero).
|
|
* This code has been optimized for size and speed : on x86, it's 45 bytes
|
|
* long, uses only registers, and consumes only 4 cycles per char.
|
|
*/
|
|
int strlcpy2(char *dst, const char *src, int size)
|
|
{
|
|
char *orig = dst;
|
|
if (size) {
|
|
while (--size && (*dst = *src)) {
|
|
src++; dst++;
|
|
}
|
|
*dst = 0;
|
|
}
|
|
return dst - orig;
|
|
}
|
|
|
|
/*
|
|
* This function simply returns a statically allocated string containing
|
|
* the ascii representation for number 'n' in decimal.
|
|
*/
|
|
char *ultoa(unsigned long n)
|
|
{
|
|
char *pos;
|
|
|
|
pos = itoa_str + sizeof(itoa_str) - 1;
|
|
*pos-- = '\0';
|
|
|
|
do {
|
|
*pos-- = '0' + n % 10;
|
|
n /= 10;
|
|
} while (n && pos >= itoa_str);
|
|
return pos + 1;
|
|
}
|
|
|
|
|
|
/*
|
|
* Returns non-zero if character <s> is a hex digit (0-9, a-f, A-F), else zero.
|
|
*
|
|
* It looks like this one would be a good candidate for inlining, but this is
|
|
* not interesting because it around 35 bytes long and often called multiple
|
|
* times within the same function.
|
|
*/
|
|
int ishex(char s)
|
|
{
|
|
s -= '0';
|
|
if ((unsigned char)s <= 9)
|
|
return 1;
|
|
s -= 'A' - '0';
|
|
if ((unsigned char)s <= 5)
|
|
return 1;
|
|
s -= 'a' - 'A';
|
|
if ((unsigned char)s <= 5)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* converts <str> to a struct sockaddr_in* which is locally allocated.
|
|
* The format is "addr:port", where "addr" can be a dotted IPv4 address,
|
|
* a host name, or empty or "*" to indicate INADDR_ANY.
|
|
*/
|
|
struct sockaddr_in *str2sa(char *str)
|
|
{
|
|
static struct sockaddr_in sa;
|
|
char *c;
|
|
int port;
|
|
|
|
memset(&sa, 0, sizeof(sa));
|
|
str = strdup(str);
|
|
if (str == NULL)
|
|
goto out_nofree;
|
|
|
|
if ((c = strrchr(str,':')) != NULL) {
|
|
*c++ = '\0';
|
|
port = atol(c);
|
|
}
|
|
else
|
|
port = 0;
|
|
|
|
if (*str == '*' || *str == '\0') { /* INADDR_ANY */
|
|
sa.sin_addr.s_addr = INADDR_ANY;
|
|
}
|
|
else if (!inet_pton(AF_INET, str, &sa.sin_addr)) {
|
|
struct hostent *he;
|
|
|
|
if ((he = gethostbyname(str)) == NULL) {
|
|
Alert("Invalid server name: '%s'\n", str);
|
|
}
|
|
else
|
|
sa.sin_addr = *(struct in_addr *) *(he->h_addr_list);
|
|
}
|
|
sa.sin_port = htons(port);
|
|
sa.sin_family = AF_INET;
|
|
|
|
free(str);
|
|
out_nofree:
|
|
return &sa;
|
|
}
|
|
|
|
/*
|
|
* converts <str> to two struct in_addr* which must be pre-allocated.
|
|
* The format is "addr[/mask]", where "addr" cannot be empty, and mask
|
|
* is optionnal and either in the dotted or CIDR notation.
|
|
* Note: "addr" can also be a hostname. Returns 1 if OK, 0 if error.
|
|
*/
|
|
int str2net(const char *str, struct in_addr *addr, struct in_addr *mask)
|
|
{
|
|
__label__ out_free, out_err;
|
|
char *c, *s;
|
|
int ret_val;
|
|
unsigned long len;
|
|
|
|
s = strdup(str);
|
|
if (!s)
|
|
return 0;
|
|
|
|
memset(mask, 0, sizeof(*mask));
|
|
memset(addr, 0, sizeof(*addr));
|
|
|
|
if ((c = strrchr(s, '/')) != NULL) {
|
|
*c++ = '\0';
|
|
/* c points to the mask */
|
|
if (strchr(c, '.') != NULL) { /* dotted notation */
|
|
if (!inet_pton(AF_INET, c, mask))
|
|
goto out_err;
|
|
}
|
|
else { /* mask length */
|
|
char *err;
|
|
len = strtol(c, &err, 10);
|
|
if (!*c || (err && *err) || (unsigned)len > 32)
|
|
goto out_err;
|
|
if (len)
|
|
mask->s_addr = htonl(~0UL << (32 - len));
|
|
else
|
|
mask->s_addr = 0;
|
|
}
|
|
}
|
|
else {
|
|
mask->s_addr = ~0U;
|
|
}
|
|
if (!inet_pton(AF_INET, s, addr)) {
|
|
struct hostent *he;
|
|
|
|
if ((he = gethostbyname(s)) == NULL) {
|
|
goto out_err;
|
|
}
|
|
else
|
|
*addr = *(struct in_addr *) *(he->h_addr_list);
|
|
}
|
|
|
|
ret_val = 1;
|
|
out_free:
|
|
free(s);
|
|
return ret_val;
|
|
out_err:
|
|
ret_val = 0;
|
|
goto out_free;
|
|
}
|
|
|
|
/* will try to encode the string <string> replacing all characters tagged in
|
|
* <map> with the hexadecimal representation of their ASCII-code (2 digits)
|
|
* prefixed by <escape>, and will store the result between <start> (included)
|
|
* and <stop> (excluded), and will always terminate the string with a '\0'
|
|
* before <stop>. The position of the '\0' is returned if the conversion
|
|
* completes. If bytes are missing between <start> and <stop>, then the
|
|
* conversion will be incomplete and truncated. If <stop> <= <start>, the '\0'
|
|
* cannot even be stored so we return <start> without writing the 0.
|
|
* The input string must also be zero-terminated.
|
|
*/
|
|
const char hextab[16] = "0123456789ABCDEF";
|
|
char *encode_string(char *start, char *stop,
|
|
const char escape, const fd_set *map,
|
|
const char *string)
|
|
{
|
|
if (start < stop) {
|
|
stop--; /* reserve one byte for the final '\0' */
|
|
while (start < stop && *string != '\0') {
|
|
if (!FD_ISSET((unsigned char)(*string), map))
|
|
*start++ = *string;
|
|
else {
|
|
if (start + 3 >= stop)
|
|
break;
|
|
*start++ = escape;
|
|
*start++ = hextab[(*string >> 4) & 15];
|
|
*start++ = hextab[*string & 15];
|
|
}
|
|
string++;
|
|
}
|
|
*start = '\0';
|
|
}
|
|
return start;
|
|
}
|
|
|
|
|
|
unsigned int str2ui(const char *s)
|
|
{
|
|
return __str2ui(s);
|
|
}
|
|
|
|
unsigned int str2uic(const char *s)
|
|
{
|
|
return __str2uic(s);
|
|
}
|
|
|
|
unsigned int strl2ui(const char *s, int len)
|
|
{
|
|
return __strl2ui(s, len);
|
|
}
|
|
|
|
unsigned int strl2uic(const char *s, int len)
|
|
{
|
|
return __strl2uic(s, len);
|
|
}
|
|
|
|
/* This one is 7 times faster than strtol() on athlon with checks.
|
|
* It returns the value of the number composed of all valid digits read,
|
|
* and can process negative numbers too.
|
|
*/
|
|
int strl2ic(const char *s, int len)
|
|
{
|
|
int i = 0;
|
|
int j;
|
|
|
|
if (len > 0) {
|
|
if (*s != '-') {
|
|
/* positive number */
|
|
while (len-- > 0) {
|
|
j = (*s++) - '0';
|
|
i = i * 10;
|
|
if (j > 9)
|
|
break;
|
|
i += j;
|
|
}
|
|
} else {
|
|
/* negative number */
|
|
s++;
|
|
while (--len > 0) {
|
|
j = (*s++) - '0';
|
|
i = i * 10;
|
|
if (j > 9)
|
|
break;
|
|
i -= j;
|
|
}
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
|
|
|
|
/* This function reads exactly <len> chars from <s> and converts them to a
|
|
* signed integer which it stores into <ret>. It accurately detects any error
|
|
* (truncated string, invalid chars, overflows). It is meant to be used in
|
|
* applications designed for hostile environments. It returns zero when the
|
|
* number has successfully been converted, non-zero otherwise. When an error
|
|
* is returned, the <ret> value is left untouched. It is yet 5 to 40 times
|
|
* faster than strtol().
|
|
*/
|
|
int strl2irc(const char *s, int len, int *ret)
|
|
{
|
|
int i = 0;
|
|
int j;
|
|
|
|
if (!len)
|
|
return 1;
|
|
|
|
if (*s != '-') {
|
|
/* positive number */
|
|
while (len-- > 0) {
|
|
j = (*s++) - '0';
|
|
if (j > 9) return 1; /* invalid char */
|
|
if (i > INT_MAX / 10) return 1; /* check for multiply overflow */
|
|
i = i * 10;
|
|
if (i + j < i) return 1; /* check for addition overflow */
|
|
i = i + j;
|
|
}
|
|
} else {
|
|
/* negative number */
|
|
s++;
|
|
while (--len > 0) {
|
|
j = (*s++) - '0';
|
|
if (j > 9) return 1; /* invalid char */
|
|
if (i < INT_MIN / 10) return 1; /* check for multiply overflow */
|
|
i = i * 10;
|
|
if (i - j > i) return 1; /* check for subtract overflow */
|
|
i = i - j;
|
|
}
|
|
}
|
|
*ret = i;
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* This function reads exactly <len> chars from <s> and converts them to a
|
|
* signed integer which it stores into <ret>. It accurately detects any error
|
|
* (truncated string, invalid chars, overflows). It is meant to be used in
|
|
* applications designed for hostile environments. It returns zero when the
|
|
* number has successfully been converted, non-zero otherwise. When an error
|
|
* is returned, the <ret> value is left untouched. It is about 3 times slower
|
|
* than str2irc().
|
|
*/
|
|
#ifndef LLONG_MAX
|
|
#define LLONG_MAX 9223372036854775807LL
|
|
#define LLONG_MIN (-LLONG_MAX - 1LL)
|
|
#endif
|
|
|
|
int strl2llrc(const char *s, int len, long long *ret)
|
|
{
|
|
long long i = 0;
|
|
int j;
|
|
|
|
if (!len)
|
|
return 1;
|
|
|
|
if (*s != '-') {
|
|
/* positive number */
|
|
while (len-- > 0) {
|
|
j = (*s++) - '0';
|
|
if (j > 9) return 1; /* invalid char */
|
|
if (i > LLONG_MAX / 10LL) return 1; /* check for multiply overflow */
|
|
i = i * 10LL;
|
|
if (i + j < i) return 1; /* check for addition overflow */
|
|
i = i + j;
|
|
}
|
|
} else {
|
|
/* negative number */
|
|
s++;
|
|
while (--len > 0) {
|
|
j = (*s++) - '0';
|
|
if (j > 9) return 1; /* invalid char */
|
|
if (i < LLONG_MIN / 10LL) return 1; /* check for multiply overflow */
|
|
i = i * 10LL;
|
|
if (i - j > i) return 1; /* check for subtract overflow */
|
|
i = i - j;
|
|
}
|
|
}
|
|
*ret = i;
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Local variables:
|
|
* c-indent-level: 8
|
|
* c-basic-offset: 8
|
|
* End:
|
|
*/
|