mirrors/haproxy
1
0
Fork 0
mirror of https://git.haproxy.org/git/haproxy.git/ synced 2025-09-21 05:41:26 +02:00
Code Issues Projects Releases Wiki Activity

REORG: include: split common/htx.h into haproxy/htx{,-t}.h

Browse Source 
Most of the file was a large set of HTX elements manipulation functions
and few types, so splitting them allowed to further reduce dependencies
and shrink the build time. Doing so revealed that a few files (h2.c,
mux_pt.c) needed haproxy/buf.h and were previously getting it through
htx.h. They were fixed.
This commit is contained in:
Willy Tarreau 2020-06-03 08:44:35 +02:00
parent 5413a87ad3
commit 16f958c0e9
29 changed files with 262 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
contrib/prometheus-exporter/service-prometheus.c
View File

@ -16,7 +16,7 @@
#include <haproxy/api.h>
#include <common/cfgparse.h>
#include <haproxy/http.h>
#include <common/htx.h>
#include <haproxy/htx.h>
#include <haproxy/pool.h>
#include <haproxy/list.h>

2
include/common/h2.h
View File

@ -31,7 +31,7 @@
#include <haproxy/api.h>
#include <haproxy/http-hdr-t.h>
#include <common/htx.h>
#include <haproxy/htx-t.h>
#include <import/ist.h>

229
include/haproxy/htx-t.h Normal file
View File

