RepoMirrors
/
haproxy
mirror of http://git.haproxy.org/git/haproxy.git/
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
haproxy/include/proto/proto_http.h

291 lines
13 KiB
C
Raw Normal View History

[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
/*
[MEDIUM] stats: make HTTP stats use an I/O handler Doing this, we can remove the last BF_HIJACK user and remove produce_content(). s->data_source could also be removed but it is currently used to detect if the stats or a server was used.
2009-10-04 13:56:38 +00:00
* include/proto/proto_http.h
* This file contains HTTP protocol definitions.
*
[REORG] http: move the http-request rules to proto_http And also rename "req_acl_rule" "http_req_rule". At the beginning that was a bit confusing to me, especially the "req_acl" list which in fact holds what we call rules. After some digging, it appeared that some part of the code is 100% HTTP and not just related to authentication anymore, so let's move that part to HTTP and keep the auth-only code in auth.c.
2011-01-06 16:51:27 +00:00
* Copyright (C) 2000-2011 Willy Tarreau - w@1wt.eu
[MEDIUM] stats: make HTTP stats use an I/O handler Doing this, we can remove the last BF_HIJACK user and remove produce_content(). s->data_source could also be removed but it is currently used to detect if the stats or a server was used.
2009-10-04 13:56:38 +00:00
*
* 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
*/
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
#ifndef _PROTO_PROTO_HTTP_H
#define _PROTO_PROTO_HTTP_H
[CLEANUP] included common/version.h everywhere
2006-06-29 16:54:54 +00:00
#include <common/config.h>
CLEANUP: actions: missplaced includes The include of action.h are misplaced.
2015-09-10 16:28:10 +00:00
#include <types/action.h>
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
#include <types/proto_http.h>
REORG/MAJOR: session: rename the "session" entity to "stream" With HTTP/2, we'll have to support multiplexed streams. A stream is in fact the largest part of what we currently call a session, it has buffers, logs, etc. In order to catch any error, this commit removes any reference to the struct session and tries to rename most "session" occurrences in function names to "stream" and "sess" to "strm" when that's related to a session. The files stream.{c,h} were added and session.{c,h} removed. The session will be reintroduced later and a few parts of the stream will progressively be moved overthere. It will more or less contain only what we need in an embryonic session. Sample fetch functions and converters will have to change a bit so that they'll use an L5 (session) instead of what's currently called "L4" which is in fact L6 for now. Once all changes are completed, we should see approximately this : L7 - http_txn L6 - stream L5 - session L4 - connection | applet There will be at most one http_txn per stream, and a same session will possibly be referenced by multiple streams. A connection will point to a session and to a stream. The session will hold all the information we need to keep even when we don't yet have a stream. Some more cleanup is needed because some code was already far from being clean. The server queue management still refers to sessions at many places while comments talk about connections. This will have to be cleaned up once we have a server-side connection pool manager. Stream flags "SN_*" still need to be renamed, it doesn't seem like any of them will need to move to the session.
2015-04-02 22:22:06 +00:00
#include <types/stream.h>
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
#include <types/task.h>
[MAJOR] replaced the client-side HTTP parser with a new one The new parser uses an FSM to strictly follow RFC2616. Headers are indexed and parsed only once they're all available. That way, complex regexes make more sense. HTTP processing is now performed in several phases by calling multiple functions, making the code cleaner and easier to read. Note that req[i]pass does not work anymore because it would require that we mark a header to be ignored. What is really needed is to have the ability to add an exception to a matching (match xx except yy). Several bugs have been fixed in appsession during the conversion to the new FSM (method length and recovery on malloc errors). The code does build and work with the debug examples, but is not usable yet to connect to anything as it does not forward the requests yet.
2006-12-04 01:26:12 +00:00
/*
* some macros used for the request parsing.
* from RFC2616:
* CTL = <any US-ASCII control character (octets 0 - 31) and DEL (127)>
[MAJOR] huge rework of the HTTP request FSM The HTTP parser has been rewritten for better compliance to RFC2616. The same parser is now usable for both requests and responses, and it now supports HTTP/0.9 as well as multi-line headers. It has also been improved for speed ; a typicial HTTP request is parsed in about 2 microseconds on a 1 GHz processor. The monitor-uri check has been moved so that the requests are not logged. The httpclose option now tries to change as little as possible in the request, and does not affect the first header if it is already set to 'close'. HTTP/0.9 requests are converted to HTTP/1.0 before being forwarded. Headers and request transformations are now distinct. The headers list is updated after each insertion/removal/transformation. The request is re-parsed and checked after each transformation. It is not possible anymore to remove a request, and requests which lead to invalid request lines are now rejected.
2007-01-21 18:16:41 +00:00
* SEP = one of the 17 defined separators or SP or HT
* LWS = CR, LF, SP or HT
* SPHT = SP or HT. Use this macro and not a boolean expression for best speed.
* CRLF = CR or LF. Use this macro and not a boolean expression for best speed.
* token = any CHAR except CTL or SEP. Use this macro and not a boolean expression for best speed.
[MINOR] implement http_is_ver_token to fix response parsing This new character map improves accuracy when parsing HTTP version, which helps inspecting requests, and fixes response handling.
2007-03-04 17:13:58 +00:00
*
* added for ease of use:
* ver_token = 'H', 'P', 'T', '/', '.', and digits.
[MAJOR] replaced the client-side HTTP parser with a new one The new parser uses an FSM to strictly follow RFC2616. Headers are indexed and parsed only once they're all available. That way, complex regexes make more sense. HTTP processing is now performed in several phases by calling multiple functions, making the code cleaner and easier to read. Note that req[i]pass does not work anymore because it would require that we mark a header to be ignored. What is really needed is to have the ability to add an exception to a matching (match xx except yy). Several bugs have been fixed in appsession during the conversion to the new FSM (method length and recovery on malloc errors). The code does build and work with the debug examples, but is not usable yet to connect to anything as it does not forward the requests yet.
2006-12-04 01:26:12 +00:00
*/
[MAJOR] huge rework of the HTTP request FSM The HTTP parser has been rewritten for better compliance to RFC2616. The same parser is now usable for both requests and responses, and it now supports HTTP/0.9 as well as multi-line headers. It has also been improved for speed ; a typicial HTTP request is parsed in about 2 microseconds on a 1 GHz processor. The monitor-uri check has been moved so that the requests are not logged. The httpclose option now tries to change as little as possible in the request, and does not affect the first header if it is already set to 'close'. HTTP/0.9 requests are converted to HTTP/1.0 before being forwarded. Headers and request transformations are now distinct. The headers list is updated after each insertion/removal/transformation. The request is re-parsed and checked after each transformation. It is not possible anymore to remove a request, and requests which lead to invalid request lines are now rejected.
2007-01-21 18:16:41 +00:00
extern const char http_is_ctl[256];
extern const char http_is_sep[256];
extern const char http_is_lws[256];
extern const char http_is_spht[256];
extern const char http_is_crlf[256];
extern const char http_is_token[256];
[MINOR] implement http_is_ver_token to fix response parsing This new character map improves accuracy when parsing HTTP version, which helps inspecting requests, and fixes response handling.
2007-03-04 17:13:58 +00:00
extern const char http_is_ver_token[256];
[MAJOR] huge rework of the HTTP request FSM The HTTP parser has been rewritten for better compliance to RFC2616. The same parser is now usable for both requests and responses, and it now supports HTTP/0.9 as well as multi-line headers. It has also been improved for speed ; a typicial HTTP request is parsed in about 2 microseconds on a 1 GHz processor. The monitor-uri check has been moved so that the requests are not logged. The httpclose option now tries to change as little as possible in the request, and does not affect the first header if it is already set to 'close'. HTTP/0.9 requests are converted to HTTP/1.0 before being forwarded. Headers and request transformations are now distinct. The headers list is updated after each insertion/removal/transformation. The request is re-parsed and checked after each transformation. It is not possible anymore to remove a request, and requests which lead to invalid request lines are now rejected.
2007-01-21 18:16:41 +00:00
[REORG] http: move HTTP error codes back to proto_http.h This one was left isolated in its own file. It probably is a leftover from the 1.2->1.3 split.
2011-05-11 14:10:11 +00:00
extern const int http_err_codes[HTTP_ERR_SIZE];
extern struct chunk http_err_chunks[HTTP_ERR_SIZE];
extern const char *HTTP_302;
extern const char *HTTP_303;
MEDIUM: remove remains of BUFSIZE in HTTP auth and sample conversions Sample conversions rely on two alternative buffers which were previously allocated as static bufs of size BUFSIZE. Now they're initialized to the global buffer size. It was the same for HTTP authentication. Note that it seems that none of them was prone to any mistake when dealing with the buffer size, but better stay on the safe side by maintaining the old assumption that a trash buffer is always "large enough".
2012-10-29 19:44:36 +00:00
extern char *get_http_auth_buff;
[REORG] http: move HTTP error codes back to proto_http.h This one was left isolated in its own file. It probably is a leftover from the 1.2->1.3 split.
2011-05-11 14:10:11 +00:00
[MAJOR] huge rework of the HTTP request FSM The HTTP parser has been rewritten for better compliance to RFC2616. The same parser is now usable for both requests and responses, and it now supports HTTP/0.9 as well as multi-line headers. It has also been improved for speed ; a typicial HTTP request is parsed in about 2 microseconds on a 1 GHz processor. The monitor-uri check has been moved so that the requests are not logged. The httpclose option now tries to change as little as possible in the request, and does not affect the first header if it is already set to 'close'. HTTP/0.9 requests are converted to HTTP/1.0 before being forwarded. Headers and request transformations are now distinct. The headers list is updated after each insertion/removal/transformation. The request is re-parsed and checked after each transformation. It is not possible anymore to remove a request, and requests which lead to invalid request lines are now rejected.
2007-01-21 18:16:41 +00:00
#define HTTP_IS_CTL(x) (http_is_ctl[(unsigned char)(x)])
#define HTTP_IS_SEP(x) (http_is_sep[(unsigned char)(x)])
#define HTTP_IS_LWS(x) (http_is_lws[(unsigned char)(x)])
#define HTTP_IS_SPHT(x) (http_is_spht[(unsigned char)(x)])
#define HTTP_IS_CRLF(x) (http_is_crlf[(unsigned char)(x)])
#define HTTP_IS_TOKEN(x) (http_is_token[(unsigned char)(x)])
[MINOR] implement http_is_ver_token to fix response parsing This new character map improves accuracy when parsing HTTP version, which helps inspecting requests, and fixes response handling.
2007-03-04 17:13:58 +00:00
#define HTTP_IS_VER_TOKEN(x) (http_is_ver_token[(unsigned char)(x)])
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
REORG/MAJOR: session: rename the "session" entity to "stream" With HTTP/2, we'll have to support multiplexed streams. A stream is in fact the largest part of what we currently call a session, it has buffers, logs, etc. In order to catch any error, this commit removes any reference to the struct session and tries to rename most "session" occurrences in function names to "stream" and "sess" to "strm" when that's related to a session. The files stream.{c,h} were added and session.{c,h} removed. The session will be reintroduced later and a few parts of the stream will progressively be moved overthere. It will more or less contain only what we need in an embryonic session. Sample fetch functions and converters will have to change a bit so that they'll use an L5 (session) instead of what's currently called "L4" which is in fact L6 for now. Once all changes are completed, we should see approximately this : L7 - http_txn L6 - stream L5 - session L4 - connection | applet There will be at most one http_txn per stream, and a same session will possibly be referenced by multiple streams. A connection will point to a session and to a stream. The session will hold all the information we need to keep even when we don't yet have a stream. Some more cleanup is needed because some code was already far from being clean. The server queue management still refers to sessions at many places while comments talk about connections. This will have to be cleaned up once we have a server-side connection pool manager. Stream flags "SN_*" still need to be renamed, it doesn't seem like any of them will need to move to the session.
2015-04-02 22:22:06 +00:00
int process_cli(struct stream *s);
int process_srv_data(struct stream *s);
int process_srv_conn(struct stream *s);
int http_wait_for_request(struct stream *s, struct channel *req, int an_bit);
int http_process_req_common(struct stream *s, struct channel *req, int an_bit, struct proxy *px);
int http_process_request(struct stream *s, struct channel *req, int an_bit);
int http_process_tarpit(struct stream *s, struct channel *req, int an_bit);
int http_wait_for_request_body(struct stream *s, struct channel *req, int an_bit);
MEDIUM: http: http_send_name_header: remove references to msg and buffer They can be deduced from txn.
2012-03-09 11:11:57 +00:00
int http_send_name_header(struct http_txn *txn, struct proxy* be, const char* svr_name);
REORG/MAJOR: session: rename the "session" entity to "stream" With HTTP/2, we'll have to support multiplexed streams. A stream is in fact the largest part of what we currently call a session, it has buffers, logs, etc. In order to catch any error, this commit removes any reference to the struct session and tries to rename most "session" occurrences in function names to "stream" and "sess" to "strm" when that's related to a session. The files stream.{c,h} were added and session.{c,h} removed. The session will be reintroduced later and a few parts of the stream will progressively be moved overthere. It will more or less contain only what we need in an embryonic session. Sample fetch functions and converters will have to change a bit so that they'll use an L5 (session) instead of what's currently called "L4" which is in fact L6 for now. Once all changes are completed, we should see approximately this : L7 - http_txn L6 - stream L5 - session L4 - connection | applet There will be at most one http_txn per stream, and a same session will possibly be referenced by multiple streams. A connection will point to a session and to a stream. The session will hold all the information we need to keep even when we don't yet have a stream. Some more cleanup is needed because some code was already far from being clean. The server queue management still refers to sessions at many places while comments talk about connections. This will have to be cleaned up once we have a server-side connection pool manager. Stream flags "SN_*" still need to be renamed, it doesn't seem like any of them will need to move to the session.
2015-04-02 22:22:06 +00:00
int http_wait_for_response(struct stream *s, struct channel *rep, int an_bit);
int http_process_res_common(struct stream *s, struct channel *rep, int an_bit, struct proxy *px);
int http_request_forward_body(struct stream *s, struct channel *req, int an_bit);
int http_response_forward_body(struct stream *s, struct channel *res, int an_bit);
MINOR: http: export function http_msg_analyzer() Exports the function http_msg_analyzer().
2015-09-25 09:06:37 +00:00
void http_msg_analyzer(struct http_msg *msg, struct hdr_idx *idx);
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
REORG/MAJOR: session: rename the "session" entity to "stream" With HTTP/2, we'll have to support multiplexed streams. A stream is in fact the largest part of what we currently call a session, it has buffers, logs, etc. In order to catch any error, this commit removes any reference to the struct session and tries to rename most "session" occurrences in function names to "stream" and "sess" to "strm" when that's related to a session. The files stream.{c,h} were added and session.{c,h} removed. The session will be reintroduced later and a few parts of the stream will progressively be moved overthere. It will more or less contain only what we need in an embryonic session. Sample fetch functions and converters will have to change a bit so that they'll use an L5 (session) instead of what's currently called "L4" which is in fact L6 for now. Once all changes are completed, we should see approximately this : L7 - http_txn L6 - stream L5 - session L4 - connection | applet There will be at most one http_txn per stream, and a same session will possibly be referenced by multiple streams. A connection will point to a session and to a stream. The session will hold all the information we need to keep even when we don't yet have a stream. Some more cleanup is needed because some code was already far from being clean. The server queue management still refers to sessions at many places while comments talk about connections. This will have to be cleaned up once we have a server-side connection pool manager. Stream flags "SN_*" still need to be renamed, it doesn't seem like any of them will need to move to the session.
2015-04-02 22:22:06 +00:00
void debug_hdr(const char *dir, struct stream *s, const char *start, const char *end);
int apply_filter_to_req_headers(struct stream *s, struct channel *req, struct hdr_exp *exp);
int apply_filter_to_req_line(struct stream *s, struct channel *req, struct hdr_exp *exp);
int apply_filters_to_request(struct stream *s, struct channel *req, struct proxy *px);
int apply_filters_to_response(struct stream *s, struct channel *rtr, struct proxy *px);
void manage_client_side_cookies(struct stream *s, struct channel *req);
void manage_server_side_cookies(struct stream *s, struct channel *rtr);
void check_response_for_cacheability(struct stream *s, struct channel *rtr);
[REORG] session: move the data_ctx struct to the stream interface's applet This is in fact where those parts belong to. The old data_state was replaced by applet.state and is now initialized when the applet is registered. It's worth noting that the applet does not need to know the session nor the buffer anymore since everything is brought by the stream interface. It is possible that having a separate applet struct would simplify the code but that's not a big deal.
2011-03-10 10:25:07 +00:00
int stats_check_uri(struct stream_interface *si, struct http_txn *txn, struct proxy *backend);
[MEDIUM] errorloc now checked first from backend then from frontend It is now possible to define an errorloc in the backend as well as in the frontend. The backend's will be used first, and if undefined, then the frontend's will be used instead. If none is used, then the original error messages will be used.
2006-12-24 16:47:20 +00:00
void init_proto_http();
MINOR: http: add full-length header fetch methods The req.hdr and res.hdr fetch methods do not work well on headers which are allowed to contain commas, such as User-Agent, Date or Expires. More specifically, full-length matching is impossible if a comma is present. This patch introduces 4 new fetch functions which are designed to work with these full-length headers : - req.fhdr, req.fhdr_cnt - res.fhdr, res.fhdr_cnt These ones do not stop at commas and permit to return full-length header values.
2013-06-10 16:39:42 +00:00
int http_find_full_header2(const char *name, int len,
char *sol, struct hdr_idx *idx,
struct hdr_ctx *ctx);
[MAJOR] implement parameter hashing for POST requests This patch extends the "url_param" load balancing method by introducing the "check_post" option. Using this option enables analysis of the beginning of POST requests to search for the specified URL parameter. The patch also fixes a few minor typos in comments that were discovered during code review.
2008-04-14 18:47:37 +00:00
int http_find_header2(const char *name, int len,
[MINOR] http: add http_remove_header2() to remove a header value. Calling this function after http_find_header2() automatically deletes the current value of the header, and removes the header itself if the value is the only one. The context is automatically adjusted for a next call to http_find_header2() to return the next header. No other change nor test should be made on the transient context though.
2010-01-18 13:54:04 +00:00
char *sol, struct hdr_idx *idx,
[MAJOR] implement parameter hashing for POST requests This patch extends the "url_param" load balancing method by introducing the "check_post" option. Using this option enables analysis of the beginning of POST requests to search for the specified URL parameter. The patch also fixes a few minor typos in comments that were discovered during code review.
2008-04-14 18:47:37 +00:00
struct hdr_ctx *ctx);
MINOR: http: some exported functions were not in the header file Export the following functions: - find_hdr_value_end - http_header_match2 - http_remove_header2 - http_header_add_tail2
2013-10-15 09:43:19 +00:00
char *find_hdr_value_end(char *s, const char *e);
int http_header_match2(const char *hdr, const char *end, const char *name, int len);
int http_remove_header2(struct http_msg *msg, struct hdr_idx *idx, struct hdr_ctx *ctx);
int http_header_add_tail2(struct http_msg *msg, struct hdr_idx *hdr_idx, const char *text, int len);
MEDIUM: http: remove the now useless http_txn from {req/res} rules The registerable http_req_rules / http_res_rules used to require a struct http_txn at the end. It's redundant with struct stream and propagates very deep into some parts (ie: it was the reason for lua requiring l7). Let's remove it now.
2015-04-03 23:09:08 +00:00
int http_replace_req_line(int action, const char *replace, int len, struct proxy *px, struct stream *s);
MINOR: http: Action for manipulating the returned status code. This patch is inspired by Bowen Ni's proposal and it is based on his first implementation: With Lua integration in HAProxy 1.6, one can change the request method, path, uri, header, response header etc except response line. I'd like to contribute the following methods to allow modification of the response line. [...] There are two new keywords in 'http-response' that allows you to rewrite them in the native HAProxy config. There are also two new APIs in Lua that allows you to do the same rewriting in your Lua script. Example: Use it in HAProxy config: *http-response set-code 404* Or use it in Lua script: *txn.http:res_set_reason("Redirect")* I dont take the full patch because the manipulation of the "reason" is useless. standard reason are associated with each returned code, and unknown code can take generic reason. So, this patch can set the status code, and the reason is automatically adapted.
2015-08-26 14:21:56 +00:00
void http_set_status(unsigned int status, struct stream *s);
REORG/MAJOR: session: rename the "session" entity to "stream" With HTTP/2, we'll have to support multiplexed streams. A stream is in fact the largest part of what we currently call a session, it has buffers, logs, etc. In order to catch any error, this commit removes any reference to the struct session and tries to rename most "session" occurrences in function names to "stream" and "sess" to "strm" when that's related to a session. The files stream.{c,h} were added and session.{c,h} removed. The session will be reintroduced later and a few parts of the stream will progressively be moved overthere. It will more or less contain only what we need in an embryonic session. Sample fetch functions and converters will have to change a bit so that they'll use an L5 (session) instead of what's currently called "L4" which is in fact L6 for now. Once all changes are completed, we should see approximately this : L7 - http_txn L6 - stream L5 - session L4 - connection | applet There will be at most one http_txn per stream, and a same session will possibly be referenced by multiple streams. A connection will point to a session and to a stream. The session will hold all the information we need to keep even when we don't yet have a stream. Some more cleanup is needed because some code was already far from being clean. The server queue management still refers to sessions at many places while comments talk about connections. This will have to be cleaned up once we have a server-side connection pool manager. Stream flags "SN_*" still need to be renamed, it doesn't seem like any of them will need to move to the session.
2015-04-02 22:22:06 +00:00
int http_transform_header_str(struct stream* s, struct http_msg *msg, const char* name,
MINOR: http: split http_transform_header() function in two parts. This function is a callback for HTTP actions. This function creates the replacement string from a build_logline() format and transform the header. This patch split this function in two part. With this modification, the header transformation and the replacement string are separed. We can now transform the header with another replacement string source than a build_logline() format.
2015-03-16 10:15:50 +00:00
unsigned int name_len, const char *str, struct my_regex *re,
int action);
MINOR: http: export function inet_set_tos() This is used by Lua.
2015-03-16 11:03:44 +00:00
void inet_set_tos(int fd, struct sockaddr_storage from, int tos);
REORG/MAJOR: session: rename the "session" entity to "stream" With HTTP/2, we'll have to support multiplexed streams. A stream is in fact the largest part of what we currently call a session, it has buffers, logs, etc. In order to catch any error, this commit removes any reference to the struct session and tries to rename most "session" occurrences in function names to "stream" and "sess" to "strm" when that's related to a session. The files stream.{c,h} were added and session.{c,h} removed. The session will be reintroduced later and a few parts of the stream will progressively be moved overthere. It will more or less contain only what we need in an embryonic session. Sample fetch functions and converters will have to change a bit so that they'll use an L5 (session) instead of what's currently called "L4" which is in fact L6 for now. Once all changes are completed, we should see approximately this : L7 - http_txn L6 - stream L5 - session L4 - connection | applet There will be at most one http_txn per stream, and a same session will possibly be referenced by multiple streams. A connection will point to a session and to a stream. The session will hold all the information we need to keep even when we don't yet have a stream. Some more cleanup is needed because some code was already far from being clean. The server queue management still refers to sessions at many places while comments talk about connections. This will have to be cleaned up once we have a server-side connection pool manager. Stream flags "SN_*" still need to be renamed, it doesn't seem like any of them will need to move to the session.
2015-04-02 22:22:06 +00:00
void http_perform_server_redirect(struct stream *s, struct stream_interface *si);
void http_return_srv_error(struct stream *s, struct stream_interface *si);
void http_capture_bad_message(struct error_snapshot *es, struct stream *s,
MEDIUM: http: remove buffer arg in http_capture_bad_message The buffer pointer is now taken from the http_msg.
2012-03-09 12:39:23 +00:00
struct http_msg *msg,
MINOR: http: switch the http state to an enum This reduces its size which is not reused by anything else. However it will significantly improve the debugger's output since we'll now get real state values. The default case had to be enabled in the parsers because gcc tries to optimize the switch/case and noticed some values were missing from the enums and emitted a warning.
2013-12-06 23:01:53 +00:00
enum ht_state state, struct proxy *other_end);
MEDIUM: http: merge acl and pattern header fetch functions HTTP header fetch is now done using smp_fetch_hdr() for both ACLs and patterns. This one also supports an occurrence number, making it possible to specify explicit occurrences for ACLs and patterns.
2012-04-26 13:11:51 +00:00
unsigned int http_get_hdr(const struct http_msg *msg, const char *hname, int hlen,
MEDIUM: http: replace get_ip_from_hdr2() with http_get_hdr() The new function does not return IP addresses but header values instead, so that the caller is free to make what it want of them. The conversion is not quite clean yet, as the previous test which considered that address 0.0.0.0 meant "no address" is still used. A different IP parsing function should be used to take this into account.
2011-12-16 20:35:50 +00:00
struct hdr_idx *idx, int occ,
struct hdr_ctx *ctx, char **vptr, int *vlen);
MINOR: http: export http_get_path() function This patch simply exports the http_get_path() function from the proto_http.c file.
2015-09-17 17:33:35 +00:00
char *http_get_path(struct http_txn *txn);
MINOR: http: export the get_reason() function This patch exports the get_reason() function.
2015-09-18 15:59:23 +00:00
const char *get_reason(unsigned int status);
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
MAJOR: http: move http_txn out of struct stream Now this one is dynamically allocated. It means that 280 bytes of memory are saved per TCP stream, but more importantly that it will become possible to remove the l7 pointer from fetches and converters since it will be deduced from the stream and will support being null. A lot of care was taken because it's easy to forget a test somewhere, and the previous code used to always trust s->txn for being valid, but all places seem to have been visited. All HTTP fetch functions check the txn first so we shouldn't have any issue there even when called from TCP. When branching from a TCP frontend to an HTTP backend, the txn is properly allocated at the same time as the hdr_idx.
2015-04-03 21:46:31 +00:00
struct http_txn *http_alloc_txn(struct stream *s);
REORG/MAJOR: session: rename the "session" entity to "stream" With HTTP/2, we'll have to support multiplexed streams. A stream is in fact the largest part of what we currently call a session, it has buffers, logs, etc. In order to catch any error, this commit removes any reference to the struct session and tries to rename most "session" occurrences in function names to "stream" and "sess" to "strm" when that's related to a session. The files stream.{c,h} were added and session.{c,h} removed. The session will be reintroduced later and a few parts of the stream will progressively be moved overthere. It will more or less contain only what we need in an embryonic session. Sample fetch functions and converters will have to change a bit so that they'll use an L5 (session) instead of what's currently called "L4" which is in fact L6 for now. Once all changes are completed, we should see approximately this : L7 - http_txn L6 - stream L5 - session L4 - connection | applet There will be at most one http_txn per stream, and a same session will possibly be referenced by multiple streams. A connection will point to a session and to a stream. The session will hold all the information we need to keep even when we don't yet have a stream. Some more cleanup is needed because some code was already far from being clean. The server queue management still refers to sessions at many places while comments talk about connections. This will have to be cleaned up once we have a server-side connection pool manager. Stream flags "SN_*" still need to be renamed, it doesn't seem like any of them will need to move to the session.
2015-04-02 22:22:06 +00:00
void http_init_txn(struct stream *s);
void http_end_txn(struct stream *s);
void http_reset_txn(struct stream *s);
void http_adjust_conn_mode(struct stream *s, struct http_txn *txn, struct http_msg *msg);
[MINOR] http: move the http transaction init/cleanup code to proto_http This code really belongs to the http part since it's transaction-specific. This will also make it easier to later reinitialize a transaction in order to support keepalive.
2009-12-22 14:03:09 +00:00
MEDIUM: actions: Merge (http|tcp)-(request|reponse) action structs This patch is the first of a serie which merge all the action structs. The function "tcp-request content", "tcp-response-content", "http-request" and "http-response" have the same values and the same process for some defined actions, but the struct and the prototype of the declared function are different. This patch try to unify all of these entries.
2015-08-04 17:35:46 +00:00
struct act_rule *parse_http_req_cond(const char **args, const char *file, int linenum, struct proxy *proxy);
struct act_rule *parse_http_res_cond(const char **args, const char *file, int linenum, struct proxy *proxy);
[REORG] http: move the http-request rules to proto_http And also rename "req_acl_rule" "http_req_rule". At the beginning that was a bit confusing to me, especially the "req_acl" list which in fact holds what we call rules. After some digging, it appeared that some part of the code is 100% HTTP and not just related to authentication anymore, so let's move that part to HTTP and keep the auth-only code in auth.c.
2011-01-06 16:51:27 +00:00
void free_http_req_rules(struct list *r);
MEDIUM: http: add actions "replace-header" and "replace-values" in http-req/resp This patch adds two new actions to http-request and http-response rulesets : - replace-header : replace a whole header line, suited for headers which might contain commas - replace-value : replace a single header value, suited for headers defined as lists. The match consists in a regex, and the replacement string takes a log-format and supports back-references.
2014-06-16 18:05:59 +00:00
void free_http_res_rules(struct list *r);
REORG/MAJOR: session: rename the "session" entity to "stream" With HTTP/2, we'll have to support multiplexed streams. A stream is in fact the largest part of what we currently call a session, it has buffers, logs, etc. In order to catch any error, this commit removes any reference to the struct session and tries to rename most "session" occurrences in function names to "stream" and "sess" to "strm" when that's related to a session. The files stream.{c,h} were added and session.{c,h} removed. The session will be reintroduced later and a few parts of the stream will progressively be moved overthere. It will more or less contain only what we need in an embryonic session. Sample fetch functions and converters will have to change a bit so that they'll use an L5 (session) instead of what's currently called "L4" which is in fact L6 for now. Once all changes are completed, we should see approximately this : L7 - http_txn L6 - stream L5 - session L4 - connection | applet There will be at most one http_txn per stream, and a same session will possibly be referenced by multiple streams. A connection will point to a session and to a stream. The session will hold all the information we need to keep even when we don't yet have a stream. Some more cleanup is needed because some code was already far from being clean. The server queue management still refers to sessions at many places while comments talk about connections. This will have to be cleaned up once we have a server-side connection pool manager. Stream flags "SN_*" still need to be renamed, it doesn't seem like any of them will need to move to the session.
2015-04-02 22:22:06 +00:00
struct chunk *http_error_message(struct stream *s, int msgnum);
MEDIUM: http: The redirect strings follows the log format rules. We handle "http-request redirect" with a log-format string now, but we leave "redirect" unaffected. Note that the control of the special "/" case is move from the runtime execution to the configuration parsing. If the format rule list is empty, the build_logline() function does nothing.
2013-11-29 11:15:45 +00:00
struct redirect_rule *http_parse_redirect_rule(const char *file, int linenum, struct proxy *curproxy,
MINOR: http: prepare support for parsing redirect actions on responses In order to support http-response redirect, the parsing needs to be adapted a little bit to only support the "location" type, and to adjust the log-format parser so that it knows the direction of the sample fetch calls.
2015-05-28 13:26:58 +00:00
const char **args, char **errmsg, int use_fmt, int dir);
MEDIUM: sample: change the prototype of sample-fetches functions This patch removes the "opt" entry from the prototype of the sample-fetches fucntions. This permits to remove some weight in the prototype call.
2015-05-11 13:42:45 +00:00
int smp_fetch_cookie(const struct arg *args, struct sample *smp, const char *kw, void *private);
int smp_fetch_base32(const struct arg *args, struct sample *smp, const char *kw, void *private);
[REORG] http: move the http-request rules to proto_http And also rename "req_acl_rule" "http_req_rule". At the beginning that was a bit confusing to me, especially the "req_acl" list which in fact holds what we call rules. After some digging, it appeared that some part of the code is 100% HTTP and not just related to authentication anymore, so let's move that part to HTTP and keep the auth-only code in auth.c.
2011-01-06 16:51:27 +00:00
MEDIUM: sample/http_proto: Add new type called method The method are actuelly stored using two types. Integer if the method is known and string if the method is not known. The fetch is declared as UINT, but in some case it can provides STR. This patch create new type called METH. This type contain interge for known method and string for the other methods. It can be used with automatic converters. The pattern matching can expect method. During the free or prune function, http_meth pettern is freed. This patch initialise the freed pointer to NULL.
2013-12-17 00:10:10 +00:00
enum http_meth_t find_http_meth(const char *str, const int len);
MEDIUM: actions: Merge (http|tcp)-(request|reponse) keywords structs This patch merges the conguration keyword struct. Each declared configuration keyword struct are similar with the others. This patch simplify the code.
2015-08-19 07:01:53 +00:00
struct action_kw *action_http_req_custom(const char *kw);
struct action_kw *action_http_res_custom(const char *kw);
MINOR: global: export many symbols. The functions "val_payload_lv" and "val_hdr" are useful with lua. The lua automatic binding for sample fetchs needs to compare check functions. The "arg_type_names" permit to display error messages.
2014-12-08 18:50:43 +00:00
int val_hdr(struct arg *arg, char **err_msg);
MEDIUM: http: register http-request and http-response keywords The http_(res|req)_keywords_register() functions allow to register new keywords. You need to declare a keyword list: struct http_req_action_kw_list test_kws = { .scope = "testscope", .kw = { { "test", parse_test }, { NULL, NULL }, } }; and a parsing function: int parse_test(const char **args, int *cur_arg, struct proxy *px, struct http_req_rule *rule, char **err) { rule->action = HTTP_REQ_ACT_CUSTOM_STOP; rule->action_ptr = action_function; return 0; } http_req_keywords_register(&test_kws); The HTTP_REQ_ACT_CUSTOM_STOP action stops evaluation of rules after your rule, HTTP_REQ_ACT_CUSTOM_CONT permits the evaluation of rules after your rule.
2014-04-24 12:38:37 +00:00
MINOR: http: made CHECK_HTTP_MESSAGE_FIRST accessible to other functions Added the definition of CHECK_HTTP_MESSAGE_FIRST and the declaration of smp_prefetch_http to the header. Changed smp_prefetch_http implementation to remove the static qualifier.
2015-09-18 16:11:16 +00:00
int smp_prefetch_http(struct proxy *px, struct stream *s, unsigned int opt,
const struct arg *args, struct sample *smp, int req_vol);
/* Note: these functions *do* modify the sample. Even in case of success, at
* least the type and uint value are modified.
*/
#define CHECK_HTTP_MESSAGE_FIRST() \
do { int r = smp_prefetch_http(smp->px, smp->strm, smp->opt, args, smp, 1); if (r <= 0) return r; } while (0)
#define CHECK_HTTP_MESSAGE_FIRST_PERM() \
do { int r = smp_prefetch_http(smp->px, smp->strm, smp->opt, args, smp, 0); if (r <= 0) return r; } while (0)
MEDIUM: actions: Merge (http|tcp)-(request|reponse) keywords structs This patch merges the conguration keyword struct. Each declared configuration keyword struct are similar with the others. This patch simplify the code.
2015-08-19 07:01:53 +00:00
static inline void http_req_keywords_register(struct action_kw_list *kw_list)
MEDIUM: http: register http-request and http-response keywords The http_(res|req)_keywords_register() functions allow to register new keywords. You need to declare a keyword list: struct http_req_action_kw_list test_kws = { .scope = "testscope", .kw = { { "test", parse_test }, { NULL, NULL }, } }; and a parsing function: int parse_test(const char **args, int *cur_arg, struct proxy *px, struct http_req_rule *rule, char **err) { rule->action = HTTP_REQ_ACT_CUSTOM_STOP; rule->action_ptr = action_function; return 0; } http_req_keywords_register(&test_kws); The HTTP_REQ_ACT_CUSTOM_STOP action stops evaluation of rules after your rule, HTTP_REQ_ACT_CUSTOM_CONT permits the evaluation of rules after your rule.
2014-04-24 12:38:37 +00:00
{
LIST_ADDQ(&http_req_keywords.list, &kw_list->list);
}
MEDIUM: actions: Merge (http|tcp)-(request|reponse) keywords structs This patch merges the conguration keyword struct. Each declared configuration keyword struct are similar with the others. This patch simplify the code.
2015-08-19 07:01:53 +00:00
static inline void http_res_keywords_register(struct action_kw_list *kw_list)
MEDIUM: http: register http-request and http-response keywords The http_(res|req)_keywords_register() functions allow to register new keywords. You need to declare a keyword list: struct http_req_action_kw_list test_kws = { .scope = "testscope", .kw = { { "test", parse_test }, { NULL, NULL }, } }; and a parsing function: int parse_test(const char **args, int *cur_arg, struct proxy *px, struct http_req_rule *rule, char **err) { rule->action = HTTP_REQ_ACT_CUSTOM_STOP; rule->action_ptr = action_function; return 0; } http_req_keywords_register(&test_kws); The HTTP_REQ_ACT_CUSTOM_STOP action stops evaluation of rules after your rule, HTTP_REQ_ACT_CUSTOM_CONT permits the evaluation of rules after your rule.
2014-04-24 12:38:37 +00:00
{
LIST_ADDQ(&http_res_keywords.list, &kw_list->list);
}
[MINOR] http: keep pointer to beginning of data We now set msg->col and msg->sov to the first byte of non-header. They will be used later when parsing chunks. A new macro was added to perform size additions on an http_msg in order to limit the risks of copy-paste in the long term. During this operation, it appeared that the http_msg struct was not optimal on 64-bit, so it was re-ordered to fill the holes.
2009-11-29 17:12:29 +00:00
/* to be used when contents change in an HTTP message */
#define http_msg_move_end(msg, bytes) do { \
unsigned int _bytes = (bytes); \
MAJOR: http: move buffer->lr to http_msg->next The buffer's pointer <lr> was only used by HTTP parsers which also use a struct http_msg to keep track of the parser's state. We've reached a point where it makes no sense to keep ->lr in the buffer, as the split between buffer and msg is only arbitrary for historical reasons. This change ensures that touching buffers will not impact HTTP messages anymore, making the buffers more content-agnostic. However, it becomes very important not to forget to update msg->next when some data get forwarded or moved (and in general each time buf->p is updated). The new pointer in http_msg becomes relative to buffer->p so that parsing multiple messages becomes easier. It is possible that at one point ->som and ->next will be merged. Note: http_parse_reqline() and http_parse_stsline() have been temporarily modified to know the message starting point in the buffer (->p).
2012-03-05 10:17:50 +00:00
(msg)->next += (_bytes); \
[MINOR] http: keep pointer to beginning of data We now set msg->col and msg->sov to the first byte of non-header. They will be used later when parsing chunks. A new macro was added to perform size additions on an http_msg in order to limit the risks of copy-paste in the long term. During this operation, it appeared that the http_msg struct was not optimal on 64-bit, so it was re-ordered to fill the holes.
2009-11-29 17:12:29 +00:00
(msg)->sov += (_bytes); \
(msg)->eoh += (_bytes); \
} while (0)
MINOR: http: add a small helper to compute the amount of body bytes present http_body_bytes() returns the number of bytes of the current message body present in the buffer. It is compatible with being called before and after the headers are forwarded. This is done to centralize further ->sov changes.
2014-04-17 18:08:17 +00:00
MEDIUM: http: add a small helper to compute how far to rewind to find headers http_hdr_rewind() returns the number of bytes to rewind before buf->p to find the beginning of headers. At the moment it's not exact as it still relies on buf->o, assuming that no other data from a past message were pending there, but it's what was done till there. The purpose is to centralize further ->sov changes aiming at avoiding to rely on buf->o.
2014-04-17 18:18:08 +00:00
/* Return the amount of bytes that need to be rewound before buf->p to access
* the current message's headers. The purpose is to be able to easily fetch
* the message's beginning before headers are forwarded, as well as after.
MAJOR: http: reset msg->sov after headers are forwarded In order to avoid abusively relying on buf->o to guess how many bytes to rewind during a redispatch, we now clear msg->sov. Thus the meaning of this field is exactly "how many bytes of headers are left to be forwarded". It is still possible to rewind because msg->eoh + msg->eol equal that value before scheduling the forwarding, so we can always subtract them.
2014-04-17 19:14:47 +00:00
* The principle is that msg->eoh and msg->eol are immutable while msg->sov
* equals the sum of the two before forwarding and is zero after forwarding,
* so the difference cancels the rewinding.
MEDIUM: http: add a small helper to compute how far to rewind to find headers http_hdr_rewind() returns the number of bytes to rewind before buf->p to find the beginning of headers. At the moment it's not exact as it still relies on buf->o, assuming that no other data from a past message were pending there, but it's what was done till there. The purpose is to centralize further ->sov changes aiming at avoiding to rely on buf->o.
2014-04-17 18:18:08 +00:00
*/
static inline int http_hdr_rewind(const struct http_msg *msg)
{
MAJOR: http: reset msg->sov after headers are forwarded In order to avoid abusively relying on buf->o to guess how many bytes to rewind during a redispatch, we now clear msg->sov. Thus the meaning of this field is exactly "how many bytes of headers are left to be forwarded". It is still possible to rewind because msg->eoh + msg->eol equal that value before scheduling the forwarding, so we can always subtract them.
2014-04-17 19:14:47 +00:00
return msg->eoh + msg->eol - msg->sov;
MEDIUM: http: add a small helper to compute how far to rewind to find headers http_hdr_rewind() returns the number of bytes to rewind before buf->p to find the beginning of headers. At the moment it's not exact as it still relies on buf->o, assuming that no other data from a past message were pending there, but it's what was done till there. The purpose is to centralize further ->sov changes aiming at avoiding to rely on buf->o.
2014-04-17 18:18:08 +00:00
}
MINOR: http: add a small helper to compute how far to rewind to find URI http_uri_rewind() returns the number of bytes to rewind before buf->p to find the URI. It relies on http_hdr_rewind() to find the beginning and is just here to simplify operations. The purpose is to centralize further ->sov changes aiming at avoiding to rely on buf->o.
2014-04-17 18:24:24 +00:00
/* Return the amount of bytes that need to be rewound before buf->p to access
* the current message's URI. The purpose is to be able to easily fetch
* the message's beginning before headers are forwarded, as well as after.
*/
static inline int http_uri_rewind(const struct http_msg *msg)
{
return http_hdr_rewind(msg) - msg->sl.rq.u;
}
MEDIUM: http: small helpers to compute how far to rewind to find BODY and DATA http_body_rewind() returns the number of bytes to rewind before buf->p to find the message's body. It relies on http_hdr_rewind() to find the beginning and adds msg->eoh + msg->eol which are always safe. http_data_rewind() does the same to get the beginning of the data, which differs from above when a chunk is present. It uses the function above and adds msg->sol. The purpose is to centralize further ->sov changes aiming at avoiding to rely on buf->o.
2014-04-17 18:31:44 +00:00
/* Return the amount of bytes that need to be rewound before buf->p to access
* the current message's BODY. The purpose is to be able to easily fetch
* the message's beginning before headers are forwarded, as well as after.
*/
static inline int http_body_rewind(const struct http_msg *msg)
{
return http_hdr_rewind(msg) - msg->eoh - msg->eol;
}
/* Return the amount of bytes that need to be rewound before buf->p to access
* the current message's DATA. The difference with the function above is that
* if a chunk is present and has already been parsed, its size is skipped so
* that the byte pointed to is the first byte of actual data. The function is
* safe for use in state HTTP_MSG_DATA regardless of whether the headers were
* already forwarded or not.
*/
static inline int http_data_rewind(const struct http_msg *msg)
{
return http_body_rewind(msg) - msg->sol;
}
MINOR: http: add a small helper to compute the amount of body bytes present http_body_bytes() returns the number of bytes of the current message body present in the buffer. It is compatible with being called before and after the headers are forwarded. This is done to centralize further ->sov changes.
2014-04-17 18:08:17 +00:00
/* Return the maximum amount of bytes that may be read after the beginning of
* the message body, according to the advertised length. The function is safe
* for use between HTTP_MSG_BODY and HTTP_MSG_DATA regardless of whether the
* headers were already forwarded or not.
*/
static inline int http_body_bytes(const struct http_msg *msg)
{
int len;
MAJOR: http: reset msg->sov after headers are forwarded In order to avoid abusively relying on buf->o to guess how many bytes to rewind during a redispatch, we now clear msg->sov. Thus the meaning of this field is exactly "how many bytes of headers are left to be forwarded". It is still possible to rewind because msg->eoh + msg->eol equal that value before scheduling the forwarding, so we can always subtract them.
2014-04-17 19:14:47 +00:00
len = msg->chn->buf->i - msg->sov - msg->sol;
MINOR: http: add a small helper to compute the amount of body bytes present http_body_bytes() returns the number of bytes of the current message body present in the buffer. It is compatible with being called before and after the headers are forwarded. This is done to centralize further ->sov changes.
2014-04-17 18:08:17 +00:00
if (len > msg->body_len)
len = msg->body_len;
return len;
}
MINOR: actions: change actions names For performances considerations, some actions are not processed by remote function. They are directly processed by the function. Some of these actions does the same things but for different processing part (request / response). This patch give the same name for the same actions, and change the normalization of the other actions names. This patch is ONLY a rename, it doesn't modify the code.
2015-08-05 17:05:19 +00:00
/* for an http-request action ACT_HTTP_REQ_TRK_*, return a tracking index
MEDIUM: http: add the track-sc* actions to http-request rules Add support for http-request track-sc, similar to what is done in tcp-request for backends. A new act_prm field was added to HTTP request rules to store the track params (table, counter). Just like for TCP rules, the table is resolved while checking for config validity. The code was mostly copied from the TCP code with the exception that here we also count the HTTP request count and rate by hand. Probably that something could be factored out in the future. It seems like tracking flags should be improved to mark each hook which tracks a key so that we can have some check points where to increase counters of the past if not done yet, a bit like is done for TRACK_BACKEND.
2014-06-25 16:12:15 +00:00
* starting at zero for SC0. Unknown actions also return zero.
*/
static inline int http_req_trk_idx(int trk_action)
{
MINOR: actions: change actions names For performances considerations, some actions are not processed by remote function. They are directly processed by the function. Some of these actions does the same things but for different processing part (request / response). This patch give the same name for the same actions, and change the normalization of the other actions names. This patch is ONLY a rename, it doesn't modify the code.
2015-08-05 17:05:19 +00:00
return trk_action - ACT_ACTION_TRK_SC0;
MEDIUM: http: add the track-sc* actions to http-request rules Add support for http-request track-sc, similar to what is done in tcp-request for backends. A new act_prm field was added to HTTP request rules to store the track params (table, counter). Just like for TCP rules, the table is resolved while checking for config validity. The code was mostly copied from the TCP code with the exception that here we also count the HTTP request count and rate by hand. Probably that something could be factored out in the future. It seems like tracking flags should be improved to mark each hook which tracks a key so that we can have some check points where to increase counters of the past if not done yet, a bit like is done for TRACK_BACKEND.
2014-06-25 16:12:15 +00:00
}
MINOR: http: add some debugging functions to pretty-print msg state names The http_msg_state_str() function reports a string containing the name of the state passed in argument. This helps while debugging.
2012-11-21 20:50:04 +00:00
/* for debugging, reports the HTTP message state name */
static inline const char *http_msg_state_str(int msg_state)
{
switch (msg_state) {
case HTTP_MSG_RQBEFORE: return "MSG_RQBEFORE";
case HTTP_MSG_RQBEFORE_CR: return "MSG_RQBEFORE_CR";
case HTTP_MSG_RQMETH: return "MSG_RQMETH";
case HTTP_MSG_RQMETH_SP: return "MSG_RQMETH_SP";
case HTTP_MSG_RQURI: return "MSG_RQURI";
case HTTP_MSG_RQURI_SP: return "MSG_RQURI_SP";
case HTTP_MSG_RQVER: return "MSG_RQVER";
case HTTP_MSG_RQLINE_END: return "MSG_RQLINE_END";
case HTTP_MSG_RPBEFORE: return "MSG_RPBEFORE";
case HTTP_MSG_RPBEFORE_CR: return "MSG_RPBEFORE_CR";
case HTTP_MSG_RPVER: return "MSG_RPVER";
case HTTP_MSG_RPVER_SP: return "MSG_RPVER_SP";
case HTTP_MSG_RPCODE: return "MSG_RPCODE";
case HTTP_MSG_RPCODE_SP: return "MSG_RPCODE_SP";
case HTTP_MSG_RPREASON: return "MSG_RPREASON";
case HTTP_MSG_RPLINE_END: return "MSG_RPLINE_END";
case HTTP_MSG_HDR_FIRST: return "MSG_HDR_FIRST";
case HTTP_MSG_HDR_NAME: return "MSG_HDR_NAME";
case HTTP_MSG_HDR_COL: return "MSG_HDR_COL";
case HTTP_MSG_HDR_L1_SP: return "MSG_HDR_L1_SP";
case HTTP_MSG_HDR_L1_LF: return "MSG_HDR_L1_LF";
case HTTP_MSG_HDR_L1_LWS: return "MSG_HDR_L1_LWS";
case HTTP_MSG_HDR_VAL: return "MSG_HDR_VAL";
case HTTP_MSG_HDR_L2_LF: return "MSG_HDR_L2_LF";
case HTTP_MSG_HDR_L2_LWS: return "MSG_HDR_L2_LWS";
case HTTP_MSG_LAST_LF: return "MSG_LAST_LF";
case HTTP_MSG_ERROR: return "MSG_ERROR";
case HTTP_MSG_BODY: return "MSG_BODY";
case HTTP_MSG_100_SENT: return "MSG_100_SENT";
case HTTP_MSG_CHUNK_SIZE: return "MSG_CHUNK_SIZE";
case HTTP_MSG_DATA: return "MSG_DATA";
case HTTP_MSG_CHUNK_CRLF: return "MSG_CHUNK_CRLF";
case HTTP_MSG_TRAILERS: return "MSG_TRAILERS";
case HTTP_MSG_DONE: return "MSG_DONE";
case HTTP_MSG_CLOSING: return "MSG_CLOSING";
case HTTP_MSG_CLOSED: return "MSG_CLOSED";
case HTTP_MSG_TUNNEL: return "MSG_TUNNEL";
default: return "MSG_??????";
}
}
[BIGMOVE] exploded the monolithic haproxy.c file into multiple files. The files are now stored under : - include/haproxy for the generic includes - include/types.h for the structures needed within prototypes - include/proto.h for function prototypes and inline functions - src/*.c for the C files Most include files are now covered by LGPL. A last move still needs to be done to put inline functions under GPL and not LGPL. Version has been set to 1.3.0 in the code but some control still needs to be done before releasing.
2006-06-26 00:48:02 +00:00
#endif /* _PROTO_PROTO_HTTP_H */
/*
* Local variables:
* c-indent-level: 8
* c-basic-offset: 8
* End:
*/