blob: f2abcba4e6f68b1462b8b8a48cfee847984d0a2d [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 */
Willy Tarreau83061a82018-07-13 11:56:34 +020025static THREAD_LOCAL struct buffer *trash_chunk;
26static THREAD_LOCAL struct buffer trash_chunk1;
27static THREAD_LOCAL struct buffer 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()... */
Willy Tarreau83061a82018-07-13 11:56:34 +020038THREAD_LOCAL struct buffer trash = { };
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*/
Willy Tarreau83061a82018-07-13 11:56:34 +020049struct buffer *get_trash_chunk(void)
Willy Tarreau47ca5452012-12-23 20:22:19 +010050{
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{
Willy Tarreau843b7cb2018-07-13 10:54:26 +020071 chunk_init(&trash, my_realloc2(trash.area, bufsize), bufsize);
Willy Tarreaue1861612019-06-07 15:33:06 +020072 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);
Willy Tarreau843b7cb2018-07-13 10:54:26 +020075 return trash.area && trash_buf1 && trash_buf2;
Willy Tarreau47ca5452012-12-23 20:22:19 +010076}
77
Willy Tarreau082b6282019-05-22 14:42:12 +020078static int alloc_trash_buffers_per_thread()
Christopher Fauletcd7879a2017-10-27 13:53:47 +020079{
80 return alloc_trash_buffers(global.tune.bufsize);
81}
82
Willy Tarreau082b6282019-05-22 14:42:12 +020083static void free_trash_buffers_per_thread()
Christopher Fauletcd7879a2017-10-27 13:53:47 +020084{
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{
Willy Tarreaubafbe012017-11-24 17:34:44 +010095 pool_destroy(pool_head_trash);
Willy Tarreau83061a82018-07-13 11:56:34 +020096 pool_head_trash = create_pool("trash",
97 sizeof(struct buffer) + global.tune.bufsize,
98 MEM_F_EXACT);
Willy Tarreaubafbe012017-11-24 17:34:44 +010099 if (!pool_head_trash || !alloc_trash_buffers(global.tune.bufsize))
Christopher Faulet748919a2017-07-26 14:59:46 +0200100 return 0;
101 return 1;
102}
103
Willy Tarreauc7e42382012-08-24 19:22:53 +0200104/*
Willy Tarreaub686afd2017-02-08 11:06:11 +0100105 * Allocate a trash chunk from the reentrant pool. The buffer starts at the
106 * end of the chunk. This chunk must be freed using free_trash_chunk(). This
107 * call may fail and the caller is responsible for checking that the returned
108 * pointer is not NULL.
109 */
Willy Tarreau83061a82018-07-13 11:56:34 +0200110struct buffer *alloc_trash_chunk(void)
Willy Tarreaub686afd2017-02-08 11:06:11 +0100111{
Willy Tarreau83061a82018-07-13 11:56:34 +0200112 struct buffer *chunk;
Willy Tarreaub686afd2017-02-08 11:06:11 +0100113
Willy Tarreaubafbe012017-11-24 17:34:44 +0100114 chunk = pool_alloc(pool_head_trash);
Willy Tarreaub686afd2017-02-08 11:06:11 +0100115 if (chunk) {
Willy Tarreau83061a82018-07-13 11:56:34 +0200116 char *buf = (char *)chunk + sizeof(struct buffer);
Willy Tarreaub686afd2017-02-08 11:06:11 +0100117 *buf = 0;
Willy Tarreau83061a82018-07-13 11:56:34 +0200118 chunk_init(chunk, buf,
119 pool_head_trash->size - sizeof(struct buffer));
Willy Tarreaub686afd2017-02-08 11:06:11 +0100120 }
121 return chunk;
122}
123
124/*
Willy Tarreau77804732012-10-29 16:14:26 +0100125 * Does an snprintf() at the beginning of chunk <chk>, respecting the limit of
126 * at most chk->size chars. If the chk->len is over, nothing is added. Returns
127 * the new chunk size, or < 0 in case of failure.
128 */
Willy Tarreau83061a82018-07-13 11:56:34 +0200129int chunk_printf(struct buffer *chk, const char *fmt, ...)
Willy Tarreau77804732012-10-29 16:14:26 +0100130{
131 va_list argp;
132 int ret;
133
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200134 if (!chk->area || !chk->size)
Willy Tarreau77804732012-10-29 16:14:26 +0100135 return 0;
136
137 va_start(argp, fmt);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200138 ret = vsnprintf(chk->area, chk->size, fmt, argp);
Willy Tarreau77804732012-10-29 16:14:26 +0100139 va_end(argp);
Willy Tarreau77804732012-10-29 16:14:26 +0100140
141 if (ret >= chk->size)
Willy Tarreau5f6333c2018-08-22 05:14:37 +0200142 return -1;
Willy Tarreau77804732012-10-29 16:14:26 +0100143
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200144 chk->data = ret;
145 return chk->data;
Willy Tarreau77804732012-10-29 16:14:26 +0100146}
147
148/*
Willy Tarreauc7e42382012-08-24 19:22:53 +0200149 * Does an snprintf() at the end of chunk <chk>, respecting the limit of
150 * at most chk->size chars. If the chk->len is over, nothing is added. Returns
151 * the new chunk size.
152 */
Willy Tarreau83061a82018-07-13 11:56:34 +0200153int chunk_appendf(struct buffer *chk, const char *fmt, ...)
Willy Tarreauc7e42382012-08-24 19:22:53 +0200154{
155 va_list argp;
156 int ret;
157
Willy Tarreaubba81562018-08-22 04:59:48 +0200158 if (!chk->area || !chk->size)
Willy Tarreauc7e42382012-08-24 19:22:53 +0200159 return 0;
160
161 va_start(argp, fmt);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200162 ret = vsnprintf(chk->area + chk->data, chk->size - chk->data, fmt,
163 argp);
164 if (ret >= chk->size - chk->data)
Willy Tarreauc7e42382012-08-24 19:22:53 +0200165 /* do not copy anything in case of truncation */
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200166 chk->area[chk->data] = 0;
Willy Tarreauc7e42382012-08-24 19:22:53 +0200167 else
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200168 chk->data += ret;
Willy Tarreauc7e42382012-08-24 19:22:53 +0200169 va_end(argp);
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200170 return chk->data;
Willy Tarreauc7e42382012-08-24 19:22:53 +0200171}
172
173/*
174 * Encode chunk <src> into chunk <dst>, respecting the limit of at most
Ilya Shipitsinc02a23f2020-05-06 00:53:22 +0500175 * chk->size chars. Replace non-printable or special characters with "&#%d;".
Willy Tarreauc7e42382012-08-24 19:22:53 +0200176 * If the chk->len is over, nothing is added. Returns the new chunk size.
177 */
Willy Tarreau83061a82018-07-13 11:56:34 +0200178int chunk_htmlencode(struct buffer *dst, struct buffer *src)
Willy Tarreauc7e42382012-08-24 19:22:53 +0200179{
180 int i, l;
181 int olen, free;
182 char c;
183
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200184 olen = dst->data;
Willy Tarreauc7e42382012-08-24 19:22:53 +0200185
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200186 for (i = 0; i < src->data; i++) {
187 free = dst->size - dst->data;
Willy Tarreauc7e42382012-08-24 19:22:53 +0200188
189 if (!free) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200190 dst->data = olen;
191 return dst->data;
Willy Tarreauc7e42382012-08-24 19:22:53 +0200192 }
193
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200194 c = src->area[i];
Willy Tarreauc7e42382012-08-24 19:22:53 +0200195
Willy Tarreau90807112020-02-25 08:16:33 +0100196 if (!isascii((unsigned char)c) || !isprint((unsigned char)c) || c == '&' || c == '"' || c == '\'' || c == '<' || c == '>') {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200197 l = snprintf(dst->area + dst->data, free, "&#%u;",
198 (unsigned char)c);
Willy Tarreauc7e42382012-08-24 19:22:53 +0200199
200 if (free < l) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200201 dst->data = olen;
202 return dst->data;
Willy Tarreauc7e42382012-08-24 19:22:53 +0200203 }
204
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200205 dst->data += l;
Willy Tarreauc7e42382012-08-24 19:22:53 +0200206 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200207 dst->area[dst->data] = c;
208 dst->data++;
Willy Tarreauc7e42382012-08-24 19:22:53 +0200209 }
210 }
211
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200212 return dst->data;
Willy Tarreauc7e42382012-08-24 19:22:53 +0200213}
214
215/*
216 * Encode chunk <src> into chunk <dst>, respecting the limit of at most
217 * chk->size chars. Replace non-printable or char passed in qc with "<%02X>".
218 * If the chk->len is over, nothing is added. Returns the new chunk size.
219 */
Willy Tarreau83061a82018-07-13 11:56:34 +0200220int chunk_asciiencode(struct buffer *dst, struct buffer *src, char qc)
Willy Tarreauc7e42382012-08-24 19:22:53 +0200221{
222 int i, l;
223 int olen, free;
224 char c;
225
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200226 olen = dst->data;
Willy Tarreauc7e42382012-08-24 19:22:53 +0200227
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200228 for (i = 0; i < src->data; i++) {
229 free = dst->size - dst->data;
Willy Tarreauc7e42382012-08-24 19:22:53 +0200230
231 if (!free) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200232 dst->data = olen;
233 return dst->data;
Willy Tarreauc7e42382012-08-24 19:22:53 +0200234 }
235
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200236 c = src->area[i];
Willy Tarreauc7e42382012-08-24 19:22:53 +0200237
Willy Tarreau90807112020-02-25 08:16:33 +0100238 if (!isascii((unsigned char)c) || !isprint((unsigned char)c) || c == '<' || c == '>' || c == qc) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200239 l = snprintf(dst->area + dst->data, free, "<%02X>",
240 (unsigned char)c);
Willy Tarreauc7e42382012-08-24 19:22:53 +0200241
242 if (free < l) {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200243 dst->data = olen;
244 return dst->data;
Willy Tarreauc7e42382012-08-24 19:22:53 +0200245 }
246
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200247 dst->data += l;
Willy Tarreauc7e42382012-08-24 19:22:53 +0200248 } else {
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200249 dst->area[dst->data] = c;
250 dst->data++;
Willy Tarreauc7e42382012-08-24 19:22:53 +0200251 }
252 }
253
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200254 return dst->data;
Willy Tarreauc7e42382012-08-24 19:22:53 +0200255}
256
Willy Tarreauad8f8e82012-10-19 15:18:06 +0200257/* Compares the string in chunk <chk> with the string in <str> which must be
258 * zero-terminated. Return is the same as with strcmp(). Neither is allowed
259 * to be null.
260 */
Willy Tarreau83061a82018-07-13 11:56:34 +0200261int chunk_strcmp(const struct buffer *chk, const char *str)
Willy Tarreauad8f8e82012-10-19 15:18:06 +0200262{
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200263 const char *s1 = chk->area;
264 int len = chk->data;
Willy Tarreauad8f8e82012-10-19 15:18:06 +0200265 int diff = 0;
266
267 do {
Emeric Brun78bd4032014-05-09 17:11:07 +0200268 if (--len < 0) {
269 diff = (unsigned char)0 - (unsigned char)*str;
Willy Tarreauad8f8e82012-10-19 15:18:06 +0200270 break;
Emeric Brun78bd4032014-05-09 17:11:07 +0200271 }
Willy Tarreauad8f8e82012-10-19 15:18:06 +0200272 diff = (unsigned char)*(s1++) - (unsigned char)*(str++);
273 } while (!diff);
274 return diff;
275}
276
277/* Case-insensitively compares the string in chunk <chk> with the string in
278 * <str> which must be zero-terminated. Return is the same as with strcmp().
279 * Neither is allowed to be null.
280 */
Willy Tarreau83061a82018-07-13 11:56:34 +0200281int chunk_strcasecmp(const struct buffer *chk, const char *str)
Willy Tarreauad8f8e82012-10-19 15:18:06 +0200282{
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200283 const char *s1 = chk->area;
284 int len = chk->data;
Willy Tarreauad8f8e82012-10-19 15:18:06 +0200285 int diff = 0;
286
287 do {
Emeric Brun78bd4032014-05-09 17:11:07 +0200288 if (--len < 0) {
289 diff = (unsigned char)0 - (unsigned char)*str;
Willy Tarreauad8f8e82012-10-19 15:18:06 +0200290 break;
Emeric Brun78bd4032014-05-09 17:11:07 +0200291 }
Willy Tarreauad8f8e82012-10-19 15:18:06 +0200292 diff = (unsigned char)*s1 - (unsigned char)*str;
293 if (unlikely(diff)) {
294 unsigned int l = (unsigned char)*s1;
295 unsigned int r = (unsigned char)*str;
296
297 l -= 'a';
298 r -= 'a';
299
300 if (likely(l <= (unsigned char)'z' - 'a'))
301 l -= 'a' - 'A';
302 if (likely(r <= (unsigned char)'z' - 'a'))
303 r -= 'a' - 'A';
304 diff = l - r;
305 }
306 s1++; str++;
307 } while (!diff);
308 return diff;
309}
Willy Tarreauc7e42382012-08-24 19:22:53 +0200310
Willy Tarreau082b6282019-05-22 14:42:12 +0200311REGISTER_PER_THREAD_ALLOC(alloc_trash_buffers_per_thread);
312REGISTER_PER_THREAD_FREE(free_trash_buffers_per_thread);
Willy Tarreau172f5ce2018-11-26 11:21:50 +0100313
Willy Tarreauc7e42382012-08-24 19:22:53 +0200314/*
315 * Local variables:
316 * c-indent-level: 8
317 * c-basic-offset: 8
318 * End:
319 */