Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/nettest2/nettest2.c

    r69e0d6d rb445803  
    4444#include <time.h>
    4545#include <arg_parse.h>
    46 #include <bool.h>
     46#include <err.h>
    4747
    4848#include <net/in.h>
    … …  
    5858#define NETTEST2_TEXT   "Networking test 2 - transfer"
    5959
    60 static size_t size;
    61 static bool verbose;
    62 static sock_type_t type;
    63 static int sockets;
    64 static int messages;
    65 static int family;
    66 static uint16_t port;
    67 
    6860static void nettest2_print_help(void)
    6961{
    7062        printf(
    71             "Network Networking test 2 aplication - UDP transfer\n"
    72             "Usage: echo [options] address\n"
    73             "Where options are:\n"
    74             "-f protocol_family | --family=protocol_family\n"
    75             "\tThe listenning socket protocol family. Only the PF_INET and "
    76             "PF_INET6 are supported.\n"
    77             "\n"
    78             "-h | --help\n"
    79             "\tShow this application help.\n"
    80             "\n"
    81             "-m count | --messages=count\n"
    82             "\tThe number of messages to send and receive per socket. The "
    83             "default is 10.\n"
    84             "\n"
    85             "-n sockets | --sockets=count\n"
    86             "\tThe number of sockets to use. The default is 10.\n"
    87             "\n"
    88             "-p port_number | --port=port_number\n"
    89             "\tThe port number the application should send messages to. The "
    90             "default is 7.\n"
    91             "\n"
    92             "-s packet_size | --size=packet_size\n"
    93             "\tThe packet data size the application sends. The default is 29 "
    94             "bytes.\n"
    95             "\n"
    96             "-v | --verbose\n"
    97             "\tShow all output messages.\n");
     63                "Network Networking test 2 aplication - UDP transfer\n" \
     64                "Usage: echo [options] numeric_address\n" \
     65                "Where options are:\n" \
     66                "-f protocol_family | --family=protocol_family\n" \
     67                "\tThe listenning socket protocol family. Only the PF_INET and PF_INET6 are supported.\n"
     68                "\n" \
     69                "-h | --help\n" \
     70                "\tShow this application help.\n"
     71                "\n" \
     72                "-m count | --messages=count\n" \
     73                "\tThe number of messages to send and receive per socket. The default is 10.\n" \
     74                "\n" \
     75                "-n sockets | --sockets=count\n" \
     76                "\tThe number of sockets to use. The default is 10.\n" \
     77                "\n" \
     78                "-p port_number | --port=port_number\n" \
     79                "\tThe port number the application should send messages to. The default is 7.\n" \
     80                "\n" \
     81                "-s packet_size | --size=packet_size\n" \
     82                "\tThe packet data size the application sends. The default is 29 bytes.\n" \
     83                "\n" \
     84                "-v | --verbose\n" \
     85                "\tShow all output messages.\n"
     86        );
    9887}
    9988
    100 /** Fill buffer with the NETTEST2_TEXT pattern.
    101  *
    102  * @param buffer        Data buffer.
    103  * @param size          Buffer size in bytes.
    104  */
    105 static void nettest2_fill_buffer(char *buffer, size_t size)
     89/** Refreshes the data.
     90 *
     91 * Fills the data block with the NETTEST1_TEXT pattern.
     92 *
     93 * @param[out] data The data block.
     94 * @param[in] size The data block size in bytes.
     95 */
     96static void nettest2_refresh_data(char *data, size_t size)
    10697{
    10798        size_t length;
    10899
     100        // fill the data
    109101        length = 0;
    110102        while (size > length + sizeof(NETTEST2_TEXT) - 1) {
    111                 memcpy(buffer + length, NETTEST2_TEXT,
    112                     sizeof(NETTEST2_TEXT) - 1);
     103                memcpy(data + length, NETTEST2_TEXT, sizeof(NETTEST2_TEXT) - 1);
    113104                length += sizeof(NETTEST2_TEXT) - 1;
    114105        }
    115 
    116         memcpy(buffer + length, NETTEST2_TEXT, size - length);
    117         buffer[size] = '\0';
     106        memcpy(data + length, NETTEST2_TEXT, size - length);
     107        data[size] = '\0';
    118108}
    119109
    120 /** Parse one command-line option.
    121  *
    122  * @param argc          Number of all command-line arguments.
    123  * @param argv          All command-line arguments.
    124  * @param index         Current argument index (in, out).
    125  */
    126 static int nettest2_parse_opt(int argc, char *argv[], int *index)
     110
     111int main(int argc, char *argv[])
    127112{
     113        ERROR_DECLARE;
     114
     115        size_t size = 28;
     116        int verbose = 0;
     117        sock_type_t type = SOCK_DGRAM;
     118        int sockets = 10;
     119        int messages = 10;
     120        int family = PF_INET;
     121        uint16_t port = 7;
     122
     123        socklen_t max_length = sizeof(struct sockaddr_in6);
     124        uint8_t address_data[max_length];
     125        struct sockaddr *address = (struct sockaddr *) address_data;
     126        struct sockaddr_in *address_in = (struct sockaddr_in *) address;
     127        struct sockaddr_in6 *address_in6 = (struct sockaddr_in6 *) address;
     128        socklen_t addrlen;
     129        uint8_t *address_start;
     130
     131        int *socket_ids;
     132        char *data;
    128133        int value;
    129         int rc;
    130 
    131         switch (argv[*index][1]) {
    132         /*
    133          * Short options with only one letter
    134          */
    135         case 'f':
    136                 rc = arg_parse_name_int(argc, argv, index, &family, 0,
    137                     socket_parse_protocol_family);
    138                 if (rc != EOK)
    139                         return rc;
    140                 break;
    141         case 'h':
    142                 nettest2_print_help();
    143                 return EOK;
    144                 break;
    145         case 'm':
    146                 rc = arg_parse_int(argc, argv, index, &messages, 0);
    147                 if (rc != EOK)
    148                         return rc;
    149                 break;
    150         case 'n':
    151                 rc = arg_parse_int(argc, argv, index, &sockets, 0);
    152                 if (rc != EOK)
    153                         return rc;
    154                 break;
    155         case 'p':
    156                 rc = arg_parse_int(argc, argv, index, &value, 0);
    157                 if (rc != EOK)
    158                         return rc;
    159                 port = (uint16_t) value;
    160                 break;
    161         case 's':
    162                 rc = arg_parse_int(argc, argv, index, &value, 0);
    163                 if (rc != EOK)
    164                         return rc;
    165                 size = (value >= 0) ? (size_t) value : 0;
    166                 break;
    167         case 't':
    168                 rc = arg_parse_name_int(argc, argv, index, &value, 0,
    169                     socket_parse_socket_type);
    170                 if (rc != EOK)
    171                         return rc;
    172                 type = (sock_type_t) value;
    173                 break;
    174         case 'v':
    175                 verbose = true;
    176                 break;
    177         /*
    178          * Long options with double dash ('-')
    179          */
    180         case '-':
    181                 if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
    182                         rc = arg_parse_name_int(argc, argv, index, &family, 9,
    183                             socket_parse_protocol_family);
    184                         if (rc != EOK)
    185                                 return rc;
    186                 } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
    187                         nettest2_print_help();
    188                         return EOK;
    189                 } else if (str_lcmp(argv[*index] + 2, "messages=", 6) == 0) {
    190                         rc = arg_parse_int(argc, argv, index, &messages, 8);
    191                         if (rc != EOK)
    192                                 return rc;
    193                 } else if (str_lcmp(argv[*index] + 2, "sockets=", 6) == 0) {
    194                         rc = arg_parse_int(argc, argv, index, &sockets, 8);
    195                         if (rc != EOK)
    196                                 return rc;
    197                 } else if (str_lcmp(argv[*index] + 2, "port=", 5) == 0) {
    198                         rc = arg_parse_int(argc, argv, index, &value, 7);
    199                         if (rc != EOK)
    200                                 return rc;
    201                         port = (uint16_t) value;
    202                 } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
    203                         rc = arg_parse_name_int(argc, argv, index, &value, 7,
    204                             socket_parse_socket_type);
    205                         if (rc != EOK)
    206                                 return rc;
    207                         type = (sock_type_t) value;
    208                 } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
    209                         verbose = 1;
     134        int index;
     135        struct timeval time_before;
     136        struct timeval time_after;
     137
     138        // parse the command line arguments
     139        // stop before the last argument if it does not start with the minus sign ('-')
     140        for (index = 1; (index < argc - 1) || ((index == argc - 1) && (argv[index][0] == '-')); ++ index) {
     141                // options should start with the minus sign ('-')
     142                if (argv[index][0] == '-') {
     143                        switch(argv[index][1]){
     144                        // short options with only one letter
     145                        case 'f':
     146                                ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &family, 0, socket_parse_protocol_family));
     147                                break;
     148                        case 'h':
     149                                nettest2_print_help();
     150                                return EOK;
     151                                break;
     152                        case 'm':
     153                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &messages, 0));
     154                                break;
     155                        case 'n':
     156                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &sockets, 0));
     157                                break;
     158                        case 'p':
     159                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &value, 0));
     160                                port = (uint16_t) value;
     161                                break;
     162                        case 's':
     163                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &value, 0));
     164                                size = (value >= 0) ? (size_t) value : 0;
     165                                break;
     166                        case 't':
     167                                ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &value, 0, socket_parse_socket_type));
     168                                type = (sock_type_t) value;
     169                                break;
     170                        case 'v':
     171                                verbose = 1;
     172                                break;
     173                        // long options with the double minus sign ('-')
     174                        case '-':
     175                                if (str_lcmp(argv[index] + 2, "family=", 7) == 0) {
     176                                        ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &family, 9, socket_parse_protocol_family));
     177                                } else if (str_lcmp(argv[index] + 2, "help", 5) == 0) {
     178                                        nettest2_print_help();
     179                                        return EOK;
     180                                } else if (str_lcmp(argv[index] + 2, "messages=", 6) == 0) {
     181                                        ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &messages, 8));
     182                                } else if (str_lcmp(argv[index] + 2, "sockets=", 6) == 0) {
     183                                        ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &sockets, 8));
     184                                } else if (str_lcmp(argv[index] + 2, "port=", 5) == 0) {
     185                                        ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &value, 7));
     186                                        port = (uint16_t) value;
     187                                } else if (str_lcmp(argv[index] + 2, "type=", 5) == 0) {
     188                                        ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &value, 7, socket_parse_socket_type));
     189                                        type = (sock_type_t) value;
     190                                } else if (str_lcmp(argv[index] + 2, "verbose", 8) == 0) {
     191                                        verbose = 1;
     192                                } else {
     193                                        nettest2_print_help();
     194                                        return EINVAL;
     195                                }
     196                                break;
     197                        default:
     198                                nettest2_print_help();
     199                                return EINVAL;
     200                        }
    210201                } else {
    211202                        nettest2_print_help();
    212203                        return EINVAL;
    213204                }
    214                 break;
    215         default:
    216                 nettest2_print_help();
    217                 return EINVAL;
    218         }
    219 
    220         return EOK;
    221 }
    222 
    223 int main(int argc, char *argv[])
    224 {
    225         socklen_t max_length;
    226         uint8_t address_data[sizeof(struct sockaddr_in6)];
    227         struct sockaddr *address;
    228         struct sockaddr_in *address_in;
    229         struct sockaddr_in6 *address_in6;
    230         socklen_t addrlen;
    231         uint8_t *address_start;
    232 
    233         int *socket_ids;
    234         char *data;
    235         int index;
    236         struct timeval time_before;
    237         struct timeval time_after;
    238 
    239         int rc;
    240 
    241         size = 28;
    242         verbose = false;
    243         type = SOCK_DGRAM;
    244         sockets = 10;
    245         messages = 10;
    246         family = PF_INET;
    247         port = 7;
    248 
    249         max_length = sizeof(address_data);
    250         address = (struct sockaddr *) address_data;
    251         address_in = (struct sockaddr_in *) address;
    252         address_in6 = (struct sockaddr_in6 *) address;
    253 
    254         /*
    255          * Parse the command line arguments.
    256          *
    257          * Stop before the last argument if it does not start with dash ('-')
    258          */
    259         for (index = 1; (index < argc - 1) || ((index == argc - 1) &&
    260             (argv[index][0] == '-')); ++index) {
    261 
    262                 /* Options should start with dash ('-') */
    263                 if (argv[index][0] == '-') {
    264                         rc = nettest2_parse_opt(argc, argv, &index);
    265                         if (rc != EOK)
    266                                 return rc;
    267                 } else {
    268                         nettest2_print_help();
    269                         return EINVAL;
    270                 }
    271         }
    272 
    273         /* If not before the last argument containing the address */
     205        }
     206
     207        // if not before the last argument containing the address
    274208        if (index >= argc) {
    275209                printf("Command line error: missing address\n");
    … …  
    278212        }
    279213
    280         /* Prepare the address buffer */
     214        // prepare the address buffer
    281215        bzero(address_data, max_length);
    282 
    283216        switch (family) {
    284217        case PF_INET:
    … …  
    299232        }
    300233
    301         /* Parse the last argument which should contain the address. */
    302         rc = inet_pton(family, argv[argc - 1], address_start);
    303         if (rc != EOK) {
    304                 fprintf(stderr, "Address parse error %d\n", rc);
    305                 return rc;
    306         }
    307 
    308         /* Check data buffer size. */
     234        // parse the last argument which should contain the address
     235        if (ERROR_OCCURRED(inet_pton(family, argv[argc - 1], address_start))) {
     236                fprintf(stderr, "Address parse error %d\n", ERROR_CODE);
     237                return ERROR_CODE;
     238        }
     239
     240        // check the buffer size
    309241        if (size <= 0) {
    310                 fprintf(stderr, "Data buffer size too small (%d). Using 1024 "
    311                     "bytes instead.\n", size);
     242                fprintf(stderr, "Data buffer size too small (%d). Using 1024 bytes instead.\n", size);
    312243                size = 1024;
    313244        }
    314245
    315         /*
    316          * Prepare the buffer. Allocate size bytes plus one for terminating
    317          * null character.
    318          */
     246        // prepare the buffer
     247        // size plus terminating null (\0)
    319248        data = (char *) malloc(size + 1);
    320249        if (!data) {
    … …  
    322251                return ENOMEM;
    323252        }
    324 
    325         /* Fill buffer with a pattern. */
    326         nettest2_fill_buffer(data, size);
    327 
    328         /* Check socket count. */
     253        nettest2_refresh_data(data, size);
     254
     255        // check the socket count
    329256        if (sockets <= 0) {
    330                 fprintf(stderr, "Socket count too small (%d). Using "
    331                     "2 instead.\n", sockets);
     257                fprintf(stderr, "Socket count too small (%d). Using 2 instead.\n", sockets);
    332258                sockets = 2;
    333259        }
    334260
    335         /*
    336          * Prepare the socket buffer.
    337          * Allocate count entries plus the terminating null (\0)
    338          */
     261        // prepare the socket buffer
     262        // count plus the terminating null (\0)
    339263        socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
    340264        if (!socket_ids) {
    … …  
    347271                printf("Starting tests\n");
    348272
    349         rc = sockets_create(verbose, socket_ids, sockets, family, type);
    350         if (rc != EOK)
    351                 return rc;
    352 
    353         if (type == SOCK_STREAM) {
    354                 rc = sockets_connect(verbose, socket_ids, sockets,
    355                     address, addrlen);
    356                 if (rc != EOK)
    357                         return rc;
    358         }
     273        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, sockets, family, type));
     274
     275        if (type == SOCK_STREAM)
     276                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, sockets, address, addrlen));
    359277
    360278        if (verbose)
    361279                printf("\n");
    362280
    363         rc = gettimeofday(&time_before, NULL);
    364         if (rc != EOK) {
    365                 fprintf(stderr, "Get time of day error %d\n", rc);
    366                 return rc;
    367         }
    368 
    369         rc = sockets_sendto_recvfrom(verbose, socket_ids, sockets, address,
    370             &addrlen, data, size, messages);
    371         if (rc != EOK)
    372                 return rc;
    373 
    374         rc = gettimeofday(&time_after, NULL);
    375         if (rc != EOK) {
    376                 fprintf(stderr, "Get time of day error %d\n", rc);
    377                 return rc;
     281        if (ERROR_OCCURRED(gettimeofday(&time_before, NULL))) {
     282                fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
     283                return ERROR_CODE;
     284        }
     285
     286        ERROR_PROPAGATE(sockets_sendto_recvfrom(verbose, socket_ids, sockets, address, &addrlen, data, size, messages));
     287
     288        if (ERROR_OCCURRED(gettimeofday(&time_after, NULL))) {
     289                fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
     290                return ERROR_CODE;
    378291        }
    379292
    … …  
    381294                printf("\tOK\n");
    382295
    383         printf("sendto + recvfrom tested in %d microseconds\n",
    384             tv_sub(&time_after, &time_before));
    385 
    386         rc = gettimeofday(&time_before, NULL);
    387         if (rc != EOK) {
    388                 fprintf(stderr, "Get time of day error %d\n", rc);
    389                 return rc;
    390         }
    391 
    392         rc = sockets_sendto(verbose, socket_ids, sockets, address, addrlen,
    393             data, size, messages);
    394         if (rc != EOK)
    395                 return rc;
    396 
    397         rc = sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen,
    398             data, size, messages);
    399         if (rc != EOK)
    400                 return rc;
    401 
    402         rc = gettimeofday(&time_after, NULL);
    403         if (rc != EOK) {
    404                 fprintf(stderr, "Get time of day error %d\n", rc);
    405                 return rc;
     296        printf("sendto + recvfrom tested in %d microseconds\n", tv_sub(&time_after, &time_before));
     297
     298        if (ERROR_OCCURRED(gettimeofday(&time_before, NULL))) {
     299                fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
     300                return ERROR_CODE;
     301        }
     302
     303        ERROR_PROPAGATE(sockets_sendto(verbose, socket_ids, sockets, address, addrlen, data, size, messages));
     304        ERROR_PROPAGATE(sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen, data, size, messages));
     305
     306        if (ERROR_OCCURRED(gettimeofday(&time_after, NULL))) {
     307                fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
     308                return ERROR_CODE;
    406309        }
    407310
    … …  
    409312                printf("\tOK\n");
    410313
    411         printf("sendto, recvfrom tested in %d microseconds\n",
    412             tv_sub(&time_after, &time_before));
    413 
    414         rc = sockets_close(verbose, socket_ids, sockets);
    415         if (rc != EOK)
    416                 return rc;
     314        printf("sendto, recvfrom tested in %d microseconds\n", tv_sub(&time_after, &time_before));
     315
     316        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, sockets));
    417317
    418318        if (verbose)
Note: See TracChangeset for help on using the changeset viewer.