source: mainline/uspace/lib/socket/generic/socket_client.c@ 849ed54

/*
 * Copyright (c) 2009 Lukas Mejdrech
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

/** @addtogroup socket
 *  @{
 */

/** @file
 *  Socket application program interface (API) implementation.
 *  @see socket.h for more information.
 *  This is a part of the network application library.
 */

#include <assert.h>
#include <async.h>
#include <fibril_synch.h>
#include <limits.h>
#include <stdlib.h>

#include <ipc/services.h>

#include <net_err.h>
#include <net_modules.h>
#include <in.h>
#include <socket.h>
#include <socket_errno.h>
#include <adt/dynamic_fifo.h>
#include <adt/int_map.h>
#include <socket_messages.h>

/** Initial received packet queue size.
 */
#define SOCKET_INITIAL_RECEIVED_SIZE    4

/** Maximum received packet queue size.
 */
#define SOCKET_MAX_RECEIVED_SIZE                0

/** Initial waiting sockets queue size.
 */
#define SOCKET_INITIAL_ACCEPTED_SIZE    1

/** Maximum waiting sockets queue size.
 */
#define SOCKET_MAX_ACCEPTED_SIZE                0

/** Default timeout for connections in microseconds.
 */
#define SOCKET_CONNECT_TIMEOUT  (1 * 1000 * 1000)

/** Maximum number of random attempts to find a new socket identifier before switching to the sequence.
 */
#define SOCKET_ID_TRIES                                 100

/** Type definition of the socket specific data.
 *  @see socket
 */
typedef struct socket   socket_t;

/** Type definition of the socket specific data pointer.
 *  @see socket
 */
typedef socket_t *      socket_ref;

/** Socket specific data.
 *  Each socket lock locks only its structure part and any number of them may be locked simultaneously.
 */
struct socket{
        /** Socket identifier.
         */
        int socket_id;
        /** Parent module phone.
         */
        int phone;
        /** Parent module service.
         */
        services_t service;
        /** Underlying protocol header size.
         *  Sending and receiving optimalization.
         */
        size_t header_size;
        /** Packet data fragment size.
         *  Sending optimalization.
         */
        size_t data_fragment_size;
        /** Sending safety lock.
         *  Locks the header_size and data_fragment_size attributes.
         */
        fibril_rwlock_t sending_lock;
        /** Received packets queue.
         */
        dyn_fifo_t received;
        /** Received packets safety lock.
         *  Used for receiving and receive notifications.
         *  Locks the received attribute.
         */
        fibril_mutex_t receive_lock;
        /** Received packets signaling.
         *  Signaled upon receive notification.
         */
        fibril_condvar_t receive_signal;
        /** Waiting sockets queue.
         */
        dyn_fifo_t accepted;
        /** Waiting sockets safety lock.
         *  Used for accepting and accept notifications.
         *  Locks the accepted attribute.
         */
        fibril_mutex_t accept_lock;
        /** Waiting sockets signaling.
         *  Signaled upon accept notification.
         */
        fibril_condvar_t accept_signal;
        /** The number of blocked functions called.
         *  Used while waiting for the received packets or accepted sockets.
         */
        int blocked;
};

/** Sockets map.
 *  Maps socket identifiers to the socket specific data.
 *  @see int_map.h
 */
INT_MAP_DECLARE(sockets, socket_t);

/** Socket client library global data.
 */
static struct socket_client_globals {
        /** TCP module phone.
         */
        int tcp_phone;
        /** UDP module phone.
         */
        int udp_phone;
//      /** The last socket identifier.
//       */
//      int last_id;
        /** Active sockets.
         */
        sockets_ref sockets;
        /** Safety lock.
         *  Write lock is used only for adding or removing sockets.
         *  When locked for writing, no other socket locks need to be locked.
         *  When locked for reading, any other socket locks may be locked.
         *  No socket lock may be locked if this lock is unlocked.
         */
        fibril_rwlock_t lock;
} socket_globals = {
        .tcp_phone = -1,
        .udp_phone = -1,
//      .last_id = 0,
        .sockets = NULL,
        .lock = {
                .readers = 0,
                .writers = 0,
                .waiters = {
                        .prev = &socket_globals.lock.waiters,
                        .next = &socket_globals.lock.waiters
                }
        }
};

INT_MAP_IMPLEMENT(sockets, socket_t);

/** Returns the active sockets.
 *  @returns The active sockets.
 */