@ -0,0 +1,229 @@
/*
* include/haproxy/htx-t.h
* This file declares the types and constants used the internal HTTP messages
*
* Copyright (C) 2018 HAProxy Technologies, Christopher Faulet <cfaulet@haproxy.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation, version 2.1
* exclusively.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef _HAPROXY_HTX_T_H
#define _HAPROXY_HTX_T_H
#include <haproxy/api.h>
#include <haproxy/http-t.h>
/*
* The internal representation of an HTTP message, called HTX, is a structure
* with useful information on the message followed by a contiguous array
* containing parts of the message, called blocks. A block is composed of
* metadata (htx_blk) and the associated payload. Blocks' metadata are stored
* starting from the end of the array while their payload are stored at the
* beginning. Blocks' metadata are often simply called blocks. it is a misuse of
* language that's simplify explanations.
*
*
* +-----+---------------+------------------------------+--------------+
* | HTX | PAYLOADS ==> | | <== HTX_BLKs |
* +-----+---------------+------------------------------+--------------+
* ^
* blocks[] (the beginning of the bocks array)
*
*
* The blocks part remains linear and sorted. You may think about it as an array
* with negative indexes. But, instead of using negative indexes, we use
* positive positions to identify a block. This position is then converted to a
* address relatively to the beginning of the blocks array.
*
*
* .....--+------------------------------+-----+-----+
* | ... | BLK | BLK |
* .....--+------------------------------+-----+-----+
* ^ ^
* Addr of the block Addr of the block
* at the position 1 at the position 0
*
*
* The payloads part is a raw space that may wrap. You never access to a block's
* payload directly. Instead you get a block to retrieve the address of its
* payload. When no more space left between blocks and payloads parts, the free
* space at the beginning, if any, is used.
*
*
* +----------- WRAPPING ------------------------+
* | |
* V |
* +-----+-------------+---------------+---------------++--------------+
* | HTX | PAYLOAD ==> | | PAYLOADS ==X || X== HTX_BLKs |
* +-----+-------------+---------------+---------------++--------------+
*
*
* The blocks part, on its side, never wrap. If we have no space to allocate a
* new block and if there is a hole at the beginning of the blocks part (so at
* the end of the blocks array), we move back all blocks.x
*
*
* ...+--------------+----------+ blocks ...+----------+--------------+
* | X== HTX_BLKS | | defrag | | <== HTX_BLKS |
* ...+--------------+----------+ =====> ...+----------+--------------+
*
*
* At the end, if payload wrapping or blocks defragmenation is not enough, some
* free space may be get back with a full defragmenation. This way, the holes in
* the middle are not reusable but count in the available free space. The only
* way to reuse this lost space is to fully defragmenate the HTX message.
*
* - * -
*
* An HTX block is as well a header as a body part or a trailer. For all these
* types of block, a payload is attached to the block. It can also be a mark,
* like the end-of-headers or end-of-message. For these blocks, there is no
* payload but it count for a byte. It is important to not skip it when data are
* forwarded. Metadata of an HTX block are composed of 2 fields :
*
* - .info : It a 32 bits field containing the block's type on 4 bits
* followed by the payload length. See below for details.
*
* - .addr : The payload's address, if any, relatively to the beginning the
* array used to store the HTX message itself.
*
* htx_blk.info representation :
*
* 0b 0000 0000 0000 0000 0000 0000 0000 0000
* ---- ------------------------ ---------
* type value (1 MB max) name length (header/trailer)
* ----------------------------------
* data length (256 MB max)
* (body, method, path, version, status, reason)
*
* types :
* - 0000 = request start-line
* - 0001 = response start-line
* - 0010 = header
* - 0011 = pseudo-header ou "special" header
* - 0100 = end-of-headers
* - 0101 = data
* - 0110 = trailer
* - 0111 = end-of-trailers
* - 1000 = end-of-message
* ...
* - 1111 = unused
*
*/
/* HTX start-line flags */
#define HTX_SL_F_NONE 0x00000000
#define HTX_SL_F_IS_RESP 0x00000001 /* It is the response start-line (unset means the request one) */
#define HTX_SL_F_XFER_LEN 0x00000002 /* The message xfer size can be dertermined */
#define HTX_SL_F_XFER_ENC 0x00000004 /* The transfer-encoding header was found in message */
#define HTX_SL_F_CLEN 0x00000008 /* The content-length header was found in message */
#define HTX_SL_F_CHNK 0x00000010 /* The message payload is chunked */
#define HTX_SL_F_VER_11 0x00000020 /* The message indicates version 1.1 or above */
#define HTX_SL_F_BODYLESS 0x00000040 /* The message has no body (content-length = 0) */
#define HTX_SL_F_HAS_SCHM 0x00000080 /* The scheme is explicitly specified */
#define HTX_SL_F_SCHM_HTTP 0x00000100 /* The scheme HTTP should be used */
#define HTX_SL_F_SCHM_HTTPS 0x00000200 /* The scheme HTTPS should be used */
#define HTX_SL_F_HAS_AUTHORITY 0x00000400 /* The request authority is explicitly specified */
#define HTX_SL_F_NORMALIZED_URI 0x00000800 /* The received URI is normalized (an implicit absolute-uri form) */
/* HTX flags */
#define HTX_FL_NONE 0x00000000
#define HTX_FL_PARSING_ERROR 0x00000001 /* Set when a parsing error occurred */
#define HTX_FL_PROCESSING_ERROR 0x00000002 /* Set when a processing error occurred */
#define HTX_FL_UPGRADE 0x00000004 /* Set when an upgrade is in progress */
#define HTX_FL_PROXY_RESP 0x00000008 /* Set when the response was generated by HAProxy */
/* HTX block's type (max 15). */
enum htx_blk_type {
HTX_BLK_REQ_SL = 0, /* Request start-line */
HTX_BLK_RES_SL = 1, /* Response start-line */
HTX_BLK_HDR = 2, /* header name/value block */
HTX_BLK_EOH = 3, /* end-of-headers block */
HTX_BLK_DATA = 4, /* data block */
HTX_BLK_TLR = 5, /* trailer name/value block */
HTX_BLK_EOT = 6, /* end-of-trailers block */
HTX_BLK_EOM = 7, /* end-of-message block */
/* 8 .. 14 unused */
HTX_BLK_UNUSED = 15, /* unused/removed block */
};
/* One HTX block descriptor */
struct htx_blk {
uint32_t addr; /* relative storage address of the block's payload */
uint32_t info; /* information about the block (type, length) */
};
/* Composite return value used by some HTX functions */
struct htx_ret {
int32_t ret; /* A numerical value */
struct htx_blk *blk; /* An HTX block */
};
/* HTX start-line */
struct htx_sl {
unsigned int flags; /* HTX_SL_F_* */
union {
struct {
enum http_meth_t meth; /* method */
} req;
struct {
uint16_t status; /* status code */
} res;
} info;
/* XXX 2 bytes unused */
int32_t hdrs_bytes; /* Bytes held by all headers, as seen by the mux
* during parsing, from this start-line to the
* corresponding EOH. -1 if unknown */
unsigned int len[3]; /* length of different parts of the start-line */
char l[0];
};
/* Internal representation of an HTTP message */
struct htx {
uint32_t size; /* the array size, in bytes, used to store the HTTP message itself */
uint32_t data; /* the data size, in bytes. To known to total size used by all allocated
* blocks (blocks and their contents), you need to add size used by blocks,
* i.e. [ used * sizeof(struct htx_blk *) ] */
int32_t tail; /* newest inserted block. -1 if the HTX message is empty */
int32_t head; /* oldest inserted block. -1 if the HTX message is empty */
int32_t first; /* position of the first block to (re)start the analyse. -1 if unset. */
uint32_t tail_addr; /* start address of the free space in front of the the blocks table */
uint32_t head_addr; /* start address of the free space at the beginning */
uint32_t end_addr; /* end address of the free space at the beginning */
uint64_t extra; /* known bytes amount remaining to receive */
uint32_t flags; /* HTX_FL_* */
/* XXX 4 bytes unused */
/* Blocks representing the HTTP message itself */
char blocks[0] __attribute__((aligned(8)));
};
#endif /* _HAPROXY_HTX_T_H */
/*
* Local variables:
* c-indent-level: 8
* c-basic-offset: 8
* End:
*/

