src/plugins/http_static/static_server.c

   1 /*
   2  * Copyright (c) 2017-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_static/http_static.h>
  17
  18 #include <sys/types.h>
  19 #include <sys/stat.h>
  20 #include <unistd.h>
  21
  22 /** @file static_server.c
  23  *  Static http server, sufficient to serve .html / .css / .js content.
  24  */
  25 /*? %%clicmd:group_label Static HTTP Server %% ?*/
  26
  27 #define HSS_FIFO_THRESH (16 << 10)
  28
  29 hss_main_t hss_main;
  30
  31 static hss_session_t *
  32 hss_session_alloc (u32 thread_index)
  33 {
  34   hss_main_t *hsm = &hss_main;
  35   hss_session_t *hs;
  36
  37   pool_get_zero (hsm->sessions[thread_index], hs);
  38   hs->session_index = hs - hsm->sessions[thread_index];
  39   hs->thread_index = thread_index;
  40   hs->cache_pool_index = ~0;
  41   return hs;
  42 }
  43
  44 __clib_export hss_session_t *
  45 hss_session_get (u32 thread_index, u32 hs_index)
  46 {
  47   hss_main_t *hsm = &hss_main;
  48   if (pool_is_free_index (hsm->sessions[thread_index], hs_index))
  49     return 0;
  50   return pool_elt_at_index (hsm->sessions[thread_index], hs_index);
  51 }
  52
  53 static void
  54 hss_session_free (hss_session_t *hs)
  55 {
  56   hss_main_t *hsm = &hss_main;
  57
  58   pool_put (hsm->sessions[hs->thread_index], hs);
  59
  60   if (CLIB_DEBUG)
  61     {
  62       u32 save_thread_index;
  63       save_thread_index = hs->thread_index;
  64       /* Poison the entry, preserve timer state and thread index */
  65       memset (hs, 0xfa, sizeof (*hs));
  66       hs->thread_index = save_thread_index;
  67     }
  68 }
  69
  70 /** \brief Disconnect a session
  71  */
  72 static void
  73 hss_session_disconnect_transport (hss_session_t *hs)
  74 {
  75   vnet_disconnect_args_t _a = { 0 }, *a = &_a;
  76   a->handle = hs->vpp_session_handle;
  77   a->app_index = hss_main.app_index;
  78   vnet_disconnect_session (a);
  79 }
  80
  81 static void
  82 start_send_data (hss_session_t *hs, http_status_code_t status)
  83 {
  84   http_msg_t msg;
  85   session_t *ts;
  86   int rv;
  87
  88   ts = session_get (hs->vpp_session_index, hs->thread_index);
  89
  90   msg.type = HTTP_MSG_REPLY;
  91   msg.code = status;
  92   msg.content_type = HTTP_CONTENT_TEXT_HTML;
  93   msg.data.len = hs->data_len;
  94
  95   if (hs->data_len > hss_main.use_ptr_thresh)
  96     {
  97       msg.data.type = HTTP_MSG_DATA_PTR;
  98       rv = svm_fifo_enqueue (ts->tx_fifo, sizeof (msg), (u8 *) &msg);
  99       ASSERT (rv == sizeof (msg));
 100
 101       uword data = pointer_to_uword (hs->data);
 102       rv = svm_fifo_enqueue (ts->tx_fifo, sizeof (data), (u8 *) &data);
 103       ASSERT (rv == sizeof (sizeof (data)));
 104
 105       goto done;
 106     }
 107
 108   msg.data.type = HTTP_MSG_DATA_INLINE;
 109
 110   rv = svm_fifo_enqueue (ts->tx_fifo, sizeof (msg), (u8 *) &msg);
 111   ASSERT (rv == sizeof (msg));
 112
 113   if (!msg.data.len)
 114     goto done;
 115
 116   rv = svm_fifo_enqueue (ts->tx_fifo, hs->data_len, hs->data);
 117
 118   if (rv != hs->data_len)
 119     {
 120       hs->data_offset = rv;
 121       svm_fifo_add_want_deq_ntf (ts->tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF);
 122     }
 123
 124 done:
 125
 126   if (svm_fifo_set_event (ts->tx_fifo))
 127     session_send_io_evt_to_thread (ts->tx_fifo, SESSION_IO_EVT_TX);
 128 }
 129
 130 __clib_export void
 131 hss_session_send_data (hss_url_handler_args_t *args)
 132 {
 133   hss_session_t *hs;
 134
 135   hs = hss_session_get (args->sh.thread_index, args->sh.session_index);
 136   if (!hs)
 137     return;
 138
 139   if (hs->data && hs->free_data)
 140     vec_free (hs->data);
 141
 142   hs->data = args->data;
 143   hs->data_len = args->data_len;
 144   hs->free_data = args->free_vec_data;
 145   start_send_data (hs, args->sc);
 146 }
 147
 148 static int
 149 try_url_handler (hss_main_t *hsm, hss_session_t *hs, http_req_method_t rt,
 150                  u8 *request)
 151 {
 152   http_status_code_t sc = HTTP_STATUS_OK;
 153   hss_url_handler_args_t args = {};
 154   uword *p, *url_table;
 155   int rv;
 156
 157   if (!hsm->enable_url_handlers || !request)
 158     return -1;
 159
 160   /* Look for built-in GET / POST handlers */
 161   url_table =
 162     (rt == HTTP_REQ_GET) ? hsm->get_url_handlers : hsm->post_url_handlers;
 163
 164   p = hash_get_mem (url_table, request);
 165   if (!p)
 166     return -1;
 167
 168   hs->path = 0;
 169   hs->data_offset = 0;
 170   hs->cache_pool_index = ~0;
 171
 172   if (hsm->debug_level > 0)
 173     clib_warning ("%s '%s'", (rt == HTTP_REQ_GET) ? "GET" : "POST", request);
 174
 175   args.reqtype = rt;
 176   args.request = request;
 177   args.sh.thread_index = hs->thread_index;
 178   args.sh.session_index = hs->session_index;
 179
 180   rv = ((hss_url_handler_fn) p[0]) (&args);
 181
 182   /* Wait for data from handler */
 183   if (rv == HSS_URL_HANDLER_ASYNC)
 184     return 0;
 185
 186   if (rv == HSS_URL_HANDLER_ERROR)
 187     {
 188       clib_warning ("builtin handler %llx hit on %s '%s' but failed!", p[0],
 189                     (rt == HTTP_REQ_GET) ? "GET" : "POST", request);
 190       sc = HTTP_STATUS_NOT_FOUND;
 191     }
 192
 193   hs->data = args.data;
 194   hs->data_len = args.data_len;
 195   hs->free_data = args.free_vec_data;
 196
 197   start_send_data (hs, sc);
 198
 199   if (!hs->data)
 200     hss_session_disconnect_transport (hs);
 201
 202   return 0;
 203 }
 204
 205 static u8
 206 file_path_is_valid (u8 *path)
 207 {
 208   struct stat _sb, *sb = &_sb;
 209
 210   if (stat ((char *) path, sb) < 0 /* can't stat the file */
 211       || (sb->st_mode & S_IFMT) != S_IFREG /* not a regular file */)
 212     return 0;
 213
 214   return 1;
 215 }
 216
 217 static u32
 218 try_index_file (hss_main_t *hsm, hss_session_t *hs, u8 *path)
 219 {
 220   u8 *port_str = 0, *redirect;
 221   transport_endpoint_t endpt;
 222   transport_proto_t proto;
 223   int print_port = 0;
 224   u16 local_port;
 225   session_t *ts;
 226   u32 plen;
 227
 228   /* Remove the trailing space */
 229   vec_dec_len (path, 1);
 230   plen = vec_len (path);
 231
 232   /* Append "index.html" */
 233   if (path[plen - 1] != '/')
 234     path = format (path, "/index.html%c", 0);
 235   else
 236     path = format (path, "index.html%c", 0);
 237
 238   if (hsm->debug_level > 0)
 239     clib_warning ("trying to find index: %s", path);
 240
 241   if (!file_path_is_valid (path))
 242     return HTTP_STATUS_NOT_FOUND;
 243
 244   /*
 245    * We found an index.html file, build a redirect
 246    */
 247   vec_delete (path, vec_len (hsm->www_root) - 1, 0);
 248
 249   ts = session_get (hs->vpp_session_index, hs->thread_index);
 250   session_get_endpoint (ts, &endpt, 1 /* is_local */);
 251
 252   local_port = clib_net_to_host_u16 (endpt.port);
 253   proto = session_type_transport_proto (ts->session_type);
 254
 255   if ((proto == TRANSPORT_PROTO_TCP && local_port != 80) ||
 256       (proto == TRANSPORT_PROTO_TLS && local_port != 443))
 257     {
 258       print_port = 1;
 259       port_str = format (0, ":%u", (u32) local_port);
 260     }
 261
 262   redirect =
 263     format (0,
 264             "Location: http%s://%U%s%s\r\n\r\n",
 265             proto == TRANSPORT_PROTO_TLS ? "s" : "", format_ip46_address,
 266             &endpt.ip, endpt.is_ip4, print_port ? port_str : (u8 *) "", path);
 267
 268   if (hsm->debug_level > 0)
 269     clib_warning ("redirect: %s", redirect);
 270
 271   vec_free (port_str);
 272
 273   hs->data = redirect;
 274   hs->data_len = vec_len (redirect);
 275   hs->free_data = 1;
 276
 277   return HTTP_STATUS_MOVED;
 278 }
 279
 280 static int
 281 try_file_handler (hss_main_t *hsm, hss_session_t *hs, http_req_method_t rt,
 282                   u8 *request)
 283 {
 284   http_status_code_t sc = HTTP_STATUS_OK;
 285   u8 *path;
 286   u32 ce_index;
 287
 288   /* Feature not enabled */
 289   if (!hsm->www_root)
 290     return -1;
 291
 292   /*
 293    * Construct the file to open
 294    * Browsers are capable of sporadically including a leading '/'
 295    */
 296   if (!request)
 297     path = format (0, "%s%c", hsm->www_root, 0);
 298   else if (request[0] == '/')
 299     path = format (0, "%s%s%c", hsm->www_root, request, 0);
 300   else
 301     path = format (0, "%s/%s%c", hsm->www_root, request, 0);
 302
 303   if (hsm->debug_level > 0)
 304     clib_warning ("%s '%s'", (rt == HTTP_REQ_GET) ? "GET" : "POST", path);
 305
 306   if (hs->data && hs->free_data)
 307     vec_free (hs->data);
 308
 309   hs->path = path;
 310   hs->data_offset = 0;
 311
 312   ce_index =
 313     hss_cache_lookup_and_attach (&hsm->cache, path, &hs->data, &hs->data_len);
 314   if (ce_index == ~0)
 315     {
 316       if (!file_path_is_valid (path))
 317         {
 318           sc = try_index_file (hsm, hs, path);
 319           goto done;
 320         }
 321       ce_index =
 322         hss_cache_add_and_attach (&hsm->cache, path, &hs->data, &hs->data_len);
 323       if (ce_index == ~0)
 324         {
 325           sc = HTTP_STATUS_INTERNAL_ERROR;
 326           goto done;
 327         }
 328     }
 329
 330   hs->cache_pool_index = ce_index;
 331
 332 done:
 333
 334   start_send_data (hs, sc);
 335   if (!hs->data)
 336     hss_session_disconnect_transport (hs);
 337
 338   return 0;
 339 }
 340
 341 static int
 342 handle_request (hss_session_t *hs, http_req_method_t rt, u8 *request)
 343 {
 344   hss_main_t *hsm = &hss_main;
 345
 346   if (!try_url_handler (hsm, hs, rt, request))
 347     return 0;
 348
 349   if (!try_file_handler (hsm, hs, rt, request))
 350     return 0;
 351
 352   /* Handler did not find anything return 404 */
 353   start_send_data (hs, HTTP_STATUS_NOT_FOUND);
 354   hss_session_disconnect_transport (hs);
 355
 356   return 0;
 357 }
 358
 359 static int
 360 hss_ts_rx_callback (session_t *ts)
 361 {
 362   hss_session_t *hs;
 363   u8 *request = 0;
 364   http_msg_t msg;
 365   int rv;
 366
 367   hs = hss_session_get (ts->thread_index, ts->opaque);
 368
 369   /* Read the http message header */
 370   rv = svm_fifo_dequeue (ts->rx_fifo, sizeof (msg), (u8 *) &msg);
 371   ASSERT (rv == sizeof (msg));
 372
 373   if (msg.type != HTTP_MSG_REQUEST ||
 374       (msg.method_type != HTTP_REQ_GET && msg.method_type != HTTP_REQ_POST))
 375     {
 376       hs->data = 0;
 377       start_send_data (hs, HTTP_STATUS_METHOD_NOT_ALLOWED);
 378       return 0;
 379     }
 380
 381   /* Read request */
 382   if (msg.data.len)
 383     {
 384       vec_validate (request, msg.data.len - 1);
 385       rv = svm_fifo_dequeue (ts->rx_fifo, msg.data.len, request);
 386       ASSERT (rv == msg.data.len);
 387     }
 388
 389   /* Find and send data */
 390   handle_request (hs, msg.method_type, request);
 391
 392   vec_free (request);
 393
 394   return 0;
 395 }
 396
 397 static int
 398 hss_ts_tx_callback (session_t *ts)
 399 {
 400   hss_session_t *hs;
 401   u32 to_send;
 402   int rv;
 403
 404   hs = hss_session_get (ts->thread_index, ts->opaque);
 405   if (!hs || !hs->data)
 406     return 0;
 407
 408   to_send = hs->data_len - hs->data_offset;
 409   rv = svm_fifo_enqueue (ts->tx_fifo, to_send, hs->data + hs->data_offset);
 410
 411   if (rv <= 0)
 412     {
 413       svm_fifo_add_want_deq_ntf (ts->tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF);
 414       return 0;
 415     }
 416
 417   if (rv < to_send)
 418     {
 419       hs->data_offset += rv;
 420       svm_fifo_add_want_deq_ntf (ts->tx_fifo, SVM_FIFO_WANT_DEQ_NOTIF);
 421     }
 422
 423   if (svm_fifo_set_event (ts->tx_fifo))
 424     session_send_io_evt_to_thread (ts->tx_fifo, SESSION_IO_EVT_TX);
 425
 426   return 0;
 427 }
 428
 429 /** \brief Session accept callback
 430  */
 431 static int
 432 hss_ts_accept_callback (session_t *ts)
 433 {
 434   hss_session_t *hs;
 435   u32 thresh;
 436
 437   hs = hss_session_alloc (ts->thread_index);
 438
 439   hs->vpp_session_index = ts->session_index;
 440   hs->vpp_session_handle = session_handle (ts);
 441
 442   /* The application sets a threshold for it's fifo to get notified when
 443    * additional data can be enqueued. We want to keep the TX fifo reasonably
 444    * full, however avoid entering a state where the
 445    * fifo is full all the time and small chunks of data are being enqueued
 446    * each time. If the fifo is small (under 16K) we set
 447    * the threshold to it's size, meaning a notification will be given when the
 448    * fifo empties.
 449    */
 450   thresh = clib_min (svm_fifo_size (ts->tx_fifo), HSS_FIFO_THRESH);
 451   svm_fifo_set_deq_thresh (ts->tx_fifo, thresh);
 452
 453   ts->opaque = hs->session_index;
 454   ts->session_state = SESSION_STATE_READY;
 455   return 0;
 456 }
 457
 458 static void
 459 hss_ts_disconnect_callback (session_t *ts)
 460 {
 461   hss_main_t *hsm = &hss_main;
 462   vnet_disconnect_args_t _a = { 0 }, *a = &_a;
 463
 464   a->handle = session_handle (ts);
 465   a->app_index = hsm->app_index;
 466   vnet_disconnect_session (a);
 467 }
 468
 469 static void
 470 hss_ts_reset_callback (session_t *ts)
 471 {
 472   hss_main_t *hsm = &hss_main;
 473   vnet_disconnect_args_t _a = { 0 }, *a = &_a;
 474
 475   a->handle = session_handle (ts);
 476   a->app_index = hsm->app_index;
 477   vnet_disconnect_session (a);
 478 }
 479
 480 static int
 481 hss_ts_connected_callback (u32 app_index, u32 api_context, session_t *ts,
 482                            session_error_t err)
 483 {
 484   clib_warning ("called...");
 485   return -1;
 486 }
 487
 488 static int
 489 hss_add_segment_callback (u32 client_index, u64 segment_handle)
 490 {
 491   return 0;
 492 }
 493
 494 static void
 495 hss_ts_cleanup (session_t *s, session_cleanup_ntf_t ntf)
 496 {
 497   hss_main_t *hsm = &hss_main;
 498   hss_session_t *hs;
 499
 500   if (ntf == SESSION_CLEANUP_TRANSPORT)
 501     return;
 502
 503   hs = hss_session_get (s->thread_index, s->opaque);
 504   if (!hs)
 505     return;
 506
 507   if (hs->cache_pool_index != ~0)
 508     {
 509       hss_cache_detach_entry (&hsm->cache, hs->cache_pool_index);
 510       hs->cache_pool_index = ~0;
 511     }
 512
 513   if (hs->free_data)
 514     vec_free (hs->data);
 515   hs->data = 0;
 516   hs->data_offset = 0;
 517   hs->free_data = 0;
 518   vec_free (hs->path);
 519
 520   hss_session_free (hs);
 521 }
 522
 523 static session_cb_vft_t hss_cb_vft = {
 524   .session_accept_callback = hss_ts_accept_callback,
 525   .session_disconnect_callback = hss_ts_disconnect_callback,
 526   .session_connected_callback = hss_ts_connected_callback,
 527   .add_segment_callback = hss_add_segment_callback,
 528   .builtin_app_rx_callback = hss_ts_rx_callback,
 529   .builtin_app_tx_callback = hss_ts_tx_callback,
 530   .session_reset_callback = hss_ts_reset_callback,
 531   .session_cleanup_callback = hss_ts_cleanup,
 532 };
 533
 534 static int
 535 hss_attach ()
 536 {
 537   vnet_app_add_cert_key_pair_args_t _ck_pair, *ck_pair = &_ck_pair;
 538   hss_main_t *hsm = &hss_main;
 539   u64 options[APP_OPTIONS_N_OPTIONS];
 540   vnet_app_attach_args_t _a, *a = &_a;
 541   u32 segment_size = 128 << 20;
 542
 543   clib_memset (a, 0, sizeof (*a));
 544   clib_memset (options, 0, sizeof (options));
 545
 546   if (hsm->private_segment_size)
 547     segment_size = hsm->private_segment_size;
 548
 549   a->api_client_index = ~0;
 550   a->name = format (0, "http_static_server");
 551   a->session_cb_vft = &hss_cb_vft;
 552   a->options = options;
 553   a->options[APP_OPTIONS_SEGMENT_SIZE] = segment_size;
 554   a->options[APP_OPTIONS_ADD_SEGMENT_SIZE] = segment_size;
 555   a->options[APP_OPTIONS_RX_FIFO_SIZE] =
 556     hsm->fifo_size ? hsm->fifo_size : 8 << 10;
 557   a->options[APP_OPTIONS_TX_FIFO_SIZE] =
 558     hsm->fifo_size ? hsm->fifo_size : 32 << 10;
 559   a->options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_IS_BUILTIN;
 560   a->options[APP_OPTIONS_PREALLOC_FIFO_PAIRS] = hsm->prealloc_fifos;
 561   a->options[APP_OPTIONS_TLS_ENGINE] = CRYPTO_ENGINE_OPENSSL;
 562
 563   if (vnet_application_attach (a))
 564     {
 565       vec_free (a->name);
 566       clib_warning ("failed to attach server");
 567       return -1;
 568     }
 569   vec_free (a->name);
 570   hsm->app_index = a->app_index;
 571
 572   clib_memset (ck_pair, 0, sizeof (*ck_pair));
 573   ck_pair->cert = (u8 *) test_srv_crt_rsa;
 574   ck_pair->key = (u8 *) test_srv_key_rsa;
 575   ck_pair->cert_len = test_srv_crt_rsa_len;
 576   ck_pair->key_len = test_srv_key_rsa_len;
 577   vnet_app_add_cert_key_pair (ck_pair);
 578   hsm->ckpair_index = ck_pair->index;
 579
 580   return 0;
 581 }
 582
 583 static int
 584 hss_transport_needs_crypto (transport_proto_t proto)
 585 {
 586   return proto == TRANSPORT_PROTO_TLS || proto == TRANSPORT_PROTO_DTLS ||
 587          proto == TRANSPORT_PROTO_QUIC;
 588 }
 589
 590 static int
 591 hss_listen (void)
 592 {
 593   hss_main_t *hsm = &hss_main;
 594   session_endpoint_cfg_t sep = SESSION_ENDPOINT_CFG_NULL;
 595   vnet_listen_args_t _a, *a = &_a;
 596   char *uri = "tcp://0.0.0.0/80";
 597   u8 need_crypto;
 598   int rv;
 599
 600   clib_memset (a, 0, sizeof (*a));
 601   a->app_index = hsm->app_index;
 602
 603   if (hsm->uri)
 604     uri = (char *) hsm->uri;
 605
 606   if (parse_uri (uri, &sep))
 607     return -1;
 608
 609   need_crypto = hss_transport_needs_crypto (sep.transport_proto);
 610
 611   sep.transport_proto = TRANSPORT_PROTO_HTTP;
 612   clib_memcpy (&a->sep_ext, &sep, sizeof (sep));
 613
 614   if (need_crypto)
 615     {
 616       session_endpoint_alloc_ext_cfg (&a->sep_ext,
 617                                       TRANSPORT_ENDPT_EXT_CFG_CRYPTO);
 618       a->sep_ext.ext_cfg->crypto.ckpair_index = hsm->ckpair_index;
 619     }
 620
 621   rv = vnet_listen (a);
 622
 623   if (need_crypto)
 624     clib_mem_free (a->sep_ext.ext_cfg);
 625
 626   return rv;
 627 }
 628
 629 static void
 630 hss_url_handlers_init (hss_main_t *hsm)
 631 {
 632   if (!hsm->get_url_handlers)
 633     {
 634       hsm->get_url_handlers = hash_create_string (0, sizeof (uword));
 635       hsm->post_url_handlers = hash_create_string (0, sizeof (uword));
 636     }
 637
 638   hss_builtinurl_json_handlers_init ();
 639 }
 640
 641 int
 642 hss_create (vlib_main_t *vm)
 643 {
 644   vlib_thread_main_t *vtm = vlib_get_thread_main ();
 645   hss_main_t *hsm = &hss_main;
 646   u32 num_threads;
 647
 648   num_threads = 1 /* main thread */  + vtm->n_threads;
 649   vec_validate (hsm->sessions, num_threads - 1);
 650
 651   if (hss_attach ())
 652     {
 653       clib_warning ("failed to attach server");
 654       return -1;
 655     }
 656   if (hss_listen ())
 657     {
 658       clib_warning ("failed to start listening");
 659       return -1;
 660     }
 661
 662   if (hsm->www_root)
 663     hss_cache_init (&hsm->cache, hsm->cache_size, hsm->debug_level);
 664
 665   if (hsm->enable_url_handlers)
 666     hss_url_handlers_init (hsm);
 667
 668   return 0;
 669 }
 670
 671 static clib_error_t *
 672 hss_create_command_fn (vlib_main_t *vm, unformat_input_t *input,
 673                        vlib_cli_command_t *cmd)
 674 {
 675   unformat_input_t _line_input, *line_input = &_line_input;
 676   hss_main_t *hsm = &hss_main;
 677   clib_error_t *error = 0;
 678   u64 seg_size;
 679   int rv;
 680
 681   if (hsm->app_index != (u32) ~0)
 682     return clib_error_return (0, "http server already running...");
 683
 684   hsm->prealloc_fifos = 0;
 685   hsm->private_segment_size = 0;
 686   hsm->fifo_size = 0;
 687   hsm->cache_size = 10 << 20;
 688
 689   /* Get a line of input. */
 690   if (!unformat_user (input, unformat_line_input, line_input))
 691     goto no_input;
 692
 693   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 694     {
 695       if (unformat (line_input, "www-root %s", &hsm->www_root))
 696         ;
 697       else
 698         if (unformat (line_input, "prealloc-fifos %d", &hsm->prealloc_fifos))
 699         ;
 700       else if (unformat (line_input, "private-segment-size %U",
 701                          unformat_memory_size, &seg_size))
 702         hsm->private_segment_size = seg_size;
 703       else if (unformat (line_input, "fifo-size %d", &hsm->fifo_size))
 704         hsm->fifo_size <<= 10;
 705       else if (unformat (line_input, "cache-size %U", unformat_memory_size,
 706                          &hsm->cache_size))
 707         ;
 708       else if (unformat (line_input, "uri %s", &hsm->uri))
 709         ;
 710       else if (unformat (line_input, "debug %d", &hsm->debug_level))
 711         ;
 712       else if (unformat (line_input, "debug"))
 713         hsm->debug_level = 1;
 714       else if (unformat (line_input, "ptr-thresh %U", unformat_memory_size,
 715                          &hsm->use_ptr_thresh))
 716         ;
 717       else if (unformat (line_input, "url-handlers"))
 718         hsm->enable_url_handlers = 1;
 719       else
 720         {
 721           error = clib_error_return (0, "unknown input `%U'",
 722                                      format_unformat_error, line_input);
 723           break;
 724         }
 725     }
 726
 727   unformat_free (line_input);
 728
 729 no_input:
 730
 731   if (error)
 732     goto done;
 733
 734   if (hsm->www_root == 0 && !hsm->enable_url_handlers)
 735     {
 736       error = clib_error_return (0, "Must set www-root or url-handlers");
 737       goto done;
 738     }
 739
 740   if (hsm->cache_size < (128 << 10))
 741     {
 742       error = clib_error_return (0, "cache-size must be at least 128kb");
 743       vec_free (hsm->www_root);
 744       goto done;
 745     }
 746
 747   vnet_session_enable_disable (vm, 1 /* turn on TCP, etc. */ );
 748
 749   if ((rv = hss_create (vm)))
 750     {
 751       error = clib_error_return (0, "server_create returned %d", rv);
 752       vec_free (hsm->www_root);
 753     }
 754
 755 done:
 756
 757   return error;
 758 }
 759
 760 /*?
 761  * Enable the static http server
 762  *
 763  * @cliexpar
 764  * This command enables the static http server. Only the www-root
 765  * parameter is required
 766  * @clistart
 767  * http static server www-root /tmp/www uri tcp://0.0.0.0/80 cache-size 2m
 768  * @cliend
 769  * @cliexcmd{http static server www-root <path> [prealloc-fios <nn>]
 770  *   [private-segment-size <nnMG>] [fifo-size <nbytes>] [uri <uri>]}
 771 ?*/
 772 VLIB_CLI_COMMAND (hss_create_command, static) = {
 773   .path = "http static server",
 774   .short_help =
 775     "http static server www-root <path> [prealloc-fifos <nn>]\n"
 776     "[private-segment-size <nnMG>] [fifo-size <nbytes>] [uri <uri>]\n"
 777     "[ptr-thresh <nn>] [url-handlers] [debug [nn]]\n",
 778   .function = hss_create_command_fn,
 779 };
 780
 781 static u8 *
 782 format_hss_session (u8 *s, va_list *args)
 783 {
 784   hss_session_t *hs = va_arg (*args, hss_session_t *);
 785   int __clib_unused verbose = va_arg (*args, int);
 786
 787   s = format (s, "\n path %s, data length %u, data_offset %u",
 788               hs->path ? hs->path : (u8 *) "[none]", hs->data_len,
 789               hs->data_offset);
 790   return s;
 791 }
 792
 793 static clib_error_t *
 794 hss_show_command_fn (vlib_main_t *vm, unformat_input_t *input,
 795                      vlib_cli_command_t *cmd)
 796 {
 797   int verbose = 0, show_cache = 0, show_sessions = 0;
 798   hss_main_t *hsm = &hss_main;
 799
 800   if (hsm->www_root == 0)
 801     return clib_error_return (0, "Static server disabled");
 802
 803   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 804     {
 805       if (unformat (input, "verbose %d", &verbose))
 806         ;
 807       else if (unformat (input, "verbose"))
 808         verbose = 1;
 809       else if (unformat (input, "cache"))
 810         show_cache = 1;
 811       else if (unformat (input, "sessions"))
 812         show_sessions = 1;
 813       else
 814         break;
 815     }
 816
 817   if ((show_cache + show_sessions) == 0)
 818     return clib_error_return (0, "specify one or more of cache, sessions");
 819
 820   if (show_cache)
 821     vlib_cli_output (vm, "%U", format_hss_cache, &hsm->cache, verbose);
 822
 823   if (show_sessions)
 824     {
 825       u32 *session_indices = 0;
 826       hss_session_t *hs;
 827       int i, j;
 828
 829
 830       for (i = 0; i < vec_len (hsm->sessions); i++)
 831         {
 832           pool_foreach (hs, hsm->sessions[i])
 833             vec_add1 (session_indices, hs - hsm->sessions[i]);
 834
 835           for (j = 0; j < vec_len (session_indices); j++)
 836             {
 837               vlib_cli_output (
 838                 vm, "%U", format_hss_session,
 839                 pool_elt_at_index (hsm->sessions[i], session_indices[j]),
 840                 verbose);
 841             }
 842           vec_reset_length (session_indices);
 843         }
 844       vec_free (session_indices);
 845     }
 846   return 0;
 847 }
 848
 849 /*?
 850  * Display static http server cache statistics
 851  *
 852  * @cliexpar
 853  * This command shows the contents of the static http server cache
 854  * @clistart
 855  * show http static server
 856  * @cliend
 857  * @cliexcmd{show http static server sessions cache [verbose [nn]]}
 858 ?*/
 859 VLIB_CLI_COMMAND (hss_show_command, static) = {
 860   .path = "show http static server",
 861   .short_help = "show http static server sessions cache [verbose [<nn>]]",
 862   .function = hss_show_command_fn,
 863 };
 864
 865 static clib_error_t *
 866 hss_clear_cache_command_fn (vlib_main_t *vm, unformat_input_t *input,
 867                             vlib_cli_command_t *cmd)
 868 {
 869   hss_main_t *hsm = &hss_main;
 870   u32 busy_items = 0;
 871
 872   if (hsm->www_root == 0)
 873     return clib_error_return (0, "Static server disabled");
 874
 875   busy_items = hss_cache_clear (&hsm->cache);
 876
 877   if (busy_items > 0)
 878     vlib_cli_output (vm, "Note: %d busy items still in cache...", busy_items);
 879   else
 880     vlib_cli_output (vm, "Cache cleared...");
 881   return 0;
 882 }
 883
 884 /*?
 885  * Clear the static http server cache, to force the server to
 886  * reload content from backing files
 887  *
 888  * @cliexpar
 889  * This command clear the static http server cache
 890  * @clistart
 891  * clear http static cache
 892  * @cliend
 893  * @cliexcmd{clear http static cache}
 894 ?*/
 895 VLIB_CLI_COMMAND (clear_hss_cache_command, static) = {
 896   .path = "clear http static cache",
 897   .short_help = "clear http static cache",
 898   .function = hss_clear_cache_command_fn,
 899 };
 900
 901 static clib_error_t *
 902 hss_main_init (vlib_main_t *vm)
 903 {
 904   hss_main_t *hsm = &hss_main;
 905
 906   hsm->app_index = ~0;
 907   hsm->vlib_main = vm;
 908
 909   return 0;
 910 }
 911
 912 VLIB_INIT_FUNCTION (hss_main_init);
 913
 914 /*
 915  * fd.io coding-style-patch-verification: ON
 916  *
 917  * Local Variables:
 918  * eval: (c-set-style "gnu")
 919  * End:
 920  */