static sockets_ref socket_get_sockets(void){
        if(! socket_globals.sockets){
                socket_globals.sockets = (sockets_ref) malloc(sizeof(sockets_t));
                if(! socket_globals.sockets){
                        return NULL;
                }
                if(sockets_initialize(socket_globals.sockets) != EOK){
                        free(socket_globals.sockets);
                        socket_globals.sockets = NULL;
                }
                srand(task_get_id());
        }
        return socket_globals.sockets;
}

/** Default thread for new connections.
 *  @param[in] iid The initial message identifier.
 *  @param[in] icall The initial message call structure.
 */
static void socket_connection(ipc_callid_t iid, ipc_call_t * icall){
        ERROR_DECLARE;

        ipc_callid_t callid;
        ipc_call_t call;
        socket_ref socket;

        while(true){

                callid = async_get_call(&call);
                switch(IPC_GET_METHOD(call)){
                        case NET_SOCKET_RECEIVED:
                        case NET_SOCKET_ACCEPTED:
                        case NET_SOCKET_DATA_FRAGMENT_SIZE:
                                fibril_rwlock_read_lock(&socket_globals.lock);
                                // find the socket
                                socket = sockets_find(socket_get_sockets(), SOCKET_GET_SOCKET_ID(call));
                                if(! socket){
                                        ERROR_CODE = ENOTSOCK;
                                }else{
                                        switch(IPC_GET_METHOD(call)){
                                                case NET_SOCKET_RECEIVED:
                                                        fibril_mutex_lock(&socket->receive_lock);
                                                        // push the number of received packet fragments
                                                        if(! ERROR_OCCURRED(dyn_fifo_push(&socket->received, SOCKET_GET_DATA_FRAGMENTS(call), SOCKET_MAX_RECEIVED_SIZE))){
                                                                // signal the received packet
                                                                fibril_condvar_signal(&socket->receive_signal);
                                                        }
                                                        fibril_mutex_unlock(&socket->receive_lock);
                                                        break;
                                                case NET_SOCKET_ACCEPTED:
                                                        // push the new socket identifier
                                                        fibril_mutex_lock(&socket->accept_lock);
                                                        if(! ERROR_OCCURRED(dyn_fifo_push(&socket->accepted, 1, SOCKET_MAX_ACCEPTED_SIZE))){
                                                                // signal the accepted socket
                                                                fibril_condvar_signal(&socket->accept_signal);
                                                        }
                                                        fibril_mutex_unlock(&socket->accept_lock);
                                                        break;
                                                default:
                                                        ERROR_CODE = ENOTSUP;
                                        }
                                        if((SOCKET_GET_DATA_FRAGMENT_SIZE(call) > 0)
                                                && (SOCKET_GET_DATA_FRAGMENT_SIZE(call) != socket->data_fragment_size)){
                                                fibril_rwlock_write_lock(&socket->sending_lock);
                                                // set the data fragment size
                                                socket->data_fragment_size = SOCKET_GET_DATA_FRAGMENT_SIZE(call);
                                                fibril_rwlock_write_unlock(&socket->sending_lock);
                                        }
                                }
                                fibril_rwlock_read_unlock(&socket_globals.lock);
                                break;
                        default:
                                ERROR_CODE = ENOTSUP;
                }
                ipc_answer_0(callid, (ipcarg_t) ERROR_CODE);
        }
}

/** Returns the TCP module phone.
 *  Connects to the TCP module if necessary.
 *  @returns The TCP module phone.
 *  @returns Other error codes as defined for the bind_service_timeout() function.
 */
static int socket_get_tcp_phone(void){
        if(socket_globals.tcp_phone < 0){
                socket_globals.tcp_phone = bind_service_timeout(SERVICE_TCP, 0, 0, SERVICE_TCP, socket_connection, SOCKET_CONNECT_TIMEOUT);
        }
        return socket_globals.tcp_phone;
}

/** Returns the UDP module phone.
 *  Connects to the UDP module if necessary.
 *  @returns The UDP module phone.
 *  @returns Other error codes as defined for the bind_service_timeout() function.
 */
static int socket_get_udp_phone(void){
        if(socket_globals.udp_phone < 0){
                socket_globals.udp_phone = bind_service_timeout(SERVICE_UDP, 0, 0, SERVICE_UDP, socket_connection, SOCKET_CONNECT_TIMEOUT);
        }
        return socket_globals.udp_phone;
}

