src/plugins/hs_apps/vcl/vcl_test_client.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 <unistd.h>
  17 #include <errno.h>
  18 #include <stdlib.h>
  19 #include <ctype.h>
  20 #include <sys/types.h>
  21 #include <sys/socket.h>
  22 #include <stdio.h>
  23 #include <time.h>
  24 #include <arpa/inet.h>
  25 #include <hs_apps/vcl/vcl_test.h>
  26 #include <pthread.h>
  27
  28 typedef struct
  29 {
  30   vcl_test_session_t *sessions;
  31   uint32_t n_sessions;
  32   uint32_t wrk_index;
  33   fd_set wr_fdset;
  34   fd_set rd_fdset;
  35   int max_fd_index;
  36   pthread_t thread_handle;
  37   vcl_test_cfg_t cfg;
  38 } vcl_test_client_worker_t;
  39
  40 typedef struct
  41 {
  42   vcl_test_client_worker_t *workers;
  43   vppcom_endpt_t server_endpt;
  44   uint32_t cfg_seq_num;
  45   vcl_test_session_t ctrl_session;
  46   vcl_test_session_t *sessions;
  47   uint8_t dump_cfg;
  48   vcl_test_t post_test;
  49   uint32_t proto;
  50   uint32_t n_workers;
  51   volatile int active_workers;
  52   struct sockaddr_storage server_addr;
  53 } vcl_test_client_main_t;
  54
  55 static __thread int __wrk_index = 0;
  56
  57 vcl_test_client_main_t vcl_client_main;
  58
  59 #define vtc_min(a, b) (a < b ? a : b)
  60 #define vtc_max(a, b) (a > b ? a : b)
  61
  62 static int
  63 vtc_cfg_sync (vcl_test_session_t * ts)
  64 {
  65   vcl_test_cfg_t *rx_cfg = (vcl_test_cfg_t *) ts->rxbuf;
  66   int rx_bytes, tx_bytes;
  67
  68   vt_atomic_add (&ts->cfg.seq_num, 1);
  69   if (ts->cfg.verbose)
  70     {
  71       vtinf ("(fd %d): Sending config to server.", ts->fd);
  72       vcl_test_cfg_dump (&ts->cfg, 1 /* is_client */ );
  73     }
  74   tx_bytes = vcl_test_write (ts->fd, (uint8_t *) & ts->cfg,
  75                              sizeof (ts->cfg), NULL, ts->cfg.verbose);
  76   if (tx_bytes < 0)
  77     {
  78       vtwrn ("(fd %d): write test cfg failed (%d)!", ts->fd, tx_bytes);
  79       return tx_bytes;
  80     }
  81
  82   rx_bytes = vcl_test_read (ts->fd, (uint8_t *) ts->rxbuf,
  83                             sizeof (vcl_test_cfg_t), NULL);
  84   if (rx_bytes < 0)
  85     return rx_bytes;
  86
  87   if (rx_cfg->magic != VCL_TEST_CFG_CTRL_MAGIC)
  88     {
  89       vtwrn ("(fd %d): Bad server reply cfg -- aborting!", ts->fd);
  90       return -1;
  91     }
  92   if ((rx_bytes != sizeof (vcl_test_cfg_t))
  93       || !vcl_test_cfg_verify (rx_cfg, &ts->cfg))
  94     {
  95       vtwrn ("(fd %d): Invalid config received from server!", ts->fd);
  96       if (rx_bytes != sizeof (vcl_test_cfg_t))
  97         {
  98           vtinf ("\tRx bytes %d != cfg size %lu", rx_bytes,
  99                  sizeof (vcl_test_cfg_t));
 100         }
 101       else
 102         {
 103           vcl_test_cfg_dump (rx_cfg, 1 /* is_client */ );
 104           vtinf ("(fd %d): Valid config sent to server.", ts->fd);
 105           vcl_test_cfg_dump (&ts->cfg, 1 /* is_client */ );
 106         }
 107       return -1;
 108     }
 109   if (ts->cfg.verbose)
 110     {
 111       vtinf ("(fd %d): Got config back from server.", ts->fd);
 112       vcl_test_cfg_dump (rx_cfg, 1 /* is_client */ );
 113     }
 114
 115   return 0;
 116 }
 117
 118 static int
 119 vtc_connect_test_sessions (vcl_test_client_worker_t * wrk)
 120 {
 121   vcl_test_client_main_t *vcm = &vcl_client_main;
 122   vcl_test_session_t *ts;
 123   uint32_t n_test_sessions;
 124   int i, rv;
 125
 126   n_test_sessions = wrk->cfg.num_test_sessions;
 127   if (n_test_sessions < 1)
 128     {
 129       errno = EINVAL;
 130       return -1;
 131     }
 132
 133   if (wrk->n_sessions >= n_test_sessions)
 134     goto done;
 135
 136   if (wrk->n_sessions)
 137     wrk->sessions = realloc (wrk->sessions,
 138                              n_test_sessions * sizeof (vcl_test_session_t));
 139   else
 140     wrk->sessions = calloc (n_test_sessions, sizeof (vcl_test_session_t));
 141
 142   if (!wrk->sessions)
 143     {
 144       vterr ("failed to alloc sessions", -errno);
 145       return errno;
 146     }
 147
 148   for (i = 0; i < n_test_sessions; i++)
 149     {
 150       ts = &wrk->sessions[i];
 151       ts->fd = vppcom_session_create (vcm->proto, 1 /* is_nonblocking */ );
 152       if (ts->fd < 0)
 153         {
 154           vterr ("vppcom_session_create()", ts->fd);
 155           return ts->fd;
 156         }
 157
 158       rv = vppcom_session_connect (ts->fd, &vcm->server_endpt);
 159       if (rv < 0)
 160         {
 161           vterr ("vppcom_session_connect()", rv);
 162           return rv;
 163         }
 164       vtinf ("Test session %d (fd %d) connected.", i, ts->fd);
 165     }
 166   wrk->n_sessions = n_test_sessions;
 167
 168 done:
 169   vtinf ("All test sessions (%d) connected!", n_test_sessions);
 170   return 0;
 171 }
 172
 173 static int
 174 vtc_worker_test_setup (vcl_test_client_worker_t * wrk)
 175 {
 176   vcl_test_client_main_t *vcm = &vcl_client_main;
 177   vcl_test_session_t *ctrl = &vcm->ctrl_session;
 178   vcl_test_cfg_t *cfg = &wrk->cfg;
 179   vcl_test_session_t *ts;
 180   uint32_t sidx;
 181   int i, j;
 182
 183   FD_ZERO (&wrk->wr_fdset);
 184   FD_ZERO (&wrk->rd_fdset);
 185
 186   for (i = 0; i < cfg->num_test_sessions; i++)
 187     {
 188       ts = &wrk->sessions[i];
 189       ts->cfg = wrk->cfg;
 190       vcl_test_session_buf_alloc (ts);
 191
 192       switch (cfg->test)
 193         {
 194         case VCL_TEST_TYPE_ECHO:
 195           memcpy (ts->txbuf, ctrl->txbuf, cfg->total_bytes);
 196           break;
 197         case VCL_TEST_TYPE_UNI:
 198         case VCL_TEST_TYPE_BI:
 199           for (j = 0; j < ts->txbuf_size; j++)
 200             ts->txbuf[j] = j & 0xff;
 201           break;
 202         }
 203
 204       FD_SET (vppcom_session_index (ts->fd), &wrk->wr_fdset);
 205       FD_SET (vppcom_session_index (ts->fd), &wrk->rd_fdset);
 206       sidx = vppcom_session_index (ts->fd);
 207       wrk->max_fd_index = vtc_max (sidx, wrk->max_fd_index);
 208     }
 209   wrk->max_fd_index += 1;
 210
 211   return 0;
 212 }
 213
 214 static int
 215 vtc_worker_init (vcl_test_client_worker_t * wrk)
 216 {
 217   vcl_test_client_main_t *vcm = &vcl_client_main;
 218   vcl_test_cfg_t *cfg = &wrk->cfg;
 219   vcl_test_session_t *ts;
 220   uint32_t n;
 221   int rv;
 222
 223   __wrk_index = wrk->wrk_index;
 224
 225   vtinf ("Initializing worker %u ...", wrk->wrk_index);
 226
 227   if (wrk->wrk_index)
 228     {
 229       if (vppcom_worker_register ())
 230         {
 231           vtwrn ("failed to register worker");
 232           return -1;
 233         }
 234       vt_atomic_add (&vcm->active_workers, 1);
 235     }
 236   rv = vtc_connect_test_sessions (wrk);
 237   if (rv)
 238     {
 239       vterr ("vtc_connect_test_sessions ()", rv);
 240       return rv;
 241     }
 242
 243   if (vtc_worker_test_setup (wrk))
 244     return -1;
 245
 246   vtinf ("Sending config to server on all sessions ...");
 247
 248   for (n = 0; n < cfg->num_test_sessions; n++)
 249     {
 250       ts = &wrk->sessions[n];
 251       if (vtc_cfg_sync (ts))
 252         return -1;
 253       memset (&ts->stats, 0, sizeof (ts->stats));
 254     }
 255
 256   return 0;
 257 }
 258
 259 static int stats_lock = 0;
 260
 261 static void
 262 vtc_accumulate_stats (vcl_test_client_worker_t * wrk,
 263                       vcl_test_session_t * ctrl)
 264 {
 265   vcl_test_session_t *ts;
 266   static char buf[64];
 267   int i, show_rx = 0;
 268
 269   while (__sync_lock_test_and_set (&stats_lock, 1))
 270     ;
 271
 272   if (ctrl->cfg.test == VCL_TEST_TYPE_BI
 273       || ctrl->cfg.test == VCL_TEST_TYPE_ECHO)
 274     show_rx = 1;
 275
 276   for (i = 0; i < wrk->cfg.num_test_sessions; i++)
 277     {
 278       ts = &wrk->sessions[i];
 279       ts->stats.start = ctrl->stats.start;
 280
 281       if (ctrl->cfg.verbose > 1)
 282         {
 283           sprintf (buf, "CLIENT (fd %d) RESULTS", ts->fd);
 284           vcl_test_stats_dump (buf, &ts->stats, show_rx, 1 /* show tx */ ,
 285                                ctrl->cfg.verbose);
 286         }
 287
 288       vcl_test_stats_accumulate (&ctrl->stats, &ts->stats);
 289       if (vcl_comp_tspec (&ctrl->stats.stop, &ts->stats.stop) < 0)
 290         ctrl->stats.stop = ts->stats.stop;
 291     }
 292
 293   __sync_lock_release (&stats_lock);
 294 }
 295
 296 static void
 297 vtc_worker_sessions_exit (vcl_test_client_worker_t * wrk)
 298 {
 299   vcl_test_client_main_t *vcm = &vcl_client_main;
 300   vcl_test_session_t *ctrl = &vcm->ctrl_session;
 301   vcl_test_session_t *ts;
 302   int i, verbose = ctrl->cfg.verbose;
 303
 304   for (i = 0; i < wrk->cfg.num_test_sessions; i++)
 305     {
 306       ts = &wrk->sessions[i];
 307       ts->cfg.test = VCL_TEST_TYPE_EXIT;
 308
 309       if (verbose)
 310         {
 311           vtinf ("(fd %d): Sending exit cfg to server...", ts->fd);
 312           vcl_test_cfg_dump (&ts->cfg, 1 /* is_client */ );
 313         }
 314       (void) vcl_test_write (ts->fd, (uint8_t *) & ts->cfg,
 315                              sizeof (ts->cfg), &ts->stats, verbose);
 316     }
 317   wrk->n_sessions = 0;
 318 }
 319
 320 static void *
 321 vtc_worker_loop (void *arg)
 322 {
 323   vcl_test_client_main_t *vcm = &vcl_client_main;
 324   vcl_test_session_t *ctrl = &vcm->ctrl_session;
 325   vcl_test_client_worker_t *wrk = arg;
 326   uint32_t n_active_sessions, n_bytes;
 327   fd_set _wfdset, *wfdset = &_wfdset;
 328   fd_set _rfdset, *rfdset = &_rfdset;
 329   vcl_test_session_t *ts;
 330   int i, rv, check_rx = 0;
 331
 332   rv = vtc_worker_init (wrk);
 333   if (rv)
 334     {
 335       vterr ("vtc_worker_init()", rv);
 336       return 0;
 337     }
 338
 339   vtinf ("Starting test ...");
 340
 341   if (wrk->wrk_index == 0)
 342     clock_gettime (CLOCK_REALTIME, &ctrl->stats.start);
 343
 344   check_rx = wrk->cfg.test != VCL_TEST_TYPE_UNI;
 345   n_active_sessions = wrk->cfg.num_test_sessions;
 346   while (n_active_sessions)
 347     {
 348       _wfdset = wrk->wr_fdset;
 349       _rfdset = wrk->rd_fdset;
 350
 351       rv = vppcom_select (wrk->max_fd_index, (unsigned long *) rfdset,
 352                           (unsigned long *) wfdset, NULL, 0);
 353       if (rv < 0)
 354         {
 355           vterr ("vppcom_select()", rv);
 356           goto exit;
 357         }
 358       else if (rv == 0)
 359         continue;
 360
 361       for (i = 0; i < wrk->cfg.num_test_sessions; i++)
 362         {
 363           ts = &wrk->sessions[i];
 364           if (!((ts->stats.stop.tv_sec == 0) &&
 365                 (ts->stats.stop.tv_nsec == 0)))
 366             continue;
 367
 368           if (FD_ISSET (vppcom_session_index (ts->fd), rfdset)
 369               && ts->stats.rx_bytes < ts->cfg.total_bytes)
 370             {
 371               (void) vcl_test_read (ts->fd, (uint8_t *) ts->rxbuf,
 372                                     ts->rxbuf_size, &ts->stats);
 373             }
 374
 375           if (FD_ISSET (vppcom_session_index (ts->fd), wfdset)
 376               && ts->stats.tx_bytes < ts->cfg.total_bytes)
 377             {
 378               n_bytes = ts->cfg.txbuf_size;
 379               if (ts->cfg.test == VCL_TEST_TYPE_ECHO)
 380                 n_bytes = strlen (ctrl->txbuf) + 1;
 381               rv = vcl_test_write (ts->fd, (uint8_t *) ts->txbuf,
 382                                    n_bytes, &ts->stats, ts->cfg.verbose);
 383               if (rv < 0)
 384                 {
 385                   vtwrn ("vppcom_test_write (%d) failed -- aborting test",
 386                          ts->fd);
 387                   goto exit;
 388                 }
 389             }
 390
 391           if ((!check_rx && ts->stats.tx_bytes >= ts->cfg.total_bytes)
 392               || (check_rx && ts->stats.rx_bytes >= ts->cfg.total_bytes))
 393             {
 394               clock_gettime (CLOCK_REALTIME, &ts->stats.stop);
 395               n_active_sessions--;
 396             }
 397         }
 398     }
 399 exit:
 400   vtinf ("Worker %d done ...", wrk->wrk_index);
 401   if (wrk->cfg.test != VCL_TEST_TYPE_ECHO)
 402     vtc_accumulate_stats (wrk, ctrl);
 403   sleep (VCL_TEST_DELAY_DISCONNECT);
 404   vtc_worker_sessions_exit (wrk);
 405   if (wrk->wrk_index)
 406     vt_atomic_add (&vcm->active_workers, -1);
 407   return 0;
 408 }
 409
 410 static void
 411 vtc_print_stats (vcl_test_session_t * ctrl)
 412 {
 413   int is_echo = ctrl->cfg.test == VCL_TEST_TYPE_ECHO;
 414   int show_rx = 0;
 415   char buf[64];
 416
 417   if (ctrl->cfg.test == VCL_TEST_TYPE_BI
 418       || ctrl->cfg.test == VCL_TEST_TYPE_ECHO)
 419     show_rx = 1;
 420
 421   vcl_test_stats_dump ("CLIENT RESULTS", &ctrl->stats,
 422                        show_rx, 1 /* show tx */ ,
 423                        ctrl->cfg.verbose);
 424   vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ );
 425
 426   if (ctrl->cfg.verbose)
 427     {
 428       vtinf ("  ctrl session info\n"
 429              VCL_TEST_SEPARATOR_STRING
 430              "          fd:  %d (0x%08x)\n"
 431              "       rxbuf:  %p\n"
 432              "  rxbuf size:  %u (0x%08x)\n"
 433              "       txbuf:  %p\n"
 434              "  txbuf size:  %u (0x%08x)\n"
 435              VCL_TEST_SEPARATOR_STRING,
 436              ctrl->fd, (uint32_t) ctrl->fd,
 437              ctrl->rxbuf, ctrl->rxbuf_size, ctrl->rxbuf_size,
 438              ctrl->txbuf, ctrl->txbuf_size, ctrl->txbuf_size);
 439     }
 440
 441   if (is_echo)
 442     sprintf (buf, "Echo");
 443   else
 444     sprintf (buf, "%s-directional Stream",
 445              ctrl->cfg.test == VCL_TEST_TYPE_BI ? "Bi" : "Uni");
 446 }
 447
 448 static void
 449 vtc_echo_client (vcl_test_client_main_t * vcm)
 450 {
 451   vcl_test_client_worker_t *wrk;
 452   vcl_test_session_t *ctrl = &vcm->ctrl_session;
 453   vcl_test_cfg_t *cfg = &ctrl->cfg;
 454
 455   cfg->total_bytes = strlen (ctrl->txbuf) + 1;
 456   memset (&ctrl->stats, 0, sizeof (ctrl->stats));
 457
 458   /* Echo works with only one worker */
 459   wrk = vcm->workers;
 460   wrk->wrk_index = 0;
 461   wrk->cfg = *cfg;
 462
 463   vtc_worker_loop (wrk);
 464
 465   /* Not relevant for echo test
 466      clock_gettime (CLOCK_REALTIME, &ctrl->stats.stop);
 467      vtc_accumulate_stats (wrk, ctrl);
 468      vtc_print_stats (ctrl);
 469    */
 470 }
 471
 472 static void
 473 vtc_stream_client (vcl_test_client_main_t * vcm)
 474 {
 475   vcl_test_session_t *ctrl = &vcm->ctrl_session;
 476   vcl_test_cfg_t *cfg = &ctrl->cfg;
 477   vcl_test_client_worker_t *wrk;
 478   uint32_t i, n_conn, n_conn_per_wrk;
 479
 480   vtinf ("%s-directional Stream Test Starting!",
 481          ctrl->cfg.test == VCL_TEST_TYPE_BI ? "Bi" : "Uni");
 482
 483   cfg->total_bytes = cfg->num_writes * cfg->txbuf_size;
 484   cfg->ctrl_handle = ~0;
 485   if (vtc_cfg_sync (ctrl))
 486     {
 487       vtwrn ("test cfg sync failed -- aborting!");
 488       return;
 489     }
 490   cfg->ctrl_handle = ((vcl_test_cfg_t *) ctrl->rxbuf)->ctrl_handle;
 491   memset (&ctrl->stats, 0, sizeof (ctrl->stats));
 492
 493   n_conn = cfg->num_test_sessions;
 494   n_conn_per_wrk = n_conn / vcm->n_workers;
 495   for (i = 0; i < vcm->n_workers; i++)
 496     {
 497       wrk = &vcm->workers[i];
 498       wrk->wrk_index = i;
 499       wrk->cfg = ctrl->cfg;
 500       wrk->cfg.num_test_sessions = vtc_min (n_conn_per_wrk, n_conn);
 501       n_conn -= wrk->cfg.num_test_sessions;
 502     }
 503
 504   for (i = 1; i < vcm->n_workers; i++)
 505     {
 506       wrk = &vcm->workers[i];
 507       pthread_create (&wrk->thread_handle, NULL, vtc_worker_loop,
 508                       (void *) wrk);
 509     }
 510   vtc_worker_loop (&vcm->workers[0]);
 511
 512   while (vcm->active_workers > 0)
 513     ;
 514
 515   vtinf ("Sending config on ctrl session (fd %d) for stats...", ctrl->fd);
 516   if (vtc_cfg_sync (ctrl))
 517     {
 518       vtwrn ("test cfg sync failed -- aborting!");
 519       return;
 520     }
 521
 522   vtc_print_stats (ctrl);
 523
 524   ctrl->cfg.test = VCL_TEST_TYPE_ECHO;
 525   ctrl->cfg.total_bytes = 0;
 526   if (vtc_cfg_sync (ctrl))
 527     vtwrn ("post-test cfg sync failed!");
 528 }
 529
 530 static void
 531 dump_help (void)
 532 {
 533 #define INDENT "\n  "
 534
 535   printf ("CLIENT: Test configuration commands:"
 536           INDENT VCL_TEST_TOKEN_HELP
 537           "\t\t\tDisplay help."
 538           INDENT VCL_TEST_TOKEN_EXIT
 539           "\t\t\tExit test client & server."
 540           INDENT VCL_TEST_TOKEN_SHOW_CFG
 541           "\t\t\tShow the current test cfg."
 542           INDENT VCL_TEST_TOKEN_RUN_UNI
 543           "\t\t\tRun the Uni-directional test."
 544           INDENT VCL_TEST_TOKEN_RUN_BI
 545           "\t\t\tRun the Bi-directional test."
 546           INDENT VCL_TEST_TOKEN_VERBOSE
 547           "\t\t\tToggle verbose setting."
 548           INDENT VCL_TEST_TOKEN_RXBUF_SIZE
 549           "<rxbuf size>\tRx buffer size (bytes)."
 550           INDENT VCL_TEST_TOKEN_TXBUF_SIZE
 551           "<txbuf size>\tTx buffer size (bytes)."
 552           INDENT VCL_TEST_TOKEN_NUM_WRITES
 553           "<# of writes>\tNumber of txbuf writes to server." "\n");
 554 }
 555
 556 static void
 557 cfg_txbuf_size_set (void)
 558 {
 559   vcl_test_client_main_t *vcm = &vcl_client_main;
 560   vcl_test_session_t *ctrl = &vcm->ctrl_session;
 561   char *p = ctrl->txbuf + strlen (VCL_TEST_TOKEN_TXBUF_SIZE);
 562   uint64_t txbuf_size = strtoull ((const char *) p, NULL, 10);
 563
 564   if (txbuf_size >= VCL_TEST_CFG_BUF_SIZE_MIN)
 565     {
 566       ctrl->cfg.txbuf_size = txbuf_size;
 567       ctrl->cfg.total_bytes = ctrl->cfg.num_writes * ctrl->cfg.txbuf_size;
 568       vcl_test_buf_alloc (&ctrl->cfg, 0 /* is_rxbuf */ ,
 569                           (uint8_t **) & ctrl->txbuf, &ctrl->txbuf_size);
 570       vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ );
 571     }
 572   else
 573     vtwrn ("Invalid txbuf size (%lu) < minimum buf size (%u)!",
 574            txbuf_size, VCL_TEST_CFG_BUF_SIZE_MIN);
 575 }
 576
 577 static void
 578 cfg_num_writes_set (void)
 579 {
 580   vcl_test_client_main_t *vcm = &vcl_client_main;
 581   vcl_test_session_t *ctrl = &vcm->ctrl_session;
 582   char *p = ctrl->txbuf + strlen (VCL_TEST_TOKEN_NUM_WRITES);
 583   uint32_t num_writes = strtoul ((const char *) p, NULL, 10);
 584
 585   if (num_writes > 0)
 586     {
 587       ctrl->cfg.num_writes = num_writes;
 588       ctrl->cfg.total_bytes = ctrl->cfg.num_writes * ctrl->cfg.txbuf_size;
 589       vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ );
 590     }
 591   else
 592     {
 593       vtwrn ("invalid num writes: %u", num_writes);
 594     }
 595 }
 596
 597 static void
 598 cfg_num_test_sessions_set (void)
 599 {
 600   vcl_test_client_main_t *vcm = &vcl_client_main;
 601   vcl_test_session_t *ctrl = &vcm->ctrl_session;
 602   char *p = ctrl->txbuf + strlen (VCL_TEST_TOKEN_NUM_TEST_SESS);
 603   uint32_t num_test_sessions = strtoul ((const char *) p, NULL, 10);
 604
 605   if ((num_test_sessions > 0) &&
 606       (num_test_sessions <= VCL_TEST_CFG_MAX_TEST_SESS))
 607     {
 608       ctrl->cfg.num_test_sessions = num_test_sessions;
 609       vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ );
 610     }
 611   else
 612     {
 613       vtwrn ("invalid num test sessions: %u, (%d max)",
 614              num_test_sessions, VCL_TEST_CFG_MAX_TEST_SESS);
 615     }
 616 }
 617
 618 static void
 619 cfg_rxbuf_size_set (void)
 620 {
 621   vcl_test_client_main_t *vcm = &vcl_client_main;
 622   vcl_test_session_t *ctrl = &vcm->ctrl_session;
 623   char *p = ctrl->txbuf + strlen (VCL_TEST_TOKEN_RXBUF_SIZE);
 624   uint64_t rxbuf_size = strtoull ((const char *) p, NULL, 10);
 625
 626   if (rxbuf_size >= VCL_TEST_CFG_BUF_SIZE_MIN)
 627     {
 628       ctrl->cfg.rxbuf_size = rxbuf_size;
 629       vcl_test_buf_alloc (&ctrl->cfg, 1 /* is_rxbuf */ ,
 630                           (uint8_t **) & ctrl->rxbuf, &ctrl->rxbuf_size);
 631       vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ );
 632     }
 633   else
 634     vtwrn ("Invalid rxbuf size (%lu) < minimum buf size (%u)!",
 635            rxbuf_size, VCL_TEST_CFG_BUF_SIZE_MIN);
 636 }
 637
 638 static void
 639 cfg_verbose_toggle (void)
 640 {
 641   vcl_test_client_main_t *vcm = &vcl_client_main;
 642   vcl_test_session_t *ctrl = &vcm->ctrl_session;
 643
 644   ctrl->cfg.verbose = ctrl->cfg.verbose ? 0 : 1;
 645   vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ );
 646
 647 }
 648
 649 static vcl_test_t
 650 parse_input ()
 651 {
 652   vcl_test_client_main_t *vcm = &vcl_client_main;
 653   vcl_test_session_t *ctrl = &vcm->ctrl_session;
 654   vcl_test_t rv = VCL_TEST_TYPE_NONE;
 655
 656   if (!strncmp (VCL_TEST_TOKEN_EXIT, ctrl->txbuf,
 657                 strlen (VCL_TEST_TOKEN_EXIT)))
 658     rv = VCL_TEST_TYPE_EXIT;
 659
 660   else if (!strncmp (VCL_TEST_TOKEN_HELP, ctrl->txbuf,
 661                      strlen (VCL_TEST_TOKEN_HELP)))
 662     dump_help ();
 663
 664   else if (!strncmp (VCL_TEST_TOKEN_SHOW_CFG, ctrl->txbuf,
 665                      strlen (VCL_TEST_TOKEN_SHOW_CFG)))
 666     vcm->dump_cfg = 1;
 667
 668   else if (!strncmp (VCL_TEST_TOKEN_VERBOSE, ctrl->txbuf,
 669                      strlen (VCL_TEST_TOKEN_VERBOSE)))
 670     cfg_verbose_toggle ();
 671
 672   else if (!strncmp (VCL_TEST_TOKEN_TXBUF_SIZE, ctrl->txbuf,
 673                      strlen (VCL_TEST_TOKEN_TXBUF_SIZE)))
 674     cfg_txbuf_size_set ();
 675
 676   else if (!strncmp (VCL_TEST_TOKEN_NUM_TEST_SESS, ctrl->txbuf,
 677                      strlen (VCL_TEST_TOKEN_NUM_TEST_SESS)))
 678     cfg_num_test_sessions_set ();
 679
 680   else if (!strncmp (VCL_TEST_TOKEN_NUM_WRITES, ctrl->txbuf,
 681                      strlen (VCL_TEST_TOKEN_NUM_WRITES)))
 682     cfg_num_writes_set ();
 683
 684   else if (!strncmp (VCL_TEST_TOKEN_RXBUF_SIZE, ctrl->txbuf,
 685                      strlen (VCL_TEST_TOKEN_RXBUF_SIZE)))
 686     cfg_rxbuf_size_set ();
 687
 688   else if (!strncmp (VCL_TEST_TOKEN_RUN_UNI, ctrl->txbuf,
 689                      strlen (VCL_TEST_TOKEN_RUN_UNI)))
 690     rv = ctrl->cfg.test = VCL_TEST_TYPE_UNI;
 691
 692   else if (!strncmp (VCL_TEST_TOKEN_RUN_BI, ctrl->txbuf,
 693                      strlen (VCL_TEST_TOKEN_RUN_BI)))
 694     rv = ctrl->cfg.test = VCL_TEST_TYPE_BI;
 695
 696   else
 697     rv = VCL_TEST_TYPE_ECHO;
 698
 699   return rv;
 700 }
 701
 702 void
 703 print_usage_and_exit (void)
 704 {
 705   fprintf (stderr,
 706            "vcl_test_client [OPTIONS] <ipaddr> <port>\n"
 707            "  OPTIONS\n"
 708            "  -h               Print this message and exit.\n"
 709            "  -6               Use IPv6\n"
 710            "  -c               Print test config before test.\n"
 711            "  -w <dir>         Write test results to <dir>.\n"
 712            "  -X               Exit after running test.\n"
 713            "  -D               Use UDP transport layer\n"
 714            "  -L               Use TLS transport layer\n"
 715            "  -E               Run Echo test.\n"
 716            "  -N <num-writes>  Test Cfg: number of writes.\n"
 717            "  -R <rxbuf-size>  Test Cfg: rx buffer size.\n"
 718            "  -T <txbuf-size>  Test Cfg: tx buffer size.\n"
 719            "  -U               Run Uni-directional test.\n"
 720            "  -B               Run Bi-directional test.\n"
 721            "  -V               Verbose mode.\n");
 722   exit (1);
 723 }
 724
 725 static void
 726 vtc_process_opts (vcl_test_client_main_t * vcm, int argc, char **argv)
 727 {
 728   vcl_test_session_t *ctrl = &vcm->ctrl_session;
 729   int c, v;
 730
 731   opterr = 0;
 732   while ((c = getopt (argc, argv, "chn:w:XE:I:N:R:T:UBV6DL")) != -1)
 733     switch (c)
 734       {
 735       case 'c':
 736         vcm->dump_cfg = 1;
 737         break;
 738
 739       case 's':
 740         if (sscanf (optarg, "0x%x", &ctrl->cfg.num_test_sessions) != 1)
 741           if (sscanf (optarg, "%u", &ctrl->cfg.num_test_sessions) != 1)
 742             {
 743               vtwrn ("Invalid value for option -%c!", c);
 744               print_usage_and_exit ();
 745             }
 746         if (!ctrl->cfg.num_test_sessions ||
 747             (ctrl->cfg.num_test_sessions > FD_SETSIZE))
 748           {
 749             vtwrn ("Invalid number of sessions (%d) specified for option -%c!"
 750                    "\n       Valid range is 1 - %d",
 751                    ctrl->cfg.num_test_sessions, c, FD_SETSIZE);
 752             print_usage_and_exit ();
 753           }
 754         break;
 755
 756       case 'w':
 757         if (sscanf (optarg, "%d", &v) != 1)
 758           {
 759             vtwrn ("Invalid value for option -%c!", c);
 760             print_usage_and_exit ();
 761           }
 762         if (v > 1)
 763           vcm->n_workers = v;
 764         break;
 765
 766       case 'X':
 767         vcm->post_test = VCL_TEST_TYPE_EXIT;
 768         break;
 769
 770       case 'E':
 771         if (strlen (optarg) > ctrl->txbuf_size)
 772           {
 773             vtwrn ("Option -%c value larger than txbuf size (%d)!",
 774                    optopt, ctrl->txbuf_size);
 775             print_usage_and_exit ();
 776           }
 777         strcpy (ctrl->txbuf, optarg);
 778         ctrl->cfg.test = VCL_TEST_TYPE_ECHO;
 779         break;
 780
 781       case 'I':
 782         if (sscanf (optarg, "0x%x", &ctrl->cfg.num_test_sessions) != 1)
 783           if (sscanf (optarg, "%d", &ctrl->cfg.num_test_sessions) != 1)
 784             {
 785               vtwrn ("Invalid value for option -%c!", c);
 786               print_usage_and_exit ();
 787             }
 788         if (ctrl->cfg.num_test_sessions > VCL_TEST_CFG_MAX_TEST_SESS)
 789           {
 790             vtwrn ("value greater than max number test sessions (%d)!",
 791                    VCL_TEST_CFG_MAX_TEST_SESS);
 792             print_usage_and_exit ();
 793           }
 794         break;
 795
 796       case 'N':
 797         if (sscanf (optarg, "0x%lx", &ctrl->cfg.num_writes) != 1)
 798           if (sscanf (optarg, "%ld", &ctrl->cfg.num_writes) != 1)
 799             {
 800               vtwrn ("Invalid value for option -%c!", c);
 801               print_usage_and_exit ();
 802             }
 803         ctrl->cfg.total_bytes = ctrl->cfg.num_writes * ctrl->cfg.txbuf_size;
 804         break;
 805
 806       case 'R':
 807         if (sscanf (optarg, "0x%lx", &ctrl->cfg.rxbuf_size) != 1)
 808           if (sscanf (optarg, "%ld", &ctrl->cfg.rxbuf_size) != 1)
 809             {
 810               vtwrn ("Invalid value for option -%c!", c);
 811               print_usage_and_exit ();
 812             }
 813         if (ctrl->cfg.rxbuf_size >= VCL_TEST_CFG_BUF_SIZE_MIN)
 814           {
 815             ctrl->rxbuf_size = ctrl->cfg.rxbuf_size;
 816             vcl_test_buf_alloc (&ctrl->cfg, 1 /* is_rxbuf */ ,
 817                                 (uint8_t **) & ctrl->rxbuf,
 818                                 &ctrl->rxbuf_size);
 819           }
 820         else
 821           {
 822             vtwrn ("rxbuf size (%lu) less than minumum (%u)",
 823                    ctrl->cfg.rxbuf_size, VCL_TEST_CFG_BUF_SIZE_MIN);
 824             print_usage_and_exit ();
 825           }
 826
 827         break;
 828
 829       case 'T':
 830         if (sscanf (optarg, "0x%lx", &ctrl->cfg.txbuf_size) != 1)
 831           if (sscanf (optarg, "%ld", &ctrl->cfg.txbuf_size) != 1)
 832             {
 833               vtwrn ("Invalid value for option -%c!", c);
 834               print_usage_and_exit ();
 835             }
 836         if (ctrl->cfg.txbuf_size >= VCL_TEST_CFG_BUF_SIZE_MIN)
 837           {
 838             ctrl->txbuf_size = ctrl->cfg.txbuf_size;
 839             vcl_test_buf_alloc (&ctrl->cfg, 0 /* is_rxbuf */ ,
 840                                 (uint8_t **) & ctrl->txbuf,
 841                                 &ctrl->txbuf_size);
 842             ctrl->cfg.total_bytes =
 843               ctrl->cfg.num_writes * ctrl->cfg.txbuf_size;
 844           }
 845         else
 846           {
 847             vtwrn ("txbuf size (%lu) less than minumum (%u)!",
 848                    ctrl->cfg.txbuf_size, VCL_TEST_CFG_BUF_SIZE_MIN);
 849             print_usage_and_exit ();
 850           }
 851         break;
 852
 853       case 'U':
 854         ctrl->cfg.test = VCL_TEST_TYPE_UNI;
 855         break;
 856
 857       case 'B':
 858         ctrl->cfg.test = VCL_TEST_TYPE_BI;
 859         break;
 860
 861       case 'V':
 862         ctrl->cfg.verbose = 1;
 863         break;
 864
 865       case '6':
 866         ctrl->cfg.address_ip6 = 1;
 867         break;
 868
 869       case 'D':
 870         ctrl->cfg.transport_udp = 1;
 871         break;
 872
 873       case 'L':
 874         ctrl->cfg.transport_tls = 1;
 875         break;
 876
 877       case '?':
 878         switch (optopt)
 879           {
 880           case 'E':
 881           case 'I':
 882           case 'N':
 883           case 'R':
 884           case 'T':
 885           case 'w':
 886             vtwrn ("Option -%c requires an argument.", optopt);
 887             break;
 888
 889           default:
 890             if (isprint (optopt))
 891               vtwrn ("Unknown option `-%c'.", optopt);
 892             else
 893               vtwrn ("Unknown option character `\\x%x'.", optopt);
 894           }
 895         /* fall thru */
 896       case 'h':
 897       default:
 898         print_usage_and_exit ();
 899       }
 900
 901   if (argc < (optind + 2))
 902     {
 903       vtwrn ("Insufficient number of arguments!");
 904       print_usage_and_exit ();
 905     }
 906
 907   if (ctrl->cfg.transport_udp)
 908     {
 909       vcm->proto = VPPCOM_PROTO_UDP;
 910     }
 911   else if (ctrl->cfg.transport_tls)
 912     {
 913       vcm->proto = VPPCOM_PROTO_TLS;
 914     }
 915   else
 916     {
 917       vcm->proto = VPPCOM_PROTO_TCP;
 918     }
 919
 920   memset (&vcm->server_addr, 0, sizeof (vcm->server_addr));
 921   if (ctrl->cfg.address_ip6)
 922     {
 923       struct sockaddr_in6 *sddr6 = (struct sockaddr_in6 *) &vcm->server_addr;
 924       sddr6->sin6_family = AF_INET6;
 925       inet_pton (AF_INET6, argv[optind++], &(sddr6->sin6_addr));
 926       sddr6->sin6_port = htons (atoi (argv[optind]));
 927
 928       vcm->server_endpt.is_ip4 = 0;
 929       vcm->server_endpt.ip = (uint8_t *) & sddr6->sin6_addr;
 930       vcm->server_endpt.port = (uint16_t) sddr6->sin6_port;
 931     }
 932   else
 933     {
 934       struct sockaddr_in *saddr4 = (struct sockaddr_in *) &vcm->server_addr;
 935       saddr4->sin_family = AF_INET;
 936       inet_pton (AF_INET, argv[optind++], &(saddr4->sin_addr));
 937       saddr4->sin_port = htons (atoi (argv[optind]));
 938
 939       vcm->server_endpt.is_ip4 = 1;
 940       vcm->server_endpt.ip = (uint8_t *) & saddr4->sin_addr;
 941       vcm->server_endpt.port = (uint16_t) saddr4->sin_port;
 942     }
 943 }
 944
 945 static void
 946 vtc_read_user_input (vcl_test_session_t * ctrl)
 947 {
 948   printf ("\nType some characters and hit <return>\n"
 949           "('" VCL_TEST_TOKEN_HELP "' for help): ");
 950
 951   if (fgets (ctrl->txbuf, ctrl->txbuf_size, stdin) != NULL)
 952     {
 953       if (strlen (ctrl->txbuf) == 1)
 954         {
 955           printf ("\nNothing to send!  Please try again...\n");
 956           return;
 957         }
 958       ctrl->txbuf[strlen (ctrl->txbuf) - 1] = 0;        // chomp the newline.
 959
 960       /* Parse input for keywords */
 961       ctrl->cfg.test = parse_input ();
 962     }
 963 }
 964
 965 static void
 966 vtc_ctrl_session_exit (void)
 967 {
 968   vcl_test_client_main_t *vcm = &vcl_client_main;
 969   vcl_test_session_t *ctrl = &vcm->ctrl_session;
 970   int verbose = ctrl->cfg.verbose;
 971
 972   ctrl->cfg.test = VCL_TEST_TYPE_EXIT;
 973   if (verbose)
 974     {
 975       vtinf ("(fd %d): Sending exit cfg to server...", ctrl->fd);
 976       vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ );
 977     }
 978   (void) vcl_test_write (ctrl->fd, (uint8_t *) & ctrl->cfg,
 979                          sizeof (ctrl->cfg), &ctrl->stats, verbose);
 980   sleep (1);
 981 }
 982
 983 int
 984 main (int argc, char **argv)
 985 {
 986   vcl_test_client_main_t *vcm = &vcl_client_main;
 987   vcl_test_session_t *ctrl = &vcm->ctrl_session;
 988   int rv;
 989
 990   vcm->n_workers = 1;
 991   vcl_test_cfg_init (&ctrl->cfg);
 992   vcl_test_session_buf_alloc (ctrl);
 993   vtc_process_opts (vcm, argc, argv);
 994
 995   vcm->workers = calloc (vcm->n_workers, sizeof (vcl_test_client_worker_t));
 996   rv = vppcom_app_create ("vcl_test_client");
 997   if (rv < 0)
 998     vtfail ("vppcom_app_create()", rv);
 999
1000   ctrl->fd = vppcom_session_create (vcm->proto, 0 /* is_nonblocking */ );
1001   if (ctrl->fd < 0)
1002     vtfail ("vppcom_session_create()", ctrl->fd);
1003
1004   if (vcm->proto == VPPCOM_PROTO_TLS)
1005     {
1006       vtinf ("Adding tls certs ...");
1007       vppcom_session_tls_add_cert (ctrl->fd, vcl_test_crt_rsa,
1008                                    vcl_test_crt_rsa_len);
1009       vppcom_session_tls_add_key (ctrl->fd, vcl_test_key_rsa,
1010                                   vcl_test_key_rsa_len);
1011     }
1012
1013   vtinf ("Connecting to server...");
1014   rv = vppcom_session_connect (ctrl->fd, &vcm->server_endpt);
1015   if (rv)
1016     vtfail ("vppcom_session_connect()", rv);
1017   vtinf ("Control session (fd %d) connected.", ctrl->fd);
1018
1019   rv = vtc_cfg_sync (ctrl);
1020   if (rv)
1021     vtfail ("vtc_cfg_sync()", rv);
1022
1023   ctrl->cfg.ctrl_handle = ((vcl_test_cfg_t *) ctrl->rxbuf)->ctrl_handle;
1024   memset (&ctrl->stats, 0, sizeof (ctrl->stats));
1025
1026   while (ctrl->cfg.test != VCL_TEST_TYPE_EXIT)
1027     {
1028       if (vcm->dump_cfg)
1029         {
1030           vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ );
1031           vcm->dump_cfg = 0;
1032         }
1033
1034       switch (ctrl->cfg.test)
1035         {
1036         case VCL_TEST_TYPE_ECHO:
1037           vtc_echo_client (vcm);
1038           break;
1039
1040         case VCL_TEST_TYPE_UNI:
1041         case VCL_TEST_TYPE_BI:
1042           vtc_stream_client (vcm);
1043           break;
1044
1045         case VCL_TEST_TYPE_EXIT:
1046           continue;
1047
1048         case VCL_TEST_TYPE_NONE:
1049         default:
1050           break;
1051         }
1052       switch (vcm->post_test)
1053         {
1054         case VCL_TEST_TYPE_EXIT:
1055           switch (ctrl->cfg.test)
1056             {
1057             case VCL_TEST_TYPE_EXIT:
1058             case VCL_TEST_TYPE_UNI:
1059             case VCL_TEST_TYPE_BI:
1060             case VCL_TEST_TYPE_ECHO:
1061               ctrl->cfg.test = VCL_TEST_TYPE_EXIT;
1062               continue;
1063
1064             case VCL_TEST_TYPE_NONE:
1065             default:
1066               break;
1067             }
1068           break;
1069
1070         case VCL_TEST_TYPE_NONE:
1071         case VCL_TEST_TYPE_ECHO:
1072         case VCL_TEST_TYPE_UNI:
1073         case VCL_TEST_TYPE_BI:
1074         default:
1075           break;
1076         }
1077
1078       memset (ctrl->txbuf, 0, ctrl->txbuf_size);
1079       memset (ctrl->rxbuf, 0, ctrl->rxbuf_size);
1080
1081       vtc_read_user_input (ctrl);
1082     }
1083
1084   vtc_ctrl_session_exit ();
1085   vppcom_session_close (ctrl->fd);
1086   vppcom_app_destroy ();
1087   free (vcm->workers);
1088   return 0;
1089 }
1090
1091 /*
1092  * fd.io coding-style-patch-verification: ON
1093  *
1094  * Local Variables:
1095  * eval: (c-set-style "gnu")
1096  * End:
1097  */