Rev 4582 | 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/int_map.h"
#include "socket_messages.h"
typedef struct socket socket_t;
typedef socket_t * socket_ref;
struct socket{
int socket_id;
int phone;
services_t service;
int max_content;
int received;
// fibril_mutex_t receive_lock;
// fibril_condvar_t receive_signal;
int accepted;
// fibril_mutex_t accept_lock;
// fibril_condvar_t accept_signal;
};
INT_MAP_DECLARE( sockets, socket_t );
static struct{
int tcp_phone;
int udp_phone;
sockets_ref sockets;
} socket_globals = { -1, -1, NULL };
INT_MAP_IMPLEMENT( sockets, socket_t );
static int socket_get_tcp_phone();
static int socket_get_tcp_phone();
static sockets_ref socket_get_sockets();
void socket_connection( ipc_callid_t iid, ipc_call_t * icall );
int socket_send_data( int socket_id, int message, ipcarg_t arg2, const void * data, size_t datalength );
void socket_initialize( socket_ref socket, int socket_id, int phone, services_t service );
static int socket_get_tcp_phone(){
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(){
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(){
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;
socket->received = 0;
socket->accepted = 0;
// 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:
socket = sockets_find( socket_get_sockets(), SOCKET_GET_SOCKET_ID( & call ));
if( ! socket ){
ERROR_CODE = ENOTSOCK;
break;
}
// fibril_mutex_lock( & socket->receive_lock );
++ socket->received;
// fibril_condvar_signal( & socket->receive_signal );
// fibril_mutex_unlock( & socket->receive_lock );
ERROR_CODE = EOK;
break;
case NET_SOCKET_ACCEPTED:
socket = sockets_find( socket_get_sockets(), SOCKET_GET_SOCKET_ID( & call ));
if( ! socket ){
ERROR_CODE = ENOTSOCK;
break;
}
// fibril_mutex_lock( & socket->accept_lock );
new_socket = ( socket_ref ) malloc( sizeof( socket_t ));
if( ! new_socket ){
ERROR_CODE = ENOMEM;
break;
}
socket_initialize( new_socket, SOCKET_GET_NEW_SOCKET_ID( & call ), socket->phone, socket->service );
if( ERROR_OCCURRED( sockets_add( socket_get_sockets(), new_socket->socket_id, new_socket ))){
break;
}
++ socket->accepted;
// fibril_condvar_signal( & socket->accept_signal );
// fibril_mutex_unlock( & socket->accept_lock );
break;
/* case NET_SOCKET_MTU:
socket = sockets_find( socket_get_sockets(), SOCKET_GET_SOCKET_ID( & call ));
if( ! socket ){
ERROR_CODE = ENOTSOCK;
break;
}
socket->mtu =
ERROR_CODE = EOK;
break;
*/ default:
ERROR_CODE = ENOTSUP;
}
ipc_answer_0( callid, ERROR_CODE );
}
}
int socket( int domain, int type, int protocol ){
socket_ref socket;
int phone;
int socket_id;
services_t 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;
}
assert( phone );
socket = ( socket_ref ) malloc( sizeof( socket_t ));
if( ! socket ) return ENOMEM;
socket_id = async_req_3_0( phone, NET_SOCKET, 0, 0, service );
if( socket_id > 0 ){
socket_initialize( socket, socket_id, phone, service );
if( sockets_add( socket_get_sockets(), socket_id, socket ) != EOK ){
free( socket );
async_msg_3( phone, NET_SOCKET_CLOSE, socket_id, 0, service );
}
}else{
free( socket );
}
return socket_id;
}
int socket_send_data( int socket_id, int 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;
socket = sockets_find( socket_get_sockets(), socket_id );
if( ! socket ) return ENOTSOCK;
message_id = async_send_3( socket->phone, message, socket->socket_id, arg2, socket->service, NULL );
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 ){
return socket_send_data( socket_id, NET_SOCKET_BIND, 0, my_addr, addrlen );
}
int listen( int socket_id, int backlog ){
socket_ref socket;
if( backlog <= 0 ) return EINVAL;
socket = sockets_find( socket_get_sockets(), socket_id );
if( ! socket ) return ENOTSOCK;
return async_req_3_0( socket->phone, NET_SOCKET_LISTEN, socket->socket_id, backlog, socket->service );
}
int accept( int socket_id, struct sockaddr * cliaddr, socklen_t * addrlen ){
socket_ref socket;
aid_t message_id;
ipcarg_t result;
if( ! cliaddr ) return EBADMEM;
if( ! addrlen ) return NO_DATA;
socket = sockets_find( socket_get_sockets(), socket_id );
if( ! socket ) return ENOTSOCK;
// fibril_mutex_lock( & socket->accept_lock );
while( socket->accepted <= 0 ){
// fibril_condvar_wait( & socket->accept_signal, & socket->accept_lock );
}
message_id = async_send_3( socket->phone, NET_SOCKET_ACCEPT, socket->socket_id, 0, socket->service, NULL );
ipc_data_read_start( socket->phone, cliaddr, * addrlen );
async_wait_for( message_id, & result );
if( result > 0 ){
-- socket->accepted;
}
// fibril_mutex_unlock( & socket->accept_lock );
return ( int ) result;
}
int connect( int socket_id, const struct sockaddr * serv_addr, socklen_t addrlen ){
return socket_send_data( socket_id, NET_SOCKET_CONNECT, 0, serv_addr, addrlen );
}
int closesocket( int socket_id ){
socket_ref socket;
socket = sockets_find( socket_get_sockets(), socket_id );
if( ! socket ) return ENOTSOCK;
return async_req_3_0( socket->phone, NET_SOCKET_CLOSE, socket->socket_id, 0, socket->service );
}
int send( int socket_id, void * data, size_t datalength, int flags ){
return socket_send_data( socket_id, NET_SOCKET_SEND, flags, data, datalength );
}
int sendto( 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;
if( ! toaddr ) return EBADMEM;
if( ! addrlen ) return NO_DATA;
if( ! data ) return EBADMEM;
if( ! datalength ) return NO_DATA;
socket = sockets_find( socket_get_sockets(), socket_id );
if( ! socket ) return ENOTSOCK;
message_id = async_send_3( socket->phone, NET_SOCKET_SENDTO, socket->socket_id, flags, socket->service, NULL );
if( ipc_data_write_start( socket->phone, toaddr, addrlen ) == EOK ){
ipc_data_write_start( socket->phone, data, datalength );
}
async_wait_for( message_id, & result );
return ( int ) result;
}
int recv( int socket_id, void * data, size_t datalength, int flags ){
socket_ref socket;
aid_t message_id;
ipcarg_t result;
if( ! data ) return EBADMEM;
if( ! datalength ) return NO_DATA;
socket = sockets_find( socket_get_sockets(), socket_id );
if( ! socket ) return ENOTSOCK;
// fibril_mutex_lock( & socket->receive_lock );
while( socket->received <= 0 ){
// fibril_condvar_wait( & socket->receive_signal, & socket->receive_lock );
}
message_id = async_send_3( socket->phone, NET_SOCKET_RECV, socket->socket_id, flags, socket->service, NULL );
ipc_data_read_start( socket->phone, data, datalength );
async_wait_for( message_id, & result );
if( result > 0 ){
-- socket->received;
}
// fibril_mutex_unlock( & socket->receive_lock );
return ( int ) result;
}
int recvfrom( 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 result;
if( ! fromaddr ) return EBADMEM;
if( ! addrlen ) return NO_DATA;
if( ! data ) return EBADMEM;
if( ! datalength ) return NO_DATA;
socket = sockets_find( socket_get_sockets(), socket_id );
if( ! socket ) return ENOTSOCK;
// fibril_mutex_lock( & socket->receive_lock );
while( socket->received <= 0 ){
// fibril_condvar_wait( & socket->receive_signal, & socket->receive_lock );
}
message_id = async_send_3( socket->phone, NET_SOCKET_RECVFROM, socket->socket_id, flags, socket->service, NULL );
if( ipc_data_read_start( socket->phone, fromaddr, * addrlen ) == EOK ){
ipc_data_read_start( socket->phone, data, datalength );
}
async_wait_for( message_id, & result );
if( result > 0 ){
-- socket->received;
}
// fibril_mutex_unlock( & socket->receive_lock );
return ( int ) 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 ) return EBADMEM;
if( ! optlen ) return NO_DATA;
socket = sockets_find( socket_get_sockets(), socket_id );
if( ! socket ) return ENOTSOCK;
message_id = async_send_3( socket->phone, NET_SOCKET_GETSOCKOPT, socket->socket_id, optname, socket->service, NULL );
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 ){
return socket_send_data( socket_id, NET_SOCKET_SETSOCKOPT, optname, value, optlen );
}
/** @}
*/