Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/nettest2/nettest2.c

    rb445803 rd9e2e0e  
    2828
    2929/** @addtogroup nettest
    30  * @{
     30 *  @{
    3131 */
    3232
    3333/** @file
    34  * Networking test 2 application - transfer.
    35  */
    36 
    37 #include "nettest.h"
    38 #include "print_error.h"
     34 *  Networking test 2 application - transfer.
     35 */
    3936
    4037#include <malloc.h>
    … …  
    5249#include <net/socket_parse.h>
    5350
    54 /** Echo module name. */
     51#include "nettest.h"
     52#include "print_error.h"
     53
     54/** Echo module name.
     55 */
    5556#define NAME    "Nettest2"
    5657
    57 /** Packet data pattern. */
     58/** Packet data pattern.
     59 */
    5860#define NETTEST2_TEXT   "Networking test 2 - transfer"
    5961
    60 static void nettest2_print_help(void)
    61 {
     62/** Module entry point.
     63 *  Starts testing.
     64 *  @param[in] argc The number of command line parameters.
     65 *  @param[in] argv The command line parameters.
     66 *  @returns EOK on success.
     67 */
     68int main(int argc, char * argv[]);
     69
     70/** Prints the application help.
     71 */
     72void nettest2_print_help(void);
     73
     74/** Refreshes the data.
     75 *  Fills the data block with the NETTEST1_TEXT pattern.
     76 *  @param[out] data The data block.
     77 *  @param[in] size The data block size in bytes.
     78 */
     79void nettest2_refresh_data(char * data, size_t size);
     80
     81int main(int argc, char * argv[]){
     82        ERROR_DECLARE;
     83
     84        size_t size                     = 28;
     85        int verbose                     = 0;
     86        sock_type_t type        = SOCK_DGRAM;
     87        int sockets                     = 10;
     88        int messages            = 10;
     89        int family                      = PF_INET;
     90        uint16_t port           = 7;
     91
     92        socklen_t max_length                            = sizeof(struct sockaddr_in6);
     93        uint8_t address_data[max_length];
     94        struct sockaddr * address                       = (struct sockaddr *) address_data;
     95        struct sockaddr_in * address_in         = (struct sockaddr_in *) address;
     96        struct sockaddr_in6 * address_in6       = (struct sockaddr_in6 *) address;
     97        socklen_t addrlen;
     98//      char address_string[INET6_ADDRSTRLEN];
     99        uint8_t * address_start;
     100
     101        int * socket_ids;
     102        char * data;
     103        int value;
     104        int index;
     105        struct timeval time_before;
     106        struct timeval time_after;
     107
     108        // parse the command line arguments
     109        // stop before the last argument if it does not start with the minus sign ('-')
     110        for(index = 1; (index < argc - 1) || ((index == argc - 1) && (argv[index][0] == '-')); ++ index){
     111                // options should start with the minus sign ('-')
     112                if(argv[index][0] == '-'){
     113                        switch(argv[index][1]){
     114                                // short options with only one letter
     115                                case 'f':
     116                                        ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &family, 0, socket_parse_protocol_family));
     117                                        break;
     118                                case 'h':
     119                                        nettest2_print_help();
     120                                        return EOK;
     121                                        break;
     122                                case 'm':
     123                                        ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &messages, 0));
     124                                        break;
     125                                case 'n':
     126                                        ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &sockets, 0));
     127                                        break;
     128                                case 'p':
     129                                        ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &value, 0));
     130                                        port = (uint16_t) value;
     131                                        break;
     132                                case 's':
     133                                        ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &value, 0));
     134                                        size = (value >= 0) ? (size_t) value : 0;
     135                                        break;
     136                                case 't':
     137                                        ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &value, 0, socket_parse_socket_type));
     138                                        type = (sock_type_t) value;
     139                                        break;
     140                                case 'v':
     141                                        verbose = 1;
     142                                        break;
     143                                // long options with the double minus sign ('-')
     144                                case '-':
     145                                        if(str_lcmp(argv[index] + 2, "family=", 7) == 0){
     146                                                ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &family, 9, socket_parse_protocol_family));
     147                                        }else if(str_lcmp(argv[index] + 2, "help", 5) == 0){
     148                                                nettest2_print_help();
     149                                                return EOK;
     150                                        }else if(str_lcmp(argv[index] + 2, "messages=", 6) == 0){
     151                                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &messages, 8));
     152                                        }else if(str_lcmp(argv[index] + 2, "sockets=", 6) == 0){
     153                                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &sockets, 8));
     154                                        }else if(str_lcmp(argv[index] + 2, "port=", 5) == 0){
     155                                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &value, 7));
     156                                                port = (uint16_t) value;
     157                                        }else if(str_lcmp(argv[index] + 2, "type=", 5) == 0){
     158                                                ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &value, 7, socket_parse_socket_type));
     159                                                type = (sock_type_t) value;
     160                                        }else if(str_lcmp(argv[index] + 2, "verbose", 8) == 0){
     161                                                verbose = 1;
     162                                        }else{
     163                                                nettest2_print_help();
     164                                                return EINVAL;
     165                                        }
     166                                        break;
     167                                default:
     168                                        nettest2_print_help();
     169                                        return EINVAL;
     170                        }
     171                }else{
     172                        nettest2_print_help();
     173                        return EINVAL;
     174                }
     175        }
     176
     177        // if not before the last argument containing the address
     178        if(index >= argc){
     179                printf("Command line error: missing address\n");
     180                nettest2_print_help();
     181                return EINVAL;
     182        }
     183
     184        // prepare the address buffer
     185        bzero(address_data, max_length);
     186        switch(family){
     187                case PF_INET:
     188                        address_in->sin_family = AF_INET;
     189                        address_in->sin_port = htons(port);
     190                        address_start = (uint8_t *) &address_in->sin_addr.s_addr;
     191                        addrlen = sizeof(struct sockaddr_in);
     192                        break;
     193                case PF_INET6:
     194                        address_in6->sin6_family = AF_INET6;
     195                        address_in6->sin6_port = htons(port);
     196                        address_start = (uint8_t *) &address_in6->sin6_addr.s6_addr;
     197                        addrlen = sizeof(struct sockaddr_in6);
     198                        break;
     199                default:
     200                        fprintf(stderr, "Address family is not supported\n");
     201                        return EAFNOSUPPORT;
     202        }
     203
     204        // parse the last argument which should contain the address
     205        if(ERROR_OCCURRED(inet_pton(family, argv[argc - 1], address_start))){
     206                fprintf(stderr, "Address parse error %d\n", ERROR_CODE);
     207                return ERROR_CODE;
     208        }
     209
     210        // check the buffer size
     211        if(size <= 0){
     212                fprintf(stderr, "Data buffer size too small (%d). Using 1024 bytes instead.\n", size);
     213                size = 1024;
     214        }
     215
     216        // prepare the buffer
     217        // size plus terminating null (\0)
     218        data = (char *) malloc(size + 1);
     219        if(! data){
     220                fprintf(stderr, "Failed to allocate data buffer.\n");
     221                return ENOMEM;
     222        }
     223        nettest2_refresh_data(data, size);
     224
     225        // check the socket count
     226        if(sockets <= 0){
     227                fprintf(stderr, "Socket count too small (%d). Using 2 instead.\n", sockets);
     228                sockets = 2;
     229        }
     230
     231        // prepare the socket buffer
     232        // count plus the terminating null (\0)
     233        socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
     234        if(! socket_ids){
     235                fprintf(stderr, "Failed to allocate receive buffer.\n");
     236                return ENOMEM;
     237        }
     238        socket_ids[sockets] = NULL;
     239
     240        if(verbose){
     241                printf("Starting tests\n");
     242        }
     243
     244        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, sockets, family, type));
     245
     246        if(type == SOCK_STREAM){
     247                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, sockets, address, addrlen));
     248        }
     249
     250        if(verbose){
     251                printf("\n");
     252        }
     253
     254        if(ERROR_OCCURRED(gettimeofday(&time_before, NULL))){
     255                fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
     256                return ERROR_CODE;
     257        }
     258
     259        ERROR_PROPAGATE(sockets_sendto_recvfrom(verbose, socket_ids, sockets, address, &addrlen, data, size, messages));
     260
     261        if(ERROR_OCCURRED(gettimeofday(&time_after, NULL))){
     262                fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
     263                return ERROR_CODE;
     264        }
     265
     266        if(verbose){
     267                printf("\tOK\n");
     268        }
     269
     270        printf("sendto + recvfrom tested in %d microseconds\n", tv_sub(&time_after, &time_before));
     271
     272        if(ERROR_OCCURRED(gettimeofday(&time_before, NULL))){
     273                fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
     274                return ERROR_CODE;
     275        }
     276
     277        ERROR_PROPAGATE(sockets_sendto(verbose, socket_ids, sockets, address, addrlen, data, size, messages));
     278        ERROR_PROPAGATE(sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen, data, size, messages));
     279
     280        if(ERROR_OCCURRED(gettimeofday(&time_after, NULL))){
     281                fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
     282                return ERROR_CODE;
     283        }
     284
     285        if(verbose){
     286                printf("\tOK\n");
     287        }
     288
     289        printf("sendto, recvfrom tested in %d microseconds\n", tv_sub(&time_after, &time_before));
     290
     291        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, sockets));
     292
     293        if(verbose){
     294                printf("\nExiting\n");
     295        }
     296
     297        return EOK;
     298}
     299
     300void nettest2_print_help(void){
    62301        printf(
    63302                "Network Networking test 2 aplication - UDP transfer\n" \
    … …  
    87326}
    88327
    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  */
    96 static void nettest2_refresh_data(char *data, size_t size)
    97 {
     328void nettest2_refresh_data(char * data, size_t size){
    98329        size_t length;
    99330
    100331        // fill the data
    101332        length = 0;
    102         while (size > length + sizeof(NETTEST2_TEXT) - 1) {
     333        while(size > length + sizeof(NETTEST2_TEXT) - 1){
    103334                memcpy(data + length, NETTEST2_TEXT, sizeof(NETTEST2_TEXT) - 1);
    104335                length += sizeof(NETTEST2_TEXT) - 1;
    … …  
    108339}
    109340
    110 
    111 int main(int argc, char *argv[])
    112 {
    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;
    133         int value;
    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                         }
    201                 } else {
    202                         nettest2_print_help();
    203                         return EINVAL;
    204                 }
    205         }
    206 
    207         // if not before the last argument containing the address
    208         if (index >= argc) {
    209                 printf("Command line error: missing address\n");
    210                 nettest2_print_help();
    211                 return EINVAL;
    212         }
    213 
    214         // prepare the address buffer
    215         bzero(address_data, max_length);
    216         switch (family) {
    217         case PF_INET:
    218                 address_in->sin_family = AF_INET;
    219                 address_in->sin_port = htons(port);
    220                 address_start = (uint8_t *) &address_in->sin_addr.s_addr;
    221                 addrlen = sizeof(struct sockaddr_in);
    222                 break;
    223         case PF_INET6:
    224                 address_in6->sin6_family = AF_INET6;
    225                 address_in6->sin6_port = htons(port);
    226                 address_start = (uint8_t *) &address_in6->sin6_addr.s6_addr;
    227                 addrlen = sizeof(struct sockaddr_in6);
    228                 break;
    229         default:
    230                 fprintf(stderr, "Address family is not supported\n");
    231                 return EAFNOSUPPORT;
    232         }
    233 
    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
    241         if (size <= 0) {
    242                 fprintf(stderr, "Data buffer size too small (%d). Using 1024 bytes instead.\n", size);
    243                 size = 1024;
    244         }
    245 
    246         // prepare the buffer
    247         // size plus terminating null (\0)
    248         data = (char *) malloc(size + 1);
    249         if (!data) {
    250                 fprintf(stderr, "Failed to allocate data buffer.\n");
    251                 return ENOMEM;
    252         }
    253         nettest2_refresh_data(data, size);
    254 
    255         // check the socket count
    256         if (sockets <= 0) {
    257                 fprintf(stderr, "Socket count too small (%d). Using 2 instead.\n", sockets);
    258                 sockets = 2;
    259         }
    260 
    261         // prepare the socket buffer
    262         // count plus the terminating null (\0)
    263         socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
    264         if (!socket_ids) {
    265                 fprintf(stderr, "Failed to allocate receive buffer.\n");
    266                 return ENOMEM;
    267         }
    268         socket_ids[sockets] = NULL;
    269 
    270         if (verbose)
    271                 printf("Starting tests\n");
    272 
    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));
    277 
    278         if (verbose)
    279                 printf("\n");
    280 
    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;
    291         }
    292 
    293         if (verbose)
    294                 printf("\tOK\n");
    295 
    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;
    309         }
    310 
    311         if (verbose)
    312                 printf("\tOK\n");
    313 
    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));
    317 
    318         if (verbose)
    319                 printf("\nExiting\n");
    320 
    321         return EOK;
    322 }
    323 
    324341/** @}
    325342 */
Note: See TracChangeset for help on using the changeset viewer.