};
const char *http_content_type_str[] = {
-#define _(s, str) str,
+#define _(s, ext, str) str,
foreach_http_content_type
#undef _
};
[HTTP_MSG_DATA_PTR] = HTTP_BUFFER_PTR,
};
+u8 *
+format_http_state (u8 *s, va_list *va)
+{
+ http_state_t state = va_arg (*va, http_state_t);
+
+ switch (state)
+ {
+ case HTTP_STATE_IDLE:
+ return format (s, "idle");
+ case HTTP_STATE_WAIT_APP_METHOD:
+ return format (s, "wait app method");
+ case HTTP_STATE_WAIT_SERVER_REPLY:
+ return format (s, "wait server reply");
+ case HTTP_STATE_CLIENT_IO_MORE_DATA:
+ return format (s, "client io more data");
+ case HTTP_STATE_WAIT_CLIENT_METHOD:
+ return format (s, "wait client method");
+ case HTTP_STATE_WAIT_APP_REPLY:
+ return format (s, "wait app reply");
+ case HTTP_STATE_APP_IO_MORE_DATA:
+ return format (s, "app io more data");
+ default:
+ break;
+ }
+ return format (s, "unknown");
+}
+
+static inline void
+http_state_change (http_conn_t *hc, http_state_t state)
+{
+ HTTP_DBG (1, "changing http state %U -> %U", format_http_state,
+ hc->http_state, format_http_state, state);
+ ASSERT (hc->http_state != state);
+ hc->http_state = state;
+}
+
static inline http_worker_t *
http_worker_get (u32 thread_index)
{
http_worker_t *wrk = http_worker_get (thread_index);
http_conn_t *hc;
- pool_get_zero (wrk->conn_pool, hc);
+ pool_get_aligned_safe (wrk->conn_pool, hc, CLIB_CACHE_LINE_BYTES);
+ clib_memset (hc, 0, sizeof (*hc));
hc->c_thread_index = thread_index;
hc->h_hc_index = hc - wrk->conn_pool;
hc->h_pa_session_handle = SESSION_INVALID_HANDLE;
hc->c_flags |= TRANSPORT_CONNECTION_F_NO_LOOKUP;
hc->state = HTTP_CONN_STATE_ESTABLISHED;
- hc->http_state = HTTP_STATE_WAIT_METHOD;
+ http_state_change (hc, HTTP_STATE_WAIT_CLIENT_METHOD);
ts->session_state = SESSION_STATE_READY;
ts->opaque = hc_index;
hc->c_c_index = new_hc_index;
hc->c_flags |= TRANSPORT_CONNECTION_F_NO_LOOKUP;
hc->state = HTTP_CONN_STATE_ESTABLISHED;
- hc->http_state = HTTP_STATE_WAIT_APP;
+ http_state_change (hc, HTTP_STATE_WAIT_APP_METHOD);
ts->session_state = SESSION_STATE_READY;
ts->opaque = new_hc_index;
as->connection_index = hc->c_c_index;
as->app_wrk_index = hc->h_pa_wrk_index;
as->session_state = SESSION_STATE_READY;
+ as->opaque = hc->h_pa_app_api_ctx;
as->session_type = session_type_from_proto_and_ip (
TRANSPORT_PROTO_HTTP, session_type_is_ip4 (ts->session_type));
+ HTTP_DBG (1, "half-open hc index %d, hc index %d", ho_hc_index,
+ new_hc_index);
+
app_wrk = app_worker_get (hc->h_pa_wrk_index);
if (!app_wrk)
{
hc->state = HTTP_CONN_STATE_CLOSED;
http_buffer_free (&hc->tx_buf);
- hc->http_state = HTTP_STATE_WAIT_METHOD;
+ http_state_change (hc, HTTP_STATE_WAIT_CLIENT_METHOD);
session_transport_reset_notify (&hc->connection);
http_disconnect_transport (hc);
"Pragma: no-cache\r\n"
"Content-Length: 0\r\n\r\n";
+static const char *http_redirect_template = "HTTP/1.1 %s\r\n";
+
/**
* http response boilerplate
*/
-static const char *http_response_template = "HTTP/1.1 200 OK\r\n"
+static const char *http_response_template = "HTTP/1.1 %s\r\n"
"Date: %U GMT\r\n"
"Expires: %U GMT\r\n"
"Server: VPP Static\r\n"
"Accept: */*\r\n";
static u32
-send_data (http_conn_t *hc, u8 *data, u32 length, u32 offset)
+http_send_data (http_conn_t *hc, u8 *data, u32 length, u32 offset)
{
const u32 max_burst = 64 << 10;
session_t *ts;
}
static void
-send_error (http_conn_t *hc, http_status_code_t ec)
+http_send_error (http_conn_t *hc, http_status_code_t ec)
{
http_main_t *hm = &http_main;
u8 *data;
now = clib_timebase_now (&hm->timebase);
data = format (0, http_error_template, http_status_code_str[ec],
format_clib_timebase_time, now);
- send_data (hc, data, vec_len (data), 0);
+ http_send_data (hc, data, vec_len (data), 0);
vec_free (data);
}
static int
-read_http_message (http_conn_t *hc)
+http_read_message (http_conn_t *hc)
{
u32 max_deq, cursize;
session_t *ts;
return -1;
}
-/**
- * waiting for request method from peer - parse request method and data
- */
+static int
+http_parse_header (http_conn_t *hc, int *content_length)
+{
+ unformat_input_t input;
+ int i, len;
+ u8 *line;
+
+ i = v_find_index (hc->rx_buf, hc->rx_buf_offset, CONTENT_LEN_STR);
+ if (i < 0)
+ {
+ clib_warning ("cannot find '%s' in the header!", CONTENT_LEN_STR);
+ return -1;
+ }
+
+ hc->rx_buf_offset = i;
+
+ i = v_find_index (hc->rx_buf, hc->rx_buf_offset, "\n");
+ if (i < 0)
+ {
+ clib_warning ("end of line missing; incomplete data");
+ return -1;
+ }
+
+ len = i - hc->rx_buf_offset;
+ line = vec_new (u8, len);
+ clib_memcpy (line, hc->rx_buf + hc->rx_buf_offset, len);
+
+ unformat_init_vector (&input, line);
+ if (!unformat (&input, CONTENT_LEN_STR "%d", content_length))
+ {
+ clib_warning ("failed to unformat content length!");
+ return -1;
+ }
+ unformat_free (&input);
+
+ /* skip rest of the header */
+ hc->rx_buf_offset += len;
+ i = v_find_index (hc->rx_buf, hc->rx_buf_offset, "<html>");
+ if (i < 0)
+ {
+ clib_warning ("<html> tag not found");
+ return -1;
+ }
+ hc->rx_buf_offset = i;
+
+ return 0;
+}
+
static http_sm_result_t
-state_srv_wait_method (http_conn_t *hc, transport_send_params_t *sp)
+http_state_wait_server_reply (http_conn_t *hc, transport_send_params_t *sp)
+{
+ int i, rv, content_length;
+ http_msg_t msg = {};
+ app_worker_t *app_wrk;
+ session_t *as;
+ http_status_code_t ec;
+
+ rv = http_read_message (hc);
+
+ /* Nothing yet, wait for data or timer expire */
+ if (rv)
+ return HTTP_SM_STOP;
+
+ if (vec_len (hc->rx_buf) < 8)
+ {
+ ec = HTTP_STATUS_BAD_REQUEST;
+ goto error;
+ }
+
+ if ((i = v_find_index (hc->rx_buf, 0, "200 OK")) >= 0)
+ {
+ msg.type = HTTP_MSG_REPLY;
+ msg.content_type = HTTP_CONTENT_TEXT_HTML;
+ msg.code = HTTP_STATUS_OK;
+ msg.data.type = HTTP_MSG_DATA_INLINE;
+ msg.data.len = 0;
+
+ rv = http_parse_header (hc, &content_length);
+ if (rv)
+ {
+ clib_warning ("failed to parse http reply");
+ session_transport_closing_notify (&hc->connection);
+ http_disconnect_transport (hc);
+ return -1;
+ }
+ msg.data.len = content_length;
+ u32 dlen = vec_len (hc->rx_buf) - hc->rx_buf_offset;
+ as = session_get_from_handle (hc->h_pa_session_handle);
+ svm_fifo_seg_t segs[2] = { { (u8 *) &msg, sizeof (msg) },
+ { &hc->rx_buf[hc->rx_buf_offset], dlen } };
+
+ rv = svm_fifo_enqueue_segments (as->rx_fifo, segs, 2,
+ 0 /* allow partial */);
+ if (rv < 0)
+ {
+ clib_warning ("error enqueue");
+ return HTTP_SM_ERROR;
+ }
+
+ hc->rx_buf_offset += dlen;
+ hc->to_recv = content_length - dlen;
+
+ if (hc->rx_buf_offset == vec_len (hc->rx_buf))
+ {
+ vec_reset_length (hc->rx_buf);
+ hc->rx_buf_offset = 0;
+ }
+
+ if (hc->to_recv == 0)
+ {
+ hc->rx_buf_offset = 0;
+ vec_reset_length (hc->rx_buf);
+ http_state_change (hc, HTTP_STATE_WAIT_CLIENT_METHOD);
+ }
+ else
+ {
+ http_state_change (hc, HTTP_STATE_CLIENT_IO_MORE_DATA);
+ }
+
+ app_wrk = app_worker_get_if_valid (as->app_wrk_index);
+ app_worker_rx_notify (app_wrk, as);
+ return HTTP_SM_STOP;
+ }
+ else
+ {
+ HTTP_DBG (0, "Unknown http method %v", hc->rx_buf);
+ ec = HTTP_STATUS_METHOD_NOT_ALLOWED;
+ goto error;
+ }
+ return HTTP_SM_STOP;
+
+error:
+
+ http_send_error (hc, ec);
+ session_transport_closing_notify (&hc->connection);
+ http_disconnect_transport (hc);
+
+ return HTTP_SM_ERROR;
+}
+
+static http_sm_result_t
+http_state_wait_client_method (http_conn_t *hc, transport_send_params_t *sp)
{
http_status_code_t ec;
app_worker_t *app_wrk;
u32 len;
u8 *buf;
- rv = read_http_message (hc);
+ rv = http_read_message (hc);
/* Nothing yet, wait for data or timer expire */
if (rv)
goto error;
}
+ HTTP_DBG (0, "GET method %v", hc->rx_buf);
len = i - hc->rx_buf_offset - 1;
}
else if ((i = v_find_index (hc->rx_buf, 0, "POST ")) >= 0)
hc->method = HTTP_REQ_POST;
hc->rx_buf_offset = i + 6;
len = vec_len (hc->rx_buf) - hc->rx_buf_offset - 1;
+ HTTP_DBG (0, "POST method %v", hc->rx_buf);
}
else
{
- HTTP_DBG (0, "Unknown http method");
+ HTTP_DBG (0, "Unknown http method %v", hc->rx_buf);
ec = HTTP_STATUS_METHOD_NOT_ALLOWED;
goto error;
}
}
vec_free (hc->rx_buf);
- hc->http_state = HTTP_STATE_WAIT_APP;
+ http_state_change (hc, HTTP_STATE_WAIT_APP_REPLY);
app_wrk = app_worker_get_if_valid (as->app_wrk_index);
- app_worker_lock_and_send_event (app_wrk, as, SESSION_IO_EVT_RX);
+ if (app_wrk)
+ app_worker_rx_notify (app_wrk, as);
return HTTP_SM_STOP;
error:
- send_error (hc, ec);
+ http_send_error (hc, ec);
session_transport_closing_notify (&hc->connection);
http_disconnect_transport (hc);
return HTTP_SM_ERROR;
}
-/**
- * waiting for data from app
- */
static http_sm_result_t
-state_srv_wait_app (http_conn_t *hc, transport_send_params_t *sp)
+http_state_wait_app_reply (http_conn_t *hc, transport_send_params_t *sp)
{
http_main_t *hm = &http_main;
- http_status_code_t ec;
- http_msg_t msg;
- session_t *as;
u8 *header;
u32 offset;
f64 now;
+ session_t *as;
+ http_status_code_t sc;
+ http_msg_t msg;
int rv;
as = session_get_from_handle (hc->h_pa_session_handle);
rv = svm_fifo_dequeue (as->tx_fifo, sizeof (msg), (u8 *) &msg);
ASSERT (rv == sizeof (msg));
- if (msg.type != HTTP_MSG_REPLY || msg.data.type > HTTP_MSG_DATA_PTR)
+ if (msg.data.type > HTTP_MSG_DATA_PTR)
{
- clib_warning ("unexpected msg type from app %u", msg.type);
- ec = HTTP_STATUS_INTERNAL_ERROR;
+ clib_warning ("no data");
+ sc = HTTP_STATUS_INTERNAL_ERROR;
goto error;
}
- if (msg.code != HTTP_STATUS_OK)
+ if (msg.type != HTTP_MSG_REPLY)
{
- ec = msg.code;
+ clib_warning ("unexpected message type %d", msg.type);
+ sc = HTTP_STATUS_INTERNAL_ERROR;
goto error;
}
* - data length
*/
now = clib_timebase_now (&hm->timebase);
- header = format (0, http_response_template,
- /* Date */
- format_clib_timebase_time, now,
- /* Expires */
- format_clib_timebase_time, now + 600.0,
- /* Content type */
- http_content_type_str[msg.content_type],
- /* Length */
- msg.data.len);
-
- offset = send_data (hc, header, vec_len (header), 0);
+
+ switch (msg.code)
+ {
+ case HTTP_STATUS_OK:
+ header =
+ format (0, http_response_template, http_status_code_str[msg.code],
+ /* Date */
+ format_clib_timebase_time, now,
+ /* Expires */
+ format_clib_timebase_time, now + 600.0,
+ /* Content type */
+ http_content_type_str[msg.content_type],
+ /* Length */
+ msg.data.len);
+ break;
+ case HTTP_STATUS_MOVED:
+ header =
+ format (0, http_redirect_template, http_status_code_str[msg.code]);
+ /* Location: http(s)://new-place already queued up as data */
+ break;
+ default:
+ return HTTP_SM_ERROR;
+ }
+
+ offset = http_send_data (hc, header, vec_len (header), 0);
if (offset != vec_len (header))
{
clib_warning ("couldn't send response header!");
- ec = HTTP_STATUS_INTERNAL_ERROR;
+ sc = HTTP_STATUS_INTERNAL_ERROR;
goto error;
}
vec_free (header);
/* Start sending the actual data */
- hc->http_state = HTTP_STATE_IO_MORE_DATA;
+ http_state_change (hc, HTTP_STATE_APP_IO_MORE_DATA);
ASSERT (sp->max_burst_size >= offset);
sp->max_burst_size -= offset;
-
return HTTP_SM_CONTINUE;
error:
-
- send_error (hc, ec);
- hc->http_state = HTTP_STATE_WAIT_METHOD;
+ clib_warning ("unexpected msg type from app %u", msg.type);
+ http_send_error (hc, sc);
+ http_state_change (hc, HTTP_STATE_WAIT_CLIENT_METHOD);
session_transport_closing_notify (&hc->connection);
http_disconnect_transport (hc);
-
return HTTP_SM_STOP;
}
static http_sm_result_t
-state_srv_send_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;
- svm_fifo_seg_t *seg;
- session_t *ts;
- int sent = 0;
-
- max_send = clib_min (max_send, sp->max_burst_size);
- ts = session_get_from_handle (hc->h_tc_session_handle);
- if ((seg = http_buffer_get_segs (hb, max_send, &n_segs)))
- sent = svm_fifo_enqueue_segments (ts->tx_fifo, seg, n_segs,
- 1 /* allow partial */);
-
- if (sent > 0)
- {
- /* Ask scheduler to notify app of deq event if needed */
- sp->bytes_dequeued += http_buffer_drain (hb, sent);
- sp->max_burst_size -= sent;
- }
-
- /* Not finished sending all data */
- if (!http_buffer_is_drained (hb))
- {
- if (sent && svm_fifo_set_event (ts->tx_fifo))
- session_send_io_evt_to_thread (ts->tx_fifo, SESSION_IO_EVT_TX);
-
- if (svm_fifo_max_enqueue (ts->tx_fifo) < HTTP_FIFO_THRESH)
- {
- /* Deschedule http session and wait for deq notification if
- * underlying ts tx fifo almost full */
- svm_fifo_add_want_deq_ntf (ts->tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF);
- transport_connection_deschedule (&hc->connection);
- sp->flags |= TRANSPORT_SND_F_DESCHED;
- }
- }
- else
- {
- if (sent && svm_fifo_set_event (ts->tx_fifo))
- session_send_io_evt_to_thread (ts->tx_fifo, SESSION_IO_EVT_TX_FLUSH);
-
- /* Finished transaction, back to HTTP_STATE_WAIT_METHOD */
- hc->http_state = HTTP_STATE_WAIT_METHOD;
- http_buffer_free (&hc->tx_buf);
- }
-
- return HTTP_SM_STOP;
-}
-
-static int
-parse_http_header (http_conn_t *hc, int *content_length)
+http_state_wait_app_method (http_conn_t *hc, transport_send_params_t *sp)
{
- unformat_input_t input;
- int i, len;
- u8 *line;
-
- if ((i = v_find_index (hc->rx_buf, hc->rx_buf_offset, "200 OK") < 0))
- {
- clib_warning ("bad response code");
- return -1;
- }
-
- i = v_find_index (hc->rx_buf, hc->rx_buf_offset, CONTENT_LEN_STR);
- if (i < 0)
- {
- clib_warning ("cannot find '%s' in the header!", CONTENT_LEN_STR);
- return -1;
- }
-
- hc->rx_buf_offset = i;
+ http_status_code_t sc;
+ http_msg_t msg;
+ session_t *as;
+ u8 *buf = 0, *request;
+ u32 offset;
+ int rv;
- i = v_find_index (hc->rx_buf, hc->rx_buf_offset, "\n");
- if (i < 0)
- {
- clib_warning ("end of line missing; incomplete data");
- return -1;
- }
+ as = session_get_from_handle (hc->h_pa_session_handle);
- len = i - hc->rx_buf_offset;
- line = vec_new (u8, len);
- clib_memcpy (line, hc->rx_buf + hc->rx_buf_offset, len);
+ rv = svm_fifo_dequeue (as->tx_fifo, sizeof (msg), (u8 *) &msg);
+ ASSERT (rv == sizeof (msg));
- unformat_init_vector (&input, line);
- if (!unformat (&input, CONTENT_LEN_STR "%d", content_length))
+ if (msg.data.type > HTTP_MSG_DATA_PTR)
{
- clib_warning ("failed to unformat content length!");
- return -1;
+ clib_warning ("no data");
+ sc = HTTP_STATUS_INTERNAL_ERROR;
+ goto error;
}
- unformat_free (&input);
- /* skip rest of the header */
- hc->rx_buf_offset += len;
- i = v_find_index (hc->rx_buf, hc->rx_buf_offset, "<html>");
- if (i < 0)
+ if (msg.type != HTTP_MSG_REQUEST)
{
- clib_warning ("<html> tag not found");
- return -1;
+ clib_warning ("unexpected message type %d", msg.type);
+ sc = HTTP_STATUS_INTERNAL_ERROR;
+ goto error;
}
- hc->rx_buf_offset = i;
- return 0;
-}
+ sc = msg.code;
-static int
-state_cln_wait_method (http_conn_t *hc, transport_send_params_t *sp)
-{
- session_t *as;
- http_msg_t msg;
- app_worker_t *app_wrk;
- int rv, content_length;
-
- rv = read_http_message (hc);
- if (rv)
- return HTTP_SM_STOP;
-
- msg.type = HTTP_MSG_REPLY;
- msg.content_type = HTTP_CONTENT_TEXT_HTML;
- msg.code = HTTP_STATUS_OK;
- msg.data.type = HTTP_MSG_DATA_INLINE;
- msg.data.len = 0;
+ vec_validate (buf, msg.data.len - 1);
+ rv = svm_fifo_dequeue (as->tx_fifo, msg.data.len, buf);
+ ASSERT (rv == msg.data.len);
- rv = parse_http_header (hc, &content_length);
- if (rv)
+ request = format (0, http_request_template, buf);
+ offset = http_send_data (hc, request, vec_len (request), 0);
+ if (offset != vec_len (request))
{
- clib_warning ("failed to parse http reply");
- session_transport_closing_notify (&hc->connection);
- http_disconnect_transport (hc);
- return -1;
+ clib_warning ("sending request failed!");
+ sc = HTTP_STATUS_INTERNAL_ERROR;
+ goto error;
}
- msg.data.len = content_length;
- u32 dlen = vec_len (hc->rx_buf) - hc->rx_buf_offset;
- as = session_get_from_handle (hc->h_pa_session_handle);
- svm_fifo_seg_t segs[2] = { { (u8 *) &msg, sizeof (msg) },
- { &hc->rx_buf[hc->rx_buf_offset], dlen } };
+ http_state_change (hc, HTTP_STATE_WAIT_SERVER_REPLY);
- rv = svm_fifo_enqueue_segments (as->rx_fifo, segs, 2, 0 /* allow partial */);
- if (rv < 0)
- {
- clib_warning ("error enqueue");
- return HTTP_SM_ERROR;
- }
- hc->rx_buf_offset += dlen;
- hc->http_state = HTTP_STATE_IO_MORE_DATA;
- hc->to_recv = content_length - dlen;
-
- if (hc->rx_buf_offset == vec_len (hc->rx_buf))
- {
- vec_reset_length (hc->rx_buf);
- hc->rx_buf_offset = 0;
- }
+ vec_free (buf);
+ vec_free (request);
- if (hc->to_recv == 0)
- {
- hc->rx_buf_offset = 0;
- vec_reset_length (hc->rx_buf);
- hc->http_state = HTTP_STATE_WAIT_APP;
- }
+ return HTTP_SM_CONTINUE;
- app_wrk = app_worker_get_if_valid (as->app_wrk_index);
- app_worker_lock_and_send_event (app_wrk, as, SESSION_IO_EVT_RX);
+error:
+ clib_warning ("unexpected msg type from app %u", msg.type);
+ http_send_error (hc, sc);
+ session_transport_closing_notify (&hc->connection);
+ http_disconnect_transport (hc);
return HTTP_SM_STOP;
}
-static int
-cln_drain_rx_buf (http_conn_t *hc, session_t *ts, session_t *as)
+static void
+http_app_enqueue (http_conn_t *hc, session_t *as)
{
app_worker_t *app_wrk;
- u32 max_enq, n_enq, dlen = vec_len (hc->rx_buf) - hc->rx_buf_offset;
+ u32 dlen, max_enq, n_enq;
int rv;
+ dlen = vec_len (hc->rx_buf) - hc->rx_buf_offset;
+ if (!dlen)
+ return;
+
max_enq = svm_fifo_max_enqueue (as->rx_fifo);
n_enq = clib_min (max_enq, dlen);
rv = svm_fifo_enqueue (as->rx_fifo, n_enq, &hc->rx_buf[hc->rx_buf_offset]);
if (rv < 0)
- {
- clib_warning ("enqueue failed");
- return -1;
- }
+ return;
hc->rx_buf_offset += rv;
-
if (hc->rx_buf_offset >= vec_len (hc->rx_buf))
{
vec_reset_length (hc->rx_buf);
app_wrk = app_worker_get_if_valid (as->app_wrk_index);
ASSERT (app_wrk);
-
- app_worker_lock_and_send_event (app_wrk, as, SESSION_IO_EVT_RX);
- return 1;
+ app_worker_rx_notify (app_wrk, as);
}
static http_sm_result_t
-state_cln_recv_more_data (http_conn_t *hc, transport_send_params_t *sp)
+http_state_client_io_more_data (http_conn_t *hc, transport_send_params_t *sp)
{
- session_t *as;
+ session_t *as, *ts;
u32 max_deq;
- session_t *ts;
- int n_read, rv;
+ int n_read;
as = session_get_from_handle (hc->h_pa_session_handle);
ts = session_get_from_handle (hc->h_tc_session_handle);
- u32 dlen = vec_len (hc->rx_buf) - hc->rx_buf_offset;
- if (dlen)
- {
- rv = cln_drain_rx_buf (hc, ts, as);
- if (rv < 0)
- {
- clib_warning ("drain rx error!");
- return HTTP_SM_ERROR;
- }
- goto maybe_reschedule;
- }
+ http_app_enqueue (hc, as);
if (hc->to_recv == 0)
{
- ASSERT (vec_len (hc->rx_buf) == 0);
- ASSERT (hc->rx_buf_offset == 0);
- hc->http_state = HTTP_STATE_WAIT_APP;
+ http_state_change (hc, HTTP_STATE_WAIT_CLIENT_METHOD);
return HTTP_SM_STOP;
}
max_deq = svm_fifo_max_dequeue (ts->rx_fifo);
- if (max_deq == 0)
- return HTTP_SM_STOP;
-
- ASSERT (vec_len (hc->rx_buf) == 0);
- ASSERT (hc->rx_buf_offset == 0);
+ if (max_deq > 0)
+ {
+ vec_validate (hc->rx_buf, max_deq - 1);
+ n_read = svm_fifo_dequeue (ts->rx_fifo, max_deq, hc->rx_buf);
+ ASSERT (n_read == max_deq);
- vec_validate (hc->rx_buf, max_deq - 1);
- n_read = svm_fifo_dequeue (ts->rx_fifo, max_deq, hc->rx_buf);
- ASSERT (n_read == max_deq);
+ if (svm_fifo_is_empty (ts->rx_fifo))
+ svm_fifo_unset_event (ts->rx_fifo);
- if (svm_fifo_is_empty (ts->rx_fifo))
- svm_fifo_unset_event (ts->rx_fifo);
-
- hc->to_recv -= n_read;
- vec_set_len (hc->rx_buf, max_deq);
+ hc->to_recv -= n_read;
+ vec_set_len (hc->rx_buf, n_read);
+ }
-maybe_reschedule:
if (hc->rx_buf_offset < vec_len (hc->rx_buf) ||
svm_fifo_max_dequeue_cons (ts->rx_fifo))
{
- if (svm_fifo_set_event (ts->rx_fifo))
- session_send_io_evt_to_thread (ts->rx_fifo, SESSION_IO_EVT_BUILTIN_RX);
+ session_enqueue_notify (ts);
}
return HTTP_SM_CONTINUE;
}
static http_sm_result_t
-state_cln_wait_app (http_conn_t *hc, transport_send_params_t *sp)
+http_state_app_io_more_data (http_conn_t *hc, transport_send_params_t *sp)
{
- session_t *as;
- http_msg_t msg;
- http_status_code_t ec;
- u8 *buf = 0, *request;
- u32 offset;
- int rv;
-
- as = session_get_from_handle (hc->h_pa_session_handle);
- rv = svm_fifo_dequeue (as->tx_fifo, sizeof (msg), (u8 *) &msg);
- ASSERT (rv == sizeof (msg));
- if (msg.type != HTTP_MSG_REQUEST || msg.data.type > HTTP_MSG_DATA_PTR)
- {
- clib_warning ("unexpected msg type from app %u", msg.type);
- ec = HTTP_STATUS_INTERNAL_ERROR;
- goto error;
- }
+ u32 max_send = 64 << 10, n_segs;
+ http_buffer_t *hb = &hc->tx_buf;
+ svm_fifo_seg_t *seg;
+ session_t *ts;
+ int sent = 0;
- vec_validate (buf, msg.data.len - 1);
- rv = svm_fifo_dequeue (as->tx_fifo, msg.data.len, buf);
- ASSERT (rv == msg.data.len);
+ max_send = clib_min (max_send, sp->max_burst_size);
+ ts = session_get_from_handle (hc->h_tc_session_handle);
+ if ((seg = http_buffer_get_segs (hb, max_send, &n_segs)))
+ sent = svm_fifo_enqueue_segments (ts->tx_fifo, seg, n_segs,
+ 1 /* allow partial */);
- request = format (0, http_request_template, buf);
- offset = send_data (hc, request, vec_len (request), 0);
- if (offset != vec_len (request))
+ if (sent > 0)
{
- clib_warning ("sending request failed!");
- ec = HTTP_STATUS_INTERNAL_ERROR;
- goto error;
+ /* Ask scheduler to notify app of deq event if needed */
+ sp->bytes_dequeued += http_buffer_drain (hb, sent);
+ sp->max_burst_size -= sent;
}
- hc->http_state = HTTP_STATE_WAIT_METHOD;
+ /* Not finished sending all data */
+ if (!http_buffer_is_drained (hb))
+ {
+ if (sent && svm_fifo_set_event (ts->tx_fifo))
+ session_send_io_evt_to_thread (ts->tx_fifo, SESSION_IO_EVT_TX);
- vec_free (buf);
- vec_free (request);
+ if (svm_fifo_max_enqueue (ts->tx_fifo) < HTTP_FIFO_THRESH)
+ {
+ /* Deschedule http session and wait for deq notification if
+ * underlying ts tx fifo almost full */
+ svm_fifo_add_want_deq_ntf (ts->tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF);
+ transport_connection_deschedule (&hc->connection);
+ sp->flags |= TRANSPORT_SND_F_DESCHED;
+ }
+ }
+ else
+ {
+ if (sent && svm_fifo_set_event (ts->tx_fifo))
+ session_send_io_evt_to_thread (ts->tx_fifo, SESSION_IO_EVT_TX_FLUSH);
- return HTTP_SM_CONTINUE;
+ /* Finished transaction, back to HTTP_STATE_WAIT_METHOD */
+ http_state_change (hc, HTTP_STATE_WAIT_CLIENT_METHOD);
+ http_buffer_free (&hc->tx_buf);
+ }
-error:
- send_error (hc, ec);
- session_transport_closing_notify (&hc->connection);
- http_disconnect_transport (hc);
return HTTP_SM_STOP;
}
typedef http_sm_result_t (*http_sm_handler) (http_conn_t *,
transport_send_params_t *sp);
-static http_sm_handler srv_state_funcs[HTTP_N_STATES] = {
- /* Waiting for GET, POST, etc. */
- state_srv_wait_method,
- /* Wait for data from app */
- state_srv_wait_app,
- /* Send more data */
- state_srv_send_more_data,
-};
-
-static http_sm_handler cln_state_funcs[HTTP_N_STATES] = {
- /* wait for reply */
- state_cln_wait_method,
- /* wait for data from app */
- state_cln_wait_app,
- /* receive more data */
- state_cln_recv_more_data,
+static http_sm_handler state_funcs[HTTP_N_STATES] = {
+ 0, /* idle state */
+ http_state_wait_app_method,
+ http_state_wait_client_method,
+ http_state_wait_server_reply,
+ http_state_wait_app_reply,
+ http_state_client_io_more_data,
+ http_state_app_io_more_data,
};
static void
http_req_run_state_machine (http_conn_t *hc, transport_send_params_t *sp)
{
http_sm_result_t res;
- http_sm_handler *state_fn =
- hc->is_client ? cln_state_funcs : srv_state_funcs;
do
{
- res = state_fn[hc->http_state](hc, sp);
+ res = state_funcs[hc->http_state](hc, sp);
if (res == HTTP_SM_ERROR)
- return;
+ {
+ HTTP_DBG (1, "error in state machine %d", res);
+ return;
+ }
}
while (res == HTTP_SM_CONTINUE);
}
static int
-http_ts_server_rx_callback (session_t *ts, http_conn_t *hc)
+http_ts_rx_callback (session_t *ts)
{
- if (hc->http_state != HTTP_STATE_WAIT_METHOD)
- {
- clib_warning ("tcp data in req state %u", hc->http_state);
- return 0;
- }
-
- http_req_run_state_machine (hc, 0);
-
- if (hc->state == HTTP_CONN_STATE_TRANSPORT_CLOSED)
- {
- if (!svm_fifo_max_dequeue_cons (ts->rx_fifo))
- session_transport_closing_notify (&hc->connection);
- }
- return 0;
-}
+ http_conn_t *hc;
-static int
-http_ts_client_rx_callback (session_t *ts, http_conn_t *hc)
-{
- if (hc->http_state != HTTP_STATE_WAIT_METHOD &&
- hc->http_state != HTTP_STATE_IO_MORE_DATA)
+ hc = http_conn_get_w_thread (ts->opaque, ts->thread_index);
+ if (!hc)
{
- clib_warning ("http in unexpected state %d (ts %d)", hc->http_state,
- ts->session_index);
- return 0;
+ clib_warning ("http connection not found (ts %d)", ts->opaque);
+ return -1;
}
http_req_run_state_machine (hc, 0);
return 0;
}
-static int
-http_ts_rx_callback (session_t *ts)
-{
- http_conn_t *hc;
-
- hc = http_conn_get_w_thread (ts->opaque, ts->thread_index);
- if (hc->is_client)
- return http_ts_client_rx_callback (ts, hc);
- return http_ts_server_rx_callback (ts, hc);
-}
-
int
http_ts_builtin_tx_callback (session_t *ts)
{
hc = http_conn_get_w_thread (hc_index, 0);
hc->h_pa_wrk_index = sep->app_wrk_index;
hc->h_pa_app_api_ctx = sep->opaque;
- hc->is_client = 1;
hc->state = HTTP_CONN_STATE_CONNECTING;
cargs->api_context = hc_index;
+ HTTP_DBG (1, "hc ho_index %x", hc_index);
+
if ((error = vnet_connect (cargs)))
return error;
u32 max_burst_sz, sent;
http_conn_t *hc;
+ HTTP_DBG (1, "app session conn index %x", as->connection_index);
+
hc = http_conn_get_w_thread (as->connection_index, as->thread_index);
- if (hc->http_state < HTTP_STATE_WAIT_APP)
+ if (!http_state_is_tx_valid (hc))
{
if (hc->state != HTTP_CONN_STATE_CLOSED)
- clib_warning ("app data req state %u session state %u", hc->http_state,
- hc->state);
+ clib_warning ("app data req state '%U' session state %u",
+ format_http_state, hc->http_state, hc->state);
svm_fifo_dequeue_drop_all (as->tx_fifo);
return 0;
}
Code Review / vpp.git / blobdiff