blob: f1a86d31e2e41c7c5aedfcdc0e2e866bca707679 [file] [log] [blame]
Willy Tarreauc7e42382012-08-24 19:22:53 +02001/*
2 * Chunk management functions.
3 *
4 * Copyright 2000-2012 Willy Tarreau <w@1wt.eu>
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
13#include <ctype.h>
14#include <stdarg.h>
15#include <stdio.h>
16#include <string.h>
17
18#include <common/config.h>
19#include <common/chunk.h>
Hubert Verstraete831962e2016-06-28 22:44:26 +020020#include <common/standard.h>
Willy Tarreauc7e42382012-08-24 19:22:53 +020021
Christopher Faulet748919a2017-07-26 14:59:46 +020022#include <types/global.h>
23
Willy Tarreau47ca5452012-12-23 20:22:19 +010024/* trash chunks used for various conversions */
Christopher Faulet6adad112017-04-21 16:47:03 +020025static THREAD_LOCAL struct chunk *trash_chunk;
26static THREAD_LOCAL struct chunk trash_chunk1;
27static THREAD_LOCAL struct chunk trash_chunk2;
Willy Tarreau47ca5452012-12-23 20:22:19 +010028
29/* trash buffers used for various conversions */
30static int trash_size;
Christopher Faulet6adad112017-04-21 16:47:03 +020031static THREAD_LOCAL char *trash_buf1;
32static THREAD_LOCAL char *trash_buf2;
Willy Tarreau47ca5452012-12-23 20:22:19 +010033
Willy Tarreaub686afd2017-02-08 11:06:11 +010034/* the trash pool for reentrant allocations */
Willy Tarreaubafbe012017-11-24 17:34:44 +010035struct pool_head *pool_head_trash = NULL;
Willy Tarreaub686afd2017-02-08 11:06:11 +010036
Christopher Faulet748919a2017-07-26 14:59:46 +020037/* this is used to drain data, and as a temporary buffer for sprintf()... */
Christopher Faulet6adad112017-04-21 16:47:03 +020038THREAD_LOCAL struct chunk trash = { .str = NULL };
Christopher Faulet748919a2017-07-26 14:59:46 +020039
Willy Tarreau47ca5452012-12-23 20:22:19 +010040/*
41* Returns a pre-allocated and initialized trash chunk that can be used for any
42* type of conversion. Two chunks and their respective buffers are alternatively
43* returned so that it is always possible to iterate data transformations without
44* losing the data being transformed. The blocks are initialized to the size of
Willy Tarreau031ad232013-12-11 17:32:08 +010045* a standard buffer, so they should be enough for everything. For convenience,
46* a zero is always emitted at the beginning of the string so that it may be
47* used as an empty string as well.
Willy Tarreau47ca5452012-12-23 20:22:19 +010048*/
49struct chunk *get_trash_chunk(void)
50{
51 char *trash_buf;
52
53 if (trash_chunk == &trash_chunk1) {
54 trash_chunk = &trash_chunk2;
55 trash_buf = trash_buf2;
56 }
57 else {
58 trash_chunk = &trash_chunk1;
59 trash_buf = trash_buf1;
60 }
Willy Tarreau031ad232013-12-11 17:32:08 +010061 *trash_buf = 0;
Willy Tarreau47ca5452012-12-23 20:22:19 +010062 chunk_init(trash_chunk, trash_buf, trash_size);
63 return trash_chunk;
64}
65
Willy Tarreau2819e992013-12-13 14:41:10 +010066/* (re)allocates the trash buffers. Returns 0 in case of failure. It is
67 * possible to call this function multiple times if the trash size changes.
68 */
Christopher Faulet748919a2017-07-26 14:59:46 +020069static int alloc_trash_buffers(int bufsize)
Willy Tarreau47ca5452012-12-23 20:22:19 +010070{
Christopher Fauletcd7879a2017-10-27 13:53:47 +020071 chunk_init(&trash, my_realloc2(trash.str, bufsize), bufsize);
Willy Tarreau47ca5452012-12-23 20:22:19 +010072 trash_size = bufsize;
Hubert Verstraete831962e2016-06-28 22:44:26 +020073 trash_buf1 = (char *)my_realloc2(trash_buf1, bufsize);
74 trash_buf2 = (char *)my_realloc2(trash_buf2, bufsize);
Christopher Fauletcd7879a2017-10-27 13:53:47 +020075 return trash.str && trash_buf1 && trash_buf2;
Willy Tarreau47ca5452012-12-23 20:22:19 +010076}
77
Christopher Fauletcd7879a2017-10-27 13:53:47 +020078static int init_trash_buffers_per_thread()
79{
80 return alloc_trash_buffers(global.tune.bufsize);
81}
82
83static void deinit_trash_buffers_per_thread()
84{
85 chunk_destroy(&trash);
86 free(trash_buf2);
87 free(trash_buf1);
88 trash_buf2 = NULL;
89 trash_buf1 = NULL;
90}
91
Christopher Faulet748919a2017-07-26 14:59:46 +020092/* Initialize the trash buffers. It returns 0 if an error occurred. */
Christopher Fauletcd7879a2017-10-27 13:53:47 +020093int init_trash_buffers(int first)
Christopher Faulet748919a2017-07-26 14:59:46 +020094{
Christopher Fauletcd7879a2017-10-27 13:53:47 +020095 if (!first) {
96 hap_register_per_thread_init(init_trash_buffers_per_thread);
97 hap_register_per_thread_deinit(deinit_trash_buffers_per_thread);
Christopher Faulet6adad112017-04-21 16:47:03 +020098 }
Willy Tarreaubafbe012017-11-24 17:34:44 +010099 pool_destroy(pool_head_trash);
100 pool_head_trash = create_pool("trash", sizeof(struct chunk) + global.tune.bufsize, MEM_F_EXACT);
101 if (!pool_head_trash || !alloc_trash_buffers(global.tune.bufsize))
Christopher Faulet748919a2017-07-26 14:59:46 +0200102 return 0;
103 return 1;
104}
105
Willy Tarreauc7e42382012-08-24 19:22:53 +0200106/*
David Carlier60deeba2015-09-25 11:58:12 +0100107 * free the trash buffers
108 */
Christopher Faulet748919a2017-07-26 14:59:46 +0200109void deinit_trash_buffers(void)
David Carlier60deeba2015-09-25 11:58:12 +0100110{
Willy Tarreaubafbe012017-11-24 17:34:44 +0100111 pool_destroy(pool_head_trash);
David Carlier60deeba2015-09-25 11:58:12 +0100112}
113
114/*
Willy Tarreaub686afd2017-02-08 11:06:11 +0100115 * Allocate a trash chunk from the reentrant pool. The buffer starts at the
116 * end of the chunk. This chunk must be freed using free_trash_chunk(). This
117 * call may fail and the caller is responsible for checking that the returned
118 * pointer is not NULL.
119 */
120struct chunk *alloc_trash_chunk(void)
121{
122 struct chunk *chunk;
123
Willy Tarreaubafbe012017-11-24 17:34:44 +0100124 chunk = pool_alloc(pool_head_trash);
Willy Tarreaub686afd2017-02-08 11:06:11 +0100125 if (chunk) {
126 char *buf = (char *)chunk + sizeof(struct chunk);
127 *buf = 0;
Willy Tarreaubafbe012017-11-24 17:34:44 +0100128 chunk_init(chunk, buf, pool_head_trash->size - sizeof(struct chunk));
Willy Tarreaub686afd2017-02-08 11:06:11 +0100129 }
130 return chunk;
131}
132
133/*
Willy Tarreau77804732012-10-29 16:14:26 +0100134 * Does an snprintf() at the beginning of chunk <chk>, respecting the limit of
135 * at most chk->size chars. If the chk->len is over, nothing is added. Returns
136 * the new chunk size, or < 0 in case of failure.
137 */
138int chunk_printf(struct chunk *chk, const char *fmt, ...)
139{
140 va_list argp;
141 int ret;
142
143 if (!chk->str || !chk->size)
144 return 0;
145
146 va_start(argp, fmt);
147 ret = vsnprintf(chk->str, chk->size, fmt, argp);
148 va_end(argp);
149 chk->len = ret;
150
151 if (ret >= chk->size)
152 ret = -1;
153
154 chk->len = ret;
155 return chk->len;
156}
157
158/*
Willy Tarreauc7e42382012-08-24 19:22:53 +0200159 * Does an snprintf() at the end of chunk <chk>, respecting the limit of
160 * at most chk->size chars. If the chk->len is over, nothing is added. Returns
161 * the new chunk size.
162 */
Willy Tarreau77804732012-10-29 16:14:26 +0100163int chunk_appendf(struct chunk *chk, const char *fmt, ...)
Willy Tarreauc7e42382012-08-24 19:22:53 +0200164{
165 va_list argp;
166 int ret;
167
Willy Tarreau320ec2a2016-02-25 16:15:19 +0100168 if (chk->len < 0 || !chk->str || !chk->size)
Willy Tarreauc7e42382012-08-24 19:22:53 +0200169 return 0;
170
171 va_start(argp, fmt);
172 ret = vsnprintf(chk->str + chk->len, chk->size - chk->len, fmt, argp);
173 if (ret >= chk->size - chk->len)
174 /* do not copy anything in case of truncation */
175 chk->str[chk->len] = 0;
176 else
177 chk->len += ret;
178 va_end(argp);
179 return chk->len;
180}
181
182/*
183 * Encode chunk <src> into chunk <dst>, respecting the limit of at most
184 * chk->size chars. Replace non-printable or special chracters with "&#%d;".
185 * If the chk->len is over, nothing is added. Returns the new chunk size.
186 */
187int chunk_htmlencode(struct chunk *dst, struct chunk *src)
188{
189 int i, l;
190 int olen, free;
191 char c;
192
Willy Tarreau320ec2a2016-02-25 16:15:19 +0100193 if (dst->len < 0)
194 return dst->len;
195
Willy Tarreauc7e42382012-08-24 19:22:53 +0200196 olen = dst->len;
197
198 for (i = 0; i < src->len; i++) {
199 free = dst->size - dst->len;
200
201 if (!free) {
202 dst->len = olen;
203 return dst->len;
204 }
205
206 c = src->str[i];
207
208 if (!isascii(c) || !isprint((unsigned char)c) || c == '&' || c == '"' || c == '\'' || c == '<' || c == '>') {
209 l = snprintf(dst->str + dst->len, free, "&#%u;", (unsigned char)c);
210
211 if (free < l) {
212 dst->len = olen;
213 return dst->len;
214 }
215
216 dst->len += l;
217 } else {
218 dst->str[dst->len] = c;
219 dst->len++;
220 }
221 }
222
223 return dst->len;
224}
225
226/*
227 * Encode chunk <src> into chunk <dst>, respecting the limit of at most
228 * chk->size chars. Replace non-printable or char passed in qc with "<%02X>".
229 * If the chk->len is over, nothing is added. Returns the new chunk size.
230 */
231int chunk_asciiencode(struct chunk *dst, struct chunk *src, char qc)
232{
233 int i, l;
234 int olen, free;
235 char c;
236
Willy Tarreau320ec2a2016-02-25 16:15:19 +0100237 if (dst->len < 0)
238 return dst->len;
239
Willy Tarreauc7e42382012-08-24 19:22:53 +0200240 olen = dst->len;
241
242 for (i = 0; i < src->len; i++) {
243 free = dst->size - dst->len;
244
245 if (!free) {
246 dst->len = olen;
247 return dst->len;
248 }
249
250 c = src->str[i];
251
252 if (!isascii(c) || !isprint((unsigned char)c) || c == '<' || c == '>' || c == qc) {
253 l = snprintf(dst->str + dst->len, free, "<%02X>", (unsigned char)c);
254
255 if (free < l) {
256 dst->len = olen;
257 return dst->len;
258 }
259
260 dst->len += l;
261 } else {
262 dst->str[dst->len] = c;
263 dst->len++;
264 }
265 }
266
267 return dst->len;
268}
269
Willy Tarreauad8f8e82012-10-19 15:18:06 +0200270/* Compares the string in chunk <chk> with the string in <str> which must be
271 * zero-terminated. Return is the same as with strcmp(). Neither is allowed
272 * to be null.
273 */
274int chunk_strcmp(const struct chunk *chk, const char *str)
275{
276 const char *s1 = chk->str;
277 int len = chk->len;
278 int diff = 0;
279
280 do {
Emeric Brun78bd4032014-05-09 17:11:07 +0200281 if (--len < 0) {
282 diff = (unsigned char)0 - (unsigned char)*str;
Willy Tarreauad8f8e82012-10-19 15:18:06 +0200283 break;
Emeric Brun78bd4032014-05-09 17:11:07 +0200284 }
Willy Tarreauad8f8e82012-10-19 15:18:06 +0200285 diff = (unsigned char)*(s1++) - (unsigned char)*(str++);
286 } while (!diff);
287 return diff;
288}
289
290/* Case-insensitively compares the string in chunk <chk> with the string in
291 * <str> which must be zero-terminated. Return is the same as with strcmp().
292 * Neither is allowed to be null.
293 */
294int chunk_strcasecmp(const struct chunk *chk, const char *str)
295{
296 const char *s1 = chk->str;
297 int len = chk->len;
298 int diff = 0;
299
300 do {
Emeric Brun78bd4032014-05-09 17:11:07 +0200301 if (--len < 0) {
302 diff = (unsigned char)0 - (unsigned char)*str;
Willy Tarreauad8f8e82012-10-19 15:18:06 +0200303 break;
Emeric Brun78bd4032014-05-09 17:11:07 +0200304 }
Willy Tarreauad8f8e82012-10-19 15:18:06 +0200305 diff = (unsigned char)*s1 - (unsigned char)*str;
306 if (unlikely(diff)) {
307 unsigned int l = (unsigned char)*s1;
308 unsigned int r = (unsigned char)*str;
309
310 l -= 'a';
311 r -= 'a';
312
313 if (likely(l <= (unsigned char)'z' - 'a'))
314 l -= 'a' - 'A';
315 if (likely(r <= (unsigned char)'z' - 'a'))
316 r -= 'a' - 'A';
317 diff = l - r;
318 }
319 s1++; str++;
320 } while (!diff);
321 return diff;
322}
Willy Tarreauc7e42382012-08-24 19:22:53 +0200323
324/*
325 * Local variables:
326 * c-indent-level: 8
327 * c-basic-offset: 8
328 * End:
329 */