Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/nettest2/nettest2.c

    rc442f63 rfff7ef4  
    5555
    5656/** Echo module name. */
    57 #define NAME  "nettest2"
     57#define NAME    "Nettest2"
    5858
    5959/** 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;
     60#define NETTEST2_TEXT   "Networking test 2 - transfer"
     61
     62static size_t size;
     63static bool verbose;
     64static sock_type_t type;
     65static int sockets;
     66static int messages;
     67static int family;
     68static uint16_t port;
    6969
    7070static void nettest2_print_help(void)
    … …  
    107107static void nettest2_fill_buffer(char *buffer, size_t size)
    108108{
    109         size_t length = 0;
     109        size_t length;
     110
     111        length = 0;
    110112        while (size > length + sizeof(NETTEST2_TEXT) - 1) {
    111113                memcpy(buffer + length, NETTEST2_TEXT,
    … …  
    113115                length += sizeof(NETTEST2_TEXT) - 1;
    114116        }
    115        
     117
    116118        memcpy(buffer + length, NETTEST2_TEXT, size - length);
    117119        buffer[size] = '\0';
    … …  
    128130        int value;
    129131        int rc;
    130        
     132
    131133        switch (argv[*index][1]) {
    132134        /*
    … …  
    134136         */
    135137        case 'f':
    136                 rc = arg_parse_name_int(argc, argv, index, &value, 0,
     138                rc = arg_parse_name_int(argc, argv, index, &family, 0,
    137139                    socket_parse_protocol_family);
    138140                if (rc != EOK)
    139141                        return rc;
    140                
    141                 family = (uint16_t) value;
    142142                break;
    143143        case 'h':
    144144                nettest2_print_help();
    145145                return EOK;
     146                break;
    146147        case 'm':
    147148                rc = arg_parse_int(argc, argv, index, &messages, 0);
    148149                if (rc != EOK)
    149150                        return rc;
    150                
    151151                break;
    152152        case 'n':
    … …  
    154154                if (rc != EOK)
    155155                        return rc;
    156                
    157156                break;
    158157        case 'p':
    … …  
    160159                if (rc != EOK)
    161160                        return rc;
    162                
    163161                port = (uint16_t) value;
    164162                break;
    … …  
    167165                if (rc != EOK)
    168166                        return rc;
    169                
    170167                size = (value >= 0) ? (size_t) value : 0;
    171168                break;
    … …  
    175172                if (rc != EOK)
    176173                        return rc;
    177                
    178174                type = (sock_type_t) value;
    179175                break;
    … …  
    181177                verbose = true;
    182178                break;
    183        
    184179        /*
    185180         * Long options with double dash ('-')
    … …  
    187182        case '-':
    188183                if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
    189                         rc = arg_parse_name_int(argc, argv, index, &value, 9,
     184                        rc = arg_parse_name_int(argc, argv, index, &family, 9,
    190185                            socket_parse_protocol_family);
    191186                        if (rc != EOK)
    192187                                return rc;
    193                        
    194                         family = (uint16_t) value;
    195188                } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
    196189                        nettest2_print_help();
    … …  
    208201                        if (rc != EOK)
    209202                                return rc;
    210                        
    211203                        port = (uint16_t) value;
    212204                } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
    … …  
    215207                        if (rc != EOK)
    216208                                return rc;
    217                        
    218209                        type = (sock_type_t) value;
    219210                } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
    … …  
    228219                return EINVAL;
    229220        }
    230        
     221
    231222        return EOK;
    232223}
    … …  
    234225int main(int argc, char *argv[])
    235226{
     227        struct sockaddr *address;
     228        struct sockaddr_in address_in;
     229        struct sockaddr_in6 address_in6;
     230        dnsr_hostinfo_t *hinfo;
     231        socklen_t addrlen;
     232        uint8_t *address_start;
     233
     234        int *socket_ids;
     235        char *data;
    236236        int index;
     237        struct timeval time_before;
     238        struct timeval time_after;
     239
    237240        int rc;
    238        
     241
     242        size = 28;
     243        verbose = false;
     244        type = SOCK_DGRAM;
     245        sockets = 10;
     246        messages = 10;
     247        family = PF_INET;
     248        port = 7;
     249
    239250        /*
    240251         * Parse the command line arguments.
    … …  
    244255        for (index = 1; (index < argc - 1) || ((index == argc - 1) &&
    245256            (argv[index][0] == '-')); ++index) {
     257
    246258                /* Options should start with dash ('-') */
    247259                if (argv[index][0] == '-') {
    … …  
    254266                }
    255267        }
    256        
    257         /* The last argument containing the host */
     268
     269        /* If not before the last argument containing the host */
    258270        if (index >= argc) {
    259                 printf("Host name missing.\n");
     271                printf("Command line error: missing host name\n");
    260272                nettest2_print_help();
    261273                return EINVAL;
    262274        }
    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        
     275
    292276        /* 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);
     277
     278        switch (family) {
     279        case PF_INET:
     280                address_in.sin_family = AF_INET;
     281                address_in.sin_port = htons(port);
     282                address = (struct sockaddr *) &address_in;
     283                addrlen = sizeof(address_in);
     284                address_start = (uint8_t *) &address_in.sin_addr.s_addr;
     285                break;
     286        case PF_INET6:
     287                address_in6.sin6_family = AF_INET6;
     288                address_in6.sin6_port = htons(port);
     289                address = (struct sockaddr *) &address_in6;
     290                addrlen = sizeof(address_in6);
     291                address_start = (uint8_t *) &address_in6.sin6_addr.s6_addr;
    307292                break;
    308293        default:
    … …  
    310295                return EAFNOSUPPORT;
    311296        }
    312        
     297
     298        /* Parse the last argument which should contain the host/address */
     299        rc = inet_pton(family, argv[argc - 1], address_start);
     300        if (rc != EOK) {
     301                /* Try interpreting as a host name */
     302                rc = dnsr_name2host(argv[argc - 1], &hinfo);
     303                if (rc != EOK) {
     304                        printf("Error resolving host '%s'.\n", argv[argc - 1]);
     305                        return rc;
     306                }
     307
     308                address_in.sin_addr.s_addr = host2uint32_t_be(hinfo->addr.ipv4);
     309        }
     310
    313311        /* Check data buffer size. */
    314312        if (size <= 0) {
    … …  
    317315                size = 1024;
    318316        }
    319        
     317
    320318        /*
    321319         * Prepare the buffer. Allocate size bytes plus one for terminating
    322320         * null character.
    323321         */
    324         char *data = (char *) malloc(size + 1);
     322        data = (char *) malloc(size + 1);
    325323        if (!data) {
    326324                fprintf(stderr, "Failed to allocate data buffer.\n");
    327325                return ENOMEM;
    328326        }
    329        
     327
    330328        /* Fill buffer with a pattern. */
    331329        nettest2_fill_buffer(data, size);
    332        
     330
    333331        /* Check socket count. */
    334332        if (sockets <= 0) {
    … …  
    337335                sockets = 2;
    338336        }
    339        
     337
    340338        /*
    341339         * Prepare the socket buffer.
    342340         * Allocate count entries plus the terminating null (\0)
    343341         */
    344         int *socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
     342        socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
    345343        if (!socket_ids) {
    346344                fprintf(stderr, "Failed to allocate receive buffer.\n");
    347345                return ENOMEM;
    348346        }
    349        
    350347        socket_ids[sockets] = 0;
    351        
     348
    352349        if (verbose)
    353350                printf("Starting tests\n");
    354        
     351
    355352        rc = sockets_create(verbose, socket_ids, sockets, family, type);
    356353        if (rc != EOK)
    357354                return rc;
    358        
     355
    359356        if (type == SOCK_STREAM) {
    360357                rc = sockets_connect(verbose, socket_ids, sockets,
    … …  
    363360                        return rc;
    364361        }
    365        
     362
    366363        if (verbose)
    367364                printf("\n");
    368        
    369         struct timeval time_before;
     365
    370366        rc = gettimeofday(&time_before, NULL);
    371367        if (rc != EOK) {
    … …  
    373369                return rc;
    374370        }
    375        
     371
    376372        rc = sockets_sendto_recvfrom(verbose, socket_ids, sockets, address,
    377             &addrlen, data, size, messages, type);
     373            &addrlen, data, size, messages);
    378374        if (rc != EOK)
    379375                return rc;
    380        
    381         struct timeval time_after;
     376
    382377        rc = gettimeofday(&time_after, NULL);
    383378        if (rc != EOK) {
    … …  
    385380                return rc;
    386381        }
    387        
     382
    388383        if (verbose)
    389384                printf("\tOK\n");
    390        
     385
    391386        printf("sendto + recvfrom tested in %ld microseconds\n",
    392387            tv_sub(&time_after, &time_before));
    393        
     388
    394389        rc = gettimeofday(&time_before, NULL);
    395390        if (rc != EOK) {
    … …  
    397392                return rc;
    398393        }
    399        
     394
    400395        rc = sockets_sendto(verbose, socket_ids, sockets, address, addrlen,
    401             data, size, messages, type);
     396            data, size, messages);
    402397        if (rc != EOK)
    403398                return rc;
    404        
     399
    405400        rc = sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen,
    406401            data, size, messages);
    407402        if (rc != EOK)
    408403                return rc;
    409        
     404
    410405        rc = gettimeofday(&time_after, NULL);
    411406        if (rc != EOK) {
    … …  
    413408                return rc;
    414409        }
    415        
     410
    416411        if (verbose)
    417412                printf("\tOK\n");
    418        
     413
    419414        printf("sendto, recvfrom tested in %ld microseconds\n",
    420415            tv_sub(&time_after, &time_before));
    421        
     416
    422417        rc = sockets_close(verbose, socket_ids, sockets);
    423418        if (rc != EOK)
    424419                return rc;
    425        
     420
    426421        if (verbose)
    427422                printf("\nExiting\n");
    428        
     423
    429424        return EOK;
    430425}
Note: See TracChangeset for help on using the changeset viewer.