Changeset bdae198 in mainline for uspace/app/nettest1/nettest.c


Ignore:
Timestamp:
2013-08-04T12:01:10Z (11 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
ea50906
Parents:
b08879c2 (diff), d856110 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/nettest1/nettest.c

    rb08879c2 rbdae198  
    4141#include "print_error.h"
    4242
    43 
    4443/** Creates new sockets.
    4544 *
    … …  
    5251 * @return Other error codes as defined for the socket() function.
    5352 */
    54 int sockets_create(int verbose, int *socket_ids, int sockets, int family, sock_type_t type)
    55 {
    56         int index;
    57 
     53int sockets_create(int verbose, int *socket_ids, unsigned int sockets,
     54    uint16_t family, sock_type_t type)
     55{
    5856        if (verbose)
    5957                printf("Create\t");
    60                
    61         fflush(stdout);
    62        
    63         for (index = 0; index < sockets; index++) {
     58       
     59        fflush(stdout);
     60       
     61        for (unsigned int index = 0; index < sockets; index++) {
    6462                socket_ids[index] = socket(family, type, 0);
    6563                if (socket_ids[index] < 0) {
    66                         printf("Socket %d (%d) error:\n", index, socket_ids[index]);
     64                        printf("Socket %u (%d) error:\n", index, socket_ids[index]);
    6765                        socket_print_error(stderr, socket_ids[index], "Socket create: ", "\n");
    6866                        return socket_ids[index];
    6967                }
     68               
    7069                if (verbose)
    7170                        print_mark(index);
    … …  
    8382 * @return Other error codes as defined for the closesocket() function.
    8483 */
    85 int sockets_close(int verbose, int *socket_ids, int sockets)
    86 {
    87         int index;
    88         int rc;
    89 
     84int sockets_close(int verbose, int *socket_ids, unsigned int sockets)
     85{
    9086        if (verbose)
    9187                printf("\tClose\t");
    92 
    93         fflush(stdout);
    94        
    95         for (index = 0; index < sockets; index++) {
    96                 rc = closesocket(socket_ids[index]);
     88       
     89        fflush(stdout);
     90       
     91        for (unsigned int index = 0; index < sockets; index++) {
     92                int rc = closesocket(socket_ids[index]);
    9793                if (rc != EOK) {
    98                         printf("Socket %d (%d) error:\n", index, socket_ids[index]);
     94                        printf("Socket %u (%d) error:\n", index, socket_ids[index]);
    9995                        socket_print_error(stderr, rc, "Socket close: ", "\n");
    10096                        return rc;
    10197                }
     98               
    10299                if (verbose)
    103100                        print_mark(index);
    … …  
    117114 * @return Other error codes as defined for the connect() function.
    118115 */
    119 int sockets_connect(int verbose, int *socket_ids, int sockets, struct sockaddr *address, socklen_t addrlen)
    120 {
    121         int index;
    122         int rc;
    123 
     116int sockets_connect(int verbose, int *socket_ids, unsigned int sockets,
     117    struct sockaddr *address, socklen_t addrlen)
     118{
    124119        if (verbose)
    125120                printf("\tConnect\t");
    … …  
    127122        fflush(stdout);
    128123       
    129         for (index = 0; index < sockets; index++) {
    130                 rc = connect(socket_ids[index], address, addrlen);
     124        for (unsigned int index = 0; index < sockets; index++) {
     125                int rc = connect(socket_ids[index], address, addrlen);
    131126                if (rc != EOK) {
    132127                        socket_print_error(stderr, rc, "Socket connect: ", "\n");
    133128                        return rc;
    134129                }
    135                 if (verbose)
    136                         print_mark(index);
    137         }
    138        
    139         return EOK;
    140 }
    141 
    142 /** Sends data via sockets.
    143  *
    144  * @param[in] verbose A value indicating whether to print out verbose information.
    145  * @param[in] socket_ids A field of stored socket identifiers.
    146  * @param[in] sockets The number of sockets in the field. Should be at most the size of the field.
    147  * @param[in] address The destination host address to send data to.
    148  * @param[in] addrlen The length of the destination address in bytes.
    149  * @param[in] data The data to be sent.
    150  * @param[in] size The data size in bytes.
    151  * @param[in] messages The number of datagrams per socket to be sent.
     130               
     131                if (verbose)
     132                        print_mark(index);
     133        }
     134       
     135        return EOK;
     136}
     137
     138/** Send data via sockets.
     139 *
     140 * @param[in] verbose    Print out verbose information.
     141 * @param[in] socket_ids Stored socket identifiers.
     142 * @param[in] sockets    Number of sockets.
     143 * @param[in] address    Destination host address to send data to.
     144 * @param[in] addrlen    Length of the destination address in bytes.
     145 * @param[in] data       Data to be sent.
     146 * @param[in] size       Size of the data in bytes.
     147 * @param[in] messages   Number of datagrams per socket to be sent.
     148 * @param[in] type       Socket type.
     149 *
    152150 * @return EOK on success.
    153151 * @return Other error codes as defined for the sendto() function.
    154  */
    155 int sockets_sendto(int verbose, int *socket_ids, int sockets, struct sockaddr *address, socklen_t addrlen, char *data, int size, int messages)
    156 {
    157         int index;
    158         int message;
    159         int rc;
    160 
     152 *
     153 */
     154int sockets_sendto(int verbose, int *socket_ids, unsigned int sockets,
     155    struct sockaddr *address, socklen_t addrlen, char *data, size_t size,
     156    unsigned int messages, sock_type_t type)
     157{
    161158        if (verbose)
    162159                printf("\tSendto\t");
    163 
    164         fflush(stdout);
    165        
    166         for (index = 0; index < sockets; index++) {
    167                 for (message = 0; message < messages; message++) {
    168                         rc = sendto(socket_ids[index], data, size, 0, address, addrlen);
     160       
     161        fflush(stdout);
     162       
     163        for (unsigned int index = 0; index < sockets; index++) {
     164                for (unsigned int message = 0; message < messages; message++) {
     165                        int rc;
     166                       
     167                        switch (type) {
     168                        case SOCK_STREAM:
     169                                rc = send(socket_ids[index], data, size, 0);
     170                                break;
     171                        case SOCK_DGRAM:
     172                                rc = sendto(socket_ids[index], data, size, 0, address, addrlen);
     173                                break;
     174                        default:
     175                                rc = EINVAL;
     176                        }
     177                       
    169178                        if (rc != EOK) {
    170                                 printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
     179                                printf("Socket %u (%d), message %u error:\n",
     180                                    index, socket_ids[index], message);
    171181                                socket_print_error(stderr, rc, "Socket send: ", "\n");
    172182                                return rc;
    173183                        }
    174184                }
    175                 if (verbose)
    176                         print_mark(index);
    177         }
    178        
    179         return EOK;
    180 }
    181 
    182 /** Receives data via sockets.
    183  *
    184  * @param[in] verbose A value indicating whether to print out verbose information.
    185  * @param[in] socket_ids A field of stored socket identifiers.
    186  * @param[in] sockets The number of sockets in the field. Should be at most the size of the field.
    187  * @param[in] address The source host address of received datagrams.
    188  * @param[in,out] addrlen The maximum length of the source address in bytes. The actual size of the source address is set instead.
    189  * @param[out] data The received data.
    190  * @param[in] size The maximum data size in bytes.
    191  * @param[in] messages The number of datagrams per socket to be received.
     185               
     186                if (verbose)
     187                        print_mark(index);
     188        }
     189       
     190        return EOK;
     191}
     192
     193/** Receive data via sockets.
     194 *
     195 * @param[in]     verbose    Print out verbose information.
     196 * @param[in]     socket_ids Stored socket identifiers.
     197 * @param[in]     sockets    Number of sockets.
     198 * @param[in]     address    Source host address of received datagrams.
     199 * @param[in,out] addrlen    Maximum length of the source address in bytes.
     200 *                           The actual size of the source address is set.
     201 * @param[out]    data       Received data.
     202 * @param[in]     size       Maximum data size in bytes.
     203 * @param[in]     messages   Number of datagrams per socket to be received.
     204 *
    192205 * @return EOK on success.
    193206 * @return Other error codes as defined for the recvfrom() function.
    194  */
    195 int sockets_recvfrom(int verbose, int *socket_ids, int sockets, struct sockaddr *address, socklen_t *addrlen, char *data, int size, int messages)
    196 {
    197         int value;
    198         int index;
    199         int message;
    200 
     207 *
     208 */
     209int sockets_recvfrom(int verbose, int *socket_ids, unsigned int sockets,
     210    struct sockaddr *address, socklen_t *addrlen, char *data, size_t size,
     211    unsigned int messages)
     212{
    201213        if (verbose)
    202214                printf("\tRecvfrom\t");
    … …  
    204216        fflush(stdout);
    205217       
    206         for (index = 0; index < sockets; index++) {
    207                 for (message = 0; message < messages; message++) {
    208                         value = recvfrom(socket_ids[index], data, size, 0, address, addrlen);
    209                         if (value < 0) {
    210                                 printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
    211                                 socket_print_error(stderr, value, "Socket receive: ", "\n");
    212                                 return value;
    213                         }
    214                 }
    215                 if (verbose)
    216                         print_mark(index);
    217         }
    218         return EOK;
    219 }
    220 
    221 /** Sends and receives data via sockets.
     218        for (unsigned int index = 0; index < sockets; index++) {
     219                for (unsigned int message = 0; message < messages; message++) {
     220                        int rc = recvfrom(socket_ids[index], data, size, 0, address, addrlen);
     221                        if (rc < 0) {
     222                                printf("Socket %u (%d), message %u error:\n",
     223                                    index, socket_ids[index], message);
     224                                socket_print_error(stderr, rc, "Socket receive: ", "\n");
     225                                return rc;
     226                        }
     227                }
     228               
     229                if (verbose)
     230                        print_mark(index);
     231        }
     232       
     233        return EOK;
     234}
     235
     236/** Send and receive data via sockets.
    222237 *
    223238 * Each datagram is sent and a reply read consequently.
    224239 * The next datagram is sent after the reply is received.
    225240 *
    226  * @param[in] verbose A value indicating whether to print out verbose information.
    227  * @param[in] socket_ids A field of stored socket identifiers.
    228  * @param[in] sockets The number of sockets in the field. Should be at most the size of the field.
    229  * @param[in,out] address The destination host address to send data to. The source host address of received datagrams is set instead.
    230  * @param[in] addrlen The length of the destination address in bytes.
    231  * @param[in,out] data The data to be sent. The received data are set instead.
    232  * @param[in] size The data size in bytes.
    233  * @param[in] messages The number of datagrams per socket to be received.
     241 * @param[in]     verbose    Print out verbose information.
     242 * @param[in]     socket_ids Stored socket identifiers.
     243 * @param[in]     sockets    Number of sockets.
     244 * @param[in,out] address    Destination host address to send data to.
     245 *                           The source host address of received datagrams is set.
     246 * @param[in]     addrlen    Length of the destination address in bytes.
     247 * @param[in,out] data       Data to be sent. The received data are set.
     248 * @param[in]     size       Size of the data in bytes.
     249 * @param[in]     messages   Number of datagrams per socket to be received.
     250 * @param[in]     type       Socket type.
     251 *
    234252 * @return EOK on success.
    235253 * @return Other error codes as defined for the recvfrom() function.
    236  */
    237 int sockets_sendto_recvfrom(int verbose, int *socket_ids, int sockets, struct sockaddr *address, socklen_t *addrlen, char *data, int size, int messages)
    238 {
    239         int value;
    240         int index;
    241         int message;
    242         int rc;
    243 
     254 *
     255 */
     256int sockets_sendto_recvfrom(int verbose, int *socket_ids, unsigned int sockets,
     257    struct sockaddr *address, socklen_t *addrlen, char *data,
     258    size_t size, unsigned int messages, sock_type_t type)
     259{
    244260        if (verbose)
    245261                printf("\tSendto and recvfrom\t");
    246 
    247         fflush(stdout);
    248        
    249         for (index = 0; index < sockets; index++) {
    250                 for (message = 0; message < messages; message++) {
    251                         rc = sendto(socket_ids[index], data, size, 0, address, *addrlen);
     262       
     263        fflush(stdout);
     264       
     265        for (unsigned int index = 0; index < sockets; index++) {
     266                for (unsigned int message = 0; message < messages; message++) {
     267                        int rc;
     268                       
     269                        switch (type) {
     270                        case SOCK_STREAM:
     271                                rc = send(socket_ids[index], data, size, 0);
     272                                break;
     273                        case SOCK_DGRAM:
     274                                rc = sendto(socket_ids[index], data, size, 0, address, *addrlen);
     275                                break;
     276                        default:
     277                                rc = EINVAL;
     278                        }
     279                       
    252280                        if (rc != EOK) {
    253                                 printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
     281                                printf("Socket %u (%d), message %u error:\n",
     282                                    index, socket_ids[index], message);
    254283                                socket_print_error(stderr, rc, "Socket send: ", "\n");
    255284                                return rc;
    256285                        }
    257                         value = recvfrom(socket_ids[index], data, size, 0, address, addrlen);
    258                         if (value < 0) {
    259                                 printf("Socket %d (%d), message %d error:\n", index, socket_ids[index], message);
    260                                 socket_print_error(stderr, value, "Socket receive: ", "\n");
    261                                 return value;
    262                         }
    263                 }
     286                       
     287                        rc = recvfrom(socket_ids[index], data, size, 0, address, addrlen);
     288                        if (rc < 0) {
     289                                printf("Socket %u (%d), message %u error:\n",
     290                                    index, socket_ids[index], message);
     291                                socket_print_error(stderr, rc, "Socket receive: ", "\n");
     292                                return rc;
     293                        }
     294                }
     295               
    264296                if (verbose)
    265297                        print_mark(index);
    … …  
    274306 *
    275307 * @param[in] index The index of the mark to be printed.
    276  */
    277 void print_mark(int index)
     308 *
     309 */
     310void print_mark(unsigned int index)
    278311{
    279312        if ((index + 1) % 10)
    … …  
    281314        else
    282315                printf("|");
     316       
    283317        fflush(stdout);
    284318}
Note: See TracChangeset for help on using the changeset viewer.