Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 1 | /* |
Willy Tarreau | c7e4238 | 2012-08-24 19:22:53 +0200 | [diff] [blame] | 2 | * Channel management functions. |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 3 | * |
Willy Tarreau | c7e4238 | 2012-08-24 19:22:53 +0200 | [diff] [blame] | 4 | * Copyright 2000-2012 Willy Tarreau <w@1wt.eu> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 5 | * |
| 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 Oledzki | ba8d7d3 | 2009-10-10 21:06:03 +0200 | [diff] [blame] | 13 | #include <ctype.h> |
Willy Tarreau | c0dde7a | 2007-01-01 21:38:07 +0100 | [diff] [blame] | 14 | #include <stdarg.h> |
| 15 | #include <stdio.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 16 | #include <string.h> |
Willy Tarreau | e3ba5f0 | 2006-06-29 18:54:54 +0200 | [diff] [blame] | 17 | |
| 18 | #include <common/config.h> |
Willy Tarreau | 7341d94 | 2007-05-13 19:56:02 +0200 | [diff] [blame] | 19 | #include <common/memory.h> |
Willy Tarreau | c7e4238 | 2012-08-24 19:22:53 +0200 | [diff] [blame] | 20 | #include <common/buffer.h> |
| 21 | #include <proto/channel.h> |
Willy Tarreau | 27a674e | 2009-08-17 07:23:33 +0200 | [diff] [blame] | 22 | #include <types/global.h> |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 23 | |
Willy Tarreau | c7e4238 | 2012-08-24 19:22:53 +0200 | [diff] [blame] | 24 | |
| 25 | /* Note: this code has not yet been completely cleaned up and still refers to |
| 26 | * the word "buffer" when "channel" is meant instead. |
| 27 | */ |
Willy Tarreau | 7341d94 | 2007-05-13 19:56:02 +0200 | [diff] [blame] | 28 | struct pool_head *pool2_buffer; |
| 29 | |
| 30 | |
| 31 | /* perform minimal intializations, report 0 in case of error, 1 if OK. */ |
| 32 | int init_buffer() |
| 33 | { |
Willy Tarreau | 7421efb | 2012-07-02 15:11:27 +0200 | [diff] [blame] | 34 | pool2_buffer = create_pool("buffer", sizeof(struct channel) + global.tune.bufsize, MEM_F_SHARED); |
Willy Tarreau | 7341d94 | 2007-05-13 19:56:02 +0200 | [diff] [blame] | 35 | return pool2_buffer != NULL; |
| 36 | } |
| 37 | |
Willy Tarreau | 0bc3493 | 2011-03-28 16:25:58 +0200 | [diff] [blame] | 38 | /* Schedule up to <bytes> more bytes to be forwarded by the buffer without notifying |
| 39 | * the task. Any pending data in the buffer is scheduled to be sent as well, |
| 40 | * in the limit of the number of bytes to forward. This must be the only method |
| 41 | * to use to schedule bytes to be sent. If the requested number is too large, it |
| 42 | * is automatically adjusted. The number of bytes taken into account is returned. |
Willy Tarreau | 2e046c6 | 2012-03-01 16:08:30 +0100 | [diff] [blame] | 43 | * Directly touching ->to_forward will cause lockups when ->o goes down to |
Willy Tarreau | 0bc3493 | 2011-03-28 16:25:58 +0200 | [diff] [blame] | 44 | * zero if nobody is ready to push the remaining data. |
| 45 | */ |
Willy Tarreau | 7421efb | 2012-07-02 15:11:27 +0200 | [diff] [blame] | 46 | unsigned long long buffer_forward(struct channel *buf, unsigned long long bytes) |
Willy Tarreau | 0bc3493 | 2011-03-28 16:25:58 +0200 | [diff] [blame] | 47 | { |
Willy Tarreau | 0bc3493 | 2011-03-28 16:25:58 +0200 | [diff] [blame] | 48 | unsigned int new_forward; |
Willy Tarreau | 02d6cfc | 2012-03-01 18:19:58 +0100 | [diff] [blame] | 49 | unsigned int forwarded; |
Willy Tarreau | 328582c | 2012-05-05 23:32:27 +0200 | [diff] [blame] | 50 | unsigned int bytes32; |
Willy Tarreau | 0bc3493 | 2011-03-28 16:25:58 +0200 | [diff] [blame] | 51 | |
Willy Tarreau | 328582c | 2012-05-05 23:32:27 +0200 | [diff] [blame] | 52 | bytes32 = bytes; |
| 53 | |
| 54 | /* hint: avoid comparisons on long long for the fast case, since if the |
| 55 | * length does not fit in an unsigned it, it will never be forwarded at |
| 56 | * once anyway. |
| 57 | */ |
| 58 | if (bytes <= ~0U) { |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 59 | if (bytes32 <= buf->buf.i) { |
Willy Tarreau | 328582c | 2012-05-05 23:32:27 +0200 | [diff] [blame] | 60 | /* OK this amount of bytes might be forwarded at once */ |
| 61 | if (!bytes32) |
| 62 | return 0; |
Willy Tarreau | a75bcef | 2012-08-24 22:56:11 +0200 | [diff] [blame] | 63 | b_adv(&buf->buf, bytes32); |
Willy Tarreau | 328582c | 2012-05-05 23:32:27 +0200 | [diff] [blame] | 64 | return bytes; |
| 65 | } |
Willy Tarreau | 0bc3493 | 2011-03-28 16:25:58 +0200 | [diff] [blame] | 66 | } |
| 67 | |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 68 | forwarded = buf->buf.i; |
Willy Tarreau | a75bcef | 2012-08-24 22:56:11 +0200 | [diff] [blame] | 69 | b_adv(&buf->buf, buf->buf.i); |
Willy Tarreau | 0bc3493 | 2011-03-28 16:25:58 +0200 | [diff] [blame] | 70 | |
Willy Tarreau | 0bc3493 | 2011-03-28 16:25:58 +0200 | [diff] [blame] | 71 | /* Note: the case below is the only case where we may return |
| 72 | * a byte count that does not fit into a 32-bit number. |
| 73 | */ |
| 74 | if (likely(buf->to_forward == BUF_INFINITE_FORWARD)) |
| 75 | return bytes; |
| 76 | |
Willy Tarreau | 02d6cfc | 2012-03-01 18:19:58 +0100 | [diff] [blame] | 77 | if (likely(bytes == BUF_INFINITE_FORWARD)) { |
| 78 | buf->to_forward = bytes; |
| 79 | return bytes; |
| 80 | } |
| 81 | |
| 82 | new_forward = buf->to_forward + bytes - forwarded; |
| 83 | bytes = forwarded; /* at least those bytes were scheduled */ |
Willy Tarreau | 0bc3493 | 2011-03-28 16:25:58 +0200 | [diff] [blame] | 84 | |
| 85 | if (new_forward <= buf->to_forward) { |
| 86 | /* integer overflow detected, let's assume no more than 2G at once */ |
| 87 | new_forward = MID_RANGE(new_forward); |
| 88 | } |
| 89 | |
| 90 | if (new_forward > buf->to_forward) { |
| 91 | bytes += new_forward - buf->to_forward; |
| 92 | buf->to_forward = new_forward; |
| 93 | } |
| 94 | return bytes; |
| 95 | } |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 96 | |
Krzysztof Piotr Oledzki | 8e4b21d | 2008-04-20 21:34:47 +0200 | [diff] [blame] | 97 | /* writes <len> bytes from message <msg> to buffer <buf>. Returns -1 in case of |
Willy Tarreau | 078e294 | 2009-08-18 07:19:39 +0200 | [diff] [blame] | 98 | * success, -2 if the message is larger than the buffer size, or the number of |
| 99 | * bytes available otherwise. The send limit is automatically adjusted with the |
| 100 | * amount of data written. FIXME-20060521: handle unaligned data. |
Willy Tarreau | 363a5bb | 2012-03-02 20:14:45 +0100 | [diff] [blame] | 101 | * Note: this function appends data to the buffer's output and possibly overwrites |
| 102 | * any pending input data which are assumed not to exist. |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 103 | */ |
Willy Tarreau | 7421efb | 2012-07-02 15:11:27 +0200 | [diff] [blame] | 104 | int bo_inject(struct channel *buf, const char *msg, int len) |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 105 | { |
| 106 | int max; |
| 107 | |
Willy Tarreau | aeac319 | 2009-08-31 08:09:57 +0200 | [diff] [blame] | 108 | if (len == 0) |
| 109 | return -1; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 110 | |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 111 | if (len > buf->buf.size) { |
Willy Tarreau | 078e294 | 2009-08-18 07:19:39 +0200 | [diff] [blame] | 112 | /* we can't write this chunk and will never be able to, because |
| 113 | * it is larger than the buffer. This must be reported as an |
| 114 | * error. Then we return -2 so that writers that don't care can |
| 115 | * ignore it and go on, and others can check for this value. |
| 116 | */ |
| 117 | return -2; |
| 118 | } |
| 119 | |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 120 | max = buffer_realign(&buf->buf); |
Willy Tarreau | aeac319 | 2009-08-31 08:09:57 +0200 | [diff] [blame] | 121 | |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 122 | if (len > max) |
| 123 | return max; |
| 124 | |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 125 | memcpy(buf->buf.p, msg, len); |
| 126 | buf->buf.o += len; |
| 127 | buf->buf.p = b_ptr(&buf->buf, len); |
Willy Tarreau | 35d66b0 | 2007-01-02 00:28:21 +0100 | [diff] [blame] | 128 | buf->total += len; |
Krzysztof Piotr Oledzki | 8e4b21d | 2008-04-20 21:34:47 +0200 | [diff] [blame] | 129 | return -1; |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 130 | } |
| 131 | |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 132 | /* Tries to copy character <c> into buffer <buf> after length controls. The |
Willy Tarreau | 2e046c6 | 2012-03-01 16:08:30 +0100 | [diff] [blame] | 133 | * ->o and to_forward pointers are updated. If the buffer's input is |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 134 | * closed, -2 is returned. If there is not enough room left in the buffer, -1 |
| 135 | * is returned. Otherwise the number of bytes copied is returned (1). Buffer |
Willy Tarreau | f941cf2 | 2012-08-27 20:53:34 +0200 | [diff] [blame] | 136 | * flag READ_PARTIAL is updated if some data can be transferred. |
Willy Tarreau | c0dde7a | 2007-01-01 21:38:07 +0100 | [diff] [blame] | 137 | */ |
Willy Tarreau | 7421efb | 2012-07-02 15:11:27 +0200 | [diff] [blame] | 138 | int bi_putchr(struct channel *buf, char c) |
Willy Tarreau | c0dde7a | 2007-01-01 21:38:07 +0100 | [diff] [blame] | 139 | { |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 140 | if (unlikely(buffer_input_closed(buf))) |
| 141 | return -2; |
Willy Tarreau | c0dde7a | 2007-01-01 21:38:07 +0100 | [diff] [blame] | 142 | |
Willy Tarreau | 3bf1b2b | 2012-08-27 20:46:07 +0200 | [diff] [blame] | 143 | if (channel_full(buf)) |
Krzysztof Piotr Oledzki | 8e4b21d | 2008-04-20 21:34:47 +0200 | [diff] [blame] | 144 | return -1; |
Willy Tarreau | c0dde7a | 2007-01-01 21:38:07 +0100 | [diff] [blame] | 145 | |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 146 | *bi_end(&buf->buf) = c; |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 147 | |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 148 | buf->buf.i++; |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 149 | buf->flags |= BF_READ_PARTIAL; |
| 150 | |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 151 | if (buf->to_forward >= 1) { |
| 152 | if (buf->to_forward != BUF_INFINITE_FORWARD) |
| 153 | buf->to_forward--; |
Willy Tarreau | a75bcef | 2012-08-24 22:56:11 +0200 | [diff] [blame] | 154 | b_adv(&buf->buf, 1); |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 155 | } |
| 156 | |
| 157 | buf->total++; |
| 158 | return 1; |
| 159 | } |
| 160 | |
| 161 | /* Tries to copy block <blk> at once into buffer <buf> after length controls. |
Willy Tarreau | 2e046c6 | 2012-03-01 16:08:30 +0100 | [diff] [blame] | 162 | * The ->o and to_forward pointers are updated. If the buffer's input is |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 163 | * closed, -2 is returned. If the block is too large for this buffer, -3 is |
| 164 | * returned. If there is not enough room left in the buffer, -1 is returned. |
| 165 | * Otherwise the number of bytes copied is returned (0 being a valid number). |
Willy Tarreau | f941cf2 | 2012-08-27 20:53:34 +0200 | [diff] [blame] | 166 | * Buffer flag READ_PARTIAL is updated if some data can be transferred. |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 167 | */ |
Willy Tarreau | 7421efb | 2012-07-02 15:11:27 +0200 | [diff] [blame] | 168 | int bi_putblk(struct channel *buf, const char *blk, int len) |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 169 | { |
| 170 | int max; |
| 171 | |
| 172 | if (unlikely(buffer_input_closed(buf))) |
| 173 | return -2; |
| 174 | |
Willy Tarreau | 591fedc | 2010-08-10 15:28:21 +0200 | [diff] [blame] | 175 | max = buffer_max_len(buf); |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 176 | if (unlikely(len > max - buffer_len(&buf->buf))) { |
Willy Tarreau | 591fedc | 2010-08-10 15:28:21 +0200 | [diff] [blame] | 177 | /* we can't write this chunk right now because the buffer is |
| 178 | * almost full or because the block is too large. Return the |
| 179 | * available space or -2 if impossible. |
Willy Tarreau | 078e294 | 2009-08-18 07:19:39 +0200 | [diff] [blame] | 180 | */ |
Willy Tarreau | 591fedc | 2010-08-10 15:28:21 +0200 | [diff] [blame] | 181 | if (len > max) |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 182 | return -3; |
Willy Tarreau | 078e294 | 2009-08-18 07:19:39 +0200 | [diff] [blame] | 183 | |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 184 | return -1; |
Willy Tarreau | 591fedc | 2010-08-10 15:28:21 +0200 | [diff] [blame] | 185 | } |
Willy Tarreau | c0dde7a | 2007-01-01 21:38:07 +0100 | [diff] [blame] | 186 | |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 187 | if (unlikely(len == 0)) |
| 188 | return 0; |
| 189 | |
Willy Tarreau | 591fedc | 2010-08-10 15:28:21 +0200 | [diff] [blame] | 190 | /* OK so the data fits in the buffer in one or two blocks */ |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 191 | max = buffer_contig_space_with_res(&buf->buf, buf->buf.size - max); |
| 192 | memcpy(bi_end(&buf->buf), blk, MIN(len, max)); |
Willy Tarreau | aeac319 | 2009-08-31 08:09:57 +0200 | [diff] [blame] | 193 | if (len > max) |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 194 | memcpy(buf->buf.data, blk + max, len - max); |
Willy Tarreau | c0dde7a | 2007-01-01 21:38:07 +0100 | [diff] [blame] | 195 | |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 196 | buf->buf.i += len; |
Willy Tarreau | aeac319 | 2009-08-31 08:09:57 +0200 | [diff] [blame] | 197 | buf->total += len; |
Willy Tarreau | 31971e5 | 2009-09-20 12:07:52 +0200 | [diff] [blame] | 198 | if (buf->to_forward) { |
| 199 | unsigned long fwd = len; |
| 200 | if (buf->to_forward != BUF_INFINITE_FORWARD) { |
| 201 | if (fwd > buf->to_forward) |
| 202 | fwd = buf->to_forward; |
| 203 | buf->to_forward -= fwd; |
| 204 | } |
Willy Tarreau | a75bcef | 2012-08-24 22:56:11 +0200 | [diff] [blame] | 205 | b_adv(&buf->buf, fwd); |
Willy Tarreau | aeac319 | 2009-08-31 08:09:57 +0200 | [diff] [blame] | 206 | } |
| 207 | |
Willy Tarreau | fb0e920 | 2009-09-23 23:47:55 +0200 | [diff] [blame] | 208 | /* notify that some data was read from the SI into the buffer */ |
| 209 | buf->flags |= BF_READ_PARTIAL; |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 210 | return len; |
Willy Tarreau | c0dde7a | 2007-01-01 21:38:07 +0100 | [diff] [blame] | 211 | } |
| 212 | |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 213 | /* Gets one text line out of a buffer from a stream interface. |
Willy Tarreau | 4fe7a2e | 2009-09-01 06:41:32 +0200 | [diff] [blame] | 214 | * Return values : |
| 215 | * >0 : number of bytes read. Includes the \n if present before len or end. |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 216 | * =0 : no '\n' before end found. <str> is left undefined. |
| 217 | * <0 : no more bytes readable because output is shut. |
Willy Tarreau | 9dab5fc | 2012-05-07 11:56:55 +0200 | [diff] [blame] | 218 | * The buffer status is not changed. The caller must call bo_skip() to |
Willy Tarreau | 4fe7a2e | 2009-09-01 06:41:32 +0200 | [diff] [blame] | 219 | * update it. The '\n' is waited for as long as neither the buffer nor the |
| 220 | * output are full. If either of them is full, the string may be returned |
| 221 | * as is, without the '\n'. |
| 222 | */ |
Willy Tarreau | 7421efb | 2012-07-02 15:11:27 +0200 | [diff] [blame] | 223 | int bo_getline(struct channel *buf, char *str, int len) |
Willy Tarreau | 4fe7a2e | 2009-09-01 06:41:32 +0200 | [diff] [blame] | 224 | { |
| 225 | int ret, max; |
| 226 | char *p; |
| 227 | |
| 228 | ret = 0; |
| 229 | max = len; |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 230 | |
| 231 | /* closed or empty + imminent close = -1; empty = 0 */ |
Willy Tarreau | 8e21bb9 | 2012-08-24 22:40:29 +0200 | [diff] [blame] | 232 | if (unlikely((buf->flags & BF_SHUTW) || channel_is_empty(buf))) { |
Willy Tarreau | 4fe7a2e | 2009-09-01 06:41:32 +0200 | [diff] [blame] | 233 | if (buf->flags & (BF_SHUTW|BF_SHUTW_NOW)) |
| 234 | ret = -1; |
| 235 | goto out; |
| 236 | } |
| 237 | |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 238 | p = bo_ptr(&buf->buf); |
Willy Tarreau | 4fe7a2e | 2009-09-01 06:41:32 +0200 | [diff] [blame] | 239 | |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 240 | if (max > buf->buf.o) { |
| 241 | max = buf->buf.o; |
Willy Tarreau | 2e1dd3d | 2009-09-23 22:56:07 +0200 | [diff] [blame] | 242 | str[max-1] = 0; |
Willy Tarreau | 4fe7a2e | 2009-09-01 06:41:32 +0200 | [diff] [blame] | 243 | } |
| 244 | while (max) { |
| 245 | *str++ = *p; |
| 246 | ret++; |
| 247 | max--; |
| 248 | |
| 249 | if (*p == '\n') |
| 250 | break; |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 251 | p = buffer_wrap_add(&buf->buf, p + 1); |
Willy Tarreau | 4fe7a2e | 2009-09-01 06:41:32 +0200 | [diff] [blame] | 252 | } |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 253 | if (ret > 0 && ret < len && ret < buf->buf.o && |
Willy Tarreau | 2e1dd3d | 2009-09-23 22:56:07 +0200 | [diff] [blame] | 254 | *(str-1) != '\n' && |
| 255 | !(buf->flags & (BF_SHUTW|BF_SHUTW_NOW))) |
Willy Tarreau | 4fe7a2e | 2009-09-01 06:41:32 +0200 | [diff] [blame] | 256 | ret = 0; |
| 257 | out: |
| 258 | if (max) |
| 259 | *str = 0; |
| 260 | return ret; |
| 261 | } |
| 262 | |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 263 | /* Gets one full block of data at once from a buffer, optionally from a |
| 264 | * specific offset. Return values : |
| 265 | * >0 : number of bytes read, equal to requested size. |
| 266 | * =0 : not enough data available. <blk> is left undefined. |
| 267 | * <0 : no more bytes readable because output is shut. |
Willy Tarreau | 9dab5fc | 2012-05-07 11:56:55 +0200 | [diff] [blame] | 268 | * The buffer status is not changed. The caller must call bo_skip() to |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 269 | * update it. |
| 270 | */ |
Willy Tarreau | 7421efb | 2012-07-02 15:11:27 +0200 | [diff] [blame] | 271 | int bo_getblk(struct channel *buf, char *blk, int len, int offset) |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 272 | { |
| 273 | int firstblock; |
| 274 | |
| 275 | if (buf->flags & BF_SHUTW) |
| 276 | return -1; |
| 277 | |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 278 | if (len + offset > buf->buf.o) { |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 279 | if (buf->flags & (BF_SHUTW|BF_SHUTW_NOW)) |
| 280 | return -1; |
| 281 | return 0; |
| 282 | } |
| 283 | |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 284 | firstblock = buf->buf.data + buf->buf.size - bo_ptr(&buf->buf); |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 285 | if (firstblock > offset) { |
| 286 | if (firstblock >= len + offset) { |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 287 | memcpy(blk, bo_ptr(&buf->buf) + offset, len); |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 288 | return len; |
| 289 | } |
| 290 | |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 291 | memcpy(blk, bo_ptr(&buf->buf) + offset, firstblock - offset); |
| 292 | memcpy(blk + firstblock - offset, buf->buf.data, len - firstblock + offset); |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 293 | return len; |
| 294 | } |
| 295 | |
Willy Tarreau | 572bf90 | 2012-07-02 17:01:20 +0200 | [diff] [blame] | 296 | memcpy(blk, buf->buf.data + offset - firstblock, len); |
Willy Tarreau | 74b08c9 | 2010-09-08 17:04:31 +0200 | [diff] [blame] | 297 | return len; |
| 298 | } |
| 299 | |
Krzysztof Piotr Oledzki | ba8d7d3 | 2009-10-10 21:06:03 +0200 | [diff] [blame] | 300 | /* |
Willy Tarreau | baaee00 | 2006-06-26 02:48:02 +0200 | [diff] [blame] | 301 | * Local variables: |
| 302 | * c-indent-level: 8 |
| 303 | * c-basic-offset: 8 |
| 304 | * End: |
| 305 | */ |