blob: 162a9ebc09b2494bba5516cc89b6fab9d4b5e0cb [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
Willy Tarreau2dd0d472006-06-29 17:53:05 +02002 include/common/standard.h
Willy Tarreaubaaee002006-06-26 02:48:02 +02003 This files contains some general purpose functions and macros.
4
Willy Tarreau70bcfb72008-01-27 02:21:53 +01005 Copyright (C) 2000-2008 Willy Tarreau - w@1wt.eu
Willy Tarreaubaaee002006-06-26 02:48:02 +02006
7 This library is free software; you can redistribute it and/or
8 modify it under the terms of the GNU Lesser General Public
9 License as published by the Free Software Foundation, version 2.1
10 exclusively.
11
12 This library is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
16
17 You should have received a copy of the GNU Lesser General Public
18 License along with this library; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20*/
21
Willy Tarreau2dd0d472006-06-29 17:53:05 +020022#ifndef _COMMON_STANDARD_H
23#define _COMMON_STANDARD_H
Willy Tarreaubaaee002006-06-26 02:48:02 +020024
Willy Tarreau167d8b52007-04-09 22:16:12 +020025#include <limits.h>
Willy Tarreaufe944602007-10-25 10:34:16 +020026#include <time.h>
Willy Tarreau938b3032007-05-10 06:39:03 +020027#include <sys/types.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020028#include <netinet/in.h>
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020029#include <common/config.h>
Willy Tarreauca28d1e2007-01-24 18:20:50 +010030#include <proto/fd.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020031
32/****** string-specific macros and functions ******/
33/* if a > max, then bound <a> to <max>. The macro returns the new <a> */
34#define UBOUND(a, max) ({ typeof(a) b = (max); if ((a) > b) (a) = b; (a); })
35
36/* if a < min, then bound <a> to <min>. The macro returns the new <a> */
37#define LBOUND(a, min) ({ typeof(a) b = (min); if ((a) < b) (a) = b; (a); })
38
39/* returns 1 only if only zero or one bit is set in X, which means that X is a
40 * power of 2, and 0 otherwise */
41#define POWEROF2(x) (((x) & ((x)-1)) == 0)
42
Willy Tarreau7d58a632007-01-13 23:06:06 +010043/*
44 * Gcc >= 3 provides the ability for the programme to give hints to the
45 * compiler about what branch of an if is most likely to be taken. This
46 * helps the compiler produce the most compact critical paths, which is
47 * generally better for the cache and to reduce the number of jumps.
48 */
Willy Tarreau70bcfb72008-01-27 02:21:53 +010049#if !defined(likely)
Willy Tarreau7d58a632007-01-13 23:06:06 +010050#if __GNUC__ < 3
51#define __builtin_expect(x,y) (x)
Willy Tarreau70bcfb72008-01-27 02:21:53 +010052#define likely(x) (x)
53#define unlikely(x) (x)
54#elif __GNUC__ < 4
55/* gcc 3.x does the best job at this */
Willy Tarreau7d58a632007-01-13 23:06:06 +010056#define likely(x) (__builtin_expect((x) != 0, 1))
57#define unlikely(x) (__builtin_expect((x) != 0, 0))
Willy Tarreau70bcfb72008-01-27 02:21:53 +010058#else
59/* GCC 4.x is stupid, it performs the comparison then compares it to 1,
60 * so we cheat in a dirty way to prevent it from doing this. This will
61 * only work with ints and booleans though.
62 */
63#define likely(x) (x)
64#define unlikely(x) (__builtin_expect((x), 0))
65#endif
66#endif
Willy Tarreaubaaee002006-06-26 02:48:02 +020067
68/*
69 * copies at most <size-1> chars from <src> to <dst>. Last char is always
70 * set to 0, unless <size> is 0. The number of chars copied is returned
71 * (excluding the terminating zero).
72 * This code has been optimized for size and speed : on x86, it's 45 bytes
73 * long, uses only registers, and consumes only 4 cycles per char.
74 */
75extern int strlcpy2(char *dst, const char *src, int size);
76
77/*
Willy Tarreau72d759c2007-10-25 12:14:10 +020078 * This function simply returns a locally allocated string containing
Willy Tarreaubaaee002006-06-26 02:48:02 +020079 * the ascii representation for number 'n' in decimal.
80 */
Willy Tarreau72d759c2007-10-25 12:14:10 +020081extern char itoa_str[][21];
82extern const char *ultoa_r(unsigned long n, char *buffer, int size);
83static inline const char *ultoa(unsigned long n)
84{
85 return ultoa_r(n, itoa_str[0], sizeof(itoa_str[0]));
86}
87
88/* Fast macros to convert up to 10 different parameters inside a same call of
89 * expression.
90 */
91#define U2A0(n) ({ ultoa_r((n), itoa_str[0], sizeof(itoa_str[0])); })
92#define U2A1(n) ({ ultoa_r((n), itoa_str[1], sizeof(itoa_str[1])); })
93#define U2A2(n) ({ ultoa_r((n), itoa_str[2], sizeof(itoa_str[2])); })
94#define U2A3(n) ({ ultoa_r((n), itoa_str[3], sizeof(itoa_str[3])); })
95#define U2A4(n) ({ ultoa_r((n), itoa_str[4], sizeof(itoa_str[4])); })
96#define U2A5(n) ({ ultoa_r((n), itoa_str[5], sizeof(itoa_str[5])); })
97#define U2A6(n) ({ ultoa_r((n), itoa_str[6], sizeof(itoa_str[6])); })
98#define U2A7(n) ({ ultoa_r((n), itoa_str[7], sizeof(itoa_str[7])); })
99#define U2A8(n) ({ ultoa_r((n), itoa_str[8], sizeof(itoa_str[8])); })
100#define U2A9(n) ({ ultoa_r((n), itoa_str[9], sizeof(itoa_str[9])); })
Willy Tarreaubaaee002006-06-26 02:48:02 +0200101
102/*
Willy Tarreau91092e52007-10-25 16:58:42 +0200103 * This function simply returns a locally allocated string containing the ascii
104 * representation for number 'n' in decimal, unless n is 0 in which case it
105 * returns the alternate string (or an empty string if the alternate string is
106 * NULL). It use is intended for limits reported in reports, where it's
107 * desirable not to display anything if there is no limit. Warning! it shares
108 * the same vector as ultoa_r().
109 */
110extern const char *limit_r(unsigned long n, char *buffer, int size, const char *alt);
111
112/* Fast macros to convert up to 10 different parameters inside a same call of
113 * expression. Warning! they share the same vectors as U2A*!
114 */
115#define LIM2A0(n, alt) ({ limit_r((n), itoa_str[0], sizeof(itoa_str[0]), (alt)); })
116#define LIM2A1(n, alt) ({ limit_r((n), itoa_str[1], sizeof(itoa_str[1]), (alt)); })
117#define LIM2A2(n, alt) ({ limit_r((n), itoa_str[2], sizeof(itoa_str[2]), (alt)); })
118#define LIM2A3(n, alt) ({ limit_r((n), itoa_str[3], sizeof(itoa_str[3]), (alt)); })
119#define LIM2A4(n, alt) ({ limit_r((n), itoa_str[4], sizeof(itoa_str[4]), (alt)); })
120#define LIM2A5(n, alt) ({ limit_r((n), itoa_str[5], sizeof(itoa_str[5]), (alt)); })
121#define LIM2A6(n, alt) ({ limit_r((n), itoa_str[6], sizeof(itoa_str[6]), (alt)); })
122#define LIM2A7(n, alt) ({ limit_r((n), itoa_str[7], sizeof(itoa_str[7]), (alt)); })
123#define LIM2A8(n, alt) ({ limit_r((n), itoa_str[8], sizeof(itoa_str[8]), (alt)); })
124#define LIM2A9(n, alt) ({ limit_r((n), itoa_str[9], sizeof(itoa_str[9]), (alt)); })
125
126/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200127 * Returns non-zero if character <s> is a hex digit (0-9, a-f, A-F), else zero.
128 */
129extern int ishex(char s);
130
131/*
Willy Tarreau2e74c3f2007-12-02 18:45:09 +0100132 * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_:.-]. If an
133 * invalid character is found, a pointer to it is returned. If everything is
134 * fine, NULL is returned.
135 */
136extern const char *invalid_char(const char *name);
137
138/*
Robert Tsai81ae1952007-12-05 10:47:29 +0100139 * converts <str> to a struct sockaddr_un* which is locally allocated.
140 * The format is "/path", where "/path" is a path to a UNIX domain socket.
141 */
142struct sockaddr_un *str2sun(char *str);
143
144/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200145 * converts <str> to a struct sockaddr_in* which is locally allocated.
146 * The format is "addr:port", where "addr" can be a dotted IPv4 address,
147 * a host name, or empty or "*" to indicate INADDR_ANY.
148 */
149struct sockaddr_in *str2sa(char *str);
150
151/*
Willy Tarreaud077a8e2007-05-08 18:28:09 +0200152 * converts <str> to two struct in_addr* which must be pre-allocated.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200153 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
154 * is optionnal and either in the dotted or CIDR notation.
155 * Note: "addr" can also be a hostname. Returns 1 if OK, 0 if error.
156 */
Willy Tarreaud077a8e2007-05-08 18:28:09 +0200157int str2net(const char *str, struct in_addr *addr, struct in_addr *mask);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200158
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100159/*
160 * Resolve destination server from URL. Convert <str> to a sockaddr_in*.
161 */
162int url2sa(const char *url, int ulen, struct sockaddr_in *addr);
163
Willy Tarreaubaaee002006-06-26 02:48:02 +0200164/* will try to encode the string <string> replacing all characters tagged in
165 * <map> with the hexadecimal representation of their ASCII-code (2 digits)
166 * prefixed by <escape>, and will store the result between <start> (included)
167 * and <stop> (excluded), and will always terminate the string with a '\0'
168 * before <stop>. The position of the '\0' is returned if the conversion
169 * completes. If bytes are missing between <start> and <stop>, then the
170 * conversion will be incomplete and truncated. If <stop> <= <start>, the '\0'
171 * cannot even be stored so we return <start> without writing the 0.
172 * The input string must also be zero-terminated.
173 */
174extern const char hextab[];
175char *encode_string(char *start, char *stop,
176 const char escape, const fd_set *map,
177 const char *string);
178
Willy Tarreau6911fa42007-03-04 18:06:08 +0100179/* This one is 6 times faster than strtoul() on athlon, but does
180 * no check at all.
181 */
182static inline unsigned int __str2ui(const char *s)
183{
184 unsigned int i = 0;
185 while (*s) {
186 i = i * 10 - '0';
187 i += (unsigned char)*s++;
188 }
189 return i;
190}
191
192/* This one is 5 times faster than strtoul() on athlon with checks.
193 * It returns the value of the number composed of all valid digits read.
194 */
195static inline unsigned int __str2uic(const char *s)
196{
197 unsigned int i = 0;
198 unsigned int j;
199 while (1) {
200 j = (*s++) - '0';
201 if (j > 9)
202 break;
203 i *= 10;
204 i += j;
205 }
206 return i;
207}
208
209/* This one is 28 times faster than strtoul() on athlon, but does
210 * no check at all!
211 */
212static inline unsigned int __strl2ui(const char *s, int len)
213{
214 unsigned int i = 0;
215 while (len-- > 0) {
216 i = i * 10 - '0';
217 i += (unsigned char)*s++;
218 }
219 return i;
220}
221
222/* This one is 7 times faster than strtoul() on athlon with checks.
223 * It returns the value of the number composed of all valid digits read.
224 */
225static inline unsigned int __strl2uic(const char *s, int len)
226{
227 unsigned int i = 0;
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200228 unsigned int j, k;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100229
230 while (len-- > 0) {
231 j = (*s++) - '0';
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200232 k = i * 10;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100233 if (j > 9)
234 break;
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200235 i = k + j;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100236 }
237 return i;
238}
239
240extern unsigned int str2ui(const char *s);
241extern unsigned int str2uic(const char *s);
242extern unsigned int strl2ui(const char *s, int len);
243extern unsigned int strl2uic(const char *s, int len);
244extern int strl2ic(const char *s, int len);
245extern int strl2irc(const char *s, int len, int *ret);
246extern int strl2llrc(const char *s, int len, long long *ret);
247
Willy Tarreaufe944602007-10-25 10:34:16 +0200248/* This function converts the time_t value <now> into a broken out struct tm
249 * which must be allocated by the caller. It is highly recommended to use this
250 * function intead of localtime() because that one requires a time_t* which
251 * is not always compatible with tv_sec depending on OS/hardware combinations.
252 */
253static inline void get_localtime(const time_t now, struct tm *tm)
254{
255 localtime_r(&now, tm);
256}
257
Willy Tarreaua0d37b62007-12-02 22:00:35 +0100258/* This function parses a time value optionally followed by a unit suffix among
259 * "d", "h", "m", "s", "ms" or "us". It converts the value into the unit
260 * expected by the caller. The computation does its best to avoid overflows.
261 * The value is returned in <ret> if everything is fine, and a NULL is returned
262 * by the function. In case of error, a pointer to the error is returned and
263 * <ret> is left untouched.
264 */
265extern const char *parse_time_err(const char *text, unsigned *ret, unsigned unit_flags);
266
267/* unit flags to pass to parse_time_err */
268#define TIME_UNIT_US 0x0000
269#define TIME_UNIT_MS 0x0001
270#define TIME_UNIT_S 0x0002
271#define TIME_UNIT_MIN 0x0003
272#define TIME_UNIT_HOUR 0x0004
273#define TIME_UNIT_DAY 0x0005
274#define TIME_UNIT_MASK 0x0007
275
Willy Tarreau2dd0d472006-06-29 17:53:05 +0200276#endif /* _COMMON_STANDARD_H */