← Back to branch summary

~ubuntu-branches/ubuntu/vivid/haproxy/vivid

« back to all changes in this revision

Viewing changes to include/proto/channel.h

  • Committer: Package Import Robot
  • Author(s): Apollon Oikonomopoulos
  • Date: 2014-06-20 11:05:17 UTC
  • mfrom: (1.1.15) (15.1.12 experimental)
  • Revision ID: package-import@ubuntu.com-20140620110517-u6q5p9kyy2f3ozw9
Tags: 1.5.0-1
* New upstream stable series. Notable changes since the 1.4 series:
  + Native SSL support on both sides with SNI/NPN/ALPN and OCSP stapling.
  + IPv6 and UNIX sockets are supported everywhere
  + End-to-end HTTP keep-alive for better support of NTLM and improved
    efficiency in static farms
  + HTTP/1.1 response compression (deflate, gzip) to save bandwidth
  + PROXY protocol versions 1 and 2 on both sides
  + Data sampling on everything in request or response, including payload
  + ACLs can use any matching method with any input sample
  + Maps and dynamic ACLs updatable from the CLI
  + Stick-tables support counters to track activity on any input sample
  + Custom format for logs, unique-id, header rewriting, and redirects
  + Improved health checks (SSL, scripted TCP, check agent, ...)
  + Much more scalable configuration supports hundreds of thousands of
    backends and certificates without sweating

* Upload to unstable, merge all 1.5 work from experimental. Most important
  packaging changes since 1.4.25-1 include:
  + systemd support.
  + A more sane default config file.
  + Zero-downtime upgrades between 1.5 releases by gracefully reloading
    HAProxy during upgrades.
  + HTML documentation shipped in the haproxy-doc package.
  + kqueue support for kfreebsd.

* Packaging changes since 1.5~dev26-2:
  + Drop patches merged upstream:
    o Fix-reference-location-in-manpage.patch
    o 0001-BUILD-stats-workaround-stupid-and-bogus-Werror-forma.patch
  + d/watch: look for stable 1.5 releases
  + systemd: respect CONFIG and EXTRAOPTS when specified in
    /etc/default/haproxy.
  + initscript: test the configuration before start or reload.
  + initscript: remove the ENABLED flag and logic.

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/proto/channel.h
 
1
/*
 
2
 * include/proto/channel.h
 
3
 * Channel management definitions, macros and inline functions.
 
4
 *
 
5
 * Copyright (C) 2000-2012 Willy Tarreau - w@1wt.eu
 
6
 *
 
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
 */
 
21
 
 
22
#ifndef _PROTO_CHANNEL_H
 
23
#define _PROTO_CHANNEL_H
 
24
 
 
25
#include <stdio.h>
 
26
#include <stdlib.h>
 
27
#include <string.h>
 
28
 
 
29
#include <common/config.h>
 
30
#include <common/chunk.h>
 
31
#include <common/memory.h>
 
32
#include <common/ticks.h>
 
33
#include <common/time.h>
 
34
 
 
35
#include <types/global.h>
 
36
 
 
37
extern struct pool_head *pool2_channel;
 
38
 
 
39
/* perform minimal intializations, report 0 in case of error, 1 if OK. */
 
40
int init_channel();
 
41
 
 
42
unsigned long long __channel_forward(struct channel *chn, unsigned long long bytes);
 
43
 
 
44
/* SI-to-channel functions working with buffers */
 
45
int bi_putblk(struct channel *chn, const char *str, int len);
 
46
int bi_putchr(struct channel *chn, char c);
 
47
int bo_inject(struct channel *chn, const char *msg, int len);
 
48
int bo_getline(struct channel *chn, char *str, int len);
 
49
int bo_getblk(struct channel *chn, char *blk, int len, int offset);
 
50
 
 
51
/* Initialize all fields in the channel. */
 
52
static inline void channel_init(struct channel *chn)
 