207
include/common/htx.h → include/haproxy/htx.h
View File

@ -1,5 +1,5 @@
/*
* include/common/htx.h
* include/haproxy/htx.h
* This file defines everything related to the internal HTTP messages.
*
* Copyright (C) 2018 HAProxy Technologies, Christopher Faulet <cfaulet@haproxy.com>
@ -19,211 +19,16 @@
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef _COMMON_HTX_H
#define _COMMON_HTX_H
#ifndef _HAPROXY_HTX_H
#define _HAPROXY_HTX_H
#include <stdio.h>
#include <import/ist.h>
#include <haproxy/api.h>
#include <haproxy/buf.h>
#include <import/ist.h>
#include <haproxy/chunk.h>
#include <haproxy/http-t.h>
#include <haproxy/http-hdr-t.h>
/*
* The internal representation of an HTTP message, called HTX, is a structure
* with useful information on the message followed by a contiguous array
* containing parts of the message, called blocks. A block is composed of
* metadata (htx_blk) and the associated payload. Blocks' metadata are stored
* starting from the end of the array while their payload are stored at the
* beginning. Blocks' metadata are often simply called blocks. it is a misuse of
* language that's simplify explanations.
*
*
* +-----+---------------+------------------------------+--------------+
* | HTX | PAYLOADS ==> | | <== HTX_BLKs |
* +-----+---------------+------------------------------+--------------+
* ^
* blocks[] (the beginning of the bocks array)
*
*
* The blocks part remains linear and sorted. You may think about it as an array
* with negative indexes. But, instead of using negative indexes, we use
* positive positions to identify a block. This position is then converted to a
* address relatively to the beginning of the blocks array.
*
*
* .....--+------------------------------+-----+-----+
* | ... | BLK | BLK |
* .....--+------------------------------+-----+-----+
* ^ ^
* Addr of the block Addr of the block
* at the position 1 at the position 0
*
*
* The payloads part is a raw space that may wrap. You never access to a block's
* payload directly. Instead you get a block to retrieve the address of its
* payload. When no more space left between blocks and payloads parts, the free
* space at the beginning, if any, is used.
*
*
* +----------- WRAPPING ------------------------+
* | |
* V |
* +-----+-------------+---------------+---------------++--------------+
* | HTX | PAYLOAD ==> | | PAYLOADS ==X || X== HTX_BLKs |
* +-----+-------------+---------------+---------------++--------------+
*
*
* The blocks part, on its side, never wrap. If we have no space to allocate a
* new block and if there is a hole at the beginning of the blocks part (so at
* the end of the blocks array), we move back all blocks.x
*
*
* ...+--------------+----------+ blocks ...+----------+--------------+
* | X== HTX_BLKS | | defrag | | <== HTX_BLKS |
* ...+--------------+----------+ =====> ...+----------+--------------+
*
*
* At the end, if payload wrapping or blocks defragmenation is not enough, some
* free space may be get back with a full defragmenation. This way, the holes in
* the middle are not reusable but count in the available free space. The only
* way to reuse this lost space is to fully defragmenate the HTX message.
*
* - * -
*
* An HTX block is as well a header as a body part or a trailer. For all these
* types of block, a payload is attached to the block. It can also be a mark,
* like the end-of-headers or end-of-message. For these blocks, there is no
* payload but it count for a byte. It is important to not skip it when data are
* forwarded. Metadata of an HTX block are composed of 2 fields :
*
* - .info : It a 32 bits field containing the block's type on 4 bits
* followed by the payload length. See below for details.
*
* - .addr : The payload's address, if any, relatively to the beginning the
* array used to store the HTX message itself.
*
* htx_blk.info representation :
*
* 0b 0000 0000 0000 0000 0000 0000 0000 0000
* ---- ------------------------ ---------
* type value (1 MB max) name length (header/trailer)
* ----------------------------------
* data length (256 MB max)
* (body, method, path, version, status, reason)
*
* types :
* - 0000 = request start-line
* - 0001 = response start-line
* - 0010 = header
* - 0011 = pseudo-header ou "special" header
* - 0100 = end-of-headers
* - 0101 = data
* - 0110 = trailer
* - 0111 = end-of-trailers
* - 1000 = end-of-message
* ...
* - 1111 = unused
*
*/
/* HTX start-line flags */
#define HTX_SL_F_NONE 0x00000000
#define HTX_SL_F_IS_RESP 0x00000001 /* It is the response start-line (unset means the request one) */
#define HTX_SL_F_XFER_LEN 0x00000002 /* The message xfer size can be dertermined */
#define HTX_SL_F_XFER_ENC 0x00000004 /* The transfer-encoding header was found in message */
#define HTX_SL_F_CLEN 0x00000008 /* The content-length header was found in message */
#define HTX_SL_F_CHNK 0x00000010 /* The message payload is chunked */
#define HTX_SL_F_VER_11 0x00000020 /* The message indicates version 1.1 or above */
#define HTX_SL_F_BODYLESS 0x00000040 /* The message has no body (content-length = 0) */
#define HTX_SL_F_HAS_SCHM 0x00000080 /* The scheme is explicitly specified */
#define HTX_SL_F_SCHM_HTTP 0x00000100 /* The scheme HTTP should be used */
#define HTX_SL_F_SCHM_HTTPS 0x00000200 /* The scheme HTTPS should be used */
#define HTX_SL_F_HAS_AUTHORITY 0x00000400 /* The request authority is explicitly specified */
#define HTX_SL_F_NORMALIZED_URI 0x00000800 /* The received URI is normalized (an implicit absolute-uri form) */
/* HTX flags */
#define HTX_FL_NONE 0x00000000
#define HTX_FL_PARSING_ERROR 0x00000001 /* Set when a parsing error occurred */
#define HTX_FL_PROCESSING_ERROR 0x00000002 /* Set when a processing error occurred */
#define HTX_FL_UPGRADE 0x00000004 /* Set when an upgrade is in progress */
#define HTX_FL_PROXY_RESP 0x00000008 /* Set when the response was generated by HAProxy */
/* HTX block's type (max 15). */
enum htx_blk_type {
HTX_BLK_REQ_SL = 0, /* Request start-line */
HTX_BLK_RES_SL = 1, /* Response start-line */
HTX_BLK_HDR = 2, /* header name/value block */
HTX_BLK_EOH = 3, /* end-of-headers block */
HTX_BLK_DATA = 4, /* data block */
HTX_BLK_TLR = 5, /* trailer name/value block */
HTX_BLK_EOT = 6, /* end-of-trailers block */
HTX_BLK_EOM = 7, /* end-of-message block */
/* 8 .. 14 unused */
HTX_BLK_UNUSED = 15, /* unused/removed block */
};
/* One HTX block descriptor */
struct htx_blk {
uint32_t addr; /* relative storage address of the block's payload */
uint32_t info; /* information about the block (type, length) */
};
/* Composite return value used by some HTX functions */
struct htx_ret {
int32_t ret; /* A numerical value */
struct htx_blk *blk; /* An HTX block */
};
/* HTX start-line */
struct htx_sl {
unsigned int flags; /* HTX_SL_F_* */
union {
struct {
enum http_meth_t meth; /* method */
} req;
struct {
uint16_t status; /* status code */
} res;
} info;
/* XXX 2 bytes unused */
int32_t hdrs_bytes; /* Bytes held by all headers, as seen by the mux
* during parsing, from this start-line to the
* corresponding EOH. -1 if unknown */
unsigned int len[3]; /* length of different parts of the start-line */
char l[0];
};
/* Internal representation of an HTTP message */
struct htx {
uint32_t size; /* the array size, in bytes, used to store the HTTP message itself */
uint32_t data; /* the data size, in bytes. To known to total size used by all allocated
* blocks (blocks and their contents), you need to add size used by blocks,
* i.e. [ used * sizeof(struct htx_blk *) ] */
int32_t tail; /* newest inserted block. -1 if the HTX message is empty */
int32_t head; /* oldest inserted block. -1 if the HTX message is empty */
int32_t first; /* position of the first block to (re)start the analyse. -1 if unset. */
uint32_t tail_addr; /* start address of the free space in front of the the blocks table */
uint32_t head_addr; /* start address of the free space at the beginning */
uint32_t end_addr; /* end address of the free space at the beginning */
uint64_t extra; /* known bytes amount remaining to receive */
uint32_t flags; /* HTX_FL_* */
/* XXX 4 bytes unused */
/* Blocks representing the HTTP message itself */
char blocks[0] __attribute__((aligned(8)));
};
#include <haproxy/htx-t.h>
extern struct htx htx_empty;
@ -866,7 +671,7 @@ static inline void htx_dump(struct buffer *chunk, const struct htx *htx, int ful
}
}
#endif /* _COMMON_HTX_H */
#endif /* _HAPROXY_HTX_H */
/*
* Local variables:

2
include/proto/channel.h
View File

@ -30,7 +30,7 @@
#include <haproxy/api.h>
#include <haproxy/chunk.h>
#include <haproxy/dynbuf.h>
#include <common/htx.h>
#include <haproxy/htx.h>
#include <haproxy/ticks.h>
#include <haproxy/time.h>

2
include/proto/fcgi-app.h
View File

@ -22,7 +22,7 @@
#ifndef _PROTO_HTTP_FCGI_H
#define _PROTO_HTTP_FCGI_H
#include <common/htx.h>
#include <haproxy/htx.h>
#include <types/fcgi-app.h>
#include <types/proxy.h>

2
include/proto/http_ana.h
View File

@ -23,7 +23,7 @@
#define _PROTO_PROTO_HTTP_H
#include <haproxy/api.h>
#include <common/htx.h>
#include <haproxy/htx.h>
#include <types/channel.h>
#include <types/http_ana.h>
#include <types/stream.h>

2
include/proto/http_fetch.h
View File

@ -23,7 +23,7 @@
#define _PROTO_HTTP_FETCH_H
#include <haproxy/api.h>
#include <common/htx.h>
#include <haproxy/htx.h>
#include <types/arg.h>
#include <types/channel.h>
#include <types/checks.h>

2
include/types/http_htx.h
View File

@ -27,7 +27,7 @@
#include <haproxy/buf-t.h>
#include <haproxy/http-t.h>
#include <common/htx.h>
#include <haproxy/htx-t.h>
#include <import/ist.h>
/* Context used to find/remove an HTTP header. */

