blob: 026574f512512d7d9a2e229bce8a8421b18cf452 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
Willy Tarreauc7e42382012-08-24 19:22:53 +02002 * include/proto/channel.h
3 * Channel management definitions, macros and inline functions.
Willy Tarreau7c3c5412009-12-13 15:53:05 +01004 *
Willy Tarreaua27dc192014-11-27 22:10:04 +01005 * Copyright (C) 2000-2014 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
Willy Tarreauc7e42382012-08-24 19:22:53 +020022#ifndef _PROTO_CHANNEL_H
23#define _PROTO_CHANNEL_H
Willy Tarreaubaaee002006-06-26 02:48:02 +020024
Willy Tarreau08d5ac82018-06-06 15:09:28 +020025#include <stdint.h>
Willy Tarreau7341d942007-05-13 19:56:02 +020026#include <stdio.h>
Willy Tarreau0f772532006-12-23 20:51:41 +010027#include <stdlib.h>
Willy Tarreau7341d942007-05-13 19:56:02 +020028#include <string.h>
Willy Tarreau0f772532006-12-23 20:51:41 +010029
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020030#include <common/config.h>
Willy Tarreauc7e42382012-08-24 19:22:53 +020031#include <common/chunk.h>
Willy Tarreau0c303ee2008-07-07 00:09:58 +020032#include <common/ticks.h>
Willy Tarreaufa645582007-06-03 15:59:52 +020033#include <common/time.h>
34
Thierry FOURNIERac836ba2014-12-16 15:41:18 +010035#include <types/channel.h>
Willy Tarreau7c3c5412009-12-13 15:53:05 +010036#include <types/global.h>
Willy Tarreau87b09662015-04-03 00:22:06 +020037#include <types/stream.h>
Willy Tarreau73796532014-11-28 14:10:28 +010038#include <types/stream_interface.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020039
Christopher Fauleta73e59b2016-12-09 17:30:18 +010040#include <proto/task.h>
41
Willy Tarreau7341d942007-05-13 19:56:02 +020042/* perform minimal intializations, report 0 in case of error, 1 if OK. */
Willy Tarreau8263d2b2012-08-28 00:06:31 +020043int init_channel();
Willy Tarreau7341d942007-05-13 19:56:02 +020044
Willy Tarreau55a69062012-10-26 00:21:52 +020045unsigned long long __channel_forward(struct channel *chn, unsigned long long bytes);
Willy Tarreau8263d2b2012-08-28 00:06:31 +020046
47/* SI-to-channel functions working with buffers */
Willy Tarreau06d80a92017-10-19 14:32:15 +020048int ci_putblk(struct channel *chn, const char *str, int len);
49struct buffer *ci_swpbuf(struct channel *chn, struct buffer *buf);
50int ci_putchr(struct channel *chn, char c);
Willy Tarreau55f3ce12018-07-18 11:49:27 +020051int ci_getline_nc(const struct channel *chn, char **blk1, size_t *len1, char **blk2, size_t *len2);
52int ci_getblk_nc(const struct channel *chn, char **blk1, size_t *len1, char **blk2, size_t *len2);
Willy Tarreau06d80a92017-10-19 14:32:15 +020053int co_inject(struct channel *chn, const char *msg, int len);
Willy Tarreau41ab8682017-10-19 14:58:40 +020054int co_getline(const struct channel *chn, char *str, int len);
55int co_getblk(const struct channel *chn, char *blk, int len, int offset);
Willy Tarreau55f3ce12018-07-18 11:49:27 +020056int co_getline_nc(const struct channel *chn, const char **blk1, size_t *len1, const char **blk2, size_t *len2);
57int co_getblk_nc(const struct channel *chn, const char **blk1, size_t *len1, const char **blk2, size_t *len2);
Thierry FOURNIERca16b032015-02-16 19:26:48 +010058
Willy Tarreau74b08c92010-09-08 17:04:31 +020059
Willy Tarreau87b09662015-04-03 00:22:06 +020060/* returns a pointer to the stream the channel belongs to */
Thierry FOURNIER27929fb2015-09-25 08:36:11 +020061static inline struct stream *chn_strm(const struct channel *chn)
Willy Tarreaud5ccfa32014-12-28 13:03:53 +010062{
63 if (chn->flags & CF_ISRESP)
Willy Tarreau87b09662015-04-03 00:22:06 +020064 return LIST_ELEM(chn, struct stream *, res);
Willy Tarreaud5ccfa32014-12-28 13:03:53 +010065 else
Willy Tarreau87b09662015-04-03 00:22:06 +020066 return LIST_ELEM(chn, struct stream *, req);
Willy Tarreaud5ccfa32014-12-28 13:03:53 +010067}
68
Willy Tarreau73796532014-11-28 14:10:28 +010069/* returns a pointer to the stream interface feeding the channel (producer) */
70static inline struct stream_interface *chn_prod(const struct channel *chn)
71{
Willy Tarreau5decc052014-11-28 14:22:12 +010072 if (chn->flags & CF_ISRESP)
Willy Tarreau87b09662015-04-03 00:22:06 +020073 return &LIST_ELEM(chn, struct stream *, res)->si[1];
Willy Tarreau5decc052014-11-28 14:22:12 +010074 else
Willy Tarreau87b09662015-04-03 00:22:06 +020075 return &LIST_ELEM(chn, struct stream *, req)->si[0];
Willy Tarreau73796532014-11-28 14:10:28 +010076}
77
78/* returns a pointer to the stream interface consuming the channel (producer) */
79static inline struct stream_interface *chn_cons(const struct channel *chn)
80{
Willy Tarreau5decc052014-11-28 14:22:12 +010081 if (chn->flags & CF_ISRESP)
Willy Tarreau87b09662015-04-03 00:22:06 +020082 return &LIST_ELEM(chn, struct stream *, res)->si[0];
Willy Tarreau5decc052014-11-28 14:22:12 +010083 else
Willy Tarreau87b09662015-04-03 00:22:06 +020084 return &LIST_ELEM(chn, struct stream *, req)->si[1];
Willy Tarreau73796532014-11-28 14:10:28 +010085}
86
Willy Tarreau08d5ac82018-06-06 15:09:28 +020087/* c_orig() : returns the pointer to the channel buffer's origin */
88static inline char *c_orig(const struct channel *c)
89{
90 return b_orig(c->buf);
91}
92
93/* c_size() : returns the size of the channel's buffer */
94static inline size_t c_size(const struct channel *c)
95{
96 return b_size(c->buf);
97}
98
99/* c_wrap() : returns the pointer to the channel buffer's wrapping point */
100static inline char *c_wrap(const struct channel *c)
101{
102 return b_wrap(c->buf);
103}
104
105/* c_data() : returns the amount of data in the channel's buffer */
106static inline size_t c_data(const struct channel *c)
107{
108 return b_data(c->buf);
109}
110
111/* c_room() : returns the room left in the channel's buffer */
112static inline size_t c_room(const struct channel *c)
113{
114 return b_size(c->buf) - b_data(c->buf);
115}
116
117/* c_empty() : returns a boolean indicating if the channel's buffer is empty */
118static inline size_t c_empty(const struct channel *c)
119{
120 return !c_data(c);
121}
122
123/* c_full() : returns a boolean indicating if the channel's buffer is full */
124static inline size_t c_full(const struct channel *c)
125{
126 return !c_room(c);
127}
128
129/* co_data() : returns the amount of output data in the channel's buffer */
130static inline size_t co_data(const struct channel *c)
131{
132 return c->buf->o;
133}
134
135/* ci_data() : returns the amount of input data in the channel's buffer */
136static inline size_t ci_data(const struct channel *c)
137{
138 return c->buf->i;
139}
140
141/* ci_next() : for an absolute pointer <p> or a relative offset <o> pointing to
142 * a valid location within channel <c>'s buffer, returns either the absolute
143 * pointer or the relative offset pointing to the next byte, which usually is
144 * at (p + 1) unless p reaches the wrapping point and wrapping is needed.
145 */
146static inline size_t ci_next_ofs(const struct channel *c, size_t o)
147{
148 return b_next_ofs(c->buf, o);
149}
150static inline char *ci_next(const struct channel *c, const char *p)
151{
152 return b_next(c->buf, p);
153}
154
155
156/* c_ptr() : returns a pointer to an offset relative to the beginning of the
157 * input data in the buffer. If instead the offset is negative, a pointer to
158 * existing output data is returned. The function only takes care of wrapping,
159 * it's up to the caller to ensure the offset is always within byte count
160 * bounds.
161 */
162static inline char *c_ptr(const struct channel *c, ssize_t ofs)
163{
164 return b_peek(c->buf, co_data(c) + ofs);
165}
166
167/* c_adv() : advances the channel's buffer by <adv> bytes, which means that the
168 * buffer's pointer advances, and that as many bytes from in are transferred
169 * from in to out. The caller is responsible for ensuring that adv is always
170 * smaller than or equal to b->i.
171 */
172static inline void c_adv(struct channel *c, size_t adv)
173{
174 struct buffer *b = c->buf;
175
176 b->p = c_ptr(c, adv);
177 b->i -= adv;
178 b->o += adv;
179}
180
181/* c_rew() : rewinds the channel's buffer by <adv> bytes, which means that the
182 * buffer's pointer goes backwards, and that as many bytes from out are moved
183 * to in. The caller is responsible for ensuring that adv is always smaller
184 * than or equal to b->o.
185 */
186static inline void c_rew(struct channel *c, size_t adv)
187{
188 struct buffer *b = c->buf;
189
190 b->p = c_ptr(c, (int)-adv);
191 b->i += adv;
192 b->o -= adv;
193}
194
195/* c_realign_if_empty() : realign the channel's buffer if it's empty */
196static inline void c_realign_if_empty(struct channel *chn)
197{
198 b_realign_if_empty(chn->buf);
199}
200
201
202/* co_head() : returns a pointer to the beginning of output data in the buffer.
203 * The "__" variants don't support wrapping, "ofs" are relative to
204 * the buffer's origin.
205 */
206static inline size_t __co_head_ofs(const struct channel *c)
207{
208 return __b_peek_ofs(c->buf, 0);
209}
210static inline char *__co_head(const struct channel *c)
211{
212 return __b_peek(c->buf, 0);
213}
214static inline size_t co_head_ofs(const struct channel *c)
215{
216 return b_peek_ofs(c->buf, 0);
217}
218static inline char *co_head(const struct channel *c)
219{
220 return b_peek(c->buf, 0);
221}
222
223
224/* co_tail() : returns a pointer to the end of output data in the buffer.
225 * The "__" variants don't support wrapping, "ofs" are relative to
226 * the buffer's origin.
227 */
228static inline size_t __co_tail_ofs(const struct channel *c)
229{
230 return __b_peek_ofs(c->buf, co_data(c));
231}
232static inline char *__co_tail(const struct channel *c)
233{
234 return __b_peek(c->buf, co_data(c));
235}
236static inline size_t co_tail_ofs(const struct channel *c)
237{
238 return b_peek_ofs(c->buf, co_data(c));
239}
240static inline char *co_tail(const struct channel *c)
241{
242 return b_peek(c->buf, co_data(c));
243}
244
245
246/* ci_head() : returns a pointer to the beginning of input data in the buffer.
247 * The "__" variants don't support wrapping, "ofs" are relative to
248 * the buffer's origin.
249 */
250static inline size_t __ci_head_ofs(const struct channel *c)
251{
252 return __b_peek_ofs(c->buf, co_data(c));
253}
254static inline char *__ci_head(const struct channel *c)
255{
256 return __b_peek(c->buf, co_data(c));
257}
258static inline size_t ci_head_ofs(const struct channel *c)
259{
260 return b_peek_ofs(c->buf, co_data(c));
261}
262static inline char *ci_head(const struct channel *c)
263{
264 return b_peek(c->buf, co_data(c));
265}
266
267
268/* ci_tail() : returns a pointer to the end of input data in the buffer.
269 * The "__" variants don't support wrapping, "ofs" are relative to
270 * the buffer's origin.
271 */
272static inline size_t __ci_tail_ofs(const struct channel *c)
273{
274 return __b_peek_ofs(c->buf, c_data(c));
275}
276static inline char *__ci_tail(const struct channel *c)
277{
278 return __b_peek(c->buf, c_data(c));
279}
280static inline size_t ci_tail_ofs(const struct channel *c)
281{
282 return b_peek_ofs(c->buf, c_data(c));
283}
284static inline char *ci_tail(const struct channel *c)
285{
286 return b_peek(c->buf, c_data(c));
287}
288
289
290/* ci_stop() : returns the pointer to the byte following the end of input data
291 * in the channel buffer. It may be out of the buffer. It's used to
292 * compute lengths or stop pointers.
293 */
294static inline size_t __ci_stop_ofs(const struct channel *c)
295{
296 return __b_stop_ofs(c->buf);
297}
298static inline const char *__ci_stop(const struct channel *c)
299{
300 return __b_stop(c->buf);
301}
302static inline size_t ci_stop_ofs(const struct channel *c)
303{
304 return b_stop_ofs(c->buf);
305}
306static inline const char *ci_stop(const struct channel *c)
307{
308 return b_stop(c->buf);
309}
310
311
Willy Tarreau7194d3c2018-06-06 16:55:45 +0200312/* Returns the amount of input data that can contiguously be read at once */
313static inline size_t ci_contig_data(const struct channel *c)
314{
315 return b_contig_data(c->buf, co_data(c));
316}
317
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200318/* Initialize all fields in the channel. */
Willy Tarreau974ced62012-10-12 23:11:02 +0200319static inline void channel_init(struct channel *chn)
Willy Tarreau54469402006-07-29 16:59:06 +0200320{
Willy Tarreau2a4b5432014-11-24 11:39:34 +0100321 chn->buf = &buf_empty;
Willy Tarreau974ced62012-10-12 23:11:02 +0200322 chn->to_forward = 0;
Willy Tarreaub145c782014-02-09 17:45:16 +0100323 chn->last_read = now_ms;
Willy Tarreau8f39dcd2014-02-09 08:31:49 +0100324 chn->xfer_small = chn->xfer_large = 0;
Willy Tarreau974ced62012-10-12 23:11:02 +0200325 chn->total = 0;
326 chn->pipe = NULL;
327 chn->analysers = 0;
Willy Tarreau974ced62012-10-12 23:11:02 +0200328 chn->flags = 0;
Willy Tarreau54469402006-07-29 16:59:06 +0200329}
330
Willy Tarreau55a69062012-10-26 00:21:52 +0200331/* Schedule up to <bytes> more bytes to be forwarded via the channel without
332 * notifying the owner task. Any data pending in the buffer are scheduled to be
333 * sent as well, in the limit of the number of bytes to forward. This must be
334 * the only method to use to schedule bytes to be forwarded. If the requested
335 * number is too large, it is automatically adjusted. The number of bytes taken
336 * into account is returned. Directly touching ->to_forward will cause lockups
337 * when buf->o goes down to zero if nobody is ready to push the remaining data.
338 */
339static inline unsigned long long channel_forward(struct channel *chn, unsigned long long bytes)
340{
341 /* hint: avoid comparisons on long long for the fast case, since if the
342 * length does not fit in an unsigned it, it will never be forwarded at
343 * once anyway.
344 */
345 if (bytes <= ~0U) {
346 unsigned int bytes32 = bytes;
347
348 if (bytes32 <= chn->buf->i) {
349 /* OK this amount of bytes might be forwarded at once */
Willy Tarreaubcbd3932018-06-06 07:13:22 +0200350 c_adv(chn, bytes32);
Willy Tarreau55a69062012-10-26 00:21:52 +0200351 return bytes;
352 }
353 }
354 return __channel_forward(chn, bytes);
355}
356
Willy Tarreau8bf242b2016-05-04 14:05:58 +0200357/* Forwards any input data and marks the channel for permanent forwarding */
358static inline void channel_forward_forever(struct channel *chn)
359{
Willy Tarreaubcbd3932018-06-06 07:13:22 +0200360 c_adv(chn, chn->buf->i);
Willy Tarreau8bf242b2016-05-04 14:05:58 +0200361 chn->to_forward = CHN_INFINITE_FORWARD;
362}
363
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200364/*********************************************************************/
365/* These functions are used to compute various channel content sizes */
366/*********************************************************************/
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100367
Willy Tarreau8e21bb92012-08-24 22:40:29 +0200368/* Reports non-zero if the channel is empty, which means both its
369 * buffer and pipe are empty. The construct looks strange but is
370 * jump-less and much more efficient on both 32 and 64-bit than
371 * the boolean test.
372 */
Willy Tarreau41ab8682017-10-19 14:58:40 +0200373static inline unsigned int channel_is_empty(const struct channel *c)
Willy Tarreau8e21bb92012-08-24 22:40:29 +0200374{
Willy Tarreau9b28e032012-10-12 23:49:43 +0200375 return !(c->buf->o | (long)c->pipe);
Willy Tarreau8e21bb92012-08-24 22:40:29 +0200376}
377
Willy Tarreauba0902e2015-01-13 14:39:16 +0100378/* Returns non-zero if the channel is rewritable, which means that the buffer
379 * it is attached to has at least <maxrewrite> bytes immediately available.
380 * This is used to decide when a request or response may be parsed when some
381 * data from a previous exchange might still be present.
Willy Tarreau379357a2013-06-08 12:55:46 +0200382 */
Willy Tarreauba0902e2015-01-13 14:39:16 +0100383static inline int channel_is_rewritable(const struct channel *chn)
Willy Tarreau379357a2013-06-08 12:55:46 +0200384{
385 int rem = chn->buf->size;
386
387 rem -= chn->buf->o;
388 rem -= chn->buf->i;
389 rem -= global.tune.maxrewrite;
390 return rem >= 0;
391}
392
Willy Tarreau9c06ee42015-01-14 16:08:45 +0100393/* Tells whether data are likely to leave the buffer. This is used to know when
394 * we can safely ignore the reserve since we know we cannot retry a connection.
395 * It returns zero if data are blocked, non-zero otherwise.
396 */
397static inline int channel_may_send(const struct channel *chn)
398{
Willy Tarreau73796532014-11-28 14:10:28 +0100399 return chn_cons(chn)->state == SI_ST_EST;
Willy Tarreau9c06ee42015-01-14 16:08:45 +0100400}
401
Willy Tarreau3889fff2015-01-13 20:20:10 +0100402/* Returns non-zero if the channel can still receive data. This is used to
Willy Tarreau379357a2013-06-08 12:55:46 +0200403 * decide when to stop reading into a buffer when we want to ensure that we
404 * leave the reserve untouched after all pending outgoing data are forwarded.
405 * The reserved space is taken into account if ->to_forward indicates that an
406 * end of transfer is close to happen. Note that both ->buf->o and ->to_forward
407 * are considered as available since they're supposed to leave the buffer. The
408 * test is optimized to avoid as many operations as possible for the fast case
Willy Tarreau4b46a3e2016-04-20 20:09:22 +0200409 * and to be used as an "if" condition. Just like channel_recv_limit(), we
410 * never allow to overwrite the reserve until the output stream interface is
411 * connected, otherwise we could spin on a POST with http-send-name-header.
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100412 */
Willy Tarreau3889fff2015-01-13 20:20:10 +0100413static inline int channel_may_recv(const struct channel *chn)
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100414{
Willy Tarreau9b28e032012-10-12 23:49:43 +0200415 int rem = chn->buf->size;
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200416
Willy Tarreau4428a292014-11-28 20:54:13 +0100417 if (chn->buf == &buf_empty)
Willy Tarreau3889fff2015-01-13 20:20:10 +0100418 return 1;
Willy Tarreau4428a292014-11-28 20:54:13 +0100419
Willy Tarreau9b28e032012-10-12 23:49:43 +0200420 rem -= chn->buf->o;
421 rem -= chn->buf->i;
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200422 if (!rem)
Willy Tarreau3889fff2015-01-13 20:20:10 +0100423 return 0; /* buffer already full */
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200424
Willy Tarreau93dc4782016-04-21 12:12:45 +0200425 if (rem > global.tune.maxrewrite)
426 return 1; /* reserve not yet reached */
Willy Tarreau4b46a3e2016-04-20 20:09:22 +0200427
Willy Tarreau93dc4782016-04-21 12:12:45 +0200428 if (!channel_may_send(chn))
429 return 0; /* don't touch reserve until we can send */
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200430
Willy Tarreau93dc4782016-04-21 12:12:45 +0200431 /* Now we know there's some room left in the reserve and we may
432 * forward. As long as i-to_fwd < size-maxrw, we may still
433 * receive. This is equivalent to i+maxrw-size < to_fwd,
434 * which is logical since i+maxrw-size is what overlaps with
435 * the reserve, and we want to ensure they're covered by scheduled
436 * forwards.
437 */
438 rem = chn->buf->i + global.tune.maxrewrite - chn->buf->size;
439 return rem < 0 || (unsigned int)rem < chn->to_forward;
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100440}
441
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200442/* Returns true if the channel's input is already closed */
Willy Tarreau974ced62012-10-12 23:11:02 +0200443static inline int channel_input_closed(struct channel *chn)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200444{
Willy Tarreau974ced62012-10-12 23:11:02 +0200445 return ((chn->flags & CF_SHUTR) != 0);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200446}
447
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200448/* Returns true if the channel's output is already closed */
Willy Tarreau974ced62012-10-12 23:11:02 +0200449static inline int channel_output_closed(struct channel *chn)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200450{
Willy Tarreau974ced62012-10-12 23:11:02 +0200451 return ((chn->flags & CF_SHUTW) != 0);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200452}
453
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200454/* Check channel timeouts, and set the corresponding flags. The likely/unlikely
455 * have been optimized for fastest normal path. The read/write timeouts are not
456 * set if there was activity on the channel. That way, we don't have to update
457 * the timeout on every I/O. Note that the analyser timeout is always checked.
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200458 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200459static inline void channel_check_timeouts(struct channel *chn)
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200460{
Willy Tarreau974ced62012-10-12 23:11:02 +0200461 if (likely(!(chn->flags & (CF_SHUTR|CF_READ_TIMEOUT|CF_READ_ACTIVITY|CF_READ_NOEXP))) &&
462 unlikely(tick_is_expired(chn->rex, now_ms)))
463 chn->flags |= CF_READ_TIMEOUT;
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200464
Christopher Fauletc5a9d5b2017-11-09 09:36:43 +0100465 if (likely(!(chn->flags & (CF_SHUTW|CF_WRITE_TIMEOUT|CF_WRITE_ACTIVITY|CF_WRITE_EVENT))) &&
Willy Tarreau974ced62012-10-12 23:11:02 +0200466 unlikely(tick_is_expired(chn->wex, now_ms)))
467 chn->flags |= CF_WRITE_TIMEOUT;
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200468
Willy Tarreau974ced62012-10-12 23:11:02 +0200469 if (likely(!(chn->flags & CF_ANA_TIMEOUT)) &&
470 unlikely(tick_is_expired(chn->analyse_exp, now_ms)))
471 chn->flags |= CF_ANA_TIMEOUT;
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200472}
473
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200474/* Erase any content from channel <buf> and adjusts flags accordingly. Note
Willy Tarreau0abebcc2009-01-08 00:09:41 +0100475 * that any spliced data is not affected since we may not have any access to
476 * it.
Willy Tarreaue393fe22008-08-16 22:18:07 +0200477 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200478static inline void channel_erase(struct channel *chn)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200479{
Willy Tarreau974ced62012-10-12 23:11:02 +0200480 chn->to_forward = 0;
Willy Tarreau474cf542014-11-24 10:54:47 +0100481 b_reset(chn->buf);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200482}
483
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200484/* marks the channel as "shutdown" ASAP for reads */
Willy Tarreau974ced62012-10-12 23:11:02 +0200485static inline void channel_shutr_now(struct channel *chn)
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200486{
Willy Tarreau974ced62012-10-12 23:11:02 +0200487 chn->flags |= CF_SHUTR_NOW;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200488}
489
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200490/* marks the channel as "shutdown" ASAP for writes */
Willy Tarreau974ced62012-10-12 23:11:02 +0200491static inline void channel_shutw_now(struct channel *chn)
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200492{
Willy Tarreau974ced62012-10-12 23:11:02 +0200493 chn->flags |= CF_SHUTW_NOW;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200494}
495
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200496/* marks the channel as "shutdown" ASAP in both directions */
Willy Tarreau974ced62012-10-12 23:11:02 +0200497static inline void channel_abort(struct channel *chn)
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200498{
Willy Tarreau974ced62012-10-12 23:11:02 +0200499 chn->flags |= CF_SHUTR_NOW | CF_SHUTW_NOW;
500 chn->flags &= ~CF_AUTO_CONNECT;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200501}
502
Willy Tarreau520d95e2009-09-19 21:04:57 +0200503/* allow the consumer to try to establish a new connection. */
Willy Tarreau974ced62012-10-12 23:11:02 +0200504static inline void channel_auto_connect(struct channel *chn)
Willy Tarreau3da77c52008-08-29 09:58:42 +0200505{
Willy Tarreau974ced62012-10-12 23:11:02 +0200506 chn->flags |= CF_AUTO_CONNECT;
Willy Tarreau3da77c52008-08-29 09:58:42 +0200507}
508
Willy Tarreau520d95e2009-09-19 21:04:57 +0200509/* prevent the consumer from trying to establish a new connection, and also
510 * disable auto shutdown forwarding.
511 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200512static inline void channel_dont_connect(struct channel *chn)
Willy Tarreau3da77c52008-08-29 09:58:42 +0200513{
Willy Tarreau974ced62012-10-12 23:11:02 +0200514 chn->flags &= ~(CF_AUTO_CONNECT|CF_AUTO_CLOSE);
Willy Tarreau3da77c52008-08-29 09:58:42 +0200515}
516
Willy Tarreau520d95e2009-09-19 21:04:57 +0200517/* allow the producer to forward shutdown requests */
Willy Tarreau974ced62012-10-12 23:11:02 +0200518static inline void channel_auto_close(struct channel *chn)
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100519{
Willy Tarreau974ced62012-10-12 23:11:02 +0200520 chn->flags |= CF_AUTO_CLOSE;
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100521}
522
Willy Tarreau520d95e2009-09-19 21:04:57 +0200523/* prevent the producer from forwarding shutdown requests */
Willy Tarreau974ced62012-10-12 23:11:02 +0200524static inline void channel_dont_close(struct channel *chn)
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100525{
Willy Tarreau974ced62012-10-12 23:11:02 +0200526 chn->flags &= ~CF_AUTO_CLOSE;
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100527}
528
Willy Tarreau90deb182010-01-07 00:20:41 +0100529/* allow the producer to read / poll the input */
Willy Tarreau974ced62012-10-12 23:11:02 +0200530static inline void channel_auto_read(struct channel *chn)
Willy Tarreau90deb182010-01-07 00:20:41 +0100531{
Willy Tarreau974ced62012-10-12 23:11:02 +0200532 chn->flags &= ~CF_DONT_READ;
Willy Tarreau90deb182010-01-07 00:20:41 +0100533}
534
535/* prevent the producer from read / poll the input */
Willy Tarreau974ced62012-10-12 23:11:02 +0200536static inline void channel_dont_read(struct channel *chn)
Willy Tarreau90deb182010-01-07 00:20:41 +0100537{
Willy Tarreau974ced62012-10-12 23:11:02 +0200538 chn->flags |= CF_DONT_READ;
Willy Tarreau90deb182010-01-07 00:20:41 +0100539}
540
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200541
542/*************************************************/
543/* Buffer operations in the context of a channel */
544/*************************************************/
545
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200546
547/* Return the max number of bytes the buffer can contain so that once all the
Willy Tarreau169c4702016-04-20 18:05:17 +0200548 * pending bytes are forwarded, the buffer still has global.tune.maxrewrite
Willy Tarreau974ced62012-10-12 23:11:02 +0200549 * bytes free. The result sits between chn->size - maxrewrite and chn->size.
Willy Tarreau169c4702016-04-20 18:05:17 +0200550 * It is important to mention that if buf->i is already larger than size-maxrw
551 * the condition above cannot be satisfied and the lowest size will be returned
552 * anyway. The principles are the following :
553 * 0) the empty buffer has a limit of zero
554 * 1) a non-connected buffer cannot touch the reserve
555 * 2) infinite forward can always fill the buffer since all data will leave
556 * 3) all output bytes are considered in transit since they're leaving
557 * 4) all input bytes covered by to_forward are considered in transit since
558 * they'll be converted to output bytes.
559 * 5) all input bytes not covered by to_forward as considered remaining
560 * 6) all bytes scheduled to be forwarded minus what is already in the input
561 * buffer will be in transit during future rounds.
562 * 7) 4+5+6 imply that the amount of input bytes (i) is irrelevant to the max
563 * usable length, only to_forward and output count. The difference is
564 * visible when to_forward > i.
565 * 8) the reserve may be covered up to the amount of bytes in transit since
566 * these bytes will only take temporary space.
Willy Tarreau999f6432016-01-25 01:09:11 +0100567 *
Willy Tarreau169c4702016-04-20 18:05:17 +0200568 * A typical buffer looks like this :
Willy Tarreau999f6432016-01-25 01:09:11 +0100569 *
Willy Tarreau169c4702016-04-20 18:05:17 +0200570 * <-------------- max_len ----------->
571 * <---- o ----><----- i -----> <--- 0..maxrewrite --->
572 * +------------+--------------+-------+----------------------+
573 * |////////////|\\\\\\\\\\\\\\|xxxxxxx| reserve |
574 * +------------+--------+-----+-------+----------------------+
575 * <- fwd -> <-avail->
576 *
577 * Or when to_forward > i :
578 *
579 * <-------------- max_len ----------->
580 * <---- o ----><----- i -----> <--- 0..maxrewrite --->
581 * +------------+--------------+-------+----------------------+
582 * |////////////|\\\\\\\\\\\\\\|xxxxxxx| reserve |
583 * +------------+--------+-----+-------+----------------------+
584 * <-avail->
585 * <------------------ fwd ---------------->
586 *
587 * - the amount of buffer bytes in transit is : min(i, fwd) + o
588 * - some scheduled bytes may be in transit (up to fwd - i)
589 * - the reserve is max(0, maxrewrite - transit)
590 * - the maximum usable buffer length is size - reserve.
591 * - the available space is max_len - i - o
592 *
593 * So the formula to compute the buffer's maximum length to protect the reserve
594 * when reading new data is :
595 *
596 * max = size - maxrewrite + min(maxrewrite, transit)
597 * = size - max(maxrewrite - transit, 0)
598 *
599 * But WARNING! The conditions might change during the transfer and it could
600 * very well happen that a buffer would contain more bytes than max_len due to
601 * i+o already walking over the reserve (eg: after a header rewrite), including
602 * i or o alone hitting the limit. So it is critical to always consider that
603 * bounds may have already been crossed and that available space may be negative
604 * for example. Due to this it is perfectly possible for this function to return
605 * a value that is lower than current i+o.
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200606 */
Willy Tarreau3f5096d2015-01-14 20:21:43 +0100607static inline int channel_recv_limit(const struct channel *chn)
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200608{
Willy Tarreauef907fe2016-05-03 17:46:24 +0200609 unsigned int transit;
Willy Tarreau999f6432016-01-25 01:09:11 +0100610 int reserve;
611
612 /* return zero if empty */
613 reserve = chn->buf->size;
614 if (chn->buf == &buf_empty)
615 goto end;
616
617 /* return size - maxrewrite if we can't send */
618 reserve = global.tune.maxrewrite;
619 if (unlikely(!channel_may_send(chn)))
620 goto end;
621
Willy Tarreauef907fe2016-05-03 17:46:24 +0200622 /* We need to check what remains of the reserve after o and to_forward
623 * have been transmitted, but they can overflow together and they can
624 * cause an integer underflow in the comparison since both are unsigned
625 * while maxrewrite is signed.
626 * The code below has been verified for being a valid check for this :
627 * - if (o + to_forward) overflow => return size [ large enough ]
628 * - if o + to_forward >= maxrw => return size [ large enough ]
629 * - otherwise return size - (maxrw - (o + to_forward))
Willy Tarreau999f6432016-01-25 01:09:11 +0100630 */
Willy Tarreauef907fe2016-05-03 17:46:24 +0200631 transit = chn->buf->o + chn->to_forward;
632 reserve -= transit;
633 if (transit < chn->to_forward || // addition overflow
634 transit >= (unsigned)global.tune.maxrewrite) // enough transit data
Willy Tarreau169c4702016-04-20 18:05:17 +0200635 return chn->buf->size;
Willy Tarreau999f6432016-01-25 01:09:11 +0100636 end:
637 return chn->buf->size - reserve;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200638}
639
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200640/* Returns the amount of space available at the input of the buffer, taking the
641 * reserved space into account if ->to_forward indicates that an end of transfer
642 * is close to happen. The test is optimized to avoid as many operations as
643 * possible for the fast case.
644 */
Willy Tarreaub5051f82015-01-14 20:25:34 +0100645static inline int channel_recv_max(const struct channel *chn)
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200646{
Willy Tarreau27bb0e12015-01-14 15:56:50 +0100647 int ret;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200648
Willy Tarreau3f5096d2015-01-14 20:21:43 +0100649 ret = channel_recv_limit(chn) - chn->buf->i - chn->buf->o;
Willy Tarreau27bb0e12015-01-14 15:56:50 +0100650 if (ret < 0)
651 ret = 0;
652 return ret;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200653}
654
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100655/* Allocates a buffer for channel <chn>, but only if it's guaranteed that it's
656 * not the last available buffer or it's the response buffer. Unless the buffer
657 * is the response buffer, an extra control is made so that we always keep
658 * <tune.buffers.reserved> buffers available after this allocation. Returns 0 in
659 * case of failure, non-zero otherwise.
660 *
661 * If no buffer are available, the requester, represented by <wait> pointer,
662 * will be added in the list of objects waiting for an available buffer.
663 */
664static inline int channel_alloc_buffer(struct channel *chn, struct buffer_wait *wait)
665{
666 int margin = 0;
667
668 if (!(chn->flags & CF_ISRESP))
669 margin = global.tune.reserved_bufs;
670
671 if (b_alloc_margin(&chn->buf, margin) != NULL)
672 return 1;
673
Emeric Bruna1dd2432017-06-21 15:42:52 +0200674 if (LIST_ISEMPTY(&wait->list)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100675 HA_SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100676 LIST_ADDQ(&buffer_wq, &wait->list);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100677 HA_SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
Emeric Bruna1dd2432017-06-21 15:42:52 +0200678 }
679
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100680 return 0;
681}
682
683/* Releases a possibly allocated buffer for channel <chn>. If it was not
684 * allocated, this function does nothing. Else the buffer is released and we try
685 * to wake up as many streams/applets as possible. */
686static inline void channel_release_buffer(struct channel *chn, struct buffer_wait *wait)
687{
688 if (chn->buf->size && buffer_empty(chn->buf)) {
689 b_free(&chn->buf);
Olivier Houchard673867c2018-05-25 16:58:52 +0200690 offer_buffers(wait->target, tasks_run_queue);
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100691 }
692}
693
Willy Tarreau319f7452015-01-14 20:32:59 +0100694/* Truncate any unread data in the channel's buffer, and disable forwarding.
695 * Outgoing data are left intact. This is mainly to be used to send error
696 * messages after existing data.
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200697 */
Willy Tarreau319f7452015-01-14 20:32:59 +0100698static inline void channel_truncate(struct channel *chn)
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200699{
Willy Tarreau9b28e032012-10-12 23:49:43 +0200700 if (!chn->buf->o)
Willy Tarreau974ced62012-10-12 23:11:02 +0200701 return channel_erase(chn);
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200702
Willy Tarreau974ced62012-10-12 23:11:02 +0200703 chn->to_forward = 0;
Willy Tarreau9b28e032012-10-12 23:49:43 +0200704 if (!chn->buf->i)
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200705 return;
706
Willy Tarreau9b28e032012-10-12 23:49:43 +0200707 chn->buf->i = 0;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200708}
709
Willy Tarreau4cf13002018-06-06 06:53:15 +0200710/* This function realigns a possibly wrapping channel buffer so that the input
711 * part is contiguous and starts at the beginning of the buffer and the output
712 * part ends at the end of the buffer. This provides the best conditions since
713 * it allows the largest inputs to be processed at once and ensures that once
714 * the output data leaves, the whole buffer is available at once.
715 */
Willy Tarreaufd8d42f2018-07-12 10:57:15 +0200716static inline void channel_slow_realign(struct channel *chn, char *swap)
Willy Tarreau4cf13002018-06-06 06:53:15 +0200717{
Willy Tarreaufd8d42f2018-07-12 10:57:15 +0200718 return b_slow_realign(chn->buf, swap, co_data(chn));
Willy Tarreau4cf13002018-06-06 06:53:15 +0200719}
720
Willy Tarreaubaaee002006-06-26 02:48:02 +0200721/*
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200722 * Advance the channel buffer's read pointer by <len> bytes. This is useful
723 * when data have been read directly from the buffer. It is illegal to call
724 * this function with <len> causing a wrapping at the end of the buffer. It's
725 * the caller's responsibility to ensure that <len> is never larger than
Willy Tarreau974ced62012-10-12 23:11:02 +0200726 * chn->o. Channel flag WRITE_PARTIAL is set.
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200727 */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200728static inline void co_skip(struct channel *chn, int len)
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200729{
Willy Tarreaue5f12ce2018-06-15 10:28:05 +0200730 b_del(chn->buf, len);
Willy Tarreau5fb38032012-12-16 19:39:09 +0100731 if (buffer_empty(chn->buf))
Willy Tarreau9b28e032012-10-12 23:49:43 +0200732 chn->buf->p = chn->buf->data;
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200733
Willy Tarreaufb0e9202009-09-23 23:47:55 +0200734 /* notify that some data was written to the SI from the buffer */
Christopher Fauletc5a9d5b2017-11-09 09:36:43 +0100735 chn->flags |= CF_WRITE_PARTIAL | CF_WRITE_EVENT;
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200736}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200737
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200738/* Tries to copy chunk <chunk> into the channel's buffer after length controls.
Willy Tarreau974ced62012-10-12 23:11:02 +0200739 * The chn->o and to_forward pointers are updated. If the channel's input is
Willy Tarreau74b08c92010-09-08 17:04:31 +0200740 * closed, -2 is returned. If the block is too large for this buffer, -3 is
741 * returned. If there is not enough room left in the buffer, -1 is returned.
742 * Otherwise the number of bytes copied is returned (0 being a valid number).
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200743 * Channel flag READ_PARTIAL is updated if some data can be transferred. The
Willy Tarreauf941cf22012-08-27 20:53:34 +0200744 * chunk's length is updated with the number of bytes sent.
Willy Tarreauaeac3192009-08-31 08:09:57 +0200745 */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200746static inline int ci_putchk(struct channel *chn, struct chunk *chunk)
Willy Tarreauaeac3192009-08-31 08:09:57 +0200747{
748 int ret;
749
Willy Tarreau06d80a92017-10-19 14:32:15 +0200750 ret = ci_putblk(chn, chunk->str, chunk->len);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200751 if (ret > 0)
752 chunk->len -= ret;
Willy Tarreauaeac3192009-08-31 08:09:57 +0200753 return ret;
754}
755
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200756/* Tries to copy string <str> at once into the channel's buffer after length
Willy Tarreau974ced62012-10-12 23:11:02 +0200757 * controls. The chn->o and to_forward pointers are updated. If the channel's
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200758 * input is closed, -2 is returned. If the block is too large for this buffer,
759 * -3 is returned. If there is not enough room left in the buffer, -1 is
760 * returned. Otherwise the number of bytes copied is returned (0 being a valid
761 * number). Channel flag READ_PARTIAL is updated if some data can be
762 * transferred.
Willy Tarreau74b08c92010-09-08 17:04:31 +0200763 */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200764static inline int ci_putstr(struct channel *chn, const char *str)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200765{
Willy Tarreau06d80a92017-10-19 14:32:15 +0200766 return ci_putblk(chn, str, strlen(str));
Willy Tarreau74b08c92010-09-08 17:04:31 +0200767}
768
769/*
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200770 * Return one char from the channel's buffer. If the buffer is empty and the
771 * channel is closed, return -2. If the buffer is just empty, return -1. The
Willy Tarreau06d80a92017-10-19 14:32:15 +0200772 * buffer's pointer is not advanced, it's up to the caller to call co_skip(buf,
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200773 * 1) when it has consumed the char. Also note that this function respects the
Willy Tarreau974ced62012-10-12 23:11:02 +0200774 * chn->o limit.
Willy Tarreau74b08c92010-09-08 17:04:31 +0200775 */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200776static inline int co_getchr(struct channel *chn)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200777{
778 /* closed or empty + imminent close = -2; empty = -1 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200779 if (unlikely((chn->flags & CF_SHUTW) || channel_is_empty(chn))) {
780 if (chn->flags & (CF_SHUTW|CF_SHUTW_NOW))
Willy Tarreau74b08c92010-09-08 17:04:31 +0200781 return -2;
782 return -1;
783 }
Willy Tarreau9b28e032012-10-12 23:49:43 +0200784 return *buffer_wrap_sub(chn->buf, chn->buf->p - chn->buf->o);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200785}
786
Willy Tarreaubaaee002006-06-26 02:48:02 +0200787
Willy Tarreauc7e42382012-08-24 19:22:53 +0200788#endif /* _PROTO_CHANNEL_H */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200789
790/*
791 * Local variables:
792 * c-indent-level: 8
793 * c-basic-offset: 8
794 * End:
795 */