53
{
 
54
        chn->buf->o = 0;
 
55
        chn->buf->i = 0;
 
56
        chn->buf->p = chn->buf->data;
 
57
        chn->to_forward = 0;
 
58
        chn->last_read = now_ms;
 
59
        chn->xfer_small = chn->xfer_large = 0;
 
60
        chn->total = 0;
 
61
        chn->pipe = NULL;
 
62
        chn->analysers = 0;
 
63
        chn->cons = NULL;
 
64
        chn->flags = 0;
 
65
}
 
66
 
 
67
/* 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
 */
 
75
static 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
 
 
93
/*********************************************************************/
 
94
/* These functions are used to compute various channel content sizes */
 
95
/*********************************************************************/
 
96
 
 
97
/* 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
 */
 
102
static inline unsigned int channel_is_empty(struct channel *c)
 
103
{
 
104
        return !(c->buf->o | (long)c->pipe);
 
105
}
 
106
 
 
107
/* 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
 */
 
111
static 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.
 
129
 */
 
130
static inline int channel_full(const struct channel *chn)
 
131
{
 
132
        int rem = chn->buf->size;
 
133
 
 
134
        rem -= chn->buf->o;
 
135
        rem -= chn->buf->i;
 
136
        if (!rem)
 
137
                return 1; /* buffer already full */
 
138
 
 
139
        if (chn->to_forward >= chn->buf->size ||
 
140
            (CHN_INFINITE_FORWARD < MAX_RANGE(typeof(chn->buf->size)) && // just there to ensure gcc
 
141
             chn->to_forward == CHN_INFINITE_FORWARD))                  // avoids the useless second
 
142
                return 0;                                               // test whenever possible
 
143
 
 
144
        rem -= global.tune.maxrewrite;
 
145
        rem += chn->buf->o;
 
146
        rem += chn->to_forward;
 
147
        return rem <= 0;
 
148
}
 
149
 
 
150
/* Returns true if the channel's input is already closed */
 
151
static inline int channel_input_closed(struct channel *chn)
 
152
{
 
153
        return ((chn->flags & CF_SHUTR) != 0);
 
154
}
 
155
 
 
156
/* Returns true if the channel's output is already closed */
 
157
static inline int channel_output_closed(struct channel *chn)
 
158
{
 
159
        return ((chn->flags & CF_SHUTW) != 0);
 
160
}
 
161
 
 
162
/* 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.
 
166
 */
 
167
static inline void channel_check_timeouts(struct channel *chn)
 
168
{
 
169
        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;
 
172
 
 
173
        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;
 
176
 
 
177
        if (likely(!(chn->flags & CF_ANA_TIMEOUT)) &&
 
178
            unlikely(tick_is_expired(chn->analyse_exp, now_ms)))
 
179
                chn->flags |= CF_ANA_TIMEOUT;
 
180
}
 
181
 
 
182
/* Erase any content from channel <buf> and adjusts flags accordingly. Note
 
183
 * that any spliced data is not affected since we may not have any access to
 
184
 * it.
 
185
 */
 
186
static inline void channel_erase(struct channel *chn)
 
187
{
 
188
        chn->buf->o = 0;
 
189
        chn->buf->i = 0;
 
190
        chn->to_forward = 0;
 
191
        chn->buf->p = chn->buf->data;
 
192
}
 
193
 
 
194
/* marks the channel as "shutdown" ASAP for reads */
 
195
static inline void channel_shutr_now(struct channel *chn)
 
196
{
 
197
        chn->flags |= CF_SHUTR_NOW;
 
198
}
 
199
 
 
200
/* marks the channel as "shutdown" ASAP for writes */
 
201
static inline void channel_shutw_now(struct channel *chn)
 
202
{
 
203
        chn->flags |= CF_SHUTW_NOW;
 
204
}
 
205
 
 
206
/* marks the channel as "shutdown" ASAP in both directions */
 
207
static inline void channel_abort(struct channel *chn)
 
208
{
 
209
        chn->flags |= CF_SHUTR_NOW | CF_SHUTW_NOW;
 
210
        chn->flags &= ~CF_AUTO_CONNECT;
 
211
}
 
