blob: 0bc28aafc4b39b51169199071407004193fb3a1a [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 Tarreaue7239b52009-03-29 13:41:58 +020081extern char itoa_str[][171];
Willy Tarreau72d759c2007-10-25 12:14:10 +020082extern const char *ultoa_r(unsigned long n, char *buffer, int size);
Willy Tarreaue7239b52009-03-29 13:41:58 +020083extern const char *ulltoh_r(unsigned long long n, char *buffer, int size);
Willy Tarreau72d759c2007-10-25 12:14:10 +020084static inline const char *ultoa(unsigned long n)
85{
86 return ultoa_r(n, itoa_str[0], sizeof(itoa_str[0]));
87}
88
89/* Fast macros to convert up to 10 different parameters inside a same call of
90 * expression.
91 */
92#define U2A0(n) ({ ultoa_r((n), itoa_str[0], sizeof(itoa_str[0])); })
93#define U2A1(n) ({ ultoa_r((n), itoa_str[1], sizeof(itoa_str[1])); })
94#define U2A2(n) ({ ultoa_r((n), itoa_str[2], sizeof(itoa_str[2])); })
95#define U2A3(n) ({ ultoa_r((n), itoa_str[3], sizeof(itoa_str[3])); })
96#define U2A4(n) ({ ultoa_r((n), itoa_str[4], sizeof(itoa_str[4])); })
97#define U2A5(n) ({ ultoa_r((n), itoa_str[5], sizeof(itoa_str[5])); })
98#define U2A6(n) ({ ultoa_r((n), itoa_str[6], sizeof(itoa_str[6])); })
99#define U2A7(n) ({ ultoa_r((n), itoa_str[7], sizeof(itoa_str[7])); })
100#define U2A8(n) ({ ultoa_r((n), itoa_str[8], sizeof(itoa_str[8])); })
101#define U2A9(n) ({ ultoa_r((n), itoa_str[9], sizeof(itoa_str[9])); })
Willy Tarreaubaaee002006-06-26 02:48:02 +0200102
Willy Tarreaue7239b52009-03-29 13:41:58 +0200103/* The same macros provide HTML encoding of numbers */
104#define U2H0(n) ({ ulltoh_r((n), itoa_str[0], sizeof(itoa_str[0])); })
105#define U2H1(n) ({ ulltoh_r((n), itoa_str[1], sizeof(itoa_str[1])); })
106#define U2H2(n) ({ ulltoh_r((n), itoa_str[2], sizeof(itoa_str[2])); })
107#define U2H3(n) ({ ulltoh_r((n), itoa_str[3], sizeof(itoa_str[3])); })
108#define U2H4(n) ({ ulltoh_r((n), itoa_str[4], sizeof(itoa_str[4])); })
109#define U2H5(n) ({ ulltoh_r((n), itoa_str[5], sizeof(itoa_str[5])); })
110#define U2H6(n) ({ ulltoh_r((n), itoa_str[6], sizeof(itoa_str[6])); })
111#define U2H7(n) ({ ulltoh_r((n), itoa_str[7], sizeof(itoa_str[7])); })
112#define U2H8(n) ({ ulltoh_r((n), itoa_str[8], sizeof(itoa_str[8])); })
113#define U2H9(n) ({ ulltoh_r((n), itoa_str[9], sizeof(itoa_str[9])); })
114
Willy Tarreaubaaee002006-06-26 02:48:02 +0200115/*
Willy Tarreau91092e52007-10-25 16:58:42 +0200116 * This function simply returns a locally allocated string containing the ascii
117 * representation for number 'n' in decimal, unless n is 0 in which case it
118 * returns the alternate string (or an empty string if the alternate string is
119 * NULL). It use is intended for limits reported in reports, where it's
120 * desirable not to display anything if there is no limit. Warning! it shares
121 * the same vector as ultoa_r().
122 */
123extern const char *limit_r(unsigned long n, char *buffer, int size, const char *alt);
124
125/* Fast macros to convert up to 10 different parameters inside a same call of
126 * expression. Warning! they share the same vectors as U2A*!
127 */
128#define LIM2A0(n, alt) ({ limit_r((n), itoa_str[0], sizeof(itoa_str[0]), (alt)); })
129#define LIM2A1(n, alt) ({ limit_r((n), itoa_str[1], sizeof(itoa_str[1]), (alt)); })
130#define LIM2A2(n, alt) ({ limit_r((n), itoa_str[2], sizeof(itoa_str[2]), (alt)); })
131#define LIM2A3(n, alt) ({ limit_r((n), itoa_str[3], sizeof(itoa_str[3]), (alt)); })
132#define LIM2A4(n, alt) ({ limit_r((n), itoa_str[4], sizeof(itoa_str[4]), (alt)); })
133#define LIM2A5(n, alt) ({ limit_r((n), itoa_str[5], sizeof(itoa_str[5]), (alt)); })
134#define LIM2A6(n, alt) ({ limit_r((n), itoa_str[6], sizeof(itoa_str[6]), (alt)); })
135#define LIM2A7(n, alt) ({ limit_r((n), itoa_str[7], sizeof(itoa_str[7]), (alt)); })
136#define LIM2A8(n, alt) ({ limit_r((n), itoa_str[8], sizeof(itoa_str[8]), (alt)); })
137#define LIM2A9(n, alt) ({ limit_r((n), itoa_str[9], sizeof(itoa_str[9]), (alt)); })
138
139/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200140 * Returns non-zero if character <s> is a hex digit (0-9, a-f, A-F), else zero.
141 */
142extern int ishex(char s);
143
144/*
Willy Tarreau2e74c3f2007-12-02 18:45:09 +0100145 * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_:.-]. If an
146 * invalid character is found, a pointer to it is returned. If everything is
147 * fine, NULL is returned.
148 */
149extern const char *invalid_char(const char *name);
150
151/*
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200152 * Checks <domainname> for invalid characters. Valid chars are [A-Za-z0-9_.-].
153 * If an invalid character is found, a pointer to it is returned.
154 * If everything is fine, NULL is returned.
155 */
156extern const char *invalid_domainchar(const char *name);
157
158/*
Robert Tsai81ae1952007-12-05 10:47:29 +0100159 * converts <str> to a struct sockaddr_un* which is locally allocated.
160 * The format is "/path", where "/path" is a path to a UNIX domain socket.
161 */
Willy Tarreaucaf720d2008-03-07 10:07:04 +0100162struct sockaddr_un *str2sun(const char *str);
Robert Tsai81ae1952007-12-05 10:47:29 +0100163
164/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200165 * converts <str> to a struct sockaddr_in* which is locally allocated.
166 * The format is "addr:port", where "addr" can be a dotted IPv4 address,
167 * a host name, or empty or "*" to indicate INADDR_ANY.
168 */
169struct sockaddr_in *str2sa(char *str);
170
171/*
Willy Tarreaud077a8e2007-05-08 18:28:09 +0200172 * converts <str> to two struct in_addr* which must be pre-allocated.
Willy Tarreaubaaee002006-06-26 02:48:02 +0200173 * The format is "addr[/mask]", where "addr" cannot be empty, and mask
174 * is optionnal and either in the dotted or CIDR notation.
175 * Note: "addr" can also be a hostname. Returns 1 if OK, 0 if error.
176 */
Willy Tarreaud077a8e2007-05-08 18:28:09 +0200177int str2net(const char *str, struct in_addr *addr, struct in_addr *mask);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200178
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100179/*
180 * Resolve destination server from URL. Convert <str> to a sockaddr_in*.
181 */
182int url2sa(const char *url, int ulen, struct sockaddr_in *addr);
183
Willy Tarreaubaaee002006-06-26 02:48:02 +0200184/* will try to encode the string <string> replacing all characters tagged in
185 * <map> with the hexadecimal representation of their ASCII-code (2 digits)
186 * prefixed by <escape>, and will store the result between <start> (included)
187 * and <stop> (excluded), and will always terminate the string with a '\0'
188 * before <stop>. The position of the '\0' is returned if the conversion
189 * completes. If bytes are missing between <start> and <stop>, then the
190 * conversion will be incomplete and truncated. If <stop> <= <start>, the '\0'
191 * cannot even be stored so we return <start> without writing the 0.
192 * The input string must also be zero-terminated.
193 */
194extern const char hextab[];
195char *encode_string(char *start, char *stop,
196 const char escape, const fd_set *map,
197 const char *string);
198
Willy Tarreau6911fa42007-03-04 18:06:08 +0100199/* This one is 6 times faster than strtoul() on athlon, but does
200 * no check at all.
201 */
202static inline unsigned int __str2ui(const char *s)
203{
204 unsigned int i = 0;
205 while (*s) {
206 i = i * 10 - '0';
207 i += (unsigned char)*s++;
208 }
209 return i;
210}
211
212/* This one is 5 times faster than strtoul() on athlon with checks.
213 * It returns the value of the number composed of all valid digits read.
214 */
215static inline unsigned int __str2uic(const char *s)
216{
217 unsigned int i = 0;
218 unsigned int j;
219 while (1) {
220 j = (*s++) - '0';
221 if (j > 9)
222 break;
223 i *= 10;
224 i += j;
225 }
226 return i;
227}
228
229/* This one is 28 times faster than strtoul() on athlon, but does
230 * no check at all!
231 */
232static inline unsigned int __strl2ui(const char *s, int len)
233{
234 unsigned int i = 0;
235 while (len-- > 0) {
236 i = i * 10 - '0';
237 i += (unsigned char)*s++;
238 }
239 return i;
240}
241
242/* This one is 7 times faster than strtoul() on athlon with checks.
243 * It returns the value of the number composed of all valid digits read.
244 */
245static inline unsigned int __strl2uic(const char *s, int len)
246{
247 unsigned int i = 0;
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200248 unsigned int j, k;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100249
250 while (len-- > 0) {
251 j = (*s++) - '0';
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200252 k = i * 10;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100253 if (j > 9)
254 break;
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200255 i = k + j;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100256 }
257 return i;
258}
259
260extern unsigned int str2ui(const char *s);
261extern unsigned int str2uic(const char *s);
262extern unsigned int strl2ui(const char *s, int len);
263extern unsigned int strl2uic(const char *s, int len);
264extern int strl2ic(const char *s, int len);
265extern int strl2irc(const char *s, int len, int *ret);
266extern int strl2llrc(const char *s, int len, long long *ret);
267
Willy Tarreaufe944602007-10-25 10:34:16 +0200268/* This function converts the time_t value <now> into a broken out struct tm
269 * which must be allocated by the caller. It is highly recommended to use this
270 * function intead of localtime() because that one requires a time_t* which
271 * is not always compatible with tv_sec depending on OS/hardware combinations.
272 */
273static inline void get_localtime(const time_t now, struct tm *tm)
274{
275 localtime_r(&now, tm);
276}
277
Willy Tarreaua0d37b62007-12-02 22:00:35 +0100278/* This function parses a time value optionally followed by a unit suffix among
279 * "d", "h", "m", "s", "ms" or "us". It converts the value into the unit
280 * expected by the caller. The computation does its best to avoid overflows.
281 * The value is returned in <ret> if everything is fine, and a NULL is returned
282 * by the function. In case of error, a pointer to the error is returned and
283 * <ret> is left untouched.
284 */
285extern const char *parse_time_err(const char *text, unsigned *ret, unsigned unit_flags);
286
287/* unit flags to pass to parse_time_err */
288#define TIME_UNIT_US 0x0000
289#define TIME_UNIT_MS 0x0001
290#define TIME_UNIT_S 0x0002
291#define TIME_UNIT_MIN 0x0003
292#define TIME_UNIT_HOUR 0x0004
293#define TIME_UNIT_DAY 0x0005
294#define TIME_UNIT_MASK 0x0007
295
Willy Tarreau7f062c42009-03-05 18:43:00 +0100296/* Multiply the two 32-bit operands and shift the 64-bit result right 32 bits.
297 * This is used to compute fixed ratios by setting one of the operands to
298 * (2^32*ratio).
299 */
300static inline unsigned int mul32hi(unsigned int a, unsigned int b)
301{
302 return ((unsigned long long)a * b) >> 32;
303}
304
Willy Tarreau946ba592009-05-10 15:41:18 +0200305/* copies at most <n> characters from <src> and always terminates with '\0' */
306char *my_strndup(const char *src, int n);
307
Willy Tarreau2dd0d472006-06-29 17:53:05 +0200308#endif /* _COMMON_STANDARD_H */