blob: 94dfbcfb8d74782248a187deb88ffe860facd904 [file] [log] [blame]
Willy Tarreaubaaee002006-06-26 02:48:02 +02001/*
Willy Tarreauc7e42382012-08-24 19:22:53 +02002 * Channel management functions.
Willy Tarreaubaaee002006-06-26 02:48:02 +02003 *
Willy Tarreaua27dc192014-11-27 22:10:04 +01004 * Copyright 2000-2014 Willy Tarreau <w@1wt.eu>
Willy Tarreaubaaee002006-06-26 02:48:02 +02005 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 *
11 */
12
Krzysztof Piotr Oledzkiba8d7d32009-10-10 21:06:03 +020013#include <ctype.h>
Willy Tarreauc0dde7a2007-01-01 21:38:07 +010014#include <stdarg.h>
15#include <stdio.h>
Willy Tarreaubaaee002006-06-26 02:48:02 +020016#include <string.h>
Willy Tarreaue3ba5f02006-06-29 18:54:54 +020017
Willy Tarreau4c7e4b72020-05-27 12:58:42 +020018#include <haproxy/api.h>
Willy Tarreau2741c8c2020-06-02 11:28:02 +020019#include <haproxy/buf.h>
Willy Tarreauf1d32c42020-06-04 21:07:02 +020020#include <haproxy/channel.h>
Willy Tarreauc7e42382012-08-24 19:22:53 +020021
Willy Tarreau7341d942007-05-13 19:56:02 +020022
Willy Tarreau8263d2b2012-08-28 00:06:31 +020023/* Schedule up to <bytes> more bytes to be forwarded via the channel without
24 * notifying the owner task. Any data pending in the buffer are scheduled to be
Willy Tarreau8bf242b2016-05-04 14:05:58 +020025 * sent as well, within the limit of the number of bytes to forward. This must
26 * be the only method to use to schedule bytes to be forwarded. If the requested
Willy Tarreau8263d2b2012-08-28 00:06:31 +020027 * number is too large, it is automatically adjusted. The number of bytes taken
28 * into account is returned. Directly touching ->to_forward will cause lockups
29 * when buf->o goes down to zero if nobody is ready to push the remaining data.
Willy Tarreau0bc34932011-03-28 16:25:58 +020030 */
Willy Tarreau55a69062012-10-26 00:21:52 +020031unsigned long long __channel_forward(struct channel *chn, unsigned long long bytes)
Willy Tarreau0bc34932011-03-28 16:25:58 +020032{
Willy Tarreau8bf242b2016-05-04 14:05:58 +020033 unsigned int budget;
Willy Tarreau02d6cfc2012-03-01 18:19:58 +010034 unsigned int forwarded;
Willy Tarreau0bc34932011-03-28 16:25:58 +020035
Willy Tarreau8bf242b2016-05-04 14:05:58 +020036 /* This is more of a safety measure as it's not supposed to happen in
37 * regular code paths.
Willy Tarreau0bc34932011-03-28 16:25:58 +020038 */
Willy Tarreau8bf242b2016-05-04 14:05:58 +020039 if (unlikely(chn->to_forward == CHN_INFINITE_FORWARD)) {
Willy Tarreaucd9e60d2018-06-19 07:33:28 +020040 c_adv(chn, ci_data(chn));
Willy Tarreau02d6cfc2012-03-01 18:19:58 +010041 return bytes;
42 }
43
Willy Tarreau8bf242b2016-05-04 14:05:58 +020044 /* Bound the transferred size to a 32-bit count since all our values
45 * are 32-bit, and we don't want to reach CHN_INFINITE_FORWARD.
46 */
47 budget = MIN(bytes, CHN_INFINITE_FORWARD - 1);
Willy Tarreau0bc34932011-03-28 16:25:58 +020048
Willy Tarreau8bf242b2016-05-04 14:05:58 +020049 /* transfer as much as we can of buf->i */
Willy Tarreaucd9e60d2018-06-19 07:33:28 +020050 forwarded = MIN(ci_data(chn), budget);
Willy Tarreaubcbd3932018-06-06 07:13:22 +020051 c_adv(chn, forwarded);
Willy Tarreau8bf242b2016-05-04 14:05:58 +020052 budget -= forwarded;
Willy Tarreau0bc34932011-03-28 16:25:58 +020053
Willy Tarreau8bf242b2016-05-04 14:05:58 +020054 if (!budget)
55 return forwarded;
56
57 /* Now we must ensure chn->to_forward sats below CHN_INFINITE_FORWARD,
58 * which also implies it won't overflow. It's less operations in 64-bit.
59 */
60 bytes = (unsigned long long)chn->to_forward + budget;
61 if (bytes >= CHN_INFINITE_FORWARD)
62 bytes = CHN_INFINITE_FORWARD - 1;
63 budget = bytes - chn->to_forward;
64
65 chn->to_forward += budget;
66 forwarded += budget;
67 return forwarded;
Willy Tarreau0bc34932011-03-28 16:25:58 +020068}
Willy Tarreaubaaee002006-06-26 02:48:02 +020069
Willy Tarreau8263d2b2012-08-28 00:06:31 +020070/* writes <len> bytes from message <msg> to the channel's buffer. Returns -1 in
71 * case of success, -2 if the message is larger than the buffer size, or the
72 * number of bytes available otherwise. The send limit is automatically
73 * adjusted to the amount of data written. FIXME-20060521: handle unaligned
74 * data. Note: this function appends data to the buffer's output and possibly
75 * overwrites any pending input data which are assumed not to exist.
Willy Tarreaubaaee002006-06-26 02:48:02 +020076 */
Willy Tarreau06d80a92017-10-19 14:32:15 +020077int co_inject(struct channel *chn, const char *msg, int len)
Willy Tarreaubaaee002006-06-26 02:48:02 +020078{
79 int max;
80
Willy Tarreauaeac3192009-08-31 08:09:57 +020081 if (len == 0)
82 return -1;
Willy Tarreaubaaee002006-06-26 02:48:02 +020083
Willy Tarreaucd9e60d2018-06-19 07:33:28 +020084 if (len < 0 || len > c_size(chn)) {
Willy Tarreau078e2942009-08-18 07:19:39 +020085 /* we can't write this chunk and will never be able to, because
86 * it is larger than the buffer. This must be reported as an
87 * error. Then we return -2 so that writers that don't care can
88 * ignore it and go on, and others can check for this value.
89 */
90 return -2;
91 }
92
Willy Tarreaud5b343b2018-06-06 06:42:46 +020093 c_realign_if_empty(chn);
Willy Tarreauc9fa0482018-07-10 17:43:27 +020094 max = b_contig_space(&chn->buf);
Willy Tarreaubaaee002006-06-26 02:48:02 +020095 if (len > max)
96 return max;
97
Christopher Faulet584348b2020-01-07 10:01:57 +010098 memcpy(co_tail(chn), msg, len);
Willy Tarreauc9fa0482018-07-10 17:43:27 +020099 b_add(&chn->buf, len);
Olivier Houchardacd14032018-06-28 18:17:23 +0200100 c_adv(chn, len);
Willy Tarreau974ced62012-10-12 23:11:02 +0200101 chn->total += len;
Krzysztof Piotr Oledzki8e4b21d2008-04-20 21:34:47 +0200102 return -1;
Willy Tarreaubaaee002006-06-26 02:48:02 +0200103}
104
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200105/* Tries to copy character <c> into the channel's buffer after some length
Willy Tarreau974ced62012-10-12 23:11:02 +0200106 * controls. The chn->o and to_forward pointers are updated. If the channel
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200107 * input is closed, -2 is returned. If there is not enough room left in the
108 * buffer, -1 is returned. Otherwise the number of bytes copied is returned
109 * (1). Channel flag READ_PARTIAL is updated if some data can be transferred.
Willy Tarreauc0dde7a2007-01-01 21:38:07 +0100110 */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200111int ci_putchr(struct channel *chn, char c)
Willy Tarreauc0dde7a2007-01-01 21:38:07 +0100112{
Willy Tarreau974ced62012-10-12 23:11:02 +0200113 if (unlikely(channel_input_closed(chn)))
Willy Tarreau74b08c92010-09-08 17:04:31 +0200114 return -2;
Willy Tarreauc0dde7a2007-01-01 21:38:07 +0100115
Willy Tarreaubc18da12015-03-13 14:00:47 +0100116 if (!channel_may_recv(chn))
Krzysztof Piotr Oledzki8e4b21d2008-04-20 21:34:47 +0200117 return -1;
Willy Tarreauc0dde7a2007-01-01 21:38:07 +0100118
Willy Tarreau8f9c72d2018-06-07 18:46:28 +0200119 *ci_tail(chn) = c;
Willy Tarreau74b08c92010-09-08 17:04:31 +0200120
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200121 b_add(&chn->buf, 1);
Willy Tarreau974ced62012-10-12 23:11:02 +0200122 chn->flags |= CF_READ_PARTIAL;
Willy Tarreau74b08c92010-09-08 17:04:31 +0200123
Willy Tarreau974ced62012-10-12 23:11:02 +0200124 if (chn->to_forward >= 1) {
125 if (chn->to_forward != CHN_INFINITE_FORWARD)
126 chn->to_forward--;
Willy Tarreaubcbd3932018-06-06 07:13:22 +0200127 c_adv(chn, 1);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200128 }
129
Willy Tarreau974ced62012-10-12 23:11:02 +0200130 chn->total++;
Willy Tarreau74b08c92010-09-08 17:04:31 +0200131 return 1;
132}
133
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200134/* Tries to copy block <blk> at once into the channel's buffer after length
Willy Tarreau974ced62012-10-12 23:11:02 +0200135 * controls. The chn->o and to_forward pointers are updated. If the channel
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200136 * input is closed, -2 is returned. If the block is too large for this buffer,
137 * -3 is returned. If there is not enough room left in the buffer, -1 is
138 * returned. Otherwise the number of bytes copied is returned (0 being a valid
139 * number). Channel flag READ_PARTIAL is updated if some data can be
Willy Tarreaubc18da12015-03-13 14:00:47 +0100140 * transferred.
Willy Tarreau74b08c92010-09-08 17:04:31 +0200141 */
Willy Tarreau06d80a92017-10-19 14:32:15 +0200142int ci_putblk(struct channel *chn, const char *blk, int len)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200143{
144 int max;
145
Willy Tarreau974ced62012-10-12 23:11:02 +0200146 if (unlikely(channel_input_closed(chn)))
Willy Tarreau74b08c92010-09-08 17:04:31 +0200147 return -2;
148
Willy Tarreau320ec2a2016-02-25 16:15:19 +0100149 if (len < 0)
150 return -3;
151
Willy Tarreau3f5096d2015-01-14 20:21:43 +0100152 max = channel_recv_limit(chn);
Willy Tarreaucd9e60d2018-06-19 07:33:28 +0200153 if (unlikely(len > max - c_data(chn))) {
Willy Tarreau591fedc2010-08-10 15:28:21 +0200154 /* we can't write this chunk right now because the buffer is
Emeric Brun147b3f02021-01-11 10:30:42 +0100155 * almost full or because the block is too large. Returns
156 * -3 if block is too large for this buffer. Or -1 if the
157 * room left is not large enough.
Willy Tarreau078e2942009-08-18 07:19:39 +0200158 */
Willy Tarreau591fedc2010-08-10 15:28:21 +0200159 if (len > max)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200160 return -3;
Willy Tarreau078e2942009-08-18 07:19:39 +0200161
Willy Tarreau74b08c92010-09-08 17:04:31 +0200162 return -1;
Willy Tarreau591fedc2010-08-10 15:28:21 +0200163 }
Willy Tarreauc0dde7a2007-01-01 21:38:07 +0100164
Willy Tarreau74b08c92010-09-08 17:04:31 +0200165 if (unlikely(len == 0))
166 return 0;
167
Willy Tarreau591fedc2010-08-10 15:28:21 +0200168 /* OK so the data fits in the buffer in one or two blocks */
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200169 max = b_contig_space(&chn->buf);
Willy Tarreau8f9c72d2018-06-07 18:46:28 +0200170 memcpy(ci_tail(chn), blk, MIN(len, max));
Willy Tarreauaeac3192009-08-31 08:09:57 +0200171 if (len > max)
Willy Tarreaucd9e60d2018-06-19 07:33:28 +0200172 memcpy(c_orig(chn), blk + max, len - max);
Willy Tarreauc0dde7a2007-01-01 21:38:07 +0100173
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200174 b_add(&chn->buf, len);
Christopher Faulete6458292019-01-02 14:24:35 +0100175 channel_add_input(chn, len);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200176 return len;
Willy Tarreauc0dde7a2007-01-01 21:38:07 +0100177}
178
Willy Tarreau36346732022-01-19 17:19:52 +0100179/* Locates the longest part of the channel's output buffer that is composed
180 * exclusively of characters not in the <delim> set, and delimited by one of
181 * these characters, and returns the initial part and the first of such
182 * delimiters. A single escape character in <escape> may be specified so that
183 * when not 0 and found, the character that follows it is never taken as a
184 * delimiter. Note that <delim> cannot contain the zero byte, hence this
185 * function is not usable with byte zero as a delimiter.
186 *
187 * Return values :
188 * >0 : number of bytes read. Includes the sep if present before len or end.
189 * =0 : no sep before end found. <str> is left undefined.
190 * <0 : no more bytes readable because output is shut.
191 * The channel status is not changed. The caller must call co_skip() to
192 * update it. One of the delimiters is waited for as long as neither the buffer
193 * nor the output are full. If either of them is full, the string may be
194 * returned as is, without the delimiter.
195 */
196int co_getdelim(const struct channel *chn, char *str, int len, const char *delim, char escape)
197{
198 uchar delim_map[256 / 8];
199 int found, escaped;
200 uint pos, bit;
201 int ret, max;
202 uchar b;
203 char *p;
204
205 ret = 0;
206 max = len;
207
208 /* closed or empty + imminent close = -1; empty = 0 */
209 if (unlikely((chn->flags & CF_SHUTW) || channel_is_empty(chn))) {
210 if (chn->flags & (CF_SHUTW|CF_SHUTW_NOW))
211 ret = -1;
212 goto out;
213 }
214
215 p = co_head(chn);
216
217 if (max > co_data(chn)) {
218 max = co_data(chn);
219 str[max-1] = 0;
220 }
221
222 /* create the byte map */
223 memset(delim_map, 0, sizeof(delim_map));
224 while ((b = *delim)) {
225 pos = b >> 3;
226 bit = b & 7;
227 delim_map[pos] |= 1 << bit;
228 delim++;
229 }
230
231 found = escaped = 0;
232 while (max) {
233 *str++ = b = *p;
234 ret++;
235 max--;
236
237 if (escape && (escaped || *p == escape)) {
238 escaped = !escaped;
239 goto skip;
240 }
241
242 pos = b >> 3;
243 bit = b & 7;
244 if (delim_map[pos] & (1 << bit)) {
245 found = 1;
246 break;
247 }
248 skip:
249 p = b_next(&chn->buf, p);
250 }
251
252 if (ret > 0 && ret < len &&
253 (ret < co_data(chn) || channel_may_recv(chn)) &&
254 !found &&
255 !(chn->flags & (CF_SHUTW|CF_SHUTW_NOW)))
256 ret = 0;
257 out:
258 if (max)
259 *str = 0;
260 return ret;
261}
262
Emeric Brun6d756162020-10-05 14:35:21 +0200263/* Gets one text word out of a channel's buffer from a stream interface.
264 * Return values :
265 * >0 : number of bytes read. Includes the sep if present before len or end.
266 * =0 : no sep before end found. <str> is left undefined.
267 * <0 : no more bytes readable because output is shut.
268 * The channel status is not changed. The caller must call co_skip() to
269 * update it. The line separator is waited for as long as neither the buffer
270 * nor the output are full. If either of them is full, the string may be
271 * returned as is, without the line separator.
272 */
273int co_getword(const struct channel *chn, char *str, int len, char sep)
274{
275 int ret, max;
276 char *p;
277
278 ret = 0;
279 max = len;
280
281 /* closed or empty + imminent close = -1; empty = 0 */
282 if (unlikely((chn->flags & CF_SHUTW) || channel_is_empty(chn))) {
283 if (chn->flags & (CF_SHUTW|CF_SHUTW_NOW))
284 ret = -1;
285 goto out;
286 }
287
288 p = co_head(chn);
289
290 if (max > co_data(chn)) {
291 max = co_data(chn);
292 str[max-1] = 0;
293 }
294 while (max) {
295 *str++ = *p;
296 ret++;
297 max--;
298
299 if (*p == sep)
300 break;
301 p = b_next(&chn->buf, p);
302 }
303 if (ret > 0 && ret < len &&
304 (ret < co_data(chn) || channel_may_recv(chn)) &&
305 *(str-1) != sep &&
306 !(chn->flags & (CF_SHUTW|CF_SHUTW_NOW)))
307 ret = 0;
308 out:
309 if (max)
310 *str = 0;
311 return ret;
312}
313
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200314/* Gets one text line out of a channel's buffer from a stream interface.
Willy Tarreau4fe7a2e2009-09-01 06:41:32 +0200315 * Return values :
316 * >0 : number of bytes read. Includes the \n if present before len or end.
Willy Tarreau74b08c92010-09-08 17:04:31 +0200317 * =0 : no '\n' before end found. <str> is left undefined.
318 * <0 : no more bytes readable because output is shut.
Willy Tarreau06d80a92017-10-19 14:32:15 +0200319 * The channel status is not changed. The caller must call co_skip() to
Willy Tarreau4fe7a2e2009-09-01 06:41:32 +0200320 * update it. The '\n' is waited for as long as neither the buffer nor the
321 * output are full. If either of them is full, the string may be returned
322 * as is, without the '\n'.
323 */
Willy Tarreau41ab8682017-10-19 14:58:40 +0200324int co_getline(const struct channel *chn, char *str, int len)
Willy Tarreau4fe7a2e2009-09-01 06:41:32 +0200325{
326 int ret, max;
327 char *p;
328
329 ret = 0;
330 max = len;
Willy Tarreau74b08c92010-09-08 17:04:31 +0200331
332 /* closed or empty + imminent close = -1; empty = 0 */
Willy Tarreau974ced62012-10-12 23:11:02 +0200333 if (unlikely((chn->flags & CF_SHUTW) || channel_is_empty(chn))) {
334 if (chn->flags & (CF_SHUTW|CF_SHUTW_NOW))
Willy Tarreau4fe7a2e2009-09-01 06:41:32 +0200335 ret = -1;
336 goto out;
337 }
338
Willy Tarreaucd9e60d2018-06-19 07:33:28 +0200339 p = co_head(chn);
Willy Tarreau4fe7a2e2009-09-01 06:41:32 +0200340
Willy Tarreaucd9e60d2018-06-19 07:33:28 +0200341 if (max > co_data(chn)) {
342 max = co_data(chn);
Willy Tarreau2e1dd3d2009-09-23 22:56:07 +0200343 str[max-1] = 0;
Willy Tarreau4fe7a2e2009-09-01 06:41:32 +0200344 }
345 while (max) {
346 *str++ = *p;
347 ret++;
348 max--;
349
350 if (*p == '\n')
351 break;
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200352 p = b_next(&chn->buf, p);
Willy Tarreau4fe7a2e2009-09-01 06:41:32 +0200353 }
Willy Tarreau82de2b62013-12-10 18:58:23 +0100354 if (ret > 0 && ret < len &&
Willy Tarreaucd9e60d2018-06-19 07:33:28 +0200355 (ret < co_data(chn) || channel_may_recv(chn)) &&
Willy Tarreau2e1dd3d2009-09-23 22:56:07 +0200356 *(str-1) != '\n' &&
Willy Tarreau974ced62012-10-12 23:11:02 +0200357 !(chn->flags & (CF_SHUTW|CF_SHUTW_NOW)))
Willy Tarreau4fe7a2e2009-09-01 06:41:32 +0200358 ret = 0;
359 out:
360 if (max)
361 *str = 0;
362 return ret;
363}
364
Emeric Brun6d756162020-10-05 14:35:21 +0200365/* Gets one char of data from a channel's buffer,
366 * Return values :
367 * 1 : number of bytes read, equal to requested size.
368 * =0 : not enough data available. <c> is left undefined.
369 * <0 : no more bytes readable because output is shut.
370 * The channel status is not changed. The caller must call co_skip() to
371 * update it.
372 */
373int co_getchar(const struct channel *chn, char *c)
374{
375 if (chn->flags & CF_SHUTW)
376 return -1;
377
378 if (unlikely(co_data(chn) == 0)) {
379 if (chn->flags & (CF_SHUTW|CF_SHUTW_NOW))
380 return -1;
381 return 0;
382 }
383
384 *c = *(co_head(chn));
385 return 1;
386}
387
Willy Tarreau8263d2b2012-08-28 00:06:31 +0200388/* Gets one full block of data at once from a channel's buffer, optionally from
389 * a specific offset. Return values :
Willy Tarreau74b08c92010-09-08 17:04:31 +0200390 * >0 : number of bytes read, equal to requested size.
391 * =0 : not enough data available. <blk> is left undefined.
392 * <0 : no more bytes readable because output is shut.
Willy Tarreau06d80a92017-10-19 14:32:15 +0200393 * The channel status is not changed. The caller must call co_skip() to
Willy Tarreau74b08c92010-09-08 17:04:31 +0200394 * update it.
395 */
Willy Tarreau41ab8682017-10-19 14:58:40 +0200396int co_getblk(const struct channel *chn, char *blk, int len, int offset)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200397{
Willy Tarreau974ced62012-10-12 23:11:02 +0200398 if (chn->flags & CF_SHUTW)
Willy Tarreau74b08c92010-09-08 17:04:31 +0200399 return -1;
400
Christopher Fauleteee16282023-03-30 15:48:27 +0200401 if (len + offset > co_data(chn) || co_data(chn) == 0) {
Willy Tarreau974ced62012-10-12 23:11:02 +0200402 if (chn->flags & (CF_SHUTW|CF_SHUTW_NOW))
Willy Tarreau74b08c92010-09-08 17:04:31 +0200403 return -1;
404 return 0;
405 }
406
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200407 return b_getblk(&chn->buf, blk, len, offset);
Willy Tarreau74b08c92010-09-08 17:04:31 +0200408}
409
Thierry FOURNIERca16b032015-02-16 19:26:48 +0100410/* Gets one or two blocks of data at once from a channel's output buffer.
411 * Return values :
412 * >0 : number of blocks filled (1 or 2). blk1 is always filled before blk2.
413 * =0 : not enough data available. <blk*> are left undefined.
414 * <0 : no more bytes readable because output is shut.
Willy Tarreau06d80a92017-10-19 14:32:15 +0200415 * The channel status is not changed. The caller must call co_skip() to
Thierry FOURNIERca16b032015-02-16 19:26:48 +0100416 * update it. Unused buffers are left in an undefined state.
417 */
Willy Tarreau55f3ce12018-07-18 11:49:27 +0200418int 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 +0100419{
Willy Tarreaucd9e60d2018-06-19 07:33:28 +0200420 if (unlikely(co_data(chn) == 0)) {
Christopher Fauletf706a792020-07-16 11:43:46 +0200421 if (chn->flags & (CF_SHUTW|CF_SHUTW_NOW))
Thierry FOURNIERca16b032015-02-16 19:26:48 +0100422 return -1;
423 return 0;
424 }
425
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200426 return b_getblk_nc(&chn->buf, blk1, len1, blk2, len2, 0, co_data(chn));
Thierry FOURNIERca16b032015-02-16 19:26:48 +0100427}
428
429/* Gets one text line out of a channel's output buffer from a stream interface.
430 * Return values :
431 * >0 : number of blocks returned (1 or 2). blk1 is always filled before blk2.
432 * =0 : not enough data available.
433 * <0 : no more bytes readable because output is shut.
434 * The '\n' is waited for as long as neither the buffer nor the output are
435 * full. If either of them is full, the string may be returned as is, without
436 * the '\n'. Unused buffers are left in an undefined state.
437 */
Willy Tarreau41ab8682017-10-19 14:58:40 +0200438int co_getline_nc(const struct channel *chn,
Willy Tarreau55f3ce12018-07-18 11:49:27 +0200439 const char **blk1, size_t *len1,
440 const char **blk2, size_t *len2)
Thierry FOURNIERca16b032015-02-16 19:26:48 +0100441{
442 int retcode;
443 int l;
444
Willy Tarreau06d80a92017-10-19 14:32:15 +0200445 retcode = co_getblk_nc(chn, blk1, len1, blk2, len2);
Tim Duesterhus45be38c2018-04-24 19:20:43 +0200446 if (unlikely(retcode <= 0))
Thierry FOURNIERca16b032015-02-16 19:26:48 +0100447 return retcode;
448
449 for (l = 0; l < *len1 && (*blk1)[l] != '\n'; l++);
450 if (l < *len1 && (*blk1)[l] == '\n') {
451 *len1 = l + 1;
452 return 1;
453 }
454
455 if (retcode >= 2) {
456 for (l = 0; l < *len2 && (*blk2)[l] != '\n'; l++);
457 if (l < *len2 && (*blk2)[l] == '\n') {
458 *len2 = l + 1;
459 return 2;
460 }
461 }
462
Christopher Fauletf706a792020-07-16 11:43:46 +0200463 if (chn->flags & (CF_SHUTW|CF_SHUTW_NOW)) {
Thierry FOURNIERca16b032015-02-16 19:26:48 +0100464 /* If we have found no LF and the buffer is shut, then
465 * the resulting string is made of the concatenation of
466 * the pending blocks (1 or 2).
467 */
468 return retcode;
469 }
470
471 /* No LF yet and not shut yet */
472 return 0;
473}
474
475/* Gets one full block of data at once from a channel's input buffer.
476 * This function can return the data slitted in one or two blocks.
477 * Return values :
478 * >0 : number of blocks returned (1 or 2). blk1 is always filled before blk2.
479 * =0 : not enough data available.
480 * <0 : no more bytes readable because input is shut.
481 */
Willy Tarreau41ab8682017-10-19 14:58:40 +0200482int ci_getblk_nc(const struct channel *chn,
Willy Tarreau55f3ce12018-07-18 11:49:27 +0200483 char **blk1, size_t *len1,
484 char **blk2, size_t *len2)
Thierry FOURNIERca16b032015-02-16 19:26:48 +0100485{
Willy Tarreaucd9e60d2018-06-19 07:33:28 +0200486 if (unlikely(ci_data(chn) == 0)) {
Thierry FOURNIERca16b032015-02-16 19:26:48 +0100487 if (chn->flags & CF_SHUTR)
488 return -1;
489 return 0;
490 }
491
Willy Tarreaucd9e60d2018-06-19 07:33:28 +0200492 if (unlikely(ci_head(chn) + ci_data(chn) > c_wrap(chn))) {
493 *blk1 = ci_head(chn);
494 *len1 = c_wrap(chn) - ci_head(chn);
495 *blk2 = c_orig(chn);
496 *len2 = ci_data(chn) - *len1;
Thierry FOURNIERca16b032015-02-16 19:26:48 +0100497 return 2;
498 }
499
Willy Tarreaucd9e60d2018-06-19 07:33:28 +0200500 *blk1 = ci_head(chn);
501 *len1 = ci_data(chn);
Thierry FOURNIERca16b032015-02-16 19:26:48 +0100502 return 1;
503}
504
505/* Gets one text line out of a channel's input buffer from a stream interface.
506 * Return values :
507 * >0 : number of blocks returned (1 or 2). blk1 is always filled before blk2.
508 * =0 : not enough data available.
509 * <0 : no more bytes readable because output is shut.
510 * The '\n' is waited for as long as neither the buffer nor the input are
511 * full. If either of them is full, the string may be returned as is, without
512 * the '\n'. Unused buffers are left in an undefined state.
513 */
Willy Tarreau41ab8682017-10-19 14:58:40 +0200514int ci_getline_nc(const struct channel *chn,
Willy Tarreau55f3ce12018-07-18 11:49:27 +0200515 char **blk1, size_t *len1,
516 char **blk2, size_t *len2)
Thierry FOURNIERca16b032015-02-16 19:26:48 +0100517{
518 int retcode;
519 int l;
520
Willy Tarreau06d80a92017-10-19 14:32:15 +0200521 retcode = ci_getblk_nc(chn, blk1, len1, blk2, len2);
Thierry FOURNIER / OZON.IO500d11e2016-11-12 17:39:58 +0100522 if (unlikely(retcode <= 0))
Thierry FOURNIERca16b032015-02-16 19:26:48 +0100523 return retcode;
524
525 for (l = 0; l < *len1 && (*blk1)[l] != '\n'; l++);
526 if (l < *len1 && (*blk1)[l] == '\n') {
527 *len1 = l + 1;
528 return 1;
529 }
530
531 if (retcode >= 2) {
532 for (l = 0; l < *len2 && (*blk2)[l] != '\n'; l++);
533 if (l < *len2 && (*blk2)[l] == '\n') {
534 *len2 = l + 1;
535 return 2;
536 }
537 }
538
539 if (chn->flags & CF_SHUTW) {
540 /* If we have found no LF and the buffer is shut, then
541 * the resulting string is made of the concatenation of
542 * the pending blocks (1 or 2).
543 */
544 return retcode;
545 }
546
547 /* No LF yet and not shut yet */
548 return 0;
549}
550
Willy Tarreau4d893d42018-07-12 15:43:32 +0200551/* Inserts <str> followed by "\r\n" at position <pos> relative to channel <c>'s
552 * input head. The <len> argument informs about the length of string <str> so
553 * that we don't have to measure it. <str> must be a valid pointer and must not
554 * include the trailing "\r\n".
555 *
556 * The number of bytes added is returned on success. 0 is returned on failure.
557 */
558int ci_insert_line2(struct channel *c, int pos, const char *str, int len)
559{
Willy Tarreauc9fa0482018-07-10 17:43:27 +0200560 struct buffer *b = &c->buf;
Willy Tarreau4d893d42018-07-12 15:43:32 +0200561 char *dst = c_ptr(c, pos);
562 int delta;
563
564 delta = len + 2;
565
Olivier Houchard363c7452018-09-26 15:09:58 +0200566 if (__b_tail(b) + delta >= b_wrap(b))
Willy Tarreau4d893d42018-07-12 15:43:32 +0200567 return 0; /* no space left */
568
569 if (b_data(b) &&
570 b_tail(b) + delta > b_head(b) &&
571 b_head(b) >= b_tail(b))
572 return 0; /* no space left before wrapping data */
573
574 /* first, protect the end of the buffer */
575 memmove(dst + delta, dst, b_tail(b) - dst);
576
577 /* now, copy str over dst */
578 memcpy(dst, str, len);
579 dst[len] = '\r';
580 dst[len + 1] = '\n';
581
582 b_add(b, delta);
583 return delta;
584}
585
Krzysztof Piotr Oledzkiba8d7d32009-10-10 21:06:03 +0200586/*
Willy Tarreaubaaee002006-06-26 02:48:02 +0200587 * Local variables:
588 * c-indent-level: 8
589 * c-basic-offset: 8
590 * End:
591 */