Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/nettest2/nettest2.c

    rc442f63 r3e6a98c5  
    4747#include <stdbool.h>
    4848
    49 #include <inet/dnsr.h>
    5049#include <net/in.h>
    5150#include <net/in6.h>
    … …  
    5554
    5655/** Echo module name. */
    57 #define NAME  "nettest2"
     56#define NAME    "Nettest2"
    5857
    5958/** Packet data pattern. */
    60 #define NETTEST2_TEXT  "Networking test 2 - transfer"
    61 
    62 static uint16_t family = PF_INET;
    63 static size_t size = 28;
    64 static bool verbose = false;
    65 static sock_type_t type = SOCK_DGRAM;
    66 static int sockets = 10;
    67 static int messages = 10;
    68 static uint16_t port = 7;
     59#define NETTEST2_TEXT   "Networking test 2 - transfer"
     60
     61static size_t size;
     62static bool verbose;
     63static sock_type_t type;
     64static int sockets;
     65static int messages;
     66static int family;
     67static uint16_t port;
    6968
    7069static void nettest2_print_help(void)
    … …  
    7271        printf(
    7372            "Network Networking test 2 aplication - UDP transfer\n"
    74             "Usage: nettest2 [options] host\n"
     73            "Usage: echo [options] address\n"
    7574            "Where options are:\n"
    7675            "-f protocol_family | --family=protocol_family\n"
    … …  
    107106static void nettest2_fill_buffer(char *buffer, size_t size)
    108107{
    109         size_t length = 0;
     108        size_t length;
     109
     110        length = 0;
    110111        while (size > length + sizeof(NETTEST2_TEXT) - 1) {
    111112                memcpy(buffer + length, NETTEST2_TEXT,
    … …  
    113114                length += sizeof(NETTEST2_TEXT) - 1;
    114115        }
    115        
     116
    116117        memcpy(buffer + length, NETTEST2_TEXT, size - length);
    117118        buffer[size] = '\0';
    … …  
    128129        int value;
    129130        int rc;
    130        
     131
    131132        switch (argv[*index][1]) {
    132133        /*
    … …  
    134135         */
    135136        case 'f':
    136                 rc = arg_parse_name_int(argc, argv, index, &value, 0,
     137                rc = arg_parse_name_int(argc, argv, index, &family, 0,
    137138                    socket_parse_protocol_family);
    138139                if (rc != EOK)
    139140                        return rc;
    140                
    141                 family = (uint16_t) value;
    142141                break;
    143142        case 'h':
    144143                nettest2_print_help();
    145144                return EOK;
     145                break;
    146146        case 'm':
    147147                rc = arg_parse_int(argc, argv, index, &messages, 0);
    148148                if (rc != EOK)
    149149                        return rc;
    150                
    151150                break;
    152151        case 'n':
    … …  
    154153                if (rc != EOK)
    155154                        return rc;
    156                
    157155                break;
    158156        case 'p':
    … …  
    160158                if (rc != EOK)
    161159                        return rc;
    162                
    163160                port = (uint16_t) value;
    164161                break;
    … …  
    167164                if (rc != EOK)
    168165                        return rc;
    169                
    170166                size = (value >= 0) ? (size_t) value : 0;
    171167                break;
    … …  
    175171                if (rc != EOK)
    176172                        return rc;
    177                
    178173                type = (sock_type_t) value;
    179174                break;
    … …  
    181176                verbose = true;
    182177                break;
    183        
    184178        /*
    185179         * Long options with double dash ('-')
    … …  
    187181        case '-':
    188182                if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
    189                         rc = arg_parse_name_int(argc, argv, index, &value, 9,
     183                        rc = arg_parse_name_int(argc, argv, index, &family, 9,
    190184                            socket_parse_protocol_family);
    191185                        if (rc != EOK)
    192186                                return rc;
    193                        
    194                         family = (uint16_t) value;
    195187                } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
    196188                        nettest2_print_help();
    … …  
    208200                        if (rc != EOK)
    209201                                return rc;
    210                        
    211202                        port = (uint16_t) value;
    212203                } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
    … …  
    215206                        if (rc != EOK)
    216207                                return rc;
    217                        
    218208                        type = (sock_type_t) value;
    219209                } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
    … …  
    228218                return EINVAL;
    229219        }
    230        
     220
    231221        return EOK;
    232222}
    … …  
    234224int main(int argc, char *argv[])
    235225{
     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;
    236234        int index;
     235        struct timeval time_before;
     236        struct timeval time_after;
     237
    237238        int rc;
    238        
     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
    239248        /*
    240249         * Parse the command line arguments.
    … …  
    244253        for (index = 1; (index < argc - 1) || ((index == argc - 1) &&
    245254            (argv[index][0] == '-')); ++index) {
     255
    246256                /* Options should start with dash ('-') */
    247257                if (argv[index][0] == '-') {
    … …  
    254264                }
    255265        }
    256        
    257         /* The last argument containing the host */
     266
     267        /* If not before the last argument containing the address */
    258268        if (index >= argc) {
    259                 printf("Host name missing.\n");
     269                printf("Command line error: missing address\n");
    260270                nettest2_print_help();
    261271                return EINVAL;
    262272        }
    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, family);
    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        
     273
    292274        /* Prepare the address buffer */
    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);
     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;
    307290                break;
    308291        default:
    … …  
    310293                return EAFNOSUPPORT;
    311294        }
    312        
     295
     296        /* Parse the last argument which should contain the address. */
     297        rc = inet_pton(family, argv[argc - 1], address_start);
     298        if (rc != EOK) {
     299                fprintf(stderr, "Address parse error %d\n", rc);
     300                return rc;
     301        }
     302
    313303        /* Check data buffer size. */
    314304        if (size <= 0) {
    … …  
    317307                size = 1024;
    318308        }
    319        
     309
    320310        /*
    321311         * Prepare the buffer. Allocate size bytes plus one for terminating
    322312         * null character.
    323313         */
    324         char *data = (char *) malloc(size + 1);
     314        data = (char *) malloc(size + 1);
    325315        if (!data) {
    326316                fprintf(stderr, "Failed to allocate data buffer.\n");
    327317                return ENOMEM;
    328318        }
    329        
     319
    330320        /* Fill buffer with a pattern. */
    331321        nettest2_fill_buffer(data, size);
    332        
     322
    333323        /* Check socket count. */
    334324        if (sockets <= 0) {
    … …  
    337327                sockets = 2;
    338328        }
    339        
     329
    340330        /*
    341331         * Prepare the socket buffer.
    342332         * Allocate count entries plus the terminating null (\0)
    343333         */
    344         int *socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
     334        socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
    345335        if (!socket_ids) {
    346336                fprintf(stderr, "Failed to allocate receive buffer.\n");
    347337                return ENOMEM;
    348338        }
    349        
    350339        socket_ids[sockets] = 0;
    351        
     340
    352341        if (verbose)
    353342                printf("Starting tests\n");
    354        
     343
    355344        rc = sockets_create(verbose, socket_ids, sockets, family, type);
    356345        if (rc != EOK)
    357346                return rc;
    358        
     347
    359348        if (type == SOCK_STREAM) {
    360349                rc = sockets_connect(verbose, socket_ids, sockets,
    … …  
    363352                        return rc;
    364353        }
    365        
     354
    366355        if (verbose)
    367356                printf("\n");
    368        
    369         struct timeval time_before;
     357
    370358        rc = gettimeofday(&time_before, NULL);
    371359        if (rc != EOK) {
    … …  
    373361                return rc;
    374362        }
    375        
     363
    376364        rc = sockets_sendto_recvfrom(verbose, socket_ids, sockets, address,
    377             &addrlen, data, size, messages, type);
     365            &addrlen, data, size, messages);
    378366        if (rc != EOK)
    379367                return rc;
    380        
    381         struct timeval time_after;
     368
    382369        rc = gettimeofday(&time_after, NULL);
    383370        if (rc != EOK) {
    … …  
    385372                return rc;
    386373        }
    387        
     374
    388375        if (verbose)
    389376                printf("\tOK\n");
    390        
     377
    391378        printf("sendto + recvfrom tested in %ld microseconds\n",
    392379            tv_sub(&time_after, &time_before));
    393        
     380
    394381        rc = gettimeofday(&time_before, NULL);
    395382        if (rc != EOK) {
    … …  
    397384                return rc;
    398385        }
    399        
     386
    400387        rc = sockets_sendto(verbose, socket_ids, sockets, address, addrlen,
    401             data, size, messages, type);
     388            data, size, messages);
    402389        if (rc != EOK)
    403390                return rc;
    404        
     391
    405392        rc = sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen,
    406393            data, size, messages);
    407394        if (rc != EOK)
    408395                return rc;
    409        
     396
    410397        rc = gettimeofday(&time_after, NULL);
    411398        if (rc != EOK) {
    … …  
    413400                return rc;
    414401        }
    415        
     402
    416403        if (verbose)
    417404                printf("\tOK\n");
    418        
     405
    419406        printf("sendto, recvfrom tested in %ld microseconds\n",
    420407            tv_sub(&time_after, &time_before));
    421        
     408
    422409        rc = sockets_close(verbose, socket_ids, sockets);
    423410        if (rc != EOK)
    424411                return rc;
    425        
     412
    426413        if (verbose)
    427414                printf("\nExiting\n");
    428        
     415
    429416        return EOK;
    430417}
Note: See TracChangeset for help on using the changeset viewer.