RepoMirrors/haproxy
1
0
Fork 0
mirror of http://git.haproxy.org/git/haproxy.git/ synced 2025-04-01 22:48:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

[CLEANUP] renamed several HTTP structures

Browse Source 
Some parts of HTTP processing were incorrectly called "request" while
they are messages or transactions. The following structure members
have changed :

  http_msg.hdr_state => msg_state
  http_msg.sor => som
  http_req.req_state => removed
  http_req => http_txn
This commit is contained in:
Willy Tarreau 2007-03-03 13:54:32 +01:00
parent 244b47beef
commit b326fcc46a
6 changed files with 67 additions and 68 deletions

20
doc/internals/http-parsing.txt
View File

@ -223,17 +223,17 @@ the recipient and MUST be forwarded by transparent proxies.
without optimal support for HTTP pipelining will have the client buffers tied
to the http_session. It may be possible that it is not sufficient for full
pipelining, but this will need further study. The link from the buffers to
the backend should be managed by the http_request, provided that they are
serialized. Each http_session, has 0 to N http_requests. Each http_request
belongs to one and only one http_session.
the backend should be managed by the http transaction (http_txn), provided
that they are serialized. Each http_session, has 0 to N http_txn. Each
http_txn belongs to one and only one http_session.
- each http_request has 1 request message, and 0 or 1 response message. Each of
them has 1 and only one http_request. An http_request holds informations such
as the HTTP method, the URI, the HTTP version, the transfer-encoding, the
HTTP status, the authorization, the req and resp content-length, the timers,
logs, etc... The backend and server which process the request are also known
from the http_request.
- each http_txn has 1 request message (http_req), and 0 or 1 response message
(http_rtr). Each of them has 1 and only one http_txn. An http_txn holds
informations such as the HTTP method, the URI, the HTTP version, the
transfer-encoding, the HTTP status, the authorization, the req and rtr
content-length, the timers, logs, etc... The backend and server which process
the request are also known from the http_txn.
- both request and response messages hold header and parsing informations, such
as the parsing state, start of headers, start of request, captures, etc...
as the parsing state, start of headers, start of message, captures, etc...

19
include/types/session.h
View File

