blob: b083768e397170b22cde684c86c484cd450a4b55 [file] [log] [blame]
Willy Tarreauc7e42382012-08-24 19:22:53 +02001/*
2 * Buffer 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
William Lallemandbe0efd82012-11-22 18:01:40 +010013#include <ctype.h>
Willy Tarreauc7e42382012-08-24 19:22:53 +020014#include <stdio.h>
15#include <string.h>
16
17#include <common/config.h>
18#include <common/buffer.h>
Willy Tarreau9b28e032012-10-12 23:49:43 +020019#include <common/memory.h>
Willy Tarreauc7e42382012-08-24 19:22:53 +020020
21#include <types/global.h>
22
Willy Tarreau9b28e032012-10-12 23:49:43 +020023struct pool_head *pool2_buffer;
24
Willy Tarreauf2f7d6b2014-11-24 11:55:08 +010025/* These buffers are used to always have a valid pointer to an empty buffer in
26 * channels. The first buffer is set once a buffer is empty. The second one is
27 * set when a buffer is desired but no more are available. It helps knowing
28 * what channel wants a buffer. They can reliably be exchanged, the split
29 * between the two is only an optimization.
Willy Tarreau2a4b5432014-11-24 11:39:34 +010030 */
31struct buffer buf_empty = { .p = buf_empty.data };
Willy Tarreauf2f7d6b2014-11-24 11:55:08 +010032struct buffer buf_wanted = { .p = buf_wanted.data };
Willy Tarreau9b28e032012-10-12 23:49:43 +020033
34/* perform minimal intializations, report 0 in case of error, 1 if OK. */
35int init_buffer()
36{
Willy Tarreaua24adf02014-11-27 01:11:56 +010037 void *buffer;
38
Willy Tarreau9b28e032012-10-12 23:49:43 +020039 pool2_buffer = create_pool("buffer", sizeof (struct buffer) + global.tune.bufsize, MEM_F_SHARED);
Willy Tarreaua24adf02014-11-27 01:11:56 +010040 if (!pool2_buffer)
41 return 0;
42
43 /* The reserved buffer is what we leave behind us. Thus we always need
44 * at least one extra buffer in minavail otherwise we'll end up waking
45 * up tasks with no memory available, causing a lot of useless wakeups.
46 * That means that we always want to have at least 3 buffers available
47 * (2 for current session, one for next session that might be needed to
48 * release a server connection).
49 */
50 pool2_buffer->minavail = MAX(global.tune.reserved_bufs, 3);
Willy Tarreau33cb0652014-12-23 22:52:37 +010051 if (global.tune.buf_limit)
52 pool2_buffer->limit = global.tune.buf_limit;
Willy Tarreaua24adf02014-11-27 01:11:56 +010053
54 buffer = pool_refill_alloc(pool2_buffer, pool2_buffer->minavail - 1);
55 if (!buffer)
56 return 0;
57
58 pool_free2(pool2_buffer, buffer);
59 return 1;
Willy Tarreau9b28e032012-10-12 23:49:43 +020060}
61
Willy Tarreauaf819352012-08-27 22:08:00 +020062/* This function writes the string <str> at position <pos> which must be in
63 * buffer <b>, and moves <end> just after the end of <str>. <b>'s parameters
64 * <l> and <r> are updated to be valid after the shift. The shift value
65 * (positive or negative) is returned. If there's no space left, the move is
66 * not done. The function does not adjust ->o because it does not make sense to
67 * use it on data scheduled to be sent. For the same reason, it does not make
68 * sense to call this function on unparsed data, so <orig> is not updated. The
69 * string length is taken from parameter <len>. If <len> is null, the <str>
70 * pointer is allowed to be null.
71 */
72int buffer_replace2(struct buffer *b, char *pos, char *end, const char *str, int len)
73{
74 int delta;
75
76 delta = len - (end - pos);
77
Thierry FOURNIERfdda6772015-03-10 01:55:01 +010078 if (bi_end(b) + delta > b->data + b->size)
Willy Tarreauaf819352012-08-27 22:08:00 +020079 return 0; /* no space left */
80
81 if (buffer_not_empty(b) &&
82 bi_end(b) + delta > bo_ptr(b) &&
83 bo_ptr(b) >= bi_end(b))
84 return 0; /* no space left before wrapping data */
85
86 /* first, protect the end of the buffer */
87 memmove(end + delta, end, bi_end(b) - end);
88
89 /* now, copy str over pos */
90 if (len)
91 memcpy(pos, str, len);
92
93 b->i += delta;
94
Willy Tarreau5fb38032012-12-16 19:39:09 +010095 if (buffer_empty(b))
Willy Tarreauaf819352012-08-27 22:08:00 +020096 b->p = b->data;
97
98 return delta;
99}
100
101/*
102 * Inserts <str> followed by "\r\n" at position <pos> in buffer <b>. The <len>
103 * argument informs about the length of string <str> so that we don't have to
104 * measure it. It does not include the "\r\n". If <str> is NULL, then the buffer
105 * is only opened for len+2 bytes but nothing is copied in. It may be useful in
106 * some circumstances. The send limit is *not* adjusted. Same comments as above
107 * for the valid use cases.
108 *
109 * The number of bytes added is returned on success. 0 is returned on failure.
110 */
111int buffer_insert_line2(struct buffer *b, char *pos, const char *str, int len)
112{
113 int delta;
114
115 delta = len + 2;
116
117 if (bi_end(b) + delta >= b->data + b->size)
118 return 0; /* no space left */
119
Godbacha6547c12014-10-31 13:16:37 +0800120 if (buffer_not_empty(b) &&
121 bi_end(b) + delta > bo_ptr(b) &&
122 bo_ptr(b) >= bi_end(b))
123 return 0; /* no space left before wrapping data */
124
Willy Tarreauaf819352012-08-27 22:08:00 +0200125 /* first, protect the end of the buffer */
126 memmove(pos + delta, pos, bi_end(b) - pos);
127
128 /* now, copy str over pos */
129 if (len && str) {
130 memcpy(pos, str, len);
131 pos[len] = '\r';
132 pos[len + 1] = '\n';
133 }
134
135 b->i += delta;
136 return delta;
137}
138
Willy Tarreau27187ab2015-07-02 12:50:23 +0200139/* This function realigns a possibly wrapping buffer so that the input part is
140 * contiguous and starts at the beginning of the buffer and the output part
141 * ends at the end of the buffer. This provides the best conditions since it
142 * allows the largest inputs to be processed at once and ensures that once the
143 * output data leaves, the whole buffer is available at once.
Willy Tarreauc7e42382012-08-24 19:22:53 +0200144 */
145void buffer_slow_realign(struct buffer *buf)
146{
Willy Tarreau27187ab2015-07-02 12:50:23 +0200147 int block1 = buf->o;
148 int block2 = 0;
149
150 /* process output data in two steps to cover wrapping */
151 if (block1 > buf->p - buf->data) {
152 block2 = buf->p - buf->data;
153 block1 -= block2;
154 }
155 memcpy(swap_buffer + buf->size - buf->o, bo_ptr(buf), block1);
156 memcpy(swap_buffer + buf->size - block2, buf->data, block2);
157
158 /* process input data in two steps to cover wrapping */
159 block1 = buf->i;
160 block2 = 0;
161
162 if (block1 > buf->data + buf->size - buf->p) {
163 block1 = buf->data + buf->size - buf->p;
164 block2 = buf->i - block1;
Willy Tarreauc7e42382012-08-24 19:22:53 +0200165 }
Willy Tarreau27187ab2015-07-02 12:50:23 +0200166 memcpy(swap_buffer, bi_ptr(buf), block1);
167 memcpy(swap_buffer + block1, buf->data, block2);
168
169 /* reinject changes into the buffer */
170 memcpy(buf->data, swap_buffer, buf->i);
171 memcpy(buf->data + buf->size - buf->o, swap_buffer + buf->size - buf->o, buf->o);
Willy Tarreauc7e42382012-08-24 19:22:53 +0200172
173 buf->p = buf->data;
174}
175
176
177/* Realigns a possibly non-contiguous buffer by bouncing bytes from source to
178 * destination. It does not use any intermediate buffer and does the move in
179 * place, though it will be slower than a simple memmove() on contiguous data,
180 * so it's desirable to use it only on non-contiguous buffers. No pointers are
181 * changed, the caller is responsible for that.
182 */
183void buffer_bounce_realign(struct buffer *buf)
184{
185 int advance, to_move;
186 char *from, *to;
187
188 from = bo_ptr(buf);
189 advance = buf->data + buf->size - from;
190 if (!advance)
191 return;
192
193 to_move = buffer_len(buf);
194 while (to_move) {
195 char last, save;
196
197 last = *from;
198 to = from + advance;
199 if (to >= buf->data + buf->size)
200 to -= buf->size;
201
202 while (1) {
203 save = *to;
204 *to = last;
205 last = save;
206 to_move--;
207 if (!to_move)
208 break;
209
210 /* check if we went back home after rotating a number of bytes */
211 if (to == from)
212 break;
213
214 /* if we ended up in the empty area, let's walk to next place. The
215 * empty area is either between buf->r and from or before from or
216 * after buf->r.
217 */
218 if (from > bi_end(buf)) {
219 if (to >= bi_end(buf) && to < from)
220 break;
221 } else if (from < bi_end(buf)) {
222 if (to < from || to >= bi_end(buf))
223 break;
224 }
225
226 /* we have overwritten a byte of the original set, let's move it */
227 to += advance;
228 if (to >= buf->data + buf->size)
229 to -= buf->size;
230 }
231
232 from++;
233 if (from >= buf->data + buf->size)
234 from -= buf->size;
235 }
236}
237
238
239/*
240 * Dumps part or all of a buffer.
241 */
242void buffer_dump(FILE *o, struct buffer *b, int from, int to)
243{
244 fprintf(o, "Dumping buffer %p\n", b);
William Lallemandbe0efd82012-11-22 18:01:40 +0100245 fprintf(o, " data=%p o=%d i=%d p=%p\n"
246 " relative: p=0x%04x\n",
247 b->data, b->o, b->i, b->p, (unsigned int)(b->p - b->data));
Willy Tarreauc7e42382012-08-24 19:22:53 +0200248
249 fprintf(o, "Dumping contents from byte %d to byte %d\n", from, to);
William Lallemandbe0efd82012-11-22 18:01:40 +0100250 fprintf(o, " 0 1 2 3 4 5 6 7 8 9 a b c d e f\n");
251 /* dump hexa */
252 while (from < to) {
253 int i;
254
255 fprintf(o, " %04x: ", from);
256 for (i = 0; ((from + i) < to) && (i < 16) ; i++) {
257 fprintf(o, "%02x ", (unsigned char)b->data[from + i]);
258 if (((from + i) & 15) == 7)
259 fprintf(o, "- ");
260 }
Godbachc08057c2013-11-14 10:15:20 +0800261 if (to - from < 16) {
Godbachc3916a72013-11-21 10:21:22 +0800262 int j = 0;
263
Godbachc08057c2013-11-14 10:15:20 +0800264 for (j = 0; j < from + 16 - to; j++)
265 fprintf(o, " ");
Godbachc3916a72013-11-21 10:21:22 +0800266 if (j > 8)
267 fprintf(o, " ");
Godbachc08057c2013-11-14 10:15:20 +0800268 }
William Lallemandbe0efd82012-11-22 18:01:40 +0100269 fprintf(o, " ");
270 for (i = 0; (from + i < to) && (i < 16) ; i++) {
Willy Tarreau95898ac2012-11-26 00:57:40 +0100271 fprintf(o, "%c", isprint((int)b->data[from + i]) ? b->data[from + i] : '.') ;
William Lallemandbe0efd82012-11-22 18:01:40 +0100272 if ((((from + i) & 15) == 15) && ((from + i) != to-1))
273 fprintf(o, "\n");
274 }
275 from += i;
Willy Tarreauc7e42382012-08-24 19:22:53 +0200276 }
277 fprintf(o, "\n--\n");
William Lallemandbe0efd82012-11-22 18:01:40 +0100278 fflush(o);
Willy Tarreauc7e42382012-08-24 19:22:53 +0200279}
280
281
282/*
283 * Local variables:
284 * c-indent-level: 8
285 * c-basic-offset: 8
286 * End:
287 */