Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 0bbef9b in mainline


Ignore:
Timestamp:
2010-11-06T22:54:25Z (11 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master
Children:
5f69504
Parents:
1712f87
Message:

Remove use of ERROR_ macros from nettest1.

Location:
uspace/app/nettest1
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/nettest1/nettest.c

    r1712f87 r0bbef9b  
    3636
    3737#include <stdio.h>
    38 #include <err.h>
    39 
    4038#include <net/socket.h>
    4139
     
    8785int sockets_close(int verbose, int *socket_ids, int sockets)
    8886{
    89         ERROR_DECLARE;
    90 
    91         int index;
     87        int index;
     88        int rc;
    9289
    9390        if (verbose)
     
    9794       
    9895        for (index = 0; index < sockets; index++) {
    99                 if (ERROR_OCCURRED(closesocket(socket_ids[index]))) {
     96                rc = closesocket(socket_ids[index]);
     97                if (rc != EOK) {
    10098                        printf("Socket %d (%d) error:\n", index, socket_ids[index]);
    101                         socket_print_error(stderr, ERROR_CODE, "Socket close: ", "\n");
    102                         return ERROR_CODE;
     99                        socket_print_error(stderr, rc, "Socket close: ", "\n");
     100                        return rc;
    103101                }
    104102                if (verbose)
     
    121119int sockets_connect(int verbose, int *socket_ids, int sockets, struct sockaddr *address, socklen_t addrlen)
    122120{
    123         ERROR_DECLARE;
    124 
    125         int index;
     121        int index;
     122        int rc;
    126123
    127124        if (verbose)
     
    131128       
    132129        for (index = 0; index < sockets; index++) {
    133                 if (ERROR_OCCURRED(connect(socket_ids[index], address, addrlen))) {
    134                         socket_print_error(stderr, ERROR_CODE, "Socket connect: ", "\n");
    135                         return ERROR_CODE;
     130                rc = connect(socket_ids[index], address, addrlen);
     131                if (rc != EOK) {
     132                        socket_print_error(stderr, rc, "Socket connect: ", "\n");
     133                        return rc;
    136134                }
    137135                if (verbose)
     
    157155int sockets_sendto(int verbose, int *socket_ids, int sockets, struct sockaddr *address, socklen_t addrlen, char *data, int size, int messages)
    158156{
    159         ERROR_DECLARE;
    160 
    161157        int index;
    162158        int message;
     159        int rc;
    163160
    164161        if (verbose)
     
    169166        for (index = 0; index < sockets; index++) {
    170167                for (message = 0; message < messages; message++) {
    171                         if (ERROR_OCCURRED(sendto(socket_ids[index], data, size, 0, address, addrlen))) {
    172                                 printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
    173                                 socket_print_error(stderr, ERROR_CODE, "Socket send: ", "\n");
    174                                 return ERROR_CODE;
     168                        rc = sendto(socket_ids[index], data, size, 0, address, addrlen);
     169                        if (rc != EOK) {
     170                                printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
     171                                socket_print_error(stderr, rc, "Socket send: ", "\n");
     172                                return rc;
    175173                        }
    176174                }
     
    239237int sockets_sendto_recvfrom(int verbose, int *socket_ids, int sockets, struct sockaddr *address, socklen_t *addrlen, char *data, int size, int messages)
    240238{
    241         ERROR_DECLARE;
    242 
    243239        int value;
    244240        int index;
    245241        int message;
     242        int rc;
    246243
    247244        if (verbose)
     
    252249        for (index = 0; index < sockets; index++) {
    253250                for (message = 0; message < messages; message++) {
    254                         if (ERROR_OCCURRED(sendto(socket_ids[index], data, size, 0, address, *addrlen))) {
    255                                 printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
    256                                 socket_print_error(stderr, ERROR_CODE, "Socket send: ", "\n");
    257                                 return ERROR_CODE;
     251                        rc = sendto(socket_ids[index], data, size, 0, address, *addrlen);
     252                        if (rc != EOK) {
     253                                printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
     254                                socket_print_error(stderr, rc, "Socket send: ", "\n");
     255                                return rc;
    258256                        }
    259257                        value = recvfrom(socket_ids[index], data, size, 0, address, addrlen);
  • uspace/app/nettest1/nettest1.c

    r1712f87 r0bbef9b  
    4444#include <time.h>
    4545#include <arg_parse.h>
    46 #include <err.h>
    4746
    4847#include <net/in.h>
     
    5756/** Packet data pattern. */
    5857#define NETTEST1_TEXT   "Networking test 1 - sockets"
     58
     59int family = PF_INET;
     60sock_type_t type = SOCK_DGRAM;
     61char *data;
     62size_t size = 27;
     63int verbose = 0;
     64
     65struct sockaddr *address;
     66socklen_t addrlen;
    5967
    6068static void nettest1_print_help(void)
     
    108116}
    109117
     118static int nettest1_test(int *socket_ids, int nsockets, int nmessages)
     119{
     120        int rc;
     121
     122        if (verbose)
     123                printf("%d sockets, %d messages\n", nsockets, nmessages);
     124
     125        rc = sockets_create(verbose, socket_ids, nsockets, family, type);
     126        if (rc != EOK)
     127                return rc;
     128
     129        if (type == SOCK_STREAM) {
     130                rc = sockets_connect(verbose, socket_ids, nsockets, address, addrlen);
     131                if (rc != EOK)
     132                        return rc;
     133        }
     134
     135        rc = sockets_sendto_recvfrom(verbose, socket_ids, nsockets, address, &addrlen, data, size, nmessages);
     136        if (rc != EOK)
     137                return rc;
     138
     139        rc = sockets_close(verbose, socket_ids, nsockets);
     140        if (rc != EOK)
     141                return rc;
     142
     143        if (verbose)
     144                printf("\tOK\n");
     145
     146        /****/
     147
     148        rc = sockets_create(verbose, socket_ids, nsockets, family, type);
     149        if (rc != EOK)
     150                return rc;
     151
     152        if (type == SOCK_STREAM) {
     153                rc = sockets_connect(verbose, socket_ids, nsockets, address, addrlen);
     154                if (rc != EOK)
     155                        return rc;
     156        }
     157
     158        rc = sockets_sendto(verbose, socket_ids, nsockets, address, addrlen, data, size, nmessages);
     159        if (rc != EOK)
     160                return rc;
     161
     162        rc = sockets_recvfrom(verbose, socket_ids, nsockets, address, &addrlen, data, size, nmessages);
     163        if (rc != EOK)
     164                return rc;
     165
     166        rc = sockets_close(verbose, socket_ids, nsockets);
     167        if (rc != EOK)
     168                return rc;
     169
     170        if (verbose)
     171                printf("\tOK\n");
     172
     173        return EOK;
     174}
    110175
    111176int main(int argc, char *argv[])
    112177{
    113         ERROR_DECLARE;
    114 
    115         size_t size = 27;
    116         int verbose = 0;
    117         sock_type_t type = SOCK_DGRAM;
    118178        int sockets = 10;
    119179        int messages = 10;
    120         int family = PF_INET;
    121180        uint16_t port = 7;
    122181
    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;
     182        socklen_t max_length;
     183        uint8_t *address_data[sizeof(struct sockaddr_in6)];
     184        struct sockaddr_in *address_in;
     185        struct sockaddr_in6 *address_in6;
    129186        uint8_t *address_start;
    130187
    131188        int *socket_ids;
    132         char *data;
    133189        int value;
    134190        int index;
    135191        struct timeval time_before;
    136192        struct timeval time_after;
     193
     194        int rc;
     195
     196        max_length = sizeof(address_data);
     197        address = (struct sockaddr *) address_data;
     198        address_in = (struct sockaddr_in *) address;
     199        address_in6 = (struct sockaddr_in6 *) address;
    137200
    138201        // parse the command line arguments
     
    144207                        // short options with only one letter
    145208                        case 'f':
    146                                 ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &family, 0, socket_parse_protocol_family));
     209                                rc = arg_parse_name_int(argc, argv, &index, &family, 0, socket_parse_protocol_family);
     210                                if (rc != EOK)
     211                                        return rc;
    147212                                break;
    148213                        case 'h':
    149214                                nettest1_print_help();
    150215                                return EOK;
    151                                 break;
    152216                        case 'm':
    153                                 ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &messages, 0));
     217                                rc = arg_parse_int(argc, argv, &index, &messages, 0);
     218                                if (rc != EOK)
     219                                        return rc;
    154220                                break;
    155221                        case 'n':
    156                                 ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &sockets, 0));
     222                                rc = arg_parse_int(argc, argv, &index, &sockets, 0);
     223                                if (rc != EOK)
     224                                        return rc;
    157225                                break;
    158226                        case 'p':
    159                                 ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &value, 0));
     227                                rc = arg_parse_int(argc, argv, &index, &value, 0);
     228                                if (rc != EOK)
     229                                        return rc;
    160230                                port = (uint16_t) value;
    161231                                break;
    162232                        case 's':
    163                                 ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &value, 0));
     233                                rc = arg_parse_int(argc, argv, &index, &value, 0);
     234                                if (rc != EOK)
     235                                        return rc;
    164236                                size = (value >= 0) ? (size_t) value : 0;
    165237                                break;
    166238                        case 't':
    167                                 ERROR_PROPAGATE(arg_parse_name_int(argc, argv, &index, &value, 0, socket_parse_socket_type));
     239                                rc = arg_parse_name_int(argc, argv, &index, &value, 0, socket_parse_socket_type);
     240                                if (rc != EOK)
     241                                        return rc;
    168242                                type = (sock_type_t) value;
    169243                                break;
     
    174248                        case '-':
    175249                                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));
     250                                        rc = arg_parse_name_int(argc, argv, &index, &family, 9, socket_parse_protocol_family);
     251                                        if (rc != EOK)
     252                                                return rc;
    177253                                } else if (str_lcmp(argv[index] + 2, "help", 5) == 0) {
    178254                                        nettest1_print_help();
    179255                                        return EOK;
    180256                                } else if (str_lcmp(argv[index] + 2, "messages=", 6) == 0) {
    181                                         ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &messages, 8));
     257                                        rc = arg_parse_int(argc, argv, &index, &messages, 8);
     258                                        if (rc != EOK)
     259                                                return rc;
    182260                                } else if (str_lcmp(argv[index] + 2, "sockets=", 6) == 0) {
    183                                         ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &sockets, 8));
     261                                        rc = arg_parse_int(argc, argv, &index, &sockets, 8);
     262                                        if (rc != EOK)
     263                                                return rc;
    184264                                } else if (str_lcmp(argv[index] + 2, "port=", 5) == 0) {
    185                                         ERROR_PROPAGATE(arg_parse_int(argc, argv, &index, &value, 7));
     265                                        rc = arg_parse_int(argc, argv, &index, &value, 7);
     266                                        if (rc != EOK)
     267                                                return rc;
    186268                                        port = (uint16_t) value;
    187269                                } 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));
     270                                        rc = arg_parse_name_int(argc, argv, &index, &value, 7, socket_parse_socket_type);
     271                                        if (rc != EOK)
     272                                                return rc;
    189273                                        type = (sock_type_t) value;
    190274                                } else if (str_lcmp(argv[index] + 2, "verbose", 8) == 0) {
     
    233317
    234318        // 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;
     319        rc = inet_pton(family, argv[argc - 1], address_start);
     320        if (rc != EOK) {
     321                fprintf(stderr, "Address parse error %d\n", rc);
     322                return rc;
    238323        }
    239324
     
    271356                printf("Starting tests\n");
    272357
    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");
     358        rc = gettimeofday(&time_before, NULL);
     359        if (rc != EOK) {
     360                fprintf(stderr, "Get time of day error %d\n", rc);
     361                return rc;
     362        }
     363
     364        nettest1_test(socket_ids,       1,        1);
     365        nettest1_test(socket_ids,       1, messages);
     366        nettest1_test(socket_ids, sockets,        1);
     367        nettest1_test(socket_ids, sockets, messages);
     368
     369        rc = gettimeofday(&time_after, NULL);
     370        if (rc != EOK) {
     371                fprintf(stderr, "Get time of day error %d\n", rc);
     372                return rc;
     373        }
    373374
    374375        printf("Tested in %d microseconds\n", tv_sub(&time_after, &time_before));
Note: See TracChangeset for help on using the changeset viewer.