/** Tries to find a new free socket identifier.
 *      @returns The new socket identifier.
 *  @returns ELIMIT if there is no socket identifier available.
 */
static int socket_generate_new_id(void){
        sockets_ref sockets;
        int socket_id;
        int count;

        sockets = socket_get_sockets();
        count = 0;
//      socket_id = socket_globals.last_id;
        do{
                if(count < SOCKET_ID_TRIES){
                        socket_id = rand() % INT_MAX;
                        ++ count;
                }else if(count == SOCKET_ID_TRIES){
                        socket_id = 1;
                        ++ count;
                // only this branch for last_id
                }else{
                        if(socket_id < INT_MAX){
                                ++ socket_id;
/*                      }else if(socket_globals.last_id){
*                               socket_globals.last_id = 0;
*                               socket_id = 1;
*/                      }else{
                                return ELIMIT;
                        }
                }
        }while(sockets_find(sockets, socket_id));
//      last_id = socket_id
        return socket_id;
}

/** Initializes a new socket specific data.
 *  @param[in,out] socket The socket to be initialized.
 *  @param[in] socket_id The new socket identifier.
 *  @param[in] phone The parent module phone.
 *  @param[in] service The parent module service.
 */
static void socket_initialize(socket_ref socket, int socket_id, int phone, services_t service){
        socket->socket_id = socket_id;
        socket->phone = phone;
        socket->service = service;
        dyn_fifo_initialize(&socket->received, SOCKET_INITIAL_RECEIVED_SIZE);
        dyn_fifo_initialize(&socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE);
        fibril_mutex_initialize(&socket->receive_lock);
        fibril_condvar_initialize(&socket->receive_signal);
        fibril_mutex_initialize(&socket->accept_lock);
        fibril_condvar_initialize(&socket->accept_signal);
        fibril_rwlock_initialize(&socket->sending_lock);
}

int socket(int domain, int type, int protocol){
        ERROR_DECLARE;

        socket_ref socket;
        int phone;
        int socket_id;
        services_t service;
        ipcarg_t fragment_size;
        ipcarg_t header_size;

        // find the appropriate service
        switch(domain){
                case PF_INET:
                        switch(type){
                                case SOCK_STREAM:
                                        if(! protocol){
                                                protocol = IPPROTO_TCP;
                                        }
                                        switch(protocol){
                                                case IPPROTO_TCP:
                                                        phone = socket_get_tcp_phone();
                                                        service = SERVICE_TCP;
                                                        break;
                                                default:
                                                        return EPROTONOSUPPORT;
                                        }
                                        break;
                                case SOCK_DGRAM:
                                        if(! protocol){
                                                protocol = IPPROTO_UDP;
                                        }
                                        switch(protocol){
                                                case IPPROTO_UDP:
                                                        phone = socket_get_udp_phone();
                                                        service = SERVICE_UDP;
                                                        break;
                                                default:
                                                        return EPROTONOSUPPORT;
                                        }
                                        break;
                                case SOCK_RAW:
                                default:
                                        return ESOCKTNOSUPPORT;
                        }
                        break;
                // TODO IPv6
                default:
                        return EPFNOSUPPORT;
        }
        if(phone < 0){
                return phone;
        }
        // create a new socket structure
        socket = (socket_ref) malloc(sizeof(socket_t));
        if(! socket){
                return ENOMEM;
        }
        bzero(socket, sizeof(*socket));
        fibril_rwlock_write_lock(&socket_globals.lock);
        // request a new socket
        socket_id = socket_generate_new_id();
        if(socket_id <= 0){
                fibril_rwlock_write_unlock(&socket_globals.lock);
                free(socket);
                return socket_id;
        }
        if(ERROR_OCCURRED((int) async_req_3_3(phone, NET_SOCKET, socket_id, 0, service, NULL, &fragment_size, &header_size))){
                fibril_rwlock_write_unlock(&socket_globals.lock);
                free(socket);
                return ERROR_CODE;
        }
        socket->data_fragment_size = (size_t) fragment_size;
        socket->header_size = (size_t) header_size;
        // finish the new socket initialization
        socket_initialize(socket, socket_id, phone, service);
        // store the new socket
        ERROR_CODE = sockets_add(socket_get_sockets(), socket_id, socket);
        fibril_rwlock_write_unlock(&socket_globals.lock);
        if(ERROR_CODE < 0){
                dyn_fifo_destroy(&socket->received);
                dyn_fifo_destroy(&socket->accepted);
                free(socket);
                async_msg_3(phone, NET_SOCKET_CLOSE, (ipcarg_t) socket_id, 0, service);
                return ERROR_CODE;
        }

        return socket_id;
}