@ -123,7 +123,7 @@ typedef enum {
* The values there are a little bit obscure, because their meaning can change
* during the parsing :
*
* - sor (Start of Request) : relative offset in the buffer of first byte of
* - som (Start of Message) : relative offset in the buffer of first byte of
* the request being processed or parsed. Reset to
* zero during accept().
* - eoh (End of Headers) : relative offset in the buffer of first byte that
@ -134,33 +134,32 @@ typedef enum {
* which marks the end of the line (LF or CRLF).
*/
struct http_msg {
int hdr_state; /* where we are in the current header parsing */
int msg_state; /* where we are in the current message parsing */
char *sol, *eol; /* start of line, end of line */
int sor; /* Start Of Request, relative to buffer */
int som; /* Start Of Message, relative to buffer */
int col, sov; /* current header: colon, start of value */
int eoh; /* End Of Headers, relative to buffer */
char **cap; /* array of captured headers (may be NULL) */
union { /* useful start line pointers, relative to buffer */
struct {
int l; /* request line length (not including CR) */
int m_l; /* METHOD length (method starts at ->sor) */
int m_l; /* METHOD length (method starts at ->som) */
int u, u_l; /* URI, length */
int v, v_l; /* VERSION, length */
} rq; /* request line : field, length */
struct {
int l; /* status line length (not including CR) */
int v_l; /* VERSION length (version starts at ->sor) */
int v_l; /* VERSION length (version starts at ->som) */
int c, c_l; /* CODE, length */
int r, r_l; /* REASON, length */
} st; /* status line : field, length */
} sl; /* start line */
};
/* This is an HTTP request, as described in RFC2616. It contains both a request
* message and a response message (which can be empty).
/* This is an HTTP transaction. It contains both a request message and a
* response message (which can be empty).
*/
struct http_req {
int req_state; /* what we are currently parsing */
struct http_txn {
http_meth_t meth; /* HTTP method */
struct hdr_idx hdr_idx; /* array of header indexes (max: MAX_HTTP_HDR) */
struct chunk auth_hdr; /* points to 'Authorization:' header */
@ -187,7 +186,7 @@ struct session {
struct sockaddr_in srv_addr; /* the address to connect to */
struct server *srv; /* the server being used */
struct pendconn *pend_pos; /* if not NULL, points to the position in the pending queue */
struct http_req hreq; /* current HTTP request being processed. Should become a list. */
struct http_txn txn; /* current HTTP transaction being processed. Should become a list. */
struct {
int logwait; /* log fields waiting to be collected : LW_* */
struct timeval tv_accept; /* date of the accept() (beginning of the session) */

8
src/client.c
View File

@ -56,7 +56,7 @@
int event_accept(int fd) {
struct proxy *p = (struct proxy *)fdtab[fd].owner;
struct session *s;
struct http_req *hreq;
struct http_txn *hreq;
struct task *t;
int cfd;
int max_accept;
@ -198,16 +198,16 @@ int event_accept(int fd) {
s->uniq_id = totalconn;
p->cum_feconn++; /* cum_beconn will be increased once assigned */
hreq = &s->hreq;
hreq = &s->txn;
hreq->req.cap = NULL;
hreq->rsp.cap = NULL;
hreq->hdr_idx.v = NULL;
hreq->hdr_idx.size = hreq->hdr_idx.used = 0;
if (p->mode == PR_MODE_HTTP) {
hreq->req.hdr_state = HTTP_MSG_RQBEFORE; /* at the very beginning of the request */
hreq->req.msg_state = HTTP_MSG_RQBEFORE; /* at the very beginning of the request */
hreq->req.sol = hreq->req.eol = NULL;
hreq->req.sor = hreq->req.eoh = 0; /* relative to the buffer */
hreq->req.som = hreq->req.eoh = 0; /* relative to the buffer */
hreq->auth_hdr.len = -1;
hreq->hdr_idx.size = MAX_HTTP_HDR;

2
src/log.c
View File

@ -294,7 +294,7 @@ void sess_log(struct session *s)
struct proxy *fe = s->fe;
struct proxy *be = s->be;
struct proxy *prx_log;
struct http_req *hreq = &s->hreq;
struct http_txn *hreq = &s->txn;
int log, tolog;
char *uri;
char *pxid;

84
src/proto_http.c
View File

@ -544,7 +544,7 @@ const char *http_parse_rspline(struct http_msg *msg, const char *msg_buf, int st
EAT_AND_JUMP_OR_RETURN(http_msg_rpver, HTTP_MSG_RPVER);
if (likely(HTTP_IS_SPHT(*ptr))) {
msg->sl.st.v_l = (ptr - msg_buf) - msg->sor;
msg->sl.st.v_l = (ptr - msg_buf) - msg->som;
EAT_AND_JUMP_OR_RETURN(http_msg_rpver_sp, HTTP_MSG_RPVER_SP);
}
goto http_msg_invalid;
@ -667,13 +667,13 @@ const char *http_parse_reqline(struct http_msg *msg, const char *msg_buf, int st
EAT_AND_JUMP_OR_RETURN(http_msg_rqmeth, HTTP_MSG_RQMETH);
if (likely(HTTP_IS_SPHT(*ptr))) {
msg->sl.rq.m_l = (ptr - msg_buf) - msg->sor;
msg->sl.rq.m_l = (ptr - msg_buf) - msg->som;
EAT_AND_JUMP_OR_RETURN(http_msg_rqmeth_sp, HTTP_MSG_RQMETH_SP);
}
if (likely(HTTP_IS_CRLF(*ptr))) {
/* HTTP 0.9 request */
msg->sl.rq.m_l = (ptr - msg_buf) - msg->sor;
msg->sl.rq.m_l = (ptr - msg_buf) - msg->som;
http_msg_req09_uri:
msg->sl.rq.u = ptr - msg_buf;
http_msg_req09_uri_e:
@ -760,7 +760,7 @@ const char *http_parse_reqline(struct http_msg *msg, const char *msg_buf, int st
/*
* This function parses an HTTP message, either a request or a response,
* depending on the initial msg->hdr_state. It can be preempted everywhere
* depending on the initial msg->msg_state. It can be preempted everywhere
* when data are missing and recalled at the exact same location with no
* information loss. The header index is re-initialized when switching from
* MSG_R[PQ]BEFORE to MSG_RPVER|MSG_RQMETH.
@ -788,7 +788,7 @@ void http_msg_analyzer(struct buffer *buf, struct http_msg *msg, struct hdr_idx
int state; /* updated only when leaving the FSM */
register char *ptr, *end; /* request pointers, to avoid dereferences */
state = msg->hdr_state;
state = msg->msg_state;
ptr = buf->lr;
end = buf->r;
@ -806,12 +806,12 @@ void http_msg_analyzer(struct buffer *buf, struct http_msg *msg, struct hdr_idx
if (likely(HTTP_IS_TOKEN(*ptr))) {
if (likely(ptr == buf->data)) {
msg->sol = ptr;
msg->sor = 0;
msg->som = 0;
} else {
#if PARSE_PRESERVE_EMPTY_LINES
/* only skip empty leading lines, don't remove them */
msg->sol = ptr;
msg->sor = ptr - buf->data;
msg->som = ptr - buf->data;
#else
/* Remove empty leading lines, as recommended by
* RFC2616. This takes a lot of time because we
@ -822,7 +822,7 @@ void http_msg_analyzer(struct buffer *buf, struct http_msg *msg, struct hdr_idx
*/
buf->lr = ptr;
buffer_replace2(buf, buf->data, buf->lr, NULL, 0);
msg->sor = 0;
msg->som = 0;
msg->sol = buf->data;
ptr = buf->data;
end = buf->r;
@ -854,14 +854,14 @@ void http_msg_analyzer(struct buffer *buf, struct http_msg *msg, struct hdr_idx
case HTTP_MSG_RPCODE_SP:
case HTTP_MSG_RPREASON:
ptr = (char *)http_parse_rspline(msg, buf->data, state, ptr, end,
&buf->lr, &msg->hdr_state);
&buf->lr, &msg->msg_state);
if (unlikely(!ptr))
return;
/* we have a full response and we know that we have either a CR
* or an LF at <ptr>.
*/
//fprintf(stderr,"sor=%d rq.l=%d *ptr=0x%02x\n", msg->sor, msg->sl.st.l, *ptr);
//fprintf(stderr,"som=%d rq.l=%d *ptr=0x%02x\n", msg->som, msg->sl.st.l, *ptr);
hdr_idx_set_start(idx, msg->sl.st.l, *ptr == '\r');
msg->sol = ptr;
@ -884,12 +884,12 @@ void http_msg_analyzer(struct buffer *buf, struct http_msg *msg, struct hdr_idx
if (likely(HTTP_IS_TOKEN(*ptr))) {
if (likely(ptr == buf->data)) {
msg->sol = ptr;
msg->sor = 0;
msg->som = 0;
} else {
#if PARSE_PRESERVE_EMPTY_LINES
/* only skip empty leading lines, don't remove them */
msg->sol = ptr;
msg->sor = ptr - buf->data;
msg->som = ptr - buf->data;
#else
/* Remove empty leading lines, as recommended by
* RFC2616. This takes a lot of time because we
@ -900,7 +900,7 @@ void http_msg_analyzer(struct buffer *buf, struct http_msg *msg, struct hdr_idx
*/
buf->lr = ptr;
buffer_replace2(buf, buf->data, buf->lr, NULL, 0);
msg->sor = 0;
msg->som = 0;
msg->sol = buf->data;
ptr = buf->data;
end = buf->r;
@ -934,14 +934,14 @@ void http_msg_analyzer(struct buffer *buf, struct http_msg *msg, struct hdr_idx
case HTTP_MSG_RQURI_SP:
case HTTP_MSG_RQVER:
ptr = (char *)http_parse_reqline(msg, buf->data, state, ptr, end,
&buf->lr, &msg->hdr_state);
&buf->lr, &msg->msg_state);
if (unlikely(!ptr))
return;
/* we have a full request and we know that we have either a CR
* or an LF at <ptr>.
*/
//fprintf(stderr,"sor=%d rq.l=%d *ptr=0x%02x\n", msg->sor, msg->sl.rq.l, *ptr);
//fprintf(stderr,"som=%d rq.l=%d *ptr=0x%02x\n", msg->som, msg->sl.rq.l, *ptr);
hdr_idx_set_start(idx, msg->sl.rq.l, *ptr == '\r');
msg->sol = ptr;
@ -1086,7 +1086,7 @@ void http_msg_analyzer(struct buffer *buf, struct http_msg *msg, struct hdr_idx
ptr++;
buf->lr = ptr;
msg->eoh = msg->sol - buf->data;
msg->hdr_state = HTTP_MSG_BODY;
msg->msg_state = HTTP_MSG_BODY;
return;
#ifdef DEBUG_FULL
default:
@ -1096,13 +1096,13 @@ void http_msg_analyzer(struct buffer *buf, struct http_msg *msg, struct hdr_idx
}
http_msg_ood:
/* out of data */
msg->hdr_state = state;
msg->msg_state = state;
buf->lr = ptr;
return;
http_msg_invalid:
/* invalid message */
msg->hdr_state = HTTP_MSG_ERROR;
msg->msg_state = HTTP_MSG_ERROR;
return;
}
@ -1144,7 +1144,7 @@ int process_cli(struct session *t)
* has to process at req->lr.
*
* Here is the information we currently have :
* req->data + req->sor = beginning of request
* req->data + req->som = beginning of request
* req->data + req->eoh = end of processed headers / start of current one
* req->data + req->eol = end of current header or line (LF or CRLF)
* req->lr = first non-visited byte
@ -1152,7 +1152,7 @@ int process_cli(struct session *t)
*/
int cur_idx;
struct http_req *hreq = &t->hreq;
struct http_txn *hreq = &t->txn;
struct http_msg *msg = &hreq->req;
struct proxy *cur_proxy;
@ -1162,10 +1162,10 @@ int process_cli(struct session *t)
/* 1: we might have to print this header in debug mode */
if (unlikely((global.mode & MODE_DEBUG) &&
(!(global.mode & MODE_QUIET) || (global.mode & MODE_VERBOSE)) &&
(msg->hdr_state == HTTP_MSG_BODY || msg->hdr_state == HTTP_MSG_ERROR))) {
(msg->msg_state == HTTP_MSG_BODY || msg->msg_state == HTTP_MSG_ERROR))) {
char *eol, *sol;
sol = req->data + msg->sor;
sol = req->data + msg->som;
eol = sol + msg->sl.rq.l;
debug_hdr("clireq", t, sol, eol);
@ -1190,11 +1190,11 @@ int process_cli(struct session *t)
*
*/
if (unlikely(msg->hdr_state != HTTP_MSG_BODY)) {
if (unlikely(msg->msg_state != HTTP_MSG_BODY)) {
/*
* First, let's catch bad requests.
*/
if (unlikely(msg->hdr_state == HTTP_MSG_ERROR))
if (unlikely(msg->msg_state == HTTP_MSG_ERROR))
goto return_bad_req;
/* 1: Since we are in header mode, if there's no space
@ -1261,7 +1261,7 @@ int process_cli(struct session *t)
/*
* 1: identify the method
*/
hreq->meth = find_http_meth(&req->data[msg->sor], msg->sl.rq.m_l);
hreq->meth = find_http_meth(&req->data[msg->som], msg->sl.rq.m_l);
/*
* 2: check if the URI matches the monitor_uri.
@ -1294,7 +1294,7 @@ int process_cli(struct session *t)
if (urilen >= REQURI_LEN)
urilen = REQURI_LEN - 1;
memcpy(t->logs.uri, &req->data[msg->sor], urilen);
memcpy(t->logs.uri, &req->data[msg->som], urilen);
t->logs.uri[urilen] = 0;
if (!(t->logs.logwait &= ~LW_REQ))
@ -1309,7 +1309,7 @@ int process_cli(struct session *t)
if (unlikely(msg->sl.rq.v_l == 0)) {
int delta;
char *cur_end;
msg->sol = req->data + msg->sor;
msg->sol = req->data + msg->som;
cur_end = msg->sol + msg->sl.rq.l;
delta = 0;
@ -1344,7 +1344,7 @@ int process_cli(struct session *t)
struct cap_hdr *h;
int len;
sol = req->data + msg->sor + hdr_idx_first_pos(&hreq->hdr_idx);
sol = req->data + msg->som + hdr_idx_first_pos(&hreq->hdr_idx);
cur_idx = hdr_idx_first_idx(&hreq->hdr_idx);
while (cur_idx) {
@ -1446,7 +1446,7 @@ int process_cli(struct session *t)
int cur_idx, old_idx, delta;
struct hdr_idx_elem *cur_hdr;
cur_next = req->data + hreq->req.sor + hdr_idx_first_pos(&hreq->hdr_idx);
cur_next = req->data + hreq->req.som + hdr_idx_first_pos(&hreq->hdr_idx);
old_idx = 0;
while ((cur_idx = hreq->hdr_idx.v[old_idx].next)) {
@ -1555,7 +1555,7 @@ int process_cli(struct session *t)
/* It needs to look into the URI */
if (t->be->beprm->appsession_name) {
get_srv_from_appsession(t, &req->data[msg->sor], msg->sl.rq.l);
get_srv_from_appsession(t, &req->data[msg->som], msg->sl.rq.l);
}
@ -1658,7 +1658,7 @@ int process_cli(struct session *t)
goto process_data;
return_bad_req: /* let's centralize all bad requests */
hreq->req.hdr_state = HTTP_MSG_ERROR;
hreq->req.msg_state = HTTP_MSG_ERROR;
t->logs.status = 400;
client_retnclose(t, error_message(t, HTTP_ERR_400));
t->fe->failed_req++;
@ -1962,7 +1962,7 @@ int process_cli(struct session *t)
*/
int process_srv(struct session *t)
{
struct http_req *hreq = &t->hreq;
struct http_txn *hreq = &t->txn;
int s = t->srv_state;
int c = t->cli_state;
struct buffer *req = t->req;
@ -3193,7 +3193,7 @@ int produce_content_stats(struct session *s)
if (!(s->flags & SN_FINST_MASK))
s->flags |= SN_FINST_R;
if (s->hreq.meth == HTTP_METH_HEAD) {
if (s->txn.meth == HTTP_METH_HEAD) {
/* that's all we return in case of HEAD request */
s->data_state = DATA_ST_FIN;
s->flags &= ~SN_SELF_GEN;
@ -3642,13 +3642,13 @@ int apply_filter_to_req_headers(struct session *t, struct buffer *req, struct hd
char term;
char *cur_ptr, *cur_end, *cur_next;
int cur_idx, old_idx, last_hdr;
struct http_req *hreq = &t->hreq;
struct http_txn *hreq = &t->txn;
struct hdr_idx_elem *cur_hdr;
int len, delta;
last_hdr = 0;
cur_next = req->data + hreq->req.sor + hdr_idx_first_pos(&hreq->hdr_idx);
cur_next = req->data + hreq->req.som + hdr_idx_first_pos(&hreq->hdr_idx);
old_idx = 0;
while (!last_hdr) {
@ -3770,7 +3770,7 @@ int apply_filter_to_req_line(struct session *t, struct buffer *req, struct hdr_e
char term;
char *cur_ptr, *cur_end;
int done;
struct http_req *hreq = &t->hreq;
struct http_txn *hreq = &t->txn;
int len, delta;
@ -3786,7 +3786,7 @@ int apply_filter_to_req_line(struct session *t, struct buffer *req, struct hdr_e
done = 0;
cur_ptr = req->data + hreq->req.sor;
cur_ptr = req->data + hreq->req.som;
cur_end = cur_ptr + hreq->req.sl.rq.l;
/* Now we have the request line between cur_ptr and cur_end */
@ -3919,7 +3919,7 @@ int apply_filters_to_request(struct session *t, struct buffer *req, struct hdr_e
*/
void manage_client_side_cookies(struct session *t, struct buffer *req)
{
struct http_req *hreq = &t->hreq;
struct http_txn *hreq = &t->txn;
char *p1, *p2, *p3, *p4;
char *del_colon, *del_cookie, *colon;
int app_cookies;
@ -3939,7 +3939,7 @@ void manage_client_side_cookies(struct session *t, struct buffer *req)
* we start with the start line.
*/
old_idx = 0;
cur_next = req->data + hreq->req.sor + hdr_idx_first_pos(&hreq->hdr_idx);
cur_next = req->data + hreq->req.som + hdr_idx_first_pos(&hreq->hdr_idx);
while ((cur_idx = hreq->hdr_idx.v[old_idx].next)) {
struct hdr_idx_elem *cur_hdr;
@ -4266,7 +4266,7 @@ void get_srv_from_appsession(struct session *t, const char *begin, int len)
char *request_line;
if (t->be->beprm->appsession_name == NULL ||
(t->hreq.meth != HTTP_METH_GET && t->hreq.meth != HTTP_METH_POST) ||
(t->txn.meth != HTTP_METH_GET && t->txn.meth != HTTP_METH_POST) ||
(request_line = memchr(begin, ';', len)) == NULL ||
((1 + t->be->beprm->appsession_name_len + 1 + t->be->beprm->appsession_len) > (begin + len - request_line)))
return;
@ -4354,7 +4354,7 @@ void get_srv_from_appsession(struct session *t, const char *begin, int len)
*/
int stats_check_uri_auth(struct session *t, struct proxy *backend)
{
struct http_req *hreq = &t->hreq;
struct http_txn *hreq = &t->txn;
struct uri_auth *uri_auth = backend->uri_auth;
struct user_auth *user;
int authenticated, cur_idx;
@ -4386,7 +4386,7 @@ int stats_check_uri_auth(struct session *t, struct proxy *backend)
/* FIXME: this should move to an earlier place */
cur_idx = 0;
h = t->req->data + hreq->req.sor + hdr_idx_first_pos(&hreq->hdr_idx);
h = t->req->data + hreq->req.som + hdr_idx_first_pos(&hreq->hdr_idx);
while ((cur_idx = hreq->hdr_idx.v[cur_idx].next)) {
int len = hreq->hdr_idx.v[cur_idx].len;
if (len > 14 &&

2
src/session.c
View File

@ -33,7 +33,7 @@ void **pool_session = NULL;
*/
void session_free(struct session *s)
{
struct http_req *hreq = &s->hreq;
struct http_txn *hreq = &s->txn;
if (s->pend_pos)
pendconn_free(s->pend_pos);