FD.io VPP  v17.07.01-10-g3be13f0
Vector Packet Processing
builtin_http_server.c
Go to the documentation of this file.
1 /*
2 * Copyright (c) 2015-2017 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 <vnet/vnet.h>
17 #include <vlibmemory/api.h>
18 #include <vnet/session/application.h>
19 #include <vnet/session/application_interface.h>
20 
21 /* define message IDs */
22 #include <vpp/api/vpe_msg_enum.h>
23 
24 /* define message structures */
25 #define vl_typedefs
26 #include <vpp/api/vpe_all_api_h.h>
27 #undef vl_typedefs
28 
29 /* define generated endian-swappers */
30 #define vl_endianfun
31 #include <vpp/api/vpe_all_api_h.h>
32 #undef vl_endianfun
33 
34 /* instantiate all the print functions we know about */
35 #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__)
36 #define vl_printfun
37 #include <vpp/api/vpe_all_api_h.h>
38 #undef vl_printfun
39 
40 typedef enum
41 {
42  EVENT_WAKEUP = 1,
43 } http_process_event_t;
44 
45 typedef struct
46 {
47  u8 *rx_buf;
48  unix_shared_memory_queue_t **vpp_queue;
49  u64 byte_index;
50 
51  uword *handler_by_get_request;
52 
53  u32 *free_http_cli_process_node_indices;
54 
55  /* Sever's event queue */
56  unix_shared_memory_queue_t *vl_input_queue;
57 
58  /* API client handle */
59  u32 my_client_index;
60 
61  u32 app_index;
62 
63  /* process node index for evnt scheduling */
64  u32 node_index;
65  vlib_main_t *vlib_main;
66 } http_server_main_t;
67 
68 http_server_main_t http_server_main;
69 
70 static void
71 free_http_process (stream_session_t * s)
72 {
73  vlib_node_runtime_t *rt;
74  vlib_main_t *vm = &vlib_global_main;
75  http_server_main_t *hsm = &http_server_main;
76  vlib_node_t *n;
77  u32 node_index;
78  stream_session_t **save_s;
79 
80  node_index = (u64) (s->opaque[0]);
81  ASSERT (node_index != 0);
82 
83  n = vlib_get_node (vm, node_index);
84  rt = vlib_node_get_runtime (vm, n->runtime_index);
85  save_s = (stream_session_t **) vlib_node_get_runtime (vm, n->runtime_index);
86 
87  /* Reset session saved node index */
88  s->opaque[0] = 0;
89  /* Reset process session pointer */
90  *save_s = 0;
91 
92  /* Turn off the process node */
93  vlib_node_set_state (vm, rt->node_index, VLIB_NODE_STATE_DISABLED);
94 
95  /* add node index to the freelist */
96  vec_add1 (hsm->free_http_cli_process_node_indices, node_index);
97 }
98 
99 static const char
100  *http_response = "HTTP/1.1 200 OK\r\n"
101  "Content-Type: text/html\r\n"
102  "Expires: Mon, 11 Jan 1970 10:10:10 GMT\r\n"
103  "Connection: close\r\n"
104  "Pragma: no-cache\r\n" "Content-Length: %d\r\n\r\n%s";
105 
106 static const char
107  *http_error_template = "HTTP/1.1 %s\r\n"
108  "Content-Type: text/html\r\n"
109  "Expires: Mon, 11 Jan 1970 10:10:10 GMT\r\n"
110  "Connection: close\r\n" "Pragma: no-cache\r\n" "Content-Length: 0\r\n\r\n";
111 
112 /* Header, including incantation to suppress favicon.ico requests */
113 static const char
114  *html_header_template = "<html><head><title>%v</title>"
115  "</head><link rel=\"icon\" href=\"data:,\"><body><pre>";
116 
117 static const char *html_footer = "</pre></body></html>\r\n";
118 
119 static void
120 http_cli_output (uword arg, u8 * buffer, uword buffer_bytes)
121 {
122  u8 **output_vecp = (u8 **) arg;
123  u8 *output_vec;
124  u32 offset;
125 
126  output_vec = *output_vecp;
127 
128  offset = vec_len (output_vec);
129  vec_validate (output_vec, offset + buffer_bytes - 1);
130  clib_memcpy (output_vec + offset, buffer, buffer_bytes);
131 
132  *output_vecp = output_vec;
133 }
134 
135 void
136 send_data (stream_session_t * s, u8 * data)
137 {
138  session_fifo_event_t evt;
139  u32 offset, bytes_to_send;
140  f64 delay = 10e-3;
141  http_server_main_t *hsm = &http_server_main;
142  vlib_main_t *vm = hsm->vlib_main;
143  f64 last_sent_timer = vlib_time_now (vm);
144 
145  bytes_to_send = vec_len (data);
146  offset = 0;
147 
148  while (bytes_to_send > 0)
149  {
150  int actual_transfer;
151 
152  actual_transfer = svm_fifo_enqueue_nowait
153  (s->server_tx_fifo, bytes_to_send, data + offset);
154 
155  /* Made any progress? */
156  if (actual_transfer <= 0)
157  {
158  vlib_process_suspend (vm, delay);
159  /* 10s deadman timer */
160  if (vlib_time_now (vm) > last_sent_timer + 10.0)
161  {
162  /* $$$$ FC: reset transport session here? */
163  break;
164  }
165  /* Exponential backoff, within reason */
166  if (delay < 1.0)
167  delay = delay * 2.0;
168  }
169  else
170  {
171  last_sent_timer = vlib_time_now (vm);
172  offset += actual_transfer;
173  bytes_to_send -= actual_transfer;
174 
175  if (svm_fifo_set_event (s->server_tx_fifo))
176  {
177  /* Fabricate TX event, send to vpp */
178  evt.fifo = s->server_tx_fifo;
179  evt.event_type = FIFO_EVENT_APP_TX;
180  evt.event_id = 0;
181 
182  unix_shared_memory_queue_add (hsm->vpp_queue[s->thread_index],
183  (u8 *) & evt,
184  0 /* do wait for mutex */ );
185  }
186  delay = 10e-3;
187  }
188  }
189 }
190 
191 static void
192 send_error (stream_session_t * s, char *str)
193 {
194  u8 *data;
195 
196  data = format (0, http_error_template, str);
197  send_data (s, data);
198  vec_free (data);
199 }
200 
201 static uword
202 http_cli_process (vlib_main_t * vm,
203  vlib_node_runtime_t * rt, vlib_frame_t * f)
204 {
205  http_server_main_t *hsm = &http_server_main;
206  u8 *request = 0, *reply = 0;
207  stream_session_t **save_s;
208  stream_session_t *s;
209  unformat_input_t input;
210  int i;
211  u8 *http = 0, *html = 0;
212 
213  save_s = vlib_node_get_runtime_data (hsm->vlib_main, rt->node_index);
214  s = *save_s;
215 
216  request = (u8 *) (void *) (s->opaque[1]);
217  s->opaque[1] = 0;
218 
219  if (vec_len (request) < 7)
220  {
221  send_error (s, "400 Bad Request");
222  goto out;
223  }
224 
225  for (i = 0; i < vec_len (request) - 4; i++)
226  {
227  if (request[i] == 'G' &&
228  request[i + 1] == 'E' &&
229  request[i + 2] == 'T' && request[i + 3] == ' ')
230  goto found;
231  }
232 bad_request:
233  send_error (s, "400 Bad Request");
234  goto out;
235 
236 found:
237  /* Lose "GET " */
238  vec_delete (request, i + 5, 0);
239 
240  /* Replace slashes with spaces, stop at the end of the path */
241  i = 0;
242  while (1)
243  {
244  if (request[i] == '/')
245  request[i] = ' ';
246  else if (request[i] == ' ')
247  {
248  /* vlib_cli_input is vector-based, no need for a NULL */
249  _vec_len (request) = i;
250  break;
251  }
252  i++;
253  /* Should never happen */
254  if (i == vec_len (request))
255  goto bad_request;
256  }
257 
258  /* Generate the html header */
259  html = format (0, html_header_template, request /* title */ );
260 
261  /* Run the command */
262  unformat_init_vector (&input, request);
263  vlib_cli_input (vm, &input, http_cli_output, (uword) & reply);
264  unformat_free (&input);
265  request = 0;
266 
267  /* Generate the html page */
268  html = format (html, "%v", reply);
269  html = format (html, html_footer);
270  /* And the http reply */
271  http = format (0, http_response, vec_len (html), html);
272 
273  /* Send it */
274  send_data (s, http);
275 
276 out:
277  /* Cleanup */
278  vec_free (request);
279  vec_free (reply);
280  vec_free (html);
281  vec_free (http);
282 
283  free_http_process (s);
284  return (0);
285 }
286 
287 static void
288 alloc_http_process (stream_session_t * s)
289 {
290  char *name;
291  vlib_node_t *n;
292  http_server_main_t *hsm = &http_server_main;
293  vlib_main_t *vm = hsm->vlib_main;
294  uword l = vec_len (hsm->free_http_cli_process_node_indices);
295  stream_session_t **save_s;
296 
297  if (vec_len (hsm->free_http_cli_process_node_indices) > 0)
298  {
299  n = vlib_get_node (vm, hsm->free_http_cli_process_node_indices[l - 1]);
300 
301  vlib_node_set_state (vm, n->index, VLIB_NODE_STATE_POLLING);
302 
303  _vec_len (hsm->free_http_cli_process_node_indices) = l - 1;
304  }
305  else
306  {
307  static vlib_node_registration_t r = {
308  .function = http_cli_process,
309  .type = VLIB_NODE_TYPE_PROCESS,
310  .process_log2_n_stack_bytes = 16,
311  .runtime_data_bytes = sizeof (void *),
312  };
313 
314  name = (char *) format (0, "http-cli-%d", l);
315 
316  r.name = name;
317  vlib_register_node (vm, &r);
318  vec_free (name);
319 
320  n = vlib_get_node (vm, r.index);
321  }
322 
323  /* Save the node index in the stream_session_t. It won't be zero. */
324  s->opaque[0] = (u64) n->index;
325 
326  /* Save the stream_session_t (pointer) in the node runtime */
327  save_s = vlib_node_get_runtime_data (vm, n->index);
328  *save_s = s;
329 
330  vlib_start_process (vm, n->runtime_index);
331 }
332 
333 static int
334 builtin_session_accept_callback (stream_session_t * s)
335 {
336  http_server_main_t *bsm = &http_server_main;
337 
338  bsm->vpp_queue[s->thread_index] =
339  session_manager_get_vpp_event_queue (s->thread_index);
340  s->session_state = SESSION_STATE_READY;
341  bsm->byte_index = 0;
342  return 0;
343 }
344 
345 static void
346 builtin_session_disconnect_callback (stream_session_t * s)
347 {
348  http_server_main_t *bsm = &http_server_main;
349  vnet_disconnect_args_t _a, *a = &_a;
350 
351  a->handle = stream_session_handle (s);
352  a->app_index = bsm->app_index;
353  vnet_disconnect_session (a);
354 }
355 
356 static void
357 builtin_session_reset_callback (stream_session_t * s)
358 {
359  clib_warning ("called.. ");
360 
361  stream_session_cleanup (s);
362 }
363 
364 
365 static int
366 builtin_session_connected_callback (u32 app_index, u32 api_context,
367  stream_session_t * s, u8 is_fail)
368 {
369  clib_warning ("called...");
370  return -1;
371 }
372 
373 static int
374 builtin_add_segment_callback (u32 client_index,
375  const u8 * seg_name, u32 seg_size)
376 {
377  clib_warning ("called...");
378  return -1;
379 }
380 
381 static int
382 builtin_redirect_connect_callback (u32 client_index, void *mp)
383 {
384  clib_warning ("called...");
385  return -1;
386 }
387 
388 static void
389 alloc_http_process_callback (void *s_arg)
390 {
391  stream_session_t *s = (stream_session_t *) s_arg;
392  alloc_http_process (s);
393 }
394 
395 static int
396 http_server_rx_callback (stream_session_t * s)
397 {
398  u32 max_dequeue;
399  int actual_transfer;
400  http_server_main_t *hsm = &http_server_main;
401  svm_fifo_t *rx_fifo;
402 
403  rx_fifo = s->server_rx_fifo;
404 
405  max_dequeue = svm_fifo_max_dequeue (rx_fifo);
406 
407  svm_fifo_unset_event (rx_fifo);
408 
409  if (PREDICT_FALSE (max_dequeue == 0))
410  return 0;
411 
412  vec_validate (hsm->rx_buf, max_dequeue - 1);
413  _vec_len (hsm->rx_buf) = max_dequeue;
414 
415  actual_transfer = svm_fifo_dequeue_nowait (rx_fifo, max_dequeue,
416  hsm->rx_buf);
417  ASSERT (actual_transfer > 0);
418 
419  _vec_len (hsm->rx_buf) = actual_transfer;
420 
421  /* send the command to a new/recycled vlib process */
422  s->opaque[1] = (u64) vec_dup (hsm->rx_buf);
423 
424  /* Send an RPC request via the thread-0 input node */
425  if (vlib_get_thread_index () != 0)
426  {
427  session_fifo_event_t evt;
428  evt.rpc_args.fp = alloc_http_process_callback;
429  evt.rpc_args.arg = s;
430  evt.event_type = FIFO_EVENT_RPC;
431  unix_shared_memory_queue_add
432  (session_manager_get_vpp_event_queue (0 /* main thread */ ),
433  (u8 *) & evt, 0 /* do wait for mutex */ );
434  }
435  else
436  alloc_http_process (s);
437  return 0;
438 }
439 
440 static session_cb_vft_t builtin_session_cb_vft = {
441  .session_accept_callback = builtin_session_accept_callback,
442  .session_disconnect_callback = builtin_session_disconnect_callback,
443  .session_connected_callback = builtin_session_connected_callback,
444  .add_segment_callback = builtin_add_segment_callback,
445  .redirect_connect_callback = builtin_redirect_connect_callback,
446  .builtin_server_rx_callback = http_server_rx_callback,
447  .session_reset_callback = builtin_session_reset_callback
448 };
449 
450 /* Abuse VPP's input queue */
451 static int
452 create_api_loopback (vlib_main_t * vm)
453 {
454  http_server_main_t *hsm = &http_server_main;
455  vl_api_memclnt_create_t _m, *mp = &_m;
456  extern void vl_api_memclnt_create_t_handler (vl_api_memclnt_create_t *);
457  api_main_t *am = &api_main;
458  vl_shmem_hdr_t *shmem_hdr;
459  uword *event_data = 0, event_type;
460  int resolved = 0;
461 
462  /*
463  * Create a "loopback" API client connection
464  * Don't do things like this unless you know what you're doing...
465  */
466 
467  shmem_hdr = am->shmem_hdr;
468  hsm->vl_input_queue = shmem_hdr->vl_input_queue;
469  memset (mp, 0, sizeof (*mp));
470  mp->_vl_msg_id = VL_API_MEMCLNT_CREATE;
471  mp->context = 0xFEEDFACE;
472  mp->input_queue = (u64) hsm->vl_input_queue;
473  strncpy ((char *) mp->name, "tcp_http_server", sizeof (mp->name) - 1);
474 
475  vl_api_memclnt_create_t_handler (mp);
476 
477  /* Wait for reply */
478  hsm->node_index = vlib_get_current_process (vm)->node_runtime.node_index;
479  vlib_process_wait_for_event_or_clock (vm, 1.0);
480  event_type = vlib_process_get_events (vm, &event_data);
481  switch (event_type)
482  {
483  case 1:
484  resolved = 1;
485  break;
486  case ~0:
487  /* timed out */
488  break;
489  default:
490  clib_warning ("unknown event_type %d", event_type);
491  }
492  if (!resolved)
493  return -1;
494 
495  return 0;
496 }
497 
498 static int
499 server_attach ()
500 {
501  http_server_main_t *hsm = &http_server_main;
502  u8 segment_name[128];
503  u64 options[SESSION_OPTIONS_N_OPTIONS];
504  vnet_app_attach_args_t _a, *a = &_a;
505 
506  memset (a, 0, sizeof (*a));
507  memset (options, 0, sizeof (options));
508 
509  a->api_client_index = hsm->my_client_index;
510  a->session_cb_vft = &builtin_session_cb_vft;
511  a->options = options;
512  a->options[SESSION_OPTIONS_SEGMENT_SIZE] = 128 << 20;
513  a->options[SESSION_OPTIONS_RX_FIFO_SIZE] = 8 << 10;
514  a->options[SESSION_OPTIONS_TX_FIFO_SIZE] = 32 << 10;
515  a->options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_BUILTIN_APP;
516  a->options[APP_OPTIONS_PREALLOC_FIFO_PAIRS] = 16;
517  a->segment_name = segment_name;
518  a->segment_name_length = ARRAY_LEN (segment_name);
519 
520  if (vnet_application_attach (a))
521  {
522  clib_warning ("failed to attach server");
523  return -1;
524  }
525  hsm->app_index = a->app_index;
526  return 0;
527 }
528 
529 static int
530 server_listen ()
531 {
532  http_server_main_t *hsm = &http_server_main;
533  vnet_bind_args_t _a, *a = &_a;
534  memset (a, 0, sizeof (*a));
535  a->app_index = hsm->app_index;
536  a->uri = "tcp://0.0.0.0/80";
537  return vnet_bind_uri (a);
538 }
539 
540 static int
541 server_create (vlib_main_t * vm)
542 {
543  http_server_main_t *hsm = &http_server_main;
544  u32 num_threads;
545  vlib_thread_main_t *vtm = vlib_get_thread_main ();
546 
547  if (hsm->my_client_index == (u32) ~ 0)
548  {
549  if (create_api_loopback (vm))
550  return -1;
551  }
552 
553  num_threads = 1 /* main thread */ + vtm->n_threads;
554  vec_validate (http_server_main.vpp_queue, num_threads - 1);
555 
556  if (server_attach ())
557  {
558  clib_warning ("failed to attach server");
559  return -1;
560  }
561  if (server_listen ())
562  {
563  clib_warning ("failed to start listening");
564  return -1;
565  }
566  return 0;
567 }
568 
569 /* Get our api client index */
570 static void
571 vl_api_memclnt_create_reply_t_handler (vl_api_memclnt_create_reply_t * mp)
572 {
573  vlib_main_t *vm = vlib_get_main ();
574  http_server_main_t *hsm = &http_server_main;
575  hsm->my_client_index = mp->index;
576  vlib_process_signal_event (vm, hsm->node_index, 1 /* evt */ ,
577  0 /* data */ );
578 }
579 
580 #define foreach_tcp_http_server_api_msg \
581 _(MEMCLNT_CREATE_REPLY, memclnt_create_reply) \
582 
583 static clib_error_t *
584 tcp_http_server_api_hookup (vlib_main_t * vm)
585 {
586  vl_msg_api_msg_config_t _c, *c = &_c;
587 
588  /* Hook up client-side static APIs to our handlers */
589 #define _(N,n) do { \
590  c->id = VL_API_##N; \
591  c->name = #n; \
592  c->handler = vl_api_##n##_t_handler; \
593  c->cleanup = vl_noop_handler; \
594  c->endian = vl_api_##n##_t_endian; \
595  c->print = vl_api_##n##_t_print; \
596  c->size = sizeof(vl_api_##n##_t); \
597  c->traced = 1; /* trace, so these msgs print */ \
598  c->replay = 0; /* don't replay client create/delete msgs */ \
599  c->message_bounce = 0; /* don't bounce this message */ \
600  vl_msg_api_config(c);} while (0);
601 
602  foreach_tcp_http_server_api_msg;
603 #undef _
604 
605  return 0;
606 }
607 
608 static clib_error_t *
609 server_create_command_fn (vlib_main_t * vm,
610  unformat_input_t * input, vlib_cli_command_t * cmd)
611 {
612  int rv;
613 
614  tcp_http_server_api_hookup (vm);
615  vnet_session_enable_disable (vm, 1 /* turn on TCP, etc. */ );
616  rv = server_create (vm);
617  switch (rv)
618  {
619  case 0:
620  break;
621  default:
622  return clib_error_return (0, "server_create returned %d", rv);
623  }
624  return 0;
625 }
626 
627 /* *INDENT-OFF* */
628 VLIB_CLI_COMMAND (server_create_command, static) =
629 {
630  .path = "test http server",
631  .short_help = "test http server",
632  .function = server_create_command_fn,
633 };
634 /* *INDENT-ON* */
635 
636 static clib_error_t *
637 builtin_http_server_main_init (vlib_main_t * vm)
638 {
639  http_server_main_t *hsm = &http_server_main;
640  hsm->my_client_index = ~0;
641  hsm->vlib_main = vm;
642 
643  return 0;
644 }
645 
646 VLIB_INIT_FUNCTION (builtin_http_server_main_init);
647 
648 /*
649 * fd.io coding-style-patch-verification: ON
650 *
651 * Local Variables:
652 * eval: (c-set-style "gnu")
653 * End:
654 */
vec_validate
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:436
vl_api_memclnt_create_reply_t
Definition: memclnt.api:29
http_cli_output
static void http_cli_output(uword arg, u8 *buffer, uword buffer_bytes)
Definition: builtin_http_server.c:120
SESSION_OPTIONS_SEGMENT_SIZE
Definition: application_interface.h:123
i
sll srl srl sll sra u16x4 i
Definition: vector_sse2.h:337
vlib_thread_main_t::n_threads
u32 n_threads
Definition: threads.h:281
vlib_process_wait_for_event_or_clock
static f64 vlib_process_wait_for_event_or_clock(vlib_main_t *vm, f64 dt)
Suspend a cooperative multi-tasking thread Waits for an event, or for the indicated number of seconds...
Definition: node_funcs.h:699
vlib_process_t::node_runtime
vlib_node_runtime_t node_runtime
Definition: node.h:499
a
a
Definition: bitmap.h:516
vlib_cli_input
void vlib_cli_input(vlib_main_t *vm, unformat_input_t *input, vlib_cli_output_function_t *function, uword function_arg)
Definition: cli.c:643
http_server_main_t::app_index
u32 app_index
Definition: builtin_http_server.c:61
vnet_bind_uri
int vnet_bind_uri(vnet_bind_args_t *a)
Definition: application_interface.c:300
vpe_all_api_h.h
send_data
void send_data(stream_session_t *s, u8 *data)
Definition: builtin_http_server.c:136
vl_api_memclnt_create_t::input_queue
u64 input_queue
Definition: memclnt.api:24
vl_shmem_hdr_::vl_input_queue
unix_shared_memory_queue_t * vl_input_queue
Definition: api_common.h:68
http_error_template
static const char * http_error_template
Definition: builtin_http_server.c:107
vlib_node_t::index
u32 index
Definition: node.h:238
vlib_time_now
static f64 vlib_time_now(vlib_main_t *vm)
Definition: main.h:192
http_server_rx_callback
static int http_server_rx_callback(stream_session_t *s)
Definition: builtin_http_server.c:396
application_interface.h
SESSION_OPTIONS_RX_FIFO_SIZE
Definition: application_interface.h:125
vl_msg_api_msg_config_t
Definition: api_common.h:104
vec_add1
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:522
vlib_thread_main_t
Definition: threads.h:253
vlib_node_registration_t
struct _vlib_node_registration vlib_node_registration_t
format
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
vpe_msg_enum.h
alloc_http_process
static void alloc_http_process(stream_session_t *s)
Definition: builtin_http_server.c:288
vlib_frame_t
Definition: node.h:333
builtin_add_segment_callback
static int builtin_add_segment_callback(u32 client_index, const u8 *seg_name, u32 seg_size)
Definition: builtin_http_server.c:374
http_response
static const char * http_response
Definition: builtin_http_server.c:100
server_attach
static int server_attach()
Definition: builtin_http_server.c:499
stream_session_t
struct _stream_session_t stream_session_t
svm_fifo_t
struct _svm_fifo svm_fifo_t
tcp_http_server_api_hookup
static clib_error_t * tcp_http_server_api_hookup(vlib_main_t *vm)
Definition: builtin_http_server.c:584
vlib_process_suspend
static uword vlib_process_suspend(vlib_main_t *vm, f64 dt)
Suspend a vlib cooperative multi-tasking thread for a period of time.
Definition: node_funcs.h:448
vlib_node_runtime_t
Definition: node.h:413
http_server_main_t::vpp_queue
unix_shared_memory_queue_t ** vpp_queue
Definition: builtin_http_server.c:48
server_create_command_fn
static clib_error_t * server_create_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: builtin_http_server.c:609
vl_api_memclnt_create_reply_t_handler
static void vl_api_memclnt_create_reply_t_handler(vl_api_memclnt_create_reply_t *mp)
Definition: builtin_http_server.c:571
VLIB_INIT_FUNCTION
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:111
vlib_process_get_events
static uword vlib_process_get_events(vlib_main_t *vm, uword **data_vector)
Return the first event type which has occurred and a vector of per-event data of that type...
Definition: node_funcs.h:542
vnet_disconnect_args_t
struct _vnet_disconnect_args_t vnet_disconnect_args_t
svm_fifo_max_dequeue
static u32 svm_fifo_max_dequeue(svm_fifo_t *f)
Definition: svm_fifo.h:71
builtin_session_connected_callback
static int builtin_session_connected_callback(u32 app_index, u32 api_context, stream_session_t *s, u8 is_fail)
Definition: builtin_http_server.c:366
session_cb_vft_t
struct _stream_session_cb_vft session_cb_vft_t
EVENT_WAKEUP
Definition: builtin_http_server.c:42
clib_error_return
#define clib_error_return(e, args...)
Definition: error.h:99
u64
unsigned long u64
Definition: types.h:89
api_main_t::shmem_hdr
struct vl_shmem_hdr_ * shmem_hdr
Definition: api_common.h:189
server_listen
static int server_listen()
Definition: builtin_http_server.c:530
stream_session_cleanup
void stream_session_cleanup(stream_session_t *s)
Cleanup transport and session state.
Definition: session.c:1025
html_header_template
static const char * html_header_template
Definition: builtin_http_server.c:114
vnet_app_attach_args_t
struct _vnet_app_attach_args_t vnet_app_attach_args_t
http_server_main
http_server_main_t http_server_main
Definition: builtin_http_server.c:68
shmem_hdr
vl_shmem_hdr_t * shmem_hdr
Definition: summary_stats_client.c:73
http_server_main_t::rx_buf
u8 * rx_buf
Definition: builtin_http_server.c:47
vl_api_memclnt_create_t
Definition: memclnt.api:21
unix_shared_memory_queue_add
int unix_shared_memory_queue_add(unix_shared_memory_queue_t *q, u8 *elem, int nowait)
Definition: unix_shared_memory_queue.c:185
vlib_process_signal_event
static void vlib_process_signal_event(vlib_main_t *vm, uword node_index, uword type_opaque, uword data)
Definition: node_funcs.h:946
vlib_global_main
vlib_main_t vlib_global_main
Definition: main.c:1653
unformat_input_t
struct _unformat_input_t unformat_input_t
vec_dup
#define vec_dup(V)
Return copy of vector (no header, no alignment)
Definition: vec.h:374
vlib_node_get_runtime_data
static void * vlib_node_get_runtime_data(vlib_main_t *vm, u32 node_index)
Get node runtime private data by node index.
Definition: node_funcs.h:109
PREDICT_FALSE
#define PREDICT_FALSE(x)
Definition: clib.h:97
svm_fifo_unset_event
static void svm_fifo_unset_event(svm_fifo_t *f)
Unsets fifo event flag.
Definition: svm_fifo.h:104
vlib_node_runtime_t::node_index
u32 node_index
Node index.
Definition: node.h:441
vnet_session_enable_disable
clib_error_t * vnet_session_enable_disable(vlib_main_t *vm, u8 is_en)
Definition: session.c:1179
api_main_t
Definition: api_common.h:168
unformat_init_vector
void unformat_init_vector(unformat_input_t *input, u8 *vector_string)
Definition: unformat.c:1031
svm_fifo_set_event
static u8 svm_fifo_set_event(svm_fifo_t *f)
Sets fifo event flag.
Definition: svm_fifo.h:94
session_manager_get_vpp_event_queue
static unix_shared_memory_queue_t * session_manager_get_vpp_event_queue(u32 thread_index)
Definition: session.h:406
SESSION_OPTIONS_N_OPTIONS
Definition: application_interface.h:129
vl_api_memclnt_create_t::name
u8 name[64]
Definition: memclnt.api:25
http_server_main_t::vlib_main
vlib_main_t * vlib_main
Definition: builtin_http_server.c:65
api_main
api_main_t api_main
Definition: api_shared.c:35
c
svmdb_client_t * c
Definition: vpp_get_metrics.c:49
vlib_node_t::runtime_index
u32 runtime_index
Definition: node.h:241
vlib_get_thread_index
static_always_inline uword vlib_get_thread_index(void)
Definition: threads.h:185
vlib_get_current_process
static vlib_process_t * vlib_get_current_process(vlib_main_t *vm)
Definition: node_funcs.h:413
vec_free
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:340
clib_warning
#define clib_warning(format, args...)
Definition: error.h:59
vlib_node_get_runtime
static vlib_node_runtime_t * vlib_node_get_runtime(vlib_main_t *vm, u32 node_index)
Get node runtime by node index.
Definition: node_funcs.h:88
send_error
static void send_error(stream_session_t *s, char *str)
Definition: builtin_http_server.c:192
clib_memcpy
#define clib_memcpy(a, b, c)
Definition: string.h:69
vnet_disconnect_session
int vnet_disconnect_session(vnet_disconnect_args_t *a)
Definition: application_interface.c:355
ARRAY_LEN
#define ARRAY_LEN(x)
Definition: clib.h:59
svm_fifo_enqueue_nowait
int svm_fifo_enqueue_nowait(svm_fifo_t *f, u32 max_bytes, u8 *copy_from_here)
Definition: svm_fifo.c:441
builtin_session_accept_callback
static int builtin_session_accept_callback(stream_session_t *s)
Definition: builtin_http_server.c:334
builtin_redirect_connect_callback
static int builtin_redirect_connect_callback(u32 client_index, void *mp)
Definition: builtin_http_server.c:382
vlib_start_process
void vlib_start_process(vlib_main_t *vm, uword process_index)
Definition: main.c:1365
http_server_main_t::vl_input_queue
unix_shared_memory_queue_t * vl_input_queue
Definition: builtin_http_server.c:56
VLIB_CLI_COMMAND
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
vnet_application_attach
int vnet_application_attach(vnet_app_attach_args_t *a)
Attaches application.
Definition: application_interface.c:238
ASSERT
#define ASSERT(truth)
Definition: error_bootstrap.h:69
u32
unsigned int u32
Definition: types.h:88
http_server_main_t
Definition: builtin_http_server.c:45
vec_delete
#define vec_delete(V, N, M)
Delete N elements starting at element M.
Definition: vec.h:785
vlib_register_node
u32 vlib_register_node(vlib_main_t *vm, vlib_node_registration_t *r)
Definition: node.c:498
SESSION_OPTIONS_TX_FIFO_SIZE
Definition: application_interface.h:126
http_server_main_t::byte_index
u64 byte_index
Definition: builtin_http_server.c:49
vlib_node_set_state
static void vlib_node_set_state(vlib_main_t *vm, u32 node_index, vlib_node_state_t new_state)
Set node dispatch state.
Definition: node_funcs.h:146
http_server_main_t::node_index
u32 node_index
Definition: builtin_http_server.c:64
APP_OPTIONS_PREALLOC_FIFO_PAIRS
Definition: application_interface.h:122
vlib_get_main
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
uword
u64 uword
Definition: types.h:112
http_server_main_t::handler_by_get_request
uword * handler_by_get_request
Definition: builtin_http_server.c:51
clib_error_t
Definition: clib_error.h:21
stream_session_handle
static u64 stream_session_handle(stream_session_t *s)
Definition: session.h:299
vl_api_memclnt_create_t_handler
void vl_api_memclnt_create_t_handler(vl_api_memclnt_create_t *mp)
Definition: memory_vlib.c:143
builtin_http_server_main_init
static clib_error_t * builtin_http_server_main_init(vlib_main_t *vm)
Definition: builtin_http_server.c:637
vec_len
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
Definition: vec_bootstrap.h:142
f64
double f64
Definition: types.h:142
u8
unsigned char u8
Definition: types.h:56
vlib_main_t
Definition: main.h:59
unformat_free
static void unformat_free(unformat_input_t *i)
Definition: format.h:161
vlib_node_t
Definition: node.h:216
vl_api_memclnt_create_reply_t::index
u32 index
Definition: memclnt.api:32
vl_api_memclnt_create_t::context
u32 context
Definition: memclnt.api:23
vlib_cli_command_t
Definition: cli.h:91
create_api_loopback
static int create_api_loopback(vlib_main_t *vm)
Definition: builtin_http_server.c:452
server_create
static int server_create(vlib_main_t *vm)
Definition: builtin_http_server.c:541
http_cli_process
static uword http_cli_process(vlib_main_t *vm, vlib_node_runtime_t *rt, vlib_frame_t *f)
Definition: builtin_http_server.c:202
offset
struct clib_bihash_value offset
template key/value backing page structure
html_footer
static const char * html_footer
Definition: builtin_http_server.c:117
request
vhost_user_req_t request
Definition: vhost-user.h:75
vl_shmem_hdr_
Definition: api_common.h:60
foreach_tcp_http_server_api_msg
#define foreach_tcp_http_server_api_msg
Definition: builtin_http_server.c:580
http_server_main_t::my_client_index
u32 my_client_index
Definition: builtin_http_server.c:59
vlib_get_thread_main
static vlib_thread_main_t * vlib_get_thread_main()
Definition: global_funcs.h:32
vlib_get_node
static vlib_node_t * vlib_get_node(vlib_main_t *vm, u32 i)
Get vlib node by index.
Definition: node_funcs.h:58
http_process_event_t
http_process_event_t
Definition: builtin_http_server.c:40
APP_OPTIONS_FLAGS
Definition: application_interface.h:121
svm_fifo_dequeue_nowait
int svm_fifo_dequeue_nowait(svm_fifo_t *f, u32 max_bytes, u8 *copy_here)
Definition: svm_fifo.c:593
vnet_bind_args_t
struct _vnet_bind_args_t vnet_bind_args_t
builtin_session_disconnect_callback
static void builtin_session_disconnect_callback(stream_session_t *s)
Definition: builtin_http_server.c:346
free_http_process
static void free_http_process(stream_session_t *s)
Definition: builtin_http_server.c:71
builtin_session_cb_vft
static session_cb_vft_t builtin_session_cb_vft
Definition: builtin_http_server.c:440
alloc_http_process_callback
static void alloc_http_process_callback(void *s_arg)
Definition: builtin_http_server.c:389
builtin_session_reset_callback
static void builtin_session_reset_callback(stream_session_t *s)
Definition: builtin_http_server.c:357
http_server_main_t::free_http_cli_process_node_indices
u32 * free_http_cli_process_node_indices
Definition: builtin_http_server.c:53
unix_shared_memory_queue_t
struct _unix_shared_memory_queue unix_shared_memory_queue_t