REORG: buffers: split buffers into chunk,buffer,channel
Many parts of the channel definition still make use of the "buffer" word.
diff --git a/include/proto/buffers.h b/include/proto/channel.h
similarity index 60%
rename from include/proto/buffers.h
rename to include/proto/channel.h
index e0d43e9..6b5478d 100644
--- a/include/proto/buffers.h
+++ b/include/proto/channel.h
@@ -1,6 +1,6 @@
/*
- * include/proto/buffers.h
- * Buffer management definitions, macros and inline functions.
+ * include/proto/channel.h
+ * Channel management definitions, macros and inline functions.
*
* Copyright (C) 2000-2012 Willy Tarreau - w@1wt.eu
*
@@ -19,19 +19,19 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
-#ifndef _PROTO_BUFFERS_H
-#define _PROTO_BUFFERS_H
+#ifndef _PROTO_CHANNEL_H
+#define _PROTO_CHANNEL_H
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <common/config.h>
+#include <common/chunk.h>
#include <common/memory.h>
#include <common/ticks.h>
#include <common/time.h>
-#include <types/buffers.h>
#include <types/global.h>
extern struct pool_head *pool2_buffer;
@@ -47,9 +47,6 @@
int bo_getblk(struct channel *buf, char *blk, int len, int offset);
int buffer_replace2(struct channel *b, char *pos, char *end, const char *str, int len);
int buffer_insert_line2(struct channel *b, char *pos, const char *str, int len);
-void buffer_dump(FILE *o, struct buffer *b, int from, int to);
-void buffer_slow_realign(struct buffer *buf);
-void buffer_bounce_realign(struct buffer *buf);
unsigned long long buffer_forward(struct channel *buf, unsigned long long bytes);
/* Initialize all fields in the buffer. The BF_OUT_EMPTY flags is set. */
@@ -70,109 +67,6 @@
/* These functions are used to compute various buffer area sizes */
/*****************************************************************/
-/* Returns an absolute pointer for a position relative to the current buffer's
- * pointer. It is written so that it is optimal when <ofs> is a const. It is
- * written as a macro instead of an inline function so that the compiler knows
- * when it can optimize out the sign test on <ofs> when passed an unsigned int.
- */
-#define b_ptr(b, ofs) \
- ({ \
- char *__ret = (b)->p + (ofs); \
- if ((ofs) > 0 && __ret >= (b)->data + (b)->size) \
- __ret -= (b)->size; \
- else if ((ofs) < 0 && __ret < (b)->data) \
- __ret += (b)->size; \
- __ret; \
- })
-
-/* Returns the start of the input data in a buffer */
-static inline char *bi_ptr(const struct buffer *b)
-{
- return b->p;
-}
-
-/* Returns the end of the input data in a buffer (pointer to next
- * insertion point).
- */
-static inline char *bi_end(const struct buffer *b)
-{
- char *ret = b->p + b->i;
-
- if (ret >= b->data + b->size)
- ret -= b->size;
- return ret;
-}
-
-/* Returns the amount of input data that can contiguously be read at once */
-static inline int bi_contig_data(const struct buffer *b)
-{
- int data = b->data + b->size - b->p;
-
- if (data > b->i)
- data = b->i;
- return data;
-}
-
-/* Returns the start of the output data in a buffer */
-static inline char *bo_ptr(const struct buffer *b)
-{
- char *ret = b->p - b->o;
-
- if (ret < b->data)
- ret += b->size;
- return ret;
-}
-
-/* Returns the end of the output data in a buffer */
-static inline char *bo_end(const struct buffer *b)
-{
- return b->p;
-}
-
-/* Returns the amount of output data that can contiguously be read at once */
-static inline int bo_contig_data(const struct buffer *b)
-{
- char *beg = b->p - b->o;
-
- if (beg < b->data)
- return b->data - beg;
- return b->o;
-}
-
-/* Return the buffer's length in bytes by summing the input and the output */
-static inline int buffer_len(const struct buffer *buf)
-{
- return buf->i + buf->o;
-}
-
-/* Return non-zero only if the buffer is not empty */
-static inline int buffer_not_empty(const struct buffer *buf)
-{
- return buf->i | buf->o;
-}
-
-/* Return non-zero only if the buffer is empty */
-static inline int buffer_empty(const struct buffer *buf)
-{
- return !buffer_not_empty(buf);
-}
-
-/* Normalizes a pointer after a subtract */
-static inline char *buffer_wrap_sub(const struct buffer *buf, char *ptr)
-{
- if (ptr < buf->data)
- ptr += buf->size;
- return ptr;
-}
-
-/* Normalizes a pointer after an addition */
-static inline char *buffer_wrap_add(const struct buffer *buf, char *ptr)
-{
- if (ptr - buf->size >= buf->data)
- ptr -= buf->size;
- return ptr;
-}
-
/* Return the number of reserved bytes in the buffer, which ensures that once
* all pending data are forwarded, the buffer still has global.tune.maxrewrite
* bytes free. The result is between 0 and global.maxrewrite, which is itself
@@ -254,41 +148,6 @@
return 0;
}
-/* Return the maximum amount of bytes that can be written into the buffer,
- * including reserved space which may be overwritten.
- */
-static inline int buffer_total_space(const struct buffer *buf)
-{
- return buf->size - buffer_len(buf);
-}
-
-/* Returns the number of contiguous bytes between <start> and <start>+<count>,
- * and enforces a limit on buf->data + buf->size. <start> must be within the
- * buffer.
- */
-static inline int buffer_contig_area(const struct buffer *buf, const char *start, int count)
-{
- if (count > buf->data - start + buf->size)
- count = buf->data - start + buf->size;
- return count;
-}
-
-/* Return the amount of bytes that can be written into the buffer at once,
- * including reserved space which may be overwritten.
- */
-static inline int buffer_contig_space(const struct buffer *buf)
-{
- const char *left, *right;
-
- if (buf->data + buf->o <= buf->p)
- right = buf->data + buf->size;
- else
- right = buf->p + buf->size - buf->o;
-
- left = buffer_wrap_add(buf, buf->p + buf->i);
- return right - left;
-}
-
/* Advances the buffer by <adv> bytes, which means that the buffer
* pointer advances, and that as many bytes from in are transferred
* to out. The caller is responsible for ensuring that adv is always
@@ -317,29 +176,6 @@
}
/* Return the amount of bytes that can be written into the buffer at once,
- * excluding the amount of reserved space passed in <res>, which is
- * preserved.
- */
-static inline int buffer_contig_space_with_res(const struct buffer *buf, int res)
-{
- /* Proceed differently if the buffer is full, partially used or empty.
- * The hard situation is when it's partially used and either data or
- * reserved space wraps at the end.
- */
- int spare = buf->size - res;
-
- if (buffer_len(buf) >= spare)
- spare = 0;
- else if (buffer_len(buf)) {
- spare = buffer_contig_space(buf) - res;
- if (spare < 0)
- spare = 0;
- }
- return spare;
-}
-
-
-/* Return the amount of bytes that can be written into the buffer at once,
* excluding reserved space, which is preserved.
*/
static inline int buffer_contig_space_res(const struct channel *chn)
@@ -347,63 +183,6 @@
return buffer_contig_space_with_res(&chn->buf, buffer_reserved(chn));
}
-/* Normalizes a pointer which is supposed to be relative to the beginning of a
- * buffer, so that wrapping is correctly handled. The intent is to use this
- * when increasing a pointer. Note that the wrapping test is only performed
- * once, so the original pointer must be between ->data-size and ->data+2*size-1,
- * otherwise an invalid pointer might be returned.
- */
-static inline const char *buffer_pointer(const struct buffer *buf, const char *ptr)
-{
- if (ptr < buf->data)
- ptr += buf->size;
- else if (ptr - buf->size >= buf->data)
- ptr -= buf->size;
- return ptr;
-}
-
-/* Returns the distance between two pointers, taking into account the ability
- * to wrap around the buffer's end.
- */
-static inline int buffer_count(const struct buffer *buf, const char *from, const char *to)
-{
- int count = to - from;
- if (count < 0)
- count += buf->size;
- return count;
-}
-
-/* returns the amount of pending bytes in the buffer. It is the amount of bytes
- * that is not scheduled to be sent.
- */
-static inline int buffer_pending(const struct buffer *buf)
-{
- return buf->i;
-}
-
-/* Returns the size of the working area which the caller knows ends at <end>.
- * If <end> equals buf->r (modulo size), then it means that the free area which
- * follows is part of the working area. Otherwise, the working area stops at
- * <end>. It always starts at buf->p. The work area includes the
- * reserved area.
- */
-static inline int buffer_work_area(const struct buffer *buf, const char *end)
-{
- end = buffer_pointer(buf, end);
- if (end == buffer_wrap_add(buf, buf->p + buf->i))
- /* pointer exactly at end, lets push forwards */
- end = buffer_wrap_sub(buf, buf->p - buf->o);
- return buffer_count(buf, buf->p, end);
-}
-
-/* Return 1 if the buffer has less than 1/4 of its capacity free, otherwise 0 */
-static inline int buffer_almost_full(const struct buffer *buf)
-{
- if (buffer_total_space(buf) < buf->size / 4)
- return 1;
- return 0;
-}
-
/* Returns true if the buffer's input is already closed */
static inline int buffer_input_closed(struct channel *buf)
{
@@ -485,18 +264,6 @@
buf->flags |= BF_FULL;
}
-/* Cut the first <n> pending bytes in a contiguous buffer. It is illegal to
- * call this function with remaining data waiting to be sent (o > 0). The
- * caller must ensure that <n> is smaller than the actual buffer's length.
- * This is mainly used to remove empty lines at the beginning of a request
- * or a response.
- */
-static inline void bi_fast_delete(struct buffer *buf, int n)
-{
- buf->i -= n;
- buf->p += n;
-}
-
/* marks the buffer as "shutdown" ASAP for reads */
static inline void buffer_shutr_now(struct channel *buf)
{
@@ -575,19 +342,6 @@
}
/*
- * Tries to realign the given buffer, and returns how many bytes can be written
- * there at once without overwriting anything.
- */
-static inline int buffer_realign(struct buffer *buf)
-{
- if (!(buf->i | buf->o)) {
- /* let's realign the buffer to optimize I/O */
- buf->p = buf->data;
- }
- return buffer_contig_space(buf);
-}
-
-/*
* Advance the buffer's read pointer by <len> bytes. This is useful when data
* have been read directly from the buffer. It is illegal to call this function
* with <len> causing a wrapping at the end of the buffer. It's the caller's
@@ -669,91 +423,8 @@
return buffer_replace2(b, pos, end, str, strlen(str));
}
-/*
- *
- * Functions below are used to manage chunks
- *
- */
-
-static inline void chunk_init(struct chunk *chk, char *str, size_t size) {
- chk->str = str;
- chk->len = 0;
- chk->size = size;
-}
-
-/* report 0 in case of error, 1 if OK. */
-static inline int chunk_initlen(struct chunk *chk, char *str, size_t size, int len) {
-
- if (size && len > size)
- return 0;
-
- chk->str = str;
- chk->len = len;
- chk->size = size;
-
- return 1;
-}
-
-static inline void chunk_initstr(struct chunk *chk, char *str) {
- chk->str = str;
- chk->len = strlen(str);
- chk->size = 0; /* mark it read-only */
-}
-
-static inline int chunk_strcpy(struct chunk *chk, const char *str) {
- size_t len;
-
- len = strlen(str);
-
- if (unlikely(len > chk->size))
- return 0;
-
- chk->len = len;
- memcpy(chk->str, str, len);
-
- return 1;
-}
-
-int chunk_printf(struct chunk *chk, const char *fmt, ...)
- __attribute__ ((format(printf, 2, 3)));
-
-int chunk_htmlencode(struct chunk *dst, struct chunk *src);
-int chunk_asciiencode(struct chunk *dst, struct chunk *src, char qc);
-
-static inline void chunk_reset(struct chunk *chk) {
- chk->str = NULL;
- chk->len = -1;
- chk->size = 0;
-}
-
-static inline void chunk_destroy(struct chunk *chk) {
-
- if (!chk->size)
- return;
-
- if (chk->str)
- free(chk->str);
-
- chunk_reset(chk);
-}
-
-/*
- * frees the destination chunk if already allocated, allocates a new string,
- * and copies the source into it. The pointer to the destination string is
- * returned, or NULL if the allocation fails or if any pointer is NULL..
- */
-static inline char *chunk_dup(struct chunk *dst, const struct chunk *src) {
- if (!dst || !src || !src->str)
- return NULL;
- if (dst->str)
- free(dst->str);
- dst->len = src->len;
- dst->str = (char *)malloc(dst->len);
- memcpy(dst->str, src->str, dst->len);
- return dst->str;
-}
-#endif /* _PROTO_BUFFERS_H */
+#endif /* _PROTO_CHANNEL_H */
/*
* Local variables:
diff --git a/include/proto/dumpstats.h b/include/proto/dumpstats.h
index 449ddc1..b6a689c 100644
--- a/include/proto/dumpstats.h
+++ b/include/proto/dumpstats.h
@@ -24,8 +24,7 @@
#define _PROTO_DUMPSTATS_H
#include <common/config.h>
-#include <types/buffers.h>
-#include <types/session.h>
+#include <types/stream_interface.h>
/* Flags for applet.ctx.stats.flags */
#define STAT_FMT_CSV 0x00000001 /* dump the stats in CSV format instead of HTML */