Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/nettest2/nettest2.c

    r26de91a rfff7ef4  
    3838#include "print_error.h"
    3939
    40 #include <assert.h>
    4140#include <malloc.h>
    4241#include <stdio.h>
    … …  
    5655
    5756/** Echo module name. */
    58 #define NAME  "nettest2"
     57#define NAME    "Nettest2"
    5958
    6059/** 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;
     60#define NETTEST2_TEXT   "Networking test 2 - transfer"
     61
     62static size_t size;
     63static bool verbose;
     64static sock_type_t type;
     65static int sockets;
     66static int messages;
     67static int family;
     68static uint16_t port;
    7069
    7170static void nettest2_print_help(void)
    … …  
    108107static void nettest2_fill_buffer(char *buffer, size_t size)
    109108{
    110         size_t length = 0;
     109        size_t length;
     110
     111        length = 0;
    111112        while (size > length + sizeof(NETTEST2_TEXT) - 1) {
    112113                memcpy(buffer + length, NETTEST2_TEXT,
    … …  
    114115                length += sizeof(NETTEST2_TEXT) - 1;
    115116        }
    116        
     117
    117118        memcpy(buffer + length, NETTEST2_TEXT, size - length);
    118119        buffer[size] = '\0';
    … …  
    129130        int value;
    130131        int rc;
    131        
     132
    132133        switch (argv[*index][1]) {
    133134        /*
    … …  
    135136         */
    136137        case 'f':
    137                 rc = arg_parse_name_int(argc, argv, index, &value, 0,
     138                rc = arg_parse_name_int(argc, argv, index, &family, 0,
    138139                    socket_parse_protocol_family);
    139140                if (rc != EOK)
    140141                        return rc;
    141                
    142                 family = (uint16_t) value;
    143142                break;
    144143        case 'h':
    145144                nettest2_print_help();
    146145                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                
    152151                break;
    153152        case 'n':
    … …  
    155154                if (rc != EOK)
    156155                        return rc;
    157                
    158156                break;
    159157        case 'p':
    … …  
    161159                if (rc != EOK)
    162160                        return rc;
    163                
    164161                port = (uint16_t) value;
    165162                break;
    … …  
    168165                if (rc != EOK)
    169166                        return rc;
    170                
    171167                size = (value >= 0) ? (size_t) value : 0;
    172168                break;
    … …  
    176172                if (rc != EOK)
    177173                        return rc;
    178                
    179174                type = (sock_type_t) value;
    180175                break;
    … …  
    182177                verbose = true;
    183178                break;
    184        
    185179        /*
    186180         * Long options with double dash ('-')
    … …  
    188182        case '-':
    189183                if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
    190                         rc = arg_parse_name_int(argc, argv, index, &value, 9,
     184                        rc = arg_parse_name_int(argc, argv, index, &family, 9,
    191185                            socket_parse_protocol_family);
    192186                        if (rc != EOK)
    193187                                return rc;
    194                        
    195                         family = (uint16_t) value;
    196188                } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
    197189                        nettest2_print_help();
    … …  
    209201                        if (rc != EOK)
    210202                                return rc;
    211                        
    212203                        port = (uint16_t) value;
    213204                } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
    … …  
    216207                        if (rc != EOK)
    217208                                return rc;
    218                        
    219209                        type = (sock_type_t) value;
    220210                } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
    … …  
    229219                return EINVAL;
    230220        }
    231        
     221
    232222        return EOK;
    233223}
    … …  
    235225int main(int argc, char *argv[])
    236226{
     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;
    237236        int index;
     237        struct timeval time_before;
     238        struct timeval time_after;
     239
    238240        int rc;
    239        
     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
    240250        /*
    241251         * Parse the command line arguments.
    … …  
    245255        for (index = 1; (index < argc - 1) || ((index == argc - 1) &&
    246256            (argv[index][0] == '-')); ++index) {
     257
    247258                /* Options should start with dash ('-') */
    248259                if (argv[index][0] == '-') {
    … …  
    255266                }
    256267        }
    257        
    258         /* The last argument containing the host */
     268
     269        /* If not before the last argument containing the host */
    259270        if (index >= argc) {
    260                 printf("Host name missing.\n");
     271                printf("Command line error: missing host name\n");
    261272                nettest2_print_help();
    262273                return EINVAL;
    263274        }
    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        
     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);
    271300        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                
     301                /* Try interpreting as a host name */
     302                rc = dnsr_name2host(argv[argc - 1], &hinfo);
    276303                if (rc != EOK) {
    277                         printf("Error resolving host '%s'.\n", addr_s);
    278                         return EINVAL;
     304                        printf("Error resolving host '%s'.\n", argv[argc - 1]);
     305                        return rc;
    279306                }
    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        
     307
     308                address_in.sin_addr.s_addr = host2uint32_t_be(hinfo->addr.ipv4);
     309        }
     310
    301311        /* Check data buffer size. */
    302312        if (size <= 0) {
    … …  
    305315                size = 1024;
    306316        }
    307        
     317
    308318        /*
    309319         * Prepare the buffer. Allocate size bytes plus one for terminating
    310320         * null character.
    311321         */
    312         char *data = (char *) malloc(size + 1);
     322        data = (char *) malloc(size + 1);
    313323        if (!data) {
    314324                fprintf(stderr, "Failed to allocate data buffer.\n");
    315325                return ENOMEM;
    316326        }
    317        
     327
    318328        /* Fill buffer with a pattern. */
    319329        nettest2_fill_buffer(data, size);
    320        
     330
    321331        /* Check socket count. */
    322332        if (sockets <= 0) {
    … …  
    325335                sockets = 2;
    326336        }
    327        
     337
    328338        /*
    329339         * Prepare the socket buffer.
    330340         * Allocate count entries plus the terminating null (\0)
    331341         */
    332         int *socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
     342        socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
    333343        if (!socket_ids) {
    334344                fprintf(stderr, "Failed to allocate receive buffer.\n");
    335345                return ENOMEM;
    336346        }
    337        
    338347        socket_ids[sockets] = 0;
    339        
     348
    340349        if (verbose)
    341350                printf("Starting tests\n");
    342        
     351
    343352        rc = sockets_create(verbose, socket_ids, sockets, family, type);
    344353        if (rc != EOK)
    345354                return rc;
    346        
     355
    347356        if (type == SOCK_STREAM) {
    348357                rc = sockets_connect(verbose, socket_ids, sockets,
    … …  
    351360                        return rc;
    352361        }
    353        
     362
    354363        if (verbose)
    355364                printf("\n");
    356        
    357         struct timeval time_before;
     365
    358366        rc = gettimeofday(&time_before, NULL);
    359367        if (rc != EOK) {
    … …  
    361369                return rc;
    362370        }
    363        
     371
    364372        rc = sockets_sendto_recvfrom(verbose, socket_ids, sockets, address,
    365             &addrlen, data, size, messages, type);
     373            &addrlen, data, size, messages);
    366374        if (rc != EOK)
    367375                return rc;
    368        
    369         struct timeval time_after;
     376
    370377        rc = gettimeofday(&time_after, NULL);
    371378        if (rc != EOK) {
    … …  
    373380                return rc;
    374381        }
    375        
     382
    376383        if (verbose)
    377384                printf("\tOK\n");
    378        
     385
    379386        printf("sendto + recvfrom tested in %ld microseconds\n",
    380387            tv_sub(&time_after, &time_before));
    381        
     388
    382389        rc = gettimeofday(&time_before, NULL);
    383390        if (rc != EOK) {
    … …  
    385392                return rc;
    386393        }
    387        
     394
    388395        rc = sockets_sendto(verbose, socket_ids, sockets, address, addrlen,
    389             data, size, messages, type);
     396            data, size, messages);
    390397        if (rc != EOK)
    391398                return rc;
    392        
     399
    393400        rc = sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen,
    394401            data, size, messages);
    395402        if (rc != EOK)
    396403                return rc;
    397        
     404
    398405        rc = gettimeofday(&time_after, NULL);
    399406        if (rc != EOK) {
    … …  
    401408                return rc;
    402409        }
    403        
     410
    404411        if (verbose)
    405412                printf("\tOK\n");
    406        
     413
    407414        printf("sendto, recvfrom tested in %ld microseconds\n",
    408415            tv_sub(&time_after, &time_before));
    409        
     416
    410417        rc = sockets_close(verbose, socket_ids, sockets);
    411418        if (rc != EOK)
    412419                return rc;
    413        
    414         free(address);
    415        
     420
    416421        if (verbose)
    417422                printf("\nExiting\n");
    418        
     423
    419424        return EOK;
    420425}
Note: See TracChangeset for help on using the changeset viewer.