WebSVN – HelenOS – Diff – /branches/network/uspace/srv/net/socket/socket_client.c


/*
 * 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_sync.h>
 
#include <ipc/services.h>
 
#include "../err.h"
#include "../modules.h"
 
#include "../include/in.h"
#include "../include/socket.h"
#include "../include/socket_errno.h"
 
#include "../structures/dynamic_fifo.h"
#include "../structures/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        64
 
/** Initial waiting sockets queue size.
 */
#define SOCKET_INITIAL_ACCEPTED_SIZE    1
 
/** Maximum waiting sockets queue size.
 */
#define SOCKET_MAX_ACCEPTED_SIZE        64
 
/** 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.
 */
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 and receiving optimalization.
     */
    size_t              data_fragment_size;
    /** Received packets queue.
     */
    dyn_fifo_t          received;
    /** Received packets safety lock.
     */
    fibril_mutex_t      receive_lock;
    /** Received packets signaling.
     */
    fibril_condvar_t    receive_signal;
    /** Waiting sockets queue.
     */
    dyn_fifo_t          accepted;
    /** Waiting sockets safety lock.
     */
    fibril_mutex_t      accept_lock;
    /** Waiting sockets signaling.
     */
    fibril_condvar_t    accept_signal;
};
 
/** 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{
    /** TCP module phone.
     */
    int tcp_phone;
    /** UDP module phone.
     */
    int udp_phone;
    /** Active sockets.
     */
    sockets_ref sockets;
} socket_globals = { -1, -1, NULL };
 
INT_MAP_IMPLEMENT( sockets, socket_t );
 
/** Returns the TCP module phone.
 *  Connects to the TCP module if necessary.
 *  @returns The TCP module phone.
 */
static int  socket_get_tcp_phone( void );
 
/** Returns the UDP module phone.
 *  Connects to the UDP module if necessary.
 *  @returns The UDP module phone.
 */
static int  socket_get_udp_phone( void );
 
/** Returns the active sockets.
 *  @returns The active sockets.
 */
static sockets_ref  socket_get_sockets( void );
 
/** Default thread for new connections.
 *  @param iid The initial message identifier. Input parameter.
 *  @param icall The initial message call structure. Input parameter.
 */
void    socket_connection( ipc_callid_t iid, ipc_call_t * icall );
 
/** Sends message to the socket parent module with specified data.
 *  @param socket_id Socket identifier. Input parameter.
 *  @param message The action message. Input parameter.
 *  @param arg2 The second message parameter. Input parameter.
 *  @param data The data to be sent. Input parameter.
 *  @param datalength The data length. Input parameter.
 *  @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.
 */
int socket_send_data( int socket_id, ipcarg_t message, ipcarg_t arg2, const void * data, size_t datalength );
 
/** Initializes a new socket specific data.
 *  @param socket The socket to be initialized. Input/output parameter.
 *  @param socket_id The new socket identifier. Input parameter.
 *  @param phone The parent module phone. Input parameter.
 *  @param service The parent module service. Input parameter.
 */
void    socket_initialize( socket_ref socket, int socket_id, int phone, services_t service );
 
/** Clears and destroys the socket.
 *  @param socket The socket to be destroyed. Input parameter.
 */
void    socket_destroy( socket_ref socket );
 
/** Receives data via the socket.
 *  @param message The action message. Input parameter.
 *  @param socket_id Socket identifier. Input parameter.
 *  @param data The data buffer to be filled. Output parameter.
 *  @param datalength The data length. Input parameter.
 *  @param flags Various receive flags. Input parameter.
 *  @param fromaddr The source address. May be NULL for connected sockets. Output parameter.
 *  @param addrlen The address length. The maximum address length is read. The actual address length is set. Used only if fromaddr is not NULL. Input/output parameter.
 *  @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.
 */
int recvfrom_core( ipcarg_t message, int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen );
 
/** Sends data via the socket to the remote address.
 *  Binds the socket to a free port if not already connected/bound.
 *  @param message The action message. Input parameter.
 *  @param socket_id Socket identifier. Input parameter.
 *  @param data The data to be sent. Input parameter.
 *  @param datalength The data length. Input parameter.
 *  @param flags Various send flags. Input parameter.
 *  @param toaddr The destination address. May be NULL for connected sockets. Input parameter.
 *  @param addrlen The address length. Used only if toaddr is not NULL. Input parameter.
 *  @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.
 */
int sendto_core( ipcarg_t message, int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen );
 
static int socket_get_tcp_phone( void ){
    if( socket_globals.tcp_phone < 0 ){
        socket_globals.tcp_phone = bind_service( SERVICE_TCP, 0, 0, SERVICE_TCP, socket_connection );
    }
    return socket_globals.tcp_phone;
}
 
static int socket_get_udp_phone( void ){
    if( socket_globals.udp_phone < 0 ){
        socket_globals.udp_phone = bind_service( SERVICE_UDP, 0, 0, SERVICE_UDP, socket_connection );
    }
    return socket_globals.udp_phone;
}
 
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;
        }
    }
    return socket_globals.sockets;
}
 
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 );
}
 
