Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/nettest2/nettest2.c

    r1ab8539 rd4d74dc  
    3838#include "print_error.h"
    3939
    40 #include <assert.h>
    4140#include <malloc.h>
    4241#include <stdio.h>
    … …  
    4645#include <time.h>
    4746#include <arg_parse.h>
    48 #include <stdbool.h>
    49 
    50 #include <inet/dnsr.h>
     47#include <bool.h>
     48
    5149#include <net/in.h>
    5250#include <net/in6.h>
    … …  
    5654
    5755/** Echo module name. */
    58 #define NAME  "nettest2"
     56#define NAME    "Nettest2"
    5957
    6058/** Packet data pattern. */
    61 #define NETTEST2_TEXT  "Networking test 2 - transfer"
    62 
    63 static uint16_t family = AF_NONE;
    64 static size_t size = 28;
    65 static bool verbose = false;
    66 static sock_type_t type = SOCK_DGRAM;
    67 static int sockets = 10;
    68 static int messages = 10;
    69 static uint16_t port = 7;
     59#define NETTEST2_TEXT   "Networking test 2 - transfer"
     60
     61static size_t size;
     62static bool verbose;
     63static sock_type_t type;
     64static int sockets;
     65static int messages;
     66static int family;
     67static uint16_t port;
    7068
    7169static void nettest2_print_help(void)
    … …  
    7371        printf(
    7472            "Network Networking test 2 aplication - UDP transfer\n"
    75             "Usage: nettest2 [options] host\n"
     73            "Usage: echo [options] address\n"
    7674            "Where options are:\n"
    7775            "-f protocol_family | --family=protocol_family\n"
    … …  
    108106static void nettest2_fill_buffer(char *buffer, size_t size)
    109107{
    110         size_t length = 0;
     108        size_t length;
     109
     110        length = 0;
    111111        while (size > length + sizeof(NETTEST2_TEXT) - 1) {
    112112                memcpy(buffer + length, NETTEST2_TEXT,
    … …  
    114114                length += sizeof(NETTEST2_TEXT) - 1;
    115115        }
    116        
     116
    117117        memcpy(buffer + length, NETTEST2_TEXT, size - length);
    118118        buffer[size] = '\0';
    … …  
    129129        int value;
    130130        int rc;
    131        
     131
    132132        switch (argv[*index][1]) {
    133133        /*
    … …  
    135135         */
    136136        case 'f':
    137                 rc = arg_parse_name_int(argc, argv, index, &value, 0,
     137                rc = arg_parse_name_int(argc, argv, index, &family, 0,
    138138                    socket_parse_protocol_family);
    139139                if (rc != EOK)
    140140                        return rc;
    141                
    142                 family = (uint16_t) value;
    143141                break;
    144142        case 'h':
    145143                nettest2_print_help();
    146144                return EOK;
     145                break;
    147146        case 'm':
    148147                rc = arg_parse_int(argc, argv, index, &messages, 0);
    149148                if (rc != EOK)
    150149                        return rc;
    151                
    152150                break;
    153151        case 'n':
    … …  
    155153                if (rc != EOK)
    156154                        return rc;
    157                
    158155                break;
    159156        case 'p':
    … …  
    161158                if (rc != EOK)
    162159                        return rc;
    163                
    164160                port = (uint16_t) value;
    165161                break;
    … …  
    168164                if (rc != EOK)
    169165                        return rc;
    170                
    171166                size = (value >= 0) ? (size_t) value : 0;
    172167                break;
    … …  
    176171                if (rc != EOK)
    177172                        return rc;
    178                
    179173                type = (sock_type_t) value;
    180174                break;
    … …  
    182176                verbose = true;
    183177                break;
    184        
    185178        /*
    186179         * Long options with double dash ('-')
    … …  
    188181        case '-':
    189182                if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
    190                         rc = arg_parse_name_int(argc, argv, index, &value, 9,
     183                        rc = arg_parse_name_int(argc, argv, index, &family, 9,
    191184                            socket_parse_protocol_family);
    192185                        if (rc != EOK)
    193186                                return rc;
    194                        
    195                         family = (uint16_t) value;
    196187                } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
    197188                        nettest2_print_help();
    … …  
    209200                        if (rc != EOK)
    210201                                return rc;
    211                        
    212202                        port = (uint16_t) value;
    213203                } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
    … …  
    216206                        if (rc != EOK)
    217207                                return rc;
    218                        
    219208                        type = (sock_type_t) value;
    220209                } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
    … …  
    229218                return EINVAL;
    230219        }
    231        
     220
    232221        return EOK;
    233222}
    … …  
    235224int main(int argc, char *argv[])
    236225{
     226        struct sockaddr *address;
     227        struct sockaddr_in address_in;
     228        struct sockaddr_in6 address_in6;
     229        socklen_t addrlen;
     230        uint8_t *address_start;
     231
     232        int *socket_ids;
     233        char *data;
    237234        int index;
     235        struct timeval time_before;
     236        struct timeval time_after;
     237
    238238        int rc;
    239        
     239
     240        size = 28;
     241        verbose = false;
     242        type = SOCK_DGRAM;
     243        sockets = 10;
     244        messages = 10;
     245        family = PF_INET;
     246        port = 7;
     247
    240248        /*
    241249         * Parse the command line arguments.
    … …  
    245253        for (index = 1; (index < argc - 1) || ((index == argc - 1) &&
    246254            (argv[index][0] == '-')); ++index) {
     255
    247256                /* Options should start with dash ('-') */
    248257                if (argv[index][0] == '-') {
    … …  
    255264                }
    256265        }
    257        
    258         /* The last argument containing the host */
     266
     267        /* If not before the last argument containing the address */
    259268        if (index >= argc) {
    260                 printf("Host name missing.\n");
     269                printf("Command line error: missing address\n");
    261270                nettest2_print_help();
    262271                return EINVAL;
    263272        }
    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        
     273
     274        /* Prepare the address buffer */
     275
     276        switch (family) {
     277        case PF_INET:
     278                address_in.sin_family = AF_INET;
     279                address_in.sin_port = htons(port);
     280                address = (struct sockaddr *) &address_in;
     281                addrlen = sizeof(address_in);
     282                address_start = (uint8_t *) &address_in.sin_addr.s_addr;
     283                break;
     284        case PF_INET6:
     285                address_in6.sin6_family = AF_INET6;
     286                address_in6.sin6_port = htons(port);
     287                address = (struct sockaddr *) &address_in6;
     288                addrlen = sizeof(address_in6);
     289                address_start = (uint8_t *) &address_in6.sin6_addr.s6_addr;
     290                break;
     291        default:
     292                fprintf(stderr, "Address family is not supported\n");
     293                return EAFNOSUPPORT;
     294        }
     295
     296        /* Parse the last argument which should contain the address. */
     297        rc = inet_pton(family, argv[argc - 1], address_start);
    271298        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                
    276                 if (rc != EOK) {
    277                         printf("Error resolving host '%s'.\n", addr_s);
    278                         return EINVAL;
    279                 }
    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        
     299                fprintf(stderr, "Address parse error %d\n", rc);
     300                return rc;
     301        }
     302
    301303        /* Check data buffer size. */
    302304        if (size <= 0) {
    … …  
    305307                size = 1024;
    306308        }
    307        
     309
    308310        /*
    309311         * Prepare the buffer. Allocate size bytes plus one for terminating
    310312         * null character.
    311313         */
    312         char *data = (char *) malloc(size + 1);
     314        data = (char *) malloc(size + 1);
    313315        if (!data) {
    314316                fprintf(stderr, "Failed to allocate data buffer.\n");
    315317                return ENOMEM;
    316318        }
    317        
     319
    318320        /* Fill buffer with a pattern. */
    319321        nettest2_fill_buffer(data, size);
    320        
     322
    321323        /* Check socket count. */
    322324        if (sockets <= 0) {
    … …  
    325327                sockets = 2;
    326328        }
    327        
     329
    328330        /*
    329331         * Prepare the socket buffer.
    330332         * Allocate count entries plus the terminating null (\0)
    331333         */
    332         int *socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
     334        socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
    333335        if (!socket_ids) {
    334336                fprintf(stderr, "Failed to allocate receive buffer.\n");
    335337                return ENOMEM;
    336338        }
    337        
    338339        socket_ids[sockets] = 0;
    339        
     340
    340341        if (verbose)
    341342                printf("Starting tests\n");
    342        
     343
    343344        rc = sockets_create(verbose, socket_ids, sockets, family, type);
    344345        if (rc != EOK)
    345346                return rc;
    346        
     347
    347348        if (type == SOCK_STREAM) {
    348349                rc = sockets_connect(verbose, socket_ids, sockets,
    … …  
    351352                        return rc;
    352353        }
    353        
     354
    354355        if (verbose)
    355356                printf("\n");
    356        
    357         struct timeval time_before;
    358         gettimeofday(&time_before, NULL);
    359        
     357
     358        rc = gettimeofday(&time_before, NULL);
     359        if (rc != EOK) {
     360                fprintf(stderr, "Get time of day error %d\n", rc);
     361                return rc;
     362        }
     363
    360364        rc = sockets_sendto_recvfrom(verbose, socket_ids, sockets, address,
    361             &addrlen, data, size, messages, type);
     365            &addrlen, data, size, messages);
    362366        if (rc != EOK)
    363367                return rc;
    364        
    365         struct timeval time_after;
    366         gettimeofday(&time_after, NULL);
    367        
     368
     369        rc = gettimeofday(&time_after, NULL);
     370        if (rc != EOK) {
     371                fprintf(stderr, "Get time of day error %d\n", rc);
     372                return rc;
     373        }
     374
    368375        if (verbose)
    369376                printf("\tOK\n");
    370        
     377
    371378        printf("sendto + recvfrom tested in %ld microseconds\n",
    372379            tv_sub(&time_after, &time_before));
    373        
    374         gettimeofday(&time_before, NULL);
    375        
     380
     381        rc = gettimeofday(&time_before, NULL);
     382        if (rc != EOK) {
     383                fprintf(stderr, "Get time of day error %d\n", rc);
     384                return rc;
     385        }
     386
    376387        rc = sockets_sendto(verbose, socket_ids, sockets, address, addrlen,
    377             data, size, messages, type);
     388            data, size, messages);
    378389        if (rc != EOK)
    379390                return rc;
    380        
     391
    381392        rc = sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen,
    382393            data, size, messages);
    383394        if (rc != EOK)
    384395                return rc;
    385        
    386         gettimeofday(&time_after, NULL);
    387        
     396
     397        rc = gettimeofday(&time_after, NULL);
     398        if (rc != EOK) {
     399                fprintf(stderr, "Get time of day error %d\n", rc);
     400                return rc;
     401        }
     402
    388403        if (verbose)
    389404                printf("\tOK\n");
    390        
     405
    391406        printf("sendto, recvfrom tested in %ld microseconds\n",
    392407            tv_sub(&time_after, &time_before));
    393        
     408
    394409        rc = sockets_close(verbose, socket_ids, sockets);
    395410        if (rc != EOK)
    396411                return rc;
    397        
    398         free(address);
    399        
     412
    400413        if (verbose)
    401414                printf("\nExiting\n");
    402        
     415
    403416        return EOK;
    404417}
Note: See TracChangeset for help on using the changeset viewer.