Now all the code used to manipulate chunks uses a struct buffer instead.
The functions are still called "chunk*", and some of them will progressively
move to the generic buffer handling code as they are cleaned up.
char trash_buf[MAX_RQ_SIZE];
char tmp_buf[MAX_RQ_SIZE];
-struct chunk trash = { .area = trash_buf, .data = 0, .size = sizeof(trash_buf) };
-struct chunk tmp = { .area = tmp_buf, .data = 0, .size = sizeof(tmp_buf) };
+struct buffer trash = { .area = trash_buf, .data = 0, .size = sizeof(trash_buf) };
+struct buffer tmp = { .area = tmp_buf, .data = 0, .size = sizeof(tmp_buf) };
/* displays a <len> long memory block at <buf>, assuming first byte of <buf>
* has address <baseaddr>. String <pfx> may be placed as a prefix in front of
struct apr_bucket_defender {
apr_bucket_refcount refcount;
- struct chunk buf;
+ struct buffer buf;
};
static apr_status_t defender_bucket_read(apr_bucket *b, const char **str,
apr_bucket_free(d);
}
-static apr_bucket *defender_bucket_make(apr_bucket *b, const struct chunk *buf)
+static apr_bucket *defender_bucket_make(apr_bucket *b,
+ const struct buffer *buf)
{
struct apr_bucket_defender *d;
return b;
}
-static apr_bucket *defender_bucket_create(const struct chunk *buf,
+static apr_bucket *defender_bucket_create(const struct buffer *buf,
apr_bucket_alloc_t *list)
{
apr_bucket *b = apr_bucket_alloc(sizeof(*b), list);
struct apr_bucket_brigade *bb = NULL;
struct apr_bucket *d = NULL, *e = NULL;
- struct chunk *method;
- struct chunk *path;
- struct chunk *query;
- struct chunk *version;
- struct chunk *body;
+ struct buffer *method;
+ struct buffer *path;
+ struct buffer *query;
+ struct buffer *version;
+ struct buffer *body;
struct defender_header hdr;
char *hdr_ptr, *hdr_end;
struct http_msg *msg);
void (*http_reply) (struct stream *s, struct filter *f,
short status,
- const struct chunk *msg);
+ const struct buffer *msg);
/*
* TCP callbacks
#include <stdlib.h>
#include <string.h>
+#include <common/buf.h>
#include <common/config.h>
#include <common/memory.h>
-/* describes a chunk of string */
-struct chunk {
- char *area; /* points to <size> bytes */
- size_t size; /* buffer size in bytes */
- size_t data; /* amount of data after head including wrapping */
-};
-
struct pool_head *pool_head_trash;
/* function prototypes */
-int chunk_printf(struct chunk *chk, const char *fmt, ...)
+int chunk_printf(struct buffer *chk, const char *fmt, ...)
__attribute__ ((format(printf, 2, 3)));
-int chunk_appendf(struct chunk *chk, const char *fmt, ...)
+int chunk_appendf(struct buffer *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);
-int chunk_strcmp(const struct chunk *chk, const char *str);
-int chunk_strcasecmp(const struct chunk *chk, const char *str);
-struct chunk *get_trash_chunk(void);
-struct chunk *alloc_trash_chunk(void);
+int chunk_htmlencode(struct buffer *dst, struct buffer *src);
+int chunk_asciiencode(struct buffer *dst, struct buffer *src, char qc);
+int chunk_strcmp(const struct buffer *chk, const char *str);
+int chunk_strcasecmp(const struct buffer *chk, const char *str);
+struct buffer *get_trash_chunk(void);
+struct buffer *alloc_trash_chunk(void);
int init_trash_buffers(int first);
void deinit_trash_buffers(void);
/*
* free a trash chunk allocated by alloc_trash_chunk(). NOP on NULL.
*/
-static inline void free_trash_chunk(struct chunk *chunk)
+static inline void free_trash_chunk(struct buffer *chunk)
{
pool_free(pool_head_trash, chunk);
}
-static inline void chunk_reset(struct chunk *chk)
+static inline void chunk_reset(struct buffer *chk)
{
chk->data = 0;
}
-static inline void chunk_init(struct chunk *chk, char *str, size_t size)
+static inline void chunk_init(struct buffer *chk, char *str, size_t size)
{
- chk->area = str;
- chk->data = 0;
+ chk->area = str;
+ chk->head = 0;
+ chk->data = 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)
+static inline int chunk_initlen(struct buffer *chk, char *str, size_t size,
+ int len)
{
if (len < 0 || (size && len > size))
return 0;
- chk->area = str;
- chk->data = len;
+ chk->area = str;
+ chk->head = 0;
+ chk->data = len;
chk->size = size;
return 1;
}
/* this is only for temporary manipulation, the chunk is read-only */
-static inline void chunk_initstr(struct chunk *chk, const char *str)
+static inline void chunk_initstr(struct buffer *chk, const char *str)
{
chk->area = (char *)str;
+ chk->head = 0;
chk->data = strlen(str);
chk->size = 0; /* mark it read-only */
}
/* copies memory area <src> into <chk> for <len> bytes. Returns 0 in
* case of failure. No trailing zero is added.
*/
-static inline int chunk_memcpy(struct chunk *chk, const char *src, size_t len)
+static inline int chunk_memcpy(struct buffer *chk, const char *src,
+ size_t len)
{
if (unlikely(len >= chk->size))
return 0;
/* appends memory area <src> after <chk> for <len> bytes. Returns 0 in
* case of failure. No trailing zero is added.
*/
-static inline int chunk_memcat(struct chunk *chk, const char *src, size_t len)
+static inline int chunk_memcat(struct buffer *chk, const char *src,
+ size_t len)
{
if (unlikely(chk->data < 0 || chk->data + len >= chk->size))
return 0;
/* copies str into <chk> followed by a trailing zero. Returns 0 in
* case of failure.
*/
-static inline int chunk_strcpy(struct chunk *chk, const char *str)
+static inline int chunk_strcpy(struct buffer *chk, const char *str)
{
size_t len;
/* appends str after <chk> followed by a trailing zero. Returns 0 in
* case of failure.
*/
-static inline int chunk_strcat(struct chunk *chk, const char *str)
+static inline int chunk_strcat(struct buffer *chk, const char *str)
{
size_t len;
/* appends <nb> characters from str after <chk>.
* Returns 0 in case of failure.
*/
-static inline int chunk_strncat(struct chunk *chk, const char *str, int nb)
+static inline int chunk_strncat(struct buffer *chk, const char *str, int nb)
{
if (unlikely(chk->data < 0 || chk->data + nb >= chk->size))
return 0;
* chunk_appendf(&trash, "%s", gethosname());
* printf("hostname=<%s>, pid=<%d>\n", name, pid);
*/
-static inline char *chunk_newstr(struct chunk *chk)
+static inline char *chunk_newstr(struct buffer *chk)
{
if (chk->data < 0 || chk->data + 1 >= chk->size)
return NULL;
return chk->area + chk->data;
}
-static inline void chunk_drop(struct chunk *chk)
+static inline void chunk_drop(struct buffer *chk)
{
chk->area = NULL;
chk->data = -1;
chk->size = 0;
}
-static inline void chunk_destroy(struct chunk *chk)
+static inline void chunk_destroy(struct buffer *chk)
{
if (!chk->size)
return;
* 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)
+static inline char *chunk_dup(struct buffer *dst, const struct buffer *src)
{
if (!dst || !src || src->data < 0 || !src->area)
return NULL;
if (dst->size)
free(dst->area);
+ dst->head = src->head;
dst->data = src->data;
dst->size = src->data;
if (dst->size < src->size || !src->size)
dst->area = (char *)malloc(dst->size);
if (!dst->area) {
+ dst->head = 0;
dst->data = 0;
dst->size = 0;
return NULL;
#include <common/hpack-tbl.h>
int hpack_decode_frame(struct hpack_dht *dht, const uint8_t *raw, uint32_t len,
- struct http_hdr *list, int list_size, struct chunk *tmp);
+ struct http_hdr *list, int list_size,
+ struct buffer *tmp);
#endif /* _COMMON_HPACK_DEC_H */
#include <common/config.h>
#include <common/ist.h>
-int hpack_encode_header(struct chunk *out, const struct ist n, const struct ist v);
+int hpack_encode_header(struct buffer *out, const struct ist n,
+ const struct ist v);
#endif /* _COMMON_HPACK_ENC_H */
*/
char *encode_chunk(char *start, char *stop,
const char escape, const fd_set *map,
- const struct chunk *chunk);
+ const struct buffer *chunk);
/*
* Tries to prefix characters tagged in the <map> with the <escape>
*/
char *escape_chunk(char *start, char *stop,
const char escape, const fd_set *map,
- const struct chunk *chunk);
+ const struct buffer *chunk);
/* Check a string for using it in a CSV output format. If the string contains
* This function appends the encoding to the existing output chunk. Please
* use csv_enc() instead if you want to replace the output chunk.
*/
-const char *csv_enc_append(const char *str, int quote, struct chunk *output);
+const char *csv_enc_append(const char *str, int quote, struct buffer *output);
/* same as above but the output chunk is reset first */
-static inline const char *csv_enc(const char *str, int quote, struct chunk *output)
+static inline const char *csv_enc(const char *str, int quote,
+ struct buffer *output)
{
chunk_reset(output);
return csv_enc_append(str, quote, output);
struct list;
int list_append_word(struct list *li, const char *str, char **err);
-int dump_text(struct chunk *out, const char *buf, int bsize);
-int dump_binary(struct chunk *out, const char *buf, int bsize);
-int dump_text_line(struct chunk *out, const char *buf, int bsize, int len,
+int dump_text(struct buffer *out, const char *buf, int bsize);
+int dump_binary(struct buffer *out, const char *buf, int bsize);
+int dump_text_line(struct buffer *out, const char *buf, int bsize, int len,
int *line, int ptr);
/* same as realloc() except that ptr is also freed upon failure */
return NULL;
}
-static inline void action_build_list(struct list *keywords, struct chunk *chk)
+static inline void action_build_list(struct list *keywords,
+ struct buffer *chk)
{
struct action_kw_list *kw_list;
int i;
* Channel flag READ_PARTIAL is updated if some data can be transferred. The
* chunk's length is updated with the number of bytes sent.
*/
-static inline int ci_putchk(struct channel *chn, struct chunk *chunk)
+static inline int ci_putchk(struct channel *chn, struct buffer *chunk)
{
int ret;
int flt_http_forward_data(struct stream *s, struct http_msg *msg, unsigned int len);
void flt_http_reset(struct stream *s, struct http_msg *msg);
-void flt_http_reply(struct stream *s, short status, const struct chunk *msg);
+void flt_http_reply(struct stream *s, short status, const struct buffer *msg);
int flt_start_analyze(struct stream *s, struct channel *chn, unsigned int an_bit);
int flt_pre_analyze(struct stream *s, struct channel *chn, unsigned int an_bit);
*/
extern const int http_err_codes[HTTP_ERR_SIZE];
-extern struct chunk http_err_chunks[HTTP_ERR_SIZE];
+extern struct buffer http_err_chunks[HTTP_ERR_SIZE];
extern const char *HTTP_302;
extern const char *HTTP_303;
struct act_rule *parse_http_res_cond(const char **args, const char *file, int linenum, struct proxy *proxy);
void free_http_req_rules(struct list *r);
void free_http_res_rules(struct list *r);
-void http_reply_and_close(struct stream *s, short status, struct chunk *msg);
-struct chunk *http_error_message(struct stream *s);
+void http_reply_and_close(struct stream *s, short status, struct buffer *msg);
+struct buffer *http_error_message(struct stream *s);
struct redirect_rule *http_parse_redirect_rule(const char *file, int linenum, struct proxy *curproxy,
const char **args, char **errmsg, int use_fmt, int dir);
int smp_fetch_cookie(const struct arg *args, struct sample *smp, const char *kw, void *private);
*/
void srv_shutdown_backup_streams(struct proxy *px, int why);
-void srv_append_status(struct chunk *msg, struct server *s, struct check *, int xferred, int forced);
+void srv_append_status(struct buffer *msg, struct server *s, struct check *,
+ int xferred, int forced);
void srv_set_stopped(struct server *s, const char *reason, struct check *check);
void srv_set_running(struct server *s, const char *reason, struct check *check);
case SMP_T_STR:
case SMP_T_BIN: {
- struct chunk *chk = &smp->data.u.str;
+ struct buffer *chk = &smp->data.u.str;
/* Here, we need to know if the sample has already been
* partially encoded. If yes, we only need to encode the
* type (string or binary), the buffer length
* (as a varint) and at least 1 byte of the
* buffer. */
- struct chunk *chk = &smp->data.u.str;
+ struct buffer *chk = &smp->data.u.str;
*p++ = (smp->data.type == SMP_T_STR)
? SPOE_DATA_T_STR
void ssl_sock_set_servername(struct connection *conn, const char *hostname);
int ssl_sock_get_cert_used_sess(struct connection *conn);
int ssl_sock_get_cert_used_conn(struct connection *conn);
-int ssl_sock_get_remote_common_name(struct connection *conn, struct chunk *out);
-int ssl_sock_get_pkey_algo(struct connection *conn, struct chunk *out);
+int ssl_sock_get_remote_common_name(struct connection *conn,
+ struct buffer *out);
+int ssl_sock_get_pkey_algo(struct connection *conn, struct buffer *out);
unsigned int ssl_sock_get_verify_result(struct connection *conn);
#if (defined SSL_CTRL_SET_TLSEXT_STATUS_REQ_CB && !defined OPENSSL_NO_OCSP)
-int ssl_sock_update_ocsp_response(struct chunk *ocsp_response, char **err);
+int ssl_sock_update_ocsp_response(struct buffer *ocsp_response, char **err);
#endif
#if (defined SSL_CTRL_SET_TLSEXT_TICKET_KEY_CB && TLS_TICKETS_NO > 0)
-void ssl_sock_update_tlskey_ref(struct tls_keys_ref *ref, struct chunk *tlskey);
-int ssl_sock_update_tlskey(char *filename, struct chunk *tlskey, char **err);
+void ssl_sock_update_tlskey_ref(struct tls_keys_ref *ref,
+ struct buffer *tlskey);
+int ssl_sock_update_tlskey(char *filename, struct buffer *tlskey, char **err);
struct tls_keys_ref *tlskeys_ref_lookup(const char *filename);
struct tls_keys_ref *tlskeys_ref_lookupid(int unique_id);
#endif
extern struct applet http_stats_applet;
void stats_io_handler(struct stream_interface *si);
-int stats_emit_raw_data_field(struct chunk *out, const struct field *f);
-int stats_emit_typed_data_field(struct chunk *out, const struct field *f);
-int stats_emit_field_tags(struct chunk *out, const struct field *f, char delim);
+int stats_emit_raw_data_field(struct buffer *out, const struct field *f);
+int stats_emit_typed_data_field(struct buffer *out, const struct field *f);
+int stats_emit_field_tags(struct buffer *out, const struct field *f,
+ char delim);
#endif /* _PROTO_STATS_H */
/* main event functions used to move data between sockets and buffers */
int stream_int_check_timeouts(struct stream_interface *si);
void stream_int_report_error(struct stream_interface *si);
-void stream_int_retnclose(struct stream_interface *si, const struct chunk *msg);
+void stream_int_retnclose(struct stream_interface *si,
+ const struct buffer *msg);
int conn_si_send_proxy(struct connection *conn, unsigned int flag);
void stream_sock_read0(struct stream_interface *si);
unsigned short state; /* Internal appctx state */
unsigned int st0; /* CLI state for stats, session state for peers */
unsigned int st1; /* prompt/payload (bitwise OR of APPCTX_CLI_ST1_*) for stats, session error for peers */
- struct chunk *chunk; /* used to store unfinished commands */
+ struct buffer *chunk; /* used to store unfinished commands */
unsigned int st2; /* output state for stats, unused by peers */
struct applet *applet; /* applet this context refers to */
void *owner; /* pointer to upper layer's entity (eg: stream interface) */
struct pat_ref *ref;
struct bref bref; /* back-reference from the pat_ref_elt being dumped */
struct pattern_expr *expr;
- struct chunk chunk;
+ struct buffer chunk;
} map;
struct {
struct hlua *hlua;
union arg_data {
long long int sint;
- struct chunk str;
+ struct buffer str;
struct in_addr ipv4;
struct in6_addr ipv6;
struct proxy *prx; /* used for fe, be, tables */
struct conn_stream *(*attach)(struct connection *); /* Create and attach a conn_stream to an outgoing connection */
void (*detach)(struct conn_stream *); /* Detach a conn_stream from an outgoing connection, when the request is done */
- void (*show_fd)(struct chunk *, struct connection *); /* append some data about connection into chunk for "show fd" */
+ void (*show_fd)(struct buffer *, struct connection *); /* append some data about connection into chunk for "show fd" */
unsigned int flags; /* some flags characterizing the mux's capabilities (MX_FL_*) */
char name[8]; /* mux layer name, zero-terminated */
};
void (*http_reset) (struct stream *s, struct filter *f, struct http_msg *msg);
void (*http_reply) (struct stream *s, struct filter *f, short status,
- const struct chunk *msg);
+ const struct buffer *msg);
/*
* TCP callbacks
char *chroot;
char *pidfile;
char *node, *desc; /* node name & description */
- struct chunk log_tag; /* name for syslog */
+ struct buffer log_tag; /* name for syslog */
struct list logsrvs;
char *log_send_hostname; /* set hostname in syslog header */
char *server_state_base; /* path to a directory where server state files can be found */
extern int actconn; /* # of active sessions */
extern int listeners;
extern int jobs; /* # of active jobs (listeners, sessions, open devices) */
-extern THREAD_LOCAL struct chunk trash;
+extern THREAD_LOCAL struct buffer trash;
extern int nb_oldpids; /* contains the number of old pids found */
extern const int zero;
extern const int one;
struct http_auth_data {
enum ht_auth_m method; /* one of HTTP_AUTH_* */
/* 7 bytes unused here */
- struct chunk method_data; /* points to the creditial part from 'Authorization:' header */
+ struct buffer method_data; /* points to the creditial part from 'Authorization:' header */
char *user, *pass; /* extracted username & password */
};
struct list logsrvs;
struct list logformat; /* log_format linked list */
struct list logformat_sd; /* log_format linked list for the RFC5424 structured-data part */
- struct chunk log_tag; /* override default syslog tag */
+ struct buffer log_tag; /* override default syslog tag */
char *header_unique_id; /* unique-id header */
struct list format_unique_id; /* unique-id format */
int to_log; /* things to be logged (LW_*) */
char *check_path; /* PATH environment to use for external agent checks */
char *expect_str; /* http-check expected content : string or text version of the regex */
struct my_regex *expect_regex; /* http-check expected content */
- struct chunk errmsg[HTTP_ERR_SIZE]; /* default or customized error messages for known errors */
+ struct buffer errmsg[HTTP_ERR_SIZE]; /* default or customized error messages for known errors */
int uuid; /* universally unique proxy ID, used for SNMP */
unsigned int backlog; /* force the frontend's listen backlog */
unsigned long bind_proc; /* bitmask of processes using this proxy */
*/
struct meth {
enum http_meth_t meth;
- struct chunk str;
+ struct buffer str;
};
union sample_value {
long long int sint; /* used for signed 64bits integers */
struct in_addr ipv4; /* used for ipv4 addresses */
struct in6_addr ipv6; /* used for ipv6 addresses */
- struct chunk str; /* used for char strings or buffers */
+ struct buffer str; /* used for char strings or buffers */
struct meth meth; /* used for http method */
};
struct list property_names; /* list of properties to load into the data set. this is taken from 51degrees-property-name-list from config. */
char *data_file_path;
int header_count; /* number of HTTP headers related to device detection. */
- struct chunk *header_names; /* array of HTTP header names. */
+ struct buffer *header_names; /* array of HTTP header names. */
fiftyoneDegreesDataSet data_set; /* data set used with the pattern and trie detection methods. */
#ifdef FIFTYONEDEGREES_H_PATTERN_INCLUDED
fiftyoneDegreesWorksetPool *pool; /* pool of worksets to avoid creating a new one for each request. */
#ifdef FIFTYONEDEGREES_H_PATTERN_INCLUDED
static void _51d_lru_free(void *cache_entry)
{
- struct chunk *ptr = cache_entry;
+ struct buffer *ptr = cache_entry;
if (!ptr)
return;
*/
static void _51d_insert_cache_entry(struct sample *smp, struct lru64 *lru, void* domain)
{
- struct chunk *cache_entry = _51d_malloc(sizeof(*cache_entry));
+ struct buffer *cache_entry = _51d_malloc(sizeof(*cache_entry));
if (!cache_entry)
return;
*/
static void _51d_retrieve_cache_entry(struct sample *smp, struct lru64 *lru)
{
- struct chunk *cache_entry = lru->data;
+ struct buffer *cache_entry = lru->data;
smp->data.u.str.area = cache_entry->area;
smp->data.u.str.data = cache_entry->data;
}
#endif
char no_data[] = "NoData"; /* response when no data could be found */
- struct chunk *temp = get_trash_chunk();
+ struct buffer *temp = get_trash_chunk();
int j, i = 0, found;
const char* property_name;
const fiftyoneDegreesAsciiString *headerName;
fiftyoneDegreesDataSet *ds = &global_51degrees.data_set;
global_51degrees.header_count = ds->httpHeadersCount;
- global_51degrees.header_names = malloc(global_51degrees.header_count * sizeof(struct chunk));
+ global_51degrees.header_names = malloc(global_51degrees.header_count * sizeof(struct buffer));
for (index = 0; index < global_51degrees.header_count; index++) {
headerName = fiftyoneDegreesGetString(ds, ds->httpHeaders[index].headerNameOffset);
(global_51degrees.header_names + index)->area = (char*)&headerName->firstByte;
global_51degrees.header_count = fiftyoneDegreesGetHttpHeaderCount(ds);
global_51degrees.device_offsets.firstOffset = malloc(
global_51degrees.header_count * sizeof(fiftyoneDegreesDeviceOffset));
- global_51degrees.header_names = malloc(global_51degrees.header_count * sizeof(struct chunk));
+ global_51degrees.header_names = malloc(global_51degrees.header_count * sizeof(struct buffer));
global_51degrees.header_offsets = malloc(global_51degrees.header_count * sizeof(int32_t));
for (index = 0; index < global_51degrees.header_count; index++) {
global_51degrees.header_offsets[index] = fiftyoneDegreesGetHttpHeaderNameOffset(ds, index);
static int init_51degrees(void)
{
int i = 0;
- struct chunk *temp;
+ struct buffer *temp;
struct _51d_property_names *name;
char **_51d_property_list = NULL;
fiftyoneDegreesDataSetInitStatus _51d_dataset_status = DATA_SET_INIT_STATUS_NOT_SET;
value = directive_value(directive, ctx.vlen, "s-maxage", 8);
if (value) {
- struct chunk *chk = get_trash_chunk();
+ struct buffer *chk = get_trash_chunk();
chunk_strncat(chk, value, ctx.vlen - 8 + 1);
chunk_strncat(chk, "", 1);
value = directive_value(ctx.line + ctx.val, ctx.vlen, "max-age", 7);
if (value) {
- struct chunk *chk = get_trash_chunk();
+ struct buffer *chk = get_trash_chunk();
chunk_strncat(chk, value, ctx.vlen - 7 + 1);
chunk_strncat(chk, "", 1);
struct hdr_ctx ctx;
blk_SHA_CTX sha1_ctx;
- struct chunk *trash;
+ struct buffer *trash;
char *path;
char *end;
trash = get_trash_chunk();
struct conn_stream *cs = check->cs;
struct connection *conn = cs_conn(cs);
const char *err_msg;
- struct chunk *chk;
+ struct buffer *chk;
int step;
char *comment;
* ERR first, then WARN.
*/
const char *msg = cmd;
- struct chunk *t;
+ struct buffer *t;
if (!*msg || status == HCHK_STATUS_L7OKD) {
if (err && *err)
#include <types/global.h>
/* trash chunks used for various conversions */
-static THREAD_LOCAL struct chunk *trash_chunk;
-static THREAD_LOCAL struct chunk trash_chunk1;
-static THREAD_LOCAL struct chunk trash_chunk2;
+static THREAD_LOCAL struct buffer *trash_chunk;
+static THREAD_LOCAL struct buffer trash_chunk1;
+static THREAD_LOCAL struct buffer trash_chunk2;
/* trash buffers used for various conversions */
static int trash_size;
struct pool_head *pool_head_trash = NULL;
/* this is used to drain data, and as a temporary buffer for sprintf()... */
-THREAD_LOCAL struct chunk trash = { };
+THREAD_LOCAL struct buffer trash = { };
/*
* Returns a pre-allocated and initialized trash chunk that can be used for any
* a zero is always emitted at the beginning of the string so that it may be
* used as an empty string as well.
*/
-struct chunk *get_trash_chunk(void)
+struct buffer *get_trash_chunk(void)
{
char *trash_buf;
hap_register_per_thread_deinit(deinit_trash_buffers_per_thread);
}
pool_destroy(pool_head_trash);
- pool_head_trash = create_pool("trash", sizeof(struct chunk) + global.tune.bufsize, MEM_F_EXACT);
+ pool_head_trash = create_pool("trash",
+ sizeof(struct buffer) + global.tune.bufsize,
+ MEM_F_EXACT);
if (!pool_head_trash || !alloc_trash_buffers(global.tune.bufsize))
return 0;
return 1;
* call may fail and the caller is responsible for checking that the returned
* pointer is not NULL.
*/
-struct chunk *alloc_trash_chunk(void)
+struct buffer *alloc_trash_chunk(void)
{
- struct chunk *chunk;
+ struct buffer *chunk;
chunk = pool_alloc(pool_head_trash);
if (chunk) {
- char *buf = (char *)chunk + sizeof(struct chunk);
+ char *buf = (char *)chunk + sizeof(struct buffer);
*buf = 0;
- chunk_init(chunk, buf, pool_head_trash->size - sizeof(struct chunk));
+ chunk_init(chunk, buf,
+ pool_head_trash->size - sizeof(struct buffer));
}
return chunk;
}
* at most chk->size chars. If the chk->len is over, nothing is added. Returns
* the new chunk size, or < 0 in case of failure.
*/
-int chunk_printf(struct chunk *chk, const char *fmt, ...)
+int chunk_printf(struct buffer *chk, const char *fmt, ...)
{
va_list argp;
int ret;
* at most chk->size chars. If the chk->len is over, nothing is added. Returns
* the new chunk size.
*/
-int chunk_appendf(struct chunk *chk, const char *fmt, ...)
+int chunk_appendf(struct buffer *chk, const char *fmt, ...)
{
va_list argp;
int ret;
* chk->size chars. Replace non-printable or special chracters with "&#%d;".
* If the chk->len is over, nothing is added. Returns the new chunk size.
*/
-int chunk_htmlencode(struct chunk *dst, struct chunk *src)
+int chunk_htmlencode(struct buffer *dst, struct buffer *src)
{
int i, l;
int olen, free;
* chk->size chars. Replace non-printable or char passed in qc with "<%02X>".
* If the chk->len is over, nothing is added. Returns the new chunk size.
*/
-int chunk_asciiencode(struct chunk *dst, struct chunk *src, char qc)
+int chunk_asciiencode(struct buffer *dst, struct buffer *src, char qc)
{
int i, l;
int olen, free;
* zero-terminated. Return is the same as with strcmp(). Neither is allowed
* to be null.
*/
-int chunk_strcmp(const struct chunk *chk, const char *str)
+int chunk_strcmp(const struct buffer *chk, const char *str)
{
const char *s1 = chk->area;
int len = chk->data;
* <str> which must be zero-terminated. Return is the same as with strcmp().
* Neither is allowed to be null.
*/
-int chunk_strcasecmp(const struct chunk *chk, const char *str)
+int chunk_strcasecmp(const struct buffer *chk, const char *str)
{
const char *s1 = chk->area;
int len = chk->data;
{
struct cli_kw_list *kw_list;
struct cli_kw *kw;
- struct chunk *tmp = get_trash_chunk();
- struct chunk out;
+ struct buffer *tmp = get_trash_chunk();
+ struct buffer out;
free(dynamic_usage_msg);
dynamic_usage_msg = NULL;
/* prepends then outputs the argument msg with a syslog-type severity depending on severity_output value */
static int cli_output_msg(struct channel *chn, const char *msg, int severity, int severity_output)
{
- struct chunk *tmp;
+ struct buffer *tmp;
if (likely(severity_output == CLI_SEVERITY_NONE))
return ci_putblk(chn, msg, strlen(msg));
tlv->client |= PP2_CLIENT_CERT_CONN;
}
if (srv->pp_opts & SRV_PP_V2_SSL_CN) {
- struct chunk *cn_trash = get_trash_chunk();
+ struct buffer *cn_trash = get_trash_chunk();
if (ssl_sock_get_remote_common_name(remote, cn_trash) > 0) {
ssl_tlv_len += make_tlv(&buf[ret+ssl_tlv_len], (buf_len - ret - ssl_tlv_len), PP2_SUBTYPE_SSL_CN,
cn_trash->data,
}
}
if (srv->pp_opts & SRV_PP_V2_SSL_KEY_ALG) {
- struct chunk *pkey_trash = get_trash_chunk();
+ struct buffer *pkey_trash = get_trash_chunk();
if (ssl_sock_get_pkey_algo(remote, pkey_trash) > 0) {
ssl_tlv_len += make_tlv(&buf[ret+ssl_tlv_len], (buf_len - ret - ssl_tlv_len), PP2_SUBTYPE_SSL_KEY_ALG,
pkey_trash->data,
static int da_haproxy(const struct arg *args, struct sample *smp, da_deviceinfo_t *devinfo)
{
- struct chunk *tmp;
+ struct buffer *tmp;
da_propid_t prop, *pprop;
da_status_t status;
da_type_t proptype;
* decides to stop the HTTP message processing.
*/
void
-flt_http_reply(struct stream *s, short status, const struct chunk *msg)
+flt_http_reply(struct stream *s, short status, const struct buffer *msg)
{
struct filter *filter;
static int
spoe_prepare_hahello_frame(struct appctx *appctx, char *frame, size_t size)
{
- struct chunk *chk;
+ struct buffer *chk;
struct spoe_agent *agent = SPOE_APPCTX(appctx)->agent;
char *p, *end;
unsigned int flags = SPOE_FRM_FL_FIN;
static void
trace_http_reply(struct stream *s, struct filter *filter, short status,
- const struct chunk *msg)
+ const struct buffer *msg)
{
struct trace_config *conf = FLT_CONF(filter);
{
lua_Debug ar;
int level = 0;
- struct chunk *msg = get_trash_chunk();
+ struct buffer *msg = get_trash_chunk();
int filled = 0;
while (lua_getstack(L, level++, &ar)) {
__LJMP static int hlua_applet_http_start_response(lua_State *L)
{
- struct chunk *tmp = get_trash_chunk();
+ struct buffer *tmp = get_trash_chunk();
struct hlua_appctx *appctx = MAY_LJMP(hlua_checkapplet_http(L, 1));
const char *name;
size_t name_len;
struct hlua_function *fcn = private;
struct stream *stream = smp->strm;
const char *error;
- const struct chunk msg = { };
+ const struct buffer msg = { };
if (!stream)
return 0;
unsigned int analyzer;
int dir;
const char *error;
- const struct chunk msg = { };
+ const struct buffer msg = { };
switch (rule->from) {
case ACT_F_TCP_REQ_CNT: analyzer = AN_REQ_INSPECT_FE ; dir = SMP_OPT_DIR_REQ; break;
struct my_regex *regex;
const char *str;
size_t len;
- struct chunk *tmp;
+ struct buffer *tmp;
regex = hlua_check_regex(L, 1);
str = luaL_checklstring(L, 2, &len);
regmatch_t pmatch[20];
int ret;
int i;
- struct chunk *tmp;
+ struct buffer *tmp;
regex = hlua_check_regex(L, 1);
str = luaL_checklstring(L, 2, &len);
* allocated there. In case of allocation failure, returns a string whose
* pointer is NULL.
*/
-static inline struct ist hpack_alloc_string(struct chunk *store, int idx, struct ist in)
+static inline struct ist hpack_alloc_string(struct buffer *store, int idx,
+ struct ist in)
{
struct ist out;
* can use list[].n.len == 0 as a marker for the end of list.
*/
int hpack_decode_frame(struct hpack_dht *dht, const uint8_t *raw, uint32_t len,
- struct http_hdr *list, int list_size, struct chunk *tmp)
+ struct http_hdr *list, int list_size,
+ struct buffer *tmp)
{
uint32_t idx;
uint32_t nlen;
/* Tries to encode header whose name is <n> and value <v> into the chunk <out>.
* Returns non-zero on success, 0 on failure (buffer full).
*/
-int hpack_encode_header(struct chunk *out, const struct ist n, const struct ist v)
+int hpack_encode_header(struct buffer *out, const struct ist n,
+ const struct ist v)
{
int len = out->data;
int size = out->size;
struct log_fmt {
char *name;
struct {
- struct chunk sep1; /* first pid separator */
- struct chunk sep2; /* second pid separator */
+ struct buffer sep1; /* first pid separator */
+ struct buffer sep2; /* second pid separator */
} pid;
};
*/
static char *lf_encode_chunk(char *start, char *stop,
const char escape, const fd_set *map,
- const struct chunk *chunk,
+ const struct buffer *chunk,
struct logformat_node *node)
{
char *str, *end;
{
static THREAD_LOCAL long tvsec;
static THREAD_LOCAL char *dataptr = NULL; /* backup of last end of header, NULL first time */
- static THREAD_LOCAL struct chunk host = { };
+ static THREAD_LOCAL struct buffer host = { };
static THREAD_LOCAL int sep = 0;
if (unlikely(time != tvsec || dataptr == NULL)) {
char *hdr, *hdr_ptr;
size_t hdr_size;
time_t time = date.tv_sec;
- struct chunk *tag = &global.log_tag;
+ struct buffer *tag = &global.log_tag;
static THREAD_LOCAL int curr_pid;
static THREAD_LOCAL char pidstr[100];
- static THREAD_LOCAL struct chunk pid;
+ static THREAD_LOCAL struct buffer pid;
msghdr.msg_iov = iovec;
struct proxy *fe = sess->fe;
struct proxy *be = s->be;
struct http_txn *txn = s->txn;
- struct chunk chunk;
+ struct buffer chunk;
char *uri;
char *spc;
char *qmark;
struct connection *conn;
const char *src = NULL;
struct sample *key;
- const struct chunk empty = { };
+ const struct buffer empty = { };
switch (tmp->type) {
case LOG_FMT_SEPARATOR:
{
struct map_descriptor *desc;
struct pattern *pat;
- struct chunk *str;
+ struct buffer *str;
/* get config */
desc = arg_p[0].data.map;
{
struct buffer *res;
char buf_data[100]; // enough for 15 settings
- struct chunk buf;
+ struct buffer buf;
int ret;
if (h2c_mux_busy(h2c, NULL)) {
{
struct h2c *h2c = h2s->h2c;
const uint8_t *hdrs = (uint8_t *)b_head(&h2c->dbuf);
- struct chunk *tmp = get_trash_chunk();
+ struct buffer *tmp = get_trash_chunk();
struct http_hdr list[MAX_HTTP_HDR * 2];
- struct chunk *copy = NULL;
+ struct buffer *copy = NULL;
unsigned int msgf;
int flen = h2c->dfl;
int outlen = 0;
struct http_hdr list[MAX_HTTP_HDR];
struct h2c *h2c = h2s->h2c;
struct h1m *h1m = &h2s->res;
- struct chunk outbuf;
+ struct buffer outbuf;
int es_now = 0;
int ret = 0;
int hdr;
{
struct h2c *h2c = h2s->h2c;
struct h1m *h1m = &h2s->res;
- struct chunk outbuf;
+ struct buffer outbuf;
int ret = 0;
size_t total = 0;
int es_now = 0;
}
/* for debugging with CLI's "show fd" command */
-static void h2_show_fd(struct chunk *msg, struct connection *conn)
+static void h2_show_fd(struct buffer *msg, struct connection *conn)
{
struct h2c *h2c = conn->mux_ctx;
struct h2s *h2s;
/* Parse a binary written in hexa. It is allocated. */
int pat_parse_bin(const char *text, struct pattern *pattern, int mflags, char **err)
{
- struct chunk *trash;
+ struct buffer *trash;
pattern->type = SMP_T_BIN;
trash = get_trash_chunk();
{
int len;
unsigned short datalen;
- struct chunk *chunk;
+ struct buffer *chunk;
char *cursor, *datamsg, *chunkp, *chunkq;
uint64_t data = 0;
unsigned int data_type;
const char HTTP_100[] =
"HTTP/1.1 100 Continue\r\n\r\n";
-const struct chunk http_100_chunk = {
+const struct buffer http_100_chunk = {
.area = (char *)&HTTP_100,
.data = sizeof(HTTP_100)-1
};
/* We must put the messages here since GCC cannot initialize consts depending
* on strlen().
*/
-struct chunk http_err_chunks[HTTP_ERR_SIZE];
+struct buffer http_err_chunks[HTTP_ERR_SIZE];
/* this struct is used between calls to smp_fetch_hdr() or smp_fetch_cookie() */
static THREAD_LOCAL struct hdr_ctx static_hdr_ctx;
* in this buffer will be lost.
*/
static void http_server_error(struct stream *s, struct stream_interface *si,
- int err, int finst, const struct chunk *msg)
+ int err, int finst, const struct buffer *msg)
{
FLT_STRM_CB(s, flt_http_reply(s, s->txn->status, msg));
channel_auto_read(si_oc(si));
* and message.
*/
-struct chunk *http_error_message(struct stream *s)
+struct buffer *http_error_message(struct stream *s)
{
const int msgnum = http_get_status_idx(s->txn->status);
}
void
-http_reply_and_close(struct stream *s, short status, struct chunk *msg)
+http_reply_and_close(struct stream *s, short status, struct buffer *msg)
{
s->txn->flags &= ~TX_WAIT_NEXT_RQ;
FLT_STRM_CB(s, flt_http_reply(s, status, msg));
{
struct http_txn *txn = s->txn;
- struct chunk auth_method;
+ struct buffer auth_method;
struct hdr_ctx ctx;
char *h, *p;
int len;
chunk_initlen(&txn->auth.method_data, p + 1, 0, ctx.vlen - len - 1);
if (!strncasecmp("Basic", auth_method.area, auth_method.data)) {
- struct chunk *http_auth = get_trash_chunk();
+ struct buffer *http_auth = get_trash_chunk();
len = base64dec(txn->auth.method_data.area,
txn->auth.method_data.data,
struct hdr_idx *idx = &s->txn->hdr_idx;
int (*http_find_hdr_func)(const char *name, int len, char *sol,
struct hdr_idx *idx, struct hdr_ctx *ctx);
- struct chunk *output = get_trash_chunk();
+ struct buffer *output = get_trash_chunk();
ctx.idx = 0;
struct list *fmt, struct my_regex *re,
int action)
{
- struct chunk *replace;
+ struct buffer *replace;
int ret = -1;
replace = alloc_trash_chunk();
* buffer, we build first the header value using build_logline, and
* after we store the header name.
*/
- struct chunk *replace;
+ struct buffer *replace;
replace = alloc_trash_chunk();
if (!replace)
case ACT_HTTP_DEL_ACL:
case ACT_HTTP_DEL_MAP: {
struct pat_ref *ref;
- struct chunk *key;
+ struct buffer *key;
/* collect reference */
ref = pat_ref_lookup(rule->arg.map.ref);
case ACT_HTTP_ADD_ACL: {
struct pat_ref *ref;
- struct chunk *key;
+ struct buffer *key;
/* collect reference */
ref = pat_ref_lookup(rule->arg.map.ref);
case ACT_HTTP_SET_MAP: {
struct pat_ref *ref;
- struct chunk *key, *value;
+ struct buffer *key, *value;
/* collect reference */
ref = pat_ref_lookup(rule->arg.map.ref);
case ACT_HTTP_SET_HDR:
case ACT_HTTP_ADD_HDR: {
- struct chunk *replace;
+ struct buffer *replace;
replace = alloc_trash_chunk();
if (!replace)
case ACT_HTTP_DEL_ACL:
case ACT_HTTP_DEL_MAP: {
struct pat_ref *ref;
- struct chunk *key;
+ struct buffer *key;
/* collect reference */
ref = pat_ref_lookup(rule->arg.map.ref);
case ACT_HTTP_ADD_ACL: {
struct pat_ref *ref;
- struct chunk *key;
+ struct buffer *key;
/* collect reference */
ref = pat_ref_lookup(rule->arg.map.ref);
case ACT_HTTP_SET_MAP: {
struct pat_ref *ref;
- struct chunk *key, *value;
+ struct buffer *key, *value;
/* collect reference */
ref = pat_ref_lookup(rule->arg.map.ref);
struct http_msg *req = &txn->req;
struct http_msg *res = &txn->rsp;
const char *msg_fmt;
- struct chunk *chunk;
+ struct buffer *chunk;
int ret = 0;
chunk = alloc_trash_chunk();
smp_fetch_hdrs_bin(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
struct http_msg *msg;
- struct chunk *temp;
+ struct buffer *temp;
struct hdr_idx *idx;
const char *cur_ptr, *cur_next, *p;
int old_idx, cur_idx;
unsigned long len;
unsigned long block1;
char *body;
- struct chunk *temp;
+ struct buffer *temp;
CHECK_HTTP_MESSAGE_FIRST();
struct hdr_idx *idx;
struct hdr_ctx ctx;
const struct http_msg *msg;
- struct chunk *temp;
+ struct buffer *temp;
char del = ',';
if (args && args->type == ARGT_STR)
smp->data.type = SMP_T_IPV4;
break;
} else {
- struct chunk *temp = get_trash_chunk();
+ struct buffer *temp = get_trash_chunk();
if (smp->data.u.str.data < temp->size - 1) {
memcpy(temp->area, smp->data.u.str.area,
smp->data.u.str.data);
struct http_txn *txn;
char *ptr, *end, *beg;
struct hdr_ctx ctx;
- struct chunk *temp;
+ struct buffer *temp;
CHECK_HTTP_MESSAGE_FIRST();
static int
smp_fetch_base32_src(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
- struct chunk *temp;
+ struct buffer *temp;
struct connection *cli_conn = objt_conn(smp->sess->origin);
if (!cli_conn)
static int
smp_fetch_capture_req_method(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
- struct chunk *temp;
+ struct buffer *temp;
struct http_txn *txn = smp->strm->txn;
char *ptr;
static int
smp_fetch_capture_req_uri(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
- struct chunk *temp;
+ struct buffer *temp;
struct http_txn *txn = smp->strm->txn;
char *ptr;
smp_fetch_param(char delim, const char *name, int name_len, const struct arg *args, struct sample *smp, const char *kw, void *private)
{
const char *vstart, *vend;
- struct chunk *temp;
+ struct buffer *temp;
const char **chunks = (const char **)smp->ctx.a;
if (!find_next_url_param(chunks,
static int
smp_fetch_url32_src(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
- struct chunk *temp;
+ struct buffer *temp;
struct connection *cli_conn = objt_conn(smp->sess->origin);
if (!cli_conn)
{
const char day[7][4] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
const char mon[12][4] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
- struct chunk *temp;
+ struct buffer *temp;
struct tm *tm;
/* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
* before decoding.
*/
if (smp->flags & SMP_F_CONST || smp->data.u.str.size <= smp->data.u.str.data) {
- struct chunk *str = get_trash_chunk();
+ struct buffer *str = get_trash_chunk();
memcpy(str->area, smp->data.u.str.area, smp->data.u.str.data);
smp->data.u.str.area = str->area;
smp->data.u.str.size = str->size;
enum act_return http_action_set_req_line(struct act_rule *rule, struct proxy *px,
struct session *sess, struct stream *s, int flags)
{
- struct chunk *replace;
+ struct buffer *replace;
enum act_return ret = ACT_RET_ERR;
replace = alloc_trash_chunk();
* It uses the proxy pointer from cli.p0, the proxy's id from cli.i0 and the server's
* pointer from cli.p1.
*/
-static int dump_servers_state(struct stream_interface *si, struct chunk *buf)
+static int dump_servers_state(struct stream_interface *si, struct buffer *buf)
{
struct appctx *appctx = __objt_appctx(si->end);
struct proxy *px = appctx->ctx.cli.p0;
static int c_ip2str(struct sample *smp)
{
- struct chunk *trash = get_trash_chunk();
+ struct buffer *trash = get_trash_chunk();
if (!inet_ntop(AF_INET, (void *)&smp->data.u.ipv4, trash->area, trash->size))
return 0;
static int c_ipv62str(struct sample *smp)
{
- struct chunk *trash = get_trash_chunk();
+ struct buffer *trash = get_trash_chunk();
if (!inet_ntop(AF_INET6, (void *)&smp->data.u.ipv6, trash->area, trash->size))
return 0;
static int c_int2str(struct sample *smp)
{
- struct chunk *trash = get_trash_chunk();
+ struct buffer *trash = get_trash_chunk();
char *pos;
pos = lltoa_r(smp->data.u.sint, trash->area, trash->size);
*/
int smp_dup(struct sample *smp)
{
- struct chunk *trash;
+ struct buffer *trash;
switch (smp->data.type) {
case SMP_T_BOOL:
static int c_addr2bin(struct sample *smp)
{
- struct chunk *chk = get_trash_chunk();
+ struct buffer *chk = get_trash_chunk();
if (smp->data.type == SMP_T_IPV4) {
chk->data = 4;
static int c_int2bin(struct sample *smp)
{
- struct chunk *chk = get_trash_chunk();
+ struct buffer *chk = get_trash_chunk();
*(unsigned long long int *) chk->area = my_htonll(smp->data.u.sint);
chk->data = 8;
static int sample_conv_base642bin(const struct arg *arg_p, struct sample *smp, void *private)
{
- struct chunk *trash = get_trash_chunk();
+ struct buffer *trash = get_trash_chunk();
int bin_len;
trash->data = 0;
static int sample_conv_bin2base64(const struct arg *arg_p, struct sample *smp, void *private)
{
- struct chunk *trash = get_trash_chunk();
+ struct buffer *trash = get_trash_chunk();
int b64_len;
trash->data = 0;
static int sample_conv_sha1(const struct arg *arg_p, struct sample *smp, void *private)
{
blk_SHA_CTX ctx;
- struct chunk *trash = get_trash_chunk();
+ struct buffer *trash = get_trash_chunk();
memset(&ctx, 0, sizeof(ctx));
static int sample_conv_bin2hex(const struct arg *arg_p, struct sample *smp, void *private)
{
- struct chunk *trash = get_trash_chunk();
+ struct buffer *trash = get_trash_chunk();
unsigned char c;
int ptr = 0;
*/
static int sample_conv_ltime(const struct arg *args, struct sample *smp, void *private)
{
- struct chunk *temp;
+ struct buffer *temp;
/* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
struct tm *tm;
*/
static int sample_conv_utime(const struct arg *args, struct sample *smp, void *private)
{
- struct chunk *temp;
+ struct buffer *temp;
/* With high numbers, the date returned can be negative, the 55 bits mask prevent this. */
time_t curr_date = smp->data.u.sint & 0x007fffffffffffffLL;
struct tm *tm;
static int sample_conv_json(const struct arg *arg_p, struct sample *smp, void *private)
{
- struct chunk *temp;
+ struct buffer *temp;
char _str[7]; /* \u + 4 hex digit + null char for sprintf. */
const char *str;
int len;
char *start, *end;
struct my_regex *reg = arg_p[0].data.reg;
regmatch_t pmatch[MAX_MATCH];
- struct chunk *trash = get_trash_chunk();
+ struct buffer *trash = get_trash_chunk();
int flag, max;
int found;
*/
static int sample_conv_concat(const struct arg *arg_p, struct sample *smp, void *private)
{
- struct chunk *trash;
+ struct buffer *trash;
struct sample tmp;
int max;
* If <xferred> is non-negative, some information about requeued sessions are
* provided.
*/
-void srv_append_status(struct chunk *msg, struct server *s, struct check *check, int xferred, int forced)
+void srv_append_status(struct buffer *msg, struct server *s,
+ struct check *check, int xferred, int forced)
{
short status = s->op_st_chg.status;
short code = s->op_st_chg.code;
chunk_appendf(msg, ", code: %d", code);
if (desc && *desc) {
- struct chunk src;
+ struct buffer src;
chunk_appendf(msg, ", info: \"");
static void srv_update_state(struct server *srv, int version, char **params)
{
char *p;
- struct chunk *msg;
+ struct buffer *msg;
/* fields since version 1
* and common to all other upcoming versions
int ret, port_change_required;
char current_addr[INET6_ADDRSTRLEN];
uint16_t current_port, new_port;
- struct chunk *msg;
+ struct buffer *msg;
int changed = 0;
msg = get_trash_chunk();
void *serverip, *firstip;
short server_sin_family, firstip_sin_family;
int ret;
- struct chunk *chk = get_trash_chunk();
+ struct buffer *chk = get_trash_chunk();
int has_no_ip = 0;
s = objt_server(requester->owner);
const char *update_server_fqdn(struct server *server, const char *fqdn, const char *updater, int dns_locked)
{
- struct chunk *msg;
+ struct buffer *msg;
msg = get_trash_chunk();
chunk_reset(msg);
int prev_srv_count = s->proxy->srv_bck + s->proxy->srv_act;
int srv_was_stopping = (s->cur_state == SRV_ST_STOPPING) || (s->cur_admin & SRV_ADMF_DRAIN);
int log_level;
- struct chunk *tmptrash = NULL;
+ struct buffer *tmptrash = NULL;
/* If currently main is not set we try to apply pending state changes */
listener_release(l);
if (ret < 0 && l->bind_conf->xprt == xprt_get(XPRT_RAW) && p->mode == PR_MODE_HTTP) {
/* critical error, no more memory, try to emit a 500 response */
- struct chunk *err_msg = &p->errmsg[HTTP_ERR_500];
+ struct buffer *err_msg = &p->errmsg[HTTP_ERR_500];
if (!err_msg->area)
err_msg = &http_err_chunks[HTTP_ERR_500];
send(cfd, err_msg->area, err_msg->data,
struct certificate_ocsp {
struct ebmb_node key;
unsigned char key_data[OCSP_MAX_CERTID_ASN1_LENGTH];
- struct chunk response;
+ struct buffer response;
long expire;
};
*
* Returns 0 on success, 1 in error case.
*/
-static int ssl_sock_load_ocsp_response(struct chunk *ocsp_response, struct certificate_ocsp *ocsp, OCSP_CERTID *cid, char **err)
+static int ssl_sock_load_ocsp_response(struct buffer *ocsp_response,
+ struct certificate_ocsp *ocsp,
+ OCSP_CERTID *cid, char **err)
{
OCSP_RESPONSE *resp;
OCSP_BASICRESP *bs = NULL;
*
* Returns 0 on success, 1 in error case.
*/
-int ssl_sock_update_ocsp_response(struct chunk *ocsp_response, char **err)
+int ssl_sock_update_ocsp_response(struct buffer *ocsp_response, char **err)
{
return ssl_sock_load_ocsp_response(ocsp_response, NULL, NULL, err);
}
return NULL;
}
-void ssl_sock_update_tlskey_ref(struct tls_keys_ref *ref, struct chunk *tlskey)
+void ssl_sock_update_tlskey_ref(struct tls_keys_ref *ref,
+ struct buffer *tlskey)
{
HA_RWLOCK_WRLOCK(TLSKEYS_REF_LOCK, &ref->lock);
memcpy((char *) (ref->tlskeys + ((ref->tls_ticket_enc_index + 2) % TLS_TICKETS_NO)),
HA_RWLOCK_WRUNLOCK(TLSKEYS_REF_LOCK, &ref->lock);
}
-int ssl_sock_update_tlskey(char *filename, struct chunk *tlskey, char **err)
+int ssl_sock_update_tlskey(char *filename, struct buffer *tlskey, char **err)
{
struct tls_keys_ref *ref = tlskeys_ref_lookup(filename);
* makes only basic test if the data seems like SCTL. No signature validation
* is performed.
*/
-static int ssl_sock_parse_sctl(struct chunk *sctl)
+static int ssl_sock_parse_sctl(struct buffer *sctl)
{
int ret = 1;
int len, pos, sct_len;
return ret;
}
-static int ssl_sock_load_sctl_from_file(const char *sctl_path, struct chunk **sctl)
+static int ssl_sock_load_sctl_from_file(const char *sctl_path,
+ struct buffer **sctl)
{
int fd = -1;
int r = 0;
int ssl_sock_sctl_add_cbk(SSL *ssl, unsigned ext_type, const unsigned char **out, size_t *outlen, int *al, void *add_arg)
{
- struct chunk *sctl = add_arg;
+ struct buffer *sctl = add_arg;
*out = (unsigned char *) sctl->area;
*outlen = sctl->data;
char sctl_path[MAXPATHLEN+1];
int ret = -1;
struct stat st;
- struct chunk *sctl = NULL;
+ struct buffer *sctl = NULL;
snprintf(sctl_path, MAXPATHLEN+1, "%s.sctl", cert_path);
}
/* used for ppv2 pkey alog (can be used for logging) */
-int ssl_sock_get_pkey_algo(struct connection *conn, struct chunk *out)
+int ssl_sock_get_pkey_algo(struct connection *conn, struct buffer *out)
{
struct pkey_info *pkinfo;
int bits = 0;
* -1 if output is not large enough.
*/
static int
-ssl_sock_get_serial(X509 *crt, struct chunk *out)
+ssl_sock_get_serial(X509 *crt, struct buffer *out)
{
ASN1_INTEGER *serial;
* -1 if output is not large enough.
*/
static int
-ssl_sock_crt2der(X509 *crt, struct chunk *out)
+ssl_sock_crt2der(X509 *crt, struct buffer *out)
{
int len;
unsigned char *p = (unsigned char *) out->area;;
}
-/* Copy Date in ASN1_UTCTIME format in struct chunk out.
+/* Copy Date in ASN1_UTCTIME format in struct buffer out.
* Returns 1 if serial is found and copied, 0 if no valid time found
* and -1 if output is not large enough.
*/
static int
-ssl_sock_get_time(ASN1_TIME *tm, struct chunk *out)
+ssl_sock_get_time(ASN1_TIME *tm, struct buffer *out)
{
if (tm->type == V_ASN1_GENERALIZEDTIME) {
ASN1_GENERALIZEDTIME *gentm = (ASN1_GENERALIZEDTIME *)tm;
* Returns 1 if entry found, 0 if entry not found, or -1 if output not large enough.
*/
static int
-ssl_sock_get_dn_entry(X509_NAME *a, const struct chunk *entry, int pos, struct chunk *out)
+ssl_sock_get_dn_entry(X509_NAME *a, const struct buffer *entry, int pos,
+ struct buffer *out)
{
X509_NAME_ENTRY *ne;
ASN1_OBJECT *obj;
* Returns 1 if dn entries exits, 0 if no dn entry found or -1 if output is not large enough.
*/
static int
-ssl_sock_get_dn_oneline(X509_NAME *a, struct chunk *out)
+ssl_sock_get_dn_oneline(X509_NAME *a, struct buffer *out)
{
X509_NAME_ENTRY *ne;
ASN1_OBJECT *obj;
* or 0 if no CN found in DN
* or -1 on error case (i.e. no peer certificate)
*/
-int ssl_sock_get_remote_common_name(struct connection *conn, struct chunk *dest)
+int ssl_sock_get_remote_common_name(struct connection *conn,
+ struct buffer *dest)
{
X509 *crt = NULL;
X509_NAME *name;
const char find_cn[] = "CN";
- const struct chunk find_cn_chunk = {
+ const struct buffer find_cn_chunk = {
.area = (char *)&find_cn,
.data = sizeof(find_cn)-1
};
int cert_peer = (kw[4] == 'c') ? 1 : 0;
X509 *crt = NULL;
int ret = 0;
- struct chunk *smp_trash;
+ struct buffer *smp_trash;
struct connection *conn;
conn = objt_conn(smp->sess->origin);
int cert_peer = (kw[4] == 'c') ? 1 : 0;
X509 *crt = NULL;
int ret = 0;
- struct chunk *smp_trash;
+ struct buffer *smp_trash;
struct connection *conn;
conn = objt_conn(smp->sess->origin);
X509 *crt = NULL;
const EVP_MD *digest;
int ret = 0;
- struct chunk *smp_trash;
+ struct buffer *smp_trash;
struct connection *conn;
conn = objt_conn(smp->sess->origin);
int cert_peer = (kw[4] == 'c') ? 1 : 0;
X509 *crt = NULL;
int ret = 0;
- struct chunk *smp_trash;
+ struct buffer *smp_trash;
struct connection *conn;
conn = objt_conn(smp->sess->origin);
X509 *crt = NULL;
X509_NAME *name;
int ret = 0;
- struct chunk *smp_trash;
+ struct buffer *smp_trash;
struct connection *conn;
conn = objt_conn(smp->sess->origin);
int cert_peer = (kw[4] == 'c') ? 1 : 0;
X509 *crt = NULL;
int ret = 0;
- struct chunk *smp_trash;
+ struct buffer *smp_trash;
struct connection *conn;
conn = objt_conn(smp->sess->origin);
X509 *crt = NULL;
X509_NAME *name;
int ret = 0;
- struct chunk *smp_trash;
+ struct buffer *smp_trash;
struct connection *conn;
conn = objt_conn(smp->sess->origin);
struct connection *conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
SSL_SESSION *ssl_sess;
- struct chunk *data;
+ struct buffer *data;
if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
return 0;
static int
smp_fetch_ssl_fc_cl_hex(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
- struct chunk *data;
+ struct buffer *data;
if (!smp_fetch_ssl_fc_cl_bin(args, smp, kw, private))
return 0;
smp_fetch_ssl_fc_cl_str(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
#if (OPENSSL_VERSION_NUMBER >= 0x1000200fL) && !defined(LIBRESSL_VERSION_NUMBER)
- struct chunk *data;
+ struct buffer *data;
int i;
if (!smp_fetch_ssl_fc_cl_bin(args, smp, kw, private))
struct connection *conn = (kw[4] != 'b') ? objt_conn(smp->sess->origin) :
smp->strm ? cs_conn(objt_cs(smp->strm->si[1].end)) : NULL;
int finished_len;
- struct chunk *finished_trash;
+ struct buffer *finished_trash;
smp->flags = 0;
if (!conn || !conn->xprt_ctx || conn->xprt != &ssl_sock)
HA_RWLOCK_RDLOCK(TLSKEYS_REF_LOCK, &ref->lock);
head = ref->tls_ticket_enc_index;
while (appctx->ctx.cli.i1 < TLS_TICKETS_NO) {
- struct chunk *t2 = get_trash_chunk();
+ struct buffer *t2 = get_trash_chunk();
chunk_reset(t2);
/* should never fail here because we dump only a key in the t2 buffer */
*/
char *encode_chunk(char *start, char *stop,
const char escape, const fd_set *map,
- const struct chunk *chunk)
+ const struct buffer *chunk)
{
char *str = chunk->area;
char *end = chunk->area + chunk->data;
*/
char *escape_chunk(char *start, char *stop,
const char escape, const fd_set *map,
- const struct chunk *chunk)
+ const struct buffer *chunk)
{
char *str = chunk->area;
char *end = chunk->area + chunk->data;
* If <quote> is 1, the converter puts the quotes only if any reserved character
* is present. If <quote> is 2, the converter always puts the quotes.
*
- * <output> is a struct chunk used for storing the output string.
+ * <output> is a struct buffer used for storing the output string.
*
* The function returns the converted string on its output. If an error
* occurs, the function returns an empty string. This type of output is useful
* the chunk. Please use csv_enc() instead if you want to replace the output
* chunk.
*/
-const char *csv_enc_append(const char *str, int quote, struct chunk *output)
+const char *csv_enc_append(const char *str, int quote, struct buffer *output)
{
char *end = output->area + output->size;
char *out = output->area + output->data;
* Other non-printable chars are encoded "\xHH". Space, '\', and '=' are also escaped.
* Print stopped if null char or <bsize> is reached, or if no more place in the chunk.
*/
-int dump_text(struct chunk *out, const char *buf, int bsize)
+int dump_text(struct buffer *out, const char *buf, int bsize)
{
unsigned char c;
int ptr = 0;
/* print a buffer in hexa.
* Print stopped if <bsize> is reached, or if no more place in the chunk.
*/
-int dump_binary(struct chunk *out, const char *buf, int bsize)
+int dump_binary(struct buffer *out, const char *buf, int bsize)
{
unsigned char c;
int ptr = 0;
* continuation of a previous truncated line begin with "+" instead of " "
* after the offset. The new pointer is returned.
*/
-int dump_text_line(struct chunk *out, const char *buf, int bsize, int len,
+int dump_text_line(struct buffer *out, const char *buf, int bsize, int len,
int *line, int ptr)
{
int end;
/* Emits a stats field without any surrounding element and properly encoded to
* resist CSV output. Returns non-zero on success, 0 if the buffer is full.
*/
-int stats_emit_raw_data_field(struct chunk *out, const struct field *f)
+int stats_emit_raw_data_field(struct buffer *out, const struct field *f)
{
switch (field_format(f, 0)) {
case FF_EMPTY: return 1;
* output is supposed to be used on its own line. Returns non-zero on success, 0
* if the buffer is full.
*/
-int stats_emit_typed_data_field(struct chunk *out, const struct field *f)
+int stats_emit_typed_data_field(struct buffer *out, const struct field *f)
{
switch (field_format(f, 0)) {
case FF_EMPTY: return 1;
/* Emits a stats field value and its type in JSON.
* Returns non-zero on success, 0 on error.
*/
-int stats_emit_json_data_field(struct chunk *out, const struct field *f)
+int stats_emit_json_data_field(struct buffer *out, const struct field *f)
{
int old_len;
char buf[20];
/* Emits an encoding of the field type on 3 characters followed by a delimiter.
* Returns non-zero on success, 0 if the buffer is full.
*/
-int stats_emit_field_tags(struct chunk *out, const struct field *f, char delim)
+int stats_emit_field_tags(struct buffer *out, const struct field *f,
+ char delim)
{
char origin, nature, scope;
/* Emits an encoding of the field type as JSON.
* Returns non-zero on success, 0 if the buffer is full.
*/
-int stats_emit_json_field_tags(struct chunk *out, const struct field *f)
+int stats_emit_json_field_tags(struct buffer *out, const struct field *f)
{
const char *origin, *nature, *scope;
int old_len;
}
/* Dump all fields from <stats> into <out> using CSV format */
-static int stats_dump_fields_csv(struct chunk *out, const struct field *stats)
+static int stats_dump_fields_csv(struct buffer *out,
+ const struct field *stats)
{
int field;
}
/* Dump all fields from <stats> into <out> using a typed "field:desc:type:value" format */
-static int stats_dump_fields_typed(struct chunk *out, const struct field *stats)
+static int stats_dump_fields_typed(struct buffer *out,
+ const struct field *stats)
{
int field;
}
/* Dump all fields from <stats> into <out> using the "show info json" format */
-static int stats_dump_json_info_fields(struct chunk *out,
+static int stats_dump_json_info_fields(struct buffer *out,
const struct field *info)
{
int field;
}
/* Dump all fields from <stats> into <out> using a typed "field:desc:type:value" format */
-static int stats_dump_fields_json(struct chunk *out, const struct field *stats,
+static int stats_dump_fields_json(struct buffer *out,
+ const struct field *stats,
int first_stat)
{
int field;
* reserved for the checkbox is ST_SHOWADMIN is set in <flags>. Some extra info
* are provided if ST_SHLGNDS is present in <flags>.
*/
-static int stats_dump_fields_html(struct chunk *out, const struct field *stats, unsigned int flags)
+static int stats_dump_fields_html(struct buffer *out,
+ const struct field *stats,
+ unsigned int flags)
{
- struct chunk src;
+ struct buffer src;
if (stats[ST_F_TYPE].u.u32 == STATS_TYPE_FE) {
chunk_appendf(out,
int stats_fill_li_stats(struct proxy *px, struct listener *l, int flags,
struct field *stats, int len)
{
- struct chunk *out = get_trash_chunk();
+ struct buffer *out = get_trash_chunk();
if (len < ST_F_TOTAL_FIELDS)
return 0;
{
struct server *via, *ref;
char str[INET6_ADDRSTRLEN];
- struct chunk *out = get_trash_chunk();
+ struct buffer *out = get_trash_chunk();
enum srv_stats_state state;
char *fld_status;
char *st_cur_param = NULL;
char *st_next_param = NULL;
- struct chunk *temp;
+ struct buffer *temp;
int reql;
temp = get_trash_chunk();
}
/* Dump all fields from <info> into <out> using the "show info" format (name: value) */
-static int stats_dump_info_fields(struct chunk *out, const struct field *info)
+static int stats_dump_info_fields(struct buffer *out,
+ const struct field *info)
{
int field;
}
/* Dump all fields from <info> into <out> using the "show info typed" format */
-static int stats_dump_typed_info_fields(struct chunk *out, const struct field *info)
+static int stats_dump_typed_info_fields(struct buffer *out,
+ const struct field *info)
{
int field;
int stats_fill_info(struct field *info, int len)
{
unsigned int up = (now.tv_sec - start_date.tv_sec);
- struct chunk *out = get_trash_chunk();
+ struct buffer *out = get_trash_chunk();
#ifdef USE_OPENSSL
int ssl_sess_rate = read_freq_ctr(&global.ssl_per_sec);
* Integer values bouned to the range [-(2**53)+1, (2**53)-1] as
* per the recommendation for interoperable integers in section 6 of RFC 7159.
*/
-static void stats_dump_json_schema(struct chunk *out)
+static void stats_dump_json_schema(struct buffer *out)
{
int old_len = out->data;
* read buffer. It returns 0 if the output buffer is full
* and needs to be called again, otherwise non-zero.
*/
-static int table_dump_head_to_buffer(struct chunk *msg, struct stream_interface *si,
+static int table_dump_head_to_buffer(struct buffer *msg,
+ struct stream_interface *si,
struct proxy *proxy, struct proxy *target)
{
struct stream *s = si_strm(si);
* read buffer. It returns 0 if the output buffer is full
* and needs to be called again, otherwise non-zero.
*/
-static int table_dump_entry_to_buffer(struct chunk *msg, struct stream_interface *si,
+static int table_dump_entry_to_buffer(struct buffer *msg,
+ struct stream_interface *si,
struct proxy *proxy, struct stksess *entry)
{
int dt;
struct proxy *backend = NULL;
if (rule->dynamic) {
- struct chunk *tmp;
+ struct buffer *tmp;
tmp = alloc_trash_chunk();
if (!tmp)
* not need to be empty before this, and its contents will not be overwritten.
* The primary goal of this function is to return error messages to a client.
*/
-void stream_int_retnclose(struct stream_interface *si, const struct chunk *msg)
+void stream_int_retnclose(struct stream_interface *si,
+ const struct buffer *msg)
{
struct channel *ic = si_ic(si);
struct channel *oc = si_oc(si);
static int ha_wurfl_get_all(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
wurfl_device_handle dHandle;
- struct chunk *temp;
+ struct buffer *temp;
wurfl_information_t *wi;
ha_wurfl_header_t wh;
static int ha_wurfl_get(const struct arg *args, struct sample *smp, const char *kw, void *private)
{
wurfl_device_handle dHandle;
- struct chunk *temp;
+ struct buffer *temp;
wurfl_data_t *wn = NULL;
struct ebmb_node *node;
ha_wurfl_header_t wh;
projects / thirdparty / haproxy.git / commitdiff
