Ignore:
Timestamp:
2011-06-01T08:43:42Z (14 years ago)
Author:
Lubos Slovak <lubos.slovak@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
8d6c1f1
Parents:
9e2e715 (diff), e51a514 (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:

Huuuuuge merge from development - all the work actually :)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/net/socket_client.c

    r9e2e715 reb522e8  
    4343#include <stdlib.h>
    4444#include <errno.h>
    45 
     45#include <task.h>
    4646#include <ipc/services.h>
    4747#include <ipc/socket.h>
    48 
    4948#include <net/modules.h>
    5049#include <net/in.h>
    … …  
    7877 */
    7978typedef struct socket socket_t;
    80 
    81 /** Type definition of the socket specific data pointer.
    82  * @see socket
    83  */
    84 typedef socket_t *socket_ref;
    8579
    8680/** Socket specific data.
    … …  
    162156
    163157        /** Active sockets. */
    164         sockets_ref sockets;
     158        sockets_t *sockets;
    165159
    166160        /** Safety lock.
    … …  
    183177/** Returns the active sockets.
    184178 *
    185  *  @returns            The active sockets.
    186  */
    187 static sockets_ref socket_get_sockets(void)
     179 *  @return             The active sockets.
     180 */
     181static sockets_t *socket_get_sockets(void)
    188182{
    189183        if (!socket_globals.sockets) {
    190184                socket_globals.sockets =
    191                     (sockets_ref) malloc(sizeof(sockets_t));
     185                    (sockets_t *) malloc(sizeof(sockets_t));
    192186                if (!socket_globals.sockets)
    193187                        return NULL;
    … …  
    213207        ipc_callid_t callid;
    214208        ipc_call_t call;
    215         socket_ref socket;
     209        socket_t *socket;
    216210        int rc;
    217211
    … …  
    219213        callid = async_get_call(&call);
    220214
    221         switch (IPC_GET_METHOD(call)) {
     215        switch (IPC_GET_IMETHOD(call)) {
    222216        case NET_SOCKET_RECEIVED:
    223217        case NET_SOCKET_ACCEPTED:
    … …  
    225219                fibril_rwlock_read_lock(&socket_globals.lock);
    226220
    227                 // find the socket
     221                /* Find the socket */
    228222                socket = sockets_find(socket_get_sockets(),
    229223                    SOCKET_GET_SOCKET_ID(call));
    … …  
    234228                }
    235229               
    236                 switch (IPC_GET_METHOD(call)) {
     230                switch (IPC_GET_IMETHOD(call)) {
    237231                case NET_SOCKET_RECEIVED:
    238232                        fibril_mutex_lock(&socket->receive_lock);
    239                         // push the number of received packet fragments
     233                        /* Push the number of received packet fragments */
    240234                        rc = dyn_fifo_push(&socket->received,
    241235                            SOCKET_GET_DATA_FRAGMENTS(call),
    242236                            SOCKET_MAX_RECEIVED_SIZE);
    243237                        if (rc == EOK) {
    244                                 // signal the received packet
     238                                /* Signal the received packet */
    245239                                fibril_condvar_signal(&socket->receive_signal);
    246240                        }
    … …  
    249243
    250244                case NET_SOCKET_ACCEPTED:
    251                         // push the new socket identifier
     245                        /* Push the new socket identifier */
    252246                        fibril_mutex_lock(&socket->accept_lock);
    253247                        rc = dyn_fifo_push(&socket->accepted, 1,
    254248                            SOCKET_MAX_ACCEPTED_SIZE);
    255                         if (rc != EOK) {
    256                                 // signal the accepted socket
     249                        if (rc == EOK) {
     250                                /* Signal the accepted socket */
    257251                                fibril_condvar_signal(&socket->accept_signal);
    258252                        }
    … …  
    269263                        fibril_rwlock_write_lock(&socket->sending_lock);
    270264
    271                         // set the data fragment size
     265                        /* Set the data fragment size */
    272266                        socket->data_fragment_size =
    273267                            SOCKET_GET_DATA_FRAGMENT_SIZE(call);
    … …  
    283277        }
    284278
    285         ipc_answer_0(callid, (ipcarg_t) rc);
     279        async_answer_0(callid, (sysarg_t) rc);
    286280        goto loop;
    287281}
    … …  
    291285 * Connects to the TCP module if necessary.
    292286 *
    293  * @returns             The TCP module phone.
    294  * @returns             Other error codes as defined for the
     287 * @return              The TCP module phone.
     288 * @return              Other error codes as defined for the
    295289 *                      bind_service_timeout() function.
    296290 */
    … …  
    310304 * Connects to the UDP module if necessary.
    311305 *
    312  * @returns             The UDP module phone.
    313  * @returns             Other error codes as defined for the
     306 * @return              The UDP module phone.
     307 * @return              Other error codes as defined for the
    314308 *                      bind_service_timeout() function.
    315309 */
    … …  
    327321/** Tries to find a new free socket identifier.
    328322 *
    329  * @returns             The new socket identifier.
    330  * @returns             ELIMIT if there is no socket identifier available.
     323 * @return              The new socket identifier.
     324 * @return              ELIMIT if there is no socket identifier available.
    331325 */
    332326static int socket_generate_new_id(void)
    333327{
    334         sockets_ref sockets;
     328        sockets_t *sockets;
    335329        int socket_id = 0;
    336330        int count;
    … …  
    347341                        socket_id = 1;
    348342                        ++count;
    349                 // only this branch for last_id
     343                /* Only this branch for last_id */
    350344                } else {
    351345                        if (socket_id < INT_MAX) {
    … …  
    372366 */
    373367static void
    374 socket_initialize(socket_ref socket, int socket_id, int phone,
     368socket_initialize(socket_t *socket, int socket_id, int phone,
    375369    services_t service)
    376370{
    … …  
    392386 * @param[in] type      Socket type.
    393387 * @param[in] protocol  Socket protocol.
    394  * @returns             The socket identifier on success.
    395  * @returns             EPFNOTSUPPORT if the protocol family is not supported.
    396  * @returns             ESOCKNOTSUPPORT if the socket type is not supported.
    397  * @returns             EPROTONOSUPPORT if the protocol is not supported.
    398  * @returns             ENOMEM if there is not enough memory left.
    399  * @returns             ELIMIT if there was not a free socket identifier found
     388 * @return              The socket identifier on success.
     389 * @return              EPFNOTSUPPORT if the protocol family is not supported.
     390 * @return              ESOCKNOTSUPPORT if the socket type is not supported.
     391 * @return              EPROTONOSUPPORT if the protocol is not supported.
     392 * @return              ENOMEM if there is not enough memory left.
     393 * @return              ELIMIT if there was not a free socket identifier found
    400394 *                      this time.
    401  * @returns             Other error codes as defined for the NET_SOCKET message.
    402  * @returns             Other error codes as defined for the
     395 * @return              Other error codes as defined for the NET_SOCKET message.
     396 * @return              Other error codes as defined for the
    403397 *                      bind_service_timeout() function.
    404398 */
    405399int socket(int domain, int type, int protocol)
    406400{
    407         socket_ref socket;
     401        socket_t *socket;
    408402        int phone;
    409403        int socket_id;
    410404        services_t service;
    411         ipcarg_t fragment_size;
    412         ipcarg_t header_size;
     405        sysarg_t fragment_size;
     406        sysarg_t header_size;
    413407        int rc;
    414408
    415         // find the appropriate service
     409        /* Find the appropriate service */
    416410        switch (domain) {
    417411        case PF_INET:
    … …  
    462456                return phone;
    463457
    464         // create a new socket structure
    465         socket = (socket_ref) malloc(sizeof(socket_t));
     458        /* Create a new socket structure */
     459        socket = (socket_t *) malloc(sizeof(socket_t));
    466460        if (!socket)
    467461                return ENOMEM;
    … …  
    470464        fibril_rwlock_write_lock(&socket_globals.lock);
    471465
    472         // request a new socket
     466        /* Request a new socket */
    473467        socket_id = socket_generate_new_id();
    474468        if (socket_id <= 0) {
    … …  
    489483        socket->header_size = (size_t) header_size;
    490484
    491         // finish the new socket initialization
     485        /* Finish the new socket initialization */
    492486        socket_initialize(socket, socket_id, phone, service);
    493         // store the new socket
     487        /* Store the new socket */
    494488        rc = sockets_add(socket_get_sockets(), socket_id, socket);
    495489
    … …  
    499493                dyn_fifo_destroy(&socket->accepted);
    500494                free(socket);
    501                 async_msg_3(phone, NET_SOCKET_CLOSE, (ipcarg_t) socket_id, 0,
     495                async_msg_3(phone, NET_SOCKET_CLOSE, (sysarg_t) socket_id, 0,
    502496                    service);
    503497                return rc;
    … …  
    514508 * @param[in] data      The data to be sent.
    515509 * @param[in] datalength The data length.
    516  * @returns             EOK on success.
    517  * @returns             ENOTSOCK if the socket is not found.
    518  * @returns             EBADMEM if the data parameter is NULL.
    519  * @returns             NO_DATA if the datalength parameter is zero (0).
    520  * @returns             Other error codes as defined for the spcific message.
     510 * @return              EOK on success.
     511 * @return              ENOTSOCK if the socket is not found.
     512 * @return              EBADMEM if the data parameter is NULL.
     513 * @return              NO_DATA if the datalength parameter is zero (0).
     514 * @return              Other error codes as defined for the spcific message.
    521515 */
    522516static int
    523 socket_send_data(int socket_id, ipcarg_t message, ipcarg_t arg2,
     517socket_send_data(int socket_id, sysarg_t message, sysarg_t arg2,
    524518    const void *data, size_t datalength)
    525519{
    526         socket_ref socket;
     520        socket_t *socket;
    527521        aid_t message_id;
    528         ipcarg_t result;
     522        sysarg_t result;
    529523
    530524        if (!data)
    … …  
    536530        fibril_rwlock_read_lock(&socket_globals.lock);
    537531
    538         // find the socket
     532        /* Find the socket */
    539533        socket = sockets_find(socket_get_sockets(), socket_id);
    540534        if (!socket) {
    … …  
    543537        }
    544538
    545         // request the message
     539        /* Request the message */
    546540        message_id = async_send_3(socket->phone, message,
    547             (ipcarg_t) socket->socket_id, arg2, socket->service, NULL);
    548         // send the address
     541            (sysarg_t) socket->socket_id, arg2, socket->service, NULL);
     542        /* Send the address */
    549543        async_data_write_start(socket->phone, data, datalength);
    550544
    … …  
    559553 * @param[in] my_addr   The port address.
    560554 * @param[in] addrlen   The address length.
    561  * @returns             EOK on success.
    562  * @returns             ENOTSOCK if the socket is not found.
    563  * @returns             EBADMEM if the my_addr parameter is NULL.
    564  * @returns             NO_DATA if the addlen parameter is zero.
    565  * @returns             Other error codes as defined for the NET_SOCKET_BIND
     555 * @return              EOK on success.
     556 * @return              ENOTSOCK if the socket is not found.
     557 * @return              EBADMEM if the my_addr parameter is NULL.
     558 * @return              NO_DATA if the addlen parameter is zero.
     559 * @return              Other error codes as defined for the NET_SOCKET_BIND
    566560 *                      message.
    567561 */
    … …  
    571565                return EINVAL;
    572566
    573         // send the address
     567        /* Send the address */
    574568        return socket_send_data(socket_id, NET_SOCKET_BIND, 0, my_addr,
    575569            (size_t) addrlen);
    … …  
    580574 * @param[in] socket_id Socket identifier.
    581575 * @param[in] backlog   The maximum number of waiting sockets to be accepted.
    582  * @returns             EOK on success.
    583  * @returns             EINVAL if the backlog parameter is not positive (<=0).
    584  * @returns             ENOTSOCK if the socket is not found.
    585  * @returns             Other error codes as defined for the NET_SOCKET_LISTEN
     576 * @return              EOK on success.
     577 * @return              EINVAL if the backlog parameter is not positive (<=0).
     578 * @return              ENOTSOCK if the socket is not found.
     579 * @return              Other error codes as defined for the NET_SOCKET_LISTEN
    586580 *                      message.
    587581 */
    588582int listen(int socket_id, int backlog)
    589583{
    590         socket_ref socket;
     584        socket_t *socket;
    591585        int result;
    592586
    … …  
    596590        fibril_rwlock_read_lock(&socket_globals.lock);
    597591
    598         // find the socket
     592        /* Find the socket */
    599593        socket = sockets_find(socket_get_sockets(), socket_id);
    600594        if (!socket) {
    … …  
    603597        }
    604598
    605         // request listen backlog change
     599        /* Request listen backlog change */
    606600        result = (int) async_req_3_0(socket->phone, NET_SOCKET_LISTEN,
    607             (ipcarg_t) socket->socket_id, (ipcarg_t) backlog, socket->service);
     601            (sysarg_t) socket->socket_id, (sysarg_t) backlog, socket->service);
    608602
    609603        fibril_rwlock_read_unlock(&socket_globals.lock);
    … …  
    618612 * @param[out] cliaddr  The remote client address.
    619613 * @param[in] addrlen   The address length.
    620  * @returns             EOK on success.
    621  * @returns             EBADMEM if the cliaddr or addrlen parameter is NULL.
    622  * @returns             EINVAL if the backlog parameter is not positive (<=0).
    623  * @returns             ENOTSOCK if the socket is not found.
    624  * @returns             Other error codes as defined for the NET_SOCKET_ACCEPT
     614 * @return              EOK on success.
     615 * @return              EBADMEM if the cliaddr or addrlen parameter is NULL.
     616 * @return              EINVAL if the backlog parameter is not positive (<=0).
     617 * @return              ENOTSOCK if the socket is not found.
     618 * @return              Other error codes as defined for the NET_SOCKET_ACCEPT
    625619 *                      message.
    626620 */
    627621int accept(int socket_id, struct sockaddr * cliaddr, socklen_t * addrlen)
    628622{
    629         socket_ref socket;
    630         socket_ref new_socket;
     623        socket_t *socket;
     624        socket_t *new_socket;
    631625        aid_t message_id;
    632         ipcarg_t ipc_result;
     626        sysarg_t ipc_result;
    633627        int result;
    634628        ipc_call_t answer;
    … …  
    639633        fibril_rwlock_write_lock(&socket_globals.lock);
    640634
    641         // find the socket
     635        /* Find the socket */
    642636        socket = sockets_find(socket_get_sockets(), socket_id);
    643637        if (!socket) {
    … …  
    648642        fibril_mutex_lock(&socket->accept_lock);
    649643
    650         // wait for an accepted socket
     644        /* Wait for an accepted socket */
    651645        ++ socket->blocked;
    652646        while (dyn_fifo_value(&socket->accepted) <= 0) {
    653647                fibril_rwlock_write_unlock(&socket_globals.lock);
    654648                fibril_condvar_wait(&socket->accept_signal, &socket->accept_lock);
    655                 // drop the accept lock to avoid deadlock
     649                /* Drop the accept lock to avoid deadlock */
    656650                fibril_mutex_unlock(&socket->accept_lock);
    657651                fibril_rwlock_write_lock(&socket_globals.lock);
    … …  
    660654        -- socket->blocked;
    661655
    662         // create a new scoket
    663         new_socket = (socket_ref) malloc(sizeof(socket_t));
     656        /* Create a new socket */
     657        new_socket = (socket_t *) malloc(sizeof(socket_t));
    664658        if (!new_socket) {
    665659                fibril_mutex_unlock(&socket->accept_lock);
    … …  
    686680        }
    687681
    688         // request accept
     682        /* Request accept */
    689683        message_id = async_send_5(socket->phone, NET_SOCKET_ACCEPT,
    690             (ipcarg_t) socket->socket_id, 0, socket->service, 0,
     684            (sysarg_t) socket->socket_id, 0, socket->service, 0,
    691685            new_socket->socket_id, &answer);
    692686
    693         // read address
    694         ipc_data_read_start(socket->phone, cliaddr, *addrlen);
     687        /* Read address */
     688        async_data_read_start(socket->phone, cliaddr, *addrlen);
    695689        fibril_rwlock_write_unlock(&socket_globals.lock);
    696690        async_wait_for(message_id, &ipc_result);
    … …  
    700694                        result = EINVAL;
    701695
    702                 // dequeue the accepted socket if successful
     696                /* Dequeue the accepted socket if successful */
    703697                dyn_fifo_pop(&socket->accepted);
    704                 // set address length
     698                /* Set address length */
    705699                *addrlen = SOCKET_GET_ADDRESS_LENGTH(answer);
    706700                new_socket->data_fragment_size =
    707701                    SOCKET_GET_DATA_FRAGMENT_SIZE(answer);
    708702        } else if (result == ENOTSOCK) {
    709                 // empty the queue if no accepted sockets
     703                /* Empty the queue if no accepted sockets */
    710704                while (dyn_fifo_pop(&socket->accepted) > 0)
    711705                        ;
    … …  
    721715 * @param[in] serv_addr The remote server address.
    722716 * @param[in] addrlen   The address length.
    723  * @returns             EOK on success.
    724  * @returns             EBADMEM if the serv_addr parameter is NULL.
    725  * @returns             NO_DATA if the addlen parameter is zero.
    726  * @returns             ENOTSOCK if the socket is not found.
    727  * @returns             Other error codes as defined for the NET_SOCKET_CONNECT
     717 * @return              EOK on success.
     718 * @return              EBADMEM if the serv_addr parameter is NULL.
     719 * @return              NO_DATA if the addlen parameter is zero.
     720 * @return              ENOTSOCK if the socket is not found.
     721 * @return              Other error codes as defined for the NET_SOCKET_CONNECT
    728722 *                      message.
    729723 */
    … …  
    736730                return EDESTADDRREQ;
    737731
    738         // send the address
     732        /* Send the address */
    739733        return socket_send_data(socket_id, NET_SOCKET_CONNECT, 0, serv_addr,
    740734            addrlen);
    … …  
    745739 * @param[in] socket    The socket to be destroyed.
    746740 */
    747 static void socket_destroy(socket_ref socket)
     741static void socket_destroy(socket_t *socket)
    748742{
    749743        int accepted_id;
    750744
    751         // destroy all accepted sockets
     745        /* Destroy all accepted sockets */
    752746        while ((accepted_id = dyn_fifo_pop(&socket->accepted)) >= 0)
    753747                socket_destroy(sockets_find(socket_get_sockets(), accepted_id));
    … …  
    755749        dyn_fifo_destroy(&socket->received);
    756750        dyn_fifo_destroy(&socket->accepted);
    757         sockets_exclude(socket_get_sockets(), socket->socket_id);
     751        sockets_exclude(socket_get_sockets(), socket->socket_id, free);
    758752}
    759753
    … …  
    761755 *
    762756 * @param[in] socket_id Socket identifier.
    763  * @returns             EOK on success.
    764  * @returns             ENOTSOCK if the socket is not found.
    765  * @returns             EINPROGRESS if there is another blocking function in
     757 * @return              EOK on success.
     758 * @return              ENOTSOCK if the socket is not found.
     759 * @return              EINPROGRESS if there is another blocking function in
    766760 *                      progress.
    767  * @returns             Other error codes as defined for the NET_SOCKET_CLOSE
     761 * @return              Other error codes as defined for the NET_SOCKET_CLOSE
    768762 *                      message.
    769763 */
    770764int closesocket(int socket_id)
    771765{
    772         socket_ref socket;
     766        socket_t *socket;
    773767        int rc;
    774768
    … …  
    785779        }
    786780
    787         // request close
     781        /* Request close */
    788782        rc = (int) async_req_3_0(socket->phone, NET_SOCKET_CLOSE,
    789             (ipcarg_t) socket->socket_id, 0, socket->service);
     783            (sysarg_t) socket->socket_id, 0, socket->service);
    790784        if (rc != EOK) {
    791785                fibril_rwlock_write_unlock(&socket_globals.lock);
    792786                return rc;
    793787        }
    794         // free the socket structure
     788        /* Free the socket structure */
    795789        socket_destroy(socket);
    796790
    … …  
    811805 *                      sockets.
    812806 * @param[in] addrlen   The address length. Used only if toaddr is not NULL.
    813  * @returns             EOK on success.
    814  * @returns             ENOTSOCK if the socket is not found.
    815  * @returns             EBADMEM if the data or toaddr parameter is NULL.
    816  * @returns             NO_DATA if the datalength or the addrlen parameter is
     807 * @return              EOK on success.
     808 * @return              ENOTSOCK if the socket is not found.
     809 * @return              EBADMEM if the data or toaddr parameter is NULL.
     810 * @return              NO_DATA if the datalength or the addrlen parameter is
    817811 *                      zero (0).
    818  * @returns             Other error codes as defined for the NET_SOCKET_SENDTO
     812 * @return              Other error codes as defined for the NET_SOCKET_SENDTO
    819813 *                      message.
    820814 */
    821815static int
    822 sendto_core(ipcarg_t message, int socket_id, const void *data,
     816sendto_core(sysarg_t message, int socket_id, const void *data,
    823817    size_t datalength, int flags, const struct sockaddr *toaddr,
    824818    socklen_t addrlen)
    825819{
    826         socket_ref socket;
     820        socket_t *socket;
    827821        aid_t message_id;
    828         ipcarg_t result;
     822        sysarg_t result;
    829823        size_t fragments;
    830824        ipc_call_t answer;
    … …  
    838832        fibril_rwlock_read_lock(&socket_globals.lock);
    839833
    840         // find socket
     834        /* Find socket */
    841835        socket = sockets_find(socket_get_sockets(), socket_id);
    842836        if (!socket) {
    … …  
    847841        fibril_rwlock_read_lock(&socket->sending_lock);
    848842
    849         // compute data fragment count
     843        /* Compute data fragment count */
    850844        if (socket->data_fragment_size > 0) {
    851845                fragments = (datalength + socket->header_size) /
    … …  
    858852        }
    859853
    860         // request send
     854        /* Request send */
    861855        message_id = async_send_5(socket->phone, message,
    862             (ipcarg_t) socket->socket_id,
     856            (sysarg_t) socket->socket_id,
    863857            (fragments == 1 ? datalength : socket->data_fragment_size),
    864             socket->service, (ipcarg_t) flags, fragments, &answer);
    865 
    866         // send the address if given
     858            socket->service, (sysarg_t) flags, fragments, &answer);
     859
     860        /* Send the address if given */
    867861        if (!toaddr ||
    868862            (async_data_write_start(socket->phone, toaddr, addrlen) == EOK)) {
    869863                if (fragments == 1) {
    870                         // send all if only one fragment
     864                        /* Send all if only one fragment */
    871865                        async_data_write_start(socket->phone, data, datalength);
    872866                } else {
    873                         // send the first fragment
     867                        /* Send the first fragment */
    874868                        async_data_write_start(socket->phone, data,
    875869                            socket->data_fragment_size - socket->header_size);
    … …  
    877871                            socket->data_fragment_size - socket->header_size;
    878872       
    879                         // send the middle fragments
     873                        /* Send the middle fragments */
    880874                        while (--fragments > 1) {
    881875                                async_data_write_start(socket->phone, data,
    … …  
    885879                        }
    886880
    887                         // send the last fragment
     881                        /* Send the last fragment */
    888882                        async_data_write_start(socket->phone, data,
    889883                            (datalength + socket->header_size) %
    … …  
    897891            (SOCKET_GET_DATA_FRAGMENT_SIZE(answer) !=
    898892            socket->data_fragment_size)) {
    899                 // set the data fragment size
     893                /* Set the data fragment size */
    900894                socket->data_fragment_size =
    901895                    SOCKET_GET_DATA_FRAGMENT_SIZE(answer);
    … …  
    913907 * @param[in] datalength The data length.
    914908 * @param[in] flags     Various send flags.
    915  * @returns             EOK on success.
    916  * @returns             ENOTSOCK if the socket is not found.
    917  * @returns             EBADMEM if the data parameter is NULL.
    918  * @returns             NO_DATA if the datalength parameter is zero.
    919  * @returns             Other error codes as defined for the NET_SOCKET_SEND
     909 * @return              EOK on success.
     910 * @return              ENOTSOCK if the socket is not found.
     911 * @return              EBADMEM if the data parameter is NULL.
     912 * @return              NO_DATA if the datalength parameter is zero.
     913 * @return              Other error codes as defined for the NET_SOCKET_SEND
    920914 *                      message.
    921915 */
    922916int send(int socket_id, void *data, size_t datalength, int flags)
    923917{
    924         // without the address
     918        /* Without the address */
    925919        return sendto_core(NET_SOCKET_SEND, socket_id, data, datalength, flags,
    926920            NULL, 0);
    … …  
    937931 * @param[in] toaddr    The destination address.
    938932 * @param[in] addrlen   The address length.
    939  * @returns             EOK on success.
    940  * @returns             ENOTSOCK if the socket is not found.
    941  * @returns             EBADMEM if the data or toaddr parameter is NULL.
    942  * @returns             NO_DATA if the datalength or the addrlen parameter is
     933 * @return              EOK on success.
     934 * @return              ENOTSOCK if the socket is not found.
     935 * @return              EBADMEM if the data or toaddr parameter is NULL.
     936 * @return              NO_DATA if the datalength or the addrlen parameter is
    943937 *                      zero.
    944  * @returns             Other error codes as defined for the NET_SOCKET_SENDTO
     938 * @return              Other error codes as defined for the NET_SOCKET_SENDTO
    945939 *                      message.
    946940 */
    … …  
    955949                return EDESTADDRREQ;
    956950
    957         // with the address
     951        /* With the address */
    958952        return sendto_core(NET_SOCKET_SENDTO, socket_id, data, datalength,
    959953            flags, toaddr, addrlen);
    … …  
    971965 *                      read. The actual address length is set. Used only if
    972966 *                      fromaddr is not NULL.
    973  * @returns             EOK on success.
    974  * @returns             ENOTSOCK if the socket is not found.
    975  * @returns             EBADMEM if the data parameter is NULL.
    976  * @returns             NO_DATA if the datalength or addrlen parameter is zero.
    977  * @returns             Other error codes as defined for the spcific message.
    978  */
    979 static int
    980 recvfrom_core(ipcarg_t message, int socket_id, void *data, size_t datalength,
     967 * @return              Positive received message size in bytes on success.
     968 * @return              Zero if no more data (other side closed the connection).
     969 * @return              ENOTSOCK if the socket is not found.
     970 * @return              EBADMEM if the data parameter is NULL.
     971 * @return              NO_DATA if the datalength or addrlen parameter is zero.
     972 * @return              Other error codes as defined for the spcific message.
     973 */
     974static ssize_t
     975recvfrom_core(sysarg_t message, int socket_id, void *data, size_t datalength,
    981976    int flags, struct sockaddr *fromaddr, socklen_t *addrlen)
    982977{
    983         socket_ref socket;
     978        socket_t *socket;
    984979        aid_t message_id;
    985         ipcarg_t ipc_result;
     980        sysarg_t ipc_result;
    986981        int result;
    987982        size_t fragments;
    … …  
    989984        size_t index;
    990985        ipc_call_t answer;
     986        ssize_t retval;
    991987
    992988        if (!data)
    … …  
    1001997        fibril_rwlock_read_lock(&socket_globals.lock);
    1002998
    1003         // find the socket
     999        /* Find the socket */
    10041000        socket = sockets_find(socket_get_sockets(), socket_id);
    10051001        if (!socket) {
    … …  
    10091005
    10101006        fibril_mutex_lock(&socket->receive_lock);
    1011         // wait for a received packet
     1007        /* Wait for a received packet */
    10121008        ++socket->blocked;
    1013         while ((result = dyn_fifo_value(&socket->received)) <= 0) {
     1009        while ((result = dyn_fifo_value(&socket->received)) < 0) {
    10141010                fibril_rwlock_read_unlock(&socket_globals.lock);
    10151011                fibril_condvar_wait(&socket->receive_signal,
    10161012                    &socket->receive_lock);
    10171013
    1018                 // drop the receive lock to avoid deadlock
     1014                /* Drop the receive lock to avoid deadlock */
    10191015                fibril_mutex_unlock(&socket->receive_lock);
    10201016                fibril_rwlock_read_lock(&socket_globals.lock);
    … …  
    10241020        fragments = (size_t) result;
    10251021
    1026         // prepare lengths if more fragments
     1022        if (fragments == 0) {
     1023                /* No more data, other side has closed the connection. */
     1024                fibril_mutex_unlock(&socket->receive_lock);
     1025                fibril_rwlock_read_unlock(&socket_globals.lock);
     1026                return 0;
     1027        }
     1028
     1029        /* Prepare lengths if more fragments */
    10271030        if (fragments > 1) {
    10281031                lengths = (size_t *) malloc(sizeof(size_t) * fragments +
    … …  
    10341037                }
    10351038
    1036                 // request packet data
     1039                /* Request packet data */
    10371040                message_id = async_send_4(socket->phone, message,
    1038                     (ipcarg_t) socket->socket_id, 0, socket->service,
    1039                     (ipcarg_t) flags, &answer);
    1040 
    1041                 // read the address if desired
     1041                    (sysarg_t) socket->socket_id, 0, socket->service,
     1042                    (sysarg_t) flags, &answer);
     1043
     1044                /* Read the address if desired */
    10421045                if(!fromaddr ||
    10431046                    (async_data_read_start(socket->phone, fromaddr,
    10441047                    *addrlen) == EOK)) {
    1045                         // read the fragment lengths
     1048                        /* Read the fragment lengths */
    10461049                        if (async_data_read_start(socket->phone, lengths,
    10471050                            sizeof(int) * (fragments + 1)) == EOK) {
    10481051                                if (lengths[fragments] <= datalength) {
    10491052
    1050                                         // read all fragments if long enough
     1053                                        /* Read all fragments if long enough */
    10511054                                        for (index = 0; index < fragments;
    10521055                                            ++index) {
    … …  
    10621065
    10631066                free(lengths);
    1064         } else {
    1065                 // request packet data
     1067        } else { /* fragments == 1 */
     1068                /* Request packet data */
    10661069                message_id = async_send_4(socket->phone, message,
    1067                     (ipcarg_t) socket->socket_id, 0, socket->service,
    1068                     (ipcarg_t) flags, &answer);
    1069 
    1070                 // read the address if desired
     1070                    (sysarg_t) socket->socket_id, 0, socket->service,
     1071                    (sysarg_t) flags, &answer);
     1072
     1073                /* Read the address if desired */
    10711074                if (!fromaddr ||
    10721075                    (async_data_read_start(socket->phone, fromaddr,
    10731076                        *addrlen) == EOK)) {
    1074                         // read all if only one fragment
     1077                        /* Read all if only one fragment */
    10751078                        async_data_read_start(socket->phone, data, datalength);
    10761079                }
    … …  
    10801083        result = (int) ipc_result;
    10811084        if (result == EOK) {
    1082                 // dequeue the received packet
     1085                /* Dequeue the received packet */
    10831086                dyn_fifo_pop(&socket->received);
    1084                 // return read data length
    1085                 result = SOCKET_GET_READ_DATA_LENGTH(answer);
    1086                 // set address length
     1087                /* Return read data length */
     1088                retval = SOCKET_GET_READ_DATA_LENGTH(answer);
     1089                /* Set address length */
    10871090                if (fromaddr && addrlen)
    10881091                        *addrlen = SOCKET_GET_ADDRESS_LENGTH(answer);
     1092        } else {
     1093                retval = (ssize_t) result;
    10891094        }
    10901095
    10911096        fibril_mutex_unlock(&socket->receive_lock);
    10921097        fibril_rwlock_read_unlock(&socket_globals.lock);
    1093         return result;
     1098        return retval;
    10941099}
    10951100
    … …  
    11001105 * @param[in] datalength The data length.
    11011106 * @param[in] flags     Various receive flags.
    1102  * @returns             EOK on success.
    1103  * @returns             ENOTSOCK if the socket is not found.
    1104  * @returns             EBADMEM if the data parameter is NULL.
    1105  * @returns             NO_DATA if the datalength parameter is zero.
    1106  * @returns             Other error codes as defined for the NET_SOCKET_RECV
     1107 * @return              Positive received message size in bytes on success.
     1108 * @return              Zero if no more data (other side closed the connection).
     1109 * @return              ENOTSOCK if the socket is not found.
     1110 * @return              EBADMEM if the data parameter is NULL.
     1111 * @return              NO_DATA if the datalength parameter is zero.
     1112 * @return              Other error codes as defined for the NET_SOCKET_RECV
    11071113 *                      message.
    11081114 */
    1109 int recv(int socket_id, void *data, size_t datalength, int flags)
    1110 {
    1111         // without the address
     1115ssize_t recv(int socket_id, void *data, size_t datalength, int flags)
     1116{
     1117        /* Without the address */
    11121118        return recvfrom_core(NET_SOCKET_RECV, socket_id, data, datalength,
    11131119            flags, NULL, NULL);
    … …  
    11231129 * @param[in,out] addrlen The address length. The maximum address length is
    11241130 *                      read. The actual address length is set.
    1125  * @returns             EOK on success.
    1126  * @returns             ENOTSOCK if the socket is not found.
    1127  * @returns             EBADMEM if the data or fromaddr parameter is NULL.
    1128  * @returns             NO_DATA if the datalength or addrlen parameter is zero.
    1129  * @returns             Other error codes as defined for the NET_SOCKET_RECVFROM
     1131 * @return              Positive received message size in bytes on success.
     1132 * @return              Zero if no more data (other side closed the connection).
     1133 * @return              ENOTSOCK if the socket is not found.
     1134 * @return              EBADMEM if the data or fromaddr parameter is NULL.
     1135 * @return              NO_DATA if the datalength or addrlen parameter is zero.
     1136 * @return              Other error codes as defined for the NET_SOCKET_RECVFROM
    11301137 *                      message.
    11311138 */
    1132 int
     1139ssize_t
    11331140recvfrom(int socket_id, void *data, size_t datalength, int flags,
    11341141    struct sockaddr *fromaddr, socklen_t *addrlen)
    … …  
    11401147                return NO_DATA;
    11411148
    1142         // with the address
     1149        /* With the address */
    11431150        return recvfrom_core(NET_SOCKET_RECVFROM, socket_id, data, datalength,
    11441151            flags, fromaddr, addrlen);
    … …  
    11531160 * @param[in,out] optlen The value buffer length. The maximum length is read.
    11541161 *                      The actual length is set.
    1155  * @returns             EOK on success.
    1156  * @returns             ENOTSOCK if the socket is not found.
    1157  * @returns             EBADMEM if the value or optlen parameter is NULL.
    1158  * @returns             NO_DATA if the optlen parameter is zero.
    1159  * @returns             Other error codes as defined for the
     1162 * @return              EOK on success.
     1163 * @return              ENOTSOCK if the socket is not found.
     1164 * @return              EBADMEM if the value or optlen parameter is NULL.
     1165 * @return              NO_DATA if the optlen parameter is zero.
     1166 * @return              Other error codes as defined for the
    11601167 *                      NET_SOCKET_GETSOCKOPT message.
    11611168 */
    … …  
    11631170getsockopt(int socket_id, int level, int optname, void *value, size_t *optlen)
    11641171{
    1165         socket_ref socket;
     1172        socket_t *socket;
    11661173        aid_t message_id;
    1167         ipcarg_t result;
     1174        sysarg_t result;
    11681175
    11691176        if (!value || !optlen)
    … …  
    11751182        fibril_rwlock_read_lock(&socket_globals.lock);
    11761183
    1177         // find the socket
     1184        /* Find the socket */
    11781185        socket = sockets_find(socket_get_sockets(), socket_id);
    11791186        if (!socket) {
    … …  
    11821189        }
    11831190
    1184         // request option value
     1191        /* Request option value */
    11851192        message_id = async_send_3(socket->phone, NET_SOCKET_GETSOCKOPT,
    1186             (ipcarg_t) socket->socket_id, (ipcarg_t) optname, socket->service,
     1193            (sysarg_t) socket->socket_id, (sysarg_t) optname, socket->service,
    11871194            NULL);
    11881195
    1189         // read the length
     1196        /* Read the length */
    11901197        if (async_data_read_start(socket->phone, optlen,
    11911198            sizeof(*optlen)) == EOK) {
    1192                 // read the value
     1199                /* Read the value */
    11931200                async_data_read_start(socket->phone, value, *optlen);
    11941201        }
    … …  
    12061213 * @param[in] value     The value to be set.
    12071214 * @param[in] optlen    The value length.
    1208  * @returns             EOK on success.
    1209  * @returns             ENOTSOCK if the socket is not found.
    1210  * @returns             EBADMEM if the value parameter is NULL.
    1211  * @returns             NO_DATA if the optlen parameter is zero.
    1212  * @returns             Other error codes as defined for the
     1215 * @return              EOK on success.
     1216 * @return              ENOTSOCK if the socket is not found.
     1217 * @return              EBADMEM if the value parameter is NULL.
     1218 * @return              NO_DATA if the optlen parameter is zero.
     1219 * @return              Other error codes as defined for the
    12131220 *                      NET_SOCKET_SETSOCKOPT message.
    12141221 */
    … …  
    12171224    size_t optlen)
    12181225{
    1219         // send the value
     1226        /* Send the value */
    12201227        return socket_send_data(socket_id, NET_SOCKET_SETSOCKOPT,
    1221             (ipcarg_t) optname, value, optlen);
     1228            (sysarg_t) optname, value, optlen);
    12221229}
    12231230
Note: See TracChangeset for help on using the changeset viewer.