void socket_connection( ipc_callid_t iid, ipc_call_t * icall ){
    ERROR_DECLARE;
 
    ipc_callid_t    callid;
    ipc_call_t      call;
    socket_ref      socket;
    socket_ref      new_socket;
 
    while( true ){
 
        callid = async_get_call( & call );
        switch( IPC_GET_METHOD( call )){
            case NET_SOCKET_RECEIVED:
                // find the socket
                socket = sockets_find( socket_get_sockets(), SOCKET_GET_SOCKET_ID( call ));
                if( ! socket ){
                    ERROR_CODE = ENOTSOCK;
                    break;
                }
                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:
                // find the socket
                socket = sockets_find( socket_get_sockets(), SOCKET_GET_SOCKET_ID( call ));
                if( ! socket ){
                    ERROR_CODE = ENOTSOCK;
                    break;
                }
                // create a new scoket
                new_socket = ( socket_ref ) malloc( sizeof( socket_t ));
                if( ! new_socket ){
                    ERROR_CODE = ENOMEM;
                    break;
                }
                socket_initialize( new_socket, SOCKET_GET_SOCKET_ID( call ), socket->phone, socket->service );
                ERROR_CODE = sockets_add( socket_get_sockets(), new_socket->socket_id, new_socket );
                if( ERROR_CODE < 0 ){
                    free( new_socket );
                }else{
                    // push the new socket identifier
                    fibril_mutex_lock( & socket->accept_lock );
                    if( ERROR_OCCURRED( dyn_fifo_push( & socket->accepted, new_socket->socket_id, SOCKET_MAX_ACCEPTED_SIZE ))){
                        sockets_exclude( socket_get_sockets(), new_socket->socket_id );
                        free( new_socket );
                    }else{
                        // signal the accepted socket
                        fibril_condvar_signal( & socket->accept_signal );
                    }
                    fibril_mutex_unlock( & socket->accept_lock );
                    ERROR_CODE = EOK;
                }
                break;
            case NET_SOCKET_DATA_FRAGMENT_SIZE:
                // find the socket
                socket = sockets_find( socket_get_sockets(), SOCKET_GET_SOCKET_ID( call ));
                if( ! socket ){
                    ERROR_CODE = ENOTSOCK;
                    break;
                }
                // set the data fragment size
                socket->data_fragment_size = SOCKET_GET_DATA_FRAGMENT_SIZE( call );
                ERROR_CODE = EOK;
                break;
            default:
                ERROR_CODE = ENOTSUP;
        }
        ipc_answer_0( callid, ( ipcarg_t ) ERROR_CODE );
    }
}
 
int socket( int domain, int type, int protocol ){
    ERROR_DECLARE;
 
    socket_ref  socket;
    int         phone;
    int         socket_id;
    services_t  service;
 
    // 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;
    }
    // create a new socket structure
    socket = ( socket_ref ) malloc( sizeof( socket_t ));
    if( ! socket ) return ENOMEM;
    if( ERROR_OCCURRED( dyn_fifo_initialize( & socket->received, SOCKET_INITIAL_RECEIVED_SIZE ))){
        free( socket );
        return ERROR_CODE;
    }
    if( ERROR_OCCURRED( dyn_fifo_initialize( & socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE ))){
        dyn_fifo_destroy( & socket->received );
        free( socket );
        return ERROR_CODE;
    }
    // request a new socket
    if( ERROR_OCCURRED(( int ) async_req_3_3( phone, NET_SOCKET, 0, 0, service, ( ipcarg_t * ) & socket_id, ( ipcarg_t * ) & socket->header_size, ( ipcarg_t * ) & socket->data_fragment_size ))){
        dyn_fifo_destroy( & socket->received );
        dyn_fifo_destroy( & socket->accepted );
        free( socket );
        return ERROR_CODE;
    }
    // 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 );
    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;
}
 
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;
    // find the socket
    socket = sockets_find( socket_get_sockets(), socket_id );
    if( ! socket ) 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
    ipc_data_write_start( socket->phone, data, datalength );
    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;
 
    if( backlog <= 0 ) return EINVAL;
    // find the socket
    socket = sockets_find( socket_get_sockets(), socket_id );
    if( ! socket ) return ENOTSOCK;
    // request listen backlog change
    return ( int ) async_req_3_0( socket->phone, NET_SOCKET_LISTEN, ( ipcarg_t ) socket->socket_id, ( ipcarg_t ) backlog, socket->service );
}
 
int accept( int socket_id, struct sockaddr * cliaddr, socklen_t * addrlen ){
    socket_ref      socket;
    aid_t           message_id;
    int             result;
 
    if(( ! cliaddr ) || ( ! addrlen )) return EBADMEM;
    // find the socket
    socket = sockets_find( socket_get_sockets(), socket_id );
    if( ! socket ) return ENOTSOCK;
    fibril_mutex_lock( & socket->accept_lock );
    // wait for an accepted socket
    while( dyn_fifo_value( & socket->accepted ) <= 0 ){
        fibril_condvar_wait( & socket->accept_signal, & socket->accept_lock );
    }
    // request accept
    message_id = async_send_3( socket->phone, NET_SOCKET_ACCEPT, ( ipcarg_t ) socket->socket_id, ( ipcarg_t ) dyn_fifo_value( & socket->accepted ), socket->service, NULL );
    // read address
    ipc_data_read_start( socket->phone, cliaddr, * addrlen );
    async_wait_for( message_id, ( ipcarg_t * ) & result );
    if( result > 0 ){
        // dequeue the accepted apcket if successful
        dyn_fifo_pop( & socket->accepted );
    }
    fibril_mutex_unlock( & socket->accept_lock );
    return result;
}
 
int connect( int socket_id, const struct sockaddr * serv_addr, socklen_t addrlen ){
    // send the address
    return socket_send_data( socket_id, NET_SOCKET_CONNECT, 0, serv_addr, addrlen );
}
 
int closesocket( int socket_id ){
    ERROR_DECLARE;
 
    socket_ref      socket;
 
    socket = sockets_find( socket_get_sockets(), socket_id );
    if( ! socket ) return ENOTSOCK;
    // 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 );
    return EOK;
}
 
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 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 EBADMEM;
    if( ! addrlen ) return NO_DATA;
    // with the address
    return sendto_core( NET_SOCKET_SENDTO, socket_id, data, datalength, flags, toaddr, addrlen );
}
 
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;
 
    if( ! data ) return EBADMEM;
    if( ! datalength ) return NO_DATA;
    // find socket
    socket = sockets_find( socket_get_sockets(), socket_id );
    if( ! socket ) return ENOTSOCK;
    // compute data fragment count
    fragments = ( datalength + socket->header_size ) / socket->data_fragment_size;
    if(( datalength + socket->header_size ) % socket->data_fragment_size ) ++ fragments;
    // request send
    message_id = async_send_4( socket->phone, message, ( ipcarg_t ) socket->socket_id, fragments, socket->service, ( ipcarg_t ) flags, NULL );
    // send the address if given
    if(( ! toaddr ) || ( ipc_data_write_start( socket->phone, toaddr, addrlen ) == EOK )){
        if( fragments == 1 ){
            // send all if only one fragment
            ipc_data_write_start( socket->phone, data, datalength );
        }else{
            // send the first fragment
            ipc_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 ){
                ipc_data_write_start( socket->phone, data, socket->data_fragment_size );
                data = (( const uint8_t * ) data ) + socket->data_fragment_size;
            }
            // send the last fragment
            ipc_data_write_start( socket->phone, data, ( datalength + socket->header_size ) % socket->data_fragment_size );
        }
    }
    async_wait_for( message_id, & result );
    return ( int ) 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 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;
    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;
    // find the socket
    socket = sockets_find( socket_get_sockets(), socket_id );
    if( ! socket ) return ENOTSOCK;
    fibril_mutex_lock( & socket->receive_lock );
    // wait for a received packet
    while(( result = dyn_fifo_value( & socket->received )) <= 0 ){
        fibril_condvar_wait( & socket->receive_signal, & socket->receive_lock );
    }
    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 );
            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 ) || ( ipc_data_read_start( socket->phone, fromaddr, * addrlen ) == EOK )){
 
 
 
 
        // read the fragment lengths
            if( ipc_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 ){
                        ipc_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 ) || ( ipc_data_read_start( socket->phone, fromaddr, * addrlen ) == EOK )){
            // read all if only one fragment
            ipc_data_read_start( socket->phone, data, datalength );
        }
    }
    async_wait_for( message_id, ( ipcarg_t * ) & 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 );
    return result;
}
 
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;
    // find the socket
    socket = sockets_find( socket_get_sockets(), socket_id );
    if( ! socket ) 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( ipc_data_read_start( socket->phone, optlen, sizeof( * optlen )) == EOK ){
        // read the value
        ipc_data_read_start( socket->phone, value, * optlen );
    }
    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 );
 
}
 
