src/plugins/http/http.c

   1 /*
   2  * Copyright (c) 2022 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #include <http/http.h>
  17 #include <vnet/session/session.h>
  18 #include <http/http_timer.h>
  19
  20 static http_main_t http_main;
  21
  22 #define HTTP_FIFO_THRESH (16 << 10)
  23 #define CONTENT_LEN_STR  "Content-Length: "
  24
  25 /* HTTP state machine result */
  26 typedef enum http_sm_result_t_
  27 {
  28   HTTP_SM_STOP = 0,
  29   HTTP_SM_CONTINUE = 1,
  30   HTTP_SM_ERROR = -1,
  31 } http_sm_result_t;
  32
  33 const char *http_status_code_str[] = {
  34 #define _(c, s, str) str,
  35   foreach_http_status_code
  36 #undef _
  37 };
  38
  39 const char *http_content_type_str[] = {
  40 #define _(s, ext, str) str,
  41   foreach_http_content_type
  42 #undef _
  43 };
  44
  45 const http_buffer_type_t msg_to_buf_type[] = {
  46   [HTTP_MSG_DATA_INLINE] = HTTP_BUFFER_FIFO,
  47   [HTTP_MSG_DATA_PTR] = HTTP_BUFFER_PTR,
  48 };
  49
  50 u8 *
  51 format_http_state (u8 *s, va_list *va)
  52 {
  53   http_state_t state = va_arg (*va, http_state_t);
  54
  55   switch (state)
  56     {
  57     case HTTP_STATE_IDLE:
  58       return format (s, "idle");
  59     case HTTP_STATE_WAIT_APP_METHOD:
  60       return format (s, "wait app method");
  61     case HTTP_STATE_WAIT_SERVER_REPLY:
  62       return format (s, "wait server reply");
  63     case HTTP_STATE_CLIENT_IO_MORE_DATA:
  64       return format (s, "client io more data");
  65     case HTTP_STATE_WAIT_CLIENT_METHOD:
  66       return format (s, "wait client method");
  67     case HTTP_STATE_WAIT_APP_REPLY:
  68       return format (s, "wait app reply");
  69     case HTTP_STATE_APP_IO_MORE_DATA:
  70       return format (s, "app io more data");
  71     default:
  72       break;
  73     }
  74   return format (s, "unknown");
  75 }
  76
  77 static inline void
  78 http_state_change (http_conn_t *hc, http_state_t state)
  79 {
  80   HTTP_DBG (1, "changing http state %U -> %U", format_http_state,
  81             hc->http_state, format_http_state, state);
  82   ASSERT (hc->http_state != state);
  83   hc->http_state = state;
  84 }
  85
  86 static inline http_worker_t *
  87 http_worker_get (u32 thread_index)
  88 {
  89   return &http_main.wrk[thread_index];
  90 }
  91
  92 static inline u32
  93 http_conn_alloc_w_thread (u32 thread_index)
  94 {
  95   http_worker_t *wrk = http_worker_get (thread_index);
  96   http_conn_t *hc;
  97
  98   pool_get_aligned_safe (wrk->conn_pool, hc, CLIB_CACHE_LINE_BYTES);
  99   clib_memset (hc, 0, sizeof (*hc));
 100   hc->c_thread_index = thread_index;
 101   hc->h_hc_index = hc - wrk->conn_pool;
 102   hc->h_pa_session_handle = SESSION_INVALID_HANDLE;
 103   hc->h_tc_session_handle = SESSION_INVALID_HANDLE;
 104   return hc->h_hc_index;
 105 }
 106
 107 static inline http_conn_t *
 108 http_conn_get_w_thread (u32 hc_index, u32 thread_index)
 109 {
 110   http_worker_t *wrk = http_worker_get (thread_index);
 111   return pool_elt_at_index (wrk->conn_pool, hc_index);
 112 }
 113
 114 void
 115 http_conn_free (http_conn_t *hc)
 116 {
 117   http_worker_t *wrk = http_worker_get (hc->c_thread_index);
 118   pool_put (wrk->conn_pool, hc);
 119 }
 120
 121 static u32
 122 http_listener_alloc (void)
 123 {
 124   http_main_t *hm = &http_main;
 125   http_conn_t *lhc;
 126
 127   pool_get_zero (hm->listener_pool, lhc);
 128   lhc->c_c_index = lhc - hm->listener_pool;
 129   return lhc->c_c_index;
 130 }
 131
 132 http_conn_t *
 133 http_listener_get (u32 lhc_index)
 134 {
 135   return pool_elt_at_index (http_main.listener_pool, lhc_index);
 136 }
 137
 138 void
 139 http_listener_free (http_conn_t *lhc)
 140 {
 141   http_main_t *hm = &http_main;
 142
 143   if (CLIB_DEBUG)
 144     memset (lhc, 0xfc, sizeof (*lhc));
 145   pool_put (hm->listener_pool, lhc);
 146 }
 147
 148 void
 149 http_disconnect_transport (http_conn_t *hc)
 150 {
 151   vnet_disconnect_args_t a = {
 152     .handle = hc->h_tc_session_handle,
 153     .app_index = http_main.app_index,
 154   };
 155
 156   hc->state = HTTP_CONN_STATE_CLOSED;
 157
 158   if (vnet_disconnect_session (&a))
 159     clib_warning ("disconnect returned");
 160 }
 161
 162 static void
 163 http_conn_timeout_cb (void *hc_handlep)
 164 {
 165   http_conn_t *hc;
 166   uword hs_handle;
 167
 168   hs_handle = pointer_to_uword (hc_handlep);
 169   hc = http_conn_get_w_thread (hs_handle & 0x00FFFFFF, hs_handle >> 24);
 170
 171   HTTP_DBG (1, "terminate thread %d index %d hs %llx", hs_handle >> 24,
 172             hs_handle & 0x00FFFFFF, hc);
 173   if (!hc)
 174     return;
 175
 176   hc->timer_handle = ~0;
 177   session_transport_closing_notify (&hc->connection);
 178   http_disconnect_transport (hc);
 179 }
 180
 181 int
 182 http_ts_accept_callback (session_t *ts)
 183 {
 184   session_t *ts_listener, *as, *asl;
 185   app_worker_t *app_wrk;
 186   http_conn_t *lhc, *hc;
 187   u32 hc_index, thresh;
 188   int rv;
 189
 190   ts_listener = listen_session_get_from_handle (ts->listener_handle);
 191   lhc = http_listener_get (ts_listener->opaque);
 192
 193   hc_index = http_conn_alloc_w_thread (ts->thread_index);
 194   hc = http_conn_get_w_thread (hc_index, ts->thread_index);
 195   clib_memcpy_fast (hc, lhc, sizeof (*lhc));
 196   hc->c_thread_index = ts->thread_index;
 197   hc->h_hc_index = hc_index;
 198
 199   hc->h_tc_session_handle = session_handle (ts);
 200   hc->c_flags |= TRANSPORT_CONNECTION_F_NO_LOOKUP;
 201
 202   hc->state = HTTP_CONN_STATE_ESTABLISHED;
 203   http_state_change (hc, HTTP_STATE_WAIT_CLIENT_METHOD);
 204
 205   ts->session_state = SESSION_STATE_READY;
 206   ts->opaque = hc_index;
 207
 208   /*
 209    * Alloc session and initialize
 210    */
 211   as = session_alloc (hc->c_thread_index);
 212   hc->c_s_index = as->session_index;
 213
 214   as->app_wrk_index = hc->h_pa_wrk_index;
 215   as->connection_index = hc->c_c_index;
 216   as->session_state = SESSION_STATE_ACCEPTING;
 217
 218   asl = listen_session_get_from_handle (lhc->h_pa_session_handle);
 219   as->session_type = asl->session_type;
 220   as->listener_handle = lhc->h_pa_session_handle;
 221
 222   /*
 223    * Init session fifos and notify app
 224    */
 225   if ((rv = app_worker_init_accepted (as)))
 226     {
 227       HTTP_DBG (1, "failed to allocate fifos");
 228       session_free (as);
 229       return rv;
 230     }
 231
 232   hc->h_pa_session_handle = session_handle (as);
 233   hc->h_pa_wrk_index = as->app_wrk_index;
 234   app_wrk = app_worker_get (as->app_wrk_index);
 235
 236   HTTP_DBG (1, "Accepted on listener %u new connection [%u]%x",
 237             ts_listener->opaque, vlib_get_thread_index (), hc_index);
 238
 239   if ((rv = app_worker_accept_notify (app_wrk, as)))
 240     {
 241       HTTP_DBG (0, "app accept returned");
 242       session_free (as);
 243       return rv;
 244     }
 245
 246   /* Avoid enqueuing small chunks of data on transport tx notifications. If
 247    * the fifo is small (under 16K) we set the threshold to it's size, meaning
 248    * a notification will be given when the fifo empties.
 249    */
 250   ts = session_get_from_handle (hc->h_tc_session_handle);
 251   thresh = clib_min (svm_fifo_size (ts->tx_fifo), HTTP_FIFO_THRESH);
 252   svm_fifo_set_deq_thresh (ts->tx_fifo, thresh);
 253
 254   http_conn_timer_start (hc);
 255
 256   return 0;
 257 }
 258
 259 static int
 260 http_ts_connected_callback (u32 http_app_index, u32 ho_hc_index, session_t *ts,
 261                             session_error_t err)
 262 {
 263   u32 new_hc_index;
 264   session_t *as;
 265   http_conn_t *hc, *ho_hc;
 266   app_worker_t *app_wrk;
 267   int rv;
 268
 269   if (err)
 270     {
 271       clib_warning ("ERROR: %d", err);
 272       return 0;
 273     }
 274
 275   new_hc_index = http_conn_alloc_w_thread (ts->thread_index);
 276   hc = http_conn_get_w_thread (new_hc_index, ts->thread_index);
 277   ho_hc = http_conn_get_w_thread (ho_hc_index, 0);
 278
 279   ASSERT (ho_hc->state == HTTP_CONN_STATE_CONNECTING);
 280
 281   clib_memcpy_fast (hc, ho_hc, sizeof (*hc));
 282
 283   hc->c_thread_index = ts->thread_index;
 284   hc->h_tc_session_handle = session_handle (ts);
 285   hc->c_c_index = new_hc_index;
 286   hc->c_flags |= TRANSPORT_CONNECTION_F_NO_LOOKUP;
 287   hc->state = HTTP_CONN_STATE_ESTABLISHED;
 288   http_state_change (hc, HTTP_STATE_WAIT_APP_METHOD);
 289
 290   ts->session_state = SESSION_STATE_READY;
 291   ts->opaque = new_hc_index;
 292
 293   /* allocate app session and initialize */
 294
 295   as = session_alloc (hc->c_thread_index);
 296   hc->c_s_index = as->session_index;
 297   as->connection_index = hc->c_c_index;
 298   as->app_wrk_index = hc->h_pa_wrk_index;
 299   as->session_state = SESSION_STATE_READY;
 300   as->opaque = hc->h_pa_app_api_ctx;
 301   as->session_type = session_type_from_proto_and_ip (
 302     TRANSPORT_PROTO_HTTP, session_type_is_ip4 (ts->session_type));
 303
 304   HTTP_DBG (1, "half-open hc index %d,  hc index %d", ho_hc_index,
 305             new_hc_index);
 306
 307   app_wrk = app_worker_get (hc->h_pa_wrk_index);
 308   if (!app_wrk)
 309     {
 310       clib_warning ("no app worker");
 311       return -1;
 312     }
 313
 314   if ((rv = app_worker_init_connected (app_wrk, as)))
 315     {
 316       HTTP_DBG (1, "failed to allocate fifos");
 317       session_free (as);
 318       return rv;
 319     }
 320   app_worker_connect_notify (app_wrk, as, err, hc->h_pa_app_api_ctx);
 321   hc->h_pa_session_handle = session_handle (as);
 322   http_conn_timer_start (hc);
 323
 324   return 0;
 325 }
 326
 327 static void
 328 http_ts_disconnect_callback (session_t *ts)
 329 {
 330   http_conn_t *hc;
 331
 332   hc = http_conn_get_w_thread (ts->opaque, ts->thread_index);
 333
 334   if (hc->state < HTTP_CONN_STATE_TRANSPORT_CLOSED)
 335     hc->state = HTTP_CONN_STATE_TRANSPORT_CLOSED;
 336
 337   /* Nothing more to rx, propagate to app */
 338   if (!svm_fifo_max_dequeue_cons (ts->rx_fifo))
 339     session_transport_closing_notify (&hc->connection);
 340 }
 341
 342 static void
 343 http_ts_reset_callback (session_t *ts)
 344 {
 345   http_conn_t *hc;
 346
 347   hc = http_conn_get_w_thread (ts->opaque, ts->thread_index);
 348
 349   hc->state = HTTP_CONN_STATE_CLOSED;
 350   http_buffer_free (&hc->tx_buf);
 351   http_state_change (hc, HTTP_STATE_WAIT_CLIENT_METHOD);
 352   session_transport_reset_notify (&hc->connection);
 353
 354   http_disconnect_transport (hc);
 355 }
 356
 357 /**
 358  * http error boilerplate
 359  */
 360 static const char *http_error_template = "HTTP/1.1 %s\r\n"
 361                                          "Date: %U GMT\r\n"
 362                                          "Content-Type: text/html\r\n"
 363                                          "Connection: close\r\n"
 364                                          "Pragma: no-cache\r\n"
 365                                          "Content-Length: 0\r\n\r\n";
 366
 367 static const char *http_redirect_template = "HTTP/1.1 %s\r\n";
 368
 369 /**
 370  * http response boilerplate
 371  */
 372 static const char *http_response_template = "HTTP/1.1 %s\r\n"
 373                                             "Date: %U GMT\r\n"
 374                                             "Expires: %U GMT\r\n"
 375                                             "Server: VPP Static\r\n"
 376                                             "Content-Type: %s\r\n"
 377                                             "Content-Length: %lu\r\n\r\n";
 378
 379 static const char *http_request_template = "GET %s HTTP/1.1\r\n"
 380                                            "User-Agent: VPP HTTP client\r\n"
 381                                            "Accept: */*\r\n";
 382
 383 static u32
 384 http_send_data (http_conn_t *hc, u8 *data, u32 length, u32 offset)
 385 {
 386   const u32 max_burst = 64 << 10;
 387   session_t *ts;
 388   u32 to_send;
 389   int sent;
 390
 391   ts = session_get_from_handle (hc->h_tc_session_handle);
 392
 393   to_send = clib_min (length - offset, max_burst);
 394   sent = svm_fifo_enqueue (ts->tx_fifo, to_send, data + offset);
 395
 396   if (sent <= 0)
 397     return offset;
 398
 399   if (svm_fifo_set_event (ts->tx_fifo))
 400     session_send_io_evt_to_thread (ts->tx_fifo, SESSION_IO_EVT_TX);
 401
 402   return (offset + sent);
 403 }
 404
 405 static void
 406 http_send_error (http_conn_t *hc, http_status_code_t ec)
 407 {
 408   http_main_t *hm = &http_main;
 409   u8 *data;
 410   f64 now;
 411
 412   if (ec >= HTTP_N_STATUS)
 413     ec = HTTP_STATUS_INTERNAL_ERROR;
 414
 415   now = clib_timebase_now (&hm->timebase);
 416   data = format (0, http_error_template, http_status_code_str[ec],
 417                  format_clib_timebase_time, now);
 418   http_send_data (hc, data, vec_len (data), 0);
 419   vec_free (data);
 420 }
 421
 422 static int
 423 http_read_message (http_conn_t *hc)
 424 {
 425   u32 max_deq, cursize;
 426   session_t *ts;
 427   int n_read;
 428
 429   ts = session_get_from_handle (hc->h_tc_session_handle);
 430
 431   cursize = vec_len (hc->rx_buf);
 432   max_deq = svm_fifo_max_dequeue (ts->rx_fifo);
 433   if (PREDICT_FALSE (max_deq == 0))
 434     return -1;
 435
 436   vec_validate (hc->rx_buf, cursize + max_deq - 1);
 437   n_read = svm_fifo_dequeue (ts->rx_fifo, max_deq, hc->rx_buf + cursize);
 438   ASSERT (n_read == max_deq);
 439
 440   if (svm_fifo_is_empty (ts->rx_fifo))
 441     svm_fifo_unset_event (ts->rx_fifo);
 442
 443   vec_set_len (hc->rx_buf, cursize + n_read);
 444   return 0;
 445 }
 446
 447 static int
 448 v_find_index (u8 *vec, u32 offset, char *str)
 449 {
 450   int start_index = offset;
 451   u32 slen = (u32) strnlen_s_inline (str, 16);
 452   u32 vlen = vec_len (vec);
 453
 454   ASSERT (slen > 0);
 455
 456   if (vlen <= slen)
 457     return -1;
 458
 459   for (; start_index < (vlen - slen); start_index++)
 460     {
 461       if (!memcmp (vec + start_index, str, slen))
 462         return start_index;
 463     }
 464
 465   return -1;
 466 }
 467
 468 static int
 469 http_parse_header (http_conn_t *hc, int *content_length)
 470 {
 471   unformat_input_t input;
 472   int i, len;
 473   u8 *line;
 474
 475   i = v_find_index (hc->rx_buf, hc->rx_buf_offset, CONTENT_LEN_STR);
 476   if (i < 0)
 477     {
 478       clib_warning ("cannot find '%s' in the header!", CONTENT_LEN_STR);
 479       return -1;
 480     }
 481
 482   hc->rx_buf_offset = i;
 483
 484   i = v_find_index (hc->rx_buf, hc->rx_buf_offset, "\n");
 485   if (i < 0)
 486     {
 487       clib_warning ("end of line missing; incomplete data");
 488       return -1;
 489     }
 490
 491   len = i - hc->rx_buf_offset;
 492   line = vec_new (u8, len);
 493   clib_memcpy (line, hc->rx_buf + hc->rx_buf_offset, len);
 494
 495   unformat_init_vector (&input, line);
 496   if (!unformat (&input, CONTENT_LEN_STR "%d", content_length))
 497     {
 498       clib_warning ("failed to unformat content length!");
 499       return -1;
 500     }
 501   unformat_free (&input);
 502
 503   /* skip rest of the header */
 504   hc->rx_buf_offset += len;
 505   i = v_find_index (hc->rx_buf, hc->rx_buf_offset, "<html>");
 506   if (i < 0)
 507     {
 508       clib_warning ("<html> tag not found");
 509       return -1;
 510     }
 511   hc->rx_buf_offset = i;
 512
 513   return 0;
 514 }
 515
 516 static http_sm_result_t
 517 http_state_wait_server_reply (http_conn_t *hc, transport_send_params_t *sp)
 518 {
 519   int i, rv, content_length;
 520   http_msg_t msg = {};
 521   app_worker_t *app_wrk;
 522   session_t *as;
 523   http_status_code_t ec;
 524
 525   rv = http_read_message (hc);
 526
 527   /* Nothing yet, wait for data or timer expire */
 528   if (rv)
 529     return HTTP_SM_STOP;
 530
 531   if (vec_len (hc->rx_buf) < 8)
 532     {
 533       ec = HTTP_STATUS_BAD_REQUEST;
 534       goto error;
 535     }
 536
 537   if ((i = v_find_index (hc->rx_buf, 0, "200 OK")) >= 0)
 538     {
 539       msg.type = HTTP_MSG_REPLY;
 540       msg.content_type = HTTP_CONTENT_TEXT_HTML;
 541       msg.code = HTTP_STATUS_OK;
 542       msg.data.type = HTTP_MSG_DATA_INLINE;
 543       msg.data.len = 0;
 544
 545       rv = http_parse_header (hc, &content_length);
 546       if (rv)
 547         {
 548           clib_warning ("failed to parse http reply");
 549           session_transport_closing_notify (&hc->connection);
 550           http_disconnect_transport (hc);
 551           return -1;
 552         }
 553       msg.data.len = content_length;
 554       u32 dlen = vec_len (hc->rx_buf) - hc->rx_buf_offset;
 555       as = session_get_from_handle (hc->h_pa_session_handle);
 556       svm_fifo_seg_t segs[2] = { { (u8 *) &msg, sizeof (msg) },
 557                                  { &hc->rx_buf[hc->rx_buf_offset], dlen } };
 558
 559       rv = svm_fifo_enqueue_segments (as->rx_fifo, segs, 2,
 560                                       0 /* allow partial */);
 561       if (rv < 0)
 562         {
 563           clib_warning ("error enqueue");
 564           return HTTP_SM_ERROR;
 565         }
 566
 567       hc->rx_buf_offset += dlen;
 568       hc->to_recv = content_length - dlen;
 569
 570       if (hc->rx_buf_offset == vec_len (hc->rx_buf))
 571         {
 572           vec_reset_length (hc->rx_buf);
 573           hc->rx_buf_offset = 0;
 574         }
 575
 576       if (hc->to_recv == 0)
 577         {
 578           hc->rx_buf_offset = 0;
 579           vec_reset_length (hc->rx_buf);
 580           http_state_change (hc, HTTP_STATE_WAIT_CLIENT_METHOD);
 581         }
 582       else
 583         {
 584           http_state_change (hc, HTTP_STATE_CLIENT_IO_MORE_DATA);
 585         }
 586
 587       app_wrk = app_worker_get_if_valid (as->app_wrk_index);
 588       app_worker_rx_notify (app_wrk, as);
 589       return HTTP_SM_STOP;
 590     }
 591   else
 592     {
 593       HTTP_DBG (0, "Unknown http method %v", hc->rx_buf);
 594       ec = HTTP_STATUS_METHOD_NOT_ALLOWED;
 595       goto error;
 596     }
 597   return HTTP_SM_STOP;
 598
 599 error:
 600
 601   http_send_error (hc, ec);
 602   session_transport_closing_notify (&hc->connection);
 603   http_disconnect_transport (hc);
 604
 605   return HTTP_SM_ERROR;
 606 }
 607
 608 static http_sm_result_t
 609 http_state_wait_client_method (http_conn_t *hc, transport_send_params_t *sp)
 610 {
 611   http_status_code_t ec;
 612   app_worker_t *app_wrk;
 613   http_msg_t msg;
 614   session_t *as;
 615   int i, rv;
 616   u32 len;
 617   u8 *buf;
 618
 619   rv = http_read_message (hc);
 620
 621   /* Nothing yet, wait for data or timer expire */
 622   if (rv)
 623     return HTTP_SM_STOP;
 624
 625   if (vec_len (hc->rx_buf) < 8)
 626     {
 627       ec = HTTP_STATUS_BAD_REQUEST;
 628       goto error;
 629     }
 630
 631   if ((i = v_find_index (hc->rx_buf, 0, "GET ")) >= 0)
 632     {
 633       hc->method = HTTP_REQ_GET;
 634       hc->rx_buf_offset = i + 5;
 635
 636       i = v_find_index (hc->rx_buf, hc->rx_buf_offset, "HTTP");
 637       if (i < 0)
 638         {
 639           ec = HTTP_STATUS_BAD_REQUEST;
 640           goto error;
 641         }
 642
 643       HTTP_DBG (0, "GET method %v", hc->rx_buf);
 644       len = i - hc->rx_buf_offset - 1;
 645     }
 646   else if ((i = v_find_index (hc->rx_buf, 0, "POST ")) >= 0)
 647     {
 648       hc->method = HTTP_REQ_POST;
 649       hc->rx_buf_offset = i + 6;
 650       len = vec_len (hc->rx_buf) - hc->rx_buf_offset - 1;
 651       HTTP_DBG (0, "POST method %v", hc->rx_buf);
 652     }
 653   else
 654     {
 655       HTTP_DBG (0, "Unknown http method %v", hc->rx_buf);
 656       ec = HTTP_STATUS_METHOD_NOT_ALLOWED;
 657       goto error;
 658     }
 659
 660   buf = &hc->rx_buf[hc->rx_buf_offset];
 661
 662   msg.type = HTTP_MSG_REQUEST;
 663   msg.method_type = hc->method;
 664   msg.content_type = HTTP_CONTENT_TEXT_HTML;
 665   msg.data.type = HTTP_MSG_DATA_INLINE;
 666   msg.data.len = len;
 667
 668   svm_fifo_seg_t segs[2] = { { (u8 *) &msg, sizeof (msg) }, { buf, len } };
 669
 670   as = session_get_from_handle (hc->h_pa_session_handle);
 671   rv = svm_fifo_enqueue_segments (as->rx_fifo, segs, 2, 0 /* allow partial */);
 672   if (rv < 0 || rv != sizeof (msg) + len)
 673     {
 674       clib_warning ("failed app enqueue");
 675       /* This should not happen as we only handle 1 request per session,
 676        * and fifo is allocated, but going forward we should consider
 677        * rescheduling */
 678       return HTTP_SM_ERROR;
 679     }
 680
 681   vec_free (hc->rx_buf);
 682   http_state_change (hc, HTTP_STATE_WAIT_APP_REPLY);
 683
 684   app_wrk = app_worker_get_if_valid (as->app_wrk_index);
 685   if (app_wrk)
 686     app_worker_rx_notify (app_wrk, as);
 687
 688   return HTTP_SM_STOP;
 689
 690 error:
 691
 692   http_send_error (hc, ec);
 693   session_transport_closing_notify (&hc->connection);
 694   http_disconnect_transport (hc);
 695
 696   return HTTP_SM_ERROR;
 697 }
 698
 699 static http_sm_result_t
 700 http_state_wait_app_reply (http_conn_t *hc, transport_send_params_t *sp)
 701 {
 702   http_main_t *hm = &http_main;
 703   u8 *header;
 704   u32 offset;
 705   f64 now;
 706   session_t *as;
 707   http_status_code_t sc;
 708   http_msg_t msg;
 709   int rv;
 710
 711   as = session_get_from_handle (hc->h_pa_session_handle);
 712
 713   rv = svm_fifo_dequeue (as->tx_fifo, sizeof (msg), (u8 *) &msg);
 714   ASSERT (rv == sizeof (msg));
 715
 716   if (msg.data.type > HTTP_MSG_DATA_PTR)
 717     {
 718       clib_warning ("no data");
 719       sc = HTTP_STATUS_INTERNAL_ERROR;
 720       goto error;
 721     }
 722
 723   if (msg.type != HTTP_MSG_REPLY)
 724     {
 725       clib_warning ("unexpected message type %d", msg.type);
 726       sc = HTTP_STATUS_INTERNAL_ERROR;
 727       goto error;
 728     }
 729
 730   http_buffer_init (&hc->tx_buf, msg_to_buf_type[msg.data.type], as->tx_fifo,
 731                     msg.data.len);
 732
 733   /*
 734    * Add headers. For now:
 735    * - current time
 736    * - expiration time
 737    * - content type
 738    * - data length
 739    */
 740   now = clib_timebase_now (&hm->timebase);
 741
 742   switch (msg.code)
 743     {
 744     case HTTP_STATUS_OK:
 745       header =
 746         format (0, http_response_template, http_status_code_str[msg.code],
 747                 /* Date */
 748                 format_clib_timebase_time, now,
 749                 /* Expires */
 750                 format_clib_timebase_time, now + 600.0,
 751                 /* Content type */
 752                 http_content_type_str[msg.content_type],
 753                 /* Length */
 754                 msg.data.len);
 755       break;
 756     case HTTP_STATUS_MOVED:
 757       header =
 758         format (0, http_redirect_template, http_status_code_str[msg.code]);
 759       /* Location: http(s)://new-place already queued up as data */
 760       break;
 761     default:
 762       return HTTP_SM_ERROR;
 763     }
 764
 765   offset = http_send_data (hc, header, vec_len (header), 0);
 766   if (offset != vec_len (header))
 767     {
 768       clib_warning ("couldn't send response header!");
 769       sc = HTTP_STATUS_INTERNAL_ERROR;
 770       vec_free (header);
 771       goto error;
 772     }
 773   vec_free (header);
 774
 775   /* Start sending the actual data */
 776   http_state_change (hc, HTTP_STATE_APP_IO_MORE_DATA);
 777
 778   ASSERT (sp->max_burst_size >= offset);
 779   sp->max_burst_size -= offset;
 780   return HTTP_SM_CONTINUE;
 781
 782 error:
 783   clib_warning ("unexpected msg type from app %u", msg.type);
 784   http_send_error (hc, sc);
 785   http_state_change (hc, HTTP_STATE_WAIT_CLIENT_METHOD);
 786   session_transport_closing_notify (&hc->connection);
 787   http_disconnect_transport (hc);
 788   return HTTP_SM_STOP;
 789 }
 790
 791 static http_sm_result_t
 792 http_state_wait_app_method (http_conn_t *hc, transport_send_params_t *sp)
 793 {
 794   http_status_code_t sc;
 795   http_msg_t msg;
 796   session_t *as;
 797   u8 *buf = 0, *request;
 798   u32 offset;
 799   int rv;
 800
 801   as = session_get_from_handle (hc->h_pa_session_handle);
 802
 803   rv = svm_fifo_dequeue (as->tx_fifo, sizeof (msg), (u8 *) &msg);
 804   ASSERT (rv == sizeof (msg));
 805
 806   if (msg.data.type > HTTP_MSG_DATA_PTR)
 807     {
 808       clib_warning ("no data");
 809       sc = HTTP_STATUS_INTERNAL_ERROR;
 810       goto error;
 811     }
 812
 813   if (msg.type != HTTP_MSG_REQUEST)
 814     {
 815       clib_warning ("unexpected message type %d", msg.type);
 816       sc = HTTP_STATUS_INTERNAL_ERROR;
 817       goto error;
 818     }
 819
 820   sc = msg.code;
 821
 822   vec_validate (buf, msg.data.len - 1);
 823   rv = svm_fifo_dequeue (as->tx_fifo, msg.data.len, buf);
 824   ASSERT (rv == msg.data.len);
 825
 826   request = format (0, http_request_template, buf);
 827   offset = http_send_data (hc, request, vec_len (request), 0);
 828   if (offset != vec_len (request))
 829     {
 830       clib_warning ("sending request failed!");
 831       sc = HTTP_STATUS_INTERNAL_ERROR;
 832       goto error;
 833     }
 834
 835   http_state_change (hc, HTTP_STATE_WAIT_SERVER_REPLY);
 836
 837   vec_free (buf);
 838   vec_free (request);
 839
 840   return HTTP_SM_CONTINUE;
 841
 842 error:
 843   clib_warning ("unexpected msg type from app %u", msg.type);
 844   http_send_error (hc, sc);
 845   session_transport_closing_notify (&hc->connection);
 846   http_disconnect_transport (hc);
 847   return HTTP_SM_STOP;
 848 }
 849
 850 static void
 851 http_app_enqueue (http_conn_t *hc, session_t *as)
 852 {
 853   app_worker_t *app_wrk;
 854   u32 dlen, max_enq, n_enq;
 855   int rv;
 856
 857   dlen = vec_len (hc->rx_buf) - hc->rx_buf_offset;
 858   if (!dlen)
 859     return;
 860
 861   max_enq = svm_fifo_max_enqueue (as->rx_fifo);
 862   n_enq = clib_min (max_enq, dlen);
 863   rv = svm_fifo_enqueue (as->rx_fifo, n_enq, &hc->rx_buf[hc->rx_buf_offset]);
 864   if (rv < 0)
 865     return;
 866
 867   hc->rx_buf_offset += rv;
 868   if (hc->rx_buf_offset >= vec_len (hc->rx_buf))
 869     {
 870       vec_reset_length (hc->rx_buf);
 871       hc->rx_buf_offset = 0;
 872     }
 873
 874   app_wrk = app_worker_get_if_valid (as->app_wrk_index);
 875   ASSERT (app_wrk);
 876   app_worker_rx_notify (app_wrk, as);
 877 }
 878
 879 static http_sm_result_t
 880 http_state_client_io_more_data (http_conn_t *hc, transport_send_params_t *sp)
 881 {
 882   session_t *as, *ts;
 883   u32 max_deq;
 884   int n_read;
 885
 886   as = session_get_from_handle (hc->h_pa_session_handle);
 887   ts = session_get_from_handle (hc->h_tc_session_handle);
 888
 889   http_app_enqueue (hc, as);
 890
 891   if (hc->to_recv == 0)
 892     {
 893       http_state_change (hc, HTTP_STATE_WAIT_CLIENT_METHOD);
 894       return HTTP_SM_STOP;
 895     }
 896
 897   max_deq = svm_fifo_max_dequeue (ts->rx_fifo);
 898   if (max_deq > 0)
 899     {
 900       vec_validate (hc->rx_buf, max_deq - 1);
 901       n_read = svm_fifo_dequeue (ts->rx_fifo, max_deq, hc->rx_buf);
 902       ASSERT (n_read == max_deq);
 903
 904       if (svm_fifo_is_empty (ts->rx_fifo))
 905         svm_fifo_unset_event (ts->rx_fifo);
 906
 907       hc->to_recv -= n_read;
 908       vec_set_len (hc->rx_buf, n_read);
 909     }
 910
 911   if (hc->rx_buf_offset < vec_len (hc->rx_buf) ||
 912       svm_fifo_max_dequeue_cons (ts->rx_fifo))
 913     {
 914         session_enqueue_notify (ts);
 915     }
 916   return HTTP_SM_CONTINUE;
 917 }
 918
 919 static http_sm_result_t
 920 http_state_app_io_more_data (http_conn_t *hc, transport_send_params_t *sp)
 921 {
 922   u32 max_send = 64 << 10, n_segs;
 923   http_buffer_t *hb = &hc->tx_buf;
 924   svm_fifo_seg_t *seg;
 925   session_t *ts;
 926   int sent = 0;
 927
 928   max_send = clib_min (max_send, sp->max_burst_size);
 929   ts = session_get_from_handle (hc->h_tc_session_handle);
 930   if ((seg = http_buffer_get_segs (hb, max_send, &n_segs)))
 931     sent = svm_fifo_enqueue_segments (ts->tx_fifo, seg, n_segs,
 932                                       1 /* allow partial */);
 933
 934   if (sent > 0)
 935     {
 936       /* Ask scheduler to notify app of deq event if needed */
 937       sp->bytes_dequeued += http_buffer_drain (hb, sent);
 938       sp->max_burst_size -= sent;
 939     }
 940
 941   /* Not finished sending all data */
 942   if (!http_buffer_is_drained (hb))
 943     {
 944       if (sent && svm_fifo_set_event (ts->tx_fifo))
 945         session_send_io_evt_to_thread (ts->tx_fifo, SESSION_IO_EVT_TX);
 946
 947       if (svm_fifo_max_enqueue (ts->tx_fifo) < HTTP_FIFO_THRESH)
 948         {
 949           /* Deschedule http session and wait for deq notification if
 950            * underlying ts tx fifo almost full */
 951           svm_fifo_add_want_deq_ntf (ts->tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF);
 952           transport_connection_deschedule (&hc->connection);
 953           sp->flags |= TRANSPORT_SND_F_DESCHED;
 954         }
 955     }
 956   else
 957     {
 958       if (sent && svm_fifo_set_event (ts->tx_fifo))
 959         session_send_io_evt_to_thread (ts->tx_fifo, SESSION_IO_EVT_TX_FLUSH);
 960
 961       /* Finished transaction, back to HTTP_STATE_WAIT_METHOD */
 962       http_state_change (hc, HTTP_STATE_WAIT_CLIENT_METHOD);
 963       http_buffer_free (&hc->tx_buf);
 964     }
 965
 966   return HTTP_SM_STOP;
 967 }
 968
 969 typedef http_sm_result_t (*http_sm_handler) (http_conn_t *,
 970                                              transport_send_params_t *sp);
 971
 972 static http_sm_handler state_funcs[HTTP_N_STATES] = {
 973   0, /* idle state */
 974   http_state_wait_app_method,
 975   http_state_wait_client_method,
 976   http_state_wait_server_reply,
 977   http_state_wait_app_reply,
 978   http_state_client_io_more_data,
 979   http_state_app_io_more_data,
 980 };
 981
 982 static void
 983 http_req_run_state_machine (http_conn_t *hc, transport_send_params_t *sp)
 984 {
 985   http_sm_result_t res;
 986   do
 987     {
 988       res = state_funcs[hc->http_state](hc, sp);
 989       if (res == HTTP_SM_ERROR)
 990         {
 991           HTTP_DBG (1, "error in state machine %d", res);
 992           return;
 993         }
 994     }
 995   while (res == HTTP_SM_CONTINUE);
 996
 997   /* Reset the session expiration timer */
 998   http_conn_timer_update (hc);
 999 }
