extras/libmemif/examples/icmp_responder/main.c

   1 /*
   2  *------------------------------------------------------------------
   3  * Copyright (c) 2017 Cisco and/or its affiliates.
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *------------------------------------------------------------------
  16  */
  17
  18 #include <stdlib.h>
  19 #include <stdint.h>
  20 #include <net/if.h>
  21 #include <sys/types.h>
  22 #include <fcntl.h>
  23 #include <sys/ioctl.h>
  24 #include <sys/socket.h>
  25 #include <sys/un.h>
  26 #include <sys/uio.h>
  27 #include <sys/mman.h>
  28 #include <sys/prctl.h>
  29 #include <inttypes.h>
  30 #include <string.h>
  31 #include <stdio.h>
  32 #include <netdb.h>
  33 #include <linux/ip.h>
  34 #include <linux/icmp.h>
  35 #include <arpa/inet.h>
  36 #include <stdlib.h>
  37 #include <netinet/if_ether.h>
  38 #include <net/if_arp.h>
  39 #include <asm/byteorder.h>
  40 #include <byteswap.h>
  41 #include <string.h>
  42 #include <sys/epoll.h>
  43 #include <errno.h>
  44 #include <unistd.h>
  45 #include <signal.h>
  46
  47 #include <libmemif.h>
  48 #include <icmp_proto.h>
  49
  50 #define APP_NAME "ICMP_Responder"
  51 #define IF_NAME  "memif_connection"
  52
  53
  54 #ifdef ICMP_DBG
  55 #define DBG(...) do {                                               \
  56                     printf (APP_NAME":%s:%d: ", __func__, __LINE__);         \
  57                     printf (__VA_ARGS__);                           \
  58                     printf ("\n");                                  \
  59                 } while (0)
  60 #else
  61 #define DBG(...)
  62 #endif
  63
  64 #define INFO(...) do {                                              \
  65                     printf ("INFO: "__VA_ARGS__);                   \
  66                     printf ("\n");                                  \
  67                 } while (0)
  68
  69 /* maximum tx/rx memif buffers */
  70 #define MAX_MEMIF_BUFS 256
  71
  72 typedef struct
  73 {
  74   uint16_t index;
  75   /* memif conenction handle */
  76   memif_conn_handle_t conn;
  77   /* transmit queue id */
  78   uint16_t tx_qid;
  79   /* tx buffers */
  80   memif_buffer_t *tx_bufs;
  81   /* allocated tx buffers counter */
  82   /* number of tx buffers pointing to shared memory */
  83   uint16_t tx_buf_num;
  84   /* rx buffers */
  85   memif_buffer_t *rx_bufs;
  86   /* allcoated rx buffers counter */
  87   /* number of rx buffers pointing to shared memory */
  88   uint16_t rx_buf_num;
  89   /* interface ip address */
  90   uint8_t ip_addr[4];
  91 } memif_connection_t;
  92
  93 memif_connection_t memif_connection;
  94 int epfd;
  95
  96 static void
  97 print_memif_details ()
  98 {
  99   memif_connection_t *c = &memif_connection;
 100   printf ("MEMIF DETAILS\n");
 101   printf ("==============================\n");
 102
 103
 104   memif_details_t md;
 105   memset (&md, 0, sizeof (md));
 106   ssize_t buflen = 2048;
 107   char *buf = malloc (buflen);
 108   memset (buf, 0, buflen);
 109   int err, e;
 110
 111   err = memif_get_details (c->conn, &md, buf, buflen);
 112   if (err != MEMIF_ERR_SUCCESS)
 113     {
 114       INFO ("%s", memif_strerror (err));
 115       if (err == MEMIF_ERR_NOCONN)
 116         {
 117           free (buf);
 118           return;
 119         }
 120     }
 121
 122   printf ("\tinterface name: %s\n", (char *) md.if_name);
 123   printf ("\tapp name: %s\n", (char *) md.inst_name);
 124   printf ("\tremote interface name: %s\n", (char *) md.remote_if_name);
 125   printf ("\tremote app name: %s\n", (char *) md.remote_inst_name);
 126   printf ("\tid: %u\n", md.id);
 127   printf ("\tsecret: %s\n", (char *) md.secret);
 128   printf ("\trole: ");
 129   if (md.role)
 130     printf ("slave\n");
 131   else
 132     printf ("master\n");
 133   printf ("\tmode: ");
 134   switch (md.mode)
 135     {
 136     case 0:
 137       printf ("ethernet\n");
 138       break;
 139     case 1:
 140       printf ("ip\n");
 141       break;
 142     case 2:
 143       printf ("punt/inject\n");
 144       break;
 145     default:
 146       printf ("unknown\n");
 147       break;
 148     }
 149   printf ("\tsocket filename: %s\n", (char *) md.socket_filename);
 150   printf ("\tsocket filename: %s\n", (char *) md.socket_filename);
 151   printf ("\trx queues:\n");
 152   for (e = 0; e < md.rx_queues_num; e++)
 153     {
 154       printf ("\t\tqueue id: %u\n", md.rx_queues[e].qid);
 155       printf ("\t\tring size: %u\n", md.rx_queues[e].ring_size);
 156       printf ("\t\tbuffer size: %u\n", md.rx_queues[e].buffer_size);
 157     }
 158   printf ("\ttx queues:\n");
 159   for (e = 0; e < md.tx_queues_num; e++)
 160     {
 161       printf ("\t\tqueue id: %u\n", md.tx_queues[e].qid);
 162       printf ("\t\tring size: %u\n", md.tx_queues[e].ring_size);
 163       printf ("\t\tbuffer size: %u\n", md.tx_queues[e].buffer_size);
 164     }
 165   printf ("\tlink: ");
 166   if (md.link_up_down)
 167     printf ("up\n");
 168   else
 169     printf ("down\n");
 170
 171   free (buf);
 172 }
 173
 174 /* informs user about connected status. private_ctx is used by user to identify connection
 175     (multiple connections WIP) */
 176 int
 177 on_connect (memif_conn_handle_t conn, void *private_ctx)
 178 {
 179   INFO ("memif connected!");
 180   return 0;
 181 }
 182
 183 /* informs user about disconnected status. private_ctx is used by user to identify connection
 184     (multiple connections WIP) */
 185 int
 186 on_disconnect (memif_conn_handle_t conn, void *private_ctx)
 187 {
 188   INFO ("memif disconnected!");
 189   return 0;
 190 }
 191
 192 int
 193 icmpr_memif_delete ()
 194 {
 195   int err;
 196   /* disconnect then delete memif connection */
 197   err = memif_delete (&(&memif_connection)->conn);
 198   if (err != MEMIF_ERR_SUCCESS)
 199     INFO ("memif_delete: %s", memif_strerror (err));
 200   return 0;
 201 }
 202
 203 void
 204 print_help ()
 205 {
 206   printf ("LIBMEMIF EXAMPLE APP: %s", APP_NAME);
 207 #ifdef ICMP_DBG
 208   printf (" (debug)");
 209 #endif
 210   printf ("\n");
 211   printf ("==============================\n");
 212   printf ("libmemif version: %s", LIBMEMIF_VERSION);
 213 #ifdef MEMIF_DBG
 214   printf (" (debug)");
 215 #endif
 216   printf ("\n");
 217   printf ("memif version: %d\n", memif_get_version ());
 218   printf ("\tuse CTRL+C to exit\n");
 219 }
 220
 221 int
 222 icmpr_buffer_alloc (long n, uint16_t qid)
 223 {
 224   memif_connection_t *c = &memif_connection;
 225   int err;
 226   uint16_t r;
 227   /* set data pointer to shared memory and set buffer_len to shared memory buffer len */
 228   err = memif_buffer_alloc (c->conn, qid, c->tx_bufs, n, &r, 0);
 229   if (err != MEMIF_ERR_SUCCESS)
 230     {
 231       INFO ("memif_buffer_alloc: %s", memif_strerror (err));
 232       c->tx_buf_num += r;
 233       return -1;
 234     }
 235   c->tx_buf_num += r;
 236   DBG ("allocated %d/%ld buffers, %u free buffers", r, n,
 237        MAX_MEMIF_BUFS - c->tx_buf_num);
 238   return 0;
 239 }
 240
 241 int
 242 icmpr_tx_burst (uint16_t qid)
 243 {
 244   memif_connection_t *c = &memif_connection;
 245   int err;
 246   uint16_t r;
 247   /* inform peer memif interface about data in shared memory buffers */
 248   /* mark memif buffers as free */
 249   err = memif_tx_burst (c->conn, qid, c->tx_bufs, c->tx_buf_num, &r);
 250   if (err != MEMIF_ERR_SUCCESS)
 251     INFO ("memif_tx_burst: %s", memif_strerror (err));
 252   DBG ("tx: %d/%u", r, c->tx_buf_num);
 253   c->tx_buf_num -= r;
 254   return 0;
 255 }
 256
 257 int
 258 icmpr_free ()
 259 {
 260   /* application cleanup */
 261   int err;
 262   memif_connection_t *c = &memif_connection;
 263   free (c->tx_bufs);
 264   c->tx_bufs = NULL;
 265   free (c->rx_bufs);
 266   c->rx_bufs = NULL;
 267
 268   err = memif_cleanup ();
 269   if (err != MEMIF_ERR_SUCCESS)
 270     INFO ("memif_delete: %s", memif_strerror (err));
 271
 272   return 0;
 273 }
 274
 275 void
 276 icmpr_exit (int sig)
 277 {
 278   printf ("\n");
 279   icmpr_memif_delete ();
 280   icmpr_free ();
 281   exit (EXIT_SUCCESS);
 282 }
 283
 284 /* called when event is polled on interrupt file descriptor.
 285     there are packets in shared memory ready to be received */
 286 int
 287 on_interrupt (memif_conn_handle_t conn, void *private_ctx, uint16_t qid)
 288 {
 289   DBG ("interrupted");
 290   memif_connection_t *c = &memif_connection;
 291   int err;
 292   uint16_t rx;
 293   /* receive data from shared memory buffers */
 294   err = memif_rx_burst (c->conn, qid, c->rx_bufs, MAX_MEMIF_BUFS, &rx);
 295   c->rx_buf_num += rx;
 296
 297   DBG ("received %d buffers. %u/%u alloc/free buffers",
 298        rx, c->rx_buf_num, MAX_MEMIF_BUFS - c->rx_buf_num);
 299
 300   if (icmpr_buffer_alloc (rx, c->tx_qid) < 0)
 301     {
 302       INFO ("buffer_alloc error");
 303       goto error;
 304     }
 305   int i;
 306   for (i = 0; i < rx; i++)
 307     {
 308       resolve_packet ((void *) (c->rx_bufs + i)->data,
 309                       (c->rx_bufs + i)->len,
 310                       (void *) (c->tx_bufs + i)->data,
 311                       &(c->tx_bufs + i)->len, c->ip_addr);
 312     }
 313
 314   /* mark memif buffers and shared memory buffers as free */
 315   err = memif_refill_queue (c->conn, qid, rx, 0);
 316   /*
 317    * In this example we can assert that c->conn points to valid connection
 318    * and 'rx <= c->rx_buf_num'.
 319    */
 320   c->rx_buf_num -= rx;
 321
 322   DBG ("freed %d buffers. %u/%u alloc/free buffers",
 323        rx, c->rx_buf_num, MAX_MEMIF_BUFS - c->rx_buf_num);
 324
 325   icmpr_tx_burst (c->tx_qid);
 326
 327   return 0;
 328
 329 error:
 330   err = memif_refill_queue (c->conn, qid, rx, 0);
 331   if (err != MEMIF_ERR_SUCCESS)
 332     INFO ("memif_buffer_free: %s", memif_strerror (err));
 333   c->rx_buf_num -= rx;
 334   DBG ("freed %d buffers. %u/%u alloc/free buffers",
 335        rx, c->rx_buf_num, MAX_MEMIF_BUFS - c->rx_buf_num);
 336   return 0;
 337 }
 338
 339 int
 340 icmpr_memif_create (int is_master)
 341 {
 342   /* setting memif connection arguments */
 343   memif_conn_args_t args;
 344   memset (&args, 0, sizeof (args));
 345   args.is_master = is_master;
 346   args.log2_ring_size = 10;
 347   args.buffer_size = 2048;
 348   args.num_s2m_rings = 2;
 349   args.num_m2s_rings = 2;
 350   strncpy ((char *) args.interface_name, IF_NAME, strlen (IF_NAME));
 351   args.mode = 0;
 352   /* socket filename is not specified, because this app is supposed to
 353      connect to VPP over memif. so default socket filename will be used */
 354   /* default socketfile = /run/vpp/memif.sock */
 355
 356   args.interface_id = 0;
 357   /* last argument for memif_create (void * private_ctx) is used by user
 358      to identify connection. this context is returned with callbacks */
 359   int err = memif_create (&(&memif_connection)->conn,
 360                           &args, on_connect, on_disconnect, on_interrupt,
 361                           NULL);
 362   if (err != MEMIF_ERR_SUCCESS)
 363     INFO ("memif_create: %s", memif_strerror (err));
 364   return 0;
 365 }
 366
 367 int
 368 main (int argc, char *argv[])
 369 {
 370   memif_connection_t *c = &memif_connection;
 371
 372   signal (SIGINT, icmpr_exit);
 373
 374   /* initialize global memif connection handle */
 375   c->conn = NULL;
 376   if (argc == 1)
 377     c->tx_qid = 0;
 378   else
 379     {
 380       char *end;
 381       c->tx_qid = strtol (argv[1], &end, 10);
 382     }
 383   INFO ("tx qid: %u", c->tx_qid);
 384   /* alloc memif buffers */
 385   c->rx_buf_num = 0;
 386   c->rx_bufs =
 387     (memif_buffer_t *) malloc (sizeof (memif_buffer_t) * MAX_MEMIF_BUFS);
 388   c->tx_buf_num = 0;
 389   c->tx_bufs =
 390     (memif_buffer_t *) malloc (sizeof (memif_buffer_t) * MAX_MEMIF_BUFS);
 391   c->ip_addr[0] = 192;
 392   c->ip_addr[1] = 168;
 393   c->ip_addr[2] = 1;
 394   c->ip_addr[3] = 2;
 395   /* initialize memory interface */
 396   int err;
 397   /* if valid callback is passed as argument, fd event polling will be done by user
 398      all file descriptors and events will be passed to user in this callback */
 399   /* if callback is set to NULL libmemif will handle fd event polling */
 400   err = memif_init (NULL, APP_NAME, NULL, NULL, NULL);
 401   if (err != MEMIF_ERR_SUCCESS)
 402     INFO ("memif_init: %s", memif_strerror (err));
 403
 404   print_help ();
 405
 406   icmpr_memif_create (0);
 407   print_memif_details ();
 408
 409   /* main loop */
 410   while (1)
 411     {
 412       if (memif_poll_event (-1) < 0)
 413         {
 414           DBG ("poll_event error!");
 415         }
 416     }
 417 }