blob: 84f768cbbe7f613ac5d807da7dfaa6d92cef9580 [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)
Willy Tarreau75875a72008-07-06 15:18:50 +020064#define unlikely(x) (__builtin_expect((unsigned long)(x), 0))
Willy Tarreau70bcfb72008-01-27 02:21:53 +010065#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/*
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200139 * Checks <domainname> for invalid characters. Valid chars are [A-Za-z0-9_.-].
140 * If an invalid character is found, a pointer to it is returned.
141 * If everything is fine, NULL is returned.
142 */
143extern const char *invalid_domainchar(const char *name);
144
145/*
Robert Tsai81ae1952007-12-05 10:47:29 +0100146 * converts <str> to a struct sockaddr_un* which is locally allocated.
147 * The format is "/path", where "/path" is a path to a UNIX domain socket.
148 */
Willy Tarreaucaf720d2008-03-07 10:07:04 +0100149struct sockaddr_un *str2sun(const char *str);
Robert Tsai81ae1952007-12-05 10:47:29 +0100150
151/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200152 * converts <str> to a struct sockaddr_in* which is locally allocated.
153 * The format is "addr:port", where "addr" can be a dotted IPv4 address,
154 * a host name, or empty or "*" to indicate INADDR_ANY.
155 */
156struct sockaddr_in *str2sa(char *str);
157
158/*
Willy Tarreaud077a8e2007-05-08 18:28:09 +0200159 * converts <str> to two struct in_addr* which must be pre-allocated.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200160 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
161 * is optionnal and either in the dotted or CIDR notation.
162 * Note: "addr" can also be a hostname. Returns 1 if OK, 0 if error.
163 */
Willy Tarreaud077a8e2007-05-08 18:28:09 +0200164int str2net(const char *str, struct in_addr *addr, struct in_addr *mask);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200165
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100166/*
167 * Resolve destination server from URL. Convert <str> to a sockaddr_in*.
168 */
169int url2sa(const char *url, int ulen, struct sockaddr_in *addr);
170
Willy Tarreaubaaee002006-06-26 02:48:02 +0200171/* will try to encode the string <string> replacing all characters tagged in
172 * <map> with the hexadecimal representation of their ASCII-code (2 digits)
173 * prefixed by <escape>, and will store the result between <start> (included)
174 * and <stop> (excluded), and will always terminate the string with a '\0'
175 * before <stop>. The position of the '\0' is returned if the conversion
176 * completes. If bytes are missing between <start> and <stop>, then the
177 * conversion will be incomplete and truncated. If <stop> <= <start>, the '\0'
178 * cannot even be stored so we return <start> without writing the 0.
179 * The input string must also be zero-terminated.
180 */
181extern const char hextab[];
182char *encode_string(char *start, char *stop,
183 const char escape, const fd_set *map,
184 const char *string);
185
Willy Tarreau6911fa42007-03-04 18:06:08 +0100186/* This one is 6 times faster than strtoul() on athlon, but does
187 * no check at all.
188 */
189static inline unsigned int __str2ui(const char *s)
190{
191 unsigned int i = 0;
192 while (*s) {
193 i = i * 10 - '0';
194 i += (unsigned char)*s++;
195 }
196 return i;
197}
198
199/* This one is 5 times faster than strtoul() on athlon with checks.
200 * It returns the value of the number composed of all valid digits read.
201 */
202static inline unsigned int __str2uic(const char *s)
203{
204 unsigned int i = 0;
205 unsigned int j;
206 while (1) {
207 j = (*s++) - '0';
208 if (j > 9)
209 break;
210 i *= 10;
211 i += j;
212 }
213 return i;
214}
215
216/* This one is 28 times faster than strtoul() on athlon, but does
217 * no check at all!
218 */
219static inline unsigned int __strl2ui(const char *s, int len)
220{
221 unsigned int i = 0;
222 while (len-- > 0) {
223 i = i * 10 - '0';
224 i += (unsigned char)*s++;
225 }
226 return i;
227}
228
229/* This one is 7 times faster than strtoul() on athlon with checks.
230 * It returns the value of the number composed of all valid digits read.
231 */
232static inline unsigned int __strl2uic(const char *s, int len)
233{
234 unsigned int i = 0;
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200235 unsigned int j, k;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100236
237 while (len-- > 0) {
238 j = (*s++) - '0';
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200239 k = i * 10;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100240 if (j > 9)
241 break;
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200242 i = k + j;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100243 }
244 return i;
245}
246
247extern unsigned int str2ui(const char *s);
248extern unsigned int str2uic(const char *s);
249extern unsigned int strl2ui(const char *s, int len);
250extern unsigned int strl2uic(const char *s, int len);
251extern int strl2ic(const char *s, int len);
252extern int strl2irc(const char *s, int len, int *ret);
253extern int strl2llrc(const char *s, int len, long long *ret);
254
Willy Tarreaufe944602007-10-25 10:34:16 +0200255/* This function converts the time_t value <now> into a broken out struct tm
256 * which must be allocated by the caller. It is highly recommended to use this
257 * function intead of localtime() because that one requires a time_t* which
258 * is not always compatible with tv_sec depending on OS/hardware combinations.
259 */
260static inline void get_localtime(const time_t now, struct tm *tm)
261{
262 localtime_r(&now, tm);
263}
264
Willy Tarreaua0d37b62007-12-02 22:00:35 +0100265/* This function parses a time value optionally followed by a unit suffix among
266 * "d", "h", "m", "s", "ms" or "us". It converts the value into the unit
267 * expected by the caller. The computation does its best to avoid overflows.
268 * The value is returned in <ret> if everything is fine, and a NULL is returned
269 * by the function. In case of error, a pointer to the error is returned and
270 * <ret> is left untouched.
271 */
272extern const char *parse_time_err(const char *text, unsigned *ret, unsigned unit_flags);
273
274/* unit flags to pass to parse_time_err */
275#define TIME_UNIT_US 0x0000
276#define TIME_UNIT_MS 0x0001
277#define TIME_UNIT_S 0x0002
278#define TIME_UNIT_MIN 0x0003
279#define TIME_UNIT_HOUR 0x0004
280#define TIME_UNIT_DAY 0x0005
281#define TIME_UNIT_MASK 0x0007
282
Willy Tarreau7f062c42009-03-05 18:43:00 +0100283/* Multiply the two 32-bit operands and shift the 64-bit result right 32 bits.
284 * This is used to compute fixed ratios by setting one of the operands to
285 * (2^32*ratio).
286 */
287static inline unsigned int mul32hi(unsigned int a, unsigned int b)
288{
289 return ((unsigned long long)a * b) >> 32;
290}
291
Willy Tarreau2dd0d472006-06-29 17:53:05 +0200292#endif /* _COMMON_STANDARD_H */