/** Sends message to the socket parent module with specified data.
 *  @param[in] socket_id Socket identifier.
 *  @param[in] message The action message.
 *  @param[in] arg2 The second message parameter.
 *  @param[in] data The data to be sent.
 *  @param[in] datalength The data length.
 *  @returns EOK on success.
 *  @returns ENOTSOCK if the socket is not found.
 *  @returns EBADMEM if the data parameter is NULL.
 *  @returns NO_DATA if the datalength parameter is zero (0).
 *  @returns Other error codes as defined for the spcific message.
 */
static int socket_send_data(int socket_id, ipcarg_t message, ipcarg_t arg2, const void * data, size_t datalength){
        socket_ref socket;
        aid_t message_id;
        ipcarg_t result;

        if(! data){
                return EBADMEM;
        }
        if(! datalength){
                return NO_DATA;
        }

        fibril_rwlock_read_lock(&socket_globals.lock);
        // find the socket
        socket = sockets_find(socket_get_sockets(), socket_id);
        if(! socket){
                fibril_rwlock_read_unlock(&socket_globals.lock);
                return ENOTSOCK;
        }
        // request the message
        message_id = async_send_3(socket->phone, message, (ipcarg_t) socket->socket_id, arg2, socket->service, NULL);
        // send the address
        async_data_write_start(socket->phone, data, datalength);
        fibril_rwlock_read_unlock(&socket_globals.lock);
        async_wait_for(message_id, &result);
        return (int) result;
}

int bind(int socket_id, const struct sockaddr * my_addr, socklen_t addrlen){
        if(addrlen <= 0){
                return EINVAL;
        }
        // send the address
        return socket_send_data(socket_id, NET_SOCKET_BIND, 0, my_addr, (size_t) addrlen);
}

int listen(int socket_id, int backlog){
        socket_ref socket;
        int result;

        if(backlog <= 0){
                return EINVAL;
        }
        fibril_rwlock_read_lock(&socket_globals.lock);
        // find the socket
        socket = sockets_find(socket_get_sockets(), socket_id);
        if(! socket){
                fibril_rwlock_read_unlock(&socket_globals.lock);
                return ENOTSOCK;
        }
        // request listen backlog change
        result = (int) async_req_3_0(socket->phone, NET_SOCKET_LISTEN, (ipcarg_t) socket->socket_id, (ipcarg_t) backlog, socket->service);
        fibril_rwlock_read_unlock(&socket_globals.lock);
        return result;
}

int accept(int socket_id, struct sockaddr * cliaddr, socklen_t * addrlen){
        socket_ref socket;
        socket_ref new_socket;
        aid_t message_id;
        ipcarg_t ipc_result;
        int result;
        ipc_call_t answer;

        if((! cliaddr) || (! addrlen)){
                return EBADMEM;
        }

        fibril_rwlock_write_lock(&socket_globals.lock);
        // find the socket
        socket = sockets_find(socket_get_sockets(), socket_id);
        if(! socket){
                fibril_rwlock_write_unlock(&socket_globals.lock);
                return ENOTSOCK;
        }
        fibril_mutex_lock(&socket->accept_lock);
        // wait for an accepted socket
        ++ socket->blocked;
        while(dyn_fifo_value(&socket->accepted) <= 0){
                fibril_rwlock_write_unlock(&socket_globals.lock);
                fibril_condvar_wait(&socket->accept_signal, &socket->accept_lock);
                // drop the accept lock to avoid deadlock
                fibril_mutex_unlock(&socket->accept_lock);
                fibril_rwlock_write_lock(&socket_globals.lock);
                fibril_mutex_lock(&socket->accept_lock);
        }
        -- socket->blocked;

        // create a new scoket
        new_socket = (socket_ref) malloc(sizeof(socket_t));
        if(! new_socket){
                fibril_mutex_unlock(&socket->accept_lock);
                fibril_rwlock_write_unlock(&socket_globals.lock);
                return ENOMEM;
        }
        bzero(new_socket, sizeof(*new_socket));
        socket_id = socket_generate_new_id();
        if(socket_id <= 0){
                fibril_mutex_unlock(&socket->accept_lock);
                fibril_rwlock_write_unlock(&socket_globals.lock);
                free(new_socket);
                return socket_id;
        }
        socket_initialize(new_socket, socket_id, socket->phone, socket->service);
        result = sockets_add(socket_get_sockets(), new_socket->socket_id, new_socket);
        if(result < 0){
                fibril_mutex_unlock(&socket->accept_lock);
                fibril_rwlock_write_unlock(&socket_globals.lock);
                free(new_socket);
                return result;
        }

        // request accept
        message_id = async_send_5(socket->phone, NET_SOCKET_ACCEPT, (ipcarg_t) socket->socket_id, 0, socket->service, 0, new_socket->socket_id, &answer);
        // read address
        ipc_data_read_start(socket->phone, cliaddr, * addrlen);
        fibril_rwlock_write_unlock(&socket_globals.lock);
        async_wait_for(message_id, &ipc_result);
        result = (int) ipc_result;
        if(result > 0){
                if(result != socket_id){
                        result = EINVAL;
                }
                // dequeue the accepted socket if successful
                dyn_fifo_pop(&socket->accepted);
                // set address length
                *addrlen = SOCKET_GET_ADDRESS_LENGTH(answer);
                new_socket->data_fragment_size = SOCKET_GET_DATA_FRAGMENT_SIZE(answer);
        }else if(result == ENOTSOCK){
                // empty the queue if no accepted sockets
                while(dyn_fifo_pop(&socket->accepted) > 0);
        }
        fibril_mutex_unlock(&socket->accept_lock);
        return result;
}

