Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/nettest1/nettest1.c

    r69e0d6d r3d459fc  
    4444#include <time.h>
    4545#include <arg_parse.h>
     46#include <err.h>
    4647
    4748#include <net/in.h>
    … …  
    5758#define NETTEST1_TEXT   "Networking test 1 - sockets"
    5859
    59 static int family = PF_INET;
    60 static sock_type_t type = SOCK_DGRAM;
    61 static char *data;
    62 static size_t size = 27;
    63 static int verbose = 0;
    64 
    65 static struct sockaddr *address;
    66 static socklen_t addrlen;
    67 
    68 static int sockets;
    69 static int messages;
    70 static uint16_t port;
    71 
    7260static void nettest1_print_help(void)
    7361{
    7462        printf(
    75             "Network Networking test 1 aplication - sockets\n"
    76             "Usage: echo [options] numeric_address\n"
    77             "Where options are:\n"
    78             "-f protocol_family | --family=protocol_family\n"
    79             "\tThe listenning socket protocol family. Only the PF_INET and "
    80             "PF_INET6 are supported.\n"
    81             "\n"
    82             "-h | --help\n"
    83             "\tShow this application help.\n"
    84             "\n"
    85             "-m count | --messages=count\n"
    86             "\tThe number of messages to send and receive per socket. The "
    87             "default is 10.\n"
    88             "\n"
    89             "-n sockets | --sockets=count\n"
    90             "\tThe number of sockets to use. The default is 10.\n"
    91             "\n"
    92             "-p port_number | --port=port_number\n"
    93             "\tThe port number the application should send messages to. The "
    94             "default is 7.\n"
    95             "\n"
    96             "-s packet_size | --size=packet_size\n"
    97             "\tThe packet data size the application sends. The default is "
    98             "28 bytes.\n"
    99             "\n"
    100             "-v | --verbose\n"
    101             "\tShow all output messages.\n");
     63                "Network Networking test 1 aplication - sockets\n" \
     64                "Usage: echo [options] numeric_address\n" \
     65                "Where options are:\n" \
     66                "-f protocol_family | --family=protocol_family\n" \
     67                "\tThe listenning socket protocol family. Only the PF_INET and PF_INET6 are supported.\n"
     68                "\n" \
     69                "-h | --help\n" \
     70                "\tShow this application help.\n"
     71                "\n" \
     72                "-m count | --messages=count\n" \
     73                "\tThe number of messages to send and receive per socket. The default is 10.\n" \
     74                "\n" \
     75                "-n sockets | --sockets=count\n" \
     76                "\tThe number of sockets to use. The default is 10.\n" \
     77                "\n" \
     78                "-p port_number | --port=port_number\n" \
     79                "\tThe port number the application should send messages to. The default is 7.\n" \
     80                "\n" \
     81                "-s packet_size | --size=packet_size\n" \
     82                "\tThe packet data size the application sends. The default is 28 bytes.\n" \
     83                "\n" \
     84                "-v | --verbose\n" \
     85                "\tShow all output messages.\n"
     86        );
    10287}
    10388
    104 /** Parse one command-line option.
    105  *
    106  * @param argc          Number of all command-line arguments.
    107  * @param argv          All command-line arguments.
    108  * @param index         Current argument index (in, out).
    109  */
    110 static int nettest1_parse_opt(int argc, char *argv[], int *index)
     89/** Refreshes the data.
     90 *
     91 * Fills the data block with the NETTEST1_TEXT pattern.
     92 *
     93 * @param[out] data The data block.
     94 * @param[in] size The data block size in bytes.
     95 */
     96static void nettest1_refresh_data(char *data, size_t size)
    11197{
     98        size_t length;
     99
     100        // fill the data
     101        length = 0;
     102        while (size > length + sizeof(NETTEST1_TEXT) - 1) {
     103                memcpy(data + length, NETTEST1_TEXT, sizeof(NETTEST1_TEXT) - 1);
     104                length += sizeof(NETTEST1_TEXT) - 1;
     105        }
     106        memcpy(data + length, NETTEST1_TEXT, size - length);
     107        data[size] = '\0';
     108}
     109
     110
     111int main(int argc, char *argv[])
     112{
     113        ERROR_DECLARE;
     114
     115        size_t size = 27;
     116        int verbose = 0;
     117        sock_type_t type = SOCK_DGRAM;
     118        int sockets = 10;
     119        int messages = 10;
     120        int family = PF_INET;
     121        uint16_t port = 7;
     122
     123        socklen_t max_length = sizeof(struct sockaddr_in6);
     124        uint8_t address_data[max_length];
     125        struct sockaddr *address = (struct sockaddr *) address_data;
     126        struct sockaddr_in *address_in = (struct sockaddr_in *) address;
     127        struct sockaddr_in6 *address_in6 = (struct sockaddr_in6 *) address;
     128        socklen_t addrlen;
     129        uint8_t *address_start;
     130
     131        int *socket_ids;
     132        char *data;
    112133        int value;
    113         int rc;
    114 
    115         switch (argv[*index][1]) {
    116         /*
    117          * Short options with only one letter
    118          */
    119         case 'f':
    120                 rc = arg_parse_name_int(argc, argv, index, &family, 0, socket_parse_protocol_family);
    121                 if (rc != EOK)
    122                         return rc;
    123                 break;
    124         case 'h':
    125                 nettest1_print_help();
    126                 return EOK;
    127         case 'm':
    128                 rc = arg_parse_int(argc, argv, index, &messages, 0);
    129                 if (rc != EOK)
    130                         return rc;
    131                 break;
    132         case 'n':
    133                 rc = arg_parse_int(argc, argv, index, &sockets, 0);
    134                 if (rc != EOK)
    135                         return rc;
    136                 break;
    137         case 'p':
    138                 rc = arg_parse_int(argc, argv, index, &value, 0);
    139                 if (rc != EOK)
    140                         return rc;
    141                 port = (uint16_t) value;
    142                 break;
    143         case 's':
    144                 rc = arg_parse_int(argc, argv, index, &value, 0);
    145                 if (rc != EOK)
    146                         return rc;
    147                 size = (value >= 0) ? (size_t) value : 0;
    148                 break;
    149         case 't':
    150                 rc = arg_parse_name_int(argc, argv, index, &value, 0, socket_parse_socket_type);
    151                 if (rc != EOK)
    152                         return rc;
    153                 type = (sock_type_t) value;
    154                 break;
    155         case 'v':
    156                 verbose = 1;
    157                 break;
    158         /*
    159          * Long options with double dash ('-')
    160          */
    161         case '-':
    162                 if (str_lcmp(argv[*index] + 2, "family=", 7) == 0) {
    163                         rc = arg_parse_name_int(argc, argv, index, &family, 9,
    164                             socket_parse_protocol_family);
    165                         if (rc != EOK)
    166                                 return rc;
    167                 } else if (str_lcmp(argv[*index] + 2, "help", 5) == 0) {
    168                         nettest1_print_help();
    169                         return EOK;
    170                 } else if (str_lcmp(argv[*index] + 2, "messages=", 6) == 0) {
    171                         rc = arg_parse_int(argc, argv, index, &messages, 8);
    172                         if (rc != EOK)
    173                                 return rc;
    174                 } else if (str_lcmp(argv[*index] + 2, "sockets=", 6) == 0) {
    175                         rc = arg_parse_int(argc, argv, index, &sockets, 8);
    176                         if (rc != EOK)
    177                                 return rc;
    178                 } else if (str_lcmp(argv[*index] + 2, "port=", 5) == 0) {
    179                         rc = arg_parse_int(argc, argv, index, &value, 7);
    180                         if (rc != EOK)
    181                                 return rc;
    182                         port = (uint16_t) value;
    183                 } else if (str_lcmp(argv[*index] + 2, "type=", 5) == 0) {
    184                         rc = arg_parse_name_int(argc, argv, index, &value, 7,
    185                             socket_parse_socket_type);
    186                         if (rc != EOK)
    187                                 return rc;
    188                         type = (sock_type_t) value;
    189                 } else if (str_lcmp(argv[*index] + 2, "verbose", 8) == 0) {
    190                         verbose = 1;
     134        int index;
     135        struct timeval time_before;
     136        struct timeval time_after;
     137
     138        // parse the command line arguments
     139        // stop before the last argument if it does not start with the minus sign ('-')
     140        for (index = 1; (index < argc - 1) || ((index == argc - 1) && (argv[index][0] == '-')); index++) {
     141                // options should start with the minus sign ('-')
     142                if (argv[index][0] == '-') {
     143                        switch (argv[index][1]) {
     144                        // short options with only one letter
     145                        case 'f':
     146                                ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &family, 0, socket_parse_protocol_family));
     147                                break;
     148                        case 'h':
     149                                nettest1_print_help();
     150                                return EOK;
     151                                break;
     152                        case 'm':
     153                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &messages, 0));
     154                                break;
     155                        case 'n':
     156                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &sockets, 0));
     157                                break;
     158                        case 'p':
     159                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &value, 0));
     160                                port = (uint16_t) value;
     161                                break;
     162                        case 's':
     163                                ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &value, 0));
     164                                size = (value >= 0) ? (size_t) value : 0;
     165                                break;
     166                        case 't':
     167                                ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &value, 0, socket_parse_socket_type));
     168                                type = (sock_type_t) value;
     169                                break;
     170                        case 'v':
     171                                verbose = 1;
     172                                break;
     173                        // long options with the double minus sign ('-')
     174                        case '-':
     175                                if (str_lcmp(argv[index] + 2, "family=", 7) == 0) {
     176                                        ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &family, 9, socket_parse_protocol_family));
     177                                } else if (str_lcmp(argv[index] + 2, "help", 5) == 0) {
     178                                        nettest1_print_help();
     179                                        return EOK;
     180                                } else if (str_lcmp(argv[index] + 2, "messages=", 6) == 0) {
     181                                        ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &messages, 8));
     182                                } else if (str_lcmp(argv[index] + 2, "sockets=", 6) == 0) {
     183                                        ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &sockets, 8));
     184                                } else if (str_lcmp(argv[index] + 2, "port=", 5) == 0) {
     185                                        ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &value, 7));
     186                                        port = (uint16_t) value;
     187                                } else if (str_lcmp(argv[index] + 2, "type=", 5) == 0) {
     188                                        ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &value, 7, socket_parse_socket_type));
     189                                        type = (sock_type_t) value;
     190                                } else if (str_lcmp(argv[index] + 2, "verbose", 8) == 0) {
     191                                        verbose = 1;
     192                                } else {
     193                                        nettest1_print_help();
     194                                        return EINVAL;
     195                                }
     196                                break;
     197                        default:
     198                                nettest1_print_help();
     199                                return EINVAL;
     200                        }
    191201                } else {
    192202                        nettest1_print_help();
    193203                        return EINVAL;
    194204                }
    195                 break;
    196         default:
    197                 nettest1_print_help();
    198                 return EINVAL;
    199         }
    200 
    201         return EOK;
    202 }
    203 
    204 /** Fill buffer with the NETTEST1_TEXT pattern.
    205  *
    206  * @param buffer        Data buffer.
    207  * @param size          Buffer size in bytes.
    208  */
    209 static void nettest1_fill_buffer(char *buffer, size_t size)
    210 {
    211         size_t length;
    212 
    213         length = 0;
    214         while (size > length + sizeof(NETTEST1_TEXT) - 1) {
    215                 memcpy(buffer + length, NETTEST1_TEXT,
    216                     sizeof(NETTEST1_TEXT) - 1);
    217                 length += sizeof(NETTEST1_TEXT) - 1;
    218         }
    219 
    220         memcpy(buffer + length, NETTEST1_TEXT, size - length);
    221         buffer[size] = '\0';
    222 }
    223 
    224 static int nettest1_test(int *socket_ids, int nsockets, int nmessages)
    225 {
    226         int rc;
    227 
    228         if (verbose)
    229                 printf("%d sockets, %d messages\n", nsockets, nmessages);
    230 
    231         rc = sockets_create(verbose, socket_ids, nsockets, family, type);
    232         if (rc != EOK)
    233                 return rc;
    234 
    235         if (type == SOCK_STREAM) {
    236                 rc = sockets_connect(verbose, socket_ids, nsockets, address,
    237                     addrlen);
    238                 if (rc != EOK)
    239                         return rc;
    240         }
    241 
    242         rc = sockets_sendto_recvfrom(verbose, socket_ids, nsockets, address,
    243             &addrlen, data, size, nmessages);
    244         if (rc != EOK)
    245                 return rc;
    246 
    247         rc = sockets_close(verbose, socket_ids, nsockets);
    248         if (rc != EOK)
    249                 return rc;
    250 
    251         if (verbose)
    252                 printf("\tOK\n");
    253 
    254         /****/
    255 
    256         rc = sockets_create(verbose, socket_ids, nsockets, family, type);
    257         if (rc != EOK)
    258                 return rc;
    259 
    260         if (type == SOCK_STREAM) {
    261                 rc = sockets_connect(verbose, socket_ids, nsockets, address,
    262                     addrlen);
    263                 if (rc != EOK)
    264                         return rc;
    265         }
    266 
    267         rc = sockets_sendto(verbose, socket_ids, nsockets, address, addrlen,
    268             data, size, nmessages);
    269         if (rc != EOK)
    270                 return rc;
    271 
    272         rc = sockets_recvfrom(verbose, socket_ids, nsockets, address, &addrlen,
    273             data, size, nmessages);
    274         if (rc != EOK)
    275                 return rc;
    276 
    277         rc = sockets_close(verbose, socket_ids, nsockets);
    278         if (rc != EOK)
    279                 return rc;
    280 
    281         if (verbose)
    282                 printf("\tOK\n");
    283 
    284         return EOK;
    285 }
    286 
    287 int main(int argc, char *argv[])
    288 {
    289 
    290         socklen_t max_length;
    291         uint8_t *address_data[sizeof(struct sockaddr_in6)];
    292         struct sockaddr_in *address_in;
    293         struct sockaddr_in6 *address_in6;
    294         uint8_t *address_start;
    295 
    296         int *socket_ids;
    297         int index;
    298         struct timeval time_before;
    299         struct timeval time_after;
    300 
    301         int rc;
    302 
    303         max_length = sizeof(address_data);
    304         address = (struct sockaddr *) address_data;
    305         address_in = (struct sockaddr_in *) address;
    306         address_in6 = (struct sockaddr_in6 *) address;
    307 
    308         sockets = 10;
    309         messages = 10;
    310         port = 7;
    311 
    312         /*
    313          * Parse the command line arguments. Stop before the last argument
    314          * if it does not start with dash ('-')
    315          */
    316         for (index = 1; (index < argc - 1) || ((index == argc - 1) && (argv[index][0] == '-')); index++) {
    317                 /* Options should start with dash ('-') */
    318                 if (argv[index][0] == '-') {
    319                         rc = nettest1_parse_opt(argc, argv, &index);
    320                         if (rc != EOK)
    321                                 return rc;
    322                 } else {
    323                         nettest1_print_help();
    324                         return EINVAL;
    325                 }
    326         }
    327 
    328         /* If not before the last argument containing the address */
     205        }
     206
     207        // if not before the last argument containing the address
    329208        if (index >= argc) {
    330209                printf("Command line error: missing address\n");
    … …  
    333212        }
    334213
    335         /* Prepare the address buffer */
     214        // prepare the address buffer
    336215        bzero(address_data, max_length);
    337 
    338216        switch (family) {
    339217        case PF_INET:
    … …  
    354232        }
    355233
    356         /* Parse the last argument which should contain the address */
    357         rc = inet_pton(family, argv[argc - 1], address_start);
    358         if (rc != EOK) {
    359                 fprintf(stderr, "Address parse error %d\n", rc);
    360                 return rc;
    361         }
    362 
    363         /* Check data buffer size */
     234        // parse the last argument which should contain the address
     235        if (ERROR_OCCURRED(inet_pton(family, argv[argc - 1], address_start))) {
     236                fprintf(stderr, "Address parse error %d\n", ERROR_CODE);
     237                return ERROR_CODE;
     238        }
     239
     240        // check the buffer size
    364241        if (size <= 0) {
    365                 fprintf(stderr, "Data buffer size too small (%d). Using 1024 "
    366                     "bytes instead.\n", size);
     242                fprintf(stderr, "Data buffer size too small (%d). Using 1024 bytes instead.\n", size);
    367243                size = 1024;
    368244        }
    369245
    370         /*
    371          * Prepare data buffer. Allocate size bytes plus one for the
    372          * trailing null character.
    373          */
     246        // prepare the buffer
     247        // size plus the terminating null (\0)
    374248        data = (char *) malloc(size + 1);
    375249        if (!data) {
    … …  
    377251                return ENOMEM;
    378252        }
    379         nettest1_fill_buffer(data, size);
    380 
    381         /* Check socket count */
     253        nettest1_refresh_data(data, size);
     254
     255        // check the socket count
    382256        if (sockets <= 0) {
    383                 fprintf(stderr, "Socket count too small (%d). Using "
    384                     "2 instead.\n", sockets);
     257                fprintf(stderr, "Socket count too small (%d). Using 2 instead.\n", sockets);
    385258                sockets = 2;
    386259        }
    387260
    388         /*
    389          * Prepare socket buffer. Allocate count fields plus the terminating
    390          * null (\0).
    391          */
     261        // prepare the socket buffer
     262        // count plus the terminating null (\0)
    392263        socket_ids = (int *) malloc(sizeof(int) * (sockets + 1));
    393264        if (!socket_ids) {
    … …  
    400271                printf("Starting tests\n");
    401272
    402         rc = gettimeofday(&time_before, NULL);
    403         if (rc != EOK) {
    404                 fprintf(stderr, "Get time of day error %d\n", rc);
    405                 return rc;
    406         }
    407 
    408         nettest1_test(socket_ids,       1,        1);
    409         nettest1_test(socket_ids,       1, messages);
    410         nettest1_test(socket_ids, sockets,        1);
    411         nettest1_test(socket_ids, sockets, messages);
    412 
    413         rc = gettimeofday(&time_after, NULL);
    414         if (rc != EOK) {
    415                 fprintf(stderr, "Get time of day error %d\n", rc);
    416                 return rc;
    417         }
    418 
    419         printf("Tested in %d microseconds\n", tv_sub(&time_after,
    420             &time_before));
     273        if (verbose)
     274                printf("1 socket, 1 message\n");
     275
     276        if (ERROR_OCCURRED(gettimeofday(&time_before, NULL))) {
     277                fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
     278                return ERROR_CODE;
     279        }
     280
     281        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, 1, family, type));
     282        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, 1));
     283        if (verbose)
     284                printf("\tOK\n");
     285
     286        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, 1, family, type));
     287        if (type == SOCK_STREAM)
     288                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, 1, address, addrlen));
     289        ERROR_PROPAGATE(sockets_sendto_recvfrom(verbose, socket_ids, 1, address, &addrlen, data, size, 1));
     290        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, 1));
     291        if (verbose)
     292                printf("\tOK\n");
     293
     294        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, 1, family, type));
     295        if (type == SOCK_STREAM)
     296                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, 1, address, addrlen));
     297        ERROR_PROPAGATE(sockets_sendto(verbose, socket_ids, 1, address, addrlen, data, size, 1));
     298        ERROR_PROPAGATE(sockets_recvfrom(verbose, socket_ids, 1, address, &addrlen, data, size, 1));
     299        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, 1));
     300        if (verbose)
     301                printf("\tOK\n");
     302
     303        if (verbose)
     304                printf("1 socket, %d messages\n", messages);
     305
     306        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, 1, family, type));
     307        if (type == SOCK_STREAM)
     308                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, 1, address, addrlen));
     309        ERROR_PROPAGATE(sockets_sendto_recvfrom(verbose, socket_ids, 1, address, &addrlen, data, size, messages));
     310        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, 1));
     311        if (verbose)
     312                printf("\tOK\n");
     313
     314        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, 1, family, type));
     315        if (type == SOCK_STREAM)
     316                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, 1, address, addrlen));
     317        ERROR_PROPAGATE(sockets_sendto(verbose, socket_ids, 1, address, addrlen, data, size, messages));
     318        ERROR_PROPAGATE(sockets_recvfrom(verbose, socket_ids, 1, address, &addrlen, data, size, messages));
     319        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, 1));
     320        if (verbose)
     321                printf("\tOK\n");
     322
     323        if (verbose)
     324                printf("%d sockets, 1 message\n", sockets);
     325
     326        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, sockets, family, type));
     327        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, sockets));
     328        if (verbose)
     329                printf("\tOK\n");
     330
     331        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, sockets, family, type));
     332        if (type == SOCK_STREAM)
     333                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, sockets, address, addrlen));
     334        ERROR_PROPAGATE(sockets_sendto_recvfrom(verbose, socket_ids, sockets, address, &addrlen, data, size, 1));
     335        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, sockets));
     336        if (verbose)
     337                printf("\tOK\n");
     338
     339        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, sockets, family, type));
     340        if (type == SOCK_STREAM)
     341                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, sockets, address, addrlen));
     342        ERROR_PROPAGATE(sockets_sendto(verbose, socket_ids, sockets, address, addrlen, data, size, 1));
     343        ERROR_PROPAGATE(sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen, data, size, 1));
     344        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, sockets));
     345        if (verbose)
     346                printf("\tOK\n");
     347
     348        if (verbose)
     349                printf("%d sockets, %d messages\n", sockets, messages);
     350
     351        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, sockets, family, type));
     352        if (type == SOCK_STREAM)
     353                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, sockets, address, addrlen));
     354        ERROR_PROPAGATE(sockets_sendto_recvfrom(verbose, socket_ids, sockets, address, &addrlen, data, size, messages));
     355        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, sockets));
     356        if (verbose)
     357                printf("\tOK\n");
     358
     359        ERROR_PROPAGATE(sockets_create(verbose, socket_ids, sockets, family, type));
     360        if (type == SOCK_STREAM)
     361                ERROR_PROPAGATE(sockets_connect(verbose, socket_ids, sockets, address, addrlen));
     362        ERROR_PROPAGATE(sockets_sendto(verbose, socket_ids, sockets, address, addrlen, data, size, messages));
     363        ERROR_PROPAGATE(sockets_recvfrom(verbose, socket_ids, sockets, address, &addrlen, data, size, messages));
     364        ERROR_PROPAGATE(sockets_close(verbose, socket_ids, sockets));
     365
     366        if (ERROR_OCCURRED(gettimeofday(&time_after, NULL))) {
     367                fprintf(stderr, "Get time of day error %d\n", ERROR_CODE);
     368                return ERROR_CODE;
     369        }
     370
     371        if (verbose)
     372                printf("\tOK\n");
     373
     374        printf("Tested in %d microseconds\n", tv_sub(&time_after, &time_before));
    421375
    422376        if (verbose)
Note: See TracChangeset for help on using the changeset viewer.