212
 
 
213
/* allow the consumer to try to establish a new connection. */
 
214
static inline void channel_auto_connect(struct channel *chn)
 
215
{
 
216
        chn->flags |= CF_AUTO_CONNECT;
 
217
}
 
218
 
 
219
/* prevent the consumer from trying to establish a new connection, and also
 
220
 * disable auto shutdown forwarding.
 
221
 */
 
222
static inline void channel_dont_connect(struct channel *chn)
 
223
{
 
224
        chn->flags &= ~(CF_AUTO_CONNECT|CF_AUTO_CLOSE);
 
225
}
 
226
 
 
227
/* allow the producer to forward shutdown requests */
 
228
static inline void channel_auto_close(struct channel *chn)
 
229
{
 
230
        chn->flags |= CF_AUTO_CLOSE;
 
231
}
 
232
 
 
233
/* prevent the producer from forwarding shutdown requests */
 
234
static inline void channel_dont_close(struct channel *chn)
 
235
{
 
236
        chn->flags &= ~CF_AUTO_CLOSE;
 
237
}
 
238
 
 
239
/* allow the producer to read / poll the input */
 
240
static inline void channel_auto_read(struct channel *chn)
 
241
{
 
242
        chn->flags &= ~CF_DONT_READ;
 
243
}
 
244
 
 
245
/* prevent the producer from read / poll the input */
 
246
static inline void channel_dont_read(struct channel *chn)
 
247
{
 
248
        chn->flags |= CF_DONT_READ;
 
249
}
 
250
 
 
251
 
 
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
 
261
 * any chn->size.
 
262
 */
 
263
static inline int buffer_reserved(const struct channel *chn)
 
