Ignore:
File:
1 edited

Legend:

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

    rfff7ef4 r02a09ed  
    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 size_t size;
    63 static bool verbose;
    64 static sock_type_t type;
    65 static int sockets;
    66 static int messages;
    67 static int family;
    68 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;
    6969
    7070static void nettest2_print_help(void)
     
    107107static void nettest2_fill_buffer(char *buffer, size_t size)
    108108{
    109         size_t length;
    110 
    111         length = 0;
     109        size_t length = 0;
    112110        while (size > length + sizeof(NETTEST2_TEXT) - 1) {
    113111                memcpy(buffer + length, NETTEST2_TEXT,
     
    115113                length += sizeof(NETTEST2_TEXT) - 1;
    116114        }
    117 
     115       
    118116        memcpy(buffer + length, NETTEST2_TEXT, size - length);
    119117        buffer[size] = '\0';
     
    130128        int value;
    131129        int rc;
    132 
     130       
    133131        switch (argv[*index][1]) {
    134132        /*
     
    136134         */
    137135        case 'f':
    138                 rc = arg_parse_name_int(argc, argv, index, &family, 0,
     136                rc = arg_parse_name_int(argc, argv, index, &value, 0,
    139137                    socket_parse_protocol_family);
    140138                if (rc != EOK)
    141139                        return rc;
     140               
     141                family = (uint16_t) value;
    142142                break;
    143143        case 'h':
    144144                nettest2_print_help();
    145145                return EOK;
    146                 break;
    147146        case 'm':
    148147                rc = arg_parse_int(argc, argv, index, &messages, 0);
    149148                if (rc != EOK)
    150149                        return rc;
     150               
    151151                break;
    152152        case 'n':
     
    154154                if (rc != EOK)
    155155                        return rc;
     156               
    156157                break;
    157158        case 'p':
     
    159160                if (rc != EOK)
    160161                        return rc;
     162               
    161163                port = (uint16_t) value;
    162164                break;
     
    165167                if (rc != EOK)
    166168                        return rc;
     169               
    167170                size = (value >= 0) ? (size_t) value : 0;
    168171                break;
     
    172175                if (rc != EOK)
    173176                        return rc;
     177               
    174178                type = (sock_type_t) value;
    175179                break;
     
    177181                verbose = true;
    178182                break;
     183       
    179184        /*
    180185         * Long options with double dash ('-')
     
    182187        case '-':
    183188                if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
    184                         rc = arg_parse_name_int(argc, argv, index, &family, 9,
     189                        rc = arg_parse_name_int(argc, argv, index, &value, 9,
    185190                            socket_parse_protocol_family);
    186191                        if (rc != EOK)
    187192                                return rc;
     193                       
     194                        family = (uint16_t) value;
    188195                } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
    189196                        nettest2_print_help();
     
    201208                        if (rc != EOK)
    202209                                return rc;
     210                       
    203211                        port = (uint16_t) value;
    204212                } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
     
    207215                        if (rc != EOK)
    208216                                return rc;
     217                       
    209218                        type = (sock_type_t) value;
    210219                } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
     
    219228                return EINVAL;
    220229        }
    221 
     230       
    222231        return EOK;
    223232}
     
    225234int main(int argc, char *argv[])
    226235{
    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 
    240237        int rc;
    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 
     238       
    250239        /*
    251240         * Parse the command line arguments.
     
    255244        for (index = 1; (index < argc - 1) || ((index == argc - 1) &&
    256245            (argv[index][0] == '-')); ++index) {
    257 
    258246                /* Options should start with dash ('-') */
    259247                if (argv[index][0] == '-') {
     
    266254                }
    267255        }
    268 
    269         /* If not before the last argument containing the host */
     256       
     257        /* The last argument containing the host */
    270258        if (index >= argc) {
    271                 printf("Command line error: missing host name\n");
     259                printf("Host name missing.\n");
    272260                nettest2_print_help();
    273261                return EINVAL;
    274262        }
    275 
     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);
     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       
    276292        /* Prepare the address buffer */
    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;
     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);
    292307                break;
    293308        default:
     
    295310                return EAFNOSUPPORT;
    296311        }
    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 
     312       
    311313        /* Check data buffer size. */
    312314        if (size <= 0) {
     
    315317                size = 1024;
    316318        }
    317 
     319       
    318320        /*
    319321         * Prepare the buffer. Allocate size bytes plus one for terminating
    320322         * null character.
    321323         */
    322         data = (char *) malloc(size + 1);
     324        char *data = (char *) malloc(size + 1);
    323325        if (!data) {
    324326                fprintf(stderr, "Failed to allocate data buffer.\n");
    325327                return ENOMEM;
    326328        }
    327 
     329       
    328330        /* Fill buffer with a pattern. */
    329331        nettest2_fill_buffer(data, size);
    330 
     332       
    331333        /* Check socket count. */
    332334        if (sockets <= 0) {
     
    335337                sockets = 2;
    336338        }
    337 
     339       
    338340        /*
    339341         * Prepare the socket buffer.
    340342         * Allocate count entries plus the terminating null (\0)
    341343         */
    342         socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
     344        int *socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
    343345        if (!socket_ids) {
    344346                fprintf(stderr, "Failed to allocate receive buffer.\n");
    345347                return ENOMEM;
    346348        }
     349       
    347350        socket_ids[sockets] = 0;
    348 
     351       
    349352        if (verbose)
    350353                printf("Starting tests\n");
    351 
     354       
    352355        rc = sockets_create(verbose, socket_ids, sockets, family, type);
    353356        if (rc != EOK)
    354357                return rc;
    355 
     358       
    356359        if (type == SOCK_STREAM) {
    357360                rc = sockets_connect(verbose, socket_ids, sockets,
     
    360363                        return rc;
    361364        }
    362 
     365       
    363366        if (verbose)
    364367                printf("\n");
    365 
     368       
     369        struct timeval time_before;
    366370        rc = gettimeofday(&time_before, NULL);
    367371        if (rc != EOK) {
     
    369373                return rc;
    370374        }
    371 
     375       
    372376        rc = sockets_sendto_recvfrom(verbose, socket_ids, sockets, address,
    373377            &addrlen, data, size, messages);
    374378        if (rc != EOK)
    375379                return rc;
    376 
     380       
     381        struct timeval time_after;
    377382        rc = gettimeofday(&time_after, NULL);
    378383        if (rc != EOK) {
     
    380385                return rc;
    381386        }
    382 
     387       
    383388        if (verbose)
    384389                printf("\tOK\n");
    385 
     390       
    386391        printf("sendto + recvfrom tested in %ld microseconds\n",
    387392            tv_sub(&time_after, &time_before));
    388 
     393       
    389394        rc = gettimeofday(&time_before, NULL);
    390395        if (rc != EOK) {
     
    392397                return rc;
    393398        }
    394 
     399       
    395400        rc = sockets_sendto(verbose, socket_ids, sockets, address, addrlen,
    396401            data, size, messages);
    397402        if (rc != EOK)
    398403                return rc;
    399 
     404       
    400405        rc = sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen,
    401406            data, size, messages);
    402407        if (rc != EOK)
    403408                return rc;
    404 
     409       
    405410        rc = gettimeofday(&time_after, NULL);
    406411        if (rc != EOK) {
     
    408413                return rc;
    409414        }
    410 
     415       
    411416        if (verbose)
    412417                printf("\tOK\n");
    413 
     418       
    414419        printf("sendto, recvfrom tested in %ld microseconds\n",
    415420            tv_sub(&time_after, &time_before));
    416 
     421       
    417422        rc = sockets_close(verbose, socket_ids, sockets);
    418423        if (rc != EOK)
    419424                return rc;
    420 
     425       
    421426        if (verbose)
    422427                printf("\nExiting\n");
    423 
     428       
    424429        return EOK;
    425430}
Note: See TracChangeset for help on using the changeset viewer.