blob: e0d43e97902acf539efbbf7d6acf4d4d0ef894aa [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
Willy Tarreau7c3c5412009-12-13 15:53:05 +01002 * include/proto/buffers.h
3 * Buffer management definitions, macros and inline functions.
4 *
Willy Tarreau9dab5fc2012-05-07 11:56:55 +02005 * Copyright (C) 2000-2012 Willy Tarreau - w@1wt.eu
Willy Tarreau7c3c5412009-12-13 15:53:05 +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
22#ifndef _PROTO_BUFFERS_H
23#define _PROTO_BUFFERS_H
24
Willy Tarreau7341d942007-05-13 19:56:02 +020025#include <stdio.h>
Willy Tarreau0f772532006-12-23 20:51:41 +010026#include <stdlib.h>
Willy Tarreau7341d942007-05-13 19:56:02 +020027#include <string.h>
Willy Tarreau0f772532006-12-23 20:51:41 +010028
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020029#include <common/config.h>
Willy Tarreau7341d942007-05-13 19:56:02 +020030#include <common/memory.h>
Willy Tarreau0c303ee2008-07-07 00:09:58 +020031#include <common/ticks.h>
Willy Tarreaufa645582007-06-03 15:59:52 +020032#include <common/time.h>
33
Willy Tarreaubaaee002006-06-26 02:48:02 +020034#include <types/buffers.h>
Willy Tarreau7c3c5412009-12-13 15:53:05 +010035#include <types/global.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020036
Willy Tarreau7341d942007-05-13 19:56:02 +020037extern struct pool_head *pool2_buffer;
38
39/* perform minimal intializations, report 0 in case of error, 1 if OK. */
40int init_buffer();
41
Willy Tarreau74b08c92010-09-08 17:04:31 +020042/* SI-to-buffer functions : buffer_{get,put}_{char,block,string,chunk} */
Willy Tarreau7421efb2012-07-02 15:11:27 +020043int bo_inject(struct channel *buf, const char *msg, int len);
44int bi_putblk(struct channel *buf, const char *str, int len);
45int bi_putchr(struct channel *buf, char c);
46int bo_getline(struct channel *buf, char *str, int len);
47int bo_getblk(struct channel *buf, char *blk, int len, int offset);
48int buffer_replace2(struct channel *b, char *pos, char *end, const char *str, int len);
49int buffer_insert_line2(struct channel *b, char *pos, const char *str, int len);
Willy Tarreau572bf902012-07-02 17:01:20 +020050void buffer_dump(FILE *o, struct buffer *b, int from, int to);
51void buffer_slow_realign(struct buffer *buf);
52void buffer_bounce_realign(struct buffer *buf);
Willy Tarreau7421efb2012-07-02 15:11:27 +020053unsigned long long buffer_forward(struct channel *buf, unsigned long long bytes);
Willy Tarreau74b08c92010-09-08 17:04:31 +020054
Willy Tarreau7c3c5412009-12-13 15:53:05 +010055/* Initialize all fields in the buffer. The BF_OUT_EMPTY flags is set. */
Willy Tarreau7421efb2012-07-02 15:11:27 +020056static inline void buffer_init(struct channel *buf)
Willy Tarreau54469402006-07-29 16:59:06 +020057{
Willy Tarreau572bf902012-07-02 17:01:20 +020058 buf->buf.o = 0;
59 buf->buf.i = 0;
60 buf->buf.p = buf->buf.data;
Willy Tarreau6b66f3e2008-12-14 17:31:54 +010061 buf->to_forward = 0;
Willy Tarreau02d6cfc2012-03-01 18:19:58 +010062 buf->total = 0;
Willy Tarreau3eba98a2009-01-25 13:56:13 +010063 buf->pipe = NULL;
Willy Tarreau2df28e82008-08-17 15:20:19 +020064 buf->analysers = 0;
Willy Tarreaufa7e1022008-10-19 07:30:41 +020065 buf->cons = NULL;
Willy Tarreauba0b63d2009-09-20 08:09:44 +020066 buf->flags = BF_OUT_EMPTY;
Willy Tarreau54469402006-07-29 16:59:06 +020067}
68
Willy Tarreau4b517ca2011-11-25 20:33:58 +010069/*****************************************************************/
70/* These functions are used to compute various buffer area sizes */
71/*****************************************************************/
72
Willy Tarreaucc5cfcb2012-05-04 21:35:27 +020073/* Returns an absolute pointer for a position relative to the current buffer's
74 * pointer. It is written so that it is optimal when <ofs> is a const. It is
75 * written as a macro instead of an inline function so that the compiler knows
76 * when it can optimize out the sign test on <ofs> when passed an unsigned int.
77 */
78#define b_ptr(b, ofs) \
79 ({ \
80 char *__ret = (b)->p + (ofs); \
81 if ((ofs) > 0 && __ret >= (b)->data + (b)->size) \
82 __ret -= (b)->size; \
83 else if ((ofs) < 0 && __ret < (b)->data) \
84 __ret += (b)->size; \
85 __ret; \
86 })
87
88/* Returns the start of the input data in a buffer */
Willy Tarreau572bf902012-07-02 17:01:20 +020089static inline char *bi_ptr(const struct buffer *b)
Willy Tarreaucc5cfcb2012-05-04 21:35:27 +020090{
91 return b->p;
92}
93
94/* Returns the end of the input data in a buffer (pointer to next
95 * insertion point).
96 */
Willy Tarreau572bf902012-07-02 17:01:20 +020097static inline char *bi_end(const struct buffer *b)
Willy Tarreaucc5cfcb2012-05-04 21:35:27 +020098{
99 char *ret = b->p + b->i;
100
101 if (ret >= b->data + b->size)
102 ret -= b->size;
103 return ret;
104}
105
106/* Returns the amount of input data that can contiguously be read at once */
Willy Tarreau572bf902012-07-02 17:01:20 +0200107static inline int bi_contig_data(const struct buffer *b)
Willy Tarreaucc5cfcb2012-05-04 21:35:27 +0200108{
109 int data = b->data + b->size - b->p;
110
111 if (data > b->i)
112 data = b->i;
113 return data;
114}
115
116/* Returns the start of the output data in a buffer */
Willy Tarreau572bf902012-07-02 17:01:20 +0200117static inline char *bo_ptr(const struct buffer *b)
Willy Tarreaucc5cfcb2012-05-04 21:35:27 +0200118{
119 char *ret = b->p - b->o;
120
121 if (ret < b->data)
122 ret += b->size;
123 return ret;
124}
125
126/* Returns the end of the output data in a buffer */
Willy Tarreau572bf902012-07-02 17:01:20 +0200127static inline char *bo_end(const struct buffer *b)
Willy Tarreaucc5cfcb2012-05-04 21:35:27 +0200128{
129 return b->p;
130}
131
132/* Returns the amount of output data that can contiguously be read at once */
Willy Tarreau572bf902012-07-02 17:01:20 +0200133static inline int bo_contig_data(const struct buffer *b)
Willy Tarreaucc5cfcb2012-05-04 21:35:27 +0200134{
135 char *beg = b->p - b->o;
136
137 if (beg < b->data)
138 return b->data - beg;
139 return b->o;
140}
141
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100142/* Return the buffer's length in bytes by summing the input and the output */
Willy Tarreau572bf902012-07-02 17:01:20 +0200143static inline int buffer_len(const struct buffer *buf)
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100144{
145 return buf->i + buf->o;
146}
147
148/* Return non-zero only if the buffer is not empty */
Willy Tarreau572bf902012-07-02 17:01:20 +0200149static inline int buffer_not_empty(const struct buffer *buf)
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100150{
151 return buf->i | buf->o;
152}
153
154/* Return non-zero only if the buffer is empty */
Willy Tarreau572bf902012-07-02 17:01:20 +0200155static inline int buffer_empty(const struct buffer *buf)
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100156{
157 return !buffer_not_empty(buf);
158}
159
Willy Tarreau7fd758b2012-03-02 10:38:01 +0100160/* Normalizes a pointer after a subtract */
Willy Tarreau572bf902012-07-02 17:01:20 +0200161static inline char *buffer_wrap_sub(const struct buffer *buf, char *ptr)
Willy Tarreau7fd758b2012-03-02 10:38:01 +0100162{
163 if (ptr < buf->data)
164 ptr += buf->size;
165 return ptr;
166}
167
168/* Normalizes a pointer after an addition */
Willy Tarreau572bf902012-07-02 17:01:20 +0200169static inline char *buffer_wrap_add(const struct buffer *buf, char *ptr)
Willy Tarreau7fd758b2012-03-02 10:38:01 +0100170{
171 if (ptr - buf->size >= buf->data)
172 ptr -= buf->size;
173 return ptr;
174}
175
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100176/* Return the number of reserved bytes in the buffer, which ensures that once
177 * all pending data are forwarded, the buffer still has global.tune.maxrewrite
178 * bytes free. The result is between 0 and global.maxrewrite, which is itself
179 * smaller than any buf->size.
180 */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200181static inline int buffer_reserved(const struct channel *buf)
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100182{
Willy Tarreau572bf902012-07-02 17:01:20 +0200183 int ret = global.tune.maxrewrite - buf->to_forward - buf->buf.o;
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100184
185 if (buf->to_forward == BUF_INFINITE_FORWARD)
186 return 0;
187 if (ret <= 0)
188 return 0;
189 return ret;
190}
191
Willy Tarreau7c3c5412009-12-13 15:53:05 +0100192/* Return the max number of bytes the buffer can contain so that once all the
193 * pending bytes are forwarded, the buffer still has global.tune.maxrewrite
194 * bytes free. The result sits between buf->size - maxrewrite and buf->size.
195 */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200196static inline int buffer_max_len(const struct channel *buf)
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100197{
Willy Tarreau572bf902012-07-02 17:01:20 +0200198 return buf->buf.size - buffer_reserved(buf);
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100199}
200
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200201/* Returns non-zero if the buffer input is considered full. The reserved space
202 * is taken into account if ->to_forward indicates that an end of transfer is
203 * close to happen. The test is optimized to avoid as many operations as
204 * possible for the fast case and to be used as an "if" condition.
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100205 */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200206static inline int bi_full(const struct channel *b)
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100207{
Willy Tarreau572bf902012-07-02 17:01:20 +0200208 int rem = b->buf.size;
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200209
Willy Tarreau572bf902012-07-02 17:01:20 +0200210 rem -= b->buf.o;
211 rem -= b->buf.i;
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200212 if (!rem)
213 return 1; /* buffer already full */
214
Willy Tarreau572bf902012-07-02 17:01:20 +0200215 if (b->to_forward >= b->buf.size ||
216 (BUF_INFINITE_FORWARD < MAX_RANGE(typeof(b->buf.size)) && // just there to ensure gcc
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200217 b->to_forward == BUF_INFINITE_FORWARD)) // avoids the useless second
218 return 0; // test whenever possible
219
220 rem -= global.tune.maxrewrite;
Willy Tarreau572bf902012-07-02 17:01:20 +0200221 rem += b->buf.o;
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200222 rem += b->to_forward;
223 return rem <= 0;
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100224}
225
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200226/* Returns the amount of space available at the input of the buffer, taking the
227 * reserved space into account if ->to_forward indicates that an end of transfer
228 * is close to happen. The test is optimized to avoid as many operations as
229 * possible for the fast case.
230 */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200231static inline int bi_avail(const struct channel *b)
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200232{
Willy Tarreau572bf902012-07-02 17:01:20 +0200233 int rem = b->buf.size;
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200234 int rem2;
235
Willy Tarreau572bf902012-07-02 17:01:20 +0200236 rem -= b->buf.o;
237 rem -= b->buf.i;
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200238 if (!rem)
239 return rem; /* buffer already full */
240
Willy Tarreau572bf902012-07-02 17:01:20 +0200241 if (b->to_forward >= b->buf.size ||
242 (BUF_INFINITE_FORWARD < MAX_RANGE(typeof(b->buf.size)) && // just there to ensure gcc
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200243 b->to_forward == BUF_INFINITE_FORWARD)) // avoids the useless second
244 return rem; // test whenever possible
245
246 rem2 = rem - global.tune.maxrewrite;
Willy Tarreau572bf902012-07-02 17:01:20 +0200247 rem2 += b->buf.o;
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200248 rem2 += b->to_forward;
249
250 if (rem > rem2)
251 rem = rem2;
252 if (rem > 0)
253 return rem;
254 return 0;
255}
256
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100257/* Return the maximum amount of bytes that can be written into the buffer,
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200258 * including reserved space which may be overwritten.
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100259 */
Willy Tarreau572bf902012-07-02 17:01:20 +0200260static inline int buffer_total_space(const struct buffer *buf)
Willy Tarreau7c3c5412009-12-13 15:53:05 +0100261{
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200262 return buf->size - buffer_len(buf);
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100263}
264
265/* Returns the number of contiguous bytes between <start> and <start>+<count>,
266 * and enforces a limit on buf->data + buf->size. <start> must be within the
267 * buffer.
268 */
Willy Tarreau572bf902012-07-02 17:01:20 +0200269static inline int buffer_contig_area(const struct buffer *buf, const char *start, int count)
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100270{
271 if (count > buf->data - start + buf->size)
272 count = buf->data - start + buf->size;
273 return count;
274}
275
276/* Return the amount of bytes that can be written into the buffer at once,
Willy Tarreau363a5bb2012-03-02 20:14:45 +0100277 * including reserved space which may be overwritten.
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100278 */
Willy Tarreau572bf902012-07-02 17:01:20 +0200279static inline int buffer_contig_space(const struct buffer *buf)
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100280{
Willy Tarreau363a5bb2012-03-02 20:14:45 +0100281 const char *left, *right;
282
283 if (buf->data + buf->o <= buf->p)
284 right = buf->data + buf->size;
285 else
286 right = buf->p + buf->size - buf->o;
287
288 left = buffer_wrap_add(buf, buf->p + buf->i);
289 return right - left;
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100290}
291
Willy Tarreau328582c2012-05-05 23:32:27 +0200292/* Advances the buffer by <adv> bytes, which means that the buffer
293 * pointer advances, and that as many bytes from in are transferred
294 * to out. The caller is responsible for ensuring that adv is always
295 * smaller than or equal to b->i. The BF_OUT_EMPTY flag is updated.
296 */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200297static inline void b_adv(struct channel *b, unsigned int adv)
Willy Tarreau328582c2012-05-05 23:32:27 +0200298{
Willy Tarreau572bf902012-07-02 17:01:20 +0200299 b->buf.i -= adv;
300 b->buf.o += adv;
301 if (b->buf.o)
Willy Tarreau328582c2012-05-05 23:32:27 +0200302 b->flags &= ~BF_OUT_EMPTY;
Willy Tarreau572bf902012-07-02 17:01:20 +0200303 b->buf.p = b_ptr(&b->buf, adv);
Willy Tarreau328582c2012-05-05 23:32:27 +0200304}
Willy Tarreau363a5bb2012-03-02 20:14:45 +0100305
Willy Tarreau13e66da2012-05-18 22:11:27 +0200306/* Rewinds the buffer by <adv> bytes, which means that the buffer pointer goes
307 * backwards, and that as many bytes from out are moved to in. The caller is
308 * responsible for ensuring that adv is always smaller than or equal to b->o.
309 */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200310static inline void b_rew(struct channel *b, unsigned int adv)
Willy Tarreau13e66da2012-05-18 22:11:27 +0200311{
Willy Tarreau572bf902012-07-02 17:01:20 +0200312 b->buf.i += adv;
313 b->buf.o -= adv;
314 if (!b->buf.o && !b->pipe)
Willy Tarreau13e66da2012-05-18 22:11:27 +0200315 b->flags |= BF_OUT_EMPTY;
Willy Tarreau572bf902012-07-02 17:01:20 +0200316 b->buf.p = b_ptr(&b->buf, (int)-adv);
Willy Tarreau13e66da2012-05-18 22:11:27 +0200317}
318
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100319/* Return the amount of bytes that can be written into the buffer at once,
Willy Tarreau363a5bb2012-03-02 20:14:45 +0100320 * excluding the amount of reserved space passed in <res>, which is
321 * preserved.
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100322 */
Willy Tarreau572bf902012-07-02 17:01:20 +0200323static inline int buffer_contig_space_with_res(const struct buffer *buf, int res)
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100324{
325 /* Proceed differently if the buffer is full, partially used or empty.
326 * The hard situation is when it's partially used and either data or
327 * reserved space wraps at the end.
328 */
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100329 int spare = buf->size - res;
330
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100331 if (buffer_len(buf) >= spare)
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100332 spare = 0;
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100333 else if (buffer_len(buf)) {
Willy Tarreau363a5bb2012-03-02 20:14:45 +0100334 spare = buffer_contig_space(buf) - res;
335 if (spare < 0)
336 spare = 0;
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100337 }
338 return spare;
339}
340
Willy Tarreau363a5bb2012-03-02 20:14:45 +0100341
342/* Return the amount of bytes that can be written into the buffer at once,
343 * excluding reserved space, which is preserved.
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100344 */
Willy Tarreau572bf902012-07-02 17:01:20 +0200345static inline int buffer_contig_space_res(const struct channel *chn)
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100346{
Willy Tarreau572bf902012-07-02 17:01:20 +0200347 return buffer_contig_space_with_res(&chn->buf, buffer_reserved(chn));
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100348}
349
350/* Normalizes a pointer which is supposed to be relative to the beginning of a
351 * buffer, so that wrapping is correctly handled. The intent is to use this
352 * when increasing a pointer. Note that the wrapping test is only performed
Willy Tarreau71730252011-11-28 16:04:29 +0100353 * once, so the original pointer must be between ->data-size and ->data+2*size-1,
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100354 * otherwise an invalid pointer might be returned.
355 */
Willy Tarreau572bf902012-07-02 17:01:20 +0200356static inline const char *buffer_pointer(const struct buffer *buf, const char *ptr)
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100357{
Willy Tarreau71730252011-11-28 16:04:29 +0100358 if (ptr < buf->data)
359 ptr += buf->size;
360 else if (ptr - buf->size >= buf->data)
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100361 ptr -= buf->size;
362 return ptr;
363}
364
365/* Returns the distance between two pointers, taking into account the ability
366 * to wrap around the buffer's end.
367 */
Willy Tarreau572bf902012-07-02 17:01:20 +0200368static inline int buffer_count(const struct buffer *buf, const char *from, const char *to)
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100369{
370 int count = to - from;
371 if (count < 0)
372 count += buf->size;
373 return count;
374}
375
376/* returns the amount of pending bytes in the buffer. It is the amount of bytes
377 * that is not scheduled to be sent.
378 */
Willy Tarreau572bf902012-07-02 17:01:20 +0200379static inline int buffer_pending(const struct buffer *buf)
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100380{
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100381 return buf->i;
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100382}
383
384/* Returns the size of the working area which the caller knows ends at <end>.
385 * If <end> equals buf->r (modulo size), then it means that the free area which
386 * follows is part of the working area. Otherwise, the working area stops at
Willy Tarreau89fa7062012-03-02 16:13:16 +0100387 * <end>. It always starts at buf->p. The work area includes the
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100388 * reserved area.
389 */
Willy Tarreau572bf902012-07-02 17:01:20 +0200390static inline int buffer_work_area(const struct buffer *buf, const char *end)
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100391{
392 end = buffer_pointer(buf, end);
Willy Tarreau363a5bb2012-03-02 20:14:45 +0100393 if (end == buffer_wrap_add(buf, buf->p + buf->i))
394 /* pointer exactly at end, lets push forwards */
Willy Tarreau89fa7062012-03-02 16:13:16 +0100395 end = buffer_wrap_sub(buf, buf->p - buf->o);
396 return buffer_count(buf, buf->p, end);
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100397}
398
399/* Return 1 if the buffer has less than 1/4 of its capacity free, otherwise 0 */
Willy Tarreau572bf902012-07-02 17:01:20 +0200400static inline int buffer_almost_full(const struct buffer *buf)
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100401{
402 if (buffer_total_space(buf) < buf->size / 4)
403 return 1;
404 return 0;
405}
406
Willy Tarreau74b08c92010-09-08 17:04:31 +0200407/* Returns true if the buffer's input is already closed */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200408static inline int buffer_input_closed(struct channel *buf)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200409{
410 return ((buf->flags & BF_SHUTR) != 0);
411}
412
413/* Returns true if the buffer's output is already closed */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200414static inline int buffer_output_closed(struct channel *buf)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200415{
416 return ((buf->flags & BF_SHUTW) != 0);
417}
418
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200419/* Check buffer timeouts, and set the corresponding flags. The
420 * likely/unlikely have been optimized for fastest normal path.
Willy Tarreaudd80c6f2008-12-13 22:25:59 +0100421 * The read/write timeouts are not set if there was activity on the buffer.
422 * That way, we don't have to update the timeout on every I/O. Note that the
423 * analyser timeout is always checked.
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200424 */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200425static inline void buffer_check_timeouts(struct channel *b)
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200426{
Willy Tarreau86491c32008-12-14 09:04:47 +0100427 if (likely(!(b->flags & (BF_SHUTR|BF_READ_TIMEOUT|BF_READ_ACTIVITY|BF_READ_NOEXP))) &&
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200428 unlikely(tick_is_expired(b->rex, now_ms)))
429 b->flags |= BF_READ_TIMEOUT;
430
Willy Tarreaudd80c6f2008-12-13 22:25:59 +0100431 if (likely(!(b->flags & (BF_SHUTW|BF_WRITE_TIMEOUT|BF_WRITE_ACTIVITY))) &&
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200432 unlikely(tick_is_expired(b->wex, now_ms)))
433 b->flags |= BF_WRITE_TIMEOUT;
434
435 if (likely(!(b->flags & BF_ANA_TIMEOUT)) &&
436 unlikely(tick_is_expired(b->analyse_exp, now_ms)))
437 b->flags |= BF_ANA_TIMEOUT;
438}
439
Willy Tarreau2e046c62012-03-01 16:08:30 +0100440/* Schedule all remaining buffer data to be sent. ->o is not touched if it
Willy Tarreaue8a28bf2009-03-08 21:12:04 +0100441 * already covers those data. That permits doing a flush even after a forward,
442 * although not recommended.
443 */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200444static inline void buffer_flush(struct channel *buf)
Willy Tarreaue8a28bf2009-03-08 21:12:04 +0100445{
Willy Tarreau572bf902012-07-02 17:01:20 +0200446 buf->buf.p = buffer_wrap_add(&buf->buf, buf->buf.p + buf->buf.i);
447 buf->buf.o += buf->buf.i;
448 buf->buf.i = 0;
449 if (buf->buf.o)
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200450 buf->flags &= ~BF_OUT_EMPTY;
Willy Tarreaue8a28bf2009-03-08 21:12:04 +0100451}
452
Willy Tarreau6f0aa472009-03-08 20:33:29 +0100453/* Erase any content from buffer <buf> and adjusts flags accordingly. Note
Willy Tarreau0abebcc2009-01-08 00:09:41 +0100454 * that any spliced data is not affected since we may not have any access to
455 * it.
Willy Tarreaue393fe22008-08-16 22:18:07 +0200456 */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200457static inline void buffer_erase(struct channel *buf)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200458{
Willy Tarreau572bf902012-07-02 17:01:20 +0200459 buf->buf.o = 0;
460 buf->buf.i = 0;
Willy Tarreau6b66f3e2008-12-14 17:31:54 +0100461 buf->to_forward = 0;
Willy Tarreau572bf902012-07-02 17:01:20 +0200462 buf->buf.p = buf->buf.data;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200463 buf->flags &= ~(BF_FULL | BF_OUT_EMPTY);
464 if (!buf->pipe)
465 buf->flags |= BF_OUT_EMPTY;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200466}
467
Willy Tarreau9cb8daa2009-09-15 21:22:24 +0200468/* Cut the "tail" of the buffer, which means strip it to the length of unsent
469 * data only, and kill any remaining unsent data. Any scheduled forwarding is
470 * stopped. This is mainly to be used to send error messages after existing
471 * data.
472 */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200473static inline void bi_erase(struct channel *buf)
Willy Tarreau9cb8daa2009-09-15 21:22:24 +0200474{
Willy Tarreau572bf902012-07-02 17:01:20 +0200475 if (!buf->buf.o)
Willy Tarreau9cb8daa2009-09-15 21:22:24 +0200476 return buffer_erase(buf);
477
478 buf->to_forward = 0;
Willy Tarreau572bf902012-07-02 17:01:20 +0200479 if (!buf->buf.i)
Willy Tarreau9cb8daa2009-09-15 21:22:24 +0200480 return;
481
Willy Tarreau572bf902012-07-02 17:01:20 +0200482 buf->buf.i = 0;
Willy Tarreauba0b63d2009-09-20 08:09:44 +0200483 buf->flags &= ~BF_FULL;
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200484 if (bi_full(buf))
Willy Tarreau9cb8daa2009-09-15 21:22:24 +0200485 buf->flags |= BF_FULL;
486}
487
Willy Tarreauec1bc822012-03-09 15:03:30 +0100488/* Cut the first <n> pending bytes in a contiguous buffer. It is illegal to
489 * call this function with remaining data waiting to be sent (o > 0). The
490 * caller must ensure that <n> is smaller than the actual buffer's length.
491 * This is mainly used to remove empty lines at the beginning of a request
492 * or a response.
Willy Tarreaud21e01c2009-12-27 15:45:38 +0100493 */
Willy Tarreau572bf902012-07-02 17:01:20 +0200494static inline void bi_fast_delete(struct buffer *buf, int n)
Willy Tarreaud21e01c2009-12-27 15:45:38 +0100495{
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100496 buf->i -= n;
Willy Tarreauec1bc822012-03-09 15:03:30 +0100497 buf->p += n;
Willy Tarreaud21e01c2009-12-27 15:45:38 +0100498}
499
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200500/* marks the buffer as "shutdown" ASAP for reads */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200501static inline void buffer_shutr_now(struct channel *buf)
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200502{
Willy Tarreaufe3718a2008-11-30 18:14:12 +0100503 buf->flags |= BF_SHUTR_NOW;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200504}
505
506/* marks the buffer as "shutdown" ASAP for writes */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200507static inline void buffer_shutw_now(struct channel *buf)
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200508{
509 buf->flags |= BF_SHUTW_NOW;
510}
511
512/* marks the buffer as "shutdown" ASAP in both directions */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200513static inline void buffer_abort(struct channel *buf)
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200514{
Willy Tarreaufe3718a2008-11-30 18:14:12 +0100515 buf->flags |= BF_SHUTR_NOW | BF_SHUTW_NOW;
Willy Tarreaue4599762010-03-21 23:25:09 +0100516 buf->flags &= ~BF_AUTO_CONNECT;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200517}
518
Willy Tarreau01bf8672008-12-07 18:03:29 +0100519/* Installs <func> as a hijacker on the buffer <b> for session <s>. The hijack
520 * flag is set, and the function called once. The function is responsible for
521 * clearing the hijack bit. It is possible that the function clears the flag
522 * during this first call.
523 */
524static inline void buffer_install_hijacker(struct session *s,
Willy Tarreau7421efb2012-07-02 15:11:27 +0200525 struct channel *b,
526 void (*func)(struct session *, struct channel *))
Willy Tarreau72b179a2008-08-28 16:01:32 +0200527{
Willy Tarreau01bf8672008-12-07 18:03:29 +0100528 b->hijacker = func;
529 b->flags |= BF_HIJACK;
530 func(s, b);
Willy Tarreau72b179a2008-08-28 16:01:32 +0200531}
532
Willy Tarreau01bf8672008-12-07 18:03:29 +0100533/* Releases the buffer from hijacking mode. Often used by the hijack function */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200534static inline void buffer_stop_hijack(struct channel *buf)
Willy Tarreau72b179a2008-08-28 16:01:32 +0200535{
536 buf->flags &= ~BF_HIJACK;
537}
538
Willy Tarreau520d95e2009-09-19 21:04:57 +0200539/* allow the consumer to try to establish a new connection. */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200540static inline void buffer_auto_connect(struct channel *buf)
Willy Tarreau3da77c52008-08-29 09:58:42 +0200541{
Willy Tarreau520d95e2009-09-19 21:04:57 +0200542 buf->flags |= BF_AUTO_CONNECT;
Willy Tarreau3da77c52008-08-29 09:58:42 +0200543}
544
Willy Tarreau520d95e2009-09-19 21:04:57 +0200545/* prevent the consumer from trying to establish a new connection, and also
546 * disable auto shutdown forwarding.
547 */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200548static inline void buffer_dont_connect(struct channel *buf)
Willy Tarreau3da77c52008-08-29 09:58:42 +0200549{
Willy Tarreau520d95e2009-09-19 21:04:57 +0200550 buf->flags &= ~(BF_AUTO_CONNECT|BF_AUTO_CLOSE);
Willy Tarreau3da77c52008-08-29 09:58:42 +0200551}
552
Willy Tarreau520d95e2009-09-19 21:04:57 +0200553/* allow the producer to forward shutdown requests */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200554static inline void buffer_auto_close(struct channel *buf)
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100555{
Willy Tarreau520d95e2009-09-19 21:04:57 +0200556 buf->flags |= BF_AUTO_CLOSE;
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100557}
558
Willy Tarreau520d95e2009-09-19 21:04:57 +0200559/* prevent the producer from forwarding shutdown requests */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200560static inline void buffer_dont_close(struct channel *buf)
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100561{
Willy Tarreau520d95e2009-09-19 21:04:57 +0200562 buf->flags &= ~BF_AUTO_CLOSE;
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100563}
564
Willy Tarreau90deb182010-01-07 00:20:41 +0100565/* allow the producer to read / poll the input */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200566static inline void buffer_auto_read(struct channel *buf)
Willy Tarreau90deb182010-01-07 00:20:41 +0100567{
568 buf->flags &= ~BF_DONT_READ;
569}
570
571/* prevent the producer from read / poll the input */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200572static inline void buffer_dont_read(struct channel *buf)
Willy Tarreau90deb182010-01-07 00:20:41 +0100573{
574 buf->flags |= BF_DONT_READ;
575}
576
Willy Tarreaubaaee002006-06-26 02:48:02 +0200577/*
578 * Tries to realign the given buffer, and returns how many bytes can be written
579 * there at once without overwriting anything.
580 */
Willy Tarreau572bf902012-07-02 17:01:20 +0200581static inline int buffer_realign(struct buffer *buf)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200582{
Willy Tarreau02d6cfc2012-03-01 18:19:58 +0100583 if (!(buf->i | buf->o)) {
Willy Tarreaubaaee002006-06-26 02:48:02 +0200584 /* let's realign the buffer to optimize I/O */
Willy Tarreaua458b672012-03-05 11:17:50 +0100585 buf->p = buf->data;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200586 }
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100587 return buffer_contig_space(buf);
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200588}
589
590/*
591 * Advance the buffer's read pointer by <len> bytes. This is useful when data
592 * have been read directly from the buffer. It is illegal to call this function
593 * with <len> causing a wrapping at the end of the buffer. It's the caller's
Willy Tarreau2e046c62012-03-01 16:08:30 +0100594 * responsibility to ensure that <len> is never larger than buf->o.
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200595 */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200596static inline void bo_skip(struct channel *buf, int len)
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200597{
Willy Tarreau572bf902012-07-02 17:01:20 +0200598 buf->buf.o -= len;
599 if (!buf->buf.o && !buf->pipe)
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200600 buf->flags |= BF_OUT_EMPTY;
601
Willy Tarreau572bf902012-07-02 17:01:20 +0200602 if (buffer_len(&buf->buf) == 0)
603 buf->buf.p = buf->buf.data;
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200604
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200605 if (!bi_full(buf))
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200606 buf->flags &= ~BF_FULL;
607
Willy Tarreaufb0e9202009-09-23 23:47:55 +0200608 /* notify that some data was written to the SI from the buffer */
609 buf->flags |= BF_WRITE_PARTIAL;
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200610}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200611
Willy Tarreau74b08c92010-09-08 17:04:31 +0200612/* Tries to copy chunk <chunk> into buffer <buf> after length controls.
Willy Tarreau2e046c62012-03-01 16:08:30 +0100613 * The ->o and to_forward pointers are updated. If the buffer's input is
Willy Tarreau74b08c92010-09-08 17:04:31 +0200614 * closed, -2 is returned. If the block is too large for this buffer, -3 is
615 * returned. If there is not enough room left in the buffer, -1 is returned.
616 * Otherwise the number of bytes copied is returned (0 being a valid number).
617 * Buffer flags FULL, EMPTY and READ_PARTIAL are updated if some data can be
618 * transferred. The chunk's length is updated with the number of bytes sent.
Willy Tarreauaeac3192009-08-31 08:09:57 +0200619 */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200620static inline int bi_putchk(struct channel *buf, struct chunk *chunk)
Willy Tarreauaeac3192009-08-31 08:09:57 +0200621{
622 int ret;
623
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200624 ret = bi_putblk(buf, chunk->str, chunk->len);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200625 if (ret > 0)
626 chunk->len -= ret;
Willy Tarreauaeac3192009-08-31 08:09:57 +0200627 return ret;
628}
629
Willy Tarreau74b08c92010-09-08 17:04:31 +0200630/* Tries to copy string <str> at once into buffer <buf> after length controls.
Willy Tarreau2e046c62012-03-01 16:08:30 +0100631 * The ->o and to_forward pointers are updated. If the buffer's input is
Willy Tarreau74b08c92010-09-08 17:04:31 +0200632 * closed, -2 is returned. If the block is too large for this buffer, -3 is
633 * returned. If there is not enough room left in the buffer, -1 is returned.
634 * Otherwise the number of bytes copied is returned (0 being a valid number).
635 * Buffer flags FULL, EMPTY and READ_PARTIAL are updated if some data can be
636 * transferred.
637 */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200638static inline int bi_putstr(struct channel *buf, const char *str)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200639{
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200640 return bi_putblk(buf, str, strlen(str));
Willy Tarreau74b08c92010-09-08 17:04:31 +0200641}
642
643/*
644 * Return one char from the buffer. If the buffer is empty and closed, return -2.
645 * If the buffer is just empty, return -1. The buffer's pointer is not advanced,
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200646 * it's up to the caller to call bo_skip(buf, 1) when it has consumed the char.
Willy Tarreau2e046c62012-03-01 16:08:30 +0100647 * Also note that this function respects the ->o limit.
Willy Tarreau74b08c92010-09-08 17:04:31 +0200648 */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200649static inline int bo_getchr(struct channel *buf)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200650{
651 /* closed or empty + imminent close = -2; empty = -1 */
652 if (unlikely(buf->flags & (BF_OUT_EMPTY|BF_SHUTW))) {
653 if (buf->flags & (BF_SHUTW|BF_SHUTW_NOW))
654 return -2;
655 return -1;
656 }
Willy Tarreau572bf902012-07-02 17:01:20 +0200657 return *buffer_wrap_sub(&buf->buf, buf->buf.p - buf->buf.o);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200658}
659
Willy Tarreau19ae56b2011-11-28 10:36:13 +0100660/* This function writes the string <str> at position <pos> which must be in
661 * buffer <b>, and moves <end> just after the end of <str>. <b>'s parameters
662 * (l, r, lr) are updated to be valid after the shift. the shift value
663 * (positive or negative) is returned. If there's no space left, the move is
Willy Tarreau2e046c62012-03-01 16:08:30 +0100664 * not done. The function does not adjust ->o nor BF_OUT_EMPTY because
Willy Tarreau19ae56b2011-11-28 10:36:13 +0100665 * it does not make sense to use it on data scheduled to be sent.
666 */
Willy Tarreau7421efb2012-07-02 15:11:27 +0200667static inline int buffer_replace(struct channel *b, char *pos, char *end, const char *str)
Willy Tarreau19ae56b2011-11-28 10:36:13 +0100668{
669 return buffer_replace2(b, pos, end, str, strlen(str));
670}
671
Willy Tarreau74b08c92010-09-08 17:04:31 +0200672/*
673 *
674 * Functions below are used to manage chunks
675 *
676 */
677
Krzysztof Piotr Oledzki78abe612009-09-27 13:23:20 +0200678static inline void chunk_init(struct chunk *chk, char *str, size_t size) {
679 chk->str = str;
680 chk->len = 0;
681 chk->size = size;
682}
683
684/* report 0 in case of error, 1 if OK. */
Krzysztof Piotr Oledzki6f61b212009-10-04 23:34:15 +0200685static inline int chunk_initlen(struct chunk *chk, char *str, size_t size, int len) {
Krzysztof Piotr Oledzki78abe612009-09-27 13:23:20 +0200686
Krzysztof Piotr Oledzki6f61b212009-10-04 23:34:15 +0200687 if (size && len > size)
Krzysztof Piotr Oledzki78abe612009-09-27 13:23:20 +0200688 return 0;
689
690 chk->str = str;
691 chk->len = len;
692 chk->size = size;
693
694 return 1;
695}
696
697static inline void chunk_initstr(struct chunk *chk, char *str) {
698 chk->str = str;
699 chk->len = strlen(str);
700 chk->size = 0; /* mark it read-only */
701}
702
703static inline int chunk_strcpy(struct chunk *chk, const char *str) {
704 size_t len;
705
706 len = strlen(str);
707
708 if (unlikely(len > chk->size))
709 return 0;
710
711 chk->len = len;
712 memcpy(chk->str, str, len);
713
714 return 1;
715}
716
717int chunk_printf(struct chunk *chk, const char *fmt, ...)
718 __attribute__ ((format(printf, 2, 3)));
719
Krzysztof Piotr Oledzkiba8d7d32009-10-10 21:06:03 +0200720int chunk_htmlencode(struct chunk *dst, struct chunk *src);
721int chunk_asciiencode(struct chunk *dst, struct chunk *src, char qc);
722
Krzysztof Piotr Oledzki78abe612009-09-27 13:23:20 +0200723static inline void chunk_reset(struct chunk *chk) {
724 chk->str = NULL;
725 chk->len = -1;
726 chk->size = 0;
727}
728
729static inline void chunk_destroy(struct chunk *chk) {
730
731 if (!chk->size)
732 return;
733
734 if (chk->str)
735 free(chk->str);
736
737 chunk_reset(chk);
738}
739
Willy Tarreau0f772532006-12-23 20:51:41 +0100740/*
741 * frees the destination chunk if already allocated, allocates a new string,
742 * and copies the source into it. The pointer to the destination string is
743 * returned, or NULL if the allocation fails or if any pointer is NULL..
744 */
745static inline char *chunk_dup(struct chunk *dst, const struct chunk *src) {
746 if (!dst || !src || !src->str)
747 return NULL;
748 if (dst->str)
749 free(dst->str);
750 dst->len = src->len;
751 dst->str = (char *)malloc(dst->len);
752 memcpy(dst->str, src->str, dst->len);
753 return dst->str;
754}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200755
756#endif /* _PROTO_BUFFERS_H */
757
758/*
759 * Local variables:
760 * c-indent-level: 8
761 * c-basic-offset: 8
762 * End:
763 */