264
{
 
265
        int ret = global.tune.maxrewrite - chn->to_forward - chn->buf->o;
 
266
 
 
267
        if (chn->to_forward == CHN_INFINITE_FORWARD)
 
268
                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
 
276
 * bytes free. The result sits between chn->size - maxrewrite and chn->size.
 
277
 */
 
278
static inline int buffer_max_len(const struct channel *chn)
 
279
{
 
280
        return chn->buf->size - buffer_reserved(chn);
 
281
}
 
282
 
 
283
/* Returns the amount of space available at the input of the buffer, taking the
 
284
 * reserved space into account if ->to_forward indicates that an end of transfer
 
285
 * is close to happen. The test is optimized to avoid as many operations as
 
286
 * possible for the fast case.
 
287
 */
 
288
static inline int bi_avail(const struct channel *chn)
 
289
{
 
290
        int rem = chn->buf->size;
 
291
        int rem2;
 
292
 
 
293
        rem -= chn->buf->o;
 
294
        rem -= chn->buf->i;
 
295
        if (!rem)
 
296
                return rem; /* buffer already full */
 
297
 
 
298
        if (chn->to_forward >= chn->buf->size ||
 
299
            (CHN_INFINITE_FORWARD < MAX_RANGE(typeof(chn->buf->size)) && // just there to ensure gcc
 
300
             chn->to_forward == CHN_INFINITE_FORWARD))                  // avoids the useless second
 
301
                return rem;                                             // test whenever possible
 
302
 
 
303
        rem2 = rem - global.tune.maxrewrite;
 
304
        rem2 += chn->buf->o;
 
305
        rem2 += chn->to_forward;
 
306
 
 
307
        if (rem > rem2)
 
308
                rem = rem2;
 
309
        if (rem > 0)
 
310
                return rem;
 
311
        return 0;
 
312
}
 
313
 
 
314
/* Cut the "tail" of the channel's buffer, which means strip it to the length
 
315
 * of unsent data only, and kill any remaining unsent data. Any scheduled
 
316
 * forwarding is stopped. This is mainly to be used to send error messages
 
317
 * after existing data.
 
318
 */
 
319
static inline void bi_erase(struct channel *chn)
 
320
{
 
321
        if (!chn->buf->o)
 
322
                return channel_erase(chn);
 
323
 
 
324
        chn->to_forward = 0;
 
325
        if (!chn->buf->i)
 
326
                return;
 
327
 
 
328
        chn->buf->i = 0;
 
329
}
 
330
 
 
331
/*
 
332
 * Advance the channel buffer's read pointer by <len> bytes. This is useful
 
333
 * when data have been read directly from the buffer. It is illegal to call
 
334
 * this function with <len> causing a wrapping at the end of the buffer. It's
 
335
 * the caller's responsibility to ensure that <len> is never larger than
 
336
 * chn->o. Channel flag WRITE_PARTIAL is set.
 
337
 */
 
338
static inline void bo_skip(struct channel *chn, int len)
 
339
{
 
340
        chn->buf->o -= len;
 
341
 
 
342
        if (buffer_empty(chn->buf))
 
343
                chn->buf->p = chn->buf->data;
 
344
 
 
345
        /* notify that some data was written to the SI from the buffer */
 
346
        chn->flags |= CF_WRITE_PARTIAL;
 
347
}
 
348
 
 
349
/* Tries to copy chunk <chunk> into the channel's buffer after length controls.
 
350
 * The chn->o and to_forward pointers are updated. If the channel's input is
 
351
 * closed, -2 is returned. If the block is too large for this buffer, -3 is
 
352
 * returned. If there is not enough room left in the buffer, -1 is returned.
 
353
 * Otherwise the number of bytes copied is returned (0 being a valid number).
 
354
 * Channel flag READ_PARTIAL is updated if some data can be transferred. The
 
355
 * chunk's length is updated with the number of bytes sent.
 
356
 */
 
357
static inline int bi_putchk(struct channel *chn, struct chunk *chunk)
 
358
{
 
359
        int ret;
 
360
 
 
361
        ret = bi_putblk(chn, chunk->str, chunk->len);
 
362
        if (ret > 0)
 
363
                chunk->len -= ret;
 
364
        return ret;
 
365
}
 
366
 
 
367
/* Tries to copy string <str> at once into the channel's buffer after length
 
368
 * controls.  The chn->o and to_forward pointers are updated. If the channel's
 
369
 * input is closed, -2 is returned. If the block is too large for this buffer,
 
370
 * -3 is returned. If there is not enough room left in the buffer, -1 is
 
371
 * returned.  Otherwise the number of bytes copied is returned (0 being a valid
 
372
 * number).  Channel flag READ_PARTIAL is updated if some data can be
 
373
 * transferred.
 
374
 */
 
375
static inline int bi_putstr(struct channel *chn, const char *str)
 
376
{
 
377
        return bi_putblk(chn, str, strlen(str));
 
378
}
 
379
 
 
380
/*
 
381
 * Return one char from the channel's buffer. If the buffer is empty and the
 
382
 * channel is closed, return -2. If the buffer is just empty, return -1. The
 
383
 * buffer's pointer is not advanced, it's up to the caller to call bo_skip(buf,
 
384
 * 1) when it has consumed the char.  Also note that this function respects the
 
385
 * chn->o limit.
 
386
 */
 
387
static inline int bo_getchr(struct channel *chn)
 
388
{
 
389
        /* closed or empty + imminent close = -2; empty = -1 */
 
390
        if (unlikely((chn->flags & CF_SHUTW) || channel_is_empty(chn))) {
 
391
                if (chn->flags & (CF_SHUTW|CF_SHUTW_NOW))
 
392
                        return -2;
 
393
                return -1;
 
394
        }
 
395
        return *buffer_wrap_sub(chn->buf, chn->buf->p - chn->buf->o);
 
396
}
 
397
 
 
398
 
 
399
#endif /* _PROTO_CHANNEL_H */
 
400
 
 
401
/*
 
402
 * Local variables:
 
403
 *  c-indent-level: 8
 
404
 *  c-basic-offset: 8
 
405
 * End:
 
406
 */