int connect(int socket_id, const struct sockaddr * serv_addr, socklen_t addrlen){
        if(! serv_addr){
                return EDESTADDRREQ;
        }
        if(! addrlen){
                return EDESTADDRREQ;
        }
        // send the address
        return socket_send_data(socket_id, NET_SOCKET_CONNECT, 0, serv_addr, addrlen);
}

/** Clears and destroys the socket.
 *  @param[in] socket The socket to be destroyed.
 */
static void socket_destroy(socket_ref socket){
        int accepted_id;

        // destroy all accepted sockets
        while((accepted_id = dyn_fifo_pop(&socket->accepted)) >= 0){
                socket_destroy(sockets_find(socket_get_sockets(), accepted_id));
        }
        dyn_fifo_destroy(&socket->received);
        dyn_fifo_destroy(&socket->accepted);
        sockets_exclude(socket_get_sockets(), socket->socket_id);
}

int closesocket(int socket_id){
        ERROR_DECLARE;

        socket_ref socket;

        fibril_rwlock_write_lock(&socket_globals.lock);
        socket = sockets_find(socket_get_sockets(), socket_id);
        if(! socket){
                fibril_rwlock_write_unlock(&socket_globals.lock);
                return ENOTSOCK;
        }
        if(socket->blocked){
                fibril_rwlock_write_unlock(&socket_globals.lock);
                return EINPROGRESS;
        }
        // request close
        ERROR_PROPAGATE((int) async_req_3_0(socket->phone, NET_SOCKET_CLOSE, (ipcarg_t) socket->socket_id, 0, socket->service));
        // free the socket structure
        socket_destroy(socket);
        fibril_rwlock_write_unlock(&socket_globals.lock);
        return EOK;
}

/** Sends data via the socket to the remote address.
 *  Binds the socket to a free port if not already connected/bound.
 *  @param[in] message The action message.
 *  @param[in] socket_id Socket identifier.
 *  @param[in] data The data to be sent.
 *  @param[in] datalength The data length.
 *  @param[in] flags Various send flags.
 *  @param[in] toaddr The destination address. May be NULL for connected sockets.
 *  @param[in] addrlen The address length. Used only if toaddr is not NULL.
 *  @returns EOK on success.
 *  @returns ENOTSOCK if the socket is not found.
 *  @returns EBADMEM if the data or toaddr parameter is NULL.
 *  @returns NO_DATA if the datalength or the addrlen parameter is zero (0).
 *  @returns Other error codes as defined for the NET_SOCKET_SENDTO message.
 */
