Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/nettest2/nettest2.c

    r7e752b2 r02a09ed  
    4040#include <malloc.h>
    4141#include <stdio.h>
     42#include <unistd.h>
    4243#include <str.h>
    4344#include <task.h>
    4445#include <time.h>
    4546#include <arg_parse.h>
    46 #include <bool.h>
    47 
     47#include <stdbool.h>
     48
     49#include <inet/dnsr.h>
    4850#include <net/in.h>
    4951#include <net/in6.h>
    … …  
    5355
    5456/** Echo module name. */
    55 #define NAME    "Nettest2"
     57#define NAME  "nettest2"
    5658
    5759/** Packet data pattern. */
    58 #define NETTEST2_TEXT   "Networking test 2 - transfer"
    59 
    60 static size_t size;
    61 static bool verbose;
    62 static sock_type_t type;
    63 static int sockets;
    64 static int messages;
    65 static int family;
    66 static uint16_t port;
     60#define NETTEST2_TEXT  "Networking test 2 - transfer"
     61
     62static uint16_t family = PF_INET;
     63static size_t size = 28;
     64static bool verbose = false;
     65static sock_type_t type = SOCK_DGRAM;
     66static int sockets = 10;
     67static int messages = 10;
     68static uint16_t port = 7;
    6769
    6870static void nettest2_print_help(void)
    … …  
    7072        printf(
    7173            "Network Networking test 2 aplication - UDP transfer\n"
    72             "Usage: echo [options] address\n"
     74            "Usage: nettest2 [options] host\n"
    7375            "Where options are:\n"
    7476            "-f protocol_family | --family=protocol_family\n"
    … …  
    105107static void nettest2_fill_buffer(char *buffer, size_t size)
    106108{
    107         size_t length;
    108 
    109         length = 0;
     109        size_t 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, &family, 0,
     136                rc = arg_parse_name_int(argc, argv, index, &value, 0,
    137137                    socket_parse_protocol_family);
    138138                if (rc != EOK)
    139139                        return rc;
     140               
     141                family = (uint16_t) value;
    140142                break;
    141143        case 'h':
    142144                nettest2_print_help();
    143145                return EOK;
    144                 break;
    145146        case 'm':
    146147                rc = arg_parse_int(argc, argv, index, &messages, 0);
    147148                if (rc != EOK)
    148149                        return rc;
     150               
    149151                break;
    150152        case 'n':
    … …  
    152154                if (rc != EOK)
    153155                        return rc;
     156               
    154157                break;
    155158        case 'p':
    … …  
    157160                if (rc != EOK)
    158161                        return rc;
     162               
    159163                port = (uint16_t) value;
    160164                break;
    … …  
    163167                if (rc != EOK)
    164168                        return rc;
     169               
    165170                size = (value >= 0) ? (size_t) value : 0;
    166171                break;
    … …  
    170175                if (rc != EOK)
    171176                        return rc;
     177               
    172178                type = (sock_type_t) value;
    173179                break;
    … …  
    175181                verbose = true;
    176182                break;
     183       
    177184        /*
    178185         * Long options with double dash ('-')
    … …  
    180187        case '-':
    181188                if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
    182                         rc = arg_parse_name_int(argc, argv, index, &family, 9,
     189                        rc = arg_parse_name_int(argc, argv, index, &value, 9,
    183190                            socket_parse_protocol_family);
    184191                        if (rc != EOK)
    185192                                return rc;
     193                       
     194                        family = (uint16_t) value;
    186195                } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
    187196                        nettest2_print_help();
    … …  
    199208                        if (rc != EOK)
    200209                                return rc;
     210                       
    201211                        port = (uint16_t) value;
    202212                } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
    … …  
    205215                        if (rc != EOK)
    206216                                return rc;
     217                       
    207218                        type = (sock_type_t) value;
    208219                } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
    … …  
    217228                return EINVAL;
    218229        }
    219 
     230       
    220231        return EOK;
    221232}
    … …  
    223234int main(int argc, char *argv[])
    224235{
    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;
    233236        int index;
    234         struct timeval time_before;
    235         struct timeval time_after;
    236 
    237237        int rc;
    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 
     238       
    247239        /*
    248240         * Parse the command line arguments.
    … …  
    252244        for (index = 1; (index < argc - 1) || ((index == argc - 1) &&
    253245            (argv[index][0] == '-')); ++index) {
    254 
    255246                /* Options should start with dash ('-') */
    256247                if (argv[index][0] == '-') {
    … …  
    263254                }
    264255        }
    265 
    266         /* If not before the last argument containing the address */
     256       
     257        /* The last argument containing the host */
    267258        if (index >= argc) {
    268                 printf("Command line error: missing address\n");
     259                printf("Host name missing.\n");
    269260                nettest2_print_help();
    270261                return EINVAL;
    271262        }
    272 
     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       
    273292        /* Prepare the address buffer */
    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;
     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);
    289307                break;
    290308        default:
    … …  
    292310                return EAFNOSUPPORT;
    293311        }
    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 
     312       
    302313        /* Check data buffer size. */
    303314        if (size <= 0) {
    … …  
    306317                size = 1024;
    307318        }
    308 
     319       
    309320        /*
    310321         * Prepare the buffer. Allocate size bytes plus one for terminating
    311322         * null character.
    312323         */
    313         data = (char *) malloc(size + 1);
     324        char *data = (char *) malloc(size + 1);
    314325        if (!data) {
    315326                fprintf(stderr, "Failed to allocate data buffer.\n");
    316327                return ENOMEM;
    317328        }
    318 
     329       
    319330        /* Fill buffer with a pattern. */
    320331        nettest2_fill_buffer(data, size);
    321 
     332       
    322333        /* Check socket count. */
    323334        if (sockets <= 0) {
    … …  
    326337                sockets = 2;
    327338        }
    328 
     339       
    329340        /*
    330341         * Prepare the socket buffer.
    331342         * Allocate count entries plus the terminating null (\0)
    332343         */
    333         socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
     344        int *socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
    334345        if (!socket_ids) {
    335346                fprintf(stderr, "Failed to allocate receive buffer.\n");
    336347                return ENOMEM;
    337348        }
     349       
    338350        socket_ids[sockets] = 0;
    339 
     351       
    340352        if (verbose)
    341353                printf("Starting tests\n");
    342 
     354       
    343355        rc = sockets_create(verbose, socket_ids, sockets, family, type);
    344356        if (rc != EOK)
    345357                return rc;
    346 
     358       
    347359        if (type == SOCK_STREAM) {
    348360                rc = sockets_connect(verbose, socket_ids, sockets,
    … …  
    351363                        return rc;
    352364        }
    353 
     365       
    354366        if (verbose)
    355367                printf("\n");
    356 
     368       
     369        struct timeval time_before;
    357370        rc = gettimeofday(&time_before, NULL);
    358371        if (rc != EOK) {
    … …  
    360373                return rc;
    361374        }
    362 
     375       
    363376        rc = sockets_sendto_recvfrom(verbose, socket_ids, sockets, address,
    364377            &addrlen, data, size, messages);
    365378        if (rc != EOK)
    366379                return rc;
    367 
     380       
     381        struct timeval time_after;
    368382        rc = gettimeofday(&time_after, NULL);
    369383        if (rc != EOK) {
    … …  
    371385                return rc;
    372386        }
    373 
     387       
    374388        if (verbose)
    375389                printf("\tOK\n");
    376 
     390       
    377391        printf("sendto + recvfrom tested in %ld microseconds\n",
    378392            tv_sub(&time_after, &time_before));
    379 
     393       
    380394        rc = gettimeofday(&time_before, NULL);
    381395        if (rc != EOK) {
    … …  
    383397                return rc;
    384398        }
    385 
     399       
    386400        rc = sockets_sendto(verbose, socket_ids, sockets, address, addrlen,
    387401            data, size, messages);
    388402        if (rc != EOK)
    389403                return rc;
    390 
     404       
    391405        rc = sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen,
    392406            data, size, messages);
    393407        if (rc != EOK)
    394408                return rc;
    395 
     409       
    396410        rc = gettimeofday(&time_after, NULL);
    397411        if (rc != EOK) {
    … …  
    399413                return rc;
    400414        }
    401 
     415       
    402416        if (verbose)
    403417                printf("\tOK\n");
    404 
     418       
    405419        printf("sendto, recvfrom tested in %ld microseconds\n",
    406420            tv_sub(&time_after, &time_before));
    407 
     421       
    408422        rc = sockets_close(verbose, socket_ids, sockets);
    409423        if (rc != EOK)
    410424                return rc;
    411 
     425       
    412426        if (verbose)
    413427                printf("\nExiting\n");
    414 
     428       
    415429        return EOK;
    416430}
Note: See TracChangeset for help on using the changeset viewer.