static int parse_app_args()

in metron-sensors/fastcapa/src/args.c [81:229]

• 113 lines of code
• 22 McCabe index (conditional complexity)

static int parse_app_args(int argc, char** argv, app_params* p)
{
    int opt;
    char** argvopt;
    int option_index;
    unsigned int nb_workers;
    static struct option lgopts[] = {
        { NULL, 0, 0, 0 }
    };

    // set default args
    p->enabled_port_mask = parse_portmask(STR(DEFAULT_PORT_MASK));
    p->kafka_topic = STR(DEFAULT_KAFKA_TOPIC);
    p->rx_burst_size = DEFAULT_RX_BURST_SIZE;
    p->tx_burst_size = DEFAULT_TX_BURST_SIZE;
    p->nb_rx_desc = DEFAULT_NB_RX_DESC;
    p->nb_rx_queue = DEFAULT_NB_RX_QUEUE;
    p->tx_ring_size = DEFAULT_TX_RING_SIZE;

    // parse arguments to this application
    argvopt = argv;
    while ((opt = getopt_long(argc, argvopt, "b:c:d:hp:q:s:t:w:x:", lgopts, &option_index)) != EOF) {
        switch (opt) {

            // help
            case 'h':
                print_usage();
                return -1;

            // rx burst size
            case 'b':
                p->rx_burst_size = atoi(optarg);
                if(p->rx_burst_size < 1 || p->rx_burst_size > MAX_RX_BURST_SIZE) {
                    fprintf(stderr, "Invalid burst size; burst=%u must be in [1, %u]. \n", p->rx_burst_size, MAX_RX_BURST_SIZE);
                    print_usage();
                    return -1;
                }
                break;

            // tx burst size
            case 'w':
                p->tx_burst_size = atoi(optarg);
                if(p->tx_burst_size < 1) {
                    fprintf(stderr, "Invalid burst size; burst=%u must be > 0. \n", p->tx_burst_size);
                    print_usage();
                    return -1;
                }
                break;

            // number of receive descriptors
            case 'd':
                p->nb_rx_desc = atoi(optarg);
                if (p->nb_rx_desc < 1) {
                    fprintf(stderr, "Invalid num of receive descriptors: '%s' \n", optarg);
                    print_usage();
                    return -1;
                }
                break;

            // size of each transmit ring
            case 'x':
                p->tx_ring_size = atoi(optarg);

                break;

            // number of receive queues for each device
            case 'q':
                p->nb_rx_queue = atoi(optarg);
                if (p->nb_rx_queue < 1) {
                    fprintf(stderr, "Invalid num of receive queues: '%s' \n", optarg);
                    print_usage();
                    return -1;
                }
                break;

          // port mask
          case 'p':
              p->enabled_port_mask = parse_portmask(optarg);
              if (p->enabled_port_mask == 0) {
                  fprintf(stderr, "Invalid portmask: '%s'\n", optarg);
                  print_usage();
                  return -1;
              }
              break;

          // kafka topic
          case 't':
              p->kafka_topic = strdup(optarg);
              if (!valid(p->kafka_topic)) {
                  printf("Invalid kafka topic: '%s'\n", optarg);
                  print_usage();
                  return -1;
              }
              break;

          // kafka config path
          case 'c':
              p->kafka_config_path = strdup(optarg);
              if (!valid(p->kafka_config_path) || !file_exists(p->kafka_config_path)) {
                  fprintf(stderr, "Invalid kafka config: '%s'\n", optarg);
                  print_usage();
                  return -1;
              }
              break;

          // kafka stats path
          case 's':
              p->kafka_stats_path = strdup(optarg);
              break;

          default:
              print_usage();
              return -1;
          }
    }

    // check number of ethernet devices
    if (rte_eth_dev_count() == 0) {
         rte_exit(EXIT_FAILURE, "No ethernet ports detected.\n");
     }

    // check number of workers
    nb_workers = rte_lcore_count() - 1;

    // need at least 1 worker for each receive queue
    if(nb_workers < p->nb_rx_queue) {
        rte_exit(EXIT_FAILURE, "Minimum 1 worker per receive queue; workers=%u rx_queues=%u. \n",
            nb_workers, p->nb_rx_queue);
    }

    p->nb_rx_workers = p->nb_rx_queue;
    p->nb_tx_workers = nb_workers - p->nb_rx_workers;

    printf("[ -p PORT_MASK ] defined as %d \n", p->enabled_port_mask);
    printf("[ -b RX_BURST_SIZE ] defined as %d \n", p->rx_burst_size);
    printf("[ -w TX_BURST_SIZE ] defined as %d \n", p->tx_burst_size);
    printf("[ -d NB_RX_DESC ] defined as %d \n", p->nb_rx_desc);
    printf("[ -x TX_RING_SIZE ] defined as %d \n", p->tx_ring_size);
    printf("[ -q NB_RX_QUEUE ] defined as %d \n", p->nb_rx_queue);
    printf("[ -t KAFKA_TOPIC ] defined as %s \n", p->kafka_topic);
    printf("[ -c KAFKA_CONFIG ] defined as %s \n", p->kafka_config_path);
    printf("[ -s KAFKA_STATS ] defined as %s \n", p->kafka_stats_path);
    printf("[ NUM_RX_WORKERS ] defined as %d \n", p->nb_rx_workers);
    printf("[ NUM_TX_WORKERS ] defined as %d \n", p->nb_tx_workers);

    // reset getopt lib
    optind = 0;
    return 0;
}