src/plugins/hs_apps/echo_server.c

   1 /*
   2 * Copyright (c) 2017-2019 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 <hs_apps/hs_test.h>
  17 #include <vnet/vnet.h>
  18 #include <vlibmemory/api.h>
  19 #include <vnet/session/application.h>
  20 #include <vnet/session/application_interface.h>
  21 #include <vnet/session/session.h>
  22
  23 static void es_set_echo_rx_callbacks (u8 no_echo);
  24
  25 typedef struct
  26 {
  27   CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
  28 #define _(type, name) type name;
  29   foreach_app_session_field
  30 #undef _
  31     u64 vpp_session_handle;
  32   u32 vpp_session_index;
  33   u32 rx_retries;
  34   u8 byte_index;
  35 } es_session_t;
  36
  37 typedef struct
  38 {
  39   CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
  40   es_session_t *sessions;
  41   u8 *rx_buf; /**< Per-thread RX buffer */
  42   svm_msg_q_t *vpp_event_queue;
  43   u32 thread_index;
  44 } es_worker_t;
  45
  46 typedef struct
  47 {
  48   u32 app_index;                /**< Server app index */
  49
  50   /*
  51    * Config params
  52    */
  53   hs_test_cfg_t cfg;
  54   u32 fifo_size;                /**< Fifo size */
  55   u32 rcv_buffer_size;          /**< Rcv buffer size */
  56   u32 prealloc_fifos;           /**< Preallocate fifos */
  57   u32 private_segment_count;    /**< Number of private segments  */
  58   u64 private_segment_size;     /**< Size of private segments  */
  59   char *server_uri;             /**< Server URI */
  60   u32 tls_engine;               /**< TLS engine: mbedtls/openssl */
  61   u32 ckpair_index;             /**< Cert and key for tls/quic */
  62
  63   /*
  64    * Test state
  65    */
  66   es_worker_t *wrk;
  67   int (*rx_callback) (session_t *session);
  68   u8 transport_proto;
  69   u64 listener_handle;          /**< Session handle of the root listener */
  70   u64 ctrl_listener_handle;
  71
  72   vlib_main_t *vlib_main;
  73 } echo_server_main_t;
  74
  75 echo_server_main_t echo_server_main;
  76
  77 #define es_err(_fmt, _args...) clib_warning (_fmt, ##_args);
  78
  79 #define es_dbg(_fmt, _args...)                                                \
  80   do                                                                          \
  81     {                                                                         \
  82       if (PREDICT_FALSE (echo_server_main.cfg.verbose))                       \
  83         es_err (_fmt, ##_args);                                               \
  84     }                                                                         \
  85   while (0)
  86
  87 #define es_cli(_fmt, _args...) vlib_cli_output (vm, _fmt, ##_args)
  88
  89 static inline es_worker_t *
  90 es_worker_get (u32 thread_index)
  91 {
  92   return vec_elt_at_index (echo_server_main.wrk, thread_index);
  93 }
  94
  95 static inline es_session_t *
  96 es_session_alloc (es_worker_t *wrk)
  97 {
  98   es_session_t *es;
  99
 100   pool_get_zero (wrk->sessions, es);
 101   es->session_index = es - wrk->sessions;
 102   return es;
 103 }
 104
 105 static inline es_session_t *
 106 es_session_get (es_worker_t *wrk, u32 es_index)
 107 {
 108   return pool_elt_at_index (wrk->sessions, es_index);
 109 }
 110
 111 int
 112 quic_echo_server_qsession_accept_callback (session_t * s)
 113 {
 114   es_dbg ("QSession %u accept w/opaque %d", s->session_index, s->opaque);
 115   return 0;
 116 }
 117
 118 static int
 119 echo_server_ctrl_session_accept_callback (session_t *s)
 120 {
 121   s->session_state = SESSION_STATE_READY;
 122   return 0;
 123 }
 124
 125 static void
 126 es_session_alloc_and_init (session_t *s)
 127 {
 128   es_session_t *es;
 129   es_worker_t *wrk = es_worker_get (s->thread_index);
 130
 131   es = es_session_alloc (wrk);
 132   hs_test_app_session_init (es, s);
 133   es->vpp_session_index = s->session_index;
 134   es->vpp_session_handle = session_handle (s);
 135   s->opaque = es->session_index;
 136 }
 137
 138 int
 139 quic_echo_server_session_accept_callback (session_t * s)
 140 {
 141   echo_server_main_t *esm = &echo_server_main;
 142
 143   if (PREDICT_FALSE (esm->ctrl_listener_handle == s->listener_handle))
 144     return echo_server_ctrl_session_accept_callback (s);
 145
 146   if (s->listener_handle == esm->listener_handle)
 147     return quic_echo_server_qsession_accept_callback (s);
 148
 149   es_dbg ("SSESSION %u accept w/opaque %d", s->session_index, s->opaque);
 150
 151   s->session_state = SESSION_STATE_READY;
 152   es_session_alloc_and_init (s);
 153   return 0;
 154 }
 155
 156 int
 157 echo_server_session_accept_callback (session_t * s)
 158 {
 159   echo_server_main_t *esm = &echo_server_main;
 160
 161   if (PREDICT_FALSE (esm->ctrl_listener_handle == s->listener_handle))
 162     return echo_server_ctrl_session_accept_callback (s);
 163
 164   s->session_state = SESSION_STATE_READY;
 165   es_session_alloc_and_init (s);
 166   return 0;
 167 }
 168
 169 void
 170 echo_server_session_disconnect_callback (session_t * s)
 171 {
 172   echo_server_main_t *esm = &echo_server_main;
 173   vnet_disconnect_args_t _a = { 0 }, *a = &_a;
 174
 175   a->handle = session_handle (s);
 176   a->app_index = esm->app_index;
 177   vnet_disconnect_session (a);
 178 }
 179
 180 void
 181 echo_server_session_reset_callback (session_t * s)
 182 {
 183   echo_server_main_t *esm = &echo_server_main;
 184   vnet_disconnect_args_t _a = { 0 }, *a = &_a;
 185   es_dbg ("Reset session %U", format_session, s, 2);
 186   a->handle = session_handle (s);
 187   a->app_index = esm->app_index;
 188   vnet_disconnect_session (a);
 189 }
 190
 191 int
 192 echo_server_session_connected_callback (u32 app_index, u32 api_context,
 193                                         session_t * s, session_error_t err)
 194 {
 195   es_err ("called...");
 196   return -1;
 197 }
 198
 199 int
 200 echo_server_add_segment_callback (u32 client_index, u64 segment_handle)
 201 {
 202   /* New heaps may be added */
 203   return 0;
 204 }
 205
 206 int
 207 echo_server_redirect_connect_callback (u32 client_index, void *mp)
 208 {
 209   es_err ("called...");
 210   return -1;
 211 }
 212
 213 static void
 214 es_foreach_thread (void *fp)
 215 {
 216   echo_server_main_t *esm = &echo_server_main;
 217   uword thread_index;
 218   for (thread_index = 0; thread_index < vec_len (esm->wrk); thread_index++)
 219     {
 220       session_send_rpc_evt_to_thread (thread_index, fp,
 221                                       uword_to_pointer (thread_index, void *));
 222     }
 223 }
 224
 225 static int
 226 es_wrk_prealloc_sessions (void *args)
 227 {
 228   echo_server_main_t *esm = &echo_server_main;
 229   u32 sessions_per_wrk, n_wrks, thread_index;
 230
 231   thread_index = pointer_to_uword (args);
 232   es_worker_t *wrk = es_worker_get (thread_index);
 233   n_wrks = vlib_num_workers () ? vlib_num_workers () : 1;
 234   sessions_per_wrk = esm->cfg.num_test_sessions / n_wrks;
 235   pool_alloc (wrk->sessions, 1.1 * sessions_per_wrk);
 236   return 0;
 237 }
 238
 239 static int
 240 echo_server_setup_test (hs_test_cfg_t *c)
 241 {
 242   if (c->test == HS_TEST_TYPE_UNI)
 243     es_set_echo_rx_callbacks (1 /* no echo */);
 244   else
 245     es_set_echo_rx_callbacks (0 /* no echo */);
 246
 247   es_foreach_thread (es_wrk_prealloc_sessions);
 248   return 0;
 249 }
 250
 251 static void
 252 echo_server_ctrl_reply (session_t *s)
 253 {
 254   echo_server_main_t *esm = &echo_server_main;
 255   int rv;
 256
 257   rv = svm_fifo_enqueue (s->tx_fifo, sizeof (esm->cfg), (u8 *) &esm->cfg);
 258   ASSERT (rv == sizeof (esm->cfg));
 259   session_send_io_evt_to_thread_custom (&s->session_index, s->thread_index,
 260                                         SESSION_IO_EVT_TX);
 261 }
 262
 263 static int
 264 es_test_cmd_sync (echo_server_main_t *esm, session_t *s)
 265 {
 266   int rv;
 267
 268   rv = echo_server_setup_test (&esm->cfg);
 269   if (rv)
 270     es_err ("setup test error!");
 271
 272   echo_server_ctrl_reply (s);
 273   return 0;
 274 }
 275
 276 static int
 277 es_wrk_cleanup_sessions (void *args)
 278 {
 279   echo_server_main_t *esm = &echo_server_main;
 280   vnet_disconnect_args_t _a = {}, *a = &_a;
 281   u32 thread_index = pointer_to_uword (args);
 282   es_session_t *es;
 283   es_worker_t *wrk;
 284
 285   wrk = es_worker_get (thread_index);
 286   a->app_index = esm->app_index;
 287
 288   pool_foreach (es, wrk->sessions)
 289     {
 290       a->handle = es->vpp_session_handle;
 291       vnet_disconnect_session (a);
 292     }
 293   pool_free (wrk->sessions);
 294
 295   return 0;
 296 }
 297
 298 static int
 299 echo_server_rx_ctrl_callback (session_t *s)
 300 {
 301   echo_server_main_t *esm = &echo_server_main;
 302   int rv;
 303
 304   rv = svm_fifo_dequeue (s->rx_fifo, sizeof (esm->cfg), (u8 *) &esm->cfg);
 305   ASSERT (rv == sizeof (esm->cfg));
 306
 307   es_dbg ("control message received:");
 308   if (esm->cfg.verbose)
 309     hs_test_cfg_dump (&esm->cfg, 0);
 310
 311   switch (esm->cfg.cmd)
 312     {
 313     case HS_TEST_CMD_SYNC:
 314       switch (esm->cfg.test)
 315         {
 316         case HS_TEST_TYPE_ECHO:
 317         case HS_TEST_TYPE_NONE:
 318           es_foreach_thread (es_wrk_cleanup_sessions);
 319           echo_server_ctrl_reply (s);
 320           break;
 321         case HS_TEST_TYPE_UNI:
 322         case HS_TEST_TYPE_BI:
 323           return es_test_cmd_sync (esm, s);
 324           break;
 325         default:
 326           es_err ("unknown command type! %d", esm->cfg.cmd);
 327         }
 328       break;
 329     case HS_TEST_CMD_START:
 330     case HS_TEST_CMD_STOP:
 331       echo_server_ctrl_reply (s);
 332       break;
 333     default:
 334       es_err ("unknown command! %d", esm->cfg.cmd);
 335       break;
 336     }
 337   return 0;
 338 }
 339
 340 /*
 341  * If no-echo, just drop the data and be done with it.
 342  */
 343 int
 344 echo_server_builtin_server_rx_callback_no_echo (session_t * s)
 345 {
 346   echo_server_main_t *esm = &echo_server_main;
 347   if (PREDICT_FALSE (esm->ctrl_listener_handle == s->listener_handle))
 348     return echo_server_rx_ctrl_callback (s);
 349
 350   svm_fifo_t *rx_fifo = s->rx_fifo;
 351   svm_fifo_dequeue_drop (rx_fifo, svm_fifo_max_dequeue_cons (rx_fifo));
 352   return 0;
 353 }
 354
 355 static void
 356 es_test_bytes (es_worker_t *wrk, es_session_t *es, int actual_transfer)
 357 {
 358   int i;
 359   for (i = 0; i < actual_transfer; i++)
 360     {
 361       if (wrk->rx_buf[i] != ((es->byte_index + i) & 0xff))
 362         {
 363           es_err ("at %lld expected %d got %d", es->byte_index + i,
 364                   (es->byte_index + i) & 0xff, wrk->rx_buf[i]);
 365         }
 366     }
 367   es->byte_index += actual_transfer;
 368 }
 369
 370 int
 371 echo_server_rx_callback (session_t * s)
 372 {
 373   u32 n_written, max_dequeue, max_enqueue, max_transfer;
 374   int actual_transfer;
 375   svm_fifo_t *tx_fifo, *rx_fifo;
 376   echo_server_main_t *esm = &echo_server_main;
 377   u32 thread_index = vlib_get_thread_index ();
 378   es_worker_t *wrk;
 379   es_session_t *es;
 380
 381   ASSERT (s->thread_index == thread_index);
 382
 383   rx_fifo = s->rx_fifo;
 384   tx_fifo = s->tx_fifo;
 385
 386   ASSERT (rx_fifo->master_thread_index == thread_index);
 387   ASSERT (tx_fifo->master_thread_index == thread_index);
 388
 389   if (PREDICT_FALSE (esm->ctrl_listener_handle == s->listener_handle))
 390     return echo_server_rx_ctrl_callback (s);
 391
 392   wrk = es_worker_get (thread_index);
 393   max_enqueue = svm_fifo_max_enqueue_prod (tx_fifo);
 394   es = es_session_get (wrk, s->opaque);
 395
 396   if (es->is_dgram)
 397     {
 398       session_dgram_pre_hdr_t ph;
 399       svm_fifo_peek (rx_fifo, 0, sizeof (ph), (u8 *) & ph);
 400       max_dequeue = ph.data_length - ph.data_offset;
 401       ASSERT (wrk->vpp_event_queue);
 402       max_enqueue -= sizeof (session_dgram_hdr_t);
 403     }
 404   else
 405     {
 406       max_dequeue = svm_fifo_max_dequeue_cons (rx_fifo);
 407     }
 408
 409   if (PREDICT_FALSE (max_dequeue == 0))
 410     return 0;
 411
 412   /* Number of bytes we're going to copy */
 413   max_transfer = clib_min (max_dequeue, max_enqueue);
 414
 415   /* No space in tx fifo */
 416   if (PREDICT_FALSE (max_transfer == 0))
 417     {
 418       /* XXX timeout for session that are stuck */
 419
 420     rx_event:
 421       /* Program self-tap to retry */
 422       if (svm_fifo_set_event (rx_fifo))
 423         {
 424           /* TODO should be session_enqueue_notify(s) but quic tests seem
 425            * to fail if that's the case */
 426           if (session_send_io_evt_to_thread (rx_fifo,
 427                                              SESSION_IO_EVT_BUILTIN_RX))
 428             es_err ("failed to enqueue self-tap");
 429
 430           if (es->rx_retries == 500000)
 431             {
 432               es_err ("session stuck: %U", format_session, s, 2);
 433             }
 434           if (es->rx_retries < 500001)
 435             es->rx_retries++;
 436         }
 437
 438       return 0;
 439     }
 440
 441   vec_validate (wrk->rx_buf, max_transfer);
 442   actual_transfer = app_recv ((app_session_t *) es, wrk->rx_buf, max_transfer);
 443   ASSERT (actual_transfer == max_transfer);
 444
 445   if (esm->cfg.test_bytes)
 446     {
 447       es_test_bytes (wrk, es, actual_transfer);
 448     }
 449
 450   /*
 451    * Echo back
 452    */
 453
 454   n_written = app_send ((app_session_t *) es, wrk->rx_buf, actual_transfer, 0);
 455
 456   if (n_written != max_transfer)
 457     es_err ("short trout! written %u read %u", n_written, max_transfer);
 458
 459   if (PREDICT_FALSE (svm_fifo_max_dequeue_cons (rx_fifo)))
 460     goto rx_event;
 461
 462   return 0;
 463 }
 464
 465 int
 466 echo_server_rx_callback_common (session_t *s)
 467 {
 468   echo_server_main_t *esm = &echo_server_main;
 469   return esm->rx_callback (s);
 470 }
 471
 472 static session_cb_vft_t echo_server_session_cb_vft = {
 473   .session_accept_callback = echo_server_session_accept_callback,
 474   .session_disconnect_callback = echo_server_session_disconnect_callback,
 475   .session_connected_callback = echo_server_session_connected_callback,
 476   .add_segment_callback = echo_server_add_segment_callback,
 477   .builtin_app_rx_callback = echo_server_rx_callback_common,
 478   .session_reset_callback = echo_server_session_reset_callback
 479 };
 480
 481 static void
 482 es_set_echo_rx_callbacks (u8 no_echo)
 483 {
 484   echo_server_main_t *esm = &echo_server_main;
 485   if (no_echo)
 486     esm->rx_callback = echo_server_builtin_server_rx_callback_no_echo;
 487   else
 488     esm->rx_callback = echo_server_rx_callback;
 489 }
 490
 491 static int
 492 echo_server_attach (u8 * appns_id, u64 appns_flags, u64 appns_secret)
 493 {
 494   vnet_app_add_cert_key_pair_args_t _ck_pair, *ck_pair = &_ck_pair;
 495   echo_server_main_t *esm = &echo_server_main;
 496   vnet_app_attach_args_t _a, *a = &_a;
 497   u64 options[APP_OPTIONS_N_OPTIONS];
 498
 499   clib_memset (a, 0, sizeof (*a));
 500   clib_memset (options, 0, sizeof (options));
 501
 502   esm->rx_callback = echo_server_rx_callback;
 503
 504   if (esm->transport_proto == TRANSPORT_PROTO_QUIC)
 505     echo_server_session_cb_vft.session_accept_callback =
 506       quic_echo_server_session_accept_callback;
 507
 508   a->api_client_index = ~0;
 509   a->name = format (0, "echo_server");
 510   a->session_cb_vft = &echo_server_session_cb_vft;
 511   a->options = options;
 512   a->options[APP_OPTIONS_SEGMENT_SIZE] = esm->private_segment_size;
 513   a->options[APP_OPTIONS_ADD_SEGMENT_SIZE] = esm->private_segment_size;
 514   a->options[APP_OPTIONS_RX_FIFO_SIZE] = esm->fifo_size;
 515   a->options[APP_OPTIONS_TX_FIFO_SIZE] = esm->fifo_size;
 516   a->options[APP_OPTIONS_PRIVATE_SEGMENT_COUNT] = esm->private_segment_count;
 517   a->options[APP_OPTIONS_TLS_ENGINE] = esm->tls_engine;
 518   a->options[APP_OPTIONS_PCT_FIRST_ALLOC] = 100;
 519   a->options[APP_OPTIONS_PREALLOC_FIFO_PAIRS] =
 520     esm->prealloc_fifos ? esm->prealloc_fifos : 1;
 521
 522   a->options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_IS_BUILTIN;
 523   if (appns_id)
 524     {
 525       a->namespace_id = appns_id;
 526       a->options[APP_OPTIONS_FLAGS] |= appns_flags;
 527       a->options[APP_OPTIONS_NAMESPACE_SECRET] = appns_secret;
 528     }
 529
 530   if (vnet_application_attach (a))
 531     {
 532       es_err ("failed to attach server");
 533       return -1;
 534     }
 535   esm->app_index = a->app_index;
 536   vec_free (a->name);
 537
 538   clib_memset (ck_pair, 0, sizeof (*ck_pair));
 539   ck_pair->cert = (u8 *) test_srv_crt_rsa;
 540   ck_pair->key = (u8 *) test_srv_key_rsa;
 541   ck_pair->cert_len = test_srv_crt_rsa_len;
 542   ck_pair->key_len = test_srv_key_rsa_len;
 543   vnet_app_add_cert_key_pair (ck_pair);
 544   esm->ckpair_index = ck_pair->index;
 545
 546   return 0;
 547 }
 548
 549 static int
 550 echo_server_detach (void)
 551 {
 552   echo_server_main_t *esm = &echo_server_main;
 553   vnet_app_detach_args_t _da, *da = &_da;
 554   int rv;
 555
 556   da->app_index = esm->app_index;
 557   da->api_client_index = ~0;
 558   rv = vnet_application_detach (da);
 559   esm->app_index = ~0;
 560   vnet_app_del_cert_key_pair (esm->ckpair_index);
 561   return rv;
 562 }
 563
 564 static int
 565 echo_client_transport_needs_crypto (transport_proto_t proto)
 566 {
 567   return proto == TRANSPORT_PROTO_TLS || proto == TRANSPORT_PROTO_DTLS ||
 568          proto == TRANSPORT_PROTO_QUIC;
 569 }
 570
 571 static int
 572 echo_server_listen_ctrl ()
 573 {
 574   echo_server_main_t *esm = &echo_server_main;
 575   vnet_listen_args_t _args = {}, *args = &_args;
 576   session_error_t rv;
 577
 578   if ((rv = parse_uri (esm->server_uri, &args->sep_ext)))
 579     return -1;
 580   args->sep_ext.transport_proto = TRANSPORT_PROTO_TCP;
 581   args->app_index = esm->app_index;
 582
 583   rv = vnet_listen (args);
 584   esm->ctrl_listener_handle = args->handle;
 585   return rv;
 586 }
 587
 588 static int
 589 echo_server_listen ()
 590 {
 591   i32 rv;
 592   echo_server_main_t *esm = &echo_server_main;
 593   vnet_listen_args_t _args = {}, *args = &_args;
 594
 595   if ((rv = parse_uri (esm->server_uri, &args->sep_ext)))
 596     {
 597       return -1;
 598     }
 599   args->app_index = esm->app_index;
 600   args->sep_ext.port = hs_make_data_port (args->sep_ext.port);
 601   if (echo_client_transport_needs_crypto (args->sep_ext.transport_proto))
 602     {
 603       session_endpoint_alloc_ext_cfg (&args->sep_ext,
 604                                       TRANSPORT_ENDPT_EXT_CFG_CRYPTO);
 605       args->sep_ext.ext_cfg->crypto.ckpair_index = esm->ckpair_index;
 606     }
 607
 608   if (args->sep_ext.transport_proto == TRANSPORT_PROTO_UDP)
 609     {
 610       args->sep_ext.transport_flags = TRANSPORT_CFG_F_CONNECTED;
 611     }
 612
 613   rv = vnet_listen (args);
 614   esm->listener_handle = args->handle;
 615   if (args->sep_ext.ext_cfg)
 616     clib_mem_free (args->sep_ext.ext_cfg);
 617   return rv;
 618 }
 619
 620 static int
 621 echo_server_create (vlib_main_t * vm, u8 * appns_id, u64 appns_flags,
 622                     u64 appns_secret)
 623 {
 624   echo_server_main_t *esm = &echo_server_main;
 625   vlib_thread_main_t *vtm = vlib_get_thread_main ();
 626   es_worker_t *wrk;
 627
 628   esm->rcv_buffer_size = clib_max (esm->rcv_buffer_size, esm->fifo_size);
 629   vec_validate (esm->wrk, vtm->n_threads);
 630
 631   vec_foreach (wrk, esm->wrk)
 632     {
 633       wrk->thread_index = wrk - esm->wrk;
 634       vec_validate (wrk->rx_buf, esm->rcv_buffer_size);
 635       wrk->vpp_event_queue =
 636         session_main_get_vpp_event_queue (wrk->thread_index);
 637     }
 638
 639   if (echo_server_attach (appns_id, appns_flags, appns_secret))
 640     {
 641       es_err ("failed to attach server");
 642       return -1;
 643     }
 644   if (echo_server_listen_ctrl ())
 645     {
 646       es_err ("failed to start listening on ctrl session");
 647       if (echo_server_detach ())
 648         es_err ("failed to detach");
 649       return -1;
 650     }
 651   if (echo_server_listen ())
 652     {
 653       es_err ("failed to start listening");
 654       if (echo_server_detach ())
 655         es_err ("failed to detach");
 656       return -1;
 657     }
 658   return 0;
 659 }
 660
 661 static clib_error_t *
 662 echo_server_create_command_fn (vlib_main_t * vm, unformat_input_t * input,
 663                                vlib_cli_command_t * cmd)
 664 {
 665   session_endpoint_cfg_t sep = SESSION_ENDPOINT_CFG_NULL;
 666   echo_server_main_t *esm = &echo_server_main;
 667   u8 server_uri_set = 0, *appns_id = 0;
 668   u64 appns_flags = 0, appns_secret = 0;
 669   char *default_uri = "tcp://0.0.0.0/1234";
 670   int rv, is_stop = 0;
 671   clib_error_t *error = 0;
 672
 673   esm->fifo_size = 64 << 10;
 674   esm->rcv_buffer_size = 128 << 10;
 675   esm->prealloc_fifos = 0;
 676   esm->private_segment_count = 0;
 677   esm->private_segment_size = 512 << 20;
 678   esm->tls_engine = CRYPTO_ENGINE_OPENSSL;
 679   vec_free (esm->server_uri);
 680
 681   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 682     {
 683       if (unformat (input, "uri %s", &esm->server_uri))
 684         server_uri_set = 1;
 685       else if (unformat (input, "fifo-size %U", unformat_memory_size,
 686                          &esm->fifo_size))
 687         ;
 688       else if (unformat (input, "rcv-buf-size %d", &esm->rcv_buffer_size))
 689         ;
 690       else if (unformat (input, "prealloc-fifos %d", &esm->prealloc_fifos))
 691         ;
 692       else if (unformat (input, "private-segment-count %d",
 693                          &esm->private_segment_count))
 694         ;
 695       else if (unformat (input, "private-segment-size %U",
 696                          unformat_memory_size, &esm->private_segment_size))
 697         ;
 698       else if (unformat (input, "appns %_%v%_", &appns_id))
 699         ;
 700       else if (unformat (input, "all-scope"))
 701         appns_flags |= (APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE
 702                         | APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE);
 703       else if (unformat (input, "local-scope"))
 704         appns_flags |= APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
 705       else if (unformat (input, "global-scope"))
 706         appns_flags |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
 707       else if (unformat (input, "secret %lu", &appns_secret))
 708         ;
 709       else if (unformat (input, "stop"))
 710         is_stop = 1;
 711       else if (unformat (input, "tls-engine %d", &esm->tls_engine))
 712         ;
 713       else
 714         {
 715           error = clib_error_return (0, "failed: unknown input `%U'",
 716                                      format_unformat_error, input);
 717           goto cleanup;
 718         }
 719     }
 720
 721   if (is_stop)
 722     {
 723       if (esm->app_index == (u32) ~ 0)
 724         {
 725           es_cli ("server not running");
 726           error = clib_error_return (0, "failed: server not running");
 727           goto cleanup;
 728         }
 729       rv = echo_server_detach ();
 730       if (rv)
 731         {
 732           es_cli ("failed: detach");
 733           error = clib_error_return (0, "failed: server detach %d", rv);
 734           goto cleanup;
 735         }
 736       goto cleanup;
 737     }
 738
 739   vnet_session_enable_disable (vm, 1 /* turn on TCP, etc. */ );
 740
 741   if (!server_uri_set)
 742     {
 743       es_cli ("No uri provided! Using default: %s", default_uri);
 744       esm->server_uri = (char *) format (0, "%s%c", default_uri, 0);
 745     }
 746
 747   if ((rv = parse_uri ((char *) esm->server_uri, &sep)))
 748     {
 749       error = clib_error_return (0, "Uri parse error: %d", rv);
 750       goto cleanup;
 751     }
 752   esm->transport_proto = sep.transport_proto;
 753
 754   rv = echo_server_create (vm, appns_id, appns_flags, appns_secret);
 755   if (rv)
 756     {
 757       vec_free (esm->server_uri);
 758       error = clib_error_return (0, "failed: server_create returned %d", rv);
 759       goto cleanup;
 760     }
 761
 762 cleanup:
 763   vec_free (appns_id);
 764
 765   return error;
 766 }
 767
 768 VLIB_CLI_COMMAND (echo_server_create_command, static) = {
 769   .path = "test echo server",
 770   .short_help =
 771     "test echo server proto <proto> [fifo-size <mbytes>]"
 772     "[rcv-buf-size <bytes>][prealloc-fifos <count>]"
 773     "[private-segment-count <count>][private-segment-size <bytes[m|g]>]"
 774     "[uri <tcp://ip/port>]",
 775   .function = echo_server_create_command_fn,
 776 };
 777
 778 clib_error_t *
 779 echo_server_main_init (vlib_main_t * vm)
 780 {
 781   return 0;
 782 }
 783
 784 VLIB_INIT_FUNCTION (echo_server_main_init);
 785
 786 /*
 787 * fd.io coding-style-patch-verification: ON
 788 *
 789 * Local Variables:
 790 * eval: (c-set-style "gnu")
 791 * End:
 792 */