do \
{ \
HTTP_DBG (1, "changing http req state: %U -> %U", \
- format_http_req_state, (_hc)->req_state, \
+ format_http_req_state, (_hc)->req.state, \
format_http_req_state, _state); \
- ASSERT ((_hc)->req_state != HTTP_REQ_STATE_TUNNEL); \
- (_hc)->req_state = _state; \
+ ASSERT ((_hc)->req.state != HTTP_REQ_STATE_TUNNEL); \
+ (_hc)->req.state = _state; \
} \
while (0)
hc = http_conn_get_w_thread (ts->opaque, ts->thread_index);
hc->state = HTTP_CONN_STATE_CLOSED;
- http_buffer_free (&hc->tx_buf);
+ http_buffer_free (&hc->req.tx_buf);
http_req_state_change (hc, HTTP_REQ_STATE_WAIT_TRANSPORT_METHOD);
session_transport_reset_notify (&hc->connection);
if (PREDICT_FALSE (max_deq == 0))
return -1;
- vec_validate (hc->rx_buf, max_deq - 1);
- n_read = svm_fifo_peek (ts->rx_fifo, 0, max_deq, hc->rx_buf);
+ vec_validate (hc->req.rx_buf, max_deq - 1);
+ n_read = svm_fifo_peek (ts->rx_fifo, 0, max_deq, hc->req.rx_buf);
ASSERT (n_read == max_deq);
HTTP_DBG (1, "read %u bytes from rx_fifo", n_read);
ts = session_get_from_handle (hc->h_tc_session_handle);
svm_fifo_dequeue_drop (ts->rx_fifo, len);
- vec_reset_length (hc->rx_buf);
+ vec_reset_length (hc->req.rx_buf);
if (svm_fifo_is_empty (ts->rx_fifo))
svm_fifo_unset_event (ts->rx_fifo);
ts = session_get_from_handle (hc->h_tc_session_handle);
svm_fifo_dequeue_drop_all (ts->rx_fifo);
- vec_reset_length (hc->rx_buf);
+ vec_reset_length (hc->req.rx_buf);
if (svm_fifo_is_empty (ts->rx_fifo))
svm_fifo_unset_event (ts->rx_fifo);
}
static void
-http_identify_optional_query (http_conn_t *hc)
+http_identify_optional_query (http_req_t *req)
{
int i;
- for (i = hc->target_path_offset;
- i < (hc->target_path_offset + hc->target_path_len); i++)
+ for (i = req->target_path_offset;
+ i < (req->target_path_offset + req->target_path_len); i++)
{
- if (hc->rx_buf[i] == '?')
+ if (req->rx_buf[i] == '?')
{
- hc->target_query_offset = i + 1;
- hc->target_query_len = hc->target_path_offset + hc->target_path_len -
- hc->target_query_offset;
- hc->target_path_len = hc->target_path_len - hc->target_query_len - 1;
+ req->target_query_offset = i + 1;
+ req->target_query_len = req->target_path_offset +
+ req->target_path_len -
+ req->target_query_offset;
+ req->target_path_len =
+ req->target_path_len - req->target_query_len - 1;
break;
}
}
}
static int
-http_get_target_form (http_conn_t *hc)
+http_get_target_form (http_req_t *req)
{
int i;
/* "*" */
- if ((hc->rx_buf[hc->target_path_offset] == '*') &&
- (hc->target_path_len == 1))
+ if ((req->rx_buf[req->target_path_offset] == '*') &&
+ (req->target_path_len == 1))
{
- hc->target_form = HTTP_TARGET_ASTERISK_FORM;
+ req->target_form = HTTP_TARGET_ASTERISK_FORM;
return 0;
}
/* 1*( "/" segment ) [ "?" query ] */
- if (hc->rx_buf[hc->target_path_offset] == '/')
+ if (req->rx_buf[req->target_path_offset] == '/')
{
/* drop leading slash */
- hc->target_path_len--;
- hc->target_path_offset++;
- hc->target_form = HTTP_TARGET_ORIGIN_FORM;
- http_identify_optional_query (hc);
+ req->target_path_len--;
+ req->target_path_offset++;
+ req->target_form = HTTP_TARGET_ORIGIN_FORM;
+ http_identify_optional_query (req);
return 0;
}
/* scheme "://" host [ ":" port ] *( "/" segment ) [ "?" query ] */
- i = v_find_index (hc->rx_buf, hc->target_path_offset, hc->target_path_len,
+ i = v_find_index (req->rx_buf, req->target_path_offset, req->target_path_len,
"://");
if (i > 0)
{
- hc->target_form = HTTP_TARGET_ABSOLUTE_FORM;
- http_identify_optional_query (hc);
+ req->target_form = HTTP_TARGET_ABSOLUTE_FORM;
+ http_identify_optional_query (req);
return 0;
}
/* host ":" port */
- for (i = hc->target_path_offset;
- i < (hc->target_path_offset + hc->target_path_len); i++)
+ for (i = req->target_path_offset;
+ i < (req->target_path_offset + req->target_path_len); i++)
{
- if ((hc->rx_buf[i] == ':') && (isdigit (hc->rx_buf[i + 1])))
+ if ((req->rx_buf[i] == ':') && (isdigit (req->rx_buf[i + 1])))
{
- hc->target_form = HTTP_TARGET_AUTHORITY_FORM;
+ req->target_form = HTTP_TARGET_AUTHORITY_FORM;
return 0;
}
}
}
static int
-http_parse_request_line (http_conn_t *hc, http_status_code_t *ec)
+http_parse_request_line (http_req_t *req, http_status_code_t *ec)
{
int i, target_len;
u32 next_line_offset, method_offset;
/* request-line = method SP request-target SP HTTP-version CRLF */
- i = v_find_index (hc->rx_buf, 8, 0, "\r\n");
+ i = v_find_index (req->rx_buf, 8, 0, "\r\n");
if (i < 0)
{
clib_warning ("request line incomplete");
return -1;
}
HTTP_DBG (2, "request line length: %d", i);
- hc->control_data_len = i + 2;
- next_line_offset = hc->control_data_len;
+ req->control_data_len = i + 2;
+ next_line_offset = req->control_data_len;
/* there should be at least one more CRLF */
- if (vec_len (hc->rx_buf) < (next_line_offset + 2))
+ if (vec_len (req->rx_buf) < (next_line_offset + 2))
{
clib_warning ("malformed message, too short");
*ec = HTTP_STATUS_BAD_REQUEST;
* parse a request-line SHOULD ignore at least one empty line (CRLF)
* received prior to the request-line.
*/
- method_offset = hc->rx_buf[0] == '\r' && hc->rx_buf[1] == '\n' ? 2 : 0;
+ method_offset = req->rx_buf[0] == '\r' && req->rx_buf[1] == '\n' ? 2 : 0;
/* parse method */
- if (!memcmp (hc->rx_buf + method_offset, "GET ", 4))
+ if (!memcmp (req->rx_buf + method_offset, "GET ", 4))
{
HTTP_DBG (0, "GET method");
- hc->method = HTTP_REQ_GET;
- hc->target_path_offset = method_offset + 4;
+ req->method = HTTP_REQ_GET;
+ req->target_path_offset = method_offset + 4;
}
- else if (!memcmp (hc->rx_buf + method_offset, "POST ", 5))
+ else if (!memcmp (req->rx_buf + method_offset, "POST ", 5))
{
HTTP_DBG (0, "POST method");
- hc->method = HTTP_REQ_POST;
- hc->target_path_offset = method_offset + 5;
+ req->method = HTTP_REQ_POST;
+ req->target_path_offset = method_offset + 5;
}
- else if (!memcmp (hc->rx_buf + method_offset, "CONNECT ", 8))
+ else if (!memcmp (req->rx_buf + method_offset, "CONNECT ", 8))
{
HTTP_DBG (0, "CONNECT method");
- hc->method = HTTP_REQ_CONNECT;
- hc->target_path_offset = method_offset + 8;
- hc->is_tunnel = 1;
+ req->method = HTTP_REQ_CONNECT;
+ req->target_path_offset = method_offset + 8;
+ req->is_tunnel = 1;
}
else
{
- if (hc->rx_buf[method_offset] - 'A' <= 'Z' - 'A')
+ if (req->rx_buf[method_offset] - 'A' <= 'Z' - 'A')
{
- clib_warning ("method not implemented: %8v", hc->rx_buf);
+ clib_warning ("method not implemented: %8v", req->rx_buf);
*ec = HTTP_STATUS_NOT_IMPLEMENTED;
return -1;
}
else
{
- clib_warning ("not method name: %8v", hc->rx_buf);
+ clib_warning ("not method name: %8v", req->rx_buf);
*ec = HTTP_STATUS_BAD_REQUEST;
return -1;
}
}
/* find version */
- i = v_find_index (hc->rx_buf, next_line_offset - 11, 11, " HTTP/");
+ i = v_find_index (req->rx_buf, next_line_offset - 11, 11, " HTTP/");
if (i < 0)
{
clib_warning ("HTTP version not present");
return -1;
}
/* verify major version */
- if (isdigit (hc->rx_buf[i + 6]))
+ if (isdigit (req->rx_buf[i + 6]))
{
- if (hc->rx_buf[i + 6] != '1')
+ if (req->rx_buf[i + 6] != '1')
{
clib_warning ("HTTP major version '%c' not supported",
- hc->rx_buf[i + 6]);
+ req->rx_buf[i + 6]);
*ec = HTTP_STATUS_HTTP_VERSION_NOT_SUPPORTED;
return -1;
}
}
else
{
- clib_warning ("HTTP major version '%c' is not digit", hc->rx_buf[i + 6]);
+ clib_warning ("HTTP major version '%c' is not digit",
+ req->rx_buf[i + 6]);
*ec = HTTP_STATUS_BAD_REQUEST;
return -1;
}
/* parse request-target */
HTTP_DBG (2, "http at %d", i);
- target_len = i - hc->target_path_offset;
+ target_len = i - req->target_path_offset;
HTTP_DBG (2, "target_len %d", target_len);
if (target_len < 1)
{
*ec = HTTP_STATUS_BAD_REQUEST;
return -1;
}
- hc->target_path_len = target_len;
- hc->target_query_offset = 0;
- hc->target_query_len = 0;
- if (http_get_target_form (hc))
+ req->target_path_len = target_len;
+ req->target_query_offset = 0;
+ req->target_query_len = 0;
+ if (http_get_target_form (req))
{
clib_warning ("invalid target");
*ec = HTTP_STATUS_BAD_REQUEST;
return -1;
}
- HTTP_DBG (2, "request-target path length: %u", hc->target_path_len);
- HTTP_DBG (2, "request-target path offset: %u", hc->target_path_offset);
- HTTP_DBG (2, "request-target query length: %u", hc->target_query_len);
- HTTP_DBG (2, "request-target query offset: %u", hc->target_query_offset);
+ HTTP_DBG (2, "request-target path length: %u", req->target_path_len);
+ HTTP_DBG (2, "request-target path offset: %u", req->target_path_offset);
+ HTTP_DBG (2, "request-target query length: %u", req->target_query_len);
+ HTTP_DBG (2, "request-target query offset: %u", req->target_query_offset);
/* set buffer offset to nex line start */
- hc->rx_buf_offset = next_line_offset;
+ req->rx_buf_offset = next_line_offset;
return 0;
}
while (0)
static int
-http_parse_status_line (http_conn_t *hc)
+http_parse_status_line (http_req_t *req)
{
int i;
u32 next_line_offset;
u8 *p, *end;
u16 status_code = 0;
+ http_main_t *hm = &http_main;
- i = v_find_index (hc->rx_buf, 0, 0, "\r\n");
+ i = v_find_index (req->rx_buf, 0, 0, "\r\n");
/* status-line = HTTP-version SP status-code SP [ reason-phrase ] CRLF */
if (i < 0)
{
clib_warning ("status line too short (%d)", i);
return -1;
}
- hc->control_data_len = i + 2;
- next_line_offset = hc->control_data_len;
- p = hc->rx_buf;
- end = hc->rx_buf + i;
+ req->control_data_len = i + 2;
+ next_line_offset = req->control_data_len;
+ p = req->rx_buf;
+ end = req->rx_buf + i;
/* there should be at least one more CRLF */
- if (vec_len (hc->rx_buf) < (next_line_offset + 2))
+ if (vec_len (req->rx_buf) < (next_line_offset + 2))
{
clib_warning ("malformed message, too short");
return -1;
clib_warning ("invalid status code %d", status_code);
return -1;
}
- hc->status_code = status_code;
- HTTP_DBG (0, "status code: %d", hc->status_code);
+ req->status_code = hm->sc_by_u16[status_code];
+ HTTP_DBG (0, "status code: %d", status_code);
/* set buffer offset to nex line start */
- hc->rx_buf_offset = next_line_offset;
+ req->rx_buf_offset = next_line_offset;
return 0;
}
static int
-http_identify_headers (http_conn_t *hc, http_status_code_t *ec)
+http_identify_headers (http_req_t *req, http_status_code_t *ec)
{
int i;
/* check if we have any header */
- if ((hc->rx_buf[hc->rx_buf_offset] == '\r') &&
- (hc->rx_buf[hc->rx_buf_offset + 1] == '\n'))
+ if ((req->rx_buf[req->rx_buf_offset] == '\r') &&
+ (req->rx_buf[req->rx_buf_offset + 1] == '\n'))
{
/* just another CRLF -> no headers */
HTTP_DBG (2, "no headers");
- hc->headers_len = 0;
- hc->control_data_len += 2;
+ req->headers_len = 0;
+ req->control_data_len += 2;
return 0;
}
/* find empty line indicating end of header section */
- i = v_find_index (hc->rx_buf, hc->rx_buf_offset, 0, "\r\n\r\n");
+ i = v_find_index (req->rx_buf, req->rx_buf_offset, 0, "\r\n\r\n");
if (i < 0)
{
clib_warning ("cannot find header section end");
*ec = HTTP_STATUS_BAD_REQUEST;
return -1;
}
- hc->headers_offset = hc->rx_buf_offset;
- hc->headers_len = i - hc->rx_buf_offset + 2;
- hc->control_data_len += (hc->headers_len + 2);
- HTTP_DBG (2, "headers length: %u", hc->headers_len);
- HTTP_DBG (2, "headers offset: %u", hc->headers_offset);
+ req->headers_offset = req->rx_buf_offset;
+ req->headers_len = i - req->rx_buf_offset + 2;
+ req->control_data_len += (req->headers_len + 2);
+ HTTP_DBG (2, "headers length: %u", req->headers_len);
+ HTTP_DBG (2, "headers offset: %u", req->headers_offset);
return 0;
}
static int
-http_identify_message_body (http_conn_t *hc, http_status_code_t *ec)
+http_identify_message_body (http_req_t *req, http_status_code_t *ec)
{
int i, value_len;
u8 *end, *p, *value_start;
u64 body_len = 0, digit;
- hc->body_len = 0;
+ req->body_len = 0;
- if (hc->headers_len == 0)
+ if (req->headers_len == 0)
{
HTTP_DBG (2, "no header, no message-body");
return 0;
}
- if (hc->is_tunnel)
+ if (req->is_tunnel)
{
HTTP_DBG (2, "tunnel, no message-body");
return 0;
/* TODO check for chunked transfer coding */
/* try to find Content-Length header */
- i = v_find_index (hc->rx_buf, hc->headers_offset, hc->headers_len,
+ i = v_find_index (req->rx_buf, req->headers_offset, req->headers_len,
"Content-Length:");
if (i < 0)
{
HTTP_DBG (2, "Content-Length header not present, no message-body");
return 0;
}
- hc->rx_buf_offset = i + 15;
+ req->rx_buf_offset = i + 15;
- i = v_find_index (hc->rx_buf, hc->rx_buf_offset, hc->headers_len, "\r\n");
+ i = v_find_index (req->rx_buf, req->rx_buf_offset, req->headers_len, "\r\n");
if (i < 0)
{
clib_warning ("end of line missing");
*ec = HTTP_STATUS_BAD_REQUEST;
return -1;
}
- value_len = i - hc->rx_buf_offset;
+ value_len = i - req->rx_buf_offset;
if (value_len < 1)
{
clib_warning ("invalid header, content length value missing");
return -1;
}
- end = hc->rx_buf + hc->rx_buf_offset + value_len;
- p = hc->rx_buf + hc->rx_buf_offset;
+ end = req->rx_buf + req->rx_buf_offset + value_len;
+ p = req->rx_buf + req->rx_buf_offset;
/* skip leading whitespace */
while (1)
{
p++;
}
- hc->body_len = body_len;
+ req->body_len = body_len;
- hc->body_offset = hc->headers_offset + hc->headers_len + 2;
- HTTP_DBG (2, "body length: %llu", hc->body_len);
- HTTP_DBG (2, "body offset: %u", hc->body_offset);
+ req->body_offset = req->headers_offset + req->headers_len + 2;
+ HTTP_DBG (2, "body length: %llu", req->body_len);
+ HTTP_DBG (2, "body offset: %u", req->body_offset);
return 0;
}
session_t *as;
u32 len, max_enq, body_sent;
http_status_code_t ec;
- http_main_t *hm = &http_main;
rv = http_read_message (hc);
return HTTP_SM_STOP;
}
- HTTP_DBG (3, "%v", hc->rx_buf);
+ HTTP_DBG (3, "%v", hc->req.rx_buf);
- if (vec_len (hc->rx_buf) < 8)
+ if (vec_len (hc->req.rx_buf) < 8)
{
clib_warning ("response buffer too short");
goto error;
}
- rv = http_parse_status_line (hc);
+ rv = http_parse_status_line (&hc->req);
if (rv)
goto error;
- rv = http_identify_headers (hc, &ec);
+ rv = http_identify_headers (&hc->req, &ec);
if (rv)
goto error;
- rv = http_identify_message_body (hc, &ec);
+ rv = http_identify_message_body (&hc->req, &ec);
if (rv)
goto error;
as = session_get_from_handle (hc->h_pa_session_handle);
max_enq = svm_fifo_max_enqueue (as->rx_fifo);
max_enq -= sizeof (msg);
- if (max_enq < hc->control_data_len)
+ if (max_enq < hc->req.control_data_len)
{
clib_warning ("not enough room for control data in app's rx fifo");
goto error;
}
- len = clib_min (max_enq, vec_len (hc->rx_buf));
+ len = clib_min (max_enq, vec_len (hc->req.rx_buf));
msg.type = HTTP_MSG_REPLY;
- msg.code = hm->sc_by_u16[hc->status_code];
- msg.data.headers_offset = hc->headers_offset;
- msg.data.headers_len = hc->headers_len;
- msg.data.body_offset = hc->body_offset;
- msg.data.body_len = hc->body_len;
+ msg.code = hc->req.status_code;
+ msg.data.headers_offset = hc->req.headers_offset;
+ msg.data.headers_len = hc->req.headers_len;
+ msg.data.body_offset = hc->req.body_offset;
+ msg.data.body_len = hc->req.body_len;
msg.data.type = HTTP_MSG_DATA_INLINE;
msg.data.len = len;
svm_fifo_seg_t segs[2] = { { (u8 *) &msg, sizeof (msg) },
- { hc->rx_buf, len } };
+ { hc->req.rx_buf, len } };
rv = svm_fifo_enqueue_segments (as->rx_fifo, segs, 2, 0 /* allow partial */);
ASSERT (rv == (sizeof (msg) + len));
http_read_message_drop (hc, len);
- body_sent = len - hc->control_data_len;
- hc->to_recv = hc->body_len - body_sent;
- if (hc->to_recv == 0)
+ body_sent = len - hc->req.control_data_len;
+ hc->req.to_recv = hc->req.body_len - body_sent;
+ if (hc->req.to_recv == 0)
{
/* all sent, we are done */
http_req_state_change (hc, HTTP_REQ_STATE_WAIT_APP_METHOD);
if (rv)
return HTTP_SM_STOP;
- HTTP_DBG (3, "%v", hc->rx_buf);
+ HTTP_DBG (3, "%v", hc->req.rx_buf);
- if (vec_len (hc->rx_buf) < 8)
+ if (vec_len (hc->req.rx_buf) < 8)
{
ec = HTTP_STATUS_BAD_REQUEST;
goto error;
}
- rv = http_parse_request_line (hc, &ec);
+ rv = http_parse_request_line (&hc->req, &ec);
if (rv)
goto error;
- rv = http_identify_headers (hc, &ec);
+ rv = http_identify_headers (&hc->req, &ec);
if (rv)
goto error;
- rv = http_identify_message_body (hc, &ec);
+ rv = http_identify_message_body (&hc->req, &ec);
if (rv)
goto error;
* if there is some space send also portion of body */
as = session_get_from_handle (hc->h_pa_session_handle);
max_enq = svm_fifo_max_enqueue (as->rx_fifo);
- if (max_enq < hc->control_data_len)
+ if (max_enq < hc->req.control_data_len)
{
clib_warning ("not enough room for control data in app's rx fifo");
ec = HTTP_STATUS_INTERNAL_ERROR;
goto error;
}
/* do not dequeue more than one HTTP request, we do not support pipelining */
- max_deq =
- clib_min (hc->control_data_len + hc->body_len, vec_len (hc->rx_buf));
+ max_deq = clib_min (hc->req.control_data_len + hc->req.body_len,
+ vec_len (hc->req.rx_buf));
len = clib_min (max_enq, max_deq);
msg.type = HTTP_MSG_REQUEST;
- msg.method_type = hc->method;
+ msg.method_type = hc->req.method;
msg.data.type = HTTP_MSG_DATA_INLINE;
msg.data.len = len;
- msg.data.target_form = hc->target_form;
- msg.data.target_path_offset = hc->target_path_offset;
- msg.data.target_path_len = hc->target_path_len;
- msg.data.target_query_offset = hc->target_query_offset;
- msg.data.target_query_len = hc->target_query_len;
- msg.data.headers_offset = hc->headers_offset;
- msg.data.headers_len = hc->headers_len;
- msg.data.body_offset = hc->body_offset;
- msg.data.body_len = hc->body_len;
+ msg.data.target_form = hc->req.target_form;
+ msg.data.target_path_offset = hc->req.target_path_offset;
+ msg.data.target_path_len = hc->req.target_path_len;
+ msg.data.target_query_offset = hc->req.target_query_offset;
+ msg.data.target_query_len = hc->req.target_query_len;
+ msg.data.headers_offset = hc->req.headers_offset;
+ msg.data.headers_len = hc->req.headers_len;
+ msg.data.body_offset = hc->req.body_offset;
+ msg.data.body_len = hc->req.body_len;
svm_fifo_seg_t segs[2] = { { (u8 *) &msg, sizeof (msg) },
- { hc->rx_buf, len } };
+ { hc->req.rx_buf, len } };
rv = svm_fifo_enqueue_segments (as->rx_fifo, segs, 2, 0 /* allow partial */);
ASSERT (rv == (sizeof (msg) + len));
- body_sent = len - hc->control_data_len;
- hc->to_recv = hc->body_len - body_sent;
- if (hc->to_recv == 0)
+ body_sent = len - hc->req.control_data_len;
+ hc->req.to_recv = hc->req.body_len - body_sent;
+ if (hc->req.to_recv == 0)
{
/* drop everything, we do not support pipelining */
http_read_message_drop_all (hc);
/* RFC9110 9.3.6: A server MUST NOT send Content-Length header field in a
* 2xx (Successful) response to CONNECT. */
- if (hc->is_tunnel && http_status_code_str[msg.code][0] == '2')
+ if (hc->req.is_tunnel && http_status_code_str[msg.code][0] == '2')
{
ASSERT (msg.data.body_len == 0);
next_state = HTTP_REQ_STATE_TUNNEL;
/* cleanup some stuff we don't need anymore in tunnel mode */
http_conn_timer_stop (hc);
- vec_free (hc->rx_buf);
- http_buffer_free (&hc->tx_buf);
+ vec_free (hc->req.rx_buf);
+ http_buffer_free (&hc->req.tx_buf);
}
else
response = format (response, content_len_template, msg.data.body_len);
if (msg.data.body_len)
{
/* Start sending the actual data */
- http_buffer_init (&hc->tx_buf, msg_to_buf_type[msg.data.type],
+ http_buffer_init (&hc->req.tx_buf, msg_to_buf_type[msg.data.type],
as->tx_fifo, msg.data.body_len);
next_state = HTTP_REQ_STATE_APP_IO_MORE_DATA;
sm_result = HTTP_SM_CONTINUE;
/* Any headers from app? */
msg.data.headers_len ? "" : "\r\n");
- http_buffer_init (&hc->tx_buf, msg_to_buf_type[msg.data.type],
+ http_buffer_init (&hc->req.tx_buf, msg_to_buf_type[msg.data.type],
as->tx_fifo, msg.data.body_len);
next_state = HTTP_REQ_STATE_APP_IO_MORE_DATA;
}
svm_fifo_dequeue_drop (ts->rx_fifo, rv);
- if (rv > hc->to_recv)
+ if (rv > hc->req.to_recv)
{
clib_warning ("http protocol error: received more data than expected");
session_transport_closing_notify (&hc->connection);
http_req_state_change (hc, HTTP_REQ_STATE_WAIT_APP_METHOD);
return HTTP_SM_ERROR;
}
- hc->to_recv -= rv;
- HTTP_DBG (1, "drained %d from ts; remains %lu", rv, hc->to_recv);
+ hc->req.to_recv -= rv;
+ HTTP_DBG (1, "drained %d from ts; remains %lu", rv, hc->req.to_recv);
/* Finished transaction:
* server back to HTTP_REQ_STATE_WAIT_APP_REPLY
* client to HTTP_REQ_STATE_WAIT_APP_METHOD */
- if (hc->to_recv == 0)
+ if (hc->req.to_recv == 0)
http_req_state_change (hc, hc->is_server ? HTTP_REQ_STATE_WAIT_APP_REPLY :
HTTP_REQ_STATE_WAIT_APP_METHOD);
http_req_state_app_io_more_data (http_conn_t *hc, transport_send_params_t *sp)
{
u32 max_send = 64 << 10, n_segs;
- http_buffer_t *hb = &hc->tx_buf;
+ http_buffer_t *hb = &hc->req.tx_buf;
svm_fifo_seg_t *seg;
session_t *ts;
int sent = 0;
http_req_state_change (hc, hc->is_server ?
HTTP_REQ_STATE_WAIT_TRANSPORT_METHOD :
HTTP_REQ_STATE_WAIT_TRANSPORT_REPLY);
- http_buffer_free (&hc->tx_buf);
+ http_buffer_free (hb);
}
return HTTP_SM_STOP;
static_always_inline int
http_req_state_is_tx_valid (http_conn_t *hc)
{
- return tx_state_funcs[hc->req_state] ? 1 : 0;
+ return tx_state_funcs[hc->req.state] ? 1 : 0;
}
static http_sm_handler rx_state_funcs[HTTP_REQ_N_STATES] = {
static_always_inline int
http_req_state_is_rx_valid (http_conn_t *hc)
{
- return rx_state_funcs[hc->req_state] ? 1 : 0;
+ return rx_state_funcs[hc->req.state] ? 1 : 0;
}
static_always_inline void
do
{
if (is_tx)
- res = tx_state_funcs[hc->req_state](hc, sp);
+ res = tx_state_funcs[hc->req.state](hc, sp);
else
- res = rx_state_funcs[hc->req_state](hc, sp);
+ res = rx_state_funcs[hc->req.state](hc, sp);
if (res == HTTP_SM_ERROR)
{
HTTP_DBG (1, "error in state machine %d", res);
clib_warning ("hc [%u]%x invalid rx state: http req state "
"'%U', session state '%U'",
ts->thread_index, ts->opaque, format_http_req_state,
- hc->req_state, format_http_conn_state, hc);
+ hc->req.state, format_http_conn_state, hc);
svm_fifo_dequeue_drop_all (ts->rx_fifo);
return 0;
}
HTTP_DBG (1, "going to free hc [%u]%x", ts->thread_index, ts->opaque);
- vec_free (hc->rx_buf);
+ vec_free (hc->req.rx_buf);
- http_buffer_free (&hc->tx_buf);
+ http_buffer_free (&hc->req.tx_buf);
if (hc->pending_timer == 0)
http_conn_timer_stop (hc);
clib_warning ("hc [%u]%x invalid tx state: http req state "
"'%U', session state '%U'",
as->thread_index, as->connection_index,
- format_http_req_state, hc->req_state,
+ format_http_req_state, hc->req.state,
format_http_conn_state, hc);
svm_fifo_dequeue_drop_all (as->tx_fifo);
return 0;
http_conn_t *hc = (http_conn_t *) tc;
HTTP_DBG (1, "hc [%u]%x", vlib_get_thread_index (), hc->h_hc_index);
- if (hc->req_state == HTTP_REQ_STATE_TUNNEL)
+ if (hc->req.state == HTTP_REQ_STATE_TUNNEL)
http_req_state_tunnel_rx (hc, 0);
return 0;
Code Review / vpp.git / commitdiff