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       goto error;
 771     }
 772   vec_free (header);
 773
 774   /* Start sending the actual data */
 775   http_state_change (hc, HTTP_STATE_APP_IO_MORE_DATA);
 776
 777   ASSERT (sp->max_burst_size >= offset);
 778   sp->max_burst_size -= offset;
 779   return HTTP_SM_CONTINUE;
 780
 781 error:
 782   clib_warning ("unexpected msg type from app %u", msg.type);
 783   http_send_error (hc, sc);
 784   http_state_change (hc, HTTP_STATE_WAIT_CLIENT_METHOD);
 785   session_transport_closing_notify (&hc->connection);
 786   http_disconnect_transport (hc);
 787   return HTTP_SM_STOP;
 788 }
 789
 790 static http_sm_result_t
 791 http_state_wait_app_method (http_conn_t *hc, transport_send_params_t *sp)
 792 {
 793   http_status_code_t sc;
 794   http_msg_t msg;
 795   session_t *as;
 796   u8 *buf = 0, *request;
 797   u32 offset;
 798   int rv;
 799
 800   as = session_get_from_handle (hc->h_pa_session_handle);
 801
 802   rv = svm_fifo_dequeue (as->tx_fifo, sizeof (msg), (u8 *) &msg);
 803   ASSERT (rv == sizeof (msg));
 804
 805   if (msg.data.type > HTTP_MSG_DATA_PTR)
 806     {
 807       clib_warning ("no data");
 808       sc = HTTP_STATUS_INTERNAL_ERROR;
 809       goto error;
 810     }
 811
 812   if (msg.type != HTTP_MSG_REQUEST)
 813     {
 814       clib_warning ("unexpected message type %d", msg.type);
 815       sc = HTTP_STATUS_INTERNAL_ERROR;
 816       goto error;
 817     }
 818
 819   sc = msg.code;
 820
 821   vec_validate (buf, msg.data.len - 1);
 822   rv = svm_fifo_dequeue (as->tx_fifo, msg.data.len, buf);
 823   ASSERT (rv == msg.data.len);
 824
 825   request = format (0, http_request_template, buf);
 826   offset = http_send_data (hc, request, vec_len (request), 0);
 827   if (offset != vec_len (request))
 828     {
 829       clib_warning ("sending request failed!");
 830       sc = HTTP_STATUS_INTERNAL_ERROR;
 831       goto error;
 832     }
 833
 834   http_state_change (hc, HTTP_STATE_WAIT_SERVER_REPLY);
 835
 836   vec_free (buf);
 837   vec_free (request);
 838
 839   return HTTP_SM_CONTINUE;
 840
 841 error:
 842   clib_warning ("unexpected msg type from app %u", msg.type);
 843   http_send_error (hc, sc);
 844   session_transport_closing_notify (&hc->connection);
 845   http_disconnect_transport (hc);
 846   return HTTP_SM_STOP;
 847 }
 848
 849 static void
 850 http_app_enqueue (http_conn_t *hc, session_t *as)
 851 {
 852   app_worker_t *app_wrk;
 853   u32 dlen, max_enq, n_enq;
 854   int rv;
 855
 856   dlen = vec_len (hc->rx_buf) - hc->rx_buf_offset;
 857   if (!dlen)
 858     return;
 859
 860   max_enq = svm_fifo_max_enqueue (as->rx_fifo);
 861   n_enq = clib_min (max_enq, dlen);
 862   rv = svm_fifo_enqueue (as->rx_fifo, n_enq, &hc->rx_buf[hc->rx_buf_offset]);
 863   if (rv < 0)
 864     return;
 865
 866   hc->rx_buf_offset += rv;
 867   if (hc->rx_buf_offset >= vec_len (hc->rx_buf))
 868     {
 869       vec_reset_length (hc->rx_buf);
 870       hc->rx_buf_offset = 0;
 871     }
 872
 873   app_wrk = app_worker_get_if_valid (as->app_wrk_index);
 874   ASSERT (app_wrk);
 875   app_worker_rx_notify (app_wrk, as);
 876 }
 877
 878 static http_sm_result_t
 879 http_state_client_io_more_data (http_conn_t *hc, transport_send_params_t *sp)
 880 {
 881   session_t *as, *ts;
 882   u32 max_deq;
 883   int n_read;
 884
 885   as = session_get_from_handle (hc->h_pa_session_handle);
 886   ts = session_get_from_handle (hc->h_tc_session_handle);
 887
 888   http_app_enqueue (hc, as);
 889
 890   if (hc->to_recv == 0)
 891     {
 892       http_state_change (hc, HTTP_STATE_WAIT_CLIENT_METHOD);
 893       return HTTP_SM_STOP;
 894     }
 895
 896   max_deq = svm_fifo_max_dequeue (ts->rx_fifo);
 897   if (max_deq > 0)
 898     {
 899       vec_validate (hc->rx_buf, max_deq - 1);
 900       n_read = svm_fifo_dequeue (ts->rx_fifo, max_deq, hc->rx_buf);
 901       ASSERT (n_read == max_deq);
 902
 903       if (svm_fifo_is_empty (ts->rx_fifo))
 904         svm_fifo_unset_event (ts->rx_fifo);
 905
 906       hc->to_recv -= n_read;
 907       vec_set_len (hc->rx_buf, n_read);
 908     }
 909
 910   if (hc->rx_buf_offset < vec_len (hc->rx_buf) ||
 911       svm_fifo_max_dequeue_cons (ts->rx_fifo))
 912     {
 913         session_enqueue_notify (ts);
 914     }
 915   return HTTP_SM_CONTINUE;
 916 }
 917
 918 static http_sm_result_t
 919 http_state_app_io_more_data (http_conn_t *hc, transport_send_params_t *sp)
 920 {
 921   u32 max_send = 64 << 10, n_segs;
 922   http_buffer_t *hb = &hc->tx_buf;
 923   svm_fifo_seg_t *seg;
 924   session_t *ts;
 925   int sent = 0;
 926
 927   max_send = clib_min (max_send, sp->max_burst_size);
 928   ts = session_get_from_handle (hc->h_tc_session_handle);
 929   if ((seg = http_buffer_get_segs (hb, max_send, &n_segs)))
 930     sent = svm_fifo_enqueue_segments (ts->tx_fifo, seg, n_segs,
 931                                       1 /* allow partial */);
 932
 933   if (sent > 0)
 934     {
 935       /* Ask scheduler to notify app of deq event if needed */
 936       sp->bytes_dequeued += http_buffer_drain (hb, sent);
 937       sp->max_burst_size -= sent;
 938     }
 939
 940   /* Not finished sending all data */
 941   if (!http_buffer_is_drained (hb))
 942     {
 943       if (sent && svm_fifo_set_event (ts->tx_fifo))
 944         session_send_io_evt_to_thread (ts->tx_fifo, SESSION_IO_EVT_TX);
 945
 946       if (svm_fifo_max_enqueue (ts->tx_fifo) < HTTP_FIFO_THRESH)
 947         {
 948           /* Deschedule http session and wait for deq notification if
 949            * underlying ts tx fifo almost full */
 950           svm_fifo_add_want_deq_ntf (ts->tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF);
 951           transport_connection_deschedule (&hc->connection);
 952           sp->flags |= TRANSPORT_SND_F_DESCHED;
 953         }
 954     }
 955   else
 956     {
 957       if (sent && svm_fifo_set_event (ts->tx_fifo))
 958         session_send_io_evt_to_thread (ts->tx_fifo, SESSION_IO_EVT_TX_FLUSH);
 959
 960       /* Finished transaction, back to HTTP_STATE_WAIT_METHOD */
 961       http_state_change (hc, HTTP_STATE_WAIT_CLIENT_METHOD);
 962       http_buffer_free (&hc->tx_buf);
 963     }
 964
 965   return HTTP_SM_STOP;
 966 }
 967
 968 typedef http_sm_result_t (*http_sm_handler) (http_conn_t *,
 969                                              transport_send_params_t *sp);
 970
 971 static http_sm_handler state_funcs[HTTP_N_STATES] = {
 972   0, /* idle state */
 973   http_state_wait_app_method,
 974   http_state_wait_client_method,
 975   http_state_wait_server_reply,
 976   http_state_wait_app_reply,
 977   http_state_client_io_more_data,
 978   http_state_app_io_more_data,
 979 };
 980
 981 static void
 982 http_req_run_state_machine (http_conn_t *hc, transport_send_params_t *sp)
 983 {
 984   http_sm_result_t res;
 985   do
 986     {
 987       res = state_funcs[hc->http_state](hc, sp);
 988       if (res == HTTP_SM_ERROR)
 989         {
 990           HTTP_DBG (1, "error in state machine %d", res);
 991           return;
 992         }
 993     }
 994   while (res == HTTP_SM_CONTINUE);
 995
 996   /* Reset the session expiration timer */
 997   http_conn_timer_update (hc);
 998 }
 999