/** @}
 */
 

Rev 4701	Rev 4708
1	/*	1	/*
2	* Copyright (c) 2009 Lukas Mejdrech	2	* Copyright (c) 2009 Lukas Mejdrech
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup socket	29	/** @addtogroup socket
30	* @{	30	* @{
31	*/	31	*/
32		32
33	/** @file	33	/** @file
34	* Socket application program interface (API) implementation.	34	* Socket application program interface (API) implementation.
35	* @see socket.h for more information.	35	* @see socket.h for more information.
36	* This is a part of the network application library.	36	* This is a part of the network application library.
37	*/	37	*/
38		38
39	#include <assert.h>	39	#include <assert.h>
40	#include <async.h>	40	#include <async.h>
41	#include <fibril_sync.h>	41	#include <fibril_sync.h>
42		42
43	#include <ipc/services.h>	43	#include <ipc/services.h>
44		44
45	#include "../err.h"	45	#include "../err.h"
46	#include "../modules.h"	46	#include "../modules.h"
47		47
48	#include "../include/in.h"	48	#include "../include/in.h"
49	#include "../include/socket.h"	49	#include "../include/socket.h"
50	#include "../include/socket_errno.h"	50	#include "../include/socket_errno.h"
51		51
52	#include "../structures/dynamic_fifo.h"	52	#include "../structures/dynamic_fifo.h"
53	#include "../structures/int_map.h"	53	#include "../structures/int_map.h"
54		54
55	#include "socket_messages.h"	55	#include "socket_messages.h"
56		56
57	/** Initial received packet queue size.	57	/** Initial received packet queue size.
58	*/	58	*/
59	#define SOCKET_INITIAL_RECEIVED_SIZE 4	59	#define SOCKET_INITIAL_RECEIVED_SIZE 4
60		60
61	/** Maximum received packet queue size.	61	/** Maximum received packet queue size.
62	*/	62	*/
63	#define SOCKET_MAX_RECEIVED_SIZE 64	63	#define SOCKET_MAX_RECEIVED_SIZE 64
64		64
65	/** Initial waiting sockets queue size.	65	/** Initial waiting sockets queue size.
66	*/	66	*/
67	#define SOCKET_INITIAL_ACCEPTED_SIZE 1	67	#define SOCKET_INITIAL_ACCEPTED_SIZE 1
68		68
69	/** Maximum waiting sockets queue size.	69	/** Maximum waiting sockets queue size.
70	*/	70	*/
71	#define SOCKET_MAX_ACCEPTED_SIZE 64	71	#define SOCKET_MAX_ACCEPTED_SIZE 64
72		72
73	/** Type definition of the socket specific data.	73	/** Type definition of the socket specific data.
74	* @see socket	74	* @see socket
75	*/	75	*/
76	typedef struct socket socket_t;	76	typedef struct socket socket_t;
77		77
78	/** Type definition of the socket specific data pointer.	78	/** Type definition of the socket specific data pointer.
79	* @see socket	79	* @see socket
80	*/	80	*/
81	typedef socket_t * socket_ref;	81	typedef socket_t * socket_ref;
82		82
83	/** Socket specific data.	83	/** Socket specific data.
84	*/	84	*/
85	struct socket{	85	struct socket{
86	/** Socket identifier.	86	/** Socket identifier.
87	*/	87	*/
88	int socket_id;	88	int socket_id;
89	/** Parent module phone.	89	/** Parent module phone.
90	*/	90	*/
91	int phone;	91	int phone;
92	/** Parent module service.	92	/** Parent module service.
93	*/	93	*/
94	services_t service;	94	services_t service;
95	/** Underlying protocol header size.	95	/** Underlying protocol header size.
96	* Sending and receiving optimalization.	96	* Sending and receiving optimalization.
97	*/	97	*/
98	int header_size;	98	size_t header_size;
99	/** Packet data fragment size.	99	/** Packet data fragment size.
100	* Sending and receiving optimalization.	100	* Sending and receiving optimalization.
101	*/	101	*/
102	int data_fragment_size;	102	size_t data_fragment_size;
103	/** Received packets queue.	103	/** Received packets queue.
104	*/	104	*/
105	dyn_fifo_t received;	105	dyn_fifo_t received;
106	/** Received packets safety lock.	106	/** Received packets safety lock.
107	*/	107	*/
108	fibril_mutex_t receive_lock;	108	fibril_mutex_t receive_lock;
109	/** Received packets signaling.	109	/** Received packets signaling.
110	*/	110	*/
111	fibril_condvar_t receive_signal;	111	fibril_condvar_t receive_signal;
112	/** Waiting sockets queue.	112	/** Waiting sockets queue.
113	*/	113	*/
114	dyn_fifo_t accepted;	114	dyn_fifo_t accepted;
115	/** Waiting sockets safety lock.	115	/** Waiting sockets safety lock.
116	*/	116	*/
117	fibril_mutex_t accept_lock;	117	fibril_mutex_t accept_lock;
118	/** Waiting sockets signaling.	118	/** Waiting sockets signaling.
119	*/	119	*/
120	fibril_condvar_t accept_signal;	120	fibril_condvar_t accept_signal;
121	};	121	};
122		122
123	/** Sockets map.	123	/** Sockets map.
124	* Maps socket identifiers to the socket specific data.	124	* Maps socket identifiers to the socket specific data.
125	* @see int_map.h	125	* @see int_map.h
126	*/	126	*/
127	INT_MAP_DECLARE( sockets, socket_t );	127	INT_MAP_DECLARE( sockets, socket_t );
128		128
129	/** Socket client library global data.	129	/** Socket client library global data.
130	*/	130	*/
131	static struct{	131	static struct{
132	/** TCP module phone.	132	/** TCP module phone.
133	*/	133	*/
134	int tcp_phone;	134	int tcp_phone;
135	/** UDP module phone.	135	/** UDP module phone.
136	*/	136	*/
137	int udp_phone;	137	int udp_phone;
138	/** Active sockets.	138	/** Active sockets.
139	*/	139	*/
140	sockets_ref sockets;	140	sockets_ref sockets;
141	} socket_globals = { -1, -1, NULL };	141	} socket_globals = { -1, -1, NULL };
142		142
143	INT_MAP_IMPLEMENT( sockets, socket_t );	143	INT_MAP_IMPLEMENT( sockets, socket_t );
144		144
145	/** Returns the TCP module phone.	145	/** Returns the TCP module phone.
146	* Connects to the TCP module if necessary.	146	* Connects to the TCP module if necessary.
147	* @returns The TCP module phone.	147	* @returns The TCP module phone.
148	*/	148	*/
149	static int socket_get_tcp_phone();	149	static int socket_get_tcp_phone( void );
150		150
151	/** Returns the UDP module phone.	151	/** Returns the UDP module phone.
152	* Connects to the UDP module if necessary.	152	* Connects to the UDP module if necessary.
153	* @returns The UDP module phone.	153	* @returns The UDP module phone.
154	*/	154	*/
155	static int socket_get_tcp_phone();	155	static int socket_get_udp_phone( void );
156		156
157	/** Returns the active sockets.	157	/** Returns the active sockets.
158	* @returns The active sockets.	158	* @returns The active sockets.
159	*/	159	*/
160	static sockets_ref socket_get_sockets();	160	static sockets_ref socket_get_sockets( void );
161		161
162	/** Default thread for new connections.	162	/** Default thread for new connections.
163	* @param iid The initial message identifier. Input parameter.	163	* @param iid The initial message identifier. Input parameter.
164	* @param icall The initial message call structure. Input parameter.	164	* @param icall The initial message call structure. Input parameter.
165	*/	165	*/
166	void socket_connection( ipc_callid_t iid, ipc_call_t * icall );	166	void socket_connection( ipc_callid_t iid, ipc_call_t * icall );
167		167
168	/** Sends message to the socket parent module with specified data.	168	/** Sends message to the socket parent module with specified data.
169	* @param socket_id Socket identifier. Input parameter.	169	* @param socket_id Socket identifier. Input parameter.
170	* @param message The action message. Input parameter.	170	* @param message The action message. Input parameter.
171	* @param arg2 The second message parameter. Input parameter.	171	* @param arg2 The second message parameter. Input parameter.
172	* @param data The data to be sent. Input parameter.	172	* @param data The data to be sent. Input parameter.
173	* @param datalength The data length. Input parameter.	173	* @param datalength The data length. Input parameter.
174	* @returns EOK on success.	174	* @returns EOK on success.
175	* @returns ENOTSOCK if the socket is not found.	175	* @returns ENOTSOCK if the socket is not found.
176	* @returns EBADMEM if the data parameter is NULL.	176	* @returns EBADMEM if the data parameter is NULL.
177	* @returns NO_DATA if the datalength parameter is zero (0).	177	* @returns NO_DATA if the datalength parameter is zero (0).
178	* @returns Other error codes as defined for the spcific message.	178	* @returns Other error codes as defined for the spcific message.
179	*/	179	*/
180	int socket_send_data( int socket_id, int message, ipcarg_t arg2, const void * data, size_t datalength );	180	int socket_send_data( int socket_id, ipcarg_t message, ipcarg_t arg2, const void * data, size_t datalength );
181		181
182	/** Initializes a new socket specific data.	182	/** Initializes a new socket specific data.
183	* @param socket The socket to be initialized. Input/output parameter.	183	* @param socket The socket to be initialized. Input/output parameter.
184	* @param socket_id The new socket identifier. Input parameter.	184	* @param socket_id The new socket identifier. Input parameter.
185	* @param phone The parent module phone. Input parameter.	185	* @param phone The parent module phone. Input parameter.
186	* @param service The parent module service. Input parameter.	186	* @param service The parent module service. Input parameter.
187	*/	187	*/
188	void socket_initialize( socket_ref socket, int socket_id, int phone, services_t service );	188	void socket_initialize( socket_ref socket, int socket_id, int phone, services_t service );
189		189
190	/** Clears and destroys the socket.	190	/** Clears and destroys the socket.
191	* @param socket The socket to be destroyed. Input parameter.	191	* @param socket The socket to be destroyed. Input parameter.
192	*/	192	*/
193	void socket_destroy( socket_ref socket );	193	void socket_destroy( socket_ref socket );
194		194
195	/** Receives data via the socket.	195	/** Receives data via the socket.
196	* @param message The action message. Input parameter.	196	* @param message The action message. Input parameter.
197	* @param socket_id Socket identifier. Input parameter.	197	* @param socket_id Socket identifier. Input parameter.
198	* @param data The data buffer to be filled. Output parameter.	198	* @param data The data buffer to be filled. Output parameter.
199	* @param datalength The data length. Input parameter.	199	* @param datalength The data length. Input parameter.
200	* @param flags Various receive flags. Input parameter.	200	* @param flags Various receive flags. Input parameter.
201	* @param fromaddr The source address. May be NULL for connected sockets. Output parameter.	201	* @param fromaddr The source address. May be NULL for connected sockets. Output parameter.
202	* @param addrlen The address length. The maximum address length is read. The actual address length is set. Used only if fromaddr is not NULL. Input/output parameter.	202	* @param addrlen The address length. The maximum address length is read. The actual address length is set. Used only if fromaddr is not NULL. Input/output parameter.
203	* @returns EOK on success.	203	* @returns EOK on success.
204	* @returns ENOTSOCK if the socket is not found.	204	* @returns ENOTSOCK if the socket is not found.
205	* @returns EBADMEM if the data parameter is NULL.	205	* @returns EBADMEM if the data parameter is NULL.
206	* @returns NO_DATA if the datalength or addrlen parameter is zero (0).	206	* @returns NO_DATA if the datalength or addrlen parameter is zero (0).
207	* @returns Other error codes as defined for the spcific message.	207	* @returns Other error codes as defined for the spcific message.
208	*/	208	*/
209	int recvfrom_core( int message, int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen );	209	int recvfrom_core( ipcarg_t message, int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen );
210		210
211	/** Sends data via the socket to the remote address.	211	/** Sends data via the socket to the remote address.
212	* Binds the socket to a free port if not already connected/bound.	212	* Binds the socket to a free port if not already connected/bound.
213	* @param message The action message. Input parameter.	213	* @param message The action message. Input parameter.
214	* @param socket_id Socket identifier. Input parameter.	214	* @param socket_id Socket identifier. Input parameter.
215	* @param data The data to be sent. Input parameter.	215	* @param data The data to be sent. Input parameter.
216	* @param datalength The data length. Input parameter.	216	* @param datalength The data length. Input parameter.
217	* @param flags Various send flags. Input parameter.	217	* @param flags Various send flags. Input parameter.
218	* @param toaddr The destination address. May be NULL for connected sockets. Input parameter.	218	* @param toaddr The destination address. May be NULL for connected sockets. Input parameter.
219	* @param addrlen The address length. Used only if toaddr is not NULL. Input parameter.	219	* @param addrlen The address length. Used only if toaddr is not NULL. Input parameter.
220	* @returns EOK on success.	220	* @returns EOK on success.
221	* @returns ENOTSOCK if the socket is not found.	221	* @returns ENOTSOCK if the socket is not found.
222	* @returns EBADMEM if the data or toaddr parameter is NULL.	222	* @returns EBADMEM if the data or toaddr parameter is NULL.
223	* @returns NO_DATA if the datalength or the addrlen parameter is zero (0).	223	* @returns NO_DATA if the datalength or the addrlen parameter is zero (0).
224	* @returns Other error codes as defined for the NET_SOCKET_SENDTO message.	224	* @returns Other error codes as defined for the NET_SOCKET_SENDTO message.
225	*/	225	*/
226	int sendto_core( int message, int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen );	226	int sendto_core( ipcarg_t message, int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t addrlen );
227		227
228	static int socket_get_tcp_phone(){	228	static int socket_get_tcp_phone( void ){
229	if( socket_globals.tcp_phone < 0 ){	229	if( socket_globals.tcp_phone < 0 ){
230	socket_globals.tcp_phone = bind_service( SERVICE_TCP, 0, 0, SERVICE_TCP, socket_connection );	230	socket_globals.tcp_phone = bind_service( SERVICE_TCP, 0, 0, SERVICE_TCP, socket_connection );
231	}	231	}
232	return socket_globals.tcp_phone;	232	return socket_globals.tcp_phone;
233	}	233	}
234		234
235	static int socket_get_udp_phone(){	235	static int socket_get_udp_phone( void ){
236	if( socket_globals.udp_phone < 0 ){	236	if( socket_globals.udp_phone < 0 ){
237	socket_globals.udp_phone = bind_service( SERVICE_UDP, 0, 0, SERVICE_UDP, socket_connection );	237	socket_globals.udp_phone = bind_service( SERVICE_UDP, 0, 0, SERVICE_UDP, socket_connection );
238	}	238	}
239	return socket_globals.udp_phone;	239	return socket_globals.udp_phone;
240	}	240	}
241		241
242	static sockets_ref socket_get_sockets(){	242	static sockets_ref socket_get_sockets( void ){
243	if( ! socket_globals.sockets ){	243	if( ! socket_globals.sockets ){
244	socket_globals.sockets = ( sockets_ref ) malloc( sizeof( sockets_t ));	244	socket_globals.sockets = ( sockets_ref ) malloc( sizeof( sockets_t ));
245	if( ! socket_globals.sockets ) return NULL;	245	if( ! socket_globals.sockets ) return NULL;
246	if( sockets_initialize( socket_globals.sockets ) != EOK ){	246	if( sockets_initialize( socket_globals.sockets ) != EOK ){
247	free( socket_globals.sockets );	247	free( socket_globals.sockets );
248	socket_globals.sockets = NULL;	248	socket_globals.sockets = NULL;
249	}	249	}
250	}	250	}
251	return socket_globals.sockets;	251	return socket_globals.sockets;
252	}	252	}
253		253
254	void socket_initialize( socket_ref socket, int socket_id, int phone, services_t service ){	254	void socket_initialize( socket_ref socket, int socket_id, int phone, services_t service ){
255	socket->socket_id = socket_id;	255	socket->socket_id = socket_id;
256	socket->phone = phone;	256	socket->phone = phone;
257	socket->service = service;	257	socket->service = service;
258	dyn_fifo_initialize( & socket->received, SOCKET_INITIAL_RECEIVED_SIZE );	258	dyn_fifo_initialize( & socket->received, SOCKET_INITIAL_RECEIVED_SIZE );
259	dyn_fifo_initialize( & socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE );	259	dyn_fifo_initialize( & socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE );
260	fibril_mutex_initialize( & socket->receive_lock );	260	fibril_mutex_initialize( & socket->receive_lock );
261	fibril_condvar_initialize( & socket->receive_signal );	261	fibril_condvar_initialize( & socket->receive_signal );
262	fibril_mutex_initialize( & socket->accept_lock );	262	fibril_mutex_initialize( & socket->accept_lock );
263	fibril_condvar_initialize( & socket->accept_signal );	263	fibril_condvar_initialize( & socket->accept_signal );
264	}	264	}
265		265
266	void socket_connection( ipc_callid_t iid, ipc_call_t * icall ){	266	void socket_connection( ipc_callid_t iid, ipc_call_t * icall ){
267	ERROR_DECLARE;	267	ERROR_DECLARE;
268		268
269	ipc_callid_t callid;	269	ipc_callid_t callid;
270	ipc_call_t call;	270	ipc_call_t call;
271	socket_ref socket;	271	socket_ref socket;
272	socket_ref new_socket;	272	socket_ref new_socket;
273		273
274	while( true ){	274	while( true ){
275		275
276	callid = async_get_call( & call );	276	callid = async_get_call( & call );
277	switch( IPC_GET_METHOD( call )){	277	switch( IPC_GET_METHOD( call )){
278	case NET_SOCKET_RECEIVED:	278	case NET_SOCKET_RECEIVED:
279	// find the socket	279	// find the socket
280	socket = sockets_find( socket_get_sockets(), SOCKET_GET_SOCKET_ID( call ));	280	socket = sockets_find( socket_get_sockets(), SOCKET_GET_SOCKET_ID( call ));
281	if( ! socket ){	281	if( ! socket ){
282	ERROR_CODE = ENOTSOCK;	282	ERROR_CODE = ENOTSOCK;
283	break;	283	break;
284	}	284	}
285	fibril_mutex_lock( & socket->receive_lock );	285	fibril_mutex_lock( & socket->receive_lock );
286	// push the number of received packet fragments	286	// push the number of received packet fragments
287	if( ! ERROR_OCCURRED( dyn_fifo_push( & socket->received, SOCKET_GET_DATA_FRAGMENTS( call ), SOCKET_MAX_RECEIVED_SIZE ))){	287	if( ! ERROR_OCCURRED( dyn_fifo_push( & socket->received, SOCKET_GET_DATA_FRAGMENTS( call ), SOCKET_MAX_RECEIVED_SIZE ))){
288	// signal the received packet	288	// signal the received packet
289	fibril_condvar_signal( & socket->receive_signal );	289	fibril_condvar_signal( & socket->receive_signal );
290	}	290	}
291	fibril_mutex_unlock( & socket->receive_lock );	291	fibril_mutex_unlock( & socket->receive_lock );
292	break;	292	break;
293	case NET_SOCKET_ACCEPTED:	293	case NET_SOCKET_ACCEPTED:
294	// find the socket	294	// find the socket
295	socket = sockets_find( socket_get_sockets(), SOCKET_GET_SOCKET_ID( call ));	295	socket = sockets_find( socket_get_sockets(), SOCKET_GET_SOCKET_ID( call ));
296	if( ! socket ){	296	if( ! socket ){
297	ERROR_CODE = ENOTSOCK;	297	ERROR_CODE = ENOTSOCK;
298	break;	298	break;
299	}	299	}
300	// create a new scoket	300	// create a new scoket
301	new_socket = ( socket_ref ) malloc( sizeof( socket_t ));	301	new_socket = ( socket_ref ) malloc( sizeof( socket_t ));
302	if( ! new_socket ){	302	if( ! new_socket ){
303	ERROR_CODE = ENOMEM;	303	ERROR_CODE = ENOMEM;
304	break;	304	break;
305	}	305	}
306	socket_initialize( new_socket, SOCKET_GET_SOCKET_ID( call ), socket->phone, socket->service );	306	socket_initialize( new_socket, SOCKET_GET_SOCKET_ID( call ), socket->phone, socket->service );
307	ERROR_CODE = sockets_add( socket_get_sockets(), new_socket->socket_id, new_socket );	307	ERROR_CODE = sockets_add( socket_get_sockets(), new_socket->socket_id, new_socket );
308	if( ERROR_CODE < 0 ){	308	if( ERROR_CODE < 0 ){
309	free( new_socket );	309	free( new_socket );
310	}else{	310	}else{
311	// push the new socket identifier	311	// push the new socket identifier
312	fibril_mutex_lock( & socket->accept_lock );	312	fibril_mutex_lock( & socket->accept_lock );
313	if( ERROR_OCCURRED( dyn_fifo_push( & socket->accepted, new_socket->socket_id, SOCKET_MAX_ACCEPTED_SIZE ))){	313	if( ERROR_OCCURRED( dyn_fifo_push( & socket->accepted, new_socket->socket_id, SOCKET_MAX_ACCEPTED_SIZE ))){
314	sockets_exclude( socket_get_sockets(), new_socket->socket_id );	314	sockets_exclude( socket_get_sockets(), new_socket->socket_id );
315	free( new_socket );	315	free( new_socket );
316	}else{	316	}else{
317	// signal the accepted socket	317	// signal the accepted socket
318	fibril_condvar_signal( & socket->accept_signal );	318	fibril_condvar_signal( & socket->accept_signal );
319	}	319	}
320	fibril_mutex_unlock( & socket->accept_lock );	320	fibril_mutex_unlock( & socket->accept_lock );
321	ERROR_CODE = EOK;	321	ERROR_CODE = EOK;
322	}	322	}
323	break;	323	break;
324	case NET_SOCKET_DATA_FRAGMENT_SIZE:	324	case NET_SOCKET_DATA_FRAGMENT_SIZE:
325	// find the socket	325	// find the socket
326	socket = sockets_find( socket_get_sockets(), SOCKET_GET_SOCKET_ID( call ));	326	socket = sockets_find( socket_get_sockets(), SOCKET_GET_SOCKET_ID( call ));
327	if( ! socket ){	327	if( ! socket ){
328	ERROR_CODE = ENOTSOCK;	328	ERROR_CODE = ENOTSOCK;
329	break;	329	break;
330	}	330	}
331	// set the data fragment size	331	// set the data fragment size
332	socket->data_fragment_size = SOCKET_GET_DATA_FRAGMENT_SIZE( call );	332	socket->data_fragment_size = SOCKET_GET_DATA_FRAGMENT_SIZE( call );
333	ERROR_CODE = EOK;	333	ERROR_CODE = EOK;
334	break;	334	break;
335	default:	335	default:
336	ERROR_CODE = ENOTSUP;	336	ERROR_CODE = ENOTSUP;
337	}	337	}
338	ipc_answer_0( callid, ERROR_CODE );	338	ipc_answer_0( callid, ( ipcarg_t ) ERROR_CODE );
339	}	339	}
340	}	340	}
341		341
342	int socket( int domain, int type, int protocol ){	342	int socket( int domain, int type, int protocol ){
343	ERROR_DECLARE;	343	ERROR_DECLARE;
344		344
345	socket_ref socket;	345	socket_ref socket;
346	int phone;	346	int phone;
347	int socket_id;	347	int socket_id;
348	services_t service;	348	services_t service;
349		349
350	// find the appropriate service	350	// find the appropriate service
351	switch( domain ){	351	switch( domain ){
352	case PF_INET:	352	case PF_INET:
353	switch( type ){	353	switch( type ){
354	case SOCK_STREAM:	354	case SOCK_STREAM:
355	if( ! protocol ) protocol = IPPROTO_TCP;	355	if( ! protocol ) protocol = IPPROTO_TCP;
356	switch( protocol ){	356	switch( protocol ){
357	case IPPROTO_TCP:	357	case IPPROTO_TCP:
358	phone = socket_get_tcp_phone();	358	phone = socket_get_tcp_phone();
359	service = SERVICE_TCP;	359	service = SERVICE_TCP;
360	break;	360	break;
361	default:	361	default:
362	return EPROTONOSUPPORT;	362	return EPROTONOSUPPORT;
363	}	363	}
364	break;	364	break;
365	case SOCK_DGRAM:	365	case SOCK_DGRAM:
366	if( ! protocol ) protocol = IPPROTO_UDP;	366	if( ! protocol ) protocol = IPPROTO_UDP;
367	switch( protocol ){	367	switch( protocol ){
368	case IPPROTO_UDP:	368	case IPPROTO_UDP:
369	phone = socket_get_udp_phone();	369	phone = socket_get_udp_phone();
370	service = SERVICE_UDP;	370	service = SERVICE_UDP;
371	break;	371	break;
372	default:	372	default:
373	return EPROTONOSUPPORT;	373	return EPROTONOSUPPORT;
374	}	374	}
375	break;	375	break;
376	case SOCK_RAW:	376	case SOCK_RAW:
377	default:	377	default:
378	return ESOCKTNOSUPPORT;	378	return ESOCKTNOSUPPORT;
379	}	379	}
380	break;	380	break;
381	// TODO IPv6	381	// TODO IPv6
382	default:	382	default:
383	return EPFNOSUPPORT;	383	return EPFNOSUPPORT;
384	}	384	}
385	// create a new socket structure	385	// create a new socket structure
386	socket = ( socket_ref ) malloc( sizeof( socket_t ));	386	socket = ( socket_ref ) malloc( sizeof( socket_t ));
387	if( ! socket ) return ENOMEM;	387	if( ! socket ) return ENOMEM;
388	if( ERROR_OCCURRED( dyn_fifo_initialize( & socket->received, SOCKET_INITIAL_RECEIVED_SIZE ))){	388	if( ERROR_OCCURRED( dyn_fifo_initialize( & socket->received, SOCKET_INITIAL_RECEIVED_SIZE ))){
389	free( socket );	389	free( socket );
390	return ERROR_CODE;	390	return ERROR_CODE;
391	}	391	}
392	if( ERROR_OCCURRED( dyn_fifo_initialize( & socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE ))){	392	if( ERROR_OCCURRED( dyn_fifo_initialize( & socket->accepted, SOCKET_INITIAL_ACCEPTED_SIZE ))){
393	dyn_fifo_destroy( & socket->received );	393	dyn_fifo_destroy( & socket->received );
394	free( socket );	394	free( socket );
395	return ERROR_CODE;	395	return ERROR_CODE;
396	}	396	}
397	// request a new socket	397	// request a new socket
398	if( ERROR_OCCURRED( async_req_3_3( phone, NET_SOCKET, 0, 0, service, ( ipcarg_t * ) & socket_id, ( ipcarg_t * ) & socket->header_size, ( ipcarg_t * ) & socket->data_fragment_size ))){	398	if( ERROR_OCCURRED(( int ) async_req_3_3( phone, NET_SOCKET, 0, 0, service, ( ipcarg_t * ) & socket_id, ( ipcarg_t * ) & socket->header_size, ( ipcarg_t * ) & socket->data_fragment_size ))){
399	dyn_fifo_destroy( & socket->received );	399	dyn_fifo_destroy( & socket->received );
400	dyn_fifo_destroy( & socket->accepted );	400	dyn_fifo_destroy( & socket->accepted );
401	free( socket );	401	free( socket );
402	return ERROR_CODE;	402	return ERROR_CODE;
403	}	403	}
404	// finish the new socket initialization	404	// finish the new socket initialization
405	socket_initialize( socket, socket_id, phone, service );	405	socket_initialize( socket, socket_id, phone, service );
406	// store the new socket	406	// store the new socket
407	ERROR_CODE = sockets_add( socket_get_sockets(), socket_id, socket );	407	ERROR_CODE = sockets_add( socket_get_sockets(), socket_id, socket );
408	if( ERROR_CODE < 0 ){	408	if( ERROR_CODE < 0 ){
409	dyn_fifo_destroy( & socket->received );	409	dyn_fifo_destroy( & socket->received );
410	dyn_fifo_destroy( & socket->accepted );	410	dyn_fifo_destroy( & socket->accepted );
411	free( socket );	411	free( socket );
412	async_msg_3( phone, NET_SOCKET_CLOSE, socket_id, 0, service );	412	async_msg_3( phone, NET_SOCKET_CLOSE, ( ipcarg_t ) socket_id, 0, service );
413	return ERROR_CODE;	413	return ERROR_CODE;
414	}	414	}
415		415
416	return socket_id;	416	return socket_id;
417	}	417	}
418		418
419	int socket_send_data( int socket_id, int message, ipcarg_t arg2, const void * data, size_t datalength ){	419	int socket_send_data( int socket_id, ipcarg_t message, ipcarg_t arg2, const void * data, size_t datalength ){
420	socket_ref socket;	420	socket_ref socket;
421	aid_t message_id;	421	aid_t message_id;
422	ipcarg_t result;	422	ipcarg_t result;
423		423
424	if( ! data ) return EBADMEM;	424	if( ! data ) return EBADMEM;
425	if( ! datalength ) return NO_DATA;	425	if( ! datalength ) return NO_DATA;
426	// find the socket	426	// find the socket
427	socket = sockets_find( socket_get_sockets(), socket_id );	427	socket = sockets_find( socket_get_sockets(), socket_id );
428	if( ! socket ) return ENOTSOCK;	428	if( ! socket ) return ENOTSOCK;
429	// request the message	429	// request the message
430	message_id = async_send_3( socket->phone, message, socket->socket_id, arg2, socket->service, NULL );	430	message_id = async_send_3( socket->phone, message, ( ipcarg_t ) socket->socket_id, arg2, socket->service, NULL );
431	// send the address	431	// send the address
432	ipc_data_write_start( socket->phone, data, datalength );	432	ipc_data_write_start( socket->phone, data, datalength );
433	async_wait_for( message_id, & result );	433	async_wait_for( message_id, & result );
434	return ( int ) result;	434	return ( int ) result;
435	}	435	}
436		436
437	int bind( int socket_id, const struct sockaddr * my_addr, socklen_t addrlen ){	437	int bind( int socket_id, const struct sockaddr * my_addr, socklen_t addrlen ){
-		438	if( addrlen <= 0 ) return EINVAL;
438	// send the address	439	// send the address
439	return socket_send_data( socket_id, NET_SOCKET_BIND, 0, my_addr, addrlen );	440	return socket_send_data( socket_id, NET_SOCKET_BIND, 0, my_addr, ( size_t ) addrlen );
440	}	441	}
441		442
442	int listen( int socket_id, int backlog ){	443	int listen( int socket_id, int backlog ){
443	socket_ref socket;	444	socket_ref socket;
444		445
445	if( backlog <= 0 ) return EINVAL;	446	if( backlog <= 0 ) return EINVAL;
446	// find the socket	447	// find the socket
447	socket = sockets_find( socket_get_sockets(), socket_id );	448	socket = sockets_find( socket_get_sockets(), socket_id );
448	if( ! socket ) return ENOTSOCK;	449	if( ! socket ) return ENOTSOCK;
449	// request listen backlog change	450	// request listen backlog change
450	return async_req_3_0( socket->phone, NET_SOCKET_LISTEN, socket->socket_id, backlog, socket->service );	451	return ( int ) async_req_3_0( socket->phone, NET_SOCKET_LISTEN, ( ipcarg_t ) socket->socket_id, ( ipcarg_t ) backlog, socket->service );
451	}	452	}
452		453
453	int accept( int socket_id, struct sockaddr * cliaddr, socklen_t * addrlen ){	454	int accept( int socket_id, struct sockaddr * cliaddr, socklen_t * addrlen ){
454	socket_ref socket;	455	socket_ref socket;
455	aid_t message_id;	456	aid_t message_id;
456	int result;	457	int result;
457		458
458	if(( ! cliaddr ) \|\| ( ! addrlen )) return EBADMEM;	459	if(( ! cliaddr ) \|\| ( ! addrlen )) return EBADMEM;
459	// find the socket	460	// find the socket
460	socket = sockets_find( socket_get_sockets(), socket_id );	461	socket = sockets_find( socket_get_sockets(), socket_id );
461	if( ! socket ) return ENOTSOCK;	462	if( ! socket ) return ENOTSOCK;
462	fibril_mutex_lock( & socket->accept_lock );	463	fibril_mutex_lock( & socket->accept_lock );
463	// wait for an accepted socket	464	// wait for an accepted socket
464	while( dyn_fifo_value( & socket->accepted ) <= 0 ){	465	while( dyn_fifo_value( & socket->accepted ) <= 0 ){
465	fibril_condvar_wait( & socket->accept_signal, & socket->accept_lock );	466	fibril_condvar_wait( & socket->accept_signal, & socket->accept_lock );
466	}	467	}
467	// request accept	468	// request accept
468	message_id = async_send_3( socket->phone, NET_SOCKET_ACCEPT, socket->socket_id, dyn_fifo_value( & socket->accepted ), socket->service, NULL );	469	message_id = async_send_3( socket->phone, NET_SOCKET_ACCEPT, ( ipcarg_t ) socket->socket_id, ( ipcarg_t ) dyn_fifo_value( & socket->accepted ), socket->service, NULL );
469	// read address	470	// read address
470	ipc_data_read_start( socket->phone, cliaddr, * addrlen );	471	ipc_data_read_start( socket->phone, cliaddr, * addrlen );
471	async_wait_for( message_id, ( ipcarg_t * ) & result );	472	async_wait_for( message_id, ( ipcarg_t * ) & result );
472	if( result > 0 ){	473	if( result > 0 ){
473	// dequeue the accepted apcket if successful	474	// dequeue the accepted apcket if successful
474	dyn_fifo_pop( & socket->accepted );	475	dyn_fifo_pop( & socket->accepted );
475	}	476	}
476	fibril_mutex_unlock( & socket->accept_lock );	477	fibril_mutex_unlock( & socket->accept_lock );
477	return result;	478	return result;
478	}	479	}
479		480
480	int connect( int socket_id, const struct sockaddr * serv_addr, socklen_t addrlen ){	481	int connect( int socket_id, const struct sockaddr * serv_addr, socklen_t addrlen ){
481	// send the address	482	// send the address
482	return socket_send_data( socket_id, NET_SOCKET_CONNECT, 0, serv_addr, addrlen );	483	return socket_send_data( socket_id, NET_SOCKET_CONNECT, 0, serv_addr, addrlen );
483	}	484	}
484		485
485	int closesocket( int socket_id ){	486	int closesocket( int socket_id ){
486	ERROR_DECLARE;	487	ERROR_DECLARE;
487		488
488	socket_ref socket;	489	socket_ref socket;
489		490
490	socket = sockets_find( socket_get_sockets(), socket_id );	491	socket = sockets_find( socket_get_sockets(), socket_id );
491	if( ! socket ) return ENOTSOCK;	492	if( ! socket ) return ENOTSOCK;
492	// request close	493	// request close
493	ERROR_PROPAGATE( async_req_3_0( socket->phone, NET_SOCKET_CLOSE, socket->socket_id, 0, socket->service ));	494	ERROR_PROPAGATE(( int ) async_req_3_0( socket->phone, NET_SOCKET_CLOSE, ( ipcarg_t ) socket->socket_id, 0, socket->service ));
494	// free the socket structure	495	// free the socket structure
495	socket_destroy( socket );	496	socket_destroy( socket );
496	return EOK;	497	return EOK;
497	}	498	}
498		499
499	void socket_destroy( socket_ref socket ){	500	void socket_destroy( socket_ref socket ){

Subversion Repositories HelenOS

(root)/branches/network/uspace/srv/net/socket/socket_client.c – Rev 4701 → 4708