2
src/backend.c
View File

@ -22,7 +22,7 @@
#include <haproxy/api.h>
#include <haproxy/hash.h>
#include <haproxy/http.h>
#include <common/htx.h>
#include <haproxy/htx.h>
#include <haproxy/ticks.h>
#include <haproxy/time.h>
#include <haproxy/namespace.h>

2
src/cache.c
View File

@ -35,7 +35,7 @@
#include <common/cfgparse.h>
#include <haproxy/hash.h>
#include <common/htx.h>
#include <haproxy/htx.h>
#include <haproxy/net_helper.h>
#define CACHE_FLT_F_IMPLICIT_DECL 0x00000001 /* The cache filtre was implicitly declared (ie without

2
src/checks.c
View File

@ -41,7 +41,7 @@
#include <haproxy/thread.h>
#include <haproxy/http.h>
#include <haproxy/h1.h>
#include <common/htx.h>
#include <haproxy/htx.h>
#include <types/global.h>
#include <types/dns.h>

2
src/filters.c
View File

@ -14,7 +14,7 @@
#include <haproxy/buf-t.h>
#include <common/cfgparse.h>
#include <haproxy/errors.h>
#include <common/htx.h>
#include <haproxy/htx.h>
#include <haproxy/namespace.h>
#include <common/standard.h>

