blob: b1c313ce6ef5101a4faa8c5a0748857ff7dfd4a0 [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
Willy Tarreau7341d942007-05-13 19:56:02 +020039/* perform minimal intializations, report 0 in case of error, 1 if OK. */
Willy Tarreau8263d2b2012-08-28 00:06:31 +020040int init_channel();
Willy Tarreau7341d942007-05-13 19:56:02 +020041
Willy Tarreau55a69062012-10-26 00:21:52 +020042unsigned long long __channel_forward(struct channel *chn, unsigned long long bytes);
Willy Tarreau8263d2b2012-08-28 00:06:31 +020043
44/* SI-to-channel functions working with buffers */
Willy Tarreau974ced62012-10-12 23:11:02 +020045int bi_putblk(struct channel *chn, const char *str, int len);
Willy Tarreaub034b252014-12-08 18:14:53 +010046struct buffer *bi_swpbuf(struct channel *chn, struct buffer *buf);
Willy Tarreau974ced62012-10-12 23:11:02 +020047int bi_putchr(struct channel *chn, char c);
Thierry FOURNIERca16b032015-02-16 19:26:48 +010048int bi_getline_nc(struct channel *chn, char **blk1, int *len1, char **blk2, int *len2);
49int bi_getblk_nc(struct channel *chn, char **blk1, int *len1, char **blk2, int *len2);
Willy Tarreau974ced62012-10-12 23:11:02 +020050int bo_inject(struct channel *chn, const char *msg, int len);
51int bo_getline(struct channel *chn, char *str, int len);
52int bo_getblk(struct channel *chn, char *blk, int len, int offset);
Thierry FOURNIERca16b032015-02-16 19:26:48 +010053int bo_getline_nc(struct channel *chn, char **blk1, int *len1, char **blk2, int *len2);
54int bo_getblk_nc(struct channel *chn, char **blk1, int *len1, char **blk2, int *len2);
55
Willy Tarreau74b08c92010-09-08 17:04:31 +020056
Willy Tarreau87b09662015-04-03 00:22:06 +020057/* returns a pointer to the stream the channel belongs to */
58static inline struct stream *chn_sess(const struct channel *chn)
Willy Tarreaud5ccfa32014-12-28 13:03:53 +010059{
60 if (chn->flags & CF_ISRESP)
Willy Tarreau87b09662015-04-03 00:22:06 +020061 return LIST_ELEM(chn, struct stream *, res);
Willy Tarreaud5ccfa32014-12-28 13:03:53 +010062 else
Willy Tarreau87b09662015-04-03 00:22:06 +020063 return LIST_ELEM(chn, struct stream *, req);
Willy Tarreaud5ccfa32014-12-28 13:03:53 +010064}
65
Willy Tarreau73796532014-11-28 14:10:28 +010066/* returns a pointer to the stream interface feeding the channel (producer) */
67static inline struct stream_interface *chn_prod(const struct channel *chn)
68{
Willy Tarreau5decc052014-11-28 14:22:12 +010069 if (chn->flags & CF_ISRESP)
Willy Tarreau87b09662015-04-03 00:22:06 +020070 return &LIST_ELEM(chn, struct stream *, res)->si[1];
Willy Tarreau5decc052014-11-28 14:22:12 +010071 else
Willy Tarreau87b09662015-04-03 00:22:06 +020072 return &LIST_ELEM(chn, struct stream *, req)->si[0];
Willy Tarreau73796532014-11-28 14:10:28 +010073}
74
75/* returns a pointer to the stream interface consuming the channel (producer) */
76static inline struct stream_interface *chn_cons(const struct channel *chn)
77{
Willy Tarreau5decc052014-11-28 14:22:12 +010078 if (chn->flags & CF_ISRESP)
Willy Tarreau87b09662015-04-03 00:22:06 +020079 return &LIST_ELEM(chn, struct stream *, res)->si[0];
Willy Tarreau5decc052014-11-28 14:22:12 +010080 else
Willy Tarreau87b09662015-04-03 00:22:06 +020081 return &LIST_ELEM(chn, struct stream *, req)->si[1];
Willy Tarreau73796532014-11-28 14:10:28 +010082}
83
Willy Tarreau8263d2b2012-08-28 00:06:31 +020084/* Initialize all fields in the channel. */
Willy Tarreau974ced62012-10-12 23:11:02 +020085static inline void channel_init(struct channel *chn)
Willy Tarreau54469402006-07-29 16:59:06 +020086{
Willy Tarreau2a4b5432014-11-24 11:39:34 +010087 chn->buf = &buf_empty;
Willy Tarreau974ced62012-10-12 23:11:02 +020088 chn->to_forward = 0;
Willy Tarreaub145c782014-02-09 17:45:16 +010089 chn->last_read = now_ms;
Willy Tarreau8f39dcd2014-02-09 08:31:49 +010090 chn->xfer_small = chn->xfer_large = 0;
Willy Tarreau974ced62012-10-12 23:11:02 +020091 chn->total = 0;
92 chn->pipe = NULL;
93 chn->analysers = 0;
Willy Tarreau974ced62012-10-12 23:11:02 +020094 chn->flags = 0;
Willy Tarreau54469402006-07-29 16:59:06 +020095}
96
Willy Tarreau55a69062012-10-26 00:21:52 +020097/* Schedule up to <bytes> more bytes to be forwarded via the channel without
98 * notifying the owner task. Any data pending in the buffer are scheduled to be
99 * sent as well, in the limit of the number of bytes to forward. This must be
100 * the only method to use to schedule bytes to be forwarded. If the requested
101 * number is too large, it is automatically adjusted. The number of bytes taken
102 * into account is returned. Directly touching ->to_forward will cause lockups
103 * when buf->o goes down to zero if nobody is ready to push the remaining data.
104 */
105static inline unsigned long long channel_forward(struct channel *chn, unsigned long long bytes)
106{
107 /* hint: avoid comparisons on long long for the fast case, since if the
108 * length does not fit in an unsigned it, it will never be forwarded at
109 * once anyway.
110 */
111 if (bytes <= ~0U) {
112 unsigned int bytes32 = bytes;
113
114 if (bytes32 <= chn->buf->i) {
115 /* OK this amount of bytes might be forwarded at once */
116 b_adv(chn->buf, bytes32);
117 return bytes;
118 }
119 }
120 return __channel_forward(chn, bytes);
121}
122
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200123/*********************************************************************/
124/* These functions are used to compute various channel content sizes */
125/*********************************************************************/
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100126
Willy Tarreau8e21bb92012-08-24 22:40:29 +0200127/* Reports non-zero if the channel is empty, which means both its
128 * buffer and pipe are empty. The construct looks strange but is
129 * jump-less and much more efficient on both 32 and 64-bit than
130 * the boolean test.
131 */
132static inline unsigned int channel_is_empty(struct channel *c)
133{
Willy Tarreau9b28e032012-10-12 23:49:43 +0200134 return !(c->buf->o | (long)c->pipe);
Willy Tarreau8e21bb92012-08-24 22:40:29 +0200135}
136
Willy Tarreauba0902e2015-01-13 14:39:16 +0100137/* Returns non-zero if the channel is rewritable, which means that the buffer
138 * it is attached to has at least <maxrewrite> bytes immediately available.
139 * This is used to decide when a request or response may be parsed when some
140 * data from a previous exchange might still be present.
Willy Tarreau379357a2013-06-08 12:55:46 +0200141 */
Willy Tarreauba0902e2015-01-13 14:39:16 +0100142static inline int channel_is_rewritable(const struct channel *chn)
Willy Tarreau379357a2013-06-08 12:55:46 +0200143{
144 int rem = chn->buf->size;
145
146 rem -= chn->buf->o;
147 rem -= chn->buf->i;
148 rem -= global.tune.maxrewrite;
149 return rem >= 0;
150}
151
Willy Tarreau9c06ee42015-01-14 16:08:45 +0100152/* Tells whether data are likely to leave the buffer. This is used to know when
153 * we can safely ignore the reserve since we know we cannot retry a connection.
154 * It returns zero if data are blocked, non-zero otherwise.
155 */
156static inline int channel_may_send(const struct channel *chn)
157{
Willy Tarreau73796532014-11-28 14:10:28 +0100158 return chn_cons(chn)->state == SI_ST_EST;
Willy Tarreau9c06ee42015-01-14 16:08:45 +0100159}
160
Willy Tarreau1a4484d2015-01-13 20:09:54 +0100161/* Returns the amount of bytes from the channel that are already scheduled for
162 * leaving (buf->o) or that are still part of the input and expected to be sent
163 * soon as covered by to_forward. This is useful to know by how much we can
Willy Tarreau9c06ee42015-01-14 16:08:45 +0100164 * shrink the rewrite reserve during forwards. Buffer data are not considered
165 * in transit until the channel is connected, so that the reserve remains
166 * protected.
Willy Tarreau1a4484d2015-01-13 20:09:54 +0100167 */
168static inline int channel_in_transit(const struct channel *chn)
169{
170 int ret;
171
Willy Tarreau9c06ee42015-01-14 16:08:45 +0100172 if (!channel_may_send(chn))
173 return 0;
174
Willy Tarreau1a4484d2015-01-13 20:09:54 +0100175 /* below, this is min(i, to_forward) optimized for the fast case */
176 if (chn->to_forward >= chn->buf->i ||
177 (CHN_INFINITE_FORWARD < MAX_RANGE(typeof(chn->buf->i)) &&
178 chn->to_forward == CHN_INFINITE_FORWARD))
179 ret = chn->buf->i;
180 else
181 ret = chn->to_forward;
182
183 ret += chn->buf->o;
184 return ret;
185}
186
Willy Tarreau3889fff2015-01-13 20:20:10 +0100187/* Returns non-zero if the channel can still receive data. This is used to
Willy Tarreau379357a2013-06-08 12:55:46 +0200188 * decide when to stop reading into a buffer when we want to ensure that we
189 * leave the reserve untouched after all pending outgoing data are forwarded.
190 * The reserved space is taken into account if ->to_forward indicates that an
191 * end of transfer is close to happen. Note that both ->buf->o and ->to_forward
192 * are considered as available since they're supposed to leave the buffer. The
193 * test is optimized to avoid as many operations as possible for the fast case
194 * and to be used as an "if" condition.
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100195 */
Willy Tarreau3889fff2015-01-13 20:20:10 +0100196static inline int channel_may_recv(const struct channel *chn)
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100197{
Willy Tarreau9b28e032012-10-12 23:49:43 +0200198 int rem = chn->buf->size;
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200199
Willy Tarreau4428a292014-11-28 20:54:13 +0100200 if (chn->buf == &buf_empty)
Willy Tarreau3889fff2015-01-13 20:20:10 +0100201 return 1;
Willy Tarreau4428a292014-11-28 20:54:13 +0100202
Willy Tarreau9b28e032012-10-12 23:49:43 +0200203 rem -= chn->buf->o;
204 rem -= chn->buf->i;
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200205 if (!rem)
Willy Tarreau3889fff2015-01-13 20:20:10 +0100206 return 0; /* buffer already full */
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200207
Willy Tarreaubb3f9942015-01-13 19:07:23 +0100208 /* now we know there's some room left, verify if we're touching
209 * the reserve with some permanent input data.
210 */
211 if (chn->to_forward >= chn->buf->i ||
212 (CHN_INFINITE_FORWARD < MAX_RANGE(typeof(chn->buf->i)) && // just there to ensure gcc
213 chn->to_forward == CHN_INFINITE_FORWARD)) // avoids the useless second
Willy Tarreau3889fff2015-01-13 20:20:10 +0100214 return 1; // test whenever possible
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200215
216 rem -= global.tune.maxrewrite;
Willy Tarreau9b28e032012-10-12 23:49:43 +0200217 rem += chn->buf->o;
Willy Tarreau974ced62012-10-12 23:11:02 +0200218 rem += chn->to_forward;
Willy Tarreau3889fff2015-01-13 20:20:10 +0100219 return rem > 0;
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100220}
221
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200222/* Returns true if the channel's input is already closed */
Willy Tarreau974ced62012-10-12 23:11:02 +0200223static inline int channel_input_closed(struct channel *chn)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200224{
Willy Tarreau974ced62012-10-12 23:11:02 +0200225 return ((chn->flags & CF_SHUTR) != 0);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200226}
227
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200228/* Returns true if the channel's output is already closed */
Willy Tarreau974ced62012-10-12 23:11:02 +0200229static inline int channel_output_closed(struct channel *chn)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200230{
Willy Tarreau974ced62012-10-12 23:11:02 +0200231 return ((chn->flags & CF_SHUTW) != 0);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200232}
233
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200234/* Check channel timeouts, and set the corresponding flags. The likely/unlikely
235 * have been optimized for fastest normal path. The read/write timeouts are not
236 * set if there was activity on the channel. That way, we don't have to update
237 * the timeout on every I/O. Note that the analyser timeout is always checked.
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200238 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200239static inline void channel_check_timeouts(struct channel *chn)
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200240{
Willy Tarreau974ced62012-10-12 23:11:02 +0200241 if (likely(!(chn->flags & (CF_SHUTR|CF_READ_TIMEOUT|CF_READ_ACTIVITY|CF_READ_NOEXP))) &&
242 unlikely(tick_is_expired(chn->rex, now_ms)))
243 chn->flags |= CF_READ_TIMEOUT;
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200244
Willy Tarreau974ced62012-10-12 23:11:02 +0200245 if (likely(!(chn->flags & (CF_SHUTW|CF_WRITE_TIMEOUT|CF_WRITE_ACTIVITY))) &&
246 unlikely(tick_is_expired(chn->wex, now_ms)))
247 chn->flags |= CF_WRITE_TIMEOUT;
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200248
Willy Tarreau974ced62012-10-12 23:11:02 +0200249 if (likely(!(chn->flags & CF_ANA_TIMEOUT)) &&
250 unlikely(tick_is_expired(chn->analyse_exp, now_ms)))
251 chn->flags |= CF_ANA_TIMEOUT;
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200252}
253
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200254/* Erase any content from channel <buf> and adjusts flags accordingly. Note
Willy Tarreau0abebcc2009-01-08 00:09:41 +0100255 * that any spliced data is not affected since we may not have any access to
256 * it.
Willy Tarreaue393fe22008-08-16 22:18:07 +0200257 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200258static inline void channel_erase(struct channel *chn)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200259{
Willy Tarreau974ced62012-10-12 23:11:02 +0200260 chn->to_forward = 0;
Willy Tarreau474cf542014-11-24 10:54:47 +0100261 b_reset(chn->buf);
Willy Tarreaubaaee002006-06-26 02:48:02 +0200262}
263
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200264/* marks the channel as "shutdown" ASAP for reads */
Willy Tarreau974ced62012-10-12 23:11:02 +0200265static inline void channel_shutr_now(struct channel *chn)
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200266{
Willy Tarreau974ced62012-10-12 23:11:02 +0200267 chn->flags |= CF_SHUTR_NOW;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200268}
269
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200270/* marks the channel as "shutdown" ASAP for writes */
Willy Tarreau974ced62012-10-12 23:11:02 +0200271static inline void channel_shutw_now(struct channel *chn)
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200272{
Willy Tarreau974ced62012-10-12 23:11:02 +0200273 chn->flags |= CF_SHUTW_NOW;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200274}
275
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200276/* marks the channel as "shutdown" ASAP in both directions */
Willy Tarreau974ced62012-10-12 23:11:02 +0200277static inline void channel_abort(struct channel *chn)
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200278{
Willy Tarreau974ced62012-10-12 23:11:02 +0200279 chn->flags |= CF_SHUTR_NOW | CF_SHUTW_NOW;
280 chn->flags &= ~CF_AUTO_CONNECT;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200281}
282
Willy Tarreau520d95e2009-09-19 21:04:57 +0200283/* allow the consumer to try to establish a new connection. */
Willy Tarreau974ced62012-10-12 23:11:02 +0200284static inline void channel_auto_connect(struct channel *chn)
Willy Tarreau3da77c52008-08-29 09:58:42 +0200285{
Willy Tarreau974ced62012-10-12 23:11:02 +0200286 chn->flags |= CF_AUTO_CONNECT;
Willy Tarreau3da77c52008-08-29 09:58:42 +0200287}
288
Willy Tarreau520d95e2009-09-19 21:04:57 +0200289/* prevent the consumer from trying to establish a new connection, and also
290 * disable auto shutdown forwarding.
291 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200292static inline void channel_dont_connect(struct channel *chn)
Willy Tarreau3da77c52008-08-29 09:58:42 +0200293{
Willy Tarreau974ced62012-10-12 23:11:02 +0200294 chn->flags &= ~(CF_AUTO_CONNECT|CF_AUTO_CLOSE);
Willy Tarreau3da77c52008-08-29 09:58:42 +0200295}
296
Willy Tarreau520d95e2009-09-19 21:04:57 +0200297/* allow the producer to forward shutdown requests */
Willy Tarreau974ced62012-10-12 23:11:02 +0200298static inline void channel_auto_close(struct channel *chn)
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100299{
Willy Tarreau974ced62012-10-12 23:11:02 +0200300 chn->flags |= CF_AUTO_CLOSE;
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100301}
302
Willy Tarreau520d95e2009-09-19 21:04:57 +0200303/* prevent the producer from forwarding shutdown requests */
Willy Tarreau974ced62012-10-12 23:11:02 +0200304static inline void channel_dont_close(struct channel *chn)
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100305{
Willy Tarreau974ced62012-10-12 23:11:02 +0200306 chn->flags &= ~CF_AUTO_CLOSE;
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100307}
308
Willy Tarreau90deb182010-01-07 00:20:41 +0100309/* allow the producer to read / poll the input */
Willy Tarreau974ced62012-10-12 23:11:02 +0200310static inline void channel_auto_read(struct channel *chn)
Willy Tarreau90deb182010-01-07 00:20:41 +0100311{
Willy Tarreau974ced62012-10-12 23:11:02 +0200312 chn->flags &= ~CF_DONT_READ;
Willy Tarreau90deb182010-01-07 00:20:41 +0100313}
314
315/* prevent the producer from read / poll the input */
Willy Tarreau974ced62012-10-12 23:11:02 +0200316static inline void channel_dont_read(struct channel *chn)
Willy Tarreau90deb182010-01-07 00:20:41 +0100317{
Willy Tarreau974ced62012-10-12 23:11:02 +0200318 chn->flags |= CF_DONT_READ;
Willy Tarreau90deb182010-01-07 00:20:41 +0100319}
320
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200321
322/*************************************************/
323/* Buffer operations in the context of a channel */
324/*************************************************/
325
326
327/* Return the number of reserved bytes in the channel's visible
328 * buffer, which ensures that once all pending data are forwarded, the
329 * buffer still has global.tune.maxrewrite bytes free. The result is
330 * between 0 and global.tune.maxrewrite, which is itself smaller than
Willy Tarreau0428a142015-01-08 11:34:55 +0100331 * any chn->size. Special care is taken to avoid any possible integer
332 * overflow in the operations.
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200333 */
Willy Tarreaua4178192015-01-14 20:16:52 +0100334static inline int channel_reserved(const struct channel *chn)
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200335{
Willy Tarreaufe578342015-01-14 14:07:13 +0100336 int reserved;
Willy Tarreau0428a142015-01-08 11:34:55 +0100337
Willy Tarreaufe578342015-01-14 14:07:13 +0100338 reserved = global.tune.maxrewrite - channel_in_transit(chn);
339 if (reserved < 0)
Willy Tarreau0428a142015-01-08 11:34:55 +0100340 reserved = 0;
Willy Tarreau0428a142015-01-08 11:34:55 +0100341 return reserved;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200342}
343
344/* Return the max number of bytes the buffer can contain so that once all the
Willy Tarreau3f5096d2015-01-14 20:21:43 +0100345 * data in transit are forwarded, the buffer still has global.tune.maxrewrite
Willy Tarreau974ced62012-10-12 23:11:02 +0200346 * bytes free. The result sits between chn->size - maxrewrite and chn->size.
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200347 */
Willy Tarreau3f5096d2015-01-14 20:21:43 +0100348static inline int channel_recv_limit(const struct channel *chn)
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200349{
Willy Tarreaua4178192015-01-14 20:16:52 +0100350 return chn->buf->size - channel_reserved(chn);
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200351}
352
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200353/* Returns the amount of space available at the input of the buffer, taking the
354 * reserved space into account if ->to_forward indicates that an end of transfer
355 * is close to happen. The test is optimized to avoid as many operations as
356 * possible for the fast case.
357 */
Willy Tarreaub5051f82015-01-14 20:25:34 +0100358static inline int channel_recv_max(const struct channel *chn)
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200359{
Willy Tarreau27bb0e12015-01-14 15:56:50 +0100360 int ret;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200361
Willy Tarreau3f5096d2015-01-14 20:21:43 +0100362 ret = channel_recv_limit(chn) - chn->buf->i - chn->buf->o;
Willy Tarreau27bb0e12015-01-14 15:56:50 +0100363 if (ret < 0)
364 ret = 0;
365 return ret;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200366}
367
Willy Tarreau319f7452015-01-14 20:32:59 +0100368/* Truncate any unread data in the channel's buffer, and disable forwarding.
369 * Outgoing data are left intact. This is mainly to be used to send error
370 * messages after existing data.
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200371 */
Willy Tarreau319f7452015-01-14 20:32:59 +0100372static inline void channel_truncate(struct channel *chn)
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200373{
Willy Tarreau9b28e032012-10-12 23:49:43 +0200374 if (!chn->buf->o)
Willy Tarreau974ced62012-10-12 23:11:02 +0200375 return channel_erase(chn);
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200376
Willy Tarreau974ced62012-10-12 23:11:02 +0200377 chn->to_forward = 0;
Willy Tarreau9b28e032012-10-12 23:49:43 +0200378 if (!chn->buf->i)
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200379 return;
380
Willy Tarreau9b28e032012-10-12 23:49:43 +0200381 chn->buf->i = 0;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200382}
383
Willy Tarreaubaaee002006-06-26 02:48:02 +0200384/*
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200385 * Advance the channel buffer's read pointer by <len> bytes. This is useful
386 * when data have been read directly from the buffer. It is illegal to call
387 * this function with <len> causing a wrapping at the end of the buffer. It's
388 * the caller's responsibility to ensure that <len> is never larger than
Willy Tarreau974ced62012-10-12 23:11:02 +0200389 * chn->o. Channel flag WRITE_PARTIAL is set.
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200390 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200391static inline void bo_skip(struct channel *chn, int len)
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200392{
Willy Tarreau9b28e032012-10-12 23:49:43 +0200393 chn->buf->o -= len;
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200394
Willy Tarreau5fb38032012-12-16 19:39:09 +0100395 if (buffer_empty(chn->buf))
Willy Tarreau9b28e032012-10-12 23:49:43 +0200396 chn->buf->p = chn->buf->data;
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200397
Willy Tarreaufb0e9202009-09-23 23:47:55 +0200398 /* notify that some data was written to the SI from the buffer */
Willy Tarreau974ced62012-10-12 23:11:02 +0200399 chn->flags |= CF_WRITE_PARTIAL;
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200400}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200401
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200402/* Tries to copy chunk <chunk> into the channel's buffer after length controls.
Willy Tarreau974ced62012-10-12 23:11:02 +0200403 * The chn->o and to_forward pointers are updated. If the channel's input is
Willy Tarreau74b08c92010-09-08 17:04:31 +0200404 * closed, -2 is returned. If the block is too large for this buffer, -3 is
405 * returned. If there is not enough room left in the buffer, -1 is returned.
406 * Otherwise the number of bytes copied is returned (0 being a valid number).
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200407 * Channel flag READ_PARTIAL is updated if some data can be transferred. The
Willy Tarreauf941cf22012-08-27 20:53:34 +0200408 * chunk's length is updated with the number of bytes sent.
Willy Tarreauaeac3192009-08-31 08:09:57 +0200409 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200410static inline int bi_putchk(struct channel *chn, struct chunk *chunk)
Willy Tarreauaeac3192009-08-31 08:09:57 +0200411{
412 int ret;
413
Willy Tarreau974ced62012-10-12 23:11:02 +0200414 ret = bi_putblk(chn, chunk->str, chunk->len);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200415 if (ret > 0)
416 chunk->len -= ret;
Willy Tarreauaeac3192009-08-31 08:09:57 +0200417 return ret;
418}
419
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200420/* Tries to copy string <str> at once into the channel's buffer after length
Willy Tarreau974ced62012-10-12 23:11:02 +0200421 * controls. The chn->o and to_forward pointers are updated. If the channel's
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200422 * input is closed, -2 is returned. If the block is too large for this buffer,
423 * -3 is returned. If there is not enough room left in the buffer, -1 is
424 * returned. Otherwise the number of bytes copied is returned (0 being a valid
425 * number). Channel flag READ_PARTIAL is updated if some data can be
426 * transferred.
Willy Tarreau74b08c92010-09-08 17:04:31 +0200427 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200428static inline int bi_putstr(struct channel *chn, const char *str)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200429{
Willy Tarreau974ced62012-10-12 23:11:02 +0200430 return bi_putblk(chn, str, strlen(str));
Willy Tarreau74b08c92010-09-08 17:04:31 +0200431}
432
433/*
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200434 * Return one char from the channel's buffer. If the buffer is empty and the
435 * channel is closed, return -2. If the buffer is just empty, return -1. The
436 * buffer's pointer is not advanced, it's up to the caller to call bo_skip(buf,
437 * 1) when it has consumed the char. Also note that this function respects the
Willy Tarreau974ced62012-10-12 23:11:02 +0200438 * chn->o limit.
Willy Tarreau74b08c92010-09-08 17:04:31 +0200439 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200440static inline int bo_getchr(struct channel *chn)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200441{
442 /* closed or empty + imminent close = -2; empty = -1 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200443 if (unlikely((chn->flags & CF_SHUTW) || channel_is_empty(chn))) {
444 if (chn->flags & (CF_SHUTW|CF_SHUTW_NOW))
Willy Tarreau74b08c92010-09-08 17:04:31 +0200445 return -2;
446 return -1;
447 }
Willy Tarreau9b28e032012-10-12 23:49:43 +0200448 return *buffer_wrap_sub(chn->buf, chn->buf->p - chn->buf->o);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200449}
450
Willy Tarreaubaaee002006-06-26 02:48:02 +0200451
Willy Tarreauc7e42382012-08-24 19:22:53 +0200452#endif /* _PROTO_CHANNEL_H */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200453
454/*
455 * Local variables:
456 * c-indent-level: 8
457 * c-basic-offset: 8
458 * End:
459 */