blob: 36633c6432e4d7996e29197929239edfd20ff6d8 [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 Tarreau9dab5fc2012-05-07 11:56:55 +02005 * Copyright (C) 2000-2012 Willy Tarreau - w@1wt.eu
Willy Tarreau7c3c5412009-12-13 15:53:05 +01006 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation, version 2.1
10 * exclusively.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
Willy Tarreaubaaee002006-06-26 02:48:02 +020021
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 Tarreau7341d942007-05-13 19:56:02 +020031#include <common/memory.h>
Willy Tarreau0c303ee2008-07-07 00:09:58 +020032#include <common/ticks.h>
Willy Tarreaufa645582007-06-03 15:59:52 +020033#include <common/time.h>
34
Willy Tarreau7c3c5412009-12-13 15:53:05 +010035#include <types/global.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020036
Willy Tarreau8263d2b2012-08-28 00:06:31 +020037extern struct pool_head *pool2_channel;
Willy Tarreau7341d942007-05-13 19:56:02 +020038
39/* 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);
46int bi_putchr(struct channel *chn, char c);
47int bo_inject(struct channel *chn, const char *msg, int len);
48int bo_getline(struct channel *chn, char *str, int len);
49int bo_getblk(struct channel *chn, char *blk, int len, int offset);
Willy Tarreau74b08c92010-09-08 17:04:31 +020050
Willy Tarreau8263d2b2012-08-28 00:06:31 +020051/* Initialize all fields in the channel. */
Willy Tarreau974ced62012-10-12 23:11:02 +020052static inline void channel_init(struct channel *chn)
Willy Tarreau54469402006-07-29 16:59:06 +020053{
Willy Tarreau9b28e032012-10-12 23:49:43 +020054 chn->buf->o = 0;
55 chn->buf->i = 0;
56 chn->buf->p = chn->buf->data;
Willy Tarreau974ced62012-10-12 23:11:02 +020057 chn->to_forward = 0;
Willy Tarreaub145c782014-02-09 17:45:16 +010058 chn->last_read = now_ms;
Willy Tarreau8f39dcd2014-02-09 08:31:49 +010059 chn->xfer_small = chn->xfer_large = 0;
Willy Tarreau974ced62012-10-12 23:11:02 +020060 chn->total = 0;
61 chn->pipe = NULL;
62 chn->analysers = 0;
63 chn->cons = NULL;
64 chn->flags = 0;
Willy Tarreau54469402006-07-29 16:59:06 +020065}
66
Willy Tarreau55a69062012-10-26 00:21:52 +020067/* Schedule up to <bytes> more bytes to be forwarded via the channel without
68 * notifying the owner task. Any data pending in the buffer are scheduled to be
69 * sent as well, in the limit of the number of bytes to forward. This must be
70 * the only method to use to schedule bytes to be forwarded. If the requested
71 * number is too large, it is automatically adjusted. The number of bytes taken
72 * into account is returned. Directly touching ->to_forward will cause lockups
73 * when buf->o goes down to zero if nobody is ready to push the remaining data.
74 */
75static inline unsigned long long channel_forward(struct channel *chn, unsigned long long bytes)
76{
77 /* hint: avoid comparisons on long long for the fast case, since if the
78 * length does not fit in an unsigned it, it will never be forwarded at
79 * once anyway.
80 */
81 if (bytes <= ~0U) {
82 unsigned int bytes32 = bytes;
83
84 if (bytes32 <= chn->buf->i) {
85 /* OK this amount of bytes might be forwarded at once */
86 b_adv(chn->buf, bytes32);
87 return bytes;
88 }
89 }
90 return __channel_forward(chn, bytes);
91}
92
Willy Tarreau8263d2b2012-08-28 00:06:31 +020093/*********************************************************************/
94/* These functions are used to compute various channel content sizes */
95/*********************************************************************/
Willy Tarreau4b517ca2011-11-25 20:33:58 +010096
Willy Tarreau8e21bb92012-08-24 22:40:29 +020097/* Reports non-zero if the channel is empty, which means both its
98 * buffer and pipe are empty. The construct looks strange but is
99 * jump-less and much more efficient on both 32 and 64-bit than
100 * the boolean test.
101 */
102static inline unsigned int channel_is_empty(struct channel *c)
103{
Willy Tarreau9b28e032012-10-12 23:49:43 +0200104 return !(c->buf->o | (long)c->pipe);
Willy Tarreau8e21bb92012-08-24 22:40:29 +0200105}
106
Willy Tarreau379357a2013-06-08 12:55:46 +0200107/* Returns non-zero if the buffer input has all of its reserve available. This
108 * is used to decide when a request or response may be parsed when some data
109 * from a previous exchange might still be present.
110 */
111static inline int channel_reserved(const struct channel *chn)
112{
113 int rem = chn->buf->size;
114
115 rem -= chn->buf->o;
116 rem -= chn->buf->i;
117 rem -= global.tune.maxrewrite;
118 return rem >= 0;
119}
120
121/* Returns non-zero if the buffer input is considered full. This is used to
122 * decide when to stop reading into a buffer when we want to ensure that we
123 * leave the reserve untouched after all pending outgoing data are forwarded.
124 * The reserved space is taken into account if ->to_forward indicates that an
125 * end of transfer is close to happen. Note that both ->buf->o and ->to_forward
126 * are considered as available since they're supposed to leave the buffer. The
127 * test is optimized to avoid as many operations as possible for the fast case
128 * and to be used as an "if" condition.
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100129 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200130static inline int channel_full(const struct channel *chn)
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100131{
Willy Tarreau9b28e032012-10-12 23:49:43 +0200132 int rem = chn->buf->size;
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200133
Willy Tarreau9b28e032012-10-12 23:49:43 +0200134 rem -= chn->buf->o;
135 rem -= chn->buf->i;
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200136 if (!rem)
137 return 1; /* buffer already full */
138
Willy Tarreau9b28e032012-10-12 23:49:43 +0200139 if (chn->to_forward >= chn->buf->size ||
140 (CHN_INFINITE_FORWARD < MAX_RANGE(typeof(chn->buf->size)) && // just there to ensure gcc
Willy Tarreau974ced62012-10-12 23:11:02 +0200141 chn->to_forward == CHN_INFINITE_FORWARD)) // avoids the useless second
142 return 0; // test whenever possible
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200143
144 rem -= global.tune.maxrewrite;
Willy Tarreau9b28e032012-10-12 23:49:43 +0200145 rem += chn->buf->o;
Willy Tarreau974ced62012-10-12 23:11:02 +0200146 rem += chn->to_forward;
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200147 return rem <= 0;
Willy Tarreau4b517ca2011-11-25 20:33:58 +0100148}
149
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200150/* Returns true if the channel's input is already closed */
Willy Tarreau974ced62012-10-12 23:11:02 +0200151static inline int channel_input_closed(struct channel *chn)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200152{
Willy Tarreau974ced62012-10-12 23:11:02 +0200153 return ((chn->flags & CF_SHUTR) != 0);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200154}
155
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200156/* Returns true if the channel's output is already closed */
Willy Tarreau974ced62012-10-12 23:11:02 +0200157static inline int channel_output_closed(struct channel *chn)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200158{
Willy Tarreau974ced62012-10-12 23:11:02 +0200159 return ((chn->flags & CF_SHUTW) != 0);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200160}
161
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200162/* Check channel timeouts, and set the corresponding flags. The likely/unlikely
163 * have been optimized for fastest normal path. The read/write timeouts are not
164 * set if there was activity on the channel. That way, we don't have to update
165 * the timeout on every I/O. Note that the analyser timeout is always checked.
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200166 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200167static inline void channel_check_timeouts(struct channel *chn)
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200168{
Willy Tarreau974ced62012-10-12 23:11:02 +0200169 if (likely(!(chn->flags & (CF_SHUTR|CF_READ_TIMEOUT|CF_READ_ACTIVITY|CF_READ_NOEXP))) &&
170 unlikely(tick_is_expired(chn->rex, now_ms)))
171 chn->flags |= CF_READ_TIMEOUT;
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200172
Willy Tarreau974ced62012-10-12 23:11:02 +0200173 if (likely(!(chn->flags & (CF_SHUTW|CF_WRITE_TIMEOUT|CF_WRITE_ACTIVITY))) &&
174 unlikely(tick_is_expired(chn->wex, now_ms)))
175 chn->flags |= CF_WRITE_TIMEOUT;
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200176
Willy Tarreau974ced62012-10-12 23:11:02 +0200177 if (likely(!(chn->flags & CF_ANA_TIMEOUT)) &&
178 unlikely(tick_is_expired(chn->analyse_exp, now_ms)))
179 chn->flags |= CF_ANA_TIMEOUT;
Willy Tarreau2eb52f02008-09-04 09:14:08 +0200180}
181
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200182/* Erase any content from channel <buf> and adjusts flags accordingly. Note
Willy Tarreau0abebcc2009-01-08 00:09:41 +0100183 * that any spliced data is not affected since we may not have any access to
184 * it.
Willy Tarreaue393fe22008-08-16 22:18:07 +0200185 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200186static inline void channel_erase(struct channel *chn)
Willy Tarreaubaaee002006-06-26 02:48:02 +0200187{
Willy Tarreau9b28e032012-10-12 23:49:43 +0200188 chn->buf->o = 0;
189 chn->buf->i = 0;
Willy Tarreau974ced62012-10-12 23:11:02 +0200190 chn->to_forward = 0;
Willy Tarreau9b28e032012-10-12 23:49:43 +0200191 chn->buf->p = chn->buf->data;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200192}
193
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200194/* marks the channel as "shutdown" ASAP for reads */
Willy Tarreau974ced62012-10-12 23:11:02 +0200195static inline void channel_shutr_now(struct channel *chn)
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200196{
Willy Tarreau974ced62012-10-12 23:11:02 +0200197 chn->flags |= CF_SHUTR_NOW;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200198}
199
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200200/* marks the channel as "shutdown" ASAP for writes */
Willy Tarreau974ced62012-10-12 23:11:02 +0200201static inline void channel_shutw_now(struct channel *chn)
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200202{
Willy Tarreau974ced62012-10-12 23:11:02 +0200203 chn->flags |= CF_SHUTW_NOW;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200204}
205
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200206/* marks the channel as "shutdown" ASAP in both directions */
Willy Tarreau974ced62012-10-12 23:11:02 +0200207static inline void channel_abort(struct channel *chn)
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200208{
Willy Tarreau974ced62012-10-12 23:11:02 +0200209 chn->flags |= CF_SHUTR_NOW | CF_SHUTW_NOW;
210 chn->flags &= ~CF_AUTO_CONNECT;
Willy Tarreaufa7e1022008-10-19 07:30:41 +0200211}
212
Willy Tarreau520d95e2009-09-19 21:04:57 +0200213/* allow the consumer to try to establish a new connection. */
Willy Tarreau974ced62012-10-12 23:11:02 +0200214static inline void channel_auto_connect(struct channel *chn)
Willy Tarreau3da77c52008-08-29 09:58:42 +0200215{
Willy Tarreau974ced62012-10-12 23:11:02 +0200216 chn->flags |= CF_AUTO_CONNECT;
Willy Tarreau3da77c52008-08-29 09:58:42 +0200217}
218
Willy Tarreau520d95e2009-09-19 21:04:57 +0200219/* prevent the consumer from trying to establish a new connection, and also
220 * disable auto shutdown forwarding.
221 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200222static inline void channel_dont_connect(struct channel *chn)
Willy Tarreau3da77c52008-08-29 09:58:42 +0200223{
Willy Tarreau974ced62012-10-12 23:11:02 +0200224 chn->flags &= ~(CF_AUTO_CONNECT|CF_AUTO_CLOSE);
Willy Tarreau3da77c52008-08-29 09:58:42 +0200225}
226
Willy Tarreau520d95e2009-09-19 21:04:57 +0200227/* allow the producer to forward shutdown requests */
Willy Tarreau974ced62012-10-12 23:11:02 +0200228static inline void channel_auto_close(struct channel *chn)
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100229{
Willy Tarreau974ced62012-10-12 23:11:02 +0200230 chn->flags |= CF_AUTO_CLOSE;
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100231}
232
Willy Tarreau520d95e2009-09-19 21:04:57 +0200233/* prevent the producer from forwarding shutdown requests */
Willy Tarreau974ced62012-10-12 23:11:02 +0200234static inline void channel_dont_close(struct channel *chn)
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100235{
Willy Tarreau974ced62012-10-12 23:11:02 +0200236 chn->flags &= ~CF_AUTO_CLOSE;
Willy Tarreau0a5d5dd2008-11-23 19:31:35 +0100237}
238
Willy Tarreau90deb182010-01-07 00:20:41 +0100239/* allow the producer to read / poll the input */
Willy Tarreau974ced62012-10-12 23:11:02 +0200240static inline void channel_auto_read(struct channel *chn)
Willy Tarreau90deb182010-01-07 00:20:41 +0100241{
Willy Tarreau974ced62012-10-12 23:11:02 +0200242 chn->flags &= ~CF_DONT_READ;
Willy Tarreau90deb182010-01-07 00:20:41 +0100243}
244
245/* prevent the producer from read / poll the input */
Willy Tarreau974ced62012-10-12 23:11:02 +0200246static inline void channel_dont_read(struct channel *chn)
Willy Tarreau90deb182010-01-07 00:20:41 +0100247{
Willy Tarreau974ced62012-10-12 23:11:02 +0200248 chn->flags |= CF_DONT_READ;
Willy Tarreau90deb182010-01-07 00:20:41 +0100249}
250
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200251
252/*************************************************/
253/* Buffer operations in the context of a channel */
254/*************************************************/
255
256
257/* Return the number of reserved bytes in the channel's visible
258 * buffer, which ensures that once all pending data are forwarded, the
259 * buffer still has global.tune.maxrewrite bytes free. The result is
260 * between 0 and global.tune.maxrewrite, which is itself smaller than
Willy Tarreau974ced62012-10-12 23:11:02 +0200261 * any chn->size.
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200262 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200263static inline int buffer_reserved(const struct channel *chn)
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200264{
Willy Tarreau9b28e032012-10-12 23:49:43 +0200265 int ret = global.tune.maxrewrite - chn->to_forward - chn->buf->o;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200266
Willy Tarreau974ced62012-10-12 23:11:02 +0200267 if (chn->to_forward == CHN_INFINITE_FORWARD)
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200268 return 0;
269 if (ret <= 0)
270 return 0;
271 return ret;
272}
273
274/* Return the max number of bytes the buffer can contain so that once all the
275 * pending bytes are forwarded, the buffer still has global.tune.maxrewrite
Willy Tarreau974ced62012-10-12 23:11:02 +0200276 * bytes free. The result sits between chn->size - maxrewrite and chn->size.
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200277 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200278static inline int buffer_max_len(const struct channel *chn)
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200279{
Willy Tarreau9b28e032012-10-12 23:49:43 +0200280 return chn->buf->size - buffer_reserved(chn);
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200281}
282
283/* Return the amount of bytes that can be written into the buffer at once,
284 * excluding reserved space, which is preserved.
285 */
286static inline int buffer_contig_space_res(const struct channel *chn)
287{
Willy Tarreau9b28e032012-10-12 23:49:43 +0200288 return buffer_contig_space_with_res(chn->buf, buffer_reserved(chn));
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200289}
290
291/* Returns the amount of space available at the input of the buffer, taking the
292 * reserved space into account if ->to_forward indicates that an end of transfer
293 * is close to happen. The test is optimized to avoid as many operations as
294 * possible for the fast case.
295 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200296static inline int bi_avail(const struct channel *chn)
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200297{
Willy Tarreau9b28e032012-10-12 23:49:43 +0200298 int rem = chn->buf->size;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200299 int rem2;
300
Willy Tarreau9b28e032012-10-12 23:49:43 +0200301 rem -= chn->buf->o;
302 rem -= chn->buf->i;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200303 if (!rem)
304 return rem; /* buffer already full */
305
Willy Tarreau9b28e032012-10-12 23:49:43 +0200306 if (chn->to_forward >= chn->buf->size ||
307 (CHN_INFINITE_FORWARD < MAX_RANGE(typeof(chn->buf->size)) && // just there to ensure gcc
Willy Tarreau974ced62012-10-12 23:11:02 +0200308 chn->to_forward == CHN_INFINITE_FORWARD)) // avoids the useless second
309 return rem; // test whenever possible
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200310
311 rem2 = rem - global.tune.maxrewrite;
Willy Tarreau9b28e032012-10-12 23:49:43 +0200312 rem2 += chn->buf->o;
Willy Tarreau974ced62012-10-12 23:11:02 +0200313 rem2 += chn->to_forward;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200314
315 if (rem > rem2)
316 rem = rem2;
317 if (rem > 0)
318 return rem;
319 return 0;
320}
321
322/* Cut the "tail" of the channel's buffer, which means strip it to the length
323 * of unsent data only, and kill any remaining unsent data. Any scheduled
324 * forwarding is stopped. This is mainly to be used to send error messages
325 * after existing data.
326 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200327static inline void bi_erase(struct channel *chn)
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200328{
Willy Tarreau9b28e032012-10-12 23:49:43 +0200329 if (!chn->buf->o)
Willy Tarreau974ced62012-10-12 23:11:02 +0200330 return channel_erase(chn);
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200331
Willy Tarreau974ced62012-10-12 23:11:02 +0200332 chn->to_forward = 0;
Willy Tarreau9b28e032012-10-12 23:49:43 +0200333 if (!chn->buf->i)
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200334 return;
335
Willy Tarreau9b28e032012-10-12 23:49:43 +0200336 chn->buf->i = 0;
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200337}
338
Willy Tarreaubaaee002006-06-26 02:48:02 +0200339/*
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200340 * Advance the channel buffer's read pointer by <len> bytes. This is useful
341 * when data have been read directly from the buffer. It is illegal to call
342 * this function with <len> causing a wrapping at the end of the buffer. It's
343 * the caller's responsibility to ensure that <len> is never larger than
Willy Tarreau974ced62012-10-12 23:11:02 +0200344 * chn->o. Channel flag WRITE_PARTIAL is set.
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200345 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200346static inline void bo_skip(struct channel *chn, int len)
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200347{
Willy Tarreau9b28e032012-10-12 23:49:43 +0200348 chn->buf->o -= len;
Willy Tarreau9dab5fc2012-05-07 11:56:55 +0200349
Willy Tarreau5fb38032012-12-16 19:39:09 +0100350 if (buffer_empty(chn->buf))
Willy Tarreau9b28e032012-10-12 23:49:43 +0200351 chn->buf->p = chn->buf->data;
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200352
Willy Tarreaufb0e9202009-09-23 23:47:55 +0200353 /* notify that some data was written to the SI from the buffer */
Willy Tarreau974ced62012-10-12 23:11:02 +0200354 chn->flags |= CF_WRITE_PARTIAL;
Willy Tarreau2b7addc2009-08-31 07:37:22 +0200355}
Willy Tarreaubaaee002006-06-26 02:48:02 +0200356
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200357/* Tries to copy chunk <chunk> into the channel's buffer after length controls.
Willy Tarreau974ced62012-10-12 23:11:02 +0200358 * The chn->o and to_forward pointers are updated. If the channel's input is
Willy Tarreau74b08c92010-09-08 17:04:31 +0200359 * closed, -2 is returned. If the block is too large for this buffer, -3 is
360 * returned. If there is not enough room left in the buffer, -1 is returned.
361 * Otherwise the number of bytes copied is returned (0 being a valid number).
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200362 * Channel flag READ_PARTIAL is updated if some data can be transferred. The
Willy Tarreauf941cf22012-08-27 20:53:34 +0200363 * chunk's length is updated with the number of bytes sent.
Willy Tarreauaeac3192009-08-31 08:09:57 +0200364 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200365static inline int bi_putchk(struct channel *chn, struct chunk *chunk)
Willy Tarreauaeac3192009-08-31 08:09:57 +0200366{
367 int ret;
368
Willy Tarreau974ced62012-10-12 23:11:02 +0200369 ret = bi_putblk(chn, chunk->str, chunk->len);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200370 if (ret > 0)
371 chunk->len -= ret;
Willy Tarreauaeac3192009-08-31 08:09:57 +0200372 return ret;
373}
374
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200375/* Tries to copy string <str> at once into the channel's buffer after length
Willy Tarreau974ced62012-10-12 23:11:02 +0200376 * controls. The chn->o and to_forward pointers are updated. If the channel's
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200377 * input is closed, -2 is returned. If the block is too large for this buffer,
378 * -3 is returned. If there is not enough room left in the buffer, -1 is
379 * returned. Otherwise the number of bytes copied is returned (0 being a valid
380 * number). Channel flag READ_PARTIAL is updated if some data can be
381 * transferred.
Willy Tarreau74b08c92010-09-08 17:04:31 +0200382 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200383static inline int bi_putstr(struct channel *chn, const char *str)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200384{
Willy Tarreau974ced62012-10-12 23:11:02 +0200385 return bi_putblk(chn, str, strlen(str));
Willy Tarreau74b08c92010-09-08 17:04:31 +0200386}
387
388/*
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200389 * Return one char from the channel's buffer. If the buffer is empty and the
390 * channel is closed, return -2. If the buffer is just empty, return -1. The
391 * buffer's pointer is not advanced, it's up to the caller to call bo_skip(buf,
392 * 1) when it has consumed the char. Also note that this function respects the
Willy Tarreau974ced62012-10-12 23:11:02 +0200393 * chn->o limit.
Willy Tarreau74b08c92010-09-08 17:04:31 +0200394 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200395static inline int bo_getchr(struct channel *chn)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200396{
397 /* closed or empty + imminent close = -2; empty = -1 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200398 if (unlikely((chn->flags & CF_SHUTW) || channel_is_empty(chn))) {
399 if (chn->flags & (CF_SHUTW|CF_SHUTW_NOW))
Willy Tarreau74b08c92010-09-08 17:04:31 +0200400 return -2;
401 return -1;
402 }
Willy Tarreau9b28e032012-10-12 23:49:43 +0200403 return *buffer_wrap_sub(chn->buf, chn->buf->p - chn->buf->o);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200404}
405
Willy Tarreaubaaee002006-06-26 02:48:02 +0200406
Willy Tarreauc7e42382012-08-24 19:22:53 +0200407#endif /* _PROTO_CHANNEL_H */
Willy Tarreaubaaee002006-06-26 02:48:02 +0200408
409/*
410 * Local variables:
411 * c-indent-level: 8
412 * c-basic-offset: 8
413 * End:
414 */