blob: cf85058997399660d97894fb0d010d6da08272e7 [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 Tarreaua1bd1fa2019-03-29 17:26:33 +010025#include <inttypes.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 Tarreaub96b77e2018-12-11 10:22:41 +010032#include <common/htx.h>
Willy Tarreau0c303ee2008-07-07 00:09:58 +020033#include <common/ticks.h>
Willy Tarreaufa645582007-06-03 15:59:52 +020034#include <common/time.h>
35
Thierry FOURNIERac836ba2014-12-16 15:41:18 +010036#include <types/channel.h>
Willy Tarreau7c3c5412009-12-13 15:53:05 +010037#include <types/global.h>
Willy Tarreau87b09662015-04-03 00:22:06 +020038#include <types/stream.h>
Willy Tarreau73796532014-11-28 14:10:28 +010039#include <types/stream_interface.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020040
Christopher Fauleta73e59b2016-12-09 17:30:18 +010041#include <proto/task.h>
42
Willy Tarreau7341d942007-05-13 19:56:02 +020043/* perform minimal intializations, report 0 in case of error, 1 if OK. */
Willy Tarreau8263d2b2012-08-28 00:06:31 +020044int init_channel();
Willy Tarreau7341d942007-05-13 19:56:02 +020045
Willy Tarreau55a69062012-10-26 00:21:52 +020046unsigned long long __channel_forward(struct channel *chn, unsigned long long bytes);
Willy Tarreau8263d2b2012-08-28 00:06:31 +020047
48/* SI-to-channel functions working with buffers */
Willy Tarreau06d80a92017-10-19 14:32:15 +020049int ci_putblk(struct channel *chn, const char *str, int len);
Willy Tarreau06d80a92017-10-19 14:32:15 +020050int 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 Tarreau4d893d42018-07-12 15:43:32 +020053int ci_insert_line2(struct channel *c, int pos, const char *str, int len);
Willy Tarreau06d80a92017-10-19 14:32:15 +020054int co_inject(struct channel *chn, const char *msg, int len);
Willy Tarreau41ab8682017-10-19 14:58:40 +020055int co_getline(const struct channel *chn, char *str, int len);
56int co_getblk(const struct channel *chn, char *blk, int len, int offset);
Willy Tarreau55f3ce12018-07-18 11:49:27 +020057int co_getline_nc(const struct channel *chn, const char **blk1, size_t *len1, const char **blk2, size_t *len2);
58int 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 +010059
Willy Tarreau74b08c92010-09-08 17:04:31 +020060
Willy Tarreau87b09662015-04-03 00:22:06 +020061/* returns a pointer to the stream the channel belongs to */
Thierry FOURNIER27929fb2015-09-25 08:36:11 +020062static inline struct stream *chn_strm(const struct channel *chn)
Willy Tarreaud5ccfa32014-12-28 13:03:53 +010063{
64 if (chn->flags & CF_ISRESP)
Willy Tarreau87b09662015-04-03 00:22:06 +020065 return LIST_ELEM(chn, struct stream *, res);
Willy Tarreaud5ccfa32014-12-28 13:03:53 +010066 else
Willy Tarreau87b09662015-04-03 00:22:06 +020067 return LIST_ELEM(chn, struct stream *, req);
Willy Tarreaud5ccfa32014-12-28 13:03:53 +010068}
69
Willy Tarreau73796532014-11-28 14:10:28 +010070/* returns a pointer to the stream interface feeding the channel (producer) */
71static inline struct stream_interface *chn_prod(const struct channel *chn)
72{
Willy Tarreau5decc052014-11-28 14:22:12 +010073 if (chn->flags & CF_ISRESP)
Willy Tarreau87b09662015-04-03 00:22:06 +020074 return &LIST_ELEM(chn, struct stream *, res)->si[1];
Willy Tarreau5decc052014-11-28 14:22:12 +010075 else
Willy Tarreau87b09662015-04-03 00:22:06 +020076 return &LIST_ELEM(chn, struct stream *, req)->si[0];
Willy Tarreau73796532014-11-28 14:10:28 +010077}
78
79/* returns a pointer to the stream interface consuming the channel (producer) */
80static inline struct stream_interface *chn_cons(const struct channel *chn)
81{
Willy Tarreau5decc052014-11-28 14:22:12 +010082 if (chn->flags & CF_ISRESP)
Willy Tarreau87b09662015-04-03 00:22:06 +020083 return &LIST_ELEM(chn, struct stream *, res)->si[0];
Willy Tarreau5decc052014-11-28 14:22:12 +010084 else
Willy Tarreau87b09662015-04-03 00:22:06 +020085 return &LIST_ELEM(chn, struct stream *, req)->si[1];
Willy Tarreau73796532014-11-28 14:10:28 +010086}
87
Willy Tarreau08d5ac82018-06-06 15:09:28 +020088/* c_orig() : returns the pointer to the channel buffer's origin */
89static inline char *c_orig(const struct channel *c)
90{
Willy Tarreauc9fa0482018-07-10 17:43:27 +020091 return b_orig(&c->buf);
Willy Tarreau08d5ac82018-06-06 15:09:28 +020092}
93
94/* c_size() : returns the size of the channel's buffer */
95static inline size_t c_size(const struct channel *c)
96{
Willy Tarreauc9fa0482018-07-10 17:43:27 +020097 return b_size(&c->buf);
Willy Tarreau08d5ac82018-06-06 15:09:28 +020098}
99
100/* c_wrap() : returns the pointer to the channel buffer's wrapping point */
101static inline char *c_wrap(const struct channel *c)
102{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200103 return b_wrap(&c->buf);
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200104}
105
106/* c_data() : returns the amount of data in the channel's buffer */
107static inline size_t c_data(const struct channel *c)
108{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200109 return b_data(&c->buf);
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200110}
111
112/* c_room() : returns the room left in the channel's buffer */
113static inline size_t c_room(const struct channel *c)
114{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200115 return b_size(&c->buf) - b_data(&c->buf);
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200116}
117
118/* c_empty() : returns a boolean indicating if the channel's buffer is empty */
119static inline size_t c_empty(const struct channel *c)
120{
121 return !c_data(c);
122}
123
124/* c_full() : returns a boolean indicating if the channel's buffer is full */
125static inline size_t c_full(const struct channel *c)
126{
127 return !c_room(c);
128}
129
130/* co_data() : returns the amount of output data in the channel's buffer */
131static inline size_t co_data(const struct channel *c)
132{
Olivier Houchard08afac02018-06-22 19:26:39 +0200133 return c->output;
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200134}
135
136/* ci_data() : returns the amount of input data in the channel's buffer */
137static inline size_t ci_data(const struct channel *c)
138{
Willy Tarreau3ee83442018-06-15 16:42:02 +0200139 return c_data(c) - co_data(c);
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200140}
141
142/* ci_next() : for an absolute pointer <p> or a relative offset <o> pointing to
143 * a valid location within channel <c>'s buffer, returns either the absolute
144 * pointer or the relative offset pointing to the next byte, which usually is
145 * at (p + 1) unless p reaches the wrapping point and wrapping is needed.
146 */
147static inline size_t ci_next_ofs(const struct channel *c, size_t o)
148{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200149 return b_next_ofs(&c->buf, o);
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200150}
151static inline char *ci_next(const struct channel *c, const char *p)
152{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200153 return b_next(&c->buf, p);
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200154}
155
156
157/* c_ptr() : returns a pointer to an offset relative to the beginning of the
158 * input data in the buffer. If instead the offset is negative, a pointer to
159 * existing output data is returned. The function only takes care of wrapping,
160 * it's up to the caller to ensure the offset is always within byte count
161 * bounds.
162 */
163static inline char *c_ptr(const struct channel *c, ssize_t ofs)
164{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200165 return b_peek(&c->buf, co_data(c) + ofs);
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200166}
167
168/* c_adv() : advances the channel's buffer by <adv> bytes, which means that the
169 * buffer's pointer advances, and that as many bytes from in are transferred
170 * from in to out. The caller is responsible for ensuring that adv is always
171 * smaller than or equal to b->i.
172 */
173static inline void c_adv(struct channel *c, size_t adv)
174{
Olivier Houchard08afac02018-06-22 19:26:39 +0200175 c->output += adv;
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200176}
177
178/* c_rew() : rewinds the channel's buffer by <adv> bytes, which means that the
179 * buffer's pointer goes backwards, and that as many bytes from out are moved
180 * to in. The caller is responsible for ensuring that adv is always smaller
181 * than or equal to b->o.
182 */
183static inline void c_rew(struct channel *c, size_t adv)
184{
Olivier Houchard08afac02018-06-22 19:26:39 +0200185 c->output -= adv;
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200186}
187
188/* c_realign_if_empty() : realign the channel's buffer if it's empty */
189static inline void c_realign_if_empty(struct channel *chn)
190{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200191 b_realign_if_empty(&chn->buf);
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200192}
193
Olivier Houchardd4251a72018-06-29 16:17:34 +0200194/* Sets the amount of output for the channel */
195static inline void co_set_data(struct channel *c, size_t output)
196{
Olivier Houchard08afac02018-06-22 19:26:39 +0200197 c->output = output;
Olivier Houchardd4251a72018-06-29 16:17:34 +0200198}
199
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200200
201/* co_head() : returns a pointer to the beginning of output data in the buffer.
202 * The "__" variants don't support wrapping, "ofs" are relative to
203 * the buffer's origin.
204 */
205static inline size_t __co_head_ofs(const struct channel *c)
206{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200207 return __b_peek_ofs(&c->buf, 0);
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200208}
209static inline char *__co_head(const struct channel *c)
210{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200211 return __b_peek(&c->buf, 0);
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200212}
213static inline size_t co_head_ofs(const struct channel *c)
214{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200215 return b_peek_ofs(&c->buf, 0);
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200216}
217static inline char *co_head(const struct channel *c)
218{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200219 return b_peek(&c->buf, 0);
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200220}
221
222
223/* co_tail() : returns a pointer to the end of output data in the buffer.
224 * The "__" variants don't support wrapping, "ofs" are relative to
225 * the buffer's origin.
226 */
227static inline size_t __co_tail_ofs(const struct channel *c)
228{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200229 return __b_peek_ofs(&c->buf, co_data(c));
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200230}
231static inline char *__co_tail(const struct channel *c)
232{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200233 return __b_peek(&c->buf, co_data(c));
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200234}
235static inline size_t co_tail_ofs(const struct channel *c)
236{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200237 return b_peek_ofs(&c->buf, co_data(c));
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200238}
239static inline char *co_tail(const struct channel *c)
240{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200241 return b_peek(&c->buf, co_data(c));
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200242}
243
244
245/* ci_head() : returns a pointer to the beginning of input data in the buffer.
246 * The "__" variants don't support wrapping, "ofs" are relative to
247 * the buffer's origin.
248 */
249static inline size_t __ci_head_ofs(const struct channel *c)
250{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200251 return __b_peek_ofs(&c->buf, co_data(c));
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200252}
253static inline char *__ci_head(const struct channel *c)
254{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200255 return __b_peek(&c->buf, co_data(c));
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200256}
257static inline size_t ci_head_ofs(const struct channel *c)
258{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200259 return b_peek_ofs(&c->buf, co_data(c));
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200260}
261static inline char *ci_head(const struct channel *c)
262{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200263 return b_peek(&c->buf, co_data(c));
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200264}
265
266
267/* ci_tail() : returns a pointer to the end of input data in the buffer.
268 * The "__" variants don't support wrapping, "ofs" are relative to
269 * the buffer's origin.
270 */
271static inline size_t __ci_tail_ofs(const struct channel *c)
272{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200273 return __b_peek_ofs(&c->buf, c_data(c));
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200274}
275static inline char *__ci_tail(const struct channel *c)
276{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200277 return __b_peek(&c->buf, c_data(c));
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200278}
279static inline size_t ci_tail_ofs(const struct channel *c)
280{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200281 return b_peek_ofs(&c->buf, c_data(c));
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200282}
283static inline char *ci_tail(const struct channel *c)
284{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200285 return b_peek(&c->buf, c_data(c));
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200286}
287
288
289/* ci_stop() : returns the pointer to the byte following the end of input data
290 * in the channel buffer. It may be out of the buffer. It's used to
291 * compute lengths or stop pointers.
292 */
293static inline size_t __ci_stop_ofs(const struct channel *c)
294{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200295 return __b_stop_ofs(&c->buf);
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200296}
297static inline const char *__ci_stop(const struct channel *c)
298{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200299 return __b_stop(&c->buf);
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200300}
301static inline size_t ci_stop_ofs(const struct channel *c)
302{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200303 return b_stop_ofs(&c->buf);
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200304}
305static inline const char *ci_stop(const struct channel *c)
306{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200307 return b_stop(&c->buf);
Willy Tarreau08d5ac82018-06-06 15:09:28 +0200308}
309
310
Willy Tarreau7194d3c2018-06-06 16:55:45 +0200311/* Returns the amount of input data that can contiguously be read at once */
312static inline size_t ci_contig_data(const struct channel *c)
313{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200314 return b_contig_data(&c->buf, co_data(c));
Willy Tarreau7194d3c2018-06-06 16:55:45 +0200315}
316
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200317/* Initialize all fields in the channel. */
Willy Tarreau974ced62012-10-12 23:11:02 +0200318static inline void channel_init(struct channel *chn)
Willy Tarreau54469402006-07-29 16:59:06 +0200319{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200320 chn->buf = BUF_NULL;
Willy Tarreau974ced62012-10-12 23:11:02 +0200321 chn->to_forward = 0;
Willy Tarreaub145c782014-02-09 17:45:16 +0100322 chn->last_read = now_ms;
Willy Tarreau8f39dcd2014-02-09 08:31:49 +0100323 chn->xfer_small = chn->xfer_large = 0;
Willy Tarreau974ced62012-10-12 23:11:02 +0200324 chn->total = 0;
325 chn->pipe = NULL;
326 chn->analysers = 0;
Willy Tarreau974ced62012-10-12 23:11:02 +0200327 chn->flags = 0;
Olivier Houchard08afac02018-06-22 19:26:39 +0200328 chn->output = 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
Willy Tarreau3ee83442018-06-15 16:42:02 +0200348 if (bytes32 <= ci_data(chn)) {
Willy Tarreau55a69062012-10-26 00:21:52 +0200349 /* 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 Tarreau3ee83442018-06-15 16:42:02 +0200360 c_adv(chn, ci_data(chn));
Willy Tarreau8bf242b2016-05-04 14:05:58 +0200361 chn->to_forward = CHN_INFINITE_FORWARD;
362}
363
Christopher Faulete6458292019-01-02 14:24:35 +0100364/* <len> bytes of input data was added into the channel <chn>. This functions
365 * must be called to update the channel state. It also handles the fast
366 * forwarding. */
367static inline void channel_add_input(struct channel *chn, unsigned int len)
368{
369 if (chn->to_forward) {
370 unsigned long fwd = len;
371 if (chn->to_forward != CHN_INFINITE_FORWARD) {
372 if (fwd > chn->to_forward)
373 fwd = chn->to_forward;
374 chn->to_forward -= fwd;
375 }
376 c_adv(chn, fwd);
377 }
378 /* notify that some data was read */
379 chn->total += len;
380 chn->flags |= CF_READ_PARTIAL;
381}
382
Christopher Fauletb2aedea2018-12-05 11:56:15 +0100383static inline unsigned long long channel_htx_forward(struct channel *chn, struct htx *htx, unsigned long long bytes)
384{
385 unsigned long long ret;
386
387 b_set_data(&chn->buf, htx->data);
388 ret = channel_forward(chn, bytes);
389 b_set_data(&chn->buf, b_size(&chn->buf));
390 return ret;
391}
392
393
394static inline void channel_htx_forward_forever(struct channel *chn, struct htx *htx)
395{
396 b_set_data(&chn->buf, htx->data);
397 channel_forward_forever(chn);
398 b_set_data(&chn->buf, b_size(&chn->buf));
399}
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200400/*********************************************************************/
401/* These functions are used to compute various channel content sizes */
402/*********************************************************************/
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100403
Willy Tarreau8e21bb92012-08-24 22:40:29 +0200404/* Reports non-zero if the channel is empty, which means both its
405 * buffer and pipe are empty. The construct looks strange but is
406 * jump-less and much more efficient on both 32 and 64-bit than
407 * the boolean test.
408 */
Willy Tarreau41ab8682017-10-19 14:58:40 +0200409static inline unsigned int channel_is_empty(const struct channel *c)
Willy Tarreau8e21bb92012-08-24 22:40:29 +0200410{
Willy Tarreau3ee83442018-06-15 16:42:02 +0200411 return !(co_data(c) | (long)c->pipe);
Willy Tarreau8e21bb92012-08-24 22:40:29 +0200412}
413
Willy Tarreauba0902e2015-01-13 14:39:16 +0100414/* Returns non-zero if the channel is rewritable, which means that the buffer
415 * it is attached to has at least <maxrewrite> bytes immediately available.
416 * This is used to decide when a request or response may be parsed when some
417 * data from a previous exchange might still be present.
Willy Tarreau379357a2013-06-08 12:55:46 +0200418 */
Willy Tarreauba0902e2015-01-13 14:39:16 +0100419static inline int channel_is_rewritable(const struct channel *chn)
Willy Tarreau379357a2013-06-08 12:55:46 +0200420{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200421 int rem = chn->buf.size;
Willy Tarreau379357a2013-06-08 12:55:46 +0200422
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200423 rem -= b_data(&chn->buf);
Willy Tarreau379357a2013-06-08 12:55:46 +0200424 rem -= global.tune.maxrewrite;
425 return rem >= 0;
426}
427
Willy Tarreau9c06ee42015-01-14 16:08:45 +0100428/* Tells whether data are likely to leave the buffer. This is used to know when
429 * we can safely ignore the reserve since we know we cannot retry a connection.
430 * It returns zero if data are blocked, non-zero otherwise.
431 */
432static inline int channel_may_send(const struct channel *chn)
433{
Willy Tarreau73796532014-11-28 14:10:28 +0100434 return chn_cons(chn)->state == SI_ST_EST;
Willy Tarreau9c06ee42015-01-14 16:08:45 +0100435}
436
Willy Tarreau3889fff2015-01-13 20:20:10 +0100437/* Returns non-zero if the channel can still receive data. This is used to
Willy Tarreau379357a2013-06-08 12:55:46 +0200438 * decide when to stop reading into a buffer when we want to ensure that we
439 * leave the reserve untouched after all pending outgoing data are forwarded.
440 * The reserved space is taken into account if ->to_forward indicates that an
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200441 * end of transfer is close to happen. Note that both ->buf.o and ->to_forward
Willy Tarreau379357a2013-06-08 12:55:46 +0200442 * are considered as available since they're supposed to leave the buffer. The
443 * test is optimized to avoid as many operations as possible for the fast case
Willy Tarreau4b46a3e2016-04-20 20:09:22 +0200444 * and to be used as an "if" condition. Just like channel_recv_limit(), we
445 * never allow to overwrite the reserve until the output stream interface is
446 * connected, otherwise we could spin on a POST with http-send-name-header.
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100447 */
Willy Tarreau3889fff2015-01-13 20:20:10 +0100448static inline int channel_may_recv(const struct channel *chn)
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100449{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200450 int rem = chn->buf.size;
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200451
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200452 if (b_is_null(&chn->buf))
Willy Tarreau3889fff2015-01-13 20:20:10 +0100453 return 1;
Willy Tarreau4428a292014-11-28 20:54:13 +0100454
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200455 rem -= b_data(&chn->buf);
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200456 if (!rem)
Willy Tarreau3889fff2015-01-13 20:20:10 +0100457 return 0; /* buffer already full */
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200458
Willy Tarreau93dc4782016-04-21 12:12:45 +0200459 if (rem > global.tune.maxrewrite)
460 return 1; /* reserve not yet reached */
Willy Tarreau4b46a3e2016-04-20 20:09:22 +0200461
Willy Tarreau93dc4782016-04-21 12:12:45 +0200462 if (!channel_may_send(chn))
463 return 0; /* don't touch reserve until we can send */
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200464
Willy Tarreau93dc4782016-04-21 12:12:45 +0200465 /* Now we know there's some room left in the reserve and we may
466 * forward. As long as i-to_fwd < size-maxrw, we may still
467 * receive. This is equivalent to i+maxrw-size < to_fwd,
468 * which is logical since i+maxrw-size is what overlaps with
469 * the reserve, and we want to ensure they're covered by scheduled
470 * forwards.
471 */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200472 rem = ci_data(chn) + global.tune.maxrewrite - chn->buf.size;
Willy Tarreau93dc4782016-04-21 12:12:45 +0200473 return rem < 0 || (unsigned int)rem < chn->to_forward;
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100474}
475
Christopher Faulet5811db02019-01-07 13:57:01 +0100476/* HTX version of channel_may_recv(). Returns non-zero if the channel can still
477 * receive data. */
478static inline int channel_htx_may_recv(const struct channel *chn, const struct htx *htx)
479{
480 uint32_t rem;
481
482 if (!htx->size)
483 return 1;
484
485 if (!channel_may_send(chn))
486 return 0; /* don't touch reserve until we can send */
487
488 rem = htx_free_data_space(htx);
489 if (!rem)
490 return 0; /* htx already full */
491
492 if (rem > global.tune.maxrewrite)
493 return 1; /* reserve not yet reached */
494
495 /* Now we know there's some room left in the reserve and we may
496 * forward. As long as i-to_fwd < size-maxrw, we may still
497 * receive. This is equivalent to i+maxrw-size < to_fwd,
498 * which is logical since i+maxrw-size is what overlaps with
499 * the reserve, and we want to ensure they're covered by scheduled
500 * forwards.
501 */
502 rem += co_data(chn);
503 if (rem > global.tune.maxrewrite)
504 return 1;
505
506 return (global.tune.maxrewrite - rem < chn->to_forward);
507}
508
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200509/* Returns true if the channel's input is already closed */
Willy Tarreau974ced62012-10-12 23:11:02 +0200510static inline int channel_input_closed(struct channel *chn)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200511{
Willy Tarreau974ced62012-10-12 23:11:02 +0200512 return ((chn->flags & CF_SHUTR) != 0);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200513}
514
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200515/* Returns true if the channel's output is already closed */
Willy Tarreau974ced62012-10-12 23:11:02 +0200516static inline int channel_output_closed(struct channel *chn)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200517{
Willy Tarreau974ced62012-10-12 23:11:02 +0200518 return ((chn->flags & CF_SHUTW) != 0);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200519}
520
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200521/* Check channel timeouts, and set the corresponding flags. The likely/unlikely
522 * have been optimized for fastest normal path. The read/write timeouts are not
523 * set if there was activity on the channel. That way, we don't have to update
524 * the timeout on every I/O. Note that the analyser timeout is always checked.
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200525 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200526static inline void channel_check_timeouts(struct channel *chn)
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200527{
Willy Tarreau974ced62012-10-12 23:11:02 +0200528 if (likely(!(chn->flags & (CF_SHUTR|CF_READ_TIMEOUT|CF_READ_ACTIVITY|CF_READ_NOEXP))) &&
529 unlikely(tick_is_expired(chn->rex, now_ms)))
530 chn->flags |= CF_READ_TIMEOUT;
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200531
Willy Tarreauede3d882018-10-24 17:17:56 +0200532 if (likely(!(chn->flags & (CF_SHUTW|CF_WRITE_TIMEOUT|CF_WRITE_ACTIVITY))) &&
Willy Tarreau974ced62012-10-12 23:11:02 +0200533 unlikely(tick_is_expired(chn->wex, now_ms)))
534 chn->flags |= CF_WRITE_TIMEOUT;
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200535
Willy Tarreau974ced62012-10-12 23:11:02 +0200536 if (likely(!(chn->flags & CF_ANA_TIMEOUT)) &&
537 unlikely(tick_is_expired(chn->analyse_exp, now_ms)))
538 chn->flags |= CF_ANA_TIMEOUT;
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200539}
540
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200541/* Erase any content from channel <buf> and adjusts flags accordingly. Note
Willy Tarreau0abebcc2009-01-08 00:09:41 +0100542 * that any spliced data is not affected since we may not have any access to
543 * it.
Willy Tarreaue393fe22008-08-16 22:18:07 +0200544 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200545static inline void channel_erase(struct channel *chn)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200546{
Willy Tarreau974ced62012-10-12 23:11:02 +0200547 chn->to_forward = 0;
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200548 b_reset(&chn->buf);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200549}
550
Christopher Fauletf7ed1952019-01-07 14:55:10 +0100551static inline void channel_htx_erase(struct channel *chn, struct htx *htx)
552{
553 htx_reset(htx);
554 channel_erase(chn);
555}
556
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200557/* marks the channel as "shutdown" ASAP for reads */
Willy Tarreau974ced62012-10-12 23:11:02 +0200558static inline void channel_shutr_now(struct channel *chn)
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200559{
Willy Tarreau974ced62012-10-12 23:11:02 +0200560 chn->flags |= CF_SHUTR_NOW;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200561}
562
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200563/* marks the channel as "shutdown" ASAP for writes */
Willy Tarreau974ced62012-10-12 23:11:02 +0200564static inline void channel_shutw_now(struct channel *chn)
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200565{
Willy Tarreau974ced62012-10-12 23:11:02 +0200566 chn->flags |= CF_SHUTW_NOW;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200567}
568
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200569/* marks the channel as "shutdown" ASAP in both directions */
Willy Tarreau974ced62012-10-12 23:11:02 +0200570static inline void channel_abort(struct channel *chn)
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200571{
Willy Tarreau974ced62012-10-12 23:11:02 +0200572 chn->flags |= CF_SHUTR_NOW | CF_SHUTW_NOW;
573 chn->flags &= ~CF_AUTO_CONNECT;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200574}
575
Willy Tarreau520d95e2009-09-19 21:04:57 +0200576/* allow the consumer to try to establish a new connection. */
Willy Tarreau974ced62012-10-12 23:11:02 +0200577static inline void channel_auto_connect(struct channel *chn)
Willy Tarreau3da77c52008-08-29 09:58:42 +0200578{
Willy Tarreau974ced62012-10-12 23:11:02 +0200579 chn->flags |= CF_AUTO_CONNECT;
Willy Tarreau3da77c52008-08-29 09:58:42 +0200580}
581
Willy Tarreau520d95e2009-09-19 21:04:57 +0200582/* prevent the consumer from trying to establish a new connection, and also
583 * disable auto shutdown forwarding.
584 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200585static inline void channel_dont_connect(struct channel *chn)
Willy Tarreau3da77c52008-08-29 09:58:42 +0200586{
Willy Tarreau974ced62012-10-12 23:11:02 +0200587 chn->flags &= ~(CF_AUTO_CONNECT|CF_AUTO_CLOSE);
Willy Tarreau3da77c52008-08-29 09:58:42 +0200588}
589
Willy Tarreau520d95e2009-09-19 21:04:57 +0200590/* allow the producer to forward shutdown requests */
Willy Tarreau974ced62012-10-12 23:11:02 +0200591static inline void channel_auto_close(struct channel *chn)
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100592{
Willy Tarreau974ced62012-10-12 23:11:02 +0200593 chn->flags |= CF_AUTO_CLOSE;
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100594}
595
Willy Tarreau520d95e2009-09-19 21:04:57 +0200596/* prevent the producer from forwarding shutdown requests */
Willy Tarreau974ced62012-10-12 23:11:02 +0200597static inline void channel_dont_close(struct channel *chn)
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100598{
Willy Tarreau974ced62012-10-12 23:11:02 +0200599 chn->flags &= ~CF_AUTO_CLOSE;
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100600}
601
Willy Tarreau90deb182010-01-07 00:20:41 +0100602/* allow the producer to read / poll the input */
Willy Tarreau974ced62012-10-12 23:11:02 +0200603static inline void channel_auto_read(struct channel *chn)
Willy Tarreau90deb182010-01-07 00:20:41 +0100604{
Willy Tarreau974ced62012-10-12 23:11:02 +0200605 chn->flags &= ~CF_DONT_READ;
Willy Tarreau90deb182010-01-07 00:20:41 +0100606}
607
608/* prevent the producer from read / poll the input */
Willy Tarreau974ced62012-10-12 23:11:02 +0200609static inline void channel_dont_read(struct channel *chn)
Willy Tarreau90deb182010-01-07 00:20:41 +0100610{
Willy Tarreau974ced62012-10-12 23:11:02 +0200611 chn->flags |= CF_DONT_READ;
Willy Tarreau90deb182010-01-07 00:20:41 +0100612}
613
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200614
615/*************************************************/
616/* Buffer operations in the context of a channel */
617/*************************************************/
618
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200619
620/* Return the max number of bytes the buffer can contain so that once all the
Willy Tarreau169c4702016-04-20 18:05:17 +0200621 * pending bytes are forwarded, the buffer still has global.tune.maxrewrite
Willy Tarreau974ced62012-10-12 23:11:02 +0200622 * bytes free. The result sits between chn->size - maxrewrite and chn->size.
Willy Tarreau169c4702016-04-20 18:05:17 +0200623 * It is important to mention that if buf->i is already larger than size-maxrw
624 * the condition above cannot be satisfied and the lowest size will be returned
625 * anyway. The principles are the following :
626 * 0) the empty buffer has a limit of zero
627 * 1) a non-connected buffer cannot touch the reserve
628 * 2) infinite forward can always fill the buffer since all data will leave
629 * 3) all output bytes are considered in transit since they're leaving
630 * 4) all input bytes covered by to_forward are considered in transit since
631 * they'll be converted to output bytes.
632 * 5) all input bytes not covered by to_forward as considered remaining
633 * 6) all bytes scheduled to be forwarded minus what is already in the input
634 * buffer will be in transit during future rounds.
635 * 7) 4+5+6 imply that the amount of input bytes (i) is irrelevant to the max
636 * usable length, only to_forward and output count. The difference is
637 * visible when to_forward > i.
638 * 8) the reserve may be covered up to the amount of bytes in transit since
639 * these bytes will only take temporary space.
Willy Tarreau999f6432016-01-25 01:09:11 +0100640 *
Willy Tarreau169c4702016-04-20 18:05:17 +0200641 * A typical buffer looks like this :
Willy Tarreau999f6432016-01-25 01:09:11 +0100642 *
Willy Tarreau169c4702016-04-20 18:05:17 +0200643 * <-------------- max_len ----------->
644 * <---- o ----><----- i -----> <--- 0..maxrewrite --->
645 * +------------+--------------+-------+----------------------+
646 * |////////////|\\\\\\\\\\\\\\|xxxxxxx| reserve |
647 * +------------+--------+-----+-------+----------------------+
648 * <- fwd -> <-avail->
649 *
650 * Or when to_forward > i :
651 *
652 * <-------------- max_len ----------->
653 * <---- o ----><----- i -----> <--- 0..maxrewrite --->
654 * +------------+--------------+-------+----------------------+
655 * |////////////|\\\\\\\\\\\\\\|xxxxxxx| reserve |
656 * +------------+--------+-----+-------+----------------------+
657 * <-avail->
658 * <------------------ fwd ---------------->
659 *
660 * - the amount of buffer bytes in transit is : min(i, fwd) + o
661 * - some scheduled bytes may be in transit (up to fwd - i)
662 * - the reserve is max(0, maxrewrite - transit)
663 * - the maximum usable buffer length is size - reserve.
664 * - the available space is max_len - i - o
665 *
666 * So the formula to compute the buffer's maximum length to protect the reserve
667 * when reading new data is :
668 *
669 * max = size - maxrewrite + min(maxrewrite, transit)
670 * = size - max(maxrewrite - transit, 0)
671 *
672 * But WARNING! The conditions might change during the transfer and it could
673 * very well happen that a buffer would contain more bytes than max_len due to
674 * i+o already walking over the reserve (eg: after a header rewrite), including
675 * i or o alone hitting the limit. So it is critical to always consider that
676 * bounds may have already been crossed and that available space may be negative
677 * for example. Due to this it is perfectly possible for this function to return
678 * a value that is lower than current i+o.
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200679 */
Willy Tarreau3f5096d2015-01-14 20:21:43 +0100680static inline int channel_recv_limit(const struct channel *chn)
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200681{
Willy Tarreauef907fe2016-05-03 17:46:24 +0200682 unsigned int transit;
Willy Tarreau999f6432016-01-25 01:09:11 +0100683 int reserve;
684
685 /* return zero if empty */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200686 reserve = chn->buf.size;
687 if (b_is_null(&chn->buf))
Willy Tarreau999f6432016-01-25 01:09:11 +0100688 goto end;
689
690 /* return size - maxrewrite if we can't send */
691 reserve = global.tune.maxrewrite;
692 if (unlikely(!channel_may_send(chn)))
693 goto end;
694
Willy Tarreauef907fe2016-05-03 17:46:24 +0200695 /* We need to check what remains of the reserve after o and to_forward
696 * have been transmitted, but they can overflow together and they can
697 * cause an integer underflow in the comparison since both are unsigned
698 * while maxrewrite is signed.
699 * The code below has been verified for being a valid check for this :
700 * - if (o + to_forward) overflow => return size [ large enough ]
701 * - if o + to_forward >= maxrw => return size [ large enough ]
702 * - otherwise return size - (maxrw - (o + to_forward))
Willy Tarreau999f6432016-01-25 01:09:11 +0100703 */
Willy Tarreau3ee83442018-06-15 16:42:02 +0200704 transit = co_data(chn) + chn->to_forward;
Willy Tarreauef907fe2016-05-03 17:46:24 +0200705 reserve -= transit;
706 if (transit < chn->to_forward || // addition overflow
707 transit >= (unsigned)global.tune.maxrewrite) // enough transit data
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200708 return chn->buf.size;
Willy Tarreau999f6432016-01-25 01:09:11 +0100709 end:
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200710 return chn->buf.size - reserve;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200711}
712
Christopher Faulet5811db02019-01-07 13:57:01 +0100713/* HTX version of channel_recv_limit(). Return the max number of bytes the HTX
714 * buffer can contain so that once all the pending bytes are forwarded, the
715 * buffer still has global.tune.maxrewrite bytes free.
716 */
717static inline int channel_htx_recv_limit(const struct channel *chn, const struct htx *htx)
718{
719 unsigned int transit;
720 int reserve;
721
722 /* return zeor if not allocated */
723 if (!htx->size)
724 return 0;
725
726 /* return max_data_space - maxrewrite if we can't send */
727 reserve = global.tune.maxrewrite;
728 if (unlikely(!channel_may_send(chn)))
729 goto end;
730
731 /* We need to check what remains of the reserve after o and to_forward
732 * have been transmitted, but they can overflow together and they can
733 * cause an integer underflow in the comparison since both are unsigned
734 * while maxrewrite is signed.
735 * The code below has been verified for being a valid check for this :
736 * - if (o + to_forward) overflow => return max_data_space [ large enough ]
737 * - if o + to_forward >= maxrw => return max_data_space [ large enough ]
738 * - otherwise return max_data_space - (maxrw - (o + to_forward))
739 */
740 transit = co_data(chn) + chn->to_forward;
741 reserve -= transit;
742 if (transit < chn->to_forward || // addition overflow
743 transit >= (unsigned)global.tune.maxrewrite) // enough transit data
744 return htx_max_data_space(htx);
745 end:
746 return (htx_max_data_space(htx) - reserve);
747}
748
Willy Tarreau23752332018-06-15 14:54:53 +0200749/* Returns non-zero if the channel's INPUT buffer's is considered full, which
750 * means that it holds at least as much INPUT data as (size - reserve). This
751 * also means that data that are scheduled for output are considered as potential
752 * free space, and that the reserved space is always considered as not usable.
753 * This information alone cannot be used as a general purpose free space indicator.
754 * However it accurately indicates that too many data were fed in the buffer
755 * for an analyzer for instance. See the channel_may_recv() function for a more
756 * generic function taking everything into account.
757 */
758static inline int channel_full(const struct channel *c, unsigned int reserve)
759{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200760 if (b_is_null(&c->buf))
Willy Tarreau23752332018-06-15 14:54:53 +0200761 return 0;
762
Willy Tarreau3ee83442018-06-15 16:42:02 +0200763 return (ci_data(c) + reserve >= c_size(c));
Willy Tarreau23752332018-06-15 14:54:53 +0200764}
765
Christopher Faulet5811db02019-01-07 13:57:01 +0100766/* HTX version of channel_full(). Instead of checking if INPUT data exceeds
767 * (size - reserve), this function checks if the free space for data in <htx>
768 * and the data scheduled for output are lower to the reserve. In such case, the
769 * channel is considered as full.
770 */
771static inline int channel_htx_full(const struct channel *c, const struct htx *htx,
772 unsigned int reserve)
773{
774 if (!htx->size)
775 return 0;
776 return (htx_free_data_space(htx) + co_data(c) <= reserve);
777}
778
Willy Tarreau23752332018-06-15 14:54:53 +0200779
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200780/* Returns the amount of space available at the input of the buffer, taking the
781 * reserved space into account if ->to_forward indicates that an end of transfer
782 * is close to happen. The test is optimized to avoid as many operations as
783 * possible for the fast case.
784 */
Willy Tarreaub5051f82015-01-14 20:25:34 +0100785static inline int channel_recv_max(const struct channel *chn)
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200786{
Willy Tarreau27bb0e12015-01-14 15:56:50 +0100787 int ret;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200788
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200789 ret = channel_recv_limit(chn) - b_data(&chn->buf);
Willy Tarreau27bb0e12015-01-14 15:56:50 +0100790 if (ret < 0)
791 ret = 0;
792 return ret;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200793}
794
Christopher Faulet5811db02019-01-07 13:57:01 +0100795/* HTX version of channel_recv_max(). */
796static inline int channel_htx_recv_max(const struct channel *chn, const struct htx *htx)
797{
798 int ret;
799
800 ret = channel_htx_recv_limit(chn, htx) - htx->data;
801 if (ret < 0)
802 ret = 0;
803 return ret;
804}
805
Willy Tarreau3f679992018-06-15 15:06:42 +0200806/* Returns the amount of bytes that can be written over the input data at once,
807 * including reserved space which may be overwritten. This is used by Lua to
808 * insert data in the input side just before the other data using buffer_replace().
809 * The goal is to transfer these new data in the output buffer.
810 */
811static inline int ci_space_for_replace(const struct channel *chn)
812{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200813 const struct buffer *buf = &chn->buf;
Willy Tarreau3f679992018-06-15 15:06:42 +0200814 const char *end;
815
816 /* If the input side data overflows, we cannot insert data contiguously. */
817 if (b_head(buf) + b_data(buf) >= b_wrap(buf))
818 return 0;
819
820 /* Check the last byte used in the buffer, it may be a byte of the output
821 * side if the buffer wraps, or its the end of the buffer.
822 */
823 end = b_head(buf);
824 if (end <= ci_head(chn))
825 end = b_wrap(buf);
826
827 /* Compute the amount of bytes which can be written. */
828 return end - ci_tail(chn);
829}
830
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100831/* Allocates a buffer for channel <chn>, but only if it's guaranteed that it's
832 * not the last available buffer or it's the response buffer. Unless the buffer
833 * is the response buffer, an extra control is made so that we always keep
834 * <tune.buffers.reserved> buffers available after this allocation. Returns 0 in
835 * case of failure, non-zero otherwise.
836 *
837 * If no buffer are available, the requester, represented by <wait> pointer,
838 * will be added in the list of objects waiting for an available buffer.
839 */
840static inline int channel_alloc_buffer(struct channel *chn, struct buffer_wait *wait)
841{
842 int margin = 0;
843
844 if (!(chn->flags & CF_ISRESP))
845 margin = global.tune.reserved_bufs;
846
847 if (b_alloc_margin(&chn->buf, margin) != NULL)
848 return 1;
849
Emeric Bruna1dd2432017-06-21 15:42:52 +0200850 if (LIST_ISEMPTY(&wait->list)) {
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100851 HA_SPIN_LOCK(BUF_WQ_LOCK, &buffer_wq_lock);
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100852 LIST_ADDQ(&buffer_wq, &wait->list);
Christopher Faulet2a944ee2017-11-07 10:42:54 +0100853 HA_SPIN_UNLOCK(BUF_WQ_LOCK, &buffer_wq_lock);
Emeric Bruna1dd2432017-06-21 15:42:52 +0200854 }
855
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100856 return 0;
857}
858
859/* Releases a possibly allocated buffer for channel <chn>. If it was not
860 * allocated, this function does nothing. Else the buffer is released and we try
861 * to wake up as many streams/applets as possible. */
862static inline void channel_release_buffer(struct channel *chn, struct buffer_wait *wait)
863{
Willy Tarreau0c7ed5d2018-07-10 09:53:31 +0200864 if (c_size(chn) && c_empty(chn)) {
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100865 b_free(&chn->buf);
Olivier Houchard673867c2018-05-25 16:58:52 +0200866 offer_buffers(wait->target, tasks_run_queue);
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100867 }
868}
869
Willy Tarreau319f7452015-01-14 20:32:59 +0100870/* Truncate any unread data in the channel's buffer, and disable forwarding.
871 * Outgoing data are left intact. This is mainly to be used to send error
872 * messages after existing data.
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200873 */
Willy Tarreau319f7452015-01-14 20:32:59 +0100874static inline void channel_truncate(struct channel *chn)
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200875{
Willy Tarreau3ee83442018-06-15 16:42:02 +0200876 if (!co_data(chn))
Willy Tarreau974ced62012-10-12 23:11:02 +0200877 return channel_erase(chn);
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200878
Willy Tarreau974ced62012-10-12 23:11:02 +0200879 chn->to_forward = 0;
Willy Tarreau3ee83442018-06-15 16:42:02 +0200880 if (!ci_data(chn))
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200881 return;
882
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200883 chn->buf.data = co_data(chn);
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200884}
885
Christopher Fauletf7ed1952019-01-07 14:55:10 +0100886static inline void channel_htx_truncate(struct channel *chn, struct htx *htx)
887{
888 if (!co_data(chn))
889 return channel_htx_erase(chn, htx);
890
891 chn->to_forward = 0;
892 if (htx->data == co_data(chn))
893 return;
894 htx_truncate(htx, co_data(chn));
895}
896
Willy Tarreau4cf13002018-06-06 06:53:15 +0200897/* This function realigns a possibly wrapping channel buffer so that the input
898 * part is contiguous and starts at the beginning of the buffer and the output
899 * part ends at the end of the buffer. This provides the best conditions since
900 * it allows the largest inputs to be processed at once and ensures that once
901 * the output data leaves, the whole buffer is available at once.
902 */
Willy Tarreaufd8d42f2018-07-12 10:57:15 +0200903static inline void channel_slow_realign(struct channel *chn, char *swap)
Willy Tarreau4cf13002018-06-06 06:53:15 +0200904{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200905 return b_slow_realign(&chn->buf, swap, co_data(chn));
Willy Tarreau4cf13002018-06-06 06:53:15 +0200906}
907
Willy Tarreaubaaee002006-06-26 02:48:02 +0200908/*
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200909 * Advance the channel buffer's read pointer by <len> bytes. This is useful
910 * when data have been read directly from the buffer. It is illegal to call
911 * this function with <len> causing a wrapping at the end of the buffer. It's
912 * the caller's responsibility to ensure that <len> is never larger than
Christopher Faulet729b5b32019-02-25 15:50:12 +0100913 * chn->o. Channel flags WRITE_PARTIAL and WROTE_DATA are set.
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200914 */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200915static inline void co_skip(struct channel *chn, int len)
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200916{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200917 b_del(&chn->buf, len);
Olivier Houchard08afac02018-06-22 19:26:39 +0200918 chn->output -= len;
Willy Tarreau0c7ed5d2018-07-10 09:53:31 +0200919 c_realign_if_empty(chn);
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200920
Willy Tarreaufb0e9202009-09-23 23:47:55 +0200921 /* notify that some data was written to the SI from the buffer */
Christopher Faulet729b5b32019-02-25 15:50:12 +0100922 chn->flags |= CF_WRITE_PARTIAL | CF_WROTE_DATA;
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200923}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200924
Christopher Fauletc6827d52019-02-25 10:44:51 +0100925/* HTX version of co_skip(). This function skips at most <len> bytes from the
926 * output of the channel <chn>. Depending on how data are stored in <htx> less
927 * than <len> bytes can be skipped. Channel flags WRITE_PARTIAL and WROTE_DATA
928 * are set.
929 */
930static inline void co_htx_skip(struct channel *chn, struct htx *htx, int len)
931{
932 struct htx_ret htxret;
933
934 htxret = htx_drain(htx, len);
935 if (htxret.ret) {
936 chn->output -= htxret.ret;
937
938 /* notify that some data was written to the SI from the buffer */
939 chn->flags |= CF_WRITE_PARTIAL | CF_WROTE_DATA;
940 }
941}
Christopher Faulet729b5b32019-02-25 15:50:12 +0100942
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200943/* Tries to copy chunk <chunk> into the channel's buffer after length controls.
Willy Tarreau974ced62012-10-12 23:11:02 +0200944 * The chn->o and to_forward pointers are updated. If the channel's input is
Willy Tarreau74b08c92010-09-08 17:04:31 +0200945 * closed, -2 is returned. If the block is too large for this buffer, -3 is
946 * returned. If there is not enough room left in the buffer, -1 is returned.
947 * Otherwise the number of bytes copied is returned (0 being a valid number).
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200948 * Channel flag READ_PARTIAL is updated if some data can be transferred. The
Willy Tarreauf941cf22012-08-27 20:53:34 +0200949 * chunk's length is updated with the number of bytes sent.
Willy Tarreauaeac3192009-08-31 08:09:57 +0200950 */
Willy Tarreau83061a82018-07-13 11:56:34 +0200951static inline int ci_putchk(struct channel *chn, struct buffer *chunk)
Willy Tarreauaeac3192009-08-31 08:09:57 +0200952{
953 int ret;
954
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200955 ret = ci_putblk(chn, chunk->area, chunk->data);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200956 if (ret > 0)
Willy Tarreau843b7cb2018-07-13 10:54:26 +0200957 chunk->data -= ret;
Willy Tarreauaeac3192009-08-31 08:09:57 +0200958 return ret;
959}
960
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200961/* Tries to copy string <str> at once into the channel's buffer after length
Willy Tarreau974ced62012-10-12 23:11:02 +0200962 * controls. The chn->o and to_forward pointers are updated. If the channel's
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200963 * input is closed, -2 is returned. If the block is too large for this buffer,
964 * -3 is returned. If there is not enough room left in the buffer, -1 is
965 * returned. Otherwise the number of bytes copied is returned (0 being a valid
966 * number). Channel flag READ_PARTIAL is updated if some data can be
967 * transferred.
Willy Tarreau74b08c92010-09-08 17:04:31 +0200968 */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200969static inline int ci_putstr(struct channel *chn, const char *str)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200970{
Willy Tarreau06d80a92017-10-19 14:32:15 +0200971 return ci_putblk(chn, str, strlen(str));
Willy Tarreau74b08c92010-09-08 17:04:31 +0200972}
973
974/*
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200975 * Return one char from the channel's buffer. If the buffer is empty and the
976 * channel is closed, return -2. If the buffer is just empty, return -1. The
Willy Tarreau06d80a92017-10-19 14:32:15 +0200977 * buffer's pointer is not advanced, it's up to the caller to call co_skip(buf,
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200978 * 1) when it has consumed the char. Also note that this function respects the
Willy Tarreau974ced62012-10-12 23:11:02 +0200979 * chn->o limit.
Willy Tarreau74b08c92010-09-08 17:04:31 +0200980 */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200981static inline int co_getchr(struct channel *chn)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200982{
983 /* closed or empty + imminent close = -2; empty = -1 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200984 if (unlikely((chn->flags & CF_SHUTW) || channel_is_empty(chn))) {
985 if (chn->flags & (CF_SHUTW|CF_SHUTW_NOW))
Willy Tarreau74b08c92010-09-08 17:04:31 +0200986 return -2;
987 return -1;
988 }
Willy Tarreau50227f92018-06-15 15:18:17 +0200989 return *co_head(chn);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200990}
991
Willy Tarreaubaaee002006-06-26 02:48:02 +0200992
Willy Tarreauc7e42382012-08-24 19:22:53 +0200993#endif /* _PROTO_CHANNEL_H */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200994
995/*
996 * Local variables:
997 * c-indent-level: 8
998 * c-basic-offset: 8
999 * End:
1000 */