Rev 4708 | Rev 4729 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed
/*
* 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.
* 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;
/** 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,
.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 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 );
fibril_rwlock_initialize( & socket->sending_lock );
}
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 )){
// TODO remember the data_fragment_size
case NET_SOCKET_RECEIVED:
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{
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 );
}
fibril_rwlock_read_unlock( & socket_globals.lock );
break;
case NET_SOCKET_ACCEPTED:
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{
// create a new scoket
new_socket = ( socket_ref ) malloc( sizeof( socket_t ));
if( ! new_socket ){
ERROR_CODE = ENOMEM;
}else{
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;
}
}
}
fibril_rwlock_read_unlock( & socket_globals.lock );
break;
// TODO obsolete?
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{
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 );
ERROR_CODE = EOK;
}
fibril_rwlock_read_unlock( & socket_globals.lock );
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->data_fragment_size, ( ipcarg_t * ) & socket->header_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
fibril_rwlock_write_lock( & socket_globals.lock );
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;
}
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
ipc_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;
aid_t message_id;
int result;
if(( ! cliaddr ) || ( ! addrlen )) return EBADMEM;
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->accept_lock );
// wait for an accepted socket
++ socket->blocked;
while( dyn_fifo_value( & socket->accepted ) <= 0 ){
fibril_rwlock_read_unlock( & socket_globals.lock );
fibril_condvar_wait( & socket->accept_signal, & socket->accept_lock );
fibril_rwlock_read_lock( & socket_globals.lock );
}
-- socket->blocked;
// 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 );
fibril_rwlock_read_unlock( & socket_globals.lock );
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;
fibril_rwlock_write_unlock( & 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;
}
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;
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
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_5( socket->phone, message, ( ipcarg_t ) socket->socket_id, socket->data_fragment_size, socket->service, ( ipcarg_t ) flags, fragments, 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 );
}
}
fibril_rwlock_read_unlock( & socket->sending_lock );
fibril_rwlock_read_unlock( & socket_globals.lock );
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;
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 );
fibril_rwlock_read_lock( & socket_globals.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 ) || ( 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 );
fibril_rwlock_read_unlock( & socket_globals.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;
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( ipc_data_read_start( socket->phone, optlen, sizeof( * optlen )) == EOK ){
// read the value
ipc_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 );
}
/** @}
*/