2
src/flt_http_comp.c
View File

@ -14,7 +14,7 @@
#include <haproxy/dynbuf.h>
#include <haproxy/http.h>
#include <common/cfgparse.h>
#include <common/htx.h>
#include <haproxy/htx.h>
#include <haproxy/list.h>
#include <common/standard.h>

2
src/flt_trace.c
View File

@ -13,7 +13,7 @@
#include <ctype.h>
#include <haproxy/api.h>
#include <common/htx.h>
#include <haproxy/htx.h>
#include <common/standard.h>
#include <haproxy/time.h>

2
src/h1_htx.c
View File

@ -14,7 +14,7 @@
#include <common/cfgparse.h>
#include <haproxy/h1.h>
#include <haproxy/http.h>
#include <common/htx.h>
#include <haproxy/htx.h>
#include <proto/h1_htx.h>

1
src/h2.c
View File

@ -30,6 +30,7 @@
#include <haproxy/http.h>
#include <common/h2.h>
#include <haproxy/http-hdr-t.h>
#include <haproxy/htx.h>
#include <import/ist.h>
#include <types/global.h>

2
src/http_ana.c
View File

@ -13,7 +13,7 @@
#include <haproxy/api.h>
#include <haproxy/base64.h>
#include <haproxy/http.h>
#include <common/htx.h>
#include <haproxy/htx.h>
#include <haproxy/net_helper.h>
#include <haproxy/regex.h>
#include <common/uri_auth.h>

