blob: fcac72fd598a500346164e70f042f0acd1fc5ba2 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
Willy Tarreaucc05fba2009-10-27 21:40:18 +01002 * include/common/standard.h
3 * This files contains some general purpose functions and macros.
4 *
Willy Tarreau348238b2010-01-18 15:05:57 +01005 * Copyright (C) 2000-2010 Willy Tarreau - w@1wt.eu
Willy Tarreaucc05fba2009-10-27 21:40:18 +01006 *
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 */
Willy Tarreaubaaee002006-06-26 02:48:02 +020021
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 Tarreau050737f2010-01-14 11:40:12 +010026#include <string.h>
Willy Tarreaufe944602007-10-25 10:34:16 +020027#include <time.h>
Willy Tarreau938b3032007-05-10 06:39:03 +020028#include <sys/types.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020029#include <netinet/in.h>
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020030#include <common/config.h>
Willy Tarreau45cb4fb2009-10-26 21:10:04 +010031#include <eb32tree.h>
Willy Tarreauca28d1e2007-01-24 18:20:50 +010032#include <proto/fd.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020033
34/****** string-specific macros and functions ******/
35/* if a > max, then bound <a> to <max>. The macro returns the new <a> */
36#define UBOUND(a, max) ({ typeof(a) b = (max); if ((a) > b) (a) = b; (a); })
37
38/* if a < min, then bound <a> to <min>. The macro returns the new <a> */
39#define LBOUND(a, min) ({ typeof(a) b = (min); if ((a) < b) (a) = b; (a); })
40
41/* returns 1 only if only zero or one bit is set in X, which means that X is a
42 * power of 2, and 0 otherwise */
43#define POWEROF2(x) (((x) & ((x)-1)) == 0)
44
Willy Tarreau7d58a632007-01-13 23:06:06 +010045/*
Willy Tarreaubaaee002006-06-26 02:48:02 +020046 * copies at most <size-1> chars from <src> to <dst>. Last char is always
47 * set to 0, unless <size> is 0. The number of chars copied is returned
48 * (excluding the terminating zero).
49 * This code has been optimized for size and speed : on x86, it's 45 bytes
50 * long, uses only registers, and consumes only 4 cycles per char.
51 */
52extern int strlcpy2(char *dst, const char *src, int size);
53
54/*
Willy Tarreau72d759c2007-10-25 12:14:10 +020055 * This function simply returns a locally allocated string containing
Willy Tarreaubaaee002006-06-26 02:48:02 +020056 * the ascii representation for number 'n' in decimal.
57 */
Willy Tarreaue7239b52009-03-29 13:41:58 +020058extern char itoa_str[][171];
Emeric Brun3a7fce52010-01-04 14:54:38 +010059extern char *ultoa_r(unsigned long n, char *buffer, int size);
Willy Tarreaue7239b52009-03-29 13:41:58 +020060extern const char *ulltoh_r(unsigned long long n, char *buffer, int size);
Willy Tarreau72d759c2007-10-25 12:14:10 +020061static inline const char *ultoa(unsigned long n)
62{
63 return ultoa_r(n, itoa_str[0], sizeof(itoa_str[0]));
64}
65
66/* Fast macros to convert up to 10 different parameters inside a same call of
67 * expression.
68 */
69#define U2A0(n) ({ ultoa_r((n), itoa_str[0], sizeof(itoa_str[0])); })
70#define U2A1(n) ({ ultoa_r((n), itoa_str[1], sizeof(itoa_str[1])); })
71#define U2A2(n) ({ ultoa_r((n), itoa_str[2], sizeof(itoa_str[2])); })
72#define U2A3(n) ({ ultoa_r((n), itoa_str[3], sizeof(itoa_str[3])); })
73#define U2A4(n) ({ ultoa_r((n), itoa_str[4], sizeof(itoa_str[4])); })
74#define U2A5(n) ({ ultoa_r((n), itoa_str[5], sizeof(itoa_str[5])); })
75#define U2A6(n) ({ ultoa_r((n), itoa_str[6], sizeof(itoa_str[6])); })
76#define U2A7(n) ({ ultoa_r((n), itoa_str[7], sizeof(itoa_str[7])); })
77#define U2A8(n) ({ ultoa_r((n), itoa_str[8], sizeof(itoa_str[8])); })
78#define U2A9(n) ({ ultoa_r((n), itoa_str[9], sizeof(itoa_str[9])); })
Willy Tarreaubaaee002006-06-26 02:48:02 +020079
Willy Tarreaue7239b52009-03-29 13:41:58 +020080/* The same macros provide HTML encoding of numbers */
81#define U2H0(n) ({ ulltoh_r((n), itoa_str[0], sizeof(itoa_str[0])); })
82#define U2H1(n) ({ ulltoh_r((n), itoa_str[1], sizeof(itoa_str[1])); })
83#define U2H2(n) ({ ulltoh_r((n), itoa_str[2], sizeof(itoa_str[2])); })
84#define U2H3(n) ({ ulltoh_r((n), itoa_str[3], sizeof(itoa_str[3])); })
85#define U2H4(n) ({ ulltoh_r((n), itoa_str[4], sizeof(itoa_str[4])); })
86#define U2H5(n) ({ ulltoh_r((n), itoa_str[5], sizeof(itoa_str[5])); })
87#define U2H6(n) ({ ulltoh_r((n), itoa_str[6], sizeof(itoa_str[6])); })
88#define U2H7(n) ({ ulltoh_r((n), itoa_str[7], sizeof(itoa_str[7])); })
89#define U2H8(n) ({ ulltoh_r((n), itoa_str[8], sizeof(itoa_str[8])); })
90#define U2H9(n) ({ ulltoh_r((n), itoa_str[9], sizeof(itoa_str[9])); })
91
Willy Tarreaubaaee002006-06-26 02:48:02 +020092/*
Willy Tarreau91092e52007-10-25 16:58:42 +020093 * This function simply returns a locally allocated string containing the ascii
94 * representation for number 'n' in decimal, unless n is 0 in which case it
95 * returns the alternate string (or an empty string if the alternate string is
96 * NULL). It use is intended for limits reported in reports, where it's
97 * desirable not to display anything if there is no limit. Warning! it shares
98 * the same vector as ultoa_r().
99 */
100extern const char *limit_r(unsigned long n, char *buffer, int size, const char *alt);
101
102/* Fast macros to convert up to 10 different parameters inside a same call of
103 * expression. Warning! they share the same vectors as U2A*!
104 */
105#define LIM2A0(n, alt) ({ limit_r((n), itoa_str[0], sizeof(itoa_str[0]), (alt)); })
106#define LIM2A1(n, alt) ({ limit_r((n), itoa_str[1], sizeof(itoa_str[1]), (alt)); })
107#define LIM2A2(n, alt) ({ limit_r((n), itoa_str[2], sizeof(itoa_str[2]), (alt)); })
108#define LIM2A3(n, alt) ({ limit_r((n), itoa_str[3], sizeof(itoa_str[3]), (alt)); })
109#define LIM2A4(n, alt) ({ limit_r((n), itoa_str[4], sizeof(itoa_str[4]), (alt)); })
110#define LIM2A5(n, alt) ({ limit_r((n), itoa_str[5], sizeof(itoa_str[5]), (alt)); })
111#define LIM2A6(n, alt) ({ limit_r((n), itoa_str[6], sizeof(itoa_str[6]), (alt)); })
112#define LIM2A7(n, alt) ({ limit_r((n), itoa_str[7], sizeof(itoa_str[7]), (alt)); })
113#define LIM2A8(n, alt) ({ limit_r((n), itoa_str[8], sizeof(itoa_str[8]), (alt)); })
114#define LIM2A9(n, alt) ({ limit_r((n), itoa_str[9], sizeof(itoa_str[9]), (alt)); })
115
116/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200117 * Returns non-zero if character <s> is a hex digit (0-9, a-f, A-F), else zero.
118 */
119extern int ishex(char s);
120
121/*
Willy Tarreauda3b7c32009-11-02 20:12:52 +0100122 * Return integer equivalent of character <c> for a hex digit (0-9, a-f, A-F),
123 * otherwise -1.
124 */
125extern int hex2i(int c);
126
127/*
Willy Tarreau2e74c3f2007-12-02 18:45:09 +0100128 * Checks <name> for invalid characters. Valid chars are [A-Za-z0-9_:.-]. If an
129 * invalid character is found, a pointer to it is returned. If everything is
130 * fine, NULL is returned.
131 */
132extern const char *invalid_char(const char *name);
133
134/*
Krzysztof Piotr Oledzkiefe3b6f2008-05-23 23:49:32 +0200135 * Checks <domainname> for invalid characters. Valid chars are [A-Za-z0-9_.-].
136 * If an invalid character is found, a pointer to it is returned.
137 * If everything is fine, NULL is returned.
138 */
139extern const char *invalid_domainchar(const char *name);
140
141/*
Robert Tsai81ae1952007-12-05 10:47:29 +0100142 * converts <str> to a struct sockaddr_un* which is locally allocated.
143 * The format is "/path", where "/path" is a path to a UNIX domain socket.
144 */
Willy Tarreaucaf720d2008-03-07 10:07:04 +0100145struct sockaddr_un *str2sun(const char *str);
Robert Tsai81ae1952007-12-05 10:47:29 +0100146
147/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200148 * converts <str> to a struct sockaddr_in* which is locally allocated.
149 * The format is "addr:port", where "addr" can be a dotted IPv4 address,
150 * a host name, or empty or "*" to indicate INADDR_ANY.
151 */
152struct sockaddr_in *str2sa(char *str);
153
154/*
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200155 * converts <str> to a struct sockaddr_in* which is locally allocated, and a
156 * port range consisting in two integers. The low and high end are always set
157 * even if the port is unspecified, in which case (0,0) is returned. The low
158 * port is set in the sockaddr_in. Thus, it is enough to check the size of the
159 * returned range to know if an array must be allocated or not. The format is
160 * "addr[:port[-port]]", where "addr" can be a dotted IPv4 address, a host
161 * name, or empty or "*" to indicate INADDR_ANY.
162 */
163struct sockaddr_in *str2sa_range(char *str, int *low, int *high);
164
Willy Tarreau2937c0d2010-01-26 17:36:17 +0100165/* converts <str> to a struct in_addr containing a network mask. It can be
166 * passed in dotted form (255.255.255.0) or in CIDR form (24). It returns 1
167 * if the conversion succeeds otherwise non-zero.
168 */
169int str2mask(const char *str, struct in_addr *mask);
170
Willy Tarreauc6f4ce82009-06-10 11:09:37 +0200171/*
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/*
Willy Tarreau106f9792009-09-19 07:54:16 +0200180 * Parse IP address found in url.
181 */
182int url2ip(const char *addr, struct in_addr *dst);
183
184/*
Alexandre Cassen5eb1a902007-11-29 15:43:32 +0100185 * Resolve destination server from URL. Convert <str> to a sockaddr_in*.
186 */
187int url2sa(const char *url, int ulen, struct sockaddr_in *addr);
188
Willy Tarreaubaaee002006-06-26 02:48:02 +0200189/* will try to encode the string <string> replacing all characters tagged in
190 * <map> with the hexadecimal representation of their ASCII-code (2 digits)
191 * prefixed by <escape>, and will store the result between <start> (included)
192 * and <stop> (excluded), and will always terminate the string with a '\0'
193 * before <stop>. The position of the '\0' is returned if the conversion
194 * completes. If bytes are missing between <start> and <stop>, then the
195 * conversion will be incomplete and truncated. If <stop> <= <start>, the '\0'
196 * cannot even be stored so we return <start> without writing the 0.
197 * The input string must also be zero-terminated.
198 */
199extern const char hextab[];
200char *encode_string(char *start, char *stop,
201 const char escape, const fd_set *map,
202 const char *string);
203
Willy Tarreau6911fa42007-03-04 18:06:08 +0100204/* This one is 6 times faster than strtoul() on athlon, but does
205 * no check at all.
206 */
207static inline unsigned int __str2ui(const char *s)
208{
209 unsigned int i = 0;
210 while (*s) {
211 i = i * 10 - '0';
212 i += (unsigned char)*s++;
213 }
214 return i;
215}
216
217/* This one is 5 times faster than strtoul() on athlon with checks.
218 * It returns the value of the number composed of all valid digits read.
219 */
220static inline unsigned int __str2uic(const char *s)
221{
222 unsigned int i = 0;
223 unsigned int j;
224 while (1) {
225 j = (*s++) - '0';
226 if (j > 9)
227 break;
228 i *= 10;
229 i += j;
230 }
231 return i;
232}
233
234/* This one is 28 times faster than strtoul() on athlon, but does
235 * no check at all!
236 */
237static inline unsigned int __strl2ui(const char *s, int len)
238{
239 unsigned int i = 0;
240 while (len-- > 0) {
241 i = i * 10 - '0';
242 i += (unsigned char)*s++;
243 }
244 return i;
245}
246
247/* This one is 7 times faster than strtoul() on athlon with checks.
248 * It returns the value of the number composed of all valid digits read.
249 */
250static inline unsigned int __strl2uic(const char *s, int len)
251{
252 unsigned int i = 0;
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200253 unsigned int j, k;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100254
255 while (len-- > 0) {
256 j = (*s++) - '0';
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200257 k = i * 10;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100258 if (j > 9)
259 break;
Willy Tarreau3f0c9762007-10-25 09:42:24 +0200260 i = k + j;
Willy Tarreau6911fa42007-03-04 18:06:08 +0100261 }
262 return i;
263}
264
265extern unsigned int str2ui(const char *s);
266extern unsigned int str2uic(const char *s);
267extern unsigned int strl2ui(const char *s, int len);
268extern unsigned int strl2uic(const char *s, int len);
269extern int strl2ic(const char *s, int len);
270extern int strl2irc(const char *s, int len, int *ret);
271extern int strl2llrc(const char *s, int len, long long *ret);
272
Krzysztof Piotr Oledzki3d5562b2009-10-10 20:11:17 +0200273static inline char *cut_crlf(char *s) {
274
275 while (*s != '\r' || *s == '\n') {
276 char *p = s++;
277
278 if (!*p)
279 return p;
280 }
281
282 *s++ = 0;
283
284 return s;
285}
286
287static inline char *ltrim(char *s, char c) {
288
289 if (c)
290 while (*s == c)
291 s++;
292
293 return s;
294}
295
296static inline char *rtrim(char *s, char c) {
297
298 char *p = s + strlen(s);
299
300 while (p-- > s)
301 if (*p == c)
302 *p = '\0';
303 else
304 break;
305
306 return s;
307}
308
309static inline char *alltrim(char *s, char c) {
310
311 rtrim(s, c);
312
313 return ltrim(s, c);
314}
315
Willy Tarreaufe944602007-10-25 10:34:16 +0200316/* This function converts the time_t value <now> into a broken out struct tm
317 * which must be allocated by the caller. It is highly recommended to use this
318 * function intead of localtime() because that one requires a time_t* which
319 * is not always compatible with tv_sec depending on OS/hardware combinations.
320 */
321static inline void get_localtime(const time_t now, struct tm *tm)
322{
323 localtime_r(&now, tm);
324}
325
Emeric Brun3a058f32009-06-30 18:26:00 +0200326/* This function converts the time_t value <now> into a broken out struct tm
327 * which must be allocated by the caller. It is highly recommended to use this
328 * function intead of gmtime() because that one requires a time_t* which
329 * is not always compatible with tv_sec depending on OS/hardware combinations.
330 */
331static inline void get_gmtime(const time_t now, struct tm *tm)
332{
333 gmtime_r(&now, tm);
334}
335
Willy Tarreaua0d37b62007-12-02 22:00:35 +0100336/* This function parses a time value optionally followed by a unit suffix among
337 * "d", "h", "m", "s", "ms" or "us". It converts the value into the unit
338 * expected by the caller. The computation does its best to avoid overflows.
339 * The value is returned in <ret> if everything is fine, and a NULL is returned
340 * by the function. In case of error, a pointer to the error is returned and
341 * <ret> is left untouched.
342 */
343extern const char *parse_time_err(const char *text, unsigned *ret, unsigned unit_flags);
Emeric Brun39132b22010-01-04 14:57:24 +0100344extern const char *parse_size_err(const char *text, unsigned *ret);
Willy Tarreaua0d37b62007-12-02 22:00:35 +0100345
346/* unit flags to pass to parse_time_err */
347#define TIME_UNIT_US 0x0000
348#define TIME_UNIT_MS 0x0001
349#define TIME_UNIT_S 0x0002
350#define TIME_UNIT_MIN 0x0003
351#define TIME_UNIT_HOUR 0x0004
352#define TIME_UNIT_DAY 0x0005
353#define TIME_UNIT_MASK 0x0007
354
Willy Tarreau7f062c42009-03-05 18:43:00 +0100355/* Multiply the two 32-bit operands and shift the 64-bit result right 32 bits.
356 * This is used to compute fixed ratios by setting one of the operands to
357 * (2^32*ratio).
358 */
359static inline unsigned int mul32hi(unsigned int a, unsigned int b)
360{
361 return ((unsigned long long)a * b) >> 32;
362}
363
Willy Tarreau946ba592009-05-10 15:41:18 +0200364/* copies at most <n> characters from <src> and always terminates with '\0' */
365char *my_strndup(const char *src, int n);
366
Willy Tarreau482b00d2009-10-04 22:48:42 +0200367/* This function returns the first unused key greater than or equal to <key> in
368 * ID tree <root>. Zero is returned if no place is found.
369 */
370unsigned int get_next_id(struct eb_root *root, unsigned int key);
371
Willy Tarreau348238b2010-01-18 15:05:57 +0100372/* This function compares a sample word possibly followed by blanks to another
373 * clean word. The compare is case-insensitive. 1 is returned if both are equal,
374 * otherwise zero. This intends to be used when checking HTTP headers for some
375 * values.
376 */
377int word_match(const char *sample, int slen, const char *word, int wlen);
378
Willy Tarreau2dd0d472006-06-29 17:53:05 +0200379#endif /* _COMMON_STANDARD_H */