Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/nettest2/nettest2.c

    r3e6a98c5 rc442f63  
    4747#include <stdbool.h>
    4848
     49#include <inet/dnsr.h>
    4950#include <net/in.h>
    5051#include <net/in6.h>
     
    5455
    5556/** Echo module name. */
    56 #define NAME    "Nettest2"
     57#define NAME  "nettest2"
    5758
    5859/** Packet data pattern. */
    59 #define NETTEST2_TEXT   "Networking test 2 - transfer"
    60 
    61 static size_t size;
    62 static bool verbose;
    63 static sock_type_t type;
    64 static int sockets;
    65 static int messages;
    66 static int family;
    67 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;
    6869
    6970static void nettest2_print_help(void)
     
    7172        printf(
    7273            "Network Networking test 2 aplication - UDP transfer\n"
    73             "Usage: echo [options] address\n"
     74            "Usage: nettest2 [options] host\n"
    7475            "Where options are:\n"
    7576            "-f protocol_family | --family=protocol_family\n"
     
    106107static void nettest2_fill_buffer(char *buffer, size_t size)
    107108{
    108         size_t length;
    109 
    110         length = 0;
     109        size_t length = 0;
    111110        while (size > length + sizeof(NETTEST2_TEXT) - 1) {
    112111                memcpy(buffer + length, NETTEST2_TEXT,
     
    114113                length += sizeof(NETTEST2_TEXT) - 1;
    115114        }
    116 
     115       
    117116        memcpy(buffer + length, NETTEST2_TEXT, size - length);
    118117        buffer[size] = '\0';
     
    129128        int value;
    130129        int rc;
    131 
     130       
    132131        switch (argv[*index][1]) {
    133132        /*
     
    135134         */
    136135        case 'f':
    137                 rc = arg_parse_name_int(argc, argv, index, &family, 0,
     136                rc = arg_parse_name_int(argc, argv, index, &value, 0,
    138137                    socket_parse_protocol_family);
    139138                if (rc != EOK)
    140139                        return rc;
     140               
     141                family = (uint16_t) value;
    141142                break;
    142143        case 'h':
    143144                nettest2_print_help();
    144145                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               
    150151                break;
    151152        case 'n':
     
    153154                if (rc != EOK)
    154155                        return rc;
     156               
    155157                break;
    156158        case 'p':
     
    158160                if (rc != EOK)
    159161                        return rc;
     162               
    160163                port = (uint16_t) value;
    161164                break;
     
    164167                if (rc != EOK)
    165168                        return rc;
     169               
    166170                size = (value >= 0) ? (size_t) value : 0;
    167171                break;
     
    171175                if (rc != EOK)
    172176                        return rc;
     177               
    173178                type = (sock_type_t) value;
    174179                break;
     
    176181                verbose = true;
    177182                break;
     183       
    178184        /*
    179185         * Long options with double dash ('-')
     
    181187        case '-':
    182188                if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
    183                         rc = arg_parse_name_int(argc, argv, index, &family, 9,
     189                        rc = arg_parse_name_int(argc, argv, index, &value, 9,
    184190                            socket_parse_protocol_family);
    185191                        if (rc != EOK)
    186192                                return rc;
     193                       
     194                        family = (uint16_t) value;
    187195                } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
    188196                        nettest2_print_help();
     
    200208                        if (rc != EOK)
    201209                                return rc;
     210                       
    202211                        port = (uint16_t) value;
    203212                } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
     
    206215                        if (rc != EOK)
    207216                                return rc;
     217                       
    208218                        type = (sock_type_t) value;
    209219                } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
     
    218228                return EINVAL;
    219229        }
    220 
     230       
    221231        return EOK;
    222232}
     
    224234int main(int argc, char *argv[])
    225235{
    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;
    234236        int index;
    235         struct timeval time_before;
    236         struct timeval time_after;
    237 
    238237        int rc;
    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 
     238       
    248239        /*
    249240         * Parse the command line arguments.
     
    253244        for (index = 1; (index < argc - 1) || ((index == argc - 1) &&
    254245            (argv[index][0] == '-')); ++index) {
    255 
    256246                /* Options should start with dash ('-') */
    257247                if (argv[index][0] == '-') {
     
    264254                }
    265255        }
    266 
    267         /* If not before the last argument containing the address */
     256       
     257        /* The last argument containing the host */
    268258        if (index >= argc) {
    269                 printf("Command line error: missing address\n");
     259                printf("Host name missing.\n");
    270260                nettest2_print_help();
    271261                return EINVAL;
    272262        }
    273 
     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       
    274292        /* Prepare the address buffer */
    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;
     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);
    290307                break;
    291308        default:
     
    293310                return EAFNOSUPPORT;
    294311        }
    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 
     312       
    303313        /* Check data buffer size. */
    304314        if (size <= 0) {
     
    307317                size = 1024;
    308318        }
    309 
     319       
    310320        /*
    311321         * Prepare the buffer. Allocate size bytes plus one for terminating
    312322         * null character.
    313323         */
    314         data = (char *) malloc(size + 1);
     324        char *data = (char *) malloc(size + 1);
    315325        if (!data) {
    316326                fprintf(stderr, "Failed to allocate data buffer.\n");
    317327                return ENOMEM;
    318328        }
    319 
     329       
    320330        /* Fill buffer with a pattern. */
    321331        nettest2_fill_buffer(data, size);
    322 
     332       
    323333        /* Check socket count. */
    324334        if (sockets <= 0) {
     
    327337                sockets = 2;
    328338        }
    329 
     339       
    330340        /*
    331341         * Prepare the socket buffer.
    332342         * Allocate count entries plus the terminating null (\0)
    333343         */
    334         socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
     344        int *socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
    335345        if (!socket_ids) {
    336346                fprintf(stderr, "Failed to allocate receive buffer.\n");
    337347                return ENOMEM;
    338348        }
     349       
    339350        socket_ids[sockets] = 0;
    340 
     351       
    341352        if (verbose)
    342353                printf("Starting tests\n");
    343 
     354       
    344355        rc = sockets_create(verbose, socket_ids, sockets, family, type);
    345356        if (rc != EOK)
    346357                return rc;
    347 
     358       
    348359        if (type == SOCK_STREAM) {
    349360                rc = sockets_connect(verbose, socket_ids, sockets,
     
    352363                        return rc;
    353364        }
    354 
     365       
    355366        if (verbose)
    356367                printf("\n");
    357 
     368       
     369        struct timeval time_before;
    358370        rc = gettimeofday(&time_before, NULL);
    359371        if (rc != EOK) {
     
    361373                return rc;
    362374        }
    363 
     375       
    364376        rc = sockets_sendto_recvfrom(verbose, socket_ids, sockets, address,
    365             &addrlen, data, size, messages);
     377            &addrlen, data, size, messages, type);
    366378        if (rc != EOK)
    367379                return rc;
    368 
     380       
     381        struct timeval time_after;
    369382        rc = gettimeofday(&time_after, NULL);
    370383        if (rc != EOK) {
     
    372385                return rc;
    373386        }
    374 
     387       
    375388        if (verbose)
    376389                printf("\tOK\n");
    377 
     390       
    378391        printf("sendto + recvfrom tested in %ld microseconds\n",
    379392            tv_sub(&time_after, &time_before));
    380 
     393       
    381394        rc = gettimeofday(&time_before, NULL);
    382395        if (rc != EOK) {
     
    384397                return rc;
    385398        }
    386 
     399       
    387400        rc = sockets_sendto(verbose, socket_ids, sockets, address, addrlen,
    388             data, size, messages);
     401            data, size, messages, type);
    389402        if (rc != EOK)
    390403                return rc;
    391 
     404       
    392405        rc = sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen,
    393406            data, size, messages);
    394407        if (rc != EOK)
    395408                return rc;
    396 
     409       
    397410        rc = gettimeofday(&time_after, NULL);
    398411        if (rc != EOK) {
     
    400413                return rc;
    401414        }
    402 
     415       
    403416        if (verbose)
    404417                printf("\tOK\n");
    405 
     418       
    406419        printf("sendto, recvfrom tested in %ld microseconds\n",
    407420            tv_sub(&time_after, &time_before));
    408 
     421       
    409422        rc = sockets_close(verbose, socket_ids, sockets);
    410423        if (rc != EOK)
    411424                return rc;
    412 
     425       
    413426        if (verbose)
    414427                printf("\nExiting\n");
    415 
     428       
    416429        return EOK;
    417430}
Note: See TracChangeset for help on using the changeset viewer.