2
src/http_fetch.c
View File

@ -21,7 +21,7 @@
#include <haproxy/chunk.h>
#include <haproxy/h1.h>
#include <haproxy/http.h>
#include <common/htx.h>
#include <haproxy/htx.h>
#include <haproxy/pool.h>
#include <common/standard.h>
#include <haproxy/version.h>

2
src/http_htx.c
View File

@ -21,7 +21,7 @@
#include <common/cfgparse.h>
#include <haproxy/h1.h>
#include <haproxy/http.h>
#include <common/htx.h>
#include <haproxy/htx.h>
#include <proto/arg.h>
#include <proto/http_htx.h>

2
src/htx.c
View File

@ -11,7 +11,7 @@
*/
#include <haproxy/chunk.h>
#include <common/htx.h>
#include <haproxy/htx.h>
struct htx htx_empty = { .size = 0, .data = 0, .head = -1, .tail = -1, .first = -1 };

2
src/mux_fcgi.c
View File

@ -14,7 +14,7 @@
#include <common/cfgparse.h>
#include <common/fcgi.h>
#include <haproxy/h1.h>
#include <common/htx.h>
#include <haproxy/htx.h>
#include <import/ist.h>
#include <haproxy/list.h>
#include <haproxy/net_helper.h>

2
src/mux_h1.c
View File

@ -14,7 +14,7 @@
#include <common/cfgparse.h>
#include <haproxy/h1.h>
#include <common/h2.h>
#include <common/htx.h>
#include <haproxy/htx.h>
#include <import/ebistree.h>

2
src/mux_h2.c
View File

@ -18,7 +18,7 @@
#include <common/hpack-dec.h>
#include <common/hpack-enc.h>
#include <common/hpack-tbl.h>
#include <common/htx.h>
#include <haproxy/htx.h>
#include <haproxy/net_helper.h>
#include <proto/connection.h>
#include <proto/http_htx.h>

1
src/mux_pt.c
View File

@ -11,6 +11,7 @@
*/
#include <haproxy/api.h>
#include <haproxy/buf.h>
#include <proto/connection.h>
#include <proto/stream.h>
#include <proto/task.h>

2
src/payload.c
View File

@ -15,7 +15,7 @@
#include <haproxy/api.h>
#include <haproxy/net_helper.h>
#include <common/htx.h>
#include <haproxy/htx.h>
#include <proto/acl.h>
#include <proto/arg.h>
#include <proto/channel.h>

1
src/sample.c
View File

@ -19,6 +19,7 @@
#include <haproxy/api.h>
#include <types/global.h>
#include <haproxy/buf.h>
#include <haproxy/chunk.h>
#include <haproxy/hash.h>
#include <haproxy/http.h>

2
src/stats.c
View File

@ -28,7 +28,7 @@
#include <common/cfgparse.h>
#include <haproxy/debug.h>
#include <haproxy/http.h>
#include <common/htx.h>
#include <haproxy/htx.h>
#include <haproxy/pool.h>
#include <haproxy/list.h>
#include <common/standard.h>

2
src/stream.c
View File

@ -19,7 +19,7 @@
#include <haproxy/dynbuf.h>
#include <haproxy/istbuf.h>
#include <haproxy/thread.h>
#include <common/htx.h>
#include <haproxy/htx.h>
#include <haproxy/pool.h>
#include <types/applet.h>