1000
1001 static int
1002 http_ts_rx_callback (session_t *ts)
1003 {
1004   http_conn_t *hc;
1005
1006   hc = http_conn_get_w_thread (ts->opaque, ts->thread_index);
1007   if (!hc)
1008     {
1009       clib_warning ("http connection not found (ts %d)", ts->opaque);
1010       return -1;
1011     }
1012
1013   http_req_run_state_machine (hc, 0);
1014
1015   if (hc->state == HTTP_CONN_STATE_TRANSPORT_CLOSED)
1016     {
1017       if (!svm_fifo_max_dequeue_cons (ts->rx_fifo))
1018         session_transport_closing_notify (&hc->connection);
1019     }
1020   return 0;
1021 }
1022
1023 int
1024 http_ts_builtin_tx_callback (session_t *ts)
1025 {
1026   http_conn_t *hc;
1027
1028   hc = http_conn_get_w_thread (ts->opaque, ts->thread_index);
1029   transport_connection_reschedule (&hc->connection);
1030
1031   return 0;
1032 }
1033
1034 static void
1035 http_ts_cleanup_callback (session_t *ts, session_cleanup_ntf_t ntf)
1036 {
1037   http_conn_t *hc;
1038
1039   if (ntf == SESSION_CLEANUP_TRANSPORT)
1040     return;
1041
1042   hc = http_conn_get_w_thread (ts->opaque, ts->thread_index);
1043   if (!hc)
1044     {
1045       clib_warning ("no http connection for %u", ts->session_index);
1046       return;
1047     }
1048
1049   vec_free (hc->rx_buf);
1050
1051   http_buffer_free (&hc->tx_buf);
1052   http_conn_timer_stop (hc);
1053
1054   session_transport_delete_notify (&hc->connection);
1055   http_conn_free (hc);
1056 }
1057
1058 int
1059 http_add_segment_callback (u32 client_index, u64 segment_handle)
1060 {
1061   /* No-op for builtin */
1062   return 0;
1063 }
1064
1065 int
1066 http_del_segment_callback (u32 client_index, u64 segment_handle)
1067 {
1068   return 0;
1069 }
1070
1071 static session_cb_vft_t http_app_cb_vft = {
1072   .session_accept_callback = http_ts_accept_callback,
1073   .session_disconnect_callback = http_ts_disconnect_callback,
1074   .session_connected_callback = http_ts_connected_callback,
1075   .session_reset_callback = http_ts_reset_callback,
1076   .session_cleanup_callback = http_ts_cleanup_callback,
1077   .add_segment_callback = http_add_segment_callback,
1078   .del_segment_callback = http_del_segment_callback,
1079   .builtin_app_rx_callback = http_ts_rx_callback,
1080   .builtin_app_tx_callback = http_ts_builtin_tx_callback,
1081 };
1082
1083 static clib_error_t *
1084 http_transport_enable (vlib_main_t *vm, u8 is_en)
1085 {
1086   vnet_app_detach_args_t _da, *da = &_da;
1087   vnet_app_attach_args_t _a, *a = &_a;
1088   u64 options[APP_OPTIONS_N_OPTIONS];
1089   http_main_t *hm = &http_main;
1090
1091   if (!is_en)
1092     {
1093       da->app_index = hm->app_index;
1094       da->api_client_index = APP_INVALID_INDEX;
1095       vnet_application_detach (da);
1096       return 0;
1097     }
1098
1099   vec_validate (hm->wrk, vlib_num_workers ());
1100
1101   clib_memset (a, 0, sizeof (*a));
1102   clib_memset (options, 0, sizeof (options));
1103
1104   a->session_cb_vft = &http_app_cb_vft;
1105   a->api_client_index = APP_INVALID_INDEX;
1106   a->options = options;
1107   a->name = format (0, "http");
1108   a->options[APP_OPTIONS_SEGMENT_SIZE] = hm->first_seg_size;
1109   a->options[APP_OPTIONS_ADD_SEGMENT_SIZE] = hm->add_seg_size;
1110   a->options[APP_OPTIONS_RX_FIFO_SIZE] = hm->fifo_size;
1111   a->options[APP_OPTIONS_TX_FIFO_SIZE] = hm->fifo_size;
1112   a->options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_IS_BUILTIN;
1113   a->options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
1114   a->options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_IS_TRANSPORT_APP;
1115
1116   if (vnet_application_attach (a))
1117     return clib_error_return (0, "failed to attach http app");
1118
1119   hm->app_index = a->app_index;
1120   vec_free (a->name);
1121
1122   clib_timebase_init (&hm->timebase, 0 /* GMT */, CLIB_TIMEBASE_DAYLIGHT_NONE,
1123                       &vm->clib_time /* share the system clock */);
1124
1125   http_timers_init (vm, http_conn_timeout_cb);
1126
1127   return 0;
1128 }
1129
1130 static int
1131 http_transport_connect (transport_endpoint_cfg_t *tep)
1132 {
1133   vnet_connect_args_t _cargs, *cargs = &_cargs;
1134   http_main_t *hm = &http_main;
1135   session_endpoint_cfg_t *sep = (session_endpoint_cfg_t *) tep;
1136   application_t *app;
1137   http_conn_t *hc;
1138   int error;
1139   u32 hc_index;
1140   app_worker_t *app_wrk = app_worker_get (sep->app_wrk_index);
1141
1142   clib_memset (cargs, 0, sizeof (*cargs));
1143   clib_memcpy (&cargs->sep_ext, sep, sizeof (session_endpoint_cfg_t));
1144   cargs->sep.transport_proto = TRANSPORT_PROTO_TCP;
1145   cargs->app_index = hm->app_index;
1146   app = application_get (app_wrk->app_index);
1147   cargs->sep_ext.ns_index = app->ns_index;
1148
1149   hc_index = http_conn_alloc_w_thread (0 /* ts->thread_index */);
1150   hc = http_conn_get_w_thread (hc_index, 0);
1151   hc->h_pa_wrk_index = sep->app_wrk_index;
1152   hc->h_pa_app_api_ctx = sep->opaque;
1153   hc->state = HTTP_CONN_STATE_CONNECTING;
1154   cargs->api_context = hc_index;
1155
1156   HTTP_DBG (1, "hc ho_index %x", hc_index);
1157
1158   if ((error = vnet_connect (cargs)))
1159     return error;
1160
1161   return 0;
1162 }
1163
1164 static u32
1165 http_start_listen (u32 app_listener_index, transport_endpoint_cfg_t *tep)
1166 {
1167   vnet_listen_args_t _args = {}, *args = &_args;
1168   session_t *ts_listener, *app_listener;
1169   http_main_t *hm = &http_main;
1170   session_endpoint_cfg_t *sep;
1171   app_worker_t *app_wrk;
1172   transport_proto_t tp;
1173   app_listener_t *al;
1174   application_t *app;
1175   http_conn_t *lhc;
1176   u32 lhc_index;
1177
1178   sep = (session_endpoint_cfg_t *) tep;
1179
1180   app_wrk = app_worker_get (sep->app_wrk_index);
1181   app = application_get (app_wrk->app_index);
1182
1183   args->app_index = hm->app_index;
1184   args->sep_ext = *sep;
1185   args->sep_ext.ns_index = app->ns_index;
1186   tp = sep->ext_cfg ? TRANSPORT_PROTO_TLS : TRANSPORT_PROTO_TCP;
1187   args->sep_ext.transport_proto = tp;
1188
1189   if (vnet_listen (args))
1190     return SESSION_INVALID_INDEX;
1191
1192   lhc_index = http_listener_alloc ();
1193   lhc = http_listener_get (lhc_index);
1194
1195   /* Grab transport connection listener and link to http listener */
1196   lhc->h_tc_session_handle = args->handle;
1197   al = app_listener_get_w_handle (lhc->h_tc_session_handle);
1198   ts_listener = app_listener_get_session (al);
1199   ts_listener->opaque = lhc_index;
1200
1201   /* Grab application listener and link to http listener */
1202   app_listener = listen_session_get (app_listener_index);
1203   lhc->h_pa_wrk_index = sep->app_wrk_index;
1204   lhc->h_pa_session_handle = listen_session_get_handle (app_listener);
1205   lhc->c_s_index = app_listener_index;
1206   lhc->c_flags |= TRANSPORT_CONNECTION_F_NO_LOOKUP;
1207
1208   return lhc_index;
1209 }
1210
1211 static u32
1212 http_stop_listen (u32 listener_index)
1213 {
1214   http_conn_t *lhc;
1215   int rv;
1216
1217   lhc = http_listener_get (listener_index);
1218
1219   vnet_unlisten_args_t a = {
1220     .handle = lhc->h_tc_session_handle,
1221     .app_index = http_main.app_index,
1222     .wrk_map_index = 0 /* default wrk */
1223   };
1224
1225   if ((rv = vnet_unlisten (&a)))
1226     clib_warning ("unlisten returned %d", rv);
1227
1228   http_listener_free (lhc);
1229
1230   return 0;
1231 }
1232
1233 static void
1234 http_transport_close (u32 hc_index, u32 thread_index)
1235 {
1236   session_t *as;
1237   http_conn_t *hc;
1238
1239   HTTP_DBG (1, "App disconnecting %x", hc_index);
1240
1241   hc = http_conn_get_w_thread (hc_index, thread_index);
1242   if (hc->state == HTTP_CONN_STATE_CONNECTING)
1243     {
1244       hc->state = HTTP_CONN_STATE_APP_CLOSED;
1245       http_disconnect_transport (hc);
1246       return;
1247     }
1248
1249   as = session_get_from_handle (hc->h_pa_session_handle);
1250
1251   /* Nothing more to send, confirm close */
1252   if (!svm_fifo_max_dequeue_cons (as->tx_fifo))
1253     {
1254       session_transport_closed_notify (&hc->connection);
1255       http_disconnect_transport (hc);
1256     }
1257   else
1258     {
1259       /* Wait for all data to be written to ts */
1260       hc->state = HTTP_CONN_STATE_APP_CLOSED;
1261     }
1262 }
1263
1264 static transport_connection_t *
1265 http_transport_get_connection (u32 hc_index, u32 thread_index)
1266 {
1267   http_conn_t *hc = http_conn_get_w_thread (hc_index, thread_index);
1268   return &hc->connection;
1269 }
1270
1271 static transport_connection_t *
1272 http_transport_get_listener (u32 listener_index)
1273 {
1274   http_conn_t *lhc = http_listener_get (listener_index);
1275   return &lhc->connection;
1276 }
1277
1278 static int
1279 http_app_tx_callback (void *session, transport_send_params_t *sp)
1280 {
1281   session_t *as = (session_t *) session;
1282   u32 max_burst_sz, sent;
1283   http_conn_t *hc;
1284
1285   HTTP_DBG (1, "app session conn index %x", as->connection_index);
1286
1287   hc = http_conn_get_w_thread (as->connection_index, as->thread_index);
1288   if (!http_state_is_tx_valid (hc))
1289     {
1290       if (hc->state != HTTP_CONN_STATE_CLOSED)
1291         clib_warning ("app data req state '%U' session state %u",
1292                       format_http_state, hc->http_state, hc->state);
1293       svm_fifo_dequeue_drop_all (as->tx_fifo);
1294       return 0;
1295     }
1296
1297   max_burst_sz = sp->max_burst_size * TRANSPORT_PACER_MIN_MSS;
1298   sp->max_burst_size = max_burst_sz;
1299
1300   http_req_run_state_machine (hc, sp);
1301
1302   if (hc->state == HTTP_CONN_STATE_APP_CLOSED)
1303     {
1304       if (!svm_fifo_max_dequeue_cons (as->tx_fifo))
1305         http_disconnect_transport (hc);
1306     }
1307
1308   sent = max_burst_sz - sp->max_burst_size;
1309
1310   return sent > 0 ? clib_max (sent / TRANSPORT_PACER_MIN_MSS, 1) : 0;
1311 }
1312
1313 static void
1314 http_transport_get_endpoint (u32 hc_index, u32 thread_index,
1315                              transport_endpoint_t *tep, u8 is_lcl)
1316 {
1317   http_conn_t *hc = http_conn_get_w_thread (hc_index, thread_index);
1318   session_t *ts;
1319
1320   ts = session_get_from_handle (hc->h_tc_session_handle);
1321   session_get_endpoint (ts, tep, is_lcl);
1322 }
1323
1324 static u8 *
1325 format_http_connection (u8 *s, va_list *args)
1326 {
1327   http_conn_t *hc = va_arg (*args, http_conn_t *);
1328   session_t *ts;
1329
1330   ts = session_get_from_handle (hc->h_tc_session_handle);
1331   s = format (s, "[%d:%d][H] app_wrk %u ts %d:%d", hc->c_thread_index,
1332               hc->c_s_index, hc->h_pa_wrk_index, ts->thread_index,
1333               ts->session_index);
1334
1335   return s;
1336 }
1337
1338 static u8 *
1339 format_http_listener (u8 *s, va_list *args)
1340 {
1341   http_conn_t *lhc = va_arg (*args, http_conn_t *);
1342   app_listener_t *al;
1343   session_t *lts;
1344
1345   al = app_listener_get_w_handle (lhc->h_tc_session_handle);
1346   lts = app_listener_get_session (al);
1347   s = format (s, "[%d:%d][H] app_wrk %u ts %d:%d", lhc->c_thread_index,
1348               lhc->c_s_index, lhc->h_pa_wrk_index, lts->thread_index,
1349               lts->session_index);
1350
1351   return s;
1352 }
1353
1354 static u8 *
1355 format_http_conn_state (u8 *s, va_list *args)
1356 {
1357   http_conn_t *hc = va_arg (*args, http_conn_t *);
1358
1359   switch (hc->state)
1360     {
1361     case HTTP_CONN_STATE_LISTEN:
1362       s = format (s, "LISTEN");
1363       break;
1364     case HTTP_CONN_STATE_CONNECTING:
1365       s = format (s, "CONNECTING");
1366       break;
1367     case HTTP_CONN_STATE_ESTABLISHED:
1368       s = format (s, "ESTABLISHED");
1369       break;
1370     case HTTP_CONN_STATE_TRANSPORT_CLOSED:
1371       s = format (s, "TRANSPORT_CLOSED");
1372       break;
1373     case HTTP_CONN_STATE_APP_CLOSED:
1374       s = format (s, "APP_CLOSED");
1375       break;
1376     case HTTP_CONN_STATE_CLOSED:
1377       s = format (s, "CLOSED");
1378       break;
1379     }
1380
1381   return s;
1382 }
1383
1384 static u8 *
1385 format_http_transport_connection (u8 *s, va_list *args)
1386 {
1387   u32 tc_index = va_arg (*args, u32);
1388   u32 thread_index = va_arg (*args, u32);
1389   u32 verbose = va_arg (*args, u32);
1390   http_conn_t *hc;
1391
1392   hc = http_conn_get_w_thread (tc_index, thread_index);
1393
1394   s = format (s, "%-" SESSION_CLI_ID_LEN "U", format_http_connection, hc);
1395   if (verbose)
1396     {
1397       s =
1398         format (s, "%-" SESSION_CLI_STATE_LEN "U", format_http_conn_state, hc);
1399       if (verbose > 1)
1400         s = format (s, "\n");
1401     }
1402
1403   return s;
1404 }
1405
1406 static u8 *
1407 format_http_transport_listener (u8 *s, va_list *args)
1408 {
1409   u32 tc_index = va_arg (*args, u32);
1410   u32 __clib_unused thread_index = va_arg (*args, u32);
1411   u32 __clib_unused verbose = va_arg (*args, u32);
1412   http_conn_t *lhc = http_listener_get (tc_index);
1413
1414   s = format (s, "%-" SESSION_CLI_ID_LEN "U", format_http_listener, lhc);
1415   if (verbose)
1416     s =
1417       format (s, "%-" SESSION_CLI_STATE_LEN "U", format_http_conn_state, lhc);
1418   return s;
1419 }
1420
1421 static const transport_proto_vft_t http_proto = {
1422   .enable = http_transport_enable,
1423   .connect = http_transport_connect,
1424   .start_listen = http_start_listen,
1425   .stop_listen = http_stop_listen,
1426   .close = http_transport_close,
1427   .custom_tx = http_app_tx_callback,
1428   .get_connection = http_transport_get_connection,
1429   .get_listener = http_transport_get_listener,
1430   .get_transport_endpoint = http_transport_get_endpoint,
1431   .format_connection = format_http_transport_connection,
1432   .format_listener = format_http_transport_listener,
1433   .transport_options = {
1434     .name = "http",
1435     .short_name = "H",
1436     .tx_type = TRANSPORT_TX_INTERNAL,
1437     .service_type = TRANSPORT_SERVICE_APP,
1438   },
1439 };
1440
1441 static clib_error_t *
1442 http_transport_init (vlib_main_t *vm)
1443 {
1444   http_main_t *hm = &http_main;
1445
1446   transport_register_protocol (TRANSPORT_PROTO_HTTP, &http_proto,
1447                                FIB_PROTOCOL_IP4, ~0);
1448   transport_register_protocol (TRANSPORT_PROTO_HTTP, &http_proto,
1449                                FIB_PROTOCOL_IP6, ~0);
1450
1451   /* Default values, configurable via startup conf */
1452   hm->add_seg_size = 256 << 20;
1453   hm->first_seg_size = 32 << 20;
1454   hm->fifo_size = 512 << 10;
1455
1456   return 0;
1457 }
1458
1459 VLIB_INIT_FUNCTION (http_transport_init);
1460
1461 static clib_error_t *
1462 http_config_fn (vlib_main_t *vm, unformat_input_t *input)
1463 {
1464   http_main_t *hm = &http_main;
1465   uword mem_sz;
1466
1467   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1468     {
1469       if (unformat (input, "first-segment-size %U", unformat_memory_size,
1470                     &mem_sz))
1471         {
1472           hm->first_seg_size = clib_max (mem_sz, 1 << 20);
1473           if (hm->first_seg_size != mem_sz)
1474             clib_warning ("first seg size too small %u", mem_sz);
1475         }
1476       else if (unformat (input, "add-segment-size %U", unformat_memory_size,
1477                          &mem_sz))
1478         {
1479           hm->add_seg_size = clib_max (mem_sz, 1 << 20);
1480           if (hm->add_seg_size != mem_sz)
1481             clib_warning ("add seg size too small %u", mem_sz);
1482         }
1483       else if (unformat (input, "fifo-size %U", unformat_memory_size, &mem_sz))
1484         {
1485           hm->fifo_size = clib_clamp (mem_sz, 4 << 10, 2 << 30);
1486           if (hm->fifo_size != mem_sz)
1487             clib_warning ("invalid fifo size %lu", mem_sz);
1488         }
1489       else
1490         return clib_error_return (0, "unknown input `%U'",
1491                                   format_unformat_error, input);
1492     }
1493   return 0;
1494 }
1495
1496 VLIB_CONFIG_FUNCTION (http_config_fn, "http");
1497
1498 VLIB_PLUGIN_REGISTER () = {
1499   .version = VPP_BUILD_VER,
1500   .description = "Hypertext Transfer Protocol (HTTP)",
1501   .default_disabled = 0,
1502 };
1503
1504 /*
1505  * fd.io coding-style-patch-verification: ON
1506  *
1507  * Local Variables:
1508  * eval: (c-set-style "gnu")
1509  * End:
1510  */