blob: 304a9357a0ef3ec34b3aa15fc4da9713e9203d8f [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 Tarreau7341d942007-05-13 19:56:02 +020025#include <stdio.h>
Willy Tarreau0f772532006-12-23 20:51:41 +010026#include <stdlib.h>
Willy Tarreau7341d942007-05-13 19:56:02 +020027#include <string.h>
Willy Tarreau0f772532006-12-23 20:51:41 +010028
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020029#include <common/config.h>
Willy Tarreauc7e42382012-08-24 19:22:53 +020030#include <common/chunk.h>
Willy Tarreau0c303ee2008-07-07 00:09:58 +020031#include <common/ticks.h>
Willy Tarreaufa645582007-06-03 15:59:52 +020032#include <common/time.h>
33
Thierry FOURNIERac836ba2014-12-16 15:41:18 +010034#include <types/channel.h>
Willy Tarreau7c3c5412009-12-13 15:53:05 +010035#include <types/global.h>
Willy Tarreau87b09662015-04-03 00:22:06 +020036#include <types/stream.h>
Willy Tarreau73796532014-11-28 14:10:28 +010037#include <types/stream_interface.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020038
Christopher Fauleta73e59b2016-12-09 17:30:18 +010039#include <proto/applet.h>
40#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 Tarreau974ced62012-10-12 23:11:02 +020048int bi_putblk(struct channel *chn, const char *str, int len);
Willy Tarreaub034b252014-12-08 18:14:53 +010049struct buffer *bi_swpbuf(struct channel *chn, struct buffer *buf);
Willy Tarreau974ced62012-10-12 23:11:02 +020050int bi_putchr(struct channel *chn, char c);
Thierry FOURNIERca16b032015-02-16 19:26:48 +010051int bi_getline_nc(struct channel *chn, char **blk1, int *len1, char **blk2, int *len2);
52int bi_getblk_nc(struct channel *chn, char **blk1, int *len1, char **blk2, int *len2);
Willy Tarreau974ced62012-10-12 23:11:02 +020053int bo_inject(struct channel *chn, const char *msg, int len);
54int bo_getline(struct channel *chn, char *str, int len);
55int bo_getblk(struct channel *chn, char *blk, int len, int offset);
Thierry FOURNIERca16b032015-02-16 19:26:48 +010056int bo_getline_nc(struct channel *chn, char **blk1, int *len1, char **blk2, int *len2);
57int bo_getblk_nc(struct channel *chn, char **blk1, int *len1, char **blk2, int *len2);
58
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 Tarreau8263d2b2012-08-28 00:06:31 +020087/* Initialize all fields in the channel. */
Willy Tarreau974ced62012-10-12 23:11:02 +020088static inline void channel_init(struct channel *chn)
Willy Tarreau54469402006-07-29 16:59:06 +020089{
Willy Tarreau2a4b5432014-11-24 11:39:34 +010090 chn->buf = &buf_empty;
Willy Tarreau974ced62012-10-12 23:11:02 +020091 chn->to_forward = 0;
Willy Tarreaub145c782014-02-09 17:45:16 +010092 chn->last_read = now_ms;
Willy Tarreau8f39dcd2014-02-09 08:31:49 +010093 chn->xfer_small = chn->xfer_large = 0;
Willy Tarreau974ced62012-10-12 23:11:02 +020094 chn->total = 0;
95 chn->pipe = NULL;
96 chn->analysers = 0;
Willy Tarreau974ced62012-10-12 23:11:02 +020097 chn->flags = 0;
Willy Tarreau54469402006-07-29 16:59:06 +020098}
99
Willy Tarreau55a69062012-10-26 00:21:52 +0200100/* Schedule up to <bytes> more bytes to be forwarded via the channel without
101 * notifying the owner task. Any data pending in the buffer are scheduled to be
102 * sent as well, in the limit of the number of bytes to forward. This must be
103 * the only method to use to schedule bytes to be forwarded. If the requested
104 * number is too large, it is automatically adjusted. The number of bytes taken
105 * into account is returned. Directly touching ->to_forward will cause lockups
106 * when buf->o goes down to zero if nobody is ready to push the remaining data.
107 */
108static inline unsigned long long channel_forward(struct channel *chn, unsigned long long bytes)
109{
110 /* hint: avoid comparisons on long long for the fast case, since if the
111 * length does not fit in an unsigned it, it will never be forwarded at
112 * once anyway.
113 */
114 if (bytes <= ~0U) {
115 unsigned int bytes32 = bytes;
116
117 if (bytes32 <= chn->buf->i) {
118 /* OK this amount of bytes might be forwarded at once */
119 b_adv(chn->buf, bytes32);
120 return bytes;
121 }
122 }
123 return __channel_forward(chn, bytes);
124}
125
Willy Tarreau8bf242b2016-05-04 14:05:58 +0200126/* Forwards any input data and marks the channel for permanent forwarding */
127static inline void channel_forward_forever(struct channel *chn)
128{
129 b_adv(chn->buf, chn->buf->i);
130 chn->to_forward = CHN_INFINITE_FORWARD;
131}
132
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200133/*********************************************************************/
134/* These functions are used to compute various channel content sizes */
135/*********************************************************************/
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100136
Willy Tarreau8e21bb92012-08-24 22:40:29 +0200137/* Reports non-zero if the channel is empty, which means both its
138 * buffer and pipe are empty. The construct looks strange but is
139 * jump-less and much more efficient on both 32 and 64-bit than
140 * the boolean test.
141 */
142static inline unsigned int channel_is_empty(struct channel *c)
143{
Willy Tarreau9b28e032012-10-12 23:49:43 +0200144 return !(c->buf->o | (long)c->pipe);
Willy Tarreau8e21bb92012-08-24 22:40:29 +0200145}
146
Willy Tarreauba0902e2015-01-13 14:39:16 +0100147/* Returns non-zero if the channel is rewritable, which means that the buffer
148 * it is attached to has at least <maxrewrite> bytes immediately available.
149 * This is used to decide when a request or response may be parsed when some
150 * data from a previous exchange might still be present.
Willy Tarreau379357a2013-06-08 12:55:46 +0200151 */
Willy Tarreauba0902e2015-01-13 14:39:16 +0100152static inline int channel_is_rewritable(const struct channel *chn)
Willy Tarreau379357a2013-06-08 12:55:46 +0200153{
154 int rem = chn->buf->size;
155
156 rem -= chn->buf->o;
157 rem -= chn->buf->i;
158 rem -= global.tune.maxrewrite;
159 return rem >= 0;
160}
161
Willy Tarreau55e58f22016-05-02 16:05:10 +0200162/* Returns non-zero if the channel is congested with data in transit waiting
163 * for leaving, indicating to the caller that it should wait for the reserve to
164 * be released before starting to process new data in case it needs the ability
165 * to append data. This is meant to be used while waiting for a clean response
166 * buffer before processing a request.
167 */
168static inline int channel_congested(const struct channel *chn)
169{
170 if (!chn->buf->o)
171 return 0;
172
173 if (!channel_is_rewritable(chn))
174 return 1;
175
176 if (chn->buf->p + chn->buf->i >
177 chn->buf->data + chn->buf->size - global.tune.maxrewrite)
178 return 1;
179
180 return 0;
181}
182
Willy Tarreau9c06ee42015-01-14 16:08:45 +0100183/* Tells whether data are likely to leave the buffer. This is used to know when
184 * we can safely ignore the reserve since we know we cannot retry a connection.
185 * It returns zero if data are blocked, non-zero otherwise.
186 */
187static inline int channel_may_send(const struct channel *chn)
188{
Willy Tarreau73796532014-11-28 14:10:28 +0100189 return chn_cons(chn)->state == SI_ST_EST;
Willy Tarreau9c06ee42015-01-14 16:08:45 +0100190}
191
Willy Tarreau3889fff2015-01-13 20:20:10 +0100192/* Returns non-zero if the channel can still receive data. This is used to
Willy Tarreau379357a2013-06-08 12:55:46 +0200193 * decide when to stop reading into a buffer when we want to ensure that we
194 * leave the reserve untouched after all pending outgoing data are forwarded.
195 * The reserved space is taken into account if ->to_forward indicates that an
196 * end of transfer is close to happen. Note that both ->buf->o and ->to_forward
197 * are considered as available since they're supposed to leave the buffer. The
198 * test is optimized to avoid as many operations as possible for the fast case
Willy Tarreau4b46a3e2016-04-20 20:09:22 +0200199 * and to be used as an "if" condition. Just like channel_recv_limit(), we
200 * never allow to overwrite the reserve until the output stream interface is
201 * connected, otherwise we could spin on a POST with http-send-name-header.
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100202 */
Willy Tarreau3889fff2015-01-13 20:20:10 +0100203static inline int channel_may_recv(const struct channel *chn)
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100204{
Willy Tarreau9b28e032012-10-12 23:49:43 +0200205 int rem = chn->buf->size;
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200206
Willy Tarreau4428a292014-11-28 20:54:13 +0100207 if (chn->buf == &buf_empty)
Willy Tarreau3889fff2015-01-13 20:20:10 +0100208 return 1;
Willy Tarreau4428a292014-11-28 20:54:13 +0100209
Willy Tarreau9b28e032012-10-12 23:49:43 +0200210 rem -= chn->buf->o;
211 rem -= chn->buf->i;
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200212 if (!rem)
Willy Tarreau3889fff2015-01-13 20:20:10 +0100213 return 0; /* buffer already full */
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200214
Willy Tarreau93dc4782016-04-21 12:12:45 +0200215 if (rem > global.tune.maxrewrite)
216 return 1; /* reserve not yet reached */
Willy Tarreau4b46a3e2016-04-20 20:09:22 +0200217
Willy Tarreau93dc4782016-04-21 12:12:45 +0200218 if (!channel_may_send(chn))
219 return 0; /* don't touch reserve until we can send */
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200220
Willy Tarreau93dc4782016-04-21 12:12:45 +0200221 /* Now we know there's some room left in the reserve and we may
222 * forward. As long as i-to_fwd < size-maxrw, we may still
223 * receive. This is equivalent to i+maxrw-size < to_fwd,
224 * which is logical since i+maxrw-size is what overlaps with
225 * the reserve, and we want to ensure they're covered by scheduled
226 * forwards.
227 */
228 rem = chn->buf->i + global.tune.maxrewrite - chn->buf->size;
229 return rem < 0 || (unsigned int)rem < chn->to_forward;
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100230}
231
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200232/* Returns true if the channel's input is already closed */
Willy Tarreau974ced62012-10-12 23:11:02 +0200233static inline int channel_input_closed(struct channel *chn)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200234{
Willy Tarreau974ced62012-10-12 23:11:02 +0200235 return ((chn->flags & CF_SHUTR) != 0);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200236}
237
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200238/* Returns true if the channel's output is already closed */
Willy Tarreau974ced62012-10-12 23:11:02 +0200239static inline int channel_output_closed(struct channel *chn)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200240{
Willy Tarreau974ced62012-10-12 23:11:02 +0200241 return ((chn->flags & CF_SHUTW) != 0);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200242}
243
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200244/* Check channel timeouts, and set the corresponding flags. The likely/unlikely
245 * have been optimized for fastest normal path. The read/write timeouts are not
246 * set if there was activity on the channel. That way, we don't have to update
247 * the timeout on every I/O. Note that the analyser timeout is always checked.
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200248 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200249static inline void channel_check_timeouts(struct channel *chn)
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200250{
Willy Tarreau974ced62012-10-12 23:11:02 +0200251 if (likely(!(chn->flags & (CF_SHUTR|CF_READ_TIMEOUT|CF_READ_ACTIVITY|CF_READ_NOEXP))) &&
252 unlikely(tick_is_expired(chn->rex, now_ms)))
253 chn->flags |= CF_READ_TIMEOUT;
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200254
Willy Tarreau974ced62012-10-12 23:11:02 +0200255 if (likely(!(chn->flags & (CF_SHUTW|CF_WRITE_TIMEOUT|CF_WRITE_ACTIVITY))) &&
256 unlikely(tick_is_expired(chn->wex, now_ms)))
257 chn->flags |= CF_WRITE_TIMEOUT;
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200258
Willy Tarreau974ced62012-10-12 23:11:02 +0200259 if (likely(!(chn->flags & CF_ANA_TIMEOUT)) &&
260 unlikely(tick_is_expired(chn->analyse_exp, now_ms)))
261 chn->flags |= CF_ANA_TIMEOUT;
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200262}
263
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200264/* Erase any content from channel <buf> and adjusts flags accordingly. Note
Willy Tarreau0abebcc2009-01-08 00:09:41 +0100265 * that any spliced data is not affected since we may not have any access to
266 * it.
Willy Tarreaue393fe22008-08-16 22:18:07 +0200267 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200268static inline void channel_erase(struct channel *chn)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200269{
Willy Tarreau974ced62012-10-12 23:11:02 +0200270 chn->to_forward = 0;
Willy Tarreau474cf542014-11-24 10:54:47 +0100271 b_reset(chn->buf);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200272}
273
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200274/* marks the channel as "shutdown" ASAP for reads */
Willy Tarreau974ced62012-10-12 23:11:02 +0200275static inline void channel_shutr_now(struct channel *chn)
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200276{
Willy Tarreau974ced62012-10-12 23:11:02 +0200277 chn->flags |= CF_SHUTR_NOW;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200278}
279
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200280/* marks the channel as "shutdown" ASAP for writes */
Willy Tarreau974ced62012-10-12 23:11:02 +0200281static inline void channel_shutw_now(struct channel *chn)
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200282{
Willy Tarreau974ced62012-10-12 23:11:02 +0200283 chn->flags |= CF_SHUTW_NOW;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200284}
285
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200286/* marks the channel as "shutdown" ASAP in both directions */
Willy Tarreau974ced62012-10-12 23:11:02 +0200287static inline void channel_abort(struct channel *chn)
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200288{
Willy Tarreau974ced62012-10-12 23:11:02 +0200289 chn->flags |= CF_SHUTR_NOW | CF_SHUTW_NOW;
290 chn->flags &= ~CF_AUTO_CONNECT;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200291}
292
Willy Tarreau520d95e2009-09-19 21:04:57 +0200293/* allow the consumer to try to establish a new connection. */
Willy Tarreau974ced62012-10-12 23:11:02 +0200294static inline void channel_auto_connect(struct channel *chn)
Willy Tarreau3da77c52008-08-29 09:58:42 +0200295{
Willy Tarreau974ced62012-10-12 23:11:02 +0200296 chn->flags |= CF_AUTO_CONNECT;
Willy Tarreau3da77c52008-08-29 09:58:42 +0200297}
298
Willy Tarreau520d95e2009-09-19 21:04:57 +0200299/* prevent the consumer from trying to establish a new connection, and also
300 * disable auto shutdown forwarding.
301 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200302static inline void channel_dont_connect(struct channel *chn)
Willy Tarreau3da77c52008-08-29 09:58:42 +0200303{
Willy Tarreau974ced62012-10-12 23:11:02 +0200304 chn->flags &= ~(CF_AUTO_CONNECT|CF_AUTO_CLOSE);
Willy Tarreau3da77c52008-08-29 09:58:42 +0200305}
306
Willy Tarreau520d95e2009-09-19 21:04:57 +0200307/* allow the producer to forward shutdown requests */
Willy Tarreau974ced62012-10-12 23:11:02 +0200308static inline void channel_auto_close(struct channel *chn)
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100309{
Willy Tarreau974ced62012-10-12 23:11:02 +0200310 chn->flags |= CF_AUTO_CLOSE;
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100311}
312
Willy Tarreau520d95e2009-09-19 21:04:57 +0200313/* prevent the producer from forwarding shutdown requests */
Willy Tarreau974ced62012-10-12 23:11:02 +0200314static inline void channel_dont_close(struct channel *chn)
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100315{
Willy Tarreau974ced62012-10-12 23:11:02 +0200316 chn->flags &= ~CF_AUTO_CLOSE;
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100317}
318
Willy Tarreau90deb182010-01-07 00:20:41 +0100319/* allow the producer to read / poll the input */
Willy Tarreau974ced62012-10-12 23:11:02 +0200320static inline void channel_auto_read(struct channel *chn)
Willy Tarreau90deb182010-01-07 00:20:41 +0100321{
Willy Tarreau974ced62012-10-12 23:11:02 +0200322 chn->flags &= ~CF_DONT_READ;
Willy Tarreau90deb182010-01-07 00:20:41 +0100323}
324
325/* prevent the producer from read / poll the input */
Willy Tarreau974ced62012-10-12 23:11:02 +0200326static inline void channel_dont_read(struct channel *chn)
Willy Tarreau90deb182010-01-07 00:20:41 +0100327{
Willy Tarreau974ced62012-10-12 23:11:02 +0200328 chn->flags |= CF_DONT_READ;
Willy Tarreau90deb182010-01-07 00:20:41 +0100329}
330
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200331
332/*************************************************/
333/* Buffer operations in the context of a channel */
334/*************************************************/
335
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200336
337/* Return the max number of bytes the buffer can contain so that once all the
Willy Tarreau169c4702016-04-20 18:05:17 +0200338 * pending bytes are forwarded, the buffer still has global.tune.maxrewrite
Willy Tarreau974ced62012-10-12 23:11:02 +0200339 * bytes free. The result sits between chn->size - maxrewrite and chn->size.
Willy Tarreau169c4702016-04-20 18:05:17 +0200340 * It is important to mention that if buf->i is already larger than size-maxrw
341 * the condition above cannot be satisfied and the lowest size will be returned
342 * anyway. The principles are the following :
343 * 0) the empty buffer has a limit of zero
344 * 1) a non-connected buffer cannot touch the reserve
345 * 2) infinite forward can always fill the buffer since all data will leave
346 * 3) all output bytes are considered in transit since they're leaving
347 * 4) all input bytes covered by to_forward are considered in transit since
348 * they'll be converted to output bytes.
349 * 5) all input bytes not covered by to_forward as considered remaining
350 * 6) all bytes scheduled to be forwarded minus what is already in the input
351 * buffer will be in transit during future rounds.
352 * 7) 4+5+6 imply that the amount of input bytes (i) is irrelevant to the max
353 * usable length, only to_forward and output count. The difference is
354 * visible when to_forward > i.
355 * 8) the reserve may be covered up to the amount of bytes in transit since
356 * these bytes will only take temporary space.
Willy Tarreau999f6432016-01-25 01:09:11 +0100357 *
Willy Tarreau169c4702016-04-20 18:05:17 +0200358 * A typical buffer looks like this :
Willy Tarreau999f6432016-01-25 01:09:11 +0100359 *
Willy Tarreau169c4702016-04-20 18:05:17 +0200360 * <-------------- max_len ----------->
361 * <---- o ----><----- i -----> <--- 0..maxrewrite --->
362 * +------------+--------------+-------+----------------------+
363 * |////////////|\\\\\\\\\\\\\\|xxxxxxx| reserve |
364 * +------------+--------+-----+-------+----------------------+
365 * <- fwd -> <-avail->
366 *
367 * Or when to_forward > i :
368 *
369 * <-------------- max_len ----------->
370 * <---- o ----><----- i -----> <--- 0..maxrewrite --->
371 * +------------+--------------+-------+----------------------+
372 * |////////////|\\\\\\\\\\\\\\|xxxxxxx| reserve |
373 * +------------+--------+-----+-------+----------------------+
374 * <-avail->
375 * <------------------ fwd ---------------->
376 *
377 * - the amount of buffer bytes in transit is : min(i, fwd) + o
378 * - some scheduled bytes may be in transit (up to fwd - i)
379 * - the reserve is max(0, maxrewrite - transit)
380 * - the maximum usable buffer length is size - reserve.
381 * - the available space is max_len - i - o
382 *
383 * So the formula to compute the buffer's maximum length to protect the reserve
384 * when reading new data is :
385 *
386 * max = size - maxrewrite + min(maxrewrite, transit)
387 * = size - max(maxrewrite - transit, 0)
388 *
389 * But WARNING! The conditions might change during the transfer and it could
390 * very well happen that a buffer would contain more bytes than max_len due to
391 * i+o already walking over the reserve (eg: after a header rewrite), including
392 * i or o alone hitting the limit. So it is critical to always consider that
393 * bounds may have already been crossed and that available space may be negative
394 * for example. Due to this it is perfectly possible for this function to return
395 * a value that is lower than current i+o.
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200396 */
Willy Tarreau3f5096d2015-01-14 20:21:43 +0100397static inline int channel_recv_limit(const struct channel *chn)
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200398{
Willy Tarreauef907fe2016-05-03 17:46:24 +0200399 unsigned int transit;
Willy Tarreau999f6432016-01-25 01:09:11 +0100400 int reserve;
401
402 /* return zero if empty */
403 reserve = chn->buf->size;
404 if (chn->buf == &buf_empty)
405 goto end;
406
407 /* return size - maxrewrite if we can't send */
408 reserve = global.tune.maxrewrite;
409 if (unlikely(!channel_may_send(chn)))
410 goto end;
411
Willy Tarreauef907fe2016-05-03 17:46:24 +0200412 /* We need to check what remains of the reserve after o and to_forward
413 * have been transmitted, but they can overflow together and they can
414 * cause an integer underflow in the comparison since both are unsigned
415 * while maxrewrite is signed.
416 * The code below has been verified for being a valid check for this :
417 * - if (o + to_forward) overflow => return size [ large enough ]
418 * - if o + to_forward >= maxrw => return size [ large enough ]
419 * - otherwise return size - (maxrw - (o + to_forward))
Willy Tarreau999f6432016-01-25 01:09:11 +0100420 */
Willy Tarreauef907fe2016-05-03 17:46:24 +0200421 transit = chn->buf->o + chn->to_forward;
422 reserve -= transit;
423 if (transit < chn->to_forward || // addition overflow
424 transit >= (unsigned)global.tune.maxrewrite) // enough transit data
Willy Tarreau169c4702016-04-20 18:05:17 +0200425 return chn->buf->size;
Willy Tarreau999f6432016-01-25 01:09:11 +0100426 end:
427 return chn->buf->size - reserve;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200428}
429
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200430/* Returns the amount of space available at the input of the buffer, taking the
431 * reserved space into account if ->to_forward indicates that an end of transfer
432 * is close to happen. The test is optimized to avoid as many operations as
433 * possible for the fast case.
434 */
Willy Tarreaub5051f82015-01-14 20:25:34 +0100435static inline int channel_recv_max(const struct channel *chn)
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200436{
Willy Tarreau27bb0e12015-01-14 15:56:50 +0100437 int ret;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200438
Willy Tarreau3f5096d2015-01-14 20:21:43 +0100439 ret = channel_recv_limit(chn) - chn->buf->i - chn->buf->o;
Willy Tarreau27bb0e12015-01-14 15:56:50 +0100440 if (ret < 0)
441 ret = 0;
442 return ret;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200443}
444
Christopher Fauleta73e59b2016-12-09 17:30:18 +0100445/* Allocates a buffer for channel <chn>, but only if it's guaranteed that it's
446 * not the last available buffer or it's the response buffer. Unless the buffer
447 * is the response buffer, an extra control is made so that we always keep
448 * <tune.buffers.reserved> buffers available after this allocation. Returns 0 in
449 * case of failure, non-zero otherwise.
450 *
451 * If no buffer are available, the requester, represented by <wait> pointer,
452 * will be added in the list of objects waiting for an available buffer.
453 */
454static inline int channel_alloc_buffer(struct channel *chn, struct buffer_wait *wait)
455{
456 int margin = 0;
457
458 if (!(chn->flags & CF_ISRESP))
459 margin = global.tune.reserved_bufs;
460
461 if (b_alloc_margin(&chn->buf, margin) != NULL)
462 return 1;
463
464 if (LIST_ISEMPTY(&wait->list))
465 LIST_ADDQ(&buffer_wq, &wait->list);
466 return 0;
467}
468
469/* Releases a possibly allocated buffer for channel <chn>. If it was not
470 * allocated, this function does nothing. Else the buffer is released and we try
471 * to wake up as many streams/applets as possible. */
472static inline void channel_release_buffer(struct channel *chn, struct buffer_wait *wait)
473{
474 if (chn->buf->size && buffer_empty(chn->buf)) {
475 b_free(&chn->buf);
476 offer_buffers(wait->target, tasks_run_queue + applets_active_queue);
477 }
478}
479
Willy Tarreau319f7452015-01-14 20:32:59 +0100480/* Truncate any unread data in the channel's buffer, and disable forwarding.
481 * Outgoing data are left intact. This is mainly to be used to send error
482 * messages after existing data.
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200483 */
Willy Tarreau319f7452015-01-14 20:32:59 +0100484static inline void channel_truncate(struct channel *chn)
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200485{
Willy Tarreau9b28e032012-10-12 23:49:43 +0200486 if (!chn->buf->o)
Willy Tarreau974ced62012-10-12 23:11:02 +0200487 return channel_erase(chn);
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200488
Willy Tarreau974ced62012-10-12 23:11:02 +0200489 chn->to_forward = 0;
Willy Tarreau9b28e032012-10-12 23:49:43 +0200490 if (!chn->buf->i)
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200491 return;
492
Willy Tarreau9b28e032012-10-12 23:49:43 +0200493 chn->buf->i = 0;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200494}
495
Willy Tarreaubaaee002006-06-26 02:48:02 +0200496/*
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200497 * Advance the channel buffer's read pointer by <len> bytes. This is useful
498 * when data have been read directly from the buffer. It is illegal to call
499 * this function with <len> causing a wrapping at the end of the buffer. It's
500 * the caller's responsibility to ensure that <len> is never larger than
Willy Tarreau974ced62012-10-12 23:11:02 +0200501 * chn->o. Channel flag WRITE_PARTIAL is set.
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200502 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200503static inline void bo_skip(struct channel *chn, int len)
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200504{
Willy Tarreau9b28e032012-10-12 23:49:43 +0200505 chn->buf->o -= len;
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200506
Willy Tarreau5fb38032012-12-16 19:39:09 +0100507 if (buffer_empty(chn->buf))
Willy Tarreau9b28e032012-10-12 23:49:43 +0200508 chn->buf->p = chn->buf->data;
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200509
Willy Tarreaufb0e9202009-09-23 23:47:55 +0200510 /* notify that some data was written to the SI from the buffer */
Willy Tarreau974ced62012-10-12 23:11:02 +0200511 chn->flags |= CF_WRITE_PARTIAL;
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200512}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200513
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200514/* Tries to copy chunk <chunk> into the channel's buffer after length controls.
Willy Tarreau974ced62012-10-12 23:11:02 +0200515 * The chn->o and to_forward pointers are updated. If the channel's input is
Willy Tarreau74b08c92010-09-08 17:04:31 +0200516 * closed, -2 is returned. If the block is too large for this buffer, -3 is
517 * returned. If there is not enough room left in the buffer, -1 is returned.
518 * Otherwise the number of bytes copied is returned (0 being a valid number).
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200519 * Channel flag READ_PARTIAL is updated if some data can be transferred. The
Willy Tarreauf941cf22012-08-27 20:53:34 +0200520 * chunk's length is updated with the number of bytes sent.
Willy Tarreauaeac3192009-08-31 08:09:57 +0200521 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200522static inline int bi_putchk(struct channel *chn, struct chunk *chunk)
Willy Tarreauaeac3192009-08-31 08:09:57 +0200523{
524 int ret;
525
Willy Tarreau974ced62012-10-12 23:11:02 +0200526 ret = bi_putblk(chn, chunk->str, chunk->len);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200527 if (ret > 0)
528 chunk->len -= ret;
Willy Tarreauaeac3192009-08-31 08:09:57 +0200529 return ret;
530}
531
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200532/* Tries to copy string <str> at once into the channel's buffer after length
Willy Tarreau974ced62012-10-12 23:11:02 +0200533 * controls. The chn->o and to_forward pointers are updated. If the channel's
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200534 * input is closed, -2 is returned. If the block is too large for this buffer,
535 * -3 is returned. If there is not enough room left in the buffer, -1 is
536 * returned. Otherwise the number of bytes copied is returned (0 being a valid
537 * number). Channel flag READ_PARTIAL is updated if some data can be
538 * transferred.
Willy Tarreau74b08c92010-09-08 17:04:31 +0200539 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200540static inline int bi_putstr(struct channel *chn, const char *str)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200541{
Willy Tarreau974ced62012-10-12 23:11:02 +0200542 return bi_putblk(chn, str, strlen(str));
Willy Tarreau74b08c92010-09-08 17:04:31 +0200543}
544
545/*
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200546 * Return one char from the channel's buffer. If the buffer is empty and the
547 * channel is closed, return -2. If the buffer is just empty, return -1. The
548 * buffer's pointer is not advanced, it's up to the caller to call bo_skip(buf,
549 * 1) when it has consumed the char. Also note that this function respects the
Willy Tarreau974ced62012-10-12 23:11:02 +0200550 * chn->o limit.
Willy Tarreau74b08c92010-09-08 17:04:31 +0200551 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200552static inline int bo_getchr(struct channel *chn)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200553{
554 /* closed or empty + imminent close = -2; empty = -1 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200555 if (unlikely((chn->flags & CF_SHUTW) || channel_is_empty(chn))) {
556 if (chn->flags & (CF_SHUTW|CF_SHUTW_NOW))
Willy Tarreau74b08c92010-09-08 17:04:31 +0200557 return -2;
558 return -1;
559 }
Willy Tarreau9b28e032012-10-12 23:49:43 +0200560 return *buffer_wrap_sub(chn->buf, chn->buf->p - chn->buf->o);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200561}
562
Willy Tarreaubaaee002006-06-26 02:48:02 +0200563
Willy Tarreauc7e42382012-08-24 19:22:53 +0200564#endif /* _PROTO_CHANNEL_H */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200565
566/*
567 * Local variables:
568 * c-indent-level: 8
569 * c-basic-offset: 8
570 * End:
571 */