Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/nettest2/nettest2.c

    rd4d74dc r1ab8539  
    3838#include "print_error.h"
    3939
     40#include <assert.h>
    4041#include <malloc.h>
    4142#include <stdio.h>
    … …  
    4546#include <time.h>
    4647#include <arg_parse.h>
    47 #include <bool.h>
    48 
     48#include <stdbool.h>
     49
     50#include <inet/dnsr.h>
    4951#include <net/in.h>
    5052#include <net/in6.h>
    … …  
    5456
    5557/** Echo module name. */
    56 #define NAME    "Nettest2"
     58#define NAME  "nettest2"
    5759
    5860/** Packet data pattern. */
    59 #define NETTEST2_TEXT   "Networking test 2 - transfer"
    60 
    61 static size_t size;
    62 static bool verbose;
    63 static sock_type_t type;
    64 static int sockets;
    65 static int messages;
    66 static int family;
    67 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;
    6870
    6971static void nettest2_print_help(void)
    … …  
    7173        printf(
    7274            "Network Networking test 2 aplication - UDP transfer\n"
    73             "Usage: echo [options] address\n"
     75            "Usage: nettest2 [options] host\n"
    7476            "Where options are:\n"
    7577            "-f protocol_family | --family=protocol_family\n"
    … …  
    106108static void nettest2_fill_buffer(char *buffer, size_t size)
    107109{
    108         size_t length;
    109 
    110         length = 0;
     110        size_t 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, &family, 0,
     137                rc = arg_parse_name_int(argc, argv, index, &value, 0,
    138138                    socket_parse_protocol_family);
    139139                if (rc != EOK)
    140140                        return rc;
     141               
     142                family = (uint16_t) value;
    141143                break;
    142144        case 'h':
    143145                nettest2_print_help();
    144146                return EOK;
    145                 break;
    146147        case 'm':
    147148                rc = arg_parse_int(argc, argv, index, &messages, 0);
    148149                if (rc != EOK)
    149150                        return rc;
     151               
    150152                break;
    151153        case 'n':
    … …  
    153155                if (rc != EOK)
    154156                        return rc;
     157               
    155158                break;
    156159        case 'p':
    … …  
    158161                if (rc != EOK)
    159162                        return rc;
     163               
    160164                port = (uint16_t) value;
    161165                break;
    … …  
    164168                if (rc != EOK)
    165169                        return rc;
     170               
    166171                size = (value >= 0) ? (size_t) value : 0;
    167172                break;
    … …  
    171176                if (rc != EOK)
    172177                        return rc;
     178               
    173179                type = (sock_type_t) value;
    174180                break;
    … …  
    176182                verbose = true;
    177183                break;
     184       
    178185        /*
    179186         * Long options with double dash ('-')
    … …  
    181188        case '-':
    182189                if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
    183                         rc = arg_parse_name_int(argc, argv, index, &family, 9,
     190                        rc = arg_parse_name_int(argc, argv, index, &value, 9,
    184191                            socket_parse_protocol_family);
    185192                        if (rc != EOK)
    186193                                return rc;
     194                       
     195                        family = (uint16_t) value;
    187196                } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
    188197                        nettest2_print_help();
    … …  
    200209                        if (rc != EOK)
    201210                                return rc;
     211                       
    202212                        port = (uint16_t) value;
    203213                } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
    … …  
    206216                        if (rc != EOK)
    207217                                return rc;
     218                       
    208219                        type = (sock_type_t) value;
    209220                } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
    … …  
    218229                return EINVAL;
    219230        }
    220 
     231       
    221232        return EOK;
    222233}
    … …  
    224235int main(int argc, char *argv[])
    225236{
    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;
    234237        int index;
    235         struct timeval time_before;
    236         struct timeval time_after;
    237 
    238238        int rc;
    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 
     239       
    248240        /*
    249241         * Parse the command line arguments.
    … …  
    253245        for (index = 1; (index < argc - 1) || ((index == argc - 1) &&
    254246            (argv[index][0] == '-')); ++index) {
    255 
    256247                /* Options should start with dash ('-') */
    257248                if (argv[index][0] == '-') {
    … …  
    264255                }
    265256        }
    266 
    267         /* If not before the last argument containing the address */
     257       
     258        /* The last argument containing the host */
    268259        if (index >= argc) {
    269                 printf("Command line error: missing address\n");
     260                printf("Host name missing.\n");
    270261                nettest2_print_help();
    271262                return EINVAL;
    272263        }
    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);
     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       
    298271        if (rc != EOK) {
    299                 fprintf(stderr, "Address parse error %d\n", rc);
    300                 return rc;
    301         }
    302 
     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       
    303301        /* Check data buffer size. */
    304302        if (size <= 0) {
    … …  
    307305                size = 1024;
    308306        }
    309 
     307       
    310308        /*
    311309         * Prepare the buffer. Allocate size bytes plus one for terminating
    312310         * null character.
    313311         */
    314         data = (char *) malloc(size + 1);
     312        char *data = (char *) malloc(size + 1);
    315313        if (!data) {
    316314                fprintf(stderr, "Failed to allocate data buffer.\n");
    317315                return ENOMEM;
    318316        }
    319 
     317       
    320318        /* Fill buffer with a pattern. */
    321319        nettest2_fill_buffer(data, size);
    322 
     320       
    323321        /* Check socket count. */
    324322        if (sockets <= 0) {
    … …  
    327325                sockets = 2;
    328326        }
    329 
     327       
    330328        /*
    331329         * Prepare the socket buffer.
    332330         * Allocate count entries plus the terminating null (\0)
    333331         */
    334         socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
     332        int *socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
    335333        if (!socket_ids) {
    336334                fprintf(stderr, "Failed to allocate receive buffer.\n");
    337335                return ENOMEM;
    338336        }
     337       
    339338        socket_ids[sockets] = 0;
    340 
     339       
    341340        if (verbose)
    342341                printf("Starting tests\n");
    343 
     342       
    344343        rc = sockets_create(verbose, socket_ids, sockets, family, type);
    345344        if (rc != EOK)
    346345                return rc;
    347 
     346       
    348347        if (type == SOCK_STREAM) {
    349348                rc = sockets_connect(verbose, socket_ids, sockets,
    … …  
    352351                        return rc;
    353352        }
    354 
     353       
    355354        if (verbose)
    356355                printf("\n");
    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 
     356       
     357        struct timeval time_before;
     358        gettimeofday(&time_before, NULL);
     359       
    364360        rc = sockets_sendto_recvfrom(verbose, socket_ids, sockets, address,
    365             &addrlen, data, size, messages);
     361            &addrlen, data, size, messages, type);
    366362        if (rc != EOK)
    367363                return rc;
    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 
     364       
     365        struct timeval time_after;
     366        gettimeofday(&time_after, NULL);
     367       
    375368        if (verbose)
    376369                printf("\tOK\n");
    377 
     370       
    378371        printf("sendto + recvfrom tested in %ld microseconds\n",
    379372            tv_sub(&time_after, &time_before));
    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 
     373       
     374        gettimeofday(&time_before, NULL);
     375       
    387376        rc = sockets_sendto(verbose, socket_ids, sockets, address, addrlen,
    388             data, size, messages);
     377            data, size, messages, type);
    389378        if (rc != EOK)
    390379                return rc;
    391 
     380       
    392381        rc = sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen,
    393382            data, size, messages);
    394383        if (rc != EOK)
    395384                return rc;
    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 
     385       
     386        gettimeofday(&time_after, NULL);
     387       
    403388        if (verbose)
    404389                printf("\tOK\n");
    405 
     390       
    406391        printf("sendto, recvfrom tested in %ld microseconds\n",
    407392            tv_sub(&time_after, &time_before));
    408 
     393       
    409394        rc = sockets_close(verbose, socket_ids, sockets);
    410395        if (rc != EOK)
    411396                return rc;
    412 
     397       
     398        free(address);
     399       
    413400        if (verbose)
    414401                printf("\nExiting\n");
    415 
     402       
    416403        return EOK;
    417404}
Note: See TracChangeset for help on using the changeset viewer.