Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/nettest2/nettest2.c

    r02a09ed r7e752b2  
    4040#include <malloc.h>
    4141#include <stdio.h>
    42 #include <unistd.h>
    4342#include <str.h>
    4443#include <task.h>
    4544#include <time.h>
    4645#include <arg_parse.h>
    47 #include <stdbool.h>
    48 
    49 #include <inet/dnsr.h>
     46#include <bool.h>
     47
    5048#include <net/in.h>
    5149#include <net/in6.h>
    … …  
    5553
    5654/** Echo module name. */
    57 #define NAME  "nettest2"
     55#define NAME    "Nettest2"
    5856
    5957/** Packet data pattern. */
    60 #define NETTEST2_TEXT  "Networking test 2 - transfer"
    61 
    62 static uint16_t family = PF_INET;
    63 static size_t size = 28;
    64 static bool verbose = false;
    65 static sock_type_t type = SOCK_DGRAM;
    66 static int sockets = 10;
    67 static int messages = 10;
    68 static uint16_t port = 7;
     58#define NETTEST2_TEXT   "Networking test 2 - transfer"
     59
     60static size_t size;
     61static bool verbose;
     62static sock_type_t type;
     63static int sockets;
     64static int messages;
     65static int family;
     66static uint16_t port;
    6967
    7068static void nettest2_print_help(void)
    … …  
    7270        printf(
    7371            "Network Networking test 2 aplication - UDP transfer\n"
    74             "Usage: nettest2 [options] host\n"
     72            "Usage: echo [options] address\n"
    7573            "Where options are:\n"
    7674            "-f protocol_family | --family=protocol_family\n"
    … …  
    107105static void nettest2_fill_buffer(char *buffer, size_t size)
    108106{
    109         size_t length = 0;
     107        size_t length;
     108
     109        length = 0;
    110110        while (size > length + sizeof(NETTEST2_TEXT) - 1) {
    111111                memcpy(buffer + length, NETTEST2_TEXT,
    … …  
    113113                length += sizeof(NETTEST2_TEXT) - 1;
    114114        }
    115        
     115
    116116        memcpy(buffer + length, NETTEST2_TEXT, size - length);
    117117        buffer[size] = '\0';
    … …  
    128128        int value;
    129129        int rc;
    130        
     130
    131131        switch (argv[*index][1]) {
    132132        /*
    … …  
    134134         */
    135135        case 'f':
    136                 rc = arg_parse_name_int(argc, argv, index, &value, 0,
     136                rc = arg_parse_name_int(argc, argv, index, &family, 0,
    137137                    socket_parse_protocol_family);
    138138                if (rc != EOK)
    139139                        return rc;
    140                
    141                 family = (uint16_t) value;
    142140                break;
    143141        case 'h':
    144142                nettest2_print_help();
    145143                return EOK;
     144                break;
    146145        case 'm':
    147146                rc = arg_parse_int(argc, argv, index, &messages, 0);
    148147                if (rc != EOK)
    149148                        return rc;
    150                
    151149                break;
    152150        case 'n':
    … …  
    154152                if (rc != EOK)
    155153                        return rc;
    156                
    157154                break;
    158155        case 'p':
    … …  
    160157                if (rc != EOK)
    161158                        return rc;
    162                
    163159                port = (uint16_t) value;
    164160                break;
    … …  
    167163                if (rc != EOK)
    168164                        return rc;
    169                
    170165                size = (value >= 0) ? (size_t) value : 0;
    171166                break;
    … …  
    175170                if (rc != EOK)
    176171                        return rc;
    177                
    178172                type = (sock_type_t) value;
    179173                break;
    … …  
    181175                verbose = true;
    182176                break;
    183        
    184177        /*
    185178         * Long options with double dash ('-')
    … …  
    187180        case '-':
    188181                if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
    189                         rc = arg_parse_name_int(argc, argv, index, &value, 9,
     182                        rc = arg_parse_name_int(argc, argv, index, &family, 9,
    190183                            socket_parse_protocol_family);
    191184                        if (rc != EOK)
    192185                                return rc;
    193                        
    194                         family = (uint16_t) value;
    195186                } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
    196187                        nettest2_print_help();
    … …  
    208199                        if (rc != EOK)
    209200                                return rc;
    210                        
    211201                        port = (uint16_t) value;
    212202                } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
    … …  
    215205                        if (rc != EOK)
    216206                                return rc;
    217                        
    218207                        type = (sock_type_t) value;
    219208                } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
    … …  
    228217                return EINVAL;
    229218        }
    230        
     219
    231220        return EOK;
    232221}
    … …  
    234223int main(int argc, char *argv[])
    235224{
     225        struct sockaddr *address;
     226        struct sockaddr_in address_in;
     227        struct sockaddr_in6 address_in6;
     228        socklen_t addrlen;
     229        uint8_t *address_start;
     230
     231        int *socket_ids;
     232        char *data;
    236233        int index;
     234        struct timeval time_before;
     235        struct timeval time_after;
     236
    237237        int rc;
    238        
     238
     239        size = 28;
     240        verbose = false;
     241        type = SOCK_DGRAM;
     242        sockets = 10;
     243        messages = 10;
     244        family = PF_INET;
     245        port = 7;
     246
    239247        /*
    240248         * Parse the command line arguments.
    … …  
    244252        for (index = 1; (index < argc - 1) || ((index == argc - 1) &&
    245253            (argv[index][0] == '-')); ++index) {
     254
    246255                /* Options should start with dash ('-') */
    247256                if (argv[index][0] == '-') {
    … …  
    254263                }
    255264        }
    256        
    257         /* The last argument containing the host */
     265
     266        /* If not before the last argument containing the address */
    258267        if (index >= argc) {
    259                 printf("Host name missing.\n");
     268                printf("Command line error: missing address\n");
    260269                nettest2_print_help();
    261270                return EINVAL;
    262271        }
    263        
    264         char *addr_s = argv[argc - 1];
    265        
    266         /* Interpret as address */
    267         inet_addr_t addr_addr;
    268         rc = inet_addr_parse(addr_s, &addr_addr);
    269        
    270         if (rc != EOK) {
    271                 /* Interpret as a host name */
    272                 dnsr_hostinfo_t *hinfo = NULL;
    273                 rc = dnsr_name2host(addr_s, &hinfo);
    274                
    275                 if (rc != EOK) {
    276                         printf("Error resolving host '%s'.\n", addr_s);
    277                         return EINVAL;
    278                 }
    279                
    280                 addr_addr = hinfo->addr;
    281         }
    282        
    283         struct sockaddr_in addr;
    284         struct sockaddr_in6 addr6;
    285         uint16_t af = inet_addr_sockaddr_in(&addr_addr, &addr, &addr6);
    286        
    287         if (af != family) {
    288                 printf("Address family does not match explicitly set family.\n");
    289                 return EINVAL;
    290         }
    291        
     272
    292273        /* Prepare the address buffer */
    293        
    294         struct sockaddr *address;
    295         socklen_t addrlen;
    296        
    297         switch (af) {
    298         case AF_INET:
    299                 addr.sin_port = htons(port);
    300                 address = (struct sockaddr *) &addr;
    301                 addrlen = sizeof(addr);
    302                 break;
    303         case AF_INET6:
    304                 addr6.sin6_port = htons(port);
    305                 address = (struct sockaddr *) &addr6;
    306                 addrlen = sizeof(addr6);
     274
     275        switch (family) {
     276        case PF_INET:
     277                address_in.sin_family = AF_INET;
     278                address_in.sin_port = htons(port);
     279                address = (struct sockaddr *) &address_in;
     280                addrlen = sizeof(address_in);
     281                address_start = (uint8_t *) &address_in.sin_addr.s_addr;
     282                break;
     283        case PF_INET6:
     284                address_in6.sin6_family = AF_INET6;
     285                address_in6.sin6_port = htons(port);
     286                address = (struct sockaddr *) &address_in6;
     287                addrlen = sizeof(address_in6);
     288                address_start = (uint8_t *) &address_in6.sin6_addr.s6_addr;
    307289                break;
    308290        default:
    … …  
    310292                return EAFNOSUPPORT;
    311293        }
    312        
     294
     295        /* Parse the last argument which should contain the address. */
     296        rc = inet_pton(family, argv[argc - 1], address_start);
     297        if (rc != EOK) {
     298                fprintf(stderr, "Address parse error %d\n", rc);
     299                return rc;
     300        }
     301
    313302        /* Check data buffer size. */
    314303        if (size <= 0) {
    … …  
    317306                size = 1024;
    318307        }
    319        
     308
    320309        /*
    321310         * Prepare the buffer. Allocate size bytes plus one for terminating
    322311         * null character.
    323312         */
    324         char *data = (char *) malloc(size + 1);
     313        data = (char *) malloc(size + 1);
    325314        if (!data) {
    326315                fprintf(stderr, "Failed to allocate data buffer.\n");
    327316                return ENOMEM;
    328317        }
    329        
     318
    330319        /* Fill buffer with a pattern. */
    331320        nettest2_fill_buffer(data, size);
    332        
     321
    333322        /* Check socket count. */
    334323        if (sockets <= 0) {
    … …  
    337326                sockets = 2;
    338327        }
    339        
     328
    340329        /*
    341330         * Prepare the socket buffer.
    342331         * Allocate count entries plus the terminating null (\0)
    343332         */
    344         int *socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
     333        socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
    345334        if (!socket_ids) {
    346335                fprintf(stderr, "Failed to allocate receive buffer.\n");
    347336                return ENOMEM;
    348337        }
    349        
    350338        socket_ids[sockets] = 0;
    351        
     339
    352340        if (verbose)
    353341                printf("Starting tests\n");
    354        
     342
    355343        rc = sockets_create(verbose, socket_ids, sockets, family, type);
    356344        if (rc != EOK)
    357345                return rc;
    358        
     346
    359347        if (type == SOCK_STREAM) {
    360348                rc = sockets_connect(verbose, socket_ids, sockets,
    … …  
    363351                        return rc;
    364352        }
    365        
     353
    366354        if (verbose)
    367355                printf("\n");
    368        
    369         struct timeval time_before;
     356
    370357        rc = gettimeofday(&time_before, NULL);
    371358        if (rc != EOK) {
    … …  
    373360                return rc;
    374361        }
    375        
     362
    376363        rc = sockets_sendto_recvfrom(verbose, socket_ids, sockets, address,
    377364            &addrlen, data, size, messages);
    378365        if (rc != EOK)
    379366                return rc;
    380        
    381         struct timeval time_after;
     367
    382368        rc = gettimeofday(&time_after, NULL);
    383369        if (rc != EOK) {
    … …  
    385371                return rc;
    386372        }
    387        
     373
    388374        if (verbose)
    389375                printf("\tOK\n");
    390        
     376
    391377        printf("sendto + recvfrom tested in %ld microseconds\n",
    392378            tv_sub(&time_after, &time_before));
    393        
     379
    394380        rc = gettimeofday(&time_before, NULL);
    395381        if (rc != EOK) {
    … …  
    397383                return rc;
    398384        }
    399        
     385
    400386        rc = sockets_sendto(verbose, socket_ids, sockets, address, addrlen,
    401387            data, size, messages);
    402388        if (rc != EOK)
    403389                return rc;
    404        
     390
    405391        rc = sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen,
    406392            data, size, messages);
    407393        if (rc != EOK)
    408394                return rc;
    409        
     395
    410396        rc = gettimeofday(&time_after, NULL);
    411397        if (rc != EOK) {
    … …  
    413399                return rc;
    414400        }
    415        
     401
    416402        if (verbose)
    417403                printf("\tOK\n");
    418        
     404
    419405        printf("sendto, recvfrom tested in %ld microseconds\n",
    420406            tv_sub(&time_after, &time_before));
    421        
     407
    422408        rc = sockets_close(verbose, socket_ids, sockets);
    423409        if (rc != EOK)
    424410                return rc;
    425        
     411
    426412        if (verbose)
    427413                printf("\nExiting\n");
    428        
     414
    429415        return EOK;
    430416}
Note: See TracChangeset for help on using the changeset viewer.