static int sendto_core(ipcarg_t message, int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen){
        socket_ref socket;
        aid_t message_id;
        ipcarg_t result;
        size_t fragments;
        ipc_call_t answer;

        if(! data){
                return EBADMEM;
        }
        if(! datalength){
                return NO_DATA;
        }
        fibril_rwlock_read_lock(&socket_globals.lock);
        // find socket
        socket = sockets_find(socket_get_sockets(), socket_id);
        if(! socket){
                fibril_rwlock_read_unlock(&socket_globals.lock);
                return ENOTSOCK;
        }
        fibril_rwlock_read_lock(&socket->sending_lock);
        // compute data fragment count
        if(socket->data_fragment_size > 0){
                fragments = (datalength + socket->header_size) / socket->data_fragment_size;
                if((datalength + socket->header_size) % socket->data_fragment_size) ++ fragments;
        }else{
                fragments = 1;
        }
        // request send
        message_id = async_send_5(socket->phone, message, (ipcarg_t) socket->socket_id, (fragments == 1 ? datalength : socket->data_fragment_size), socket->service, (ipcarg_t) flags, fragments, &answer);
        // send the address if given
        if((! toaddr) || (async_data_write_start(socket->phone, toaddr, addrlen) == EOK)){
                if(fragments == 1){
                        // send all if only one fragment
                        async_data_write_start(socket->phone, data, datalength);
                }else{
                        // send the first fragment
                        async_data_write_start(socket->phone, data, socket->data_fragment_size - socket->header_size);
                        data = ((const uint8_t *) data) + socket->data_fragment_size - socket->header_size;
                        // send the middle fragments
                        while((-- fragments) > 1){
                                async_data_write_start(socket->phone, data, socket->data_fragment_size);
                                data = ((const uint8_t *) data) + socket->data_fragment_size;
                        }
                        // send the last fragment
                        async_data_write_start(socket->phone, data, (datalength + socket->header_size) % socket->data_fragment_size);
                }
        }
        async_wait_for(message_id, &result);
        if((SOCKET_GET_DATA_FRAGMENT_SIZE(answer) > 0)
                && (SOCKET_GET_DATA_FRAGMENT_SIZE(answer) != socket->data_fragment_size)){
                // set the data fragment size
                socket->data_fragment_size = SOCKET_GET_DATA_FRAGMENT_SIZE(answer);
        }
        fibril_rwlock_read_unlock(&socket->sending_lock);
        fibril_rwlock_read_unlock(&socket_globals.lock);
        return (int) result;
}

int send(int socket_id, void * data, size_t datalength, int flags){
        // without the address
        return sendto_core(NET_SOCKET_SEND, socket_id, data, datalength, flags, NULL, 0);
}

int sendto(int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen){
        if(! toaddr){
                return EDESTADDRREQ;
        }
        if(! addrlen){
                return EDESTADDRREQ;
        }
        // with the address
        return sendto_core(NET_SOCKET_SENDTO, socket_id, data, datalength, flags, toaddr, addrlen);
}

/** Receives data via the socket.
 *  @param[in] message The action message.
 *  @param[in] socket_id Socket identifier.
 *  @param[out] data The data buffer to be filled.
 *  @param[in] datalength The data length.
 *  @param[in] flags Various receive flags.
 *  @param[out] fromaddr The source address. May be NULL for connected sockets.
 *  @param[in,out] addrlen The address length. The maximum address length is read. The actual address length is set. Used only if fromaddr is not NULL.
 *  @returns EOK on success.
 *  @returns ENOTSOCK if the socket is not found.
 *  @returns EBADMEM if the data parameter is NULL.
 *  @returns NO_DATA if the datalength or addrlen parameter is zero (0).
 *  @returns Other error codes as defined for the spcific message.
 */
