Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/nettest1/nettest1.c

    rc442f63 rd4d74dc  
    4646#include <arg_parse.h>
    4747
    48 #include <inet/dnsr.h>
    4948#include <net/in.h>
    5049#include <net/in6.h>
    … …  
    5453
    5554/** Echo module name. */
    56 #define NAME  "nettest1"
     55#define NAME    "Nettest1"
    5756
    5857/** Packet data pattern. */
    59 #define NETTEST1_TEXT  "Networking test 1 - sockets"
    60 
    61 static uint16_t family = AF_INET;
     58#define NETTEST1_TEXT   "Networking test 1 - sockets"
     59
     60static int family = PF_INET;
    6261static sock_type_t type = SOCK_DGRAM;
     62static char *data;
    6363static size_t size = 27;
    64 static bool verbose = false;
    65 static int sockets = 10;
    66 static int messages = 10;
    67 static uint16_t port = 7;
     64static int verbose = 0;
    6865
    6966static struct sockaddr *address;
    7067static socklen_t addrlen;
    7168
    72 static char *data;
     69static int sockets;
     70static int messages;
     71static uint16_t port;
    7372
    7473static void nettest1_print_help(void)
    … …  
    7675        printf(
    7776            "Network Networking test 1 aplication - sockets\n"
    78             "Usage: nettest1 [options] host\n"
     77            "Usage: echo [options] numeric_address\n"
    7978            "Where options are:\n"
    8079            "-f protocol_family | --family=protocol_family\n"
    … …  
    114113        int value;
    115114        int rc;
    116        
     115
    117116        switch (argv[*index][1]) {
    118117        /*
    … …  
    120119         */
    121120        case 'f':
    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;
     121                rc = arg_parse_name_int(argc, argv, index, &family, 0, socket_parse_protocol_family);
     122                if (rc != EOK)
     123                        return rc;
    128124                break;
    129125        case 'h':
    … …  
    134130                if (rc != EOK)
    135131                        return rc;
    136                
    137132                break;
    138133        case 'n':
    … …  
    140135                if (rc != EOK)
    141136                        return rc;
    142                
    143137                break;
    144138        case 'p':
    … …  
    146140                if (rc != EOK)
    147141                        return rc;
    148                
    149142                port = (uint16_t) value;
    150143                break;
    … …  
    153146                if (rc != EOK)
    154147                        return rc;
    155                
    156148                size = (value >= 0) ? (size_t) value : 0;
    157149                break;
    158150        case 't':
    159                 rc = arg_parse_name_int(argc, argv, index, &value, 0,
    160                     socket_parse_socket_type);
    161                 if (rc != EOK)
    162                         return rc;
    163                
     151                rc = arg_parse_name_int(argc, argv, index, &value, 0, socket_parse_socket_type);
     152                if (rc != EOK)
     153                        return rc;
    164154                type = (sock_type_t) value;
    165155                break;
    … …  
    167157                verbose = 1;
    168158                break;
    169        
    170159        /*
    171160         * Long options with double dash ('-')
    … …  
    173162        case '-':
    174163                if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
    175                         rc = arg_parse_name_int(argc, argv, index, &value, 9,
     164                        rc = arg_parse_name_int(argc, argv, index, &family, 9,
    176165                            socket_parse_protocol_family);
    177166                        if (rc != EOK)
    178167                                return rc;
    179                        
    180                         family = (uint16_t) value;
    181168                } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
    182169                        nettest1_print_help();
    … …  
    194181                        if (rc != EOK)
    195182                                return rc;
    196                        
    197183                        port = (uint16_t) value;
    198184                } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
    … …  
    201187                        if (rc != EOK)
    202188                                return rc;
    203                        
    204189                        type = (sock_type_t) value;
    205190                } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
    … …  
    214199                return EINVAL;
    215200        }
    216        
     201
    217202        return EOK;
    218203}
    … …  
    225210static void nettest1_fill_buffer(char *buffer, size_t size)
    226211{
    227         size_t length = 0;
     212        size_t length;
     213
     214        length = 0;
    228215        while (size > length + sizeof(NETTEST1_TEXT) - 1) {
    229216                memcpy(buffer + length, NETTEST1_TEXT,
    … …  
    231218                length += sizeof(NETTEST1_TEXT) - 1;
    232219        }
    233        
     220
    234221        memcpy(buffer + length, NETTEST1_TEXT, size - length);
    235222        buffer[size] = '\0';
    … …  
    238225static int nettest1_test(int *socket_ids, int nsockets, int nmessages)
    239226{
     227        int rc;
     228
    240229        if (verbose)
    241230                printf("%d sockets, %d messages\n", nsockets, nmessages);
    242        
    243         int rc = sockets_create(verbose, socket_ids, nsockets, family, type);
    244         if (rc != EOK)
    245                 return rc;
    246        
     231
     232        rc = sockets_create(verbose, socket_ids, nsockets, family, type);
     233        if (rc != EOK)
     234                return rc;
     235
    247236        if (type == SOCK_STREAM) {
    248237                rc = sockets_connect(verbose, socket_ids, nsockets, address,
    … …  
    251240                        return rc;
    252241        }
    253        
     242
    254243        rc = sockets_sendto_recvfrom(verbose, socket_ids, nsockets, address,
    255             &addrlen, data, size, nmessages, type);
    256         if (rc != EOK)
    257                 return rc;
    258        
     244            &addrlen, data, size, nmessages);
     245        if (rc != EOK)
     246                return rc;
     247
    259248        rc = sockets_close(verbose, socket_ids, nsockets);
    260249        if (rc != EOK)
    261250                return rc;
    262        
     251
    263252        if (verbose)
    264253                printf("\tOK\n");
    265        
     254
    266255        /****/
    267        
     256
    268257        rc = sockets_create(verbose, socket_ids, nsockets, family, type);
    269258        if (rc != EOK)
    270259                return rc;
    271        
     260
    272261        if (type == SOCK_STREAM) {
    273262                rc = sockets_connect(verbose, socket_ids, nsockets, address,
    … …  
    276265                        return rc;
    277266        }
    278        
     267
    279268        rc = sockets_sendto(verbose, socket_ids, nsockets, address, addrlen,
    280             data, size, nmessages, type);
    281         if (rc != EOK)
    282                 return rc;
    283        
     269            data, size, nmessages);
     270        if (rc != EOK)
     271                return rc;
     272
    284273        rc = sockets_recvfrom(verbose, socket_ids, nsockets, address, &addrlen,
    285274            data, size, nmessages);
    286275        if (rc != EOK)
    287276                return rc;
    288        
     277
    289278        rc = sockets_close(verbose, socket_ids, nsockets);
    290279        if (rc != EOK)
    291280                return rc;
    292        
     281
    293282        if (verbose)
    294283                printf("\tOK\n");
    295        
     284
    296285        return EOK;
    297286}
    … …  
    299288int main(int argc, char *argv[])
    300289{
     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
    301305        /*
    302306         * Parse the command line arguments. Stop before the last argument
    303307         * if it does not start with dash ('-')
    304308         */
    305         int index;
    306         int rc;
    307        
    308         for (index = 1; (index < argc - 1) || ((index == argc - 1) &&
    309             (argv[index][0] == '-')); index++) {
     309        for (index = 1; (index < argc - 1) || ((index == argc - 1) && (argv[index][0] == '-')); index++) {
    310310                /* Options should start with dash ('-') */
    311311                if (argv[index][0] == '-') {
    … …  
    318318                }
    319319        }
    320        
    321         /* The last argument containing the host */
     320
     321        /* If not before the last argument containing the address */
    322322        if (index >= argc) {
    323                 printf("Host name missing.\n");
     323                printf("Command line error: missing address\n");
    324324                nettest1_print_help();
    325325                return EINVAL;
    326326        }
    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        
     327
    356328        /* Prepare the address buffer */
    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);
     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;
    368344                break;
    369345        default:
    … …  
    371347                return EAFNOSUPPORT;
    372348        }
    373        
     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
    374357        /* Check data buffer size */
    375358        if (size <= 0) {
    … …  
    378361                size = 1024;
    379362        }
    380        
     363
    381364        /*
    382365         * Prepare data buffer. Allocate size bytes plus one for the
    … …  
    389372        }
    390373        nettest1_fill_buffer(data, size);
    391        
     374
    392375        /* Check socket count */
    393376        if (sockets <= 0) {
    … …  
    396379                sockets = 2;
    397380        }
    398        
     381
    399382        /*
    400383         * Prepare socket buffer. Allocate count fields plus the terminating
    401384         * null (\0).
    402385         */
    403         int *socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
     386        socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
    404387        if (!socket_ids) {
    405388                fprintf(stderr, "Failed to allocate receive buffer.\n");
    406389                return ENOMEM;
    407390        }
    408        
    409391        socket_ids[sockets] = 0;
    410        
     392
    411393        if (verbose)
    412394                printf("Starting tests\n");
    413        
    414         struct timeval time_before;
     395
    415396        rc = gettimeofday(&time_before, NULL);
    416397        if (rc != EOK) {
    … …  
    418399                return rc;
    419400        }
    420        
     401
    421402        nettest1_test(socket_ids,       1,        1);
    422403        nettest1_test(socket_ids,       1, messages);
    423404        nettest1_test(socket_ids, sockets,        1);
    424405        nettest1_test(socket_ids, sockets, messages);
    425        
    426         struct timeval time_after;
     406
    427407        rc = gettimeofday(&time_after, NULL);
    428408        if (rc != EOK) {
    … …  
    430410                return rc;
    431411        }
    432        
     412
    433413        printf("Tested in %ld microseconds\n", tv_sub(&time_after,
    434414            &time_before));
    435        
     415
    436416        if (verbose)
    437417                printf("Exiting\n");
    438        
     418
    439419        return EOK;
    440420}
    441421
     422
    442423/** @}
    443424 */
Note: See TracChangeset for help on using the changeset viewer.