Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/nettest2/nettest2.c

    rfff7ef4 r26de91a  
    3838#include "print_error.h"
    3939
     40#include <assert.h>
    4041#include <malloc.h>
    4142#include <stdio.h>
    … …  
    5556
    5657/** Echo module name. */
    57 #define NAME    "Nettest2"
     58#define NAME  "nettest2"
    5859
    5960/** Packet data pattern. */
    60 #define NETTEST2_TEXT   "Networking test 2 - transfer"
    61 
    62 static size_t size;
    63 static bool verbose;
    64 static sock_type_t type;
    65 static int sockets;
    66 static int messages;
    67 static int family;
    68 static uint16_t port;
     61#define NETTEST2_TEXT  "Networking test 2 - transfer"
     62
     63static uint16_t family = AF_NONE;
     64static size_t size = 28;
     65static bool verbose = false;
     66static sock_type_t type = SOCK_DGRAM;
     67static int sockets = 10;
     68static int messages = 10;
     69static uint16_t port = 7;
    6970
    7071static void nettest2_print_help(void)
    … …  
    107108static void nettest2_fill_buffer(char *buffer, size_t size)
    108109{
    109         size_t length;
    110 
    111         length = 0;
     110        size_t length = 0;
    112111        while (size > length + sizeof(NETTEST2_TEXT) - 1) {
    113112                memcpy(buffer + length, NETTEST2_TEXT,
    … …  
    115114                length += sizeof(NETTEST2_TEXT) - 1;
    116115        }
    117 
     116       
    118117        memcpy(buffer + length, NETTEST2_TEXT, size - length);
    119118        buffer[size] = '\0';
    … …  
    130129        int value;
    131130        int rc;
    132 
     131       
    133132        switch (argv[*index][1]) {
    134133        /*
    … …  
    136135         */
    137136        case 'f':
    138                 rc = arg_parse_name_int(argc, argv, index, &family, 0,
     137                rc = arg_parse_name_int(argc, argv, index, &value, 0,
    139138                    socket_parse_protocol_family);
    140139                if (rc != EOK)
    141140                        return rc;
     141               
     142                family = (uint16_t) value;
    142143                break;
    143144        case 'h':
    144145                nettest2_print_help();
    145146                return EOK;
    146                 break;
    147147        case 'm':
    148148                rc = arg_parse_int(argc, argv, index, &messages, 0);
    149149                if (rc != EOK)
    150150                        return rc;
     151               
    151152                break;
    152153        case 'n':
    … …  
    154155                if (rc != EOK)
    155156                        return rc;
     157               
    156158                break;
    157159        case 'p':
    … …  
    159161                if (rc != EOK)
    160162                        return rc;
     163               
    161164                port = (uint16_t) value;
    162165                break;
    … …  
    165168                if (rc != EOK)
    166169                        return rc;
     170               
    167171                size = (value >= 0) ? (size_t) value : 0;
    168172                break;
    … …  
    172176                if (rc != EOK)
    173177                        return rc;
     178               
    174179                type = (sock_type_t) value;
    175180                break;
    … …  
    177182                verbose = true;
    178183                break;
     184       
    179185        /*
    180186         * Long options with double dash ('-')
    … …  
    182188        case '-':
    183189                if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
    184                         rc = arg_parse_name_int(argc, argv, index, &family, 9,
     190                        rc = arg_parse_name_int(argc, argv, index, &value, 9,
    185191                            socket_parse_protocol_family);
    186192                        if (rc != EOK)
    187193                                return rc;
     194                       
     195                        family = (uint16_t) value;
    188196                } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
    189197                        nettest2_print_help();
    … …  
    201209                        if (rc != EOK)
    202210                                return rc;
     211                       
    203212                        port = (uint16_t) value;
    204213                } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
    … …  
    207216                        if (rc != EOK)
    208217                                return rc;
     218                       
    209219                        type = (sock_type_t) value;
    210220                } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
    … …  
    219229                return EINVAL;
    220230        }
    221 
     231       
    222232        return EOK;
    223233}
    … …  
    225235int main(int argc, char *argv[])
    226236{
    227         struct sockaddr *address;
    228         struct sockaddr_in address_in;
    229         struct sockaddr_in6 address_in6;
    230         dnsr_hostinfo_t *hinfo;
    231         socklen_t addrlen;
    232         uint8_t *address_start;
    233 
    234         int *socket_ids;
    235         char *data;
    236237        int index;
    237         struct timeval time_before;
    238         struct timeval time_after;
    239 
    240238        int rc;
    241 
    242         size = 28;
    243         verbose = false;
    244         type = SOCK_DGRAM;
    245         sockets = 10;
    246         messages = 10;
    247         family = PF_INET;
    248         port = 7;
    249 
     239       
    250240        /*
    251241         * Parse the command line arguments.
    … …  
    255245        for (index = 1; (index < argc - 1) || ((index == argc - 1) &&
    256246            (argv[index][0] == '-')); ++index) {
    257 
    258247                /* Options should start with dash ('-') */
    259248                if (argv[index][0] == '-') {
    … …  
    266255                }
    267256        }
    268 
    269         /* If not before the last argument containing the host */
     257       
     258        /* The last argument containing the host */
    270259        if (index >= argc) {
    271                 printf("Command line error: missing host name\n");
     260                printf("Host name missing.\n");
    272261                nettest2_print_help();
    273262                return EINVAL;
    274263        }
    275 
    276         /* Prepare the address buffer */
    277 
    278         switch (family) {
    279         case PF_INET:
    280                 address_in.sin_family = AF_INET;
    281                 address_in.sin_port = htons(port);
    282                 address = (struct sockaddr *) &address_in;
    283                 addrlen = sizeof(address_in);
    284                 address_start = (uint8_t *) &address_in.sin_addr.s_addr;
    285                 break;
    286         case PF_INET6:
    287                 address_in6.sin6_family = AF_INET6;
    288                 address_in6.sin6_port = htons(port);
    289                 address = (struct sockaddr *) &address_in6;
    290                 addrlen = sizeof(address_in6);
    291                 address_start = (uint8_t *) &address_in6.sin6_addr.s6_addr;
    292                 break;
    293         default:
    294                 fprintf(stderr, "Address family is not supported\n");
    295                 return EAFNOSUPPORT;
    296         }
    297 
    298         /* Parse the last argument which should contain the host/address */
    299         rc = inet_pton(family, argv[argc - 1], address_start);
    300         if (rc != EOK) {
    301                 /* Try interpreting as a host name */
    302                 rc = dnsr_name2host(argv[argc - 1], &hinfo);
     264       
     265        char *addr_s = argv[argc - 1];
     266       
     267        /* Interpret as address */
     268        inet_addr_t addr_addr;
     269        rc = inet_addr_parse(addr_s, &addr_addr);
     270       
     271        if (rc != EOK) {
     272                /* Interpret as a host name */
     273                dnsr_hostinfo_t *hinfo = NULL;
     274                rc = dnsr_name2host(addr_s, &hinfo, ipver_from_af(family));
     275               
    303276                if (rc != EOK) {
    304                         printf("Error resolving host '%s'.\n", argv[argc - 1]);
    305                         return rc;
     277                        printf("Error resolving host '%s'.\n", addr_s);
     278                        return EINVAL;
    306279                }
    307 
    308                 address_in.sin_addr.s_addr = host2uint32_t_be(hinfo->addr.ipv4);
    309         }
    310 
     280               
     281                addr_addr = hinfo->addr;
     282        }
     283       
     284        struct sockaddr *address;
     285        socklen_t addrlen;
     286        rc = inet_addr_sockaddr(&addr_addr, port, &address, &addrlen);
     287        if (rc != EOK) {
     288                assert(rc == ENOMEM);
     289                printf("Out of memory.\n");
     290                return ENOMEM;
     291        }
     292       
     293        if (family == AF_NONE)
     294                family = address->sa_family;
     295       
     296        if (address->sa_family != family) {
     297                printf("Address family does not match explicitly set family.\n");
     298                return EINVAL;
     299        }
     300       
    311301        /* Check data buffer size. */
    312302        if (size <= 0) {
    … …  
    315305                size = 1024;
    316306        }
    317 
     307       
    318308        /*
    319309         * Prepare the buffer. Allocate size bytes plus one for terminating
    320310         * null character.
    321311         */
    322         data = (char *) malloc(size + 1);
     312        char *data = (char *) malloc(size + 1);
    323313        if (!data) {
    324314                fprintf(stderr, "Failed to allocate data buffer.\n");
    325315                return ENOMEM;
    326316        }
    327 
     317       
    328318        /* Fill buffer with a pattern. */
    329319        nettest2_fill_buffer(data, size);
    330 
     320       
    331321        /* Check socket count. */
    332322        if (sockets <= 0) {
    … …  
    335325                sockets = 2;
    336326        }
    337 
     327       
    338328        /*
    339329         * Prepare the socket buffer.
    340330         * Allocate count entries plus the terminating null (\0)
    341331         */
    342         socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
     332        int *socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
    343333        if (!socket_ids) {
    344334                fprintf(stderr, "Failed to allocate receive buffer.\n");
    345335                return ENOMEM;
    346336        }
     337       
    347338        socket_ids[sockets] = 0;
    348 
     339       
    349340        if (verbose)
    350341                printf("Starting tests\n");
    351 
     342       
    352343        rc = sockets_create(verbose, socket_ids, sockets, family, type);
    353344        if (rc != EOK)
    354345                return rc;
    355 
     346       
    356347        if (type == SOCK_STREAM) {
    357348                rc = sockets_connect(verbose, socket_ids, sockets,
    … …  
    360351                        return rc;
    361352        }
    362 
     353       
    363354        if (verbose)
    364355                printf("\n");
    365 
     356       
     357        struct timeval time_before;
    366358        rc = gettimeofday(&time_before, NULL);
    367359        if (rc != EOK) {
    … …  
    369361                return rc;
    370362        }
    371 
     363       
    372364        rc = sockets_sendto_recvfrom(verbose, socket_ids, sockets, address,
    373             &addrlen, data, size, messages);
     365            &addrlen, data, size, messages, type);
    374366        if (rc != EOK)
    375367                return rc;
    376 
     368       
     369        struct timeval time_after;
    377370        rc = gettimeofday(&time_after, NULL);
    378371        if (rc != EOK) {
    … …  
    380373                return rc;
    381374        }
    382 
     375       
    383376        if (verbose)
    384377                printf("\tOK\n");
    385 
     378       
    386379        printf("sendto + recvfrom tested in %ld microseconds\n",
    387380            tv_sub(&time_after, &time_before));
    388 
     381       
    389382        rc = gettimeofday(&time_before, NULL);
    390383        if (rc != EOK) {
    … …  
    392385                return rc;
    393386        }
    394 
     387       
    395388        rc = sockets_sendto(verbose, socket_ids, sockets, address, addrlen,
    396             data, size, messages);
     389            data, size, messages, type);
    397390        if (rc != EOK)
    398391                return rc;
    399 
     392       
    400393        rc = sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen,
    401394            data, size, messages);
    402395        if (rc != EOK)
    403396                return rc;
    404 
     397       
    405398        rc = gettimeofday(&time_after, NULL);
    406399        if (rc != EOK) {
    … …  
    408401                return rc;
    409402        }
    410 
     403       
    411404        if (verbose)
    412405                printf("\tOK\n");
    413 
     406       
    414407        printf("sendto, recvfrom tested in %ld microseconds\n",
    415408            tv_sub(&time_after, &time_before));
    416 
     409       
    417410        rc = sockets_close(verbose, socket_ids, sockets);
    418411        if (rc != EOK)
    419412                return rc;
    420 
     413       
     414        free(address);
     415       
    421416        if (verbose)
    422417                printf("\nExiting\n");
    423 
     418       
    424419        return EOK;
    425420}
Note: See TracChangeset for help on using the changeset viewer.