static int recvfrom_core(ipcarg_t message, int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen){
        socket_ref socket;
        aid_t message_id;
        ipcarg_t ipc_result;
        int result;
        size_t fragments;
        size_t * lengths;
        size_t index;
        ipc_call_t answer;

        if(! data){
                return EBADMEM;
        }
        if(! datalength){
                return NO_DATA;
        }
        if(fromaddr && (! addrlen)){
                return EINVAL;
        }
        fibril_rwlock_read_lock(&socket_globals.lock);
        // find the socket
        socket = sockets_find(socket_get_sockets(), socket_id);
        if(! socket){
                fibril_rwlock_read_unlock(&socket_globals.lock);
                return ENOTSOCK;
        }
        fibril_mutex_lock(&socket->receive_lock);
        // wait for a received packet
        ++ socket->blocked;
        while((result = dyn_fifo_value(&socket->received)) <= 0){
                fibril_rwlock_read_unlock(&socket_globals.lock);
                fibril_condvar_wait(&socket->receive_signal, &socket->receive_lock);
                // drop the receive lock to avoid deadlock
                fibril_mutex_unlock(&socket->receive_lock);
                fibril_rwlock_read_lock(&socket_globals.lock);
                fibril_mutex_lock(&socket->receive_lock);
        }
        -- socket->blocked;
        fragments = (size_t) result;
        // prepare lengths if more fragments
        if(fragments > 1){
                lengths = (size_t *) malloc(sizeof(size_t) * fragments + sizeof(size_t));
                if(! lengths){
                        fibril_mutex_unlock(&socket->receive_lock);
                        fibril_rwlock_read_unlock(&socket_globals.lock);
                        return ENOMEM;
                }
                // request packet data
                message_id = async_send_4(socket->phone, message, (ipcarg_t) socket->socket_id, 0, socket->service, (ipcarg_t) flags, &answer);
                // read the address if desired
                if((! fromaddr) || (async_data_read_start(socket->phone, fromaddr, * addrlen) == EOK)){
                // read the fragment lengths
                        if(async_data_read_start(socket->phone, lengths, sizeof(int) * (fragments + 1)) == EOK){
                                if(lengths[fragments] <= datalength){
                                        // read all fragments if long enough
                                        for(index = 0; index < fragments; ++ index){
                                                async_data_read_start(socket->phone, data, lengths[index]);
                                                data = ((uint8_t *) data) + lengths[index];
                                        }
                                }
                        }
                }
                free(lengths);
        }else{
                // request packet data
                message_id = async_send_4(socket->phone, message, (ipcarg_t) socket->socket_id, 0, socket->service, (ipcarg_t) flags, &answer);
                // read the address if desired
                if((! fromaddr) || (async_data_read_start(socket->phone, fromaddr, * addrlen) == EOK)){
                        // read all if only one fragment
                        async_data_read_start(socket->phone, data, datalength);
                }
        }
        async_wait_for(message_id, &ipc_result);
        result = (int) ipc_result;
        // if successful
        if(result == EOK){
                // dequeue the received packet
                dyn_fifo_pop(&socket->received);
                // return read data length
                result = SOCKET_GET_READ_DATA_LENGTH(answer);
                // set address length
                if(fromaddr && addrlen){
                        *addrlen = SOCKET_GET_ADDRESS_LENGTH(answer);
                }
        }
        fibril_mutex_unlock(&socket->receive_lock);
        fibril_rwlock_read_unlock(&socket_globals.lock);
        return result;
}

int recv(int socket_id, void * data, size_t datalength, int flags){
        // without the address
        return recvfrom_core(NET_SOCKET_RECV, socket_id, data, datalength, flags, NULL, NULL);
}

int recvfrom(int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen){
        if(! fromaddr){
                return EBADMEM;
        }
        if(! addrlen){
                return NO_DATA;
        }
        // with the address
        return recvfrom_core(NET_SOCKET_RECVFROM, socket_id, data, datalength, flags, fromaddr, addrlen);
}

int getsockopt(int socket_id, int level, int optname, void * value, size_t * optlen){
        socket_ref socket;
        aid_t message_id;
        ipcarg_t result;

        if(!(value && optlen)){
                return EBADMEM;
        }
        if(!(*optlen)){
                return NO_DATA;
        }
        fibril_rwlock_read_lock(&socket_globals.lock);
        // find the socket
        socket = sockets_find(socket_get_sockets(), socket_id);
        if(! socket){
                fibril_rwlock_read_unlock(&socket_globals.lock);
                return ENOTSOCK;
        }
        // request option value
        message_id = async_send_3(socket->phone, NET_SOCKET_GETSOCKOPT, (ipcarg_t) socket->socket_id, (ipcarg_t) optname, socket->service, NULL);
        // read the length
        if(async_data_read_start(socket->phone, optlen, sizeof(*optlen)) == EOK){
                // read the value
                async_data_read_start(socket->phone, value, * optlen);
        }
        fibril_rwlock_read_unlock(&socket_globals.lock);
        async_wait_for(message_id, &result);
        return (int) result;
}

int setsockopt(int socket_id, int level, int optname, const void * value, size_t optlen){
        // send the value
        return socket_send_data(socket_id, NET_SOCKET_SETSOCKOPT, (ipcarg_t) optname, value, optlen);

}

/** @}
 */