src/plugins/hs_apps/sapi/quic_echo.c

   1 /*
   2  * Copyright (c) 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 <stdio.h>
  17 #include <signal.h>
  18
  19 #include <vnet/session/application_interface.h>
  20 #include <vlibmemory/api.h>
  21
  22 #include <vpp/api/vpe_msg_enum.h>
  23 #include <svm/fifo_segment.h>
  24
  25 #define vl_typedefs             /* define message structures */
  26 #include <vpp/api/vpe_all_api_h.h>
  27 #undef vl_typedefs
  28
  29 /* declare message handlers for each api */
  30
  31 #define vl_endianfun            /* define message structures */
  32 #include <vpp/api/vpe_all_api_h.h>
  33 #undef vl_endianfun
  34
  35 /* instantiate all the print functions we know about */
  36 #define vl_print(handle, ...)
  37 #define vl_printfun
  38 #include <vpp/api/vpe_all_api_h.h>
  39 #undef vl_printfun
  40
  41 #define SESSION_INVALID_INDEX ((u32)~0)
  42 #define SESSION_INVALID_HANDLE ((u64)~0)
  43
  44 #define QUIC_ECHO_DBG 0
  45 #define DBG(_fmt, _args...)                     \
  46     if (QUIC_ECHO_DBG)                          \
  47       clib_warning (_fmt, ##_args)
  48
  49 #define CHECK(expected, result, _fmt, _args...)         \
  50     if (expected != result)                             \
  51       ECHO_FAIL ("expected %d, got %d : " _fmt, expected, result, ##_args);
  52
  53 #define ECHO_FAIL(_fmt,_args...)        \
  54   {                                     \
  55     echo_main_t *em = &echo_main;       \
  56     em->has_failed = 1;         \
  57     em->time_to_stop = 1;               \
  58     clib_warning ("ECHO-ERROR: "_fmt, ##_args);         \
  59   }
  60
  61 typedef enum
  62 {
  63   SESSION_FLAG_NOFLAG = 0,
  64   SESSION_FLAG_SHOULD_CLOSE = 1,
  65   SESSION_FLAG_SHOULD_FREE = 2,
  66 } echo_session_flag_t;
  67
  68 typedef struct
  69 {
  70   CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
  71 #define _(type, name) type name;
  72   foreach_app_session_field
  73 #undef _
  74   u64 vpp_session_handle;
  75   u64 bytes_sent;
  76   u64 bytes_to_send;
  77   volatile u64 bytes_received;
  78   volatile u64 bytes_to_receive;
  79   f64 start;
  80   u32 listener_index;           /* listener index in echo session pool */
  81   volatile u64 accepted_session_count;  /* sessions we accepted */
  82   volatile echo_session_flag_t flags;
  83 } echo_session_t;
  84
  85 typedef enum
  86 {
  87   ECHO_NO_DATA_SOURCE,
  88   ECHO_TEST_DATA_SOURCE,
  89   ECHO_RX_DATA_SOURCE,
  90   ECHO_INVALID_DATA_SOURCE
  91 } data_source_t;
  92
  93 enum quic_session_type_t
  94 {
  95   QUIC_SESSION_TYPE_QUIC,
  96   QUIC_SESSION_TYPE_STREAM,
  97   QUIC_SESSION_TYPE_LISTEN,
  98 };
  99
 100
 101 typedef enum
 102 {
 103   STATE_START,
 104   STATE_ATTACHED,
 105   STATE_LISTEN,
 106   STATE_READY,
 107   STATE_DISCONNECTED,
 108   STATE_DETACHED
 109 } connection_state_t;
 110
 111 typedef enum
 112 {
 113   ECHO_EVT_START,               /* app starts */
 114   ECHO_EVT_FIRST_QCONNECT,      /* First connect Quic session sent */
 115   ECHO_EVT_LAST_QCONNECTED,     /* All Quic session are connected */
 116   ECHO_EVT_FIRST_SCONNECT,      /* First connect Stream session sent */
 117   ECHO_EVT_LAST_SCONNECTED,     /* All Stream session are connected */
 118   ECHO_EVT_LAST_BYTE,           /* Last byte received */
 119   ECHO_EVT_EXIT,                /* app exits */
 120 } echo_test_evt_t;
 121
 122 typedef struct _quic_echo_cb_vft
 123 {
 124   void (*quic_connected_cb) (session_connected_msg_t * mp, u32 session_index);
 125   void (*client_stream_connected_cb) (session_connected_msg_t * mp,
 126                                       u32 session_index);
 127   void (*server_stream_connected_cb) (session_connected_msg_t * mp,
 128                                       u32 session_index);
 129   void (*quic_accepted_cb) (session_accepted_msg_t * mp, u32 session_index);
 130   void (*client_stream_accepted_cb) (session_accepted_msg_t * mp,
 131                                      u32 session_index);
 132   void (*server_stream_accepted_cb) (session_accepted_msg_t * mp,
 133                                      u32 session_index);
 134 } quic_echo_cb_vft_t;
 135
 136
 137 typedef enum
 138 {
 139   RETURN_PACKETS_NOTEST,
 140   RETURN_PACKETS_LOG_WRONG,
 141   RETURN_PACKETS_ASSERT,
 142 } test_return_packets_t;
 143
 144 typedef struct
 145 {
 146   /* vpe input queue */
 147   svm_queue_t *vl_input_queue;
 148
 149   /* API client handle */
 150   u32 my_client_index;
 151
 152   /* The URI we're playing with */
 153   u8 *uri;
 154
 155   /* Session pool */
 156   echo_session_t *sessions;
 157
 158   /* Hash table for disconnect processing */
 159   uword *session_index_by_vpp_handles;
 160   /* Index of vpp listener session */
 161   u32 listen_session_index;
 162
 163   /* Hash table for shared segment_names */
 164   uword *shared_segment_handles;
 165   clib_spinlock_t segment_handles_lock;
 166
 167   int i_am_master;
 168
 169   /* Our event queue */
 170   svm_msg_q_t *our_event_queue;
 171
 172   u8 *socket_name;
 173
 174   pid_t my_pid;
 175
 176   /* For deadman timers */
 177   clib_time_t clib_time;
 178
 179   /* State of the connection, shared between msg RX thread and main thread */
 180   volatile connection_state_t state;
 181
 182   /* Signal variables */
 183   volatile u8 time_to_stop;
 184   u8 has_failed;
 185
 186   /* VNET_API_ERROR_FOO -> "Foo" hash table */
 187   uword *error_string_by_error_number;
 188
 189   u8 *connect_test_data;
 190   u8 test_return_packets;
 191   u64 bytes_to_send;
 192   u64 bytes_to_receive;
 193   u32 fifo_size;
 194   u32 rx_buf_size;
 195   u32 tx_buf_size;
 196   data_source_t data_source;
 197   u8 send_disconnects;          /* actively send disconnect */
 198
 199   u8 *appns_id;
 200   u64 appns_flags;
 201   u64 appns_secret;
 202
 203   pthread_t *client_thread_handles;
 204   u32 *thread_args;
 205   u32 n_clients;                /* Target number of QUIC sessions */
 206   u32 n_stream_clients;         /* Target Number of STREAM sessions per QUIC session */
 207   volatile u32 n_quic_clients_connected;        /* Number of connected QUIC sessions */
 208   volatile u32 n_clients_connected;     /* Number of STREAM sessions connected */
 209
 210   u64 tx_total;
 211   u64 rx_total;
 212
 213   /* Event based timing : start & end depend on CLI specified events */
 214   u8 first_sconnect_sent;       /* Sent the first Stream session connect ? */
 215   f64 start_time;
 216   f64 end_time;
 217   u8 timing_start_event;
 218   u8 timing_end_event;
 219
 220   /* cb vft for QUIC scenarios */
 221   quic_echo_cb_vft_t cb_vft;
 222
 223   /** Flag that decides if socket, instead of svm, api is used to connect to
 224    * vpp. If sock api is used, shm binary api is subsequently bootstrapped
 225    * and all other messages are exchanged using shm IPC. */
 226   u8 use_sock_api;
 227
 228   /* Limit the number of incorrect data messages */
 229   int max_test_msg;
 230
 231   fifo_segment_main_t segment_main;
 232 } echo_main_t;
 233
 234 echo_main_t echo_main;
 235
 236 #if CLIB_DEBUG > 0
 237 #define NITER 10000
 238 #else
 239 #define NITER 4000000
 240 #endif
 241
 242 #if CLIB_DEBUG > 0
 243 #define TIMEOUT 10.0
 244 #else
 245 #define TIMEOUT 10.0
 246 #endif
 247
 248 /*
 249  *
 250  *  Format functions
 251  *
 252  */
 253
 254 u8 *
 255 format_ip4_address (u8 * s, va_list * args)
 256 {
 257   u8 *a = va_arg (*args, u8 *);
 258   return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
 259 }
 260
 261 u8 *
 262 format_ip6_address (u8 * s, va_list * args)
 263 {
 264   ip6_address_t *a = va_arg (*args, ip6_address_t *);
 265   u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
 266
 267   i_max_n_zero = ARRAY_LEN (a->as_u16);
 268   max_n_zeros = 0;
 269   i_first_zero = i_max_n_zero;
 270   n_zeros = 0;
 271   for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
 272     {
 273       u32 is_zero = a->as_u16[i] == 0;
 274       if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
 275         {
 276           i_first_zero = i;
 277           n_zeros = 0;
 278         }
 279       n_zeros += is_zero;
 280       if ((!is_zero && n_zeros > max_n_zeros)
 281           || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
 282         {
 283           i_max_n_zero = i_first_zero;
 284           max_n_zeros = n_zeros;
 285           i_first_zero = ARRAY_LEN (a->as_u16);
 286           n_zeros = 0;
 287         }
 288     }
 289
 290   last_double_colon = 0;
 291   for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
 292     {
 293       if (i == i_max_n_zero && max_n_zeros > 1)
 294         {
 295           s = format (s, "::");
 296           i += max_n_zeros - 1;
 297           last_double_colon = 1;
 298         }
 299       else
 300         {
 301           s = format (s, "%s%x",
 302                       (last_double_colon || i == 0) ? "" : ":",
 303                       clib_net_to_host_u16 (a->as_u16[i]));
 304           last_double_colon = 0;
 305         }
 306     }
 307
 308   return s;
 309 }
 310
 311 /* Format an IP46 address. */
 312 u8 *
 313 format_ip46_address (u8 * s, va_list * args)
 314 {
 315   ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
 316   ip46_type_t type = va_arg (*args, ip46_type_t);
 317   int is_ip4 = 1;
 318
 319   switch (type)
 320     {
 321     case IP46_TYPE_ANY:
 322       is_ip4 = ip46_address_is_ip4 (ip46);
 323       break;
 324     case IP46_TYPE_IP4:
 325       is_ip4 = 1;
 326       break;
 327     case IP46_TYPE_IP6:
 328       is_ip4 = 0;
 329       break;
 330     }
 331
 332   return is_ip4 ?
 333     format (s, "%U", format_ip4_address, &ip46->ip4) :
 334     format (s, "%U", format_ip6_address, &ip46->ip6);
 335 }
 336
 337 u8 *
 338 format_quic_echo_state (u8 * s, va_list * args)
 339 {
 340   u32 state = va_arg (*args, u32);
 341   if (state == STATE_START)
 342     return format (s, "STATE_START");
 343   if (state == STATE_ATTACHED)
 344     return format (s, "STATE_ATTACHED");
 345   if (state == STATE_LISTEN)
 346     return format (s, "STATE_LISTEN");
 347   if (state == STATE_READY)
 348     return format (s, "STATE_READY");
 349   if (state == STATE_DISCONNECTED)
 350     return format (s, "STATE_DISCONNECTED");
 351   if (state == STATE_DETACHED)
 352     return format (s, "STATE_DETACHED");
 353   else
 354     return format (s, "unknown state");
 355 }
 356
 357 static u8 *
 358 format_api_error (u8 * s, va_list * args)
 359 {
 360   echo_main_t *em = &echo_main;
 361   i32 error = va_arg (*args, u32);
 362   uword *p;
 363
 364   p = hash_get (em->error_string_by_error_number, -error);
 365
 366   if (p)
 367     s = format (s, "%s", p[0]);
 368   else
 369     s = format (s, "%d", error);
 370   return s;
 371 }
 372
 373 static uword
 374 unformat_data (unformat_input_t * input, va_list * args)
 375 {
 376   u64 _a;
 377   u64 *a = va_arg (*args, u64 *);
 378   if (unformat (input, "%lluGb", &_a))
 379     {
 380       *a = _a << 30;
 381       return 1;
 382     }
 383   else if (unformat (input, "%lluMb", &_a))
 384     {
 385       *a = _a << 20;
 386       return 1;
 387     }
 388   else if (unformat (input, "%lluKb", &_a))
 389     {
 390       *a = _a << 10;
 391       return 1;
 392     }
 393   else if (unformat (input, "%llu", a))
 394     return 1;
 395   return 0;
 396 }
 397
 398 static uword
 399 echo_unformat_timing_event (unformat_input_t * input, va_list * args)
 400 {
 401   echo_test_evt_t *a = va_arg (*args, echo_test_evt_t *);
 402   if (unformat (input, "start"))
 403     *a = ECHO_EVT_START;
 404   else if (unformat (input, "qconnect"))
 405     *a = ECHO_EVT_FIRST_QCONNECT;
 406   else if (unformat (input, "qconnected"))
 407     *a = ECHO_EVT_LAST_QCONNECTED;
 408   else if (unformat (input, "sconnect"))
 409     *a = ECHO_EVT_FIRST_SCONNECT;
 410   else if (unformat (input, "sconnected"))
 411     *a = ECHO_EVT_LAST_SCONNECTED;
 412   else if (unformat (input, "lastbyte"))
 413     *a = ECHO_EVT_LAST_BYTE;
 414   else if (unformat (input, "exit"))
 415     *a = ECHO_EVT_EXIT;
 416   else
 417     return 0;
 418   return 1;
 419 }
 420
 421 u8 *
 422 echo_format_timing_event (u8 * s, va_list * args)
 423 {
 424   u32 timing_event = va_arg (*args, u32);
 425   if (timing_event == ECHO_EVT_START)
 426     return format (s, "start");
 427   if (timing_event == ECHO_EVT_FIRST_QCONNECT)
 428     return format (s, "qconnect");
 429   if (timing_event == ECHO_EVT_LAST_QCONNECTED)
 430     return format (s, "qconnected");
 431   if (timing_event == ECHO_EVT_FIRST_SCONNECT)
 432     return format (s, "sconnect");
 433   if (timing_event == ECHO_EVT_LAST_SCONNECTED)
 434     return format (s, "sconnected");
 435   if (timing_event == ECHO_EVT_LAST_BYTE)
 436     return format (s, "lastbyte");
 437   if (timing_event == ECHO_EVT_EXIT)
 438     return format (s, "exit");
 439   else
 440     return format (s, "unknown timing event");
 441 }
 442
 443 static void
 444 init_error_string_table (echo_main_t * em)
 445 {
 446   em->error_string_by_error_number = hash_create (0, sizeof (uword));
 447
 448 #define _(n,v,s) hash_set (em->error_string_by_error_number, -v, s);
 449   foreach_vnet_api_error;
 450 #undef _
 451
 452   hash_set (em->error_string_by_error_number, 99, "Misc");
 453 }
 454
 455 /*
 456  *
 457  *  End of format functions
 458  *
 459  */
 460
 461 /*
 462  *
 463  *  Session API Calls
 464  *
 465  */
 466
 467 void
 468 application_send_attach (echo_main_t * em)
 469 {
 470   vl_api_application_attach_t *bmp;
 471   vl_api_application_tls_cert_add_t *cert_mp;
 472   vl_api_application_tls_key_add_t *key_mp;
 473
 474   bmp = vl_msg_api_alloc (sizeof (*bmp));
 475   clib_memset (bmp, 0, sizeof (*bmp));
 476
 477   bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_ATTACH);
 478   bmp->client_index = em->my_client_index;
 479   bmp->context = ntohl (0xfeedface);
 480   bmp->options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_ACCEPT_REDIRECT;
 481   bmp->options[APP_OPTIONS_FLAGS] |= APP_OPTIONS_FLAGS_ADD_SEGMENT;
 482   bmp->options[APP_OPTIONS_PREALLOC_FIFO_PAIRS] = 16;
 483   bmp->options[APP_OPTIONS_RX_FIFO_SIZE] = em->fifo_size;
 484   bmp->options[APP_OPTIONS_TX_FIFO_SIZE] = em->fifo_size;
 485   bmp->options[APP_OPTIONS_ADD_SEGMENT_SIZE] = 128 << 20;
 486   bmp->options[APP_OPTIONS_SEGMENT_SIZE] = 256 << 20;
 487   bmp->options[APP_OPTIONS_EVT_QUEUE_SIZE] = 256;
 488   if (em->appns_id)
 489     {
 490       bmp->namespace_id_len = vec_len (em->appns_id);
 491       clib_memcpy_fast (bmp->namespace_id, em->appns_id,
 492                         bmp->namespace_id_len);
 493       bmp->options[APP_OPTIONS_FLAGS] |= em->appns_flags;
 494       bmp->options[APP_OPTIONS_NAMESPACE_SECRET] = em->appns_secret;
 495     }
 496   vl_msg_api_send_shmem (em->vl_input_queue, (u8 *) & bmp);
 497
 498   cert_mp = vl_msg_api_alloc (sizeof (*cert_mp) + test_srv_crt_rsa_len);
 499   clib_memset (cert_mp, 0, sizeof (*cert_mp));
 500   cert_mp->_vl_msg_id = ntohs (VL_API_APPLICATION_TLS_CERT_ADD);
 501   cert_mp->client_index = em->my_client_index;
 502   cert_mp->context = ntohl (0xfeedface);
 503   cert_mp->cert_len = clib_host_to_net_u16 (test_srv_crt_rsa_len);
 504   clib_memcpy_fast (cert_mp->cert, test_srv_crt_rsa, test_srv_crt_rsa_len);
 505   vl_msg_api_send_shmem (em->vl_input_queue, (u8 *) & cert_mp);
 506
 507   key_mp = vl_msg_api_alloc (sizeof (*key_mp) + test_srv_key_rsa_len);
 508   clib_memset (key_mp, 0, sizeof (*key_mp) + test_srv_key_rsa_len);
 509   key_mp->_vl_msg_id = ntohs (VL_API_APPLICATION_TLS_KEY_ADD);
 510   key_mp->client_index = em->my_client_index;
 511   key_mp->context = ntohl (0xfeedface);
 512   key_mp->key_len = clib_host_to_net_u16 (test_srv_key_rsa_len);
 513   clib_memcpy_fast (key_mp->key, test_srv_key_rsa, test_srv_key_rsa_len);
 514   vl_msg_api_send_shmem (em->vl_input_queue, (u8 *) & key_mp);
 515 }
 516
 517 void
 518 application_detach (echo_main_t * em)
 519 {
 520   vl_api_application_detach_t *bmp;
 521   bmp = vl_msg_api_alloc (sizeof (*bmp));
 522   clib_memset (bmp, 0, sizeof (*bmp));
 523
 524   bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_DETACH);
 525   bmp->client_index = em->my_client_index;
 526   bmp->context = ntohl (0xfeedface);
 527   vl_msg_api_send_shmem (em->vl_input_queue, (u8 *) & bmp);
 528 }
 529
 530 static void
 531 server_send_listen (echo_main_t * em)
 532 {
 533   vl_api_bind_uri_t *bmp;
 534   bmp = vl_msg_api_alloc (sizeof (*bmp));
 535   clib_memset (bmp, 0, sizeof (*bmp));
 536
 537   bmp->_vl_msg_id = ntohs (VL_API_BIND_URI);
 538   bmp->client_index = em->my_client_index;
 539   bmp->context = ntohl (0xfeedface);
 540   memcpy (bmp->uri, em->uri, vec_len (em->uri));
 541   vl_msg_api_send_shmem (em->vl_input_queue, (u8 *) & bmp);
 542 }
 543
 544 static void
 545 server_send_unbind (echo_main_t * em)
 546 {
 547   vl_api_unbind_uri_t *ump;
 548
 549   ump = vl_msg_api_alloc (sizeof (*ump));
 550   clib_memset (ump, 0, sizeof (*ump));
 551
 552   ump->_vl_msg_id = ntohs (VL_API_UNBIND_URI);
 553   ump->client_index = em->my_client_index;
 554   memcpy (ump->uri, em->uri, vec_len (em->uri));
 555   vl_msg_api_send_shmem (em->vl_input_queue, (u8 *) & ump);
 556 }
 557
 558 static void
 559 echo_send_connect (echo_main_t * em, u8 * uri, u32 opaque)
 560 {
 561   vl_api_connect_uri_t *cmp;
 562   cmp = vl_msg_api_alloc (sizeof (*cmp));
 563   clib_memset (cmp, 0, sizeof (*cmp));
 564
 565   cmp->_vl_msg_id = ntohs (VL_API_CONNECT_URI);
 566   cmp->client_index = em->my_client_index;
 567   cmp->context = ntohl (opaque);
 568   memcpy (cmp->uri, uri, vec_len (uri));
 569   vl_msg_api_send_shmem (em->vl_input_queue, (u8 *) & cmp);
 570 }
 571
 572 static void
 573 echo_disconnect_session (echo_main_t * em, echo_session_t * s)
 574 {
 575   vl_api_disconnect_session_t *dmp;
 576   dmp = vl_msg_api_alloc (sizeof (*dmp));
 577   clib_memset (dmp, 0, sizeof (*dmp));
 578   dmp->_vl_msg_id = ntohs (VL_API_DISCONNECT_SESSION);
 579   dmp->client_index = em->my_client_index;
 580   dmp->handle = s->vpp_session_handle;
 581   DBG ("Disconnect session 0x%lx", dmp->handle);
 582   vl_msg_api_send_shmem (em->vl_input_queue, (u8 *) & dmp);
 583 }
 584
 585 /*
 586  *
 587  *  End Session API Calls
 588  *
 589  */
 590
 591 static int
 592 wait_for_segment_allocation (u64 segment_handle)
 593 {
 594   echo_main_t *em = &echo_main;
 595   f64 timeout;
 596   timeout = clib_time_now (&em->clib_time) + TIMEOUT;
 597   uword *segment_present;
 598   DBG ("Waiting for segment 0x%lx...", segment_handle);
 599   while (clib_time_now (&em->clib_time) < timeout)
 600     {
 601       clib_spinlock_lock (&em->segment_handles_lock);
 602       segment_present = hash_get (em->shared_segment_handles, segment_handle);
 603       clib_spinlock_unlock (&em->segment_handles_lock);
 604       if (segment_present != 0)
 605         return 0;
 606       if (em->time_to_stop == 1)
 607         return 0;
 608     }
 609   DBG ("timeout wait_for_segment_allocation (0x%lx)", segment_handle);
 610   return -1;
 611 }
 612
 613 static void
 614 quic_echo_notify_event (echo_main_t * em, echo_test_evt_t e)
 615 {
 616   if (em->timing_start_event == e)
 617     em->start_time = clib_time_now (&em->clib_time);
 618   else if (em->timing_end_event == e)
 619     em->end_time = clib_time_now (&em->clib_time);
 620 }
 621
 622 static void
 623 echo_assert_test_suceeded (echo_main_t * em)
 624 {
 625   CHECK (em->rx_total,
 626          em->n_stream_clients * em->n_clients * em->bytes_to_receive,
 627          "Not enough data received");
 628   CHECK (em->tx_total,
 629          em->n_stream_clients * em->n_clients * em->bytes_to_send,
 630          "Not enough data sent");
 631   CHECK (0, hash_elts (em->session_index_by_vpp_handles),
 632          "Some sessions are still open");
 633 }
 634
 635 always_inline void
 636 echo_session_dequeue_notify (echo_session_t * s)
 637 {
 638   int rv;
 639   rv = app_send_io_evt_to_vpp (s->vpp_evt_q, s->rx_fifo->master_session_index,
 640                                SESSION_IO_EVT_RX, SVM_Q_WAIT);
 641   svm_fifo_clear_deq_ntf (s->rx_fifo);
 642   if (rv)
 643     ECHO_FAIL ("app_send_io_evt_to_vpp errored %d", rv);
 644 }
 645
 646 static int
 647 ssvm_segment_attach (char *name, ssvm_segment_type_t type, int fd)
 648 {
 649   fifo_segment_create_args_t _a, *a = &_a;
 650   fifo_segment_main_t *sm = &echo_main.segment_main;
 651   int rv;
 652
 653   clib_memset (a, 0, sizeof (*a));
 654   a->segment_name = (char *) name;
 655   a->segment_type = type;
 656
 657   if (type == SSVM_SEGMENT_MEMFD)
 658     a->memfd_fd = fd;
 659
 660   if ((rv = fifo_segment_attach (sm, a)))
 661     return rv;
 662   vec_reset_length (a->new_segment_indices);
 663   return 0;
 664 }
 665
 666 static void
 667 stop_signal (int signum)
 668 {
 669   echo_main_t *um = &echo_main;
 670   um->time_to_stop = 1;
 671 }
 672
 673 static clib_error_t *
 674 setup_signal_handlers (void)
 675 {
 676   signal (SIGINT, stop_signal);
 677   signal (SIGQUIT, stop_signal);
 678   signal (SIGTERM, stop_signal);
 679   return 0;
 680 }
 681
 682 int
 683 connect_to_vpp (char *name)
 684 {
 685   echo_main_t *em = &echo_main;
 686   api_main_t *am = &api_main;
 687
 688   if (em->use_sock_api)
 689     {
 690       if (vl_socket_client_connect ((char *) em->socket_name, name,
 691                                     0 /* default rx, tx buffer */ ))
 692         {
 693           clib_warning ("socket connect failed");
 694           return -1;
 695         }
 696
 697       if (vl_socket_client_init_shm (0, 1 /* want_pthread */ ))
 698         {
 699           clib_warning ("init shm api failed");
 700           return -1;
 701         }
 702     }
 703   else
 704     {
 705       if (vl_client_connect_to_vlib ("/vpe-api", name, 32) < 0)
 706         {
 707           clib_warning ("shmem connect failed");
 708           return -1;
 709         }
 710     }
 711   em->vl_input_queue = am->shmem_hdr->vl_input_queue;
 712   em->my_client_index = am->my_client_index;
 713   return 0;
 714 }
 715
 716 static void
 717 session_print_stats (echo_main_t * em, echo_session_t * session)
 718 {
 719   f64 deltat = clib_time_now (&em->clib_time) - session->start;
 720   fformat (stdout, "Session 0x%x done in %.6fs RX[%.4f] TX[%.4f] Gbit/s\n",
 721            session->vpp_session_handle, deltat,
 722            (session->bytes_received * 8.0) / deltat / 1e9,
 723            (session->bytes_sent * 8.0) / deltat / 1e9);
 724 }
 725
 726 static void
 727 print_global_stats (echo_main_t * em)
 728 {
 729   f64 deltat = em->end_time - em->start_time;
 730   u8 *s = format (0, "%U:%U",
 731                   echo_format_timing_event, em->timing_start_event,
 732                   echo_format_timing_event, em->timing_end_event);
 733   fformat (stdout, "Timinig %s\n", s);
 734   fformat (stdout, "-------- TX --------\n");
 735   fformat (stdout, "%lld bytes (%lld mbytes, %lld gbytes) in %.2f seconds\n",
 736            em->tx_total, em->tx_total / (1ULL << 20),
 737            em->tx_total / (1ULL << 30), deltat);
 738   fformat (stdout, "%.4f Gbit/second\n", (em->tx_total * 8.0) / deltat / 1e9);
 739   fformat (stdout, "-------- RX --------\n");
 740   fformat (stdout, "%lld bytes (%lld mbytes, %lld gbytes) in %.2f seconds\n",
 741            em->rx_total, em->rx_total / (1ULL << 20),
 742            em->rx_total / (1ULL << 30), deltat);
 743   fformat (stdout, "%.4f Gbit/second\n", (em->rx_total * 8.0) / deltat / 1e9);
 744   fformat (stdout, "--------------------\n");
 745 }
 746
 747 static void
 748 echo_free_sessions (echo_main_t * em)
 749 {
 750   /* Free marked sessions */
 751   echo_session_t *s;
 752   u32 *session_indexes = 0, *session_index;
 753
 754   /* *INDENT-OFF* */
 755   pool_foreach (s, em->sessions,
 756   ({
 757     if (s->flags & SESSION_FLAG_SHOULD_FREE)
 758       vec_add1 (session_indexes, s->session_index);}
 759   ));
 760   /* *INDENT-ON* */
 761   vec_foreach (session_index, session_indexes)
 762   {
 763     /* Free session */
 764     s = pool_elt_at_index (em->sessions, *session_index);
 765     DBG ("Freeing session 0x%lx", s->vpp_session_handle);
 766     pool_put (em->sessions, s);
 767     clib_memset (s, 0xfe, sizeof (*s));
 768   }
 769 }
 770
 771 static void
 772 echo_cleanup_session (echo_main_t * em, echo_session_t * s)
 773 {
 774   echo_session_t *ls;
 775   u64 accepted_session_count;
 776   if (s->listener_index != SESSION_INVALID_INDEX)
 777     {
 778       ls = pool_elt_at_index (em->sessions, s->listener_index);
 779       accepted_session_count =
 780         clib_atomic_sub_fetch (&ls->accepted_session_count, 1);
 781       if (accepted_session_count == 0
 782           && ls->session_type != QUIC_SESSION_TYPE_LISTEN
 783           && em->send_disconnects)
 784         echo_disconnect_session (em, ls);
 785     }
 786   if (s->session_type == QUIC_SESSION_TYPE_QUIC)
 787     clib_atomic_sub_fetch (&em->n_quic_clients_connected, 1);
 788   else if (s->session_type == QUIC_SESSION_TYPE_STREAM)
 789     clib_atomic_sub_fetch (&em->n_clients_connected, 1);
 790
 791   DBG ("Cleanup sessions (still %uQ %uS)", em->n_quic_clients_connected,
 792        em->n_clients_connected);
 793   hash_unset (em->session_index_by_vpp_handles, s->vpp_session_handle);
 794
 795   /* Mark session as to be freed */
 796   s->flags |= SESSION_FLAG_SHOULD_FREE;
 797 }
 798
 799 static void
 800 test_recv_bytes (echo_main_t * em, echo_session_t * s, u8 * rx_buf,
 801                  u32 n_read)
 802 {
 803   u32 i;
 804   u8 expected;
 805   for (i = 0; i < n_read; i++)
 806     {
 807       expected = (s->bytes_received + i) & 0xff;
 808       if (rx_buf[i] == expected || em->max_test_msg > 0)
 809         continue;
 810       clib_warning ("Session 0x%lx byte %lld was 0x%x expected 0x%x",
 811                     s->vpp_session_handle, s->bytes_received + i, rx_buf[i],
 812                     expected);
 813       em->max_test_msg--;
 814       if (em->max_test_msg == 0)
 815         clib_warning ("Too many errors, hiding next ones");
 816       if (em->test_return_packets == RETURN_PACKETS_ASSERT)
 817         ECHO_FAIL ("test-bytes errored");
 818     }
 819 }
 820
 821 static int
 822 recv_data_chunk (echo_main_t * em, echo_session_t * s, u8 * rx_buf)
 823 {
 824   int n_read;
 825   n_read = app_recv_stream ((app_session_t *) s, rx_buf, vec_len (rx_buf));
 826   if (n_read <= 0)
 827     return 0;
 828   if (svm_fifo_needs_deq_ntf (s->rx_fifo, n_read))
 829     echo_session_dequeue_notify (s);
 830
 831   if (em->test_return_packets)
 832     test_recv_bytes (em, s, rx_buf, n_read);
 833
 834   ASSERT (s->bytes_to_receive >= n_read);
 835   s->bytes_received += n_read;
 836   s->bytes_to_receive -= n_read;
 837   return n_read;
 838 }
 839
 840 static int
 841 send_data_chunk (echo_session_t * s, u8 * tx_buf, int offset, int len)
 842 {
 843   int n_sent;
 844   int bytes_this_chunk = clib_min (s->bytes_to_send, len - offset);
 845   if (!bytes_this_chunk)
 846     return 0;
 847   n_sent = app_send_stream ((app_session_t *) s, tx_buf + offset,
 848                             bytes_this_chunk, 0);
 849   if (n_sent < 0)
 850     return 0;
 851   s->bytes_to_send -= n_sent;
 852   s->bytes_sent += n_sent;
 853   return n_sent;
 854 }
 855
 856 static int
 857 mirror_data_chunk (echo_main_t * em, echo_session_t * s, u8 * tx_buf, u64 len)
 858 {
 859   u64 n_sent = 0;
 860   while (n_sent < len && !em->time_to_stop)
 861     n_sent += send_data_chunk (s, tx_buf, n_sent, len);
 862   return n_sent;
 863 }
 864
 865 /*
 866  * Rx/Tx polling thread per connection
 867  */
 868 static void *
 869 echo_thread_fn (void *arg)
 870 {
 871   echo_main_t *em = &echo_main;
 872   u8 *rx_buf = 0;
 873   u32 session_index = *(u32 *) arg;
 874   echo_session_t *s;
 875   int n_read, n_sent, idle_loop = 0;
 876   vec_validate (rx_buf, em->rx_buf_size);
 877
 878   while (!em->time_to_stop && em->state != STATE_READY)
 879     ;
 880
 881   s = pool_elt_at_index (em->sessions, session_index);
 882   while (!em->time_to_stop)
 883     {
 884       n_read = recv_data_chunk (em, s, rx_buf);
 885       if (em->data_source == ECHO_TEST_DATA_SOURCE)
 886         n_sent =
 887           send_data_chunk (s, em->connect_test_data,
 888                            s->bytes_sent % em->tx_buf_size, em->tx_buf_size);
 889       else if (em->data_source == ECHO_RX_DATA_SOURCE)
 890         n_sent = mirror_data_chunk (em, s, rx_buf, n_read);
 891       else
 892         n_sent = 0;
 893       if (!s->bytes_to_send && !s->bytes_to_receive)
 894         break;
 895       if (s->flags & SESSION_FLAG_SHOULD_CLOSE)
 896         break;
 897
 898       /* check idle clients */
 899       if (!n_sent & !n_read)
 900         idle_loop++;
 901       else
 902         idle_loop = 0;
 903       if (idle_loop == 1e7)
 904         {
 905           DBG ("Idle client TX:%dB RX:%dB", s->bytes_to_send,
 906                s->bytes_to_receive);
 907           DBG ("Idle FIFOs  TX:%dB RX:%dB", svm_fifo_max_dequeue (s->tx_fifo),
 908                svm_fifo_max_dequeue (s->rx_fifo));
 909         }
 910     }
 911   DBG ("[%lu/%lu] -> S(%x) -> [%lu/%lu]",
 912        s->bytes_received, s->bytes_received + s->bytes_to_receive,
 913        session_index, s->bytes_sent, s->bytes_sent + s->bytes_to_send);
 914   em->tx_total += s->bytes_sent;
 915   em->rx_total += s->bytes_received;
 916   clib_warning ("%d/%d", em->rx_total,
 917                 em->n_clients * em->n_stream_clients * em->bytes_to_receive);
 918   if (em->rx_total ==
 919       em->n_clients * em->n_stream_clients * em->bytes_to_receive)
 920     quic_echo_notify_event (em, ECHO_EVT_LAST_BYTE);
 921   if (em->send_disconnects)
 922     echo_disconnect_session (em, s);
 923   else
 924     {
 925       while (!(s->flags & SESSION_FLAG_SHOULD_CLOSE) & !em->time_to_stop)
 926         ;
 927       echo_cleanup_session (em, s);
 928     }
 929   pthread_exit (0);
 930 }
 931
 932 static void
 933 session_bound_handler (session_bound_msg_t * mp)
 934 {
 935   echo_main_t *em = &echo_main;
 936   echo_session_t *listen_session;
 937   u32 session_index;
 938
 939   if (mp->retval)
 940     {
 941       ECHO_FAIL ("bind failed: %U", format_api_error,
 942                  clib_net_to_host_u32 (mp->retval));
 943       return;
 944     }
 945
 946   clib_warning ("listening on %U:%u", format_ip46_address, mp->lcl_ip,
 947                 mp->lcl_is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
 948                 clib_net_to_host_u16 (mp->lcl_port));
 949
 950   /* Allocate local session and set it up */
 951   pool_get (em->sessions, listen_session);
 952   listen_session->session_type = QUIC_SESSION_TYPE_LISTEN;
 953   listen_session->accepted_session_count = 0;
 954   session_index = listen_session - em->sessions;
 955   listen_session->session_index = session_index;
 956   hash_set (em->session_index_by_vpp_handles, mp->handle, session_index);
 957   em->state = STATE_LISTEN;
 958   em->listen_session_index = session_index;
 959 }
 960
 961 static void
 962 session_accepted_handler (session_accepted_msg_t * mp)
 963 {
 964   app_session_evt_t _app_evt, *app_evt = &_app_evt;
 965   session_accepted_reply_msg_t *rmp;
 966   svm_fifo_t *rx_fifo, *tx_fifo;
 967   echo_main_t *em = &echo_main;
 968   echo_session_t *session, *listen_session;
 969   u32 session_index;
 970   uword *p;
 971   /* Allocate local session and set it up */
 972   pool_get (em->sessions, session);
 973   session_index = session - em->sessions;
 974
 975   if (wait_for_segment_allocation (mp->segment_handle))
 976     {
 977       ECHO_FAIL ("wait_for_segment_allocation errored");
 978       return;
 979     }
 980
 981   rx_fifo = uword_to_pointer (mp->server_rx_fifo, svm_fifo_t *);
 982   rx_fifo->client_session_index = session_index;
 983   tx_fifo = uword_to_pointer (mp->server_tx_fifo, svm_fifo_t *);
 984   tx_fifo->client_session_index = session_index;
 985
 986   session->rx_fifo = rx_fifo;
 987   session->tx_fifo = tx_fifo;
 988   session->session_index = session_index;
 989   session->vpp_session_handle = mp->handle;
 990   session->start = clib_time_now (&em->clib_time);
 991   session->vpp_evt_q = uword_to_pointer (mp->vpp_event_queue_address,
 992                                          svm_msg_q_t *);
 993
 994   session->accepted_session_count = 0;
 995   p = hash_get (em->session_index_by_vpp_handles, mp->listener_handle);
 996   if (!p)
 997     {
 998       ECHO_FAIL ("unknown handle 0x%lx", mp->listener_handle);
 999       return;
1000     }
1001   session->listener_index = p[0];
1002   listen_session = pool_elt_at_index (em->sessions, p[0]);
1003   clib_atomic_fetch_add (&listen_session->accepted_session_count, 1);
1004
1005   /* Add it to lookup table */
1006   DBG ("Accepted session 0x%lx, Listener 0x%lx idx %lu", mp->handle,
1007        mp->listener_handle, session_index);
1008   hash_set (em->session_index_by_vpp_handles, mp->handle, session_index);
1009
1010   app_alloc_ctrl_evt_to_vpp (session->vpp_evt_q, app_evt,
1011                              SESSION_CTRL_EVT_ACCEPTED_REPLY);
1012   rmp = (session_accepted_reply_msg_t *) app_evt->evt->data;
1013   rmp->handle = mp->handle;
1014   rmp->context = mp->context;
1015   app_send_ctrl_evt_to_vpp (session->vpp_evt_q, app_evt);
1016
1017   if (listen_session->session_type == QUIC_SESSION_TYPE_LISTEN)
1018     {
1019       session->session_type = QUIC_SESSION_TYPE_QUIC;
1020       if (em->cb_vft.quic_accepted_cb)
1021         em->cb_vft.quic_accepted_cb (mp, session_index);
1022       clib_atomic_fetch_add (&em->n_quic_clients_connected, 1);
1023     }
1024   else if (em->i_am_master)
1025     {
1026       session->session_type = QUIC_SESSION_TYPE_STREAM;
1027       if (em->cb_vft.server_stream_accepted_cb)
1028         em->cb_vft.server_stream_accepted_cb (mp, session_index);
1029       clib_atomic_fetch_add (&em->n_clients_connected, 1);
1030     }
1031   else
1032     {
1033       session->session_type = QUIC_SESSION_TYPE_STREAM;
1034       if (em->cb_vft.client_stream_accepted_cb)
1035         em->cb_vft.client_stream_accepted_cb (mp, session_index);
1036       clib_atomic_fetch_add (&em->n_clients_connected, 1);
1037     }
1038
1039   if (em->n_clients_connected == em->n_clients * em->n_stream_clients)
1040     {
1041       em->state = STATE_READY;
1042       quic_echo_notify_event (em, ECHO_EVT_LAST_SCONNECTED);
1043     }
1044   if (em->n_quic_clients_connected == em->n_clients)
1045     quic_echo_notify_event (em, ECHO_EVT_LAST_QCONNECTED);
1046 }
1047
1048 static void
1049 session_connected_handler (session_connected_msg_t * mp)
1050 {
1051   echo_main_t *em = &echo_main;
1052   echo_session_t *session, *listen_session;
1053   u32 session_index;
1054   u32 listener_index = htonl (mp->context);
1055   svm_fifo_t *rx_fifo, *tx_fifo;
1056
1057   if (mp->retval)
1058     {
1059       ECHO_FAIL ("connection failed with code: %U", format_api_error,
1060                  clib_net_to_host_u32 (mp->retval));
1061       return;
1062     }
1063
1064   pool_get (em->sessions, session);
1065   clib_memset (session, 0, sizeof (*session));
1066   session_index = session - em->sessions;
1067
1068   if (wait_for_segment_allocation (mp->segment_handle))
1069     {
1070       ECHO_FAIL ("wait_for_segment_allocation errored");
1071       return;
1072     }
1073
1074   rx_fifo = uword_to_pointer (mp->server_rx_fifo, svm_fifo_t *);
1075   rx_fifo->client_session_index = session_index;
1076   tx_fifo = uword_to_pointer (mp->server_tx_fifo, svm_fifo_t *);
1077   tx_fifo->client_session_index = session_index;
1078
1079   session->rx_fifo = rx_fifo;
1080   session->tx_fifo = tx_fifo;
1081   session->vpp_session_handle = mp->handle;
1082   session->session_index = session_index;
1083   session->start = clib_time_now (&em->clib_time);
1084   session->vpp_evt_q = uword_to_pointer (mp->vpp_event_queue_address,
1085                                          svm_msg_q_t *);
1086
1087   session->listener_index = listener_index;
1088   session->accepted_session_count = 0;
1089   if (listener_index != SESSION_INVALID_INDEX)
1090     {
1091       listen_session = pool_elt_at_index (em->sessions, listener_index);
1092       clib_atomic_fetch_add (&listen_session->accepted_session_count, 1);
1093     }
1094
1095   DBG ("Connected session 0x%lx", mp->handle, session_index);
1096   hash_set (em->session_index_by_vpp_handles, mp->handle, session_index);
1097
1098   if (listener_index == SESSION_INVALID_INDEX)
1099     {
1100       session->session_type = QUIC_SESSION_TYPE_QUIC;
1101       if (em->cb_vft.quic_connected_cb)
1102         em->cb_vft.quic_connected_cb (mp, session_index);
1103       clib_atomic_fetch_add (&em->n_quic_clients_connected, 1);
1104     }
1105   else if (em->i_am_master)
1106     {
1107       session->session_type = QUIC_SESSION_TYPE_STREAM;
1108       if (em->cb_vft.server_stream_connected_cb)
1109         em->cb_vft.server_stream_connected_cb (mp, session_index);
1110       clib_atomic_fetch_add (&em->n_clients_connected, 1);
1111     }
1112   else
1113     {
1114       session->session_type = QUIC_SESSION_TYPE_STREAM;
1115       if (em->cb_vft.client_stream_connected_cb)
1116         em->cb_vft.client_stream_connected_cb (mp, session_index);
1117       clib_atomic_fetch_add (&em->n_clients_connected, 1);
1118     }
1119
1120   if (em->n_clients_connected == em->n_clients * em->n_stream_clients)
1121     {
1122       em->state = STATE_READY;
1123       quic_echo_notify_event (em, ECHO_EVT_LAST_SCONNECTED);
1124     }
1125   if (em->n_quic_clients_connected == em->n_clients)
1126     quic_echo_notify_event (em, ECHO_EVT_LAST_QCONNECTED);
1127 }
1128
1129 /*
1130  *
1131  *  ECHO Callback definitions
1132  *
1133  */
1134
1135
1136 static void
1137 echo_on_connected_connect (session_connected_msg_t * mp, u32 session_index)
1138 {
1139   echo_main_t *em = &echo_main;
1140   u8 *uri = format (0, "QUIC://session/%lu", mp->handle);
1141   u64 i;
1142
1143   if (!em->first_sconnect_sent)
1144     {
1145       em->first_sconnect_sent = 1;
1146       quic_echo_notify_event (em, ECHO_EVT_FIRST_SCONNECT);
1147     }
1148   for (i = 0; i < em->n_stream_clients; i++)
1149     echo_send_connect (em, uri, session_index);
1150
1151   clib_warning ("Qsession 0x%llx connected to %U:%d",
1152                 mp->handle, format_ip46_address, &mp->lcl.ip,
1153                 mp->lcl.is_ip4, clib_net_to_host_u16 (mp->lcl.port));
1154 }
1155
1156 static void
1157 echo_on_connected_send (session_connected_msg_t * mp, u32 session_index)
1158 {
1159   echo_main_t *em = &echo_main;
1160   int rv;
1161   echo_session_t *session;
1162
1163   session = pool_elt_at_index (em->sessions, session_index);
1164   session->bytes_to_send = em->bytes_to_send;
1165   session->bytes_to_receive = em->bytes_to_receive;
1166
1167   DBG ("Stream session 0x%lx connected", session->vpp_session_handle);
1168
1169   /*
1170    * Start RX thread
1171    */
1172   em->thread_args[em->n_clients_connected] = session_index;
1173   rv = pthread_create (&em->client_thread_handles[em->n_clients_connected],
1174                        NULL /*attr */ , echo_thread_fn,
1175                        (void *) &em->thread_args[em->n_clients_connected]);
1176   if (rv)
1177     {
1178       ECHO_FAIL ("pthread_create returned %d", rv);
1179       return;
1180     }
1181 }
1182
1183 static void
1184 echo_on_connected_error (session_connected_msg_t * mp, u32 session_index)
1185 {
1186   ECHO_FAIL ("Got a wrong connected on session %u [%lx]", session_index,
1187              mp->handle);
1188 }
1189
1190 static void
1191 echo_on_accept_recv (session_accepted_msg_t * mp, u32 session_index)
1192 {
1193   echo_main_t *em = &echo_main;
1194   int rv;
1195   echo_session_t *session;
1196
1197   session = pool_elt_at_index (em->sessions, session_index);
1198   session->bytes_to_send = em->bytes_to_send;
1199   session->bytes_to_receive = em->bytes_to_receive;
1200
1201   DBG ("Stream session 0x%lx accepted", mp->handle);
1202
1203   /*
1204    * Start RX thread
1205    */
1206   em->thread_args[em->n_clients_connected] = session_index;
1207   rv = pthread_create (&em->client_thread_handles[em->n_clients_connected],
1208                        NULL /*attr */ , echo_thread_fn,
1209                        (void *) &em->thread_args[em->n_clients_connected]);
1210   if (rv)
1211     {
1212       ECHO_FAIL ("pthread_create returned %d", rv);
1213       return;
1214     }
1215 }
1216
1217 static void
1218 echo_on_accept_connect (session_accepted_msg_t * mp, u32 session_index)
1219 {
1220   echo_main_t *em = &echo_main;
1221   DBG ("Accept on QSession 0x%lx %u", mp->handle);
1222   u8 *uri = format (0, "QUIC://session/%lu", mp->handle);
1223   u32 i;
1224
1225   if (!em->first_sconnect_sent)
1226     {
1227       em->first_sconnect_sent = 1;
1228       quic_echo_notify_event (em, ECHO_EVT_FIRST_SCONNECT);
1229     }
1230   for (i = 0; i < em->n_stream_clients; i++)
1231     echo_send_connect (em, uri, session_index);
1232 }
1233
1234 static void
1235 echo_on_accept_error (session_accepted_msg_t * mp, u32 session_index)
1236 {
1237   ECHO_FAIL ("Got a wrong accept on session %u [%lx]", session_index,
1238              mp->handle);
1239 }
1240
1241 static void
1242 echo_on_accept_log_ip (session_accepted_msg_t * mp, u32 session_index)
1243 {
1244   u8 *ip_str;
1245   ip_str = format (0, "%U", format_ip46_address, &mp->rmt.ip, mp->rmt.is_ip4);
1246   clib_warning ("Accepted session from: %s:%d", ip_str,
1247                 clib_net_to_host_u16 (mp->rmt.port));
1248
1249 }
1250
1251 static const quic_echo_cb_vft_t default_cb_vft = {
1252   /* Qsessions */
1253   .quic_accepted_cb = echo_on_accept_log_ip,
1254   .quic_connected_cb = echo_on_connected_connect,
1255   /* client initiated streams */
1256   .server_stream_accepted_cb = echo_on_accept_recv,
1257   .client_stream_connected_cb = echo_on_connected_send,
1258   /* server initiated streams */
1259   .client_stream_accepted_cb = echo_on_accept_error,
1260   .server_stream_connected_cb = echo_on_connected_error,
1261 };
1262
1263 static const quic_echo_cb_vft_t server_stream_cb_vft = {
1264   /* Qsessions */
1265   .quic_accepted_cb = echo_on_accept_connect,
1266   .quic_connected_cb = NULL,
1267   /* client initiated streams */
1268   .server_stream_accepted_cb = echo_on_accept_error,
1269   .client_stream_connected_cb = echo_on_connected_error,
1270   /* server initiated streams */
1271   .client_stream_accepted_cb = echo_on_accept_recv,
1272   .server_stream_connected_cb = echo_on_connected_send,
1273 };
1274
1275 static uword
1276 echo_unformat_quic_setup_vft (unformat_input_t * input, va_list * args)
1277 {
1278   echo_main_t *em = &echo_main;
1279   if (unformat (input, "serverstream"))
1280     em->cb_vft = server_stream_cb_vft;
1281   else if (unformat (input, "default"))
1282     ;
1283   else
1284     return 0;
1285   return 1;
1286 }
1287
1288 /*
1289  *
1290  *  End of ECHO callback definitions
1291  *
1292  */
1293
1294 static void
1295 session_disconnected_handler (session_disconnected_msg_t * mp)
1296 {
1297   app_session_evt_t _app_evt, *app_evt = &_app_evt;
1298   session_disconnected_reply_msg_t *rmp;
1299   echo_main_t *em = &echo_main;
1300   echo_session_t *s;
1301   uword *p;
1302   int rv = 0;
1303   DBG ("passive close session 0x%lx", mp->handle);
1304   p = hash_get (em->session_index_by_vpp_handles, mp->handle);
1305   if (!p)
1306     {
1307       ECHO_FAIL ("couldn't find session key %llx", mp->handle);
1308       return;
1309     }
1310
1311   s = pool_elt_at_index (em->sessions, p[0]);
1312   if (s->session_type == QUIC_SESSION_TYPE_STREAM)
1313     s->flags |= SESSION_FLAG_SHOULD_CLOSE;      /* tell thread to close session */
1314   else
1315     echo_cleanup_session (em, s);       /* We can clean Qsessions right away */
1316
1317   app_alloc_ctrl_evt_to_vpp (s->vpp_evt_q, app_evt,
1318                              SESSION_CTRL_EVT_DISCONNECTED_REPLY);
1319   rmp = (session_disconnected_reply_msg_t *) app_evt->evt->data;
1320   rmp->retval = rv;
1321   rmp->handle = mp->handle;
1322   rmp->context = mp->context;
1323   app_send_ctrl_evt_to_vpp (s->vpp_evt_q, app_evt);
1324
1325   if (s->session_type == QUIC_SESSION_TYPE_STREAM)
1326     session_print_stats (em, s);
1327 }
1328
1329 static void
1330 session_reset_handler (session_reset_msg_t * mp)
1331 {
1332   app_session_evt_t _app_evt, *app_evt = &_app_evt;
1333   echo_main_t *em = &echo_main;
1334   session_reset_reply_msg_t *rmp;
1335   echo_session_t *session = 0;
1336   uword *p;
1337   int rv = 0;
1338
1339   DBG ("Reset session 0x%lx", mp->handle);
1340   p = hash_get (em->session_index_by_vpp_handles, mp->handle);
1341
1342   if (!p)
1343     {
1344       ECHO_FAIL ("couldn't find session key %llx", mp->handle);
1345       return;
1346     }
1347
1348   session = pool_elt_at_index (em->sessions, p[0]);
1349   /* Cleanup later */
1350   em->time_to_stop = 1;
1351   app_alloc_ctrl_evt_to_vpp (session->vpp_evt_q, app_evt,
1352                              SESSION_CTRL_EVT_RESET_REPLY);
1353   rmp = (session_reset_reply_msg_t *) app_evt->evt->data;
1354   rmp->retval = rv;
1355   rmp->handle = mp->handle;
1356   app_send_ctrl_evt_to_vpp (session->vpp_evt_q, app_evt);
1357 }
1358
1359 static void
1360 handle_mq_event (session_event_t * e)
1361 {
1362   switch (e->event_type)
1363     {
1364     case SESSION_CTRL_EVT_BOUND:
1365       session_bound_handler ((session_bound_msg_t *) e->data);
1366       break;
1367     case SESSION_CTRL_EVT_ACCEPTED:
1368       session_accepted_handler ((session_accepted_msg_t *) e->data);
1369       break;
1370     case SESSION_CTRL_EVT_CONNECTED:
1371       session_connected_handler ((session_connected_msg_t *) e->data);
1372       break;
1373     case SESSION_CTRL_EVT_DISCONNECTED:
1374       session_disconnected_handler ((session_disconnected_msg_t *) e->data);
1375       break;
1376     case SESSION_CTRL_EVT_RESET:
1377       session_reset_handler ((session_reset_msg_t *) e->data);
1378       break;
1379     case SESSION_IO_EVT_RX:
1380       break;
1381     default:
1382       clib_warning ("unhandled event %u", e->event_type);
1383     }
1384 }
1385
1386 static int
1387 wait_for_state_change (echo_main_t * em, connection_state_t state,
1388                        f64 timeout)
1389 {
1390   svm_msg_q_msg_t msg;
1391   session_event_t *e;
1392   f64 end_time = clib_time_now (&em->clib_time) + timeout;
1393
1394   while (!timeout || clib_time_now (&em->clib_time) < end_time)
1395     {
1396       if (em->state == state)
1397         return 0;
1398       if (em->time_to_stop == 1)
1399         return 0;
1400       if (!em->our_event_queue || em->state < STATE_ATTACHED)
1401         continue;
1402
1403       if (svm_msg_q_sub (em->our_event_queue, &msg, SVM_Q_NOWAIT, 0))
1404         continue;
1405       e = svm_msg_q_msg_data (em->our_event_queue, &msg);
1406       handle_mq_event (e);
1407       svm_msg_q_free_msg (em->our_event_queue, &msg);
1408     }
1409   DBG ("timeout waiting for %U", format_quic_echo_state, state);
1410   return -1;
1411 }
1412
1413 static void
1414 echo_event_loop (echo_main_t * em)
1415 {
1416   svm_msg_q_msg_t msg;
1417   session_event_t *e;
1418
1419   DBG ("Waiting for data on %u clients", em->n_clients_connected);
1420   while (em->n_clients_connected | em->n_quic_clients_connected)
1421     {
1422       int rc = svm_msg_q_sub (em->our_event_queue, &msg, SVM_Q_TIMEDWAIT, 1);
1423       if (PREDICT_FALSE (rc == ETIMEDOUT && em->time_to_stop))
1424         break;
1425       if (rc == ETIMEDOUT)
1426         continue;
1427       e = svm_msg_q_msg_data (em->our_event_queue, &msg);
1428       handle_mq_event (e);
1429       svm_msg_q_free_msg (em->our_event_queue, &msg);
1430     }
1431 }
1432
1433 static void
1434 clients_run (echo_main_t * em)
1435 {
1436   u64 i;
1437   quic_echo_notify_event (em, ECHO_EVT_FIRST_QCONNECT);
1438   for (i = 0; i < em->n_clients; i++)
1439     echo_send_connect (em, em->uri, SESSION_INVALID_INDEX);
1440
1441   if (wait_for_state_change (em, STATE_READY, TIMEOUT))
1442     {
1443       ECHO_FAIL ("Timeout waiting for state ready");
1444       return;
1445     }
1446
1447   echo_event_loop (em);
1448 }
1449
1450 static void
1451 server_run (echo_main_t * em)
1452 {
1453   server_send_listen (em);
1454   if (wait_for_state_change (em, STATE_READY, 0))
1455     {
1456       ECHO_FAIL ("Timeout waiting for state ready");
1457       return;
1458     }
1459   echo_event_loop (em);
1460
1461   /* Cleanup */
1462   server_send_unbind (em);
1463   wait_for_state_change (em, STATE_DISCONNECTED, TIMEOUT);
1464 }
1465
1466 /*
1467  *
1468  *  Session API handlers
1469  *
1470  */
1471
1472
1473 static void
1474 vl_api_application_attach_reply_t_handler (vl_api_application_attach_reply_t *
1475                                            mp)
1476 {
1477   echo_main_t *em = &echo_main;
1478   int *fds = 0;
1479   u32 n_fds = 0;
1480   u64 segment_handle;
1481   segment_handle = clib_net_to_host_u64 (mp->segment_handle);
1482   DBG ("Attached returned app %u", htons (mp->app_index));
1483
1484   if (mp->retval)
1485     {
1486       ECHO_FAIL ("attach failed: %U", format_api_error,
1487                  clib_net_to_host_u32 (mp->retval));
1488       return;
1489     }
1490
1491   if (mp->segment_name_length == 0)
1492     {
1493       ECHO_FAIL ("segment_name_length zero");
1494       return;
1495     }
1496
1497   ASSERT (mp->app_event_queue_address);
1498   em->our_event_queue = uword_to_pointer (mp->app_event_queue_address,
1499                                           svm_msg_q_t *);
1500
1501   if (mp->n_fds)
1502     {
1503       vec_validate (fds, mp->n_fds);
1504       vl_socket_client_recv_fd_msg (fds, mp->n_fds, 5);
1505
1506       if (mp->fd_flags & SESSION_FD_F_VPP_MQ_SEGMENT)
1507         if (ssvm_segment_attach (0, SSVM_SEGMENT_MEMFD, fds[n_fds++]))
1508           {
1509             ECHO_FAIL ("svm_fifo_segment_attach failed");
1510             return;
1511           }
1512
1513       if (mp->fd_flags & SESSION_FD_F_MEMFD_SEGMENT)
1514         if (ssvm_segment_attach ((char *) mp->segment_name,
1515                                  SSVM_SEGMENT_MEMFD, fds[n_fds++]))
1516           {
1517             ECHO_FAIL ("svm_fifo_segment_attach ('%s') failed",
1518                        mp->segment_name);
1519             return;
1520           }
1521       if (mp->fd_flags & SESSION_FD_F_MQ_EVENTFD)
1522         svm_msg_q_set_consumer_eventfd (em->our_event_queue, fds[n_fds++]);
1523
1524       vec_free (fds);
1525     }
1526   else
1527     {
1528       if (ssvm_segment_attach ((char *) mp->segment_name, SSVM_SEGMENT_SHM,
1529                                -1))
1530         {
1531           ECHO_FAIL ("svm_fifo_segment_attach ('%s') failed",
1532                      mp->segment_name);
1533           return;
1534         }
1535     }
1536   clib_spinlock_lock (&em->segment_handles_lock);
1537   hash_set (em->shared_segment_handles, segment_handle, 1);
1538   clib_spinlock_unlock (&em->segment_handles_lock);
1539   DBG ("Mapped segment 0x%lx", segment_handle);
1540
1541   em->state = STATE_ATTACHED;
1542 }
1543
1544 static void
1545 vl_api_application_detach_reply_t_handler (vl_api_application_detach_reply_t *
1546                                            mp)
1547 {
1548   if (mp->retval)
1549     {
1550       ECHO_FAIL ("detach returned with err: %d", mp->retval);
1551       return;
1552     }
1553   echo_main.state = STATE_DETACHED;
1554 }
1555
1556
1557 static void
1558 vl_api_unmap_segment_t_handler (vl_api_unmap_segment_t * mp)
1559 {
1560   echo_main_t *em = &echo_main;
1561   u64 segment_handle = clib_net_to_host_u64 (mp->segment_handle);
1562
1563   clib_spinlock_lock (&em->segment_handles_lock);
1564   hash_unset (em->shared_segment_handles, segment_handle);
1565   clib_spinlock_unlock (&em->segment_handles_lock);
1566   DBG ("Unmaped segment 0x%lx", segment_handle);
1567 }
1568
1569 static void
1570 vl_api_map_another_segment_t_handler (vl_api_map_another_segment_t * mp)
1571 {
1572   fifo_segment_main_t *sm = &echo_main.segment_main;
1573   fifo_segment_create_args_t _a, *a = &_a;
1574   echo_main_t *em = &echo_main;
1575   int *fds = 0;
1576   char *seg_name = (char *) mp->segment_name;
1577   u64 segment_handle = clib_net_to_host_u64 (mp->segment_handle);
1578
1579   if (mp->fd_flags & SESSION_FD_F_MEMFD_SEGMENT)
1580     {
1581       vec_validate (fds, 1);
1582       vl_socket_client_recv_fd_msg (fds, 1, 5);
1583       if (ssvm_segment_attach (seg_name, SSVM_SEGMENT_MEMFD, fds[0]))
1584         {
1585           ECHO_FAIL ("svm_fifo_segment_attach ('%s')"
1586                      "failed on SSVM_SEGMENT_MEMFD", seg_name);
1587           return;
1588         }
1589       vec_free (fds);
1590     }
1591   else
1592     {
1593       clib_memset (a, 0, sizeof (*a));
1594       a->segment_name = seg_name;
1595       a->segment_size = mp->segment_size;
1596       /* Attach to the segment vpp created */
1597       if (fifo_segment_attach (sm, a))
1598         {
1599           ECHO_FAIL ("svm_fifo_segment_attach ('%s') failed", seg_name);
1600           return;
1601         }
1602     }
1603   clib_spinlock_lock (&em->segment_handles_lock);
1604   hash_set (em->shared_segment_handles, segment_handle, 1);
1605   clib_spinlock_unlock (&em->segment_handles_lock);
1606   DBG ("Mapped segment 0x%lx", segment_handle);
1607 }
1608
1609 static void
1610 vl_api_bind_uri_reply_t_handler (vl_api_bind_uri_reply_t * mp)
1611 {
1612   echo_main_t *em = &echo_main;
1613   if (mp->retval)
1614     {
1615       ECHO_FAIL ("bind failed: %U", format_api_error,
1616                  clib_net_to_host_u32 (mp->retval));
1617       return;
1618     }
1619
1620   em->state = STATE_LISTEN;
1621 }
1622
1623 static void
1624 vl_api_unbind_uri_reply_t_handler (vl_api_unbind_uri_reply_t * mp)
1625 {
1626   echo_session_t *listen_session;
1627   echo_main_t *em = &echo_main;
1628   if (mp->retval != 0)
1629     {
1630       /* ECHO_FAIL ("returned %d", ntohl (mp->retval));
1631          return;  FIXME : UDPC issue */
1632     }
1633   em->state = STATE_DISCONNECTED;
1634   listen_session = pool_elt_at_index (em->sessions, em->listen_session_index);
1635   echo_cleanup_session (em, listen_session);
1636 }
1637
1638 static void
1639 vl_api_disconnect_session_reply_t_handler (vl_api_disconnect_session_reply_t *
1640                                            mp)
1641 {
1642   echo_main_t *em = &echo_main;
1643   echo_session_t *s;
1644   uword *p;
1645
1646   if (mp->retval)
1647     {
1648       ECHO_FAIL ("vpp complained about disconnect: %d", ntohl (mp->retval));
1649       return;
1650     }
1651
1652   DBG ("Got disonnected reply for session 0x%lx", mp->handle);
1653   p = hash_get (em->session_index_by_vpp_handles, mp->handle);
1654   if (!p)
1655     {
1656       ECHO_FAIL ("couldn't find session key %llx", mp->handle);
1657       return;
1658     }
1659
1660   s = pool_elt_at_index (em->sessions, p[0]);
1661   echo_cleanup_session (em, s);
1662 }
1663
1664 static void
1665   vl_api_application_tls_cert_add_reply_t_handler
1666   (vl_api_application_tls_cert_add_reply_t * mp)
1667 {
1668   if (mp->retval)
1669     ECHO_FAIL ("failed to add tls cert");
1670 }
1671
1672 static void
1673   vl_api_application_tls_key_add_reply_t_handler
1674   (vl_api_application_tls_key_add_reply_t * mp)
1675 {
1676   if (mp->retval)
1677     ECHO_FAIL ("failed to add tls key");
1678 }
1679
1680 #define foreach_quic_echo_msg                                           \
1681 _(BIND_URI_REPLY, bind_uri_reply)                                       \
1682 _(UNBIND_URI_REPLY, unbind_uri_reply)                                   \
1683 _(DISCONNECT_SESSION_REPLY, disconnect_session_reply)                   \
1684 _(APPLICATION_ATTACH_REPLY, application_attach_reply)                   \
1685 _(APPLICATION_DETACH_REPLY, application_detach_reply)                   \
1686 _(MAP_ANOTHER_SEGMENT, map_another_segment)                             \
1687 _(UNMAP_SEGMENT, unmap_segment)                                         \
1688 _(APPLICATION_TLS_CERT_ADD_REPLY, application_tls_cert_add_reply)       \
1689 _(APPLICATION_TLS_KEY_ADD_REPLY, application_tls_key_add_reply)         \
1690
1691 void
1692 quic_echo_api_hookup (echo_main_t * em)
1693 {
1694 #define _(N,n)                                                  \
1695     vl_msg_api_set_handlers(VL_API_##N, #n,                     \
1696                            vl_api_##n##_t_handler,              \
1697                            vl_noop_handler,                     \
1698                            vl_api_##n##_t_endian,               \
1699                            vl_api_##n##_t_print,                \
1700                            sizeof(vl_api_##n##_t), 1);
1701   foreach_quic_echo_msg;
1702 #undef _
1703 }
1704
1705 /*
1706  *
1707  *  End Session API handlers
1708  *
1709  */
1710
1711 static void
1712 print_usage_and_exit (void)
1713 {
1714   fprintf (stderr,
1715            "quic_echo [socket-name SOCKET] [client|server] [uri URI] [OPTIONS]\n"
1716            "\n"
1717            "  socket-name PATH    Specify the binary socket path to connect to VPP\n"
1718            "  use-svm-api         Use SVM API to connect to VPP\n"
1719            "  test-bytes[:assert] Check data correctness when receiving (assert fails on first error)\n"
1720            "  fifo-size N         Use N Kb fifos\n"
1721            "  rx-buf N            Use N Kb RX buffer\n"
1722            "  tx-buf N            Use N Kb TX test buffer\n"
1723            "  appns NAMESPACE     Use the namespace NAMESPACE\n"
1724            "  all-scope           all-scope option\n"
1725            "  local-scope         local-scope option\n"
1726            "  global-scope        global-scope option\n"
1727            "  secret SECRET       set namespace secret\n"
1728            "  chroot prefix PATH  Use PATH as memory root path\n"
1729            "  quic-setup OPT      OPT=serverstream : Client open N connections. On each one server opens M streams\n"
1730            "                            by default : Client open N connections. On each one client opens M streams\n"
1731            "\n"
1732            "  nclients N[/M]       Open N QUIC connections, each one with M streams (M defaults to 1)\n"
1733            "  TX=1337[Kb|Mb|GB]    Send 1337 [K|M|G]bytes, use TX=RX to reflect the data\n"
1734            "  RX=1337[Kb|Mb|GB]    Expect 1337 [K|M|G]bytes\n"
1735            "\n"
1736            "Default config is :\n"
1737            "server nclients 1/1 RX=64Kb TX=RX\n"
1738            "client nclients 1/1 RX=64Kb TX=64Kb\n");
1739   exit (1);
1740 }
1741
1742
1743 void
1744 quic_echo_process_opts (int argc, char **argv)
1745 {
1746   echo_main_t *em = &echo_main;
1747   unformat_input_t _argv, *a = &_argv;
1748   u32 tmp;
1749   u8 *chroot_prefix;
1750   u8 *uri = 0;
1751
1752   unformat_init_command_line (a, argv);
1753   while (unformat_check_input (a) != UNFORMAT_END_OF_INPUT)
1754     {
1755       if (unformat (a, "chroot prefix %s", &chroot_prefix))
1756         {
1757           vl_set_memory_root_path ((char *) chroot_prefix);
1758         }
1759       else if (unformat (a, "uri %s", &uri))
1760         em->uri = format (0, "%s%c", uri, 0);
1761       else if (unformat (a, "server"))
1762         em->i_am_master = 1;
1763       else if (unformat (a, "client"))
1764         em->i_am_master = 0;
1765       else if (unformat (a, "test-bytes:assert"))
1766         em->test_return_packets = RETURN_PACKETS_ASSERT;
1767       else if (unformat (a, "test-bytes"))
1768         em->test_return_packets = RETURN_PACKETS_LOG_WRONG;
1769       else if (unformat (a, "socket-name %s", &em->socket_name))
1770         ;
1771       else if (unformat (a, "use-svm-api"))
1772         em->use_sock_api = 0;
1773       else if (unformat (a, "fifo-size %d", &tmp))
1774         em->fifo_size = tmp << 10;
1775       else if (unformat (a, "rx-buf %d", &tmp))
1776         em->rx_buf_size = tmp << 10;
1777       else if (unformat (a, "tx-buf %d", &tmp))
1778         em->rx_buf_size = tmp << 10;
1779       else
1780         if (unformat
1781             (a, "nclients %d/%d", &em->n_clients, &em->n_stream_clients))
1782         ;
1783       else if (unformat (a, "nclients %d", &em->n_clients))
1784         ;
1785       else if (unformat (a, "appns %_%v%_", &em->appns_id))
1786         ;
1787       else if (unformat (a, "all-scope"))
1788         em->appns_flags |= (APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE
1789                             | APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE);
1790       else if (unformat (a, "local-scope"))
1791         em->appns_flags = APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
1792       else if (unformat (a, "global-scope"))
1793         em->appns_flags = APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
1794       else if (unformat (a, "secret %lu", &em->appns_secret))
1795         ;
1796       else if (unformat (a, "quic-setup %U", echo_unformat_quic_setup_vft))
1797         ;
1798       else if (unformat (a, "TX=RX"))
1799         em->data_source = ECHO_RX_DATA_SOURCE;
1800       else if (unformat (a, "TX=%U", unformat_data, &em->bytes_to_send))
1801         ;
1802       else if (unformat (a, "RX=%U", unformat_data, &em->bytes_to_receive))
1803         ;
1804       else if (unformat (a, "time %U:%U",
1805                          echo_unformat_timing_event, &em->timing_start_event,
1806                          echo_unformat_timing_event, &em->timing_end_event))
1807         ;
1808       else
1809         print_usage_and_exit ();
1810     }
1811
1812   if (em->bytes_to_receive == (u64) ~ 0)
1813     em->bytes_to_receive = 64 << 10;    /* default */
1814   if (em->bytes_to_send == (u64) ~ 0)
1815     em->bytes_to_send = 64 << 10;       /* default */
1816   else if (em->bytes_to_send == 0)
1817     em->data_source = ECHO_NO_DATA_SOURCE;
1818   else
1819     em->data_source = ECHO_TEST_DATA_SOURCE;
1820
1821   if (em->data_source == ECHO_INVALID_DATA_SOURCE)
1822     em->data_source =
1823       em->i_am_master ? ECHO_RX_DATA_SOURCE : ECHO_TEST_DATA_SOURCE;
1824   if (em->data_source == ECHO_RX_DATA_SOURCE)
1825     em->bytes_to_send = em->bytes_to_receive;
1826
1827   em->send_disconnects = !em->i_am_master;
1828 }
1829
1830 int
1831 main (int argc, char **argv)
1832 {
1833   echo_main_t *em = &echo_main;
1834   fifo_segment_main_t *sm = &em->segment_main;
1835   char *app_name;
1836   u32 n_clients, i;
1837
1838   clib_mem_init_thread_safe (0, 256 << 20);
1839   clib_memset (em, 0, sizeof (*em));
1840   em->session_index_by_vpp_handles = hash_create (0, sizeof (uword));
1841   em->shared_segment_handles = hash_create (0, sizeof (uword));
1842   em->my_pid = getpid ();
1843   em->socket_name = format (0, "%s%c", API_SOCKET_FILE, 0);
1844   em->use_sock_api = 1;
1845   em->fifo_size = 64 << 10;
1846   em->n_clients = 1;
1847   em->n_stream_clients = 1;
1848   em->max_test_msg = 50;
1849   em->time_to_stop = 0;
1850   em->i_am_master = 1;
1851   em->test_return_packets = RETURN_PACKETS_NOTEST;
1852   em->timing_start_event = ECHO_EVT_FIRST_QCONNECT;
1853   em->timing_end_event = ECHO_EVT_LAST_BYTE;
1854   em->bytes_to_receive = ~0;    /* defaulted when we know if server/client */
1855   em->bytes_to_send = ~0;       /* defaulted when we know if server/client */
1856   em->rx_buf_size = 1 << 20;
1857   em->tx_buf_size = 1 << 20;
1858   em->data_source = ECHO_INVALID_DATA_SOURCE;
1859   em->uri = format (0, "%s%c", "quic://0.0.0.0/1234", 0);
1860   em->cb_vft = default_cb_vft;
1861   quic_echo_process_opts (argc, argv);
1862
1863   n_clients = em->n_clients * em->n_stream_clients;
1864   vec_validate (em->client_thread_handles, n_clients - 1);
1865   vec_validate (em->thread_args, n_clients - 1);
1866   clib_time_init (&em->clib_time);
1867   init_error_string_table (em);
1868   fifo_segment_main_init (sm, HIGH_SEGMENT_BASEVA, 20);
1869   clib_spinlock_init (&em->segment_handles_lock);
1870   vec_validate (em->connect_test_data, em->tx_buf_size);
1871   for (i = 0; i < em->tx_buf_size; i++)
1872     em->connect_test_data[i] = i & 0xff;
1873
1874   setup_signal_handlers ();
1875   quic_echo_api_hookup (em);
1876
1877   app_name = em->i_am_master ? "quic_echo_server" : "quic_echo_client";
1878   if (connect_to_vpp (app_name) < 0)
1879     {
1880       svm_region_exit ();
1881       fformat (stderr, "Couldn't connect to vpe, exiting...\n");
1882       exit (1);
1883     }
1884
1885   quic_echo_notify_event (em, ECHO_EVT_START);
1886
1887   application_send_attach (em);
1888   if (wait_for_state_change (em, STATE_ATTACHED, TIMEOUT))
1889     {
1890       fformat (stderr, "Couldn't attach to vpp, exiting...\n");
1891       exit (1);
1892     }
1893   if (em->i_am_master)
1894     server_run (em);
1895   else
1896     clients_run (em);
1897   quic_echo_notify_event (em, ECHO_EVT_EXIT);
1898   print_global_stats (em);
1899   echo_free_sessions (em);
1900   echo_assert_test_suceeded (em);
1901   application_detach (em);
1902   if (wait_for_state_change (em, STATE_DETACHED, TIMEOUT))
1903     {
1904       fformat (stderr, "Couldn't detach to vpp, exiting...\n");
1905       exit (1);
1906     }
1907   if (em->use_sock_api)
1908     vl_socket_client_disconnect ();
1909   else
1910     vl_client_disconnect_from_vlib ();
1911   fformat (stdout, "Test complete !\n");
1912   exit (em->has_failed);
1913 }
1914
1915 /*
1916  * fd.io coding-style-patch-verification: ON
1917  *
1918  * Local Variables:
1919  * eval: (c-set-style "gnu")
1920  * End:
1921  */