1000 static int
1001 http_ts_rx_callback (session_t *ts)
1002 {
1003   http_conn_t *hc;
1004
1005   hc = http_conn_get_w_thread (ts->opaque, ts->thread_index);
1006   if (!hc)
1007     {
1008       clib_warning ("http connection not found (ts %d)", ts->opaque);
1009       return -1;
1010     }
1011
1012   http_req_run_state_machine (hc, 0);
1013
1014   if (hc->state == HTTP_CONN_STATE_TRANSPORT_CLOSED)
1015     {
1016       if (!svm_fifo_max_dequeue_cons (ts->rx_fifo))
1017         session_transport_closing_notify (&hc->connection);
1018     }
1019   return 0;
1020 }
1021
1022 int
1023 http_ts_builtin_tx_callback (session_t *ts)
1024 {
1025   http_conn_t *hc;
1026
1027   hc = http_conn_get_w_thread (ts->opaque, ts->thread_index);
1028   transport_connection_reschedule (&hc->connection);
1029
1030   return 0;
1031 }
1032
1033 static void
1034 http_ts_cleanup_callback (session_t *ts, session_cleanup_ntf_t ntf)
1035 {
1036   http_conn_t *hc;
1037
1038   if (ntf == SESSION_CLEANUP_TRANSPORT)
1039     return;
1040
1041   hc = http_conn_get_w_thread (ts->opaque, ts->thread_index);
1042   if (!hc)
1043     {
1044       clib_warning ("no http connection for %u", ts->session_index);
1045       return;
1046     }
1047
1048   vec_free (hc->rx_buf);
1049
1050   http_buffer_free (&hc->tx_buf);
1051   http_conn_timer_stop (hc);
1052
1053   session_transport_delete_notify (&hc->connection);
1054   http_conn_free (hc);
1055 }
1056
1057 int
1058 http_add_segment_callback (u32 client_index, u64 segment_handle)
1059 {
1060   /* No-op for builtin */
1061   return 0;
1062 }
1063
1064 int
1065 http_del_segment_callback (u32 client_index, u64 segment_handle)
1066 {
1067   return 0;
1068 }
1069
1070 static session_cb_vft_t http_app_cb_vft = {
1071   .session_accept_callback = http_ts_accept_callback,
1072   .session_disconnect_callback = http_ts_disconnect_callback,
1073   .session_connected_callback = http_ts_connected_callback,
1074   .session_reset_callback = http_ts_reset_callback,
1075   .session_cleanup_callback = http_ts_cleanup_callback,
1076   .add_segment_callback = http_add_segment_callback,
1077   .del_segment_callback = http_del_segment_callback,
1078   .builtin_app_rx_callback = http_ts_rx_callback,
1079   .builtin_app_tx_callback = http_ts_builtin_tx_callback,
1080 };
1081
1082 static clib_error_t *
1083 http_transport_enable (vlib_main_t *vm, u8 is_en)
1084 {
1085   vnet_app_detach_args_t _da, *da = &_da;
1086   vnet_app_attach_args_t _a, *a = &_a;
1087   u64 options[APP_OPTIONS_N_OPTIONS];
1088   http_main_t *hm = &http_main;
1089
1090   if (!is_en)
1091     {
1092       da->app_index = hm->app_index;
1093       da->api_client_index = APP_INVALID_INDEX;
1094       vnet_application_detach (da);
1095       return 0;
1096     }
1097
1098   vec_validate (hm->wrk, vlib_num_workers ());
1099
1100   clib_memset (a, 0, sizeof (*a));
1101   clib_memset (options, 0, sizeof (options));
1102
1103   a->session_cb_vft = &http_app_cb_vft;
1104   a->api_client_index = APP_INVALID_INDEX;
1105   a->options = options;
1106   a->name = format (0, "http");
1107   a->options[APP_OPTIONS_SEGMENT_SIZE] = hm->first_seg_size;
1108   a->options[APP_OPTIONS_ADD_SEGMENT_SIZE] = hm->add_seg_size;
1109   a->options[APP_OPTIONS_RX_FIFO_SIZE] = hm->fifo_size;
1110   a->options[APP_OPTIONS_TX_FIFO_SIZE] = hm->fifo_size;
1111   a->options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_IS_BUILTIN;
1112   a->options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
1113   a->options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_IS_TRANSPORT_APP;
1114
1115   if (vnet_application_attach (a))
1116     return clib_error_return (0, "failed to attach http app");
1117
1118   hm->app_index = a->app_index;
1119   vec_free (a->name);
1120
1121   clib_timebase_init (&hm->timebase, 0 /* GMT */, CLIB_TIMEBASE_DAYLIGHT_NONE,
1122                       &vm->clib_time /* share the system clock */);
1123
1124   http_timers_init (vm, http_conn_timeout_cb);
1125
1126   return 0;
1127 }
1128
1129 static int
1130 http_transport_connect (transport_endpoint_cfg_t *tep)
1131 {
1132   vnet_connect_args_t _cargs, *cargs = &_cargs;
1133   http_main_t *hm = &http_main;
1134   session_endpoint_cfg_t *sep = (session_endpoint_cfg_t *) tep;
1135   application_t *app;
1136   http_conn_t *hc;
1137   int error;
1138   u32 hc_index;
1139   app_worker_t *app_wrk = app_worker_get (sep->app_wrk_index);
1140
1141   clib_memset (cargs, 0, sizeof (*cargs));
1142   clib_memcpy (&cargs->sep_ext, sep, sizeof (session_endpoint_cfg_t));
1143   cargs->sep.transport_proto = TRANSPORT_PROTO_TCP;
1144   cargs->app_index = hm->app_index;
1145   app = application_get (app_wrk->app_index);
1146   cargs->sep_ext.ns_index = app->ns_index;
1147
1148   hc_index = http_conn_alloc_w_thread (0 /* ts->thread_index */);
1149   hc = http_conn_get_w_thread (hc_index, 0);
1150   hc->h_pa_wrk_index = sep->app_wrk_index;
1151   hc->h_pa_app_api_ctx = sep->opaque;
1152   hc->state = HTTP_CONN_STATE_CONNECTING;
1153   cargs->api_context = hc_index;
1154
1155   HTTP_DBG (1, "hc ho_index %x", hc_index);
1156
1157   if ((error = vnet_connect (cargs)))
1158     return error;
1159
1160   return 0;
1161 }
1162
1163 static u32
1164 http_start_listen (u32 app_listener_index, transport_endpoint_cfg_t *tep)
1165 {
1166   vnet_listen_args_t _args = {}, *args = &_args;
1167   session_t *ts_listener, *app_listener;
1168   http_main_t *hm = &http_main;
1169   session_endpoint_cfg_t *sep;
1170   app_worker_t *app_wrk;
1171   transport_proto_t tp;
1172   app_listener_t *al;
1173   application_t *app;
1174   http_conn_t *lhc;
1175   u32 lhc_index;
1176
1177   sep = (session_endpoint_cfg_t *) tep;
1178
1179   app_wrk = app_worker_get (sep->app_wrk_index);
1180   app = application_get (app_wrk->app_index);
1181
1182   args->app_index = hm->app_index;
1183   args->sep_ext = *sep;
1184   args->sep_ext.ns_index = app->ns_index;
1185   tp = sep->ext_cfg ? TRANSPORT_PROTO_TLS : TRANSPORT_PROTO_TCP;
1186   args->sep_ext.transport_proto = tp;
1187
1188   if (vnet_listen (args))
1189     return SESSION_INVALID_INDEX;
1190
1191   lhc_index = http_listener_alloc ();
1192   lhc = http_listener_get (lhc_index);
1193
1194   /* Grab transport connection listener and link to http listener */
1195   lhc->h_tc_session_handle = args->handle;
1196   al = app_listener_get_w_handle (lhc->h_tc_session_handle);
1197   ts_listener = app_listener_get_session (al);
1198   ts_listener->opaque = lhc_index;
1199
1200   /* Grab application listener and link to http listener */
1201   app_listener = listen_session_get (app_listener_index);
1202   lhc->h_pa_wrk_index = sep->app_wrk_index;
1203   lhc->h_pa_session_handle = listen_session_get_handle (app_listener);
1204   lhc->c_s_index = app_listener_index;
1205   lhc->c_flags |= TRANSPORT_CONNECTION_F_NO_LOOKUP;
1206
1207   return lhc_index;
1208 }
1209
1210 static u32
1211 http_stop_listen (u32 listener_index)
1212 {
1213   http_conn_t *lhc;
1214   int rv;
1215
1216   lhc = http_listener_get (listener_index);
1217
1218   vnet_unlisten_args_t a = {
1219     .handle = lhc->h_tc_session_handle,
1220     .app_index = http_main.app_index,
1221     .wrk_map_index = 0 /* default wrk */
1222   };
1223
1224   if ((rv = vnet_unlisten (&a)))
1225     clib_warning ("unlisten returned %d", rv);
1226
1227   http_listener_free (lhc);
1228
1229   return 0;
1230 }
1231
1232 static void
1233 http_transport_close (u32 hc_index, u32 thread_index)
1234 {
1235   session_t *as;
1236   http_conn_t *hc;
1237
1238   HTTP_DBG (1, "App disconnecting %x", hc_index);
1239
1240   hc = http_conn_get_w_thread (hc_index, thread_index);
1241   if (hc->state == HTTP_CONN_STATE_CONNECTING)
1242     {
1243       hc->state = HTTP_CONN_STATE_APP_CLOSED;
1244       http_disconnect_transport (hc);
1245       return;
1246     }
1247
1248   as = session_get_from_handle (hc->h_pa_session_handle);
1249
1250   /* Nothing more to send, confirm close */
1251   if (!svm_fifo_max_dequeue_cons (as->tx_fifo))
1252     {
1253       session_transport_closed_notify (&hc->connection);
1254       http_disconnect_transport (hc);
1255     }
1256   else
1257     {
1258       /* Wait for all data to be written to ts */
1259       hc->state = HTTP_CONN_STATE_APP_CLOSED;
1260     }
1261 }
1262
1263 static transport_connection_t *
1264 http_transport_get_connection (u32 hc_index, u32 thread_index)
1265 {
1266   http_conn_t *hc = http_conn_get_w_thread (hc_index, thread_index);
1267   return &hc->connection;
1268 }
1269
1270 static transport_connection_t *
1271 http_transport_get_listener (u32 listener_index)
1272 {
1273   http_conn_t *lhc = http_listener_get (listener_index);
1274   return &lhc->connection;
1275 }
1276
1277 static int
1278 http_app_tx_callback (void *session, transport_send_params_t *sp)
1279 {
1280   session_t *as = (session_t *) session;
1281   u32 max_burst_sz, sent;
1282   http_conn_t *hc;
1283
1284   HTTP_DBG (1, "app session conn index %x", as->connection_index);
1285
1286   hc = http_conn_get_w_thread (as->connection_index, as->thread_index);
1287   if (!http_state_is_tx_valid (hc))
1288     {
1289       if (hc->state != HTTP_CONN_STATE_CLOSED)
1290         clib_warning ("app data req state '%U' session state %u",
1291                       format_http_state, hc->http_state, hc->state);
1292       svm_fifo_dequeue_drop_all (as->tx_fifo);
1293       return 0;
1294     }
1295
1296   max_burst_sz = sp->max_burst_size * TRANSPORT_PACER_MIN_MSS;
1297   sp->max_burst_size = max_burst_sz;
1298
1299   http_req_run_state_machine (hc, sp);
1300
1301   if (hc->state == HTTP_CONN_STATE_APP_CLOSED)
1302     {
1303       if (!svm_fifo_max_dequeue_cons (as->tx_fifo))
1304         http_disconnect_transport (hc);
1305     }
1306
1307   sent = max_burst_sz - sp->max_burst_size;
1308
1309   return sent > 0 ? clib_max (sent / TRANSPORT_PACER_MIN_MSS, 1) : 0;
1310 }
1311
1312 static void
1313 http_transport_get_endpoint (u32 hc_index, u32 thread_index,
1314                              transport_endpoint_t *tep, u8 is_lcl)
1315 {
1316   http_conn_t *hc = http_conn_get_w_thread (hc_index, thread_index);
1317   session_t *ts;
1318
1319   ts = session_get_from_handle (hc->h_tc_session_handle);
1320   session_get_endpoint (ts, tep, is_lcl);
1321 }
1322
1323 static u8 *
1324 format_http_connection (u8 *s, va_list *args)
1325 {
1326   http_conn_t *hc = va_arg (*args, http_conn_t *);
1327   session_t *ts;
1328
1329   ts = session_get_from_handle (hc->h_tc_session_handle);
1330   s = format (s, "[%d:%d][H] app_wrk %u ts %d:%d", hc->c_thread_index,
1331               hc->c_s_index, hc->h_pa_wrk_index, ts->thread_index,
1332               ts->session_index);
1333
1334   return s;
1335 }
1336
1337 static u8 *
1338 format_http_listener (u8 *s, va_list *args)
1339 {
1340   http_conn_t *lhc = va_arg (*args, http_conn_t *);
1341   app_listener_t *al;
1342   session_t *lts;
1343
1344   al = app_listener_get_w_handle (lhc->h_tc_session_handle);
1345   lts = app_listener_get_session (al);
1346   s = format (s, "[%d:%d][H] app_wrk %u ts %d:%d", lhc->c_thread_index,
1347               lhc->c_s_index, lhc->h_pa_wrk_index, lts->thread_index,
1348               lts->session_index);
1349
1350   return s;
1351 }
1352
1353 static u8 *
1354 format_http_conn_state (u8 *s, va_list *args)
1355 {
1356   http_conn_t *hc = va_arg (*args, http_conn_t *);
1357
1358   switch (hc->state)
1359     {
1360     case HTTP_CONN_STATE_LISTEN:
1361       s = format (s, "LISTEN");
1362       break;
1363     case HTTP_CONN_STATE_CONNECTING:
1364       s = format (s, "CONNECTING");
1365       break;
1366     case HTTP_CONN_STATE_ESTABLISHED:
1367       s = format (s, "ESTABLISHED");
1368       break;
1369     case HTTP_CONN_STATE_TRANSPORT_CLOSED:
1370       s = format (s, "TRANSPORT_CLOSED");
1371       break;
1372     case HTTP_CONN_STATE_APP_CLOSED:
1373       s = format (s, "APP_CLOSED");
1374       break;
1375     case HTTP_CONN_STATE_CLOSED:
1376       s = format (s, "CLOSED");
1377       break;
1378     }
1379
1380   return s;
1381 }
1382
1383 static u8 *
1384 format_http_transport_connection (u8 *s, va_list *args)
1385 {
1386   u32 tc_index = va_arg (*args, u32);
1387   u32 thread_index = va_arg (*args, u32);
1388   u32 verbose = va_arg (*args, u32);
1389   http_conn_t *hc;
1390
1391   hc = http_conn_get_w_thread (tc_index, thread_index);
1392
1393   s = format (s, "%-" SESSION_CLI_ID_LEN "U", format_http_connection, hc);
1394   if (verbose)
1395     {
1396       s =
1397         format (s, "%-" SESSION_CLI_STATE_LEN "U", format_http_conn_state, hc);
1398       if (verbose > 1)
1399         s = format (s, "\n");
1400     }
1401
1402   return s;
1403 }
1404
1405 static u8 *
1406 format_http_transport_listener (u8 *s, va_list *args)
1407 {
1408   u32 tc_index = va_arg (*args, u32);
1409   u32 __clib_unused thread_index = va_arg (*args, u32);
1410   u32 __clib_unused verbose = va_arg (*args, u32);
1411   http_conn_t *lhc = http_listener_get (tc_index);
1412
1413   s = format (s, "%-" SESSION_CLI_ID_LEN "U", format_http_listener, lhc);
1414   if (verbose)
1415     s =
1416       format (s, "%-" SESSION_CLI_STATE_LEN "U", format_http_conn_state, lhc);
1417   return s;
1418 }
1419
1420 static const transport_proto_vft_t http_proto = {
1421   .enable = http_transport_enable,
1422   .connect = http_transport_connect,
1423   .start_listen = http_start_listen,
1424   .stop_listen = http_stop_listen,
1425   .close = http_transport_close,
1426   .custom_tx = http_app_tx_callback,
1427   .get_connection = http_transport_get_connection,
1428   .get_listener = http_transport_get_listener,
1429   .get_transport_endpoint = http_transport_get_endpoint,
1430   .format_connection = format_http_transport_connection,
1431   .format_listener = format_http_transport_listener,
1432   .transport_options = {
1433     .name = "http",
1434     .short_name = "H",
1435     .tx_type = TRANSPORT_TX_INTERNAL,
1436     .service_type = TRANSPORT_SERVICE_APP,
1437   },
1438 };
1439
1440 static clib_error_t *
1441 http_transport_init (vlib_main_t *vm)
1442 {
1443   http_main_t *hm = &http_main;
1444
1445   transport_register_protocol (TRANSPORT_PROTO_HTTP, &http_proto,
1446                                FIB_PROTOCOL_IP4, ~0);
1447   transport_register_protocol (TRANSPORT_PROTO_HTTP, &http_proto,
1448                                FIB_PROTOCOL_IP6, ~0);
1449
1450   /* Default values, configurable via startup conf */
1451   hm->add_seg_size = 256 << 20;
1452   hm->first_seg_size = 32 << 20;
1453   hm->fifo_size = 512 << 10;
1454
1455   return 0;
1456 }
1457
1458 VLIB_INIT_FUNCTION (http_transport_init);
1459
1460 static clib_error_t *
1461 http_config_fn (vlib_main_t *vm, unformat_input_t *input)
1462 {
1463   http_main_t *hm = &http_main;
1464   uword mem_sz;
1465
1466   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1467     {
1468       if (unformat (input, "first-segment-size %U", unformat_memory_size,
1469                     &mem_sz))
1470         {
1471           hm->first_seg_size = clib_max (mem_sz, 1 << 20);
1472           if (hm->first_seg_size != mem_sz)
1473             clib_warning ("first seg size too small %u", mem_sz);
1474         }
1475       else if (unformat (input, "add-segment-size %U", unformat_memory_size,
1476                          &mem_sz))
1477         {
1478           hm->add_seg_size = clib_max (mem_sz, 1 << 20);
1479           if (hm->add_seg_size != mem_sz)
1480             clib_warning ("add seg size too small %u", mem_sz);
1481         }
1482       else if (unformat (input, "fifo-size %U", unformat_memory_size, &mem_sz))
1483         {
1484           hm->fifo_size = clib_clamp (mem_sz, 4 << 10, 2 << 30);
1485           if (hm->fifo_size != mem_sz)
1486             clib_warning ("invalid fifo size %lu", mem_sz);
1487         }
1488       else
1489         return clib_error_return (0, "unknown input `%U'",
1490                                   format_unformat_error, input);
1491     }
1492   return 0;
1493 }
1494
1495 VLIB_CONFIG_FUNCTION (http_config_fn, "http");
1496
1497 VLIB_PLUGIN_REGISTER () = {
1498   .version = VPP_BUILD_VER,
1499   .description = "Hypertext Transfer Protocol (HTTP)",
1500   .default_disabled = 0,
1501 };
1502
1503 /*
1504  * fd.io coding-style-patch-verification: ON
1505  *
1506  * Local Variables:
1507  * eval: (c-set-style "gnu")
1508  * End:
1509  */