Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/nettest1/nettest1.c

    rd4d74dc rc442f63  
    4646#include <arg_parse.h>
    4747
     48#include <inet/dnsr.h>
    4849#include <net/in.h>
    4950#include <net/in6.h>
    … …  
    5354
    5455/** Echo module name. */
    55 #define NAME    "Nettest1"
     56#define NAME  "nettest1"
    5657
    5758/** Packet data pattern. */
    58 #define NETTEST1_TEXT   "Networking test 1 - sockets"
    59 
    60 static int family = PF_INET;
     59#define NETTEST1_TEXT  "Networking test 1 - sockets"
     60
     61static uint16_t family = AF_INET;
    6162static sock_type_t type = SOCK_DGRAM;
    62 static char *data;
    6363static size_t size = 27;
    64 static int verbose = 0;
     64static bool verbose = false;
     65static int sockets = 10;
     66static int messages = 10;
     67static uint16_t port = 7;
    6568
    6669static struct sockaddr *address;
    6770static socklen_t addrlen;
    6871
    69 static int sockets;
    70 static int messages;
    71 static uint16_t port;
     72static char *data;
    7273
    7374static void nettest1_print_help(void)
    … …  
    7576        printf(
    7677            "Network Networking test 1 aplication - sockets\n"
    77             "Usage: echo [options] numeric_address\n"
     78            "Usage: nettest1 [options] host\n"
    7879            "Where options are:\n"
    7980            "-f protocol_family | --family=protocol_family\n"
    … …  
    113114        int value;
    114115        int rc;
    115 
     116       
    116117        switch (argv[*index][1]) {
    117118        /*
    … …  
    119120         */
    120121        case 'f':
    121                 rc = arg_parse_name_int(argc, argv, index, &family, 0, socket_parse_protocol_family);
    122                 if (rc != EOK)
    123                         return rc;
     122                rc = arg_parse_name_int(argc, argv, index, &value, 0,
     123                    socket_parse_protocol_family);
     124                if (rc != EOK)
     125                        return rc;
     126               
     127                family = (uint16_t) value;
    124128                break;
    125129        case 'h':
    … …  
    130134                if (rc != EOK)
    131135                        return rc;
     136               
    132137                break;
    133138        case 'n':
    … …  
    135140                if (rc != EOK)
    136141                        return rc;
     142               
    137143                break;
    138144        case 'p':
    … …  
    140146                if (rc != EOK)
    141147                        return rc;
     148               
    142149                port = (uint16_t) value;
    143150                break;
    … …  
    146153                if (rc != EOK)
    147154                        return rc;
     155               
    148156                size = (value >= 0) ? (size_t) value : 0;
    149157                break;
    150158        case 't':
    151                 rc = arg_parse_name_int(argc, argv, index, &value, 0, socket_parse_socket_type);
    152                 if (rc != EOK)
    153                         return rc;
     159                rc = arg_parse_name_int(argc, argv, index, &value, 0,
     160                    socket_parse_socket_type);
     161                if (rc != EOK)
     162                        return rc;
     163               
    154164                type = (sock_type_t) value;
    155165                break;
    … …  
    157167                verbose = 1;
    158168                break;
     169       
    159170        /*
    160171         * Long options with double dash ('-')
    … …  
    162173        case '-':
    163174                if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
    164                         rc = arg_parse_name_int(argc, argv, index, &family, 9,
     175                        rc = arg_parse_name_int(argc, argv, index, &value, 9,
    165176                            socket_parse_protocol_family);
    166177                        if (rc != EOK)
    167178                                return rc;
     179                       
     180                        family = (uint16_t) value;
    168181                } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
    169182                        nettest1_print_help();
    … …  
    181194                        if (rc != EOK)
    182195                                return rc;
     196                       
    183197                        port = (uint16_t) value;
    184198                } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
    … …  
    187201                        if (rc != EOK)
    188202                                return rc;
     203                       
    189204                        type = (sock_type_t) value;
    190205                } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
    … …  
    199214                return EINVAL;
    200215        }
    201 
     216       
    202217        return EOK;
    203218}
    … …  
    210225static void nettest1_fill_buffer(char *buffer, size_t size)
    211226{
    212         size_t length;
    213 
    214         length = 0;
     227        size_t length = 0;
    215228        while (size > length + sizeof(NETTEST1_TEXT) - 1) {
    216229                memcpy(buffer + length, NETTEST1_TEXT,
    … …  
    218231                length += sizeof(NETTEST1_TEXT) - 1;
    219232        }
    220 
     233       
    221234        memcpy(buffer + length, NETTEST1_TEXT, size - length);
    222235        buffer[size] = '\0';
    … …  
    225238static int nettest1_test(int *socket_ids, int nsockets, int nmessages)
    226239{
    227         int rc;
    228 
    229240        if (verbose)
    230241                printf("%d sockets, %d messages\n", nsockets, nmessages);
    231 
    232         rc = sockets_create(verbose, socket_ids, nsockets, family, type);
    233         if (rc != EOK)
    234                 return rc;
    235 
     242       
     243        int rc = sockets_create(verbose, socket_ids, nsockets, family, type);
     244        if (rc != EOK)
     245                return rc;
     246       
    236247        if (type == SOCK_STREAM) {
    237248                rc = sockets_connect(verbose, socket_ids, nsockets, address,
    … …  
    240251                        return rc;
    241252        }
    242 
     253       
    243254        rc = sockets_sendto_recvfrom(verbose, socket_ids, nsockets, address,
    244             &addrlen, data, size, nmessages);
    245         if (rc != EOK)
    246                 return rc;
    247 
     255            &addrlen, data, size, nmessages, type);
     256        if (rc != EOK)
     257                return rc;
     258       
    248259        rc = sockets_close(verbose, socket_ids, nsockets);
    249260        if (rc != EOK)
    250261                return rc;
    251 
     262       
    252263        if (verbose)
    253264                printf("\tOK\n");
    254 
     265       
    255266        /****/
    256 
     267       
    257268        rc = sockets_create(verbose, socket_ids, nsockets, family, type);
    258269        if (rc != EOK)
    259270                return rc;
    260 
     271       
    261272        if (type == SOCK_STREAM) {
    262273                rc = sockets_connect(verbose, socket_ids, nsockets, address,
    … …  
    265276                        return rc;
    266277        }
    267 
     278       
    268279        rc = sockets_sendto(verbose, socket_ids, nsockets, address, addrlen,
    269             data, size, nmessages);
    270         if (rc != EOK)
    271                 return rc;
    272 
     280            data, size, nmessages, type);
     281        if (rc != EOK)
     282                return rc;
     283       
    273284        rc = sockets_recvfrom(verbose, socket_ids, nsockets, address, &addrlen,
    274285            data, size, nmessages);
    275286        if (rc != EOK)
    276287                return rc;
    277 
     288       
    278289        rc = sockets_close(verbose, socket_ids, nsockets);
    279290        if (rc != EOK)
    280291                return rc;
    281 
     292       
    282293        if (verbose)
    283294                printf("\tOK\n");
    284 
     295       
    285296        return EOK;
    286297}
    … …  
    288299int main(int argc, char *argv[])
    289300{
    290         struct sockaddr_in address_in;
    291         struct sockaddr_in6 address_in6;
    292         uint8_t *address_start;
    293 
    294         int *socket_ids;
    295         int index;
    296         struct timeval time_before;
    297         struct timeval time_after;
    298 
    299         int rc;
    300 
    301         sockets = 10;
    302         messages = 10;
    303         port = 7;
    304 
    305301        /*
    306302         * Parse the command line arguments. Stop before the last argument
    307303         * if it does not start with dash ('-')
    308304         */
    309         for (index = 1; (index < argc - 1) || ((index == argc - 1) && (argv[index][0] == '-')); index++) {
     305        int index;
     306        int rc;
     307       
     308        for (index = 1; (index < argc - 1) || ((index == argc - 1) &&
     309            (argv[index][0] == '-')); index++) {
    310310                /* Options should start with dash ('-') */
    311311                if (argv[index][0] == '-') {
    … …  
    318318                }
    319319        }
    320 
    321         /* If not before the last argument containing the address */
     320       
     321        /* The last argument containing the host */
    322322        if (index >= argc) {
    323                 printf("Command line error: missing address\n");
     323                printf("Host name missing.\n");
    324324                nettest1_print_help();
    325325                return EINVAL;
    326326        }
    327 
     327       
     328        char *addr_s = argv[argc - 1];
     329       
     330        /* Interpret as address */
     331        inet_addr_t addr_addr;
     332        rc = inet_addr_parse(addr_s, &addr_addr);
     333       
     334        if (rc != EOK) {
     335                /* Interpret as a host name */
     336                dnsr_hostinfo_t *hinfo = NULL;
     337                rc = dnsr_name2host(addr_s, &hinfo, family);
     338               
     339                if (rc != EOK) {
     340                        printf("Error resolving host '%s'.\n", addr_s);
     341                        return EINVAL;
     342                }
     343               
     344                addr_addr = hinfo->addr;
     345        }
     346       
     347        struct sockaddr_in addr;
     348        struct sockaddr_in6 addr6;
     349        uint16_t af = inet_addr_sockaddr_in(&addr_addr, &addr, &addr6);
     350       
     351        if (af != family) {
     352                printf("Address family does not match explicitly set family.\n");
     353                return EINVAL;
     354        }
     355       
    328356        /* Prepare the address buffer */
    329 
    330         switch (family) {
    331         case PF_INET:
    332                 address_in.sin_family = AF_INET;
    333                 address_in.sin_port = htons(port);
    334                 address = (struct sockaddr *) &address_in;
    335                 addrlen = sizeof(address_in);
    336                 address_start = (uint8_t *) &address_in.sin_addr.s_addr;
    337                 break;
    338         case PF_INET6:
    339                 address_in6.sin6_family = AF_INET6;
    340                 address_in6.sin6_port = htons(port);
    341                 address = (struct sockaddr *) &address_in6;
    342                 addrlen = sizeof(address_in6);
    343                 address_start = (uint8_t *) &address_in6.sin6_addr.s6_addr;
     357       
     358        switch (af) {
     359        case AF_INET:
     360                addr.sin_port = htons(port);
     361                address = (struct sockaddr *) &addr;
     362                addrlen = sizeof(addr);
     363                break;
     364        case AF_INET6:
     365                addr6.sin6_port = htons(port);
     366                address = (struct sockaddr *) &addr6;
     367                addrlen = sizeof(addr6);
    344368                break;
    345369        default:
    … …  
    347371                return EAFNOSUPPORT;
    348372        }
    349 
    350         /* Parse the last argument which should contain the address */
    351         rc = inet_pton(family, argv[argc - 1], address_start);
    352         if (rc != EOK) {
    353                 fprintf(stderr, "Address parse error %d\n", rc);
    354                 return rc;
    355         }
    356 
     373       
    357374        /* Check data buffer size */
    358375        if (size <= 0) {
    … …  
    361378                size = 1024;
    362379        }
    363 
     380       
    364381        /*
    365382         * Prepare data buffer. Allocate size bytes plus one for the
    … …  
    372389        }
    373390        nettest1_fill_buffer(data, size);
    374 
     391       
    375392        /* Check socket count */
    376393        if (sockets <= 0) {
    … …  
    379396                sockets = 2;
    380397        }
    381 
     398       
    382399        /*
    383400         * Prepare socket buffer. Allocate count fields plus the terminating
    384401         * null (\0).
    385402         */
    386         socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
     403        int *socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
    387404        if (!socket_ids) {
    388405                fprintf(stderr, "Failed to allocate receive buffer.\n");
    389406                return ENOMEM;
    390407        }
     408       
    391409        socket_ids[sockets] = 0;
    392 
     410       
    393411        if (verbose)
    394412                printf("Starting tests\n");
    395 
     413       
     414        struct timeval time_before;
    396415        rc = gettimeofday(&time_before, NULL);
    397416        if (rc != EOK) {
    … …  
    399418                return rc;
    400419        }
    401 
     420       
    402421        nettest1_test(socket_ids,       1,        1);
    403422        nettest1_test(socket_ids,       1, messages);
    404423        nettest1_test(socket_ids, sockets,        1);
    405424        nettest1_test(socket_ids, sockets, messages);
    406 
     425       
     426        struct timeval time_after;
    407427        rc = gettimeofday(&time_after, NULL);
    408428        if (rc != EOK) {
    … …  
    410430                return rc;
    411431        }
    412 
     432       
    413433        printf("Tested in %ld microseconds\n", tv_sub(&time_after,
    414434            &time_before));
    415 
     435       
    416436        if (verbose)
    417437                printf("Exiting\n");
    418 
     438       
    419439        return EOK;
    420440}
    421441
    422 
    423442/** @}
    424443 */
Note: See TracChangeset for help on using the changeset viewer.