Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4707 → Rev 4708

/branches/network/uspace/srv/net/tl/tcp/tcp.c
48,7 → 48,10
#include "../../include/ip_client.h"
#include "../../include/ip_interface.h"
#include "../../include/ip_protocols.h"
#include "../../include/icmp_interface.h"
 
#include "../../socket/socket_core.h"
 
#include "../tl_messages.h"
 
#include "tcp.h"
/branches/network/uspace/srv/net/tl/tcp/Makefile
43,11 → 43,13
$(STRUCTURES)packet/packet.c \
$(STRUCTURES)packet/packet_client.c \
$(STRUCTURES)packet/packet_remote.c \
$(STRUCTURES)dynamic_fifo.c \
$(STRUCTURES)measured_strings.c \
$(NET_BASE)il/ip/ip_client.c \
$(NET_BASE)il/ip/ip_remote.c \
$(NET_BASE)il/icmp/icmp_remote.c \
$(NET_BASE)il/icmp/icmp_client.c \
$(NET_BASE)net/net_remote.c
$(NET_BASE)net/net_remote.c \
$(NET_BASE)socket/socket_core.c
 
include $(NET_BASE)Makefile.module
/branches/network/uspace/srv/net/tl/udp/udp.c
226,13 → 226,14
int udp_received_msg( device_id_t device_id, packet_t packet, services_t receiver, services_t error ){
ERROR_DECLARE;
 
int length;
int offset;
size_t length;
size_t offset;
int result;
uint8_t * data;
udp_header_ref header;
socket_core_ref * socket;
packet_t next_packet;
int total_length;
size_t total_length;
// uint16_t checksum;
int fragments;
packet_t tmp_packet;
245,11 → 246,12
// process error
// TODO remove debug dump
// length = icmp_client_header_length( packet );
length = icmp_client_process_packet( packet, & type, & code, NULL, NULL );
if( length < 0 ){
return release_and_return( packet, length );
result = icmp_client_process_packet( packet, & type, & code, NULL, NULL );
if( result < 0 ){
return release_and_return( packet, result );
}
printf( "ICMP error %d (%d) in packet %d\n", type, code, packet_get_id( packet ) );
length = ( size_t ) result;
if( ERROR_OCCURRED( packet_trim( packet, length, 0 ))){
return release_and_return( packet, ERROR_CODE );
}
259,10 → 261,11
}
}
// TODO process received ipopts?
offset = ip_client_process_packet( packet, NULL, NULL, NULL, NULL, NULL );
if( offset < 0 ){
return release_and_return( packet, offset );
result = ip_client_process_packet( packet, NULL, NULL, NULL, NULL, NULL );
if( result < 0 ){
return release_and_return( packet, result );
}
offset = ( size_t ) result;
 
length = packet_get_data_length( packet );
if( length <= 0 ){
292,7 → 295,7
do{
++ fragments;
length = packet_get_data_length( packet );
if( ! length ){
if( length <= 0 ){
return release_and_return( packet, NO_DATA );
}
if( total_length < length ){
320,7 → 323,7
}
 
// notify the destination socket
async_msg_2(( ** socket ).phone, NET_SOCKET_RECEIVED, ( ** socket ).socket_id, fragments );
async_msg_2(( ** socket ).phone, NET_SOCKET_RECEIVED, ( ipcarg_t ) ( ** socket ).socket_id, ( ipcarg_t ) fragments );
return EOK;
}
 
448,17 → 451,17
// printf( "res = %d\n", res );
 
switch( answer_count ){
case 0: ipc_answer_0( callid, res );
case 0: ipc_answer_0( callid, ( ipcarg_t ) res );
continue;
case 1: ipc_answer_1( callid, res, IPC_GET_ARG1( answer ));
case 1: ipc_answer_1( callid, ( ipcarg_t ) res, IPC_GET_ARG1( answer ));
continue;
case 2: ipc_answer_2( callid, res, IPC_GET_ARG1( answer ), IPC_GET_ARG2( answer ));
case 2: ipc_answer_2( callid, ( ipcarg_t ) res, IPC_GET_ARG1( answer ), IPC_GET_ARG2( answer ));
continue;
case 3: ipc_answer_3( callid, res, IPC_GET_ARG1( answer ), IPC_GET_ARG2( answer ), IPC_GET_ARG3( answer ));
case 3: ipc_answer_3( callid, ( ipcarg_t ) res, IPC_GET_ARG1( answer ), IPC_GET_ARG2( answer ), IPC_GET_ARG3( answer ));
continue;
case 4: ipc_answer_4( callid, res, IPC_GET_ARG1( answer ), IPC_GET_ARG2( answer ), IPC_GET_ARG3( answer ), IPC_GET_ARG4( answer ));
case 4: ipc_answer_4( callid, ( ipcarg_t ) res, IPC_GET_ARG1( answer ), IPC_GET_ARG2( answer ), IPC_GET_ARG3( answer ), IPC_GET_ARG4( answer ));
continue;
default: ipc_answer_5( callid, res, IPC_GET_ARG1( answer ), IPC_GET_ARG2( answer ), IPC_GET_ARG3( answer ), IPC_GET_ARG4( answer ), IPC_GET_ARG5( answer ));
default: ipc_answer_5( callid, ( ipcarg_t ) res, IPC_GET_ARG1( answer ), IPC_GET_ARG2( answer ), IPC_GET_ARG3( answer ), IPC_GET_ARG4( answer ), IPC_GET_ARG5( answer ));
continue;
}
}
478,8 → 481,8
packet_t next_packet;
udp_header_ref header;
int index;
int total_length;
int length;
size_t total_length;
int result;
 
if( addrlen < sizeof( struct sockaddr )) return EINVAL;
address = ( struct sockaddr * ) addr;
505,8 → 508,9
ERROR_PROPAGATE( ip_packet_size_req( udp_globals.ip_phone, -1, & udp_globals.addr_len, & udp_globals.prefix, & udp_globals.content, & udp_globals.suffix ));
 
// read the first packet fragment
total_length = socket_read_packet_data( & packet, sizeof( udp_header_t ), address_in );
if( total_length < 0 ) return total_length;
result = socket_read_packet_data( & packet, sizeof( udp_header_t ), address_in );
if( result < 0 ) return result;
total_length = ( size_t ) result;
// prefix the udp header
header = PACKET_PREFIX( packet, udp_header_t );
if( ! header ){
515,16 → 519,15
}
// read the rest of the packet fragments
for( index = 1; index < fragments; ++ index ){
length = socket_read_packet_data( & next_packet, 0, address_in );
if( length < 0 ){
pq_release( udp_globals.net_phone, packet_get_id( packet ));
return length;
result = socket_read_packet_data( & next_packet, 0, address_in );
if( result < 0 ){
return release_and_return( packet, result );
}
packet = pq_add( packet, next_packet, index, 0 );
total_length += length;
total_length += ( size_t ) result;
}
// set the udp header
header->source = ( socket->port < 0 ) ? 0 : htons( socket->port );
header->source = htons( socket->port );
header->dest = htons( address_in->sin_port );
header->len = htons( total_length + sizeof( udp_header_t ));
// TODO my ip address for the pseudo header checksum
537,10 → 540,8
// send the packet
return ip_send_msg( udp_globals.ip_phone, socket->device_id, packet, SERVICE_UDP, 0 );
// TODO IPv6
default:
return EAFNOSUPPORT;
}
return EOK;
return EAFNOSUPPORT;
}
 
int udp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags ){
551,12 → 552,13
packet_t packet;
udp_header_ref header;
struct sockaddr_in address;
int length;
size_t length;
packet_t next_packet;
void * data;
int fragments;
int * lengths;
int index;
uint8_t * data;
size_t fragments;
size_t * lengths;
int result;
size_t index;
uint8_t * addr;
 
// find the socket
576,8 → 578,8
// set the source address
address.sin_family = PF_INET;
address.sin_port = ntohs( header->source );
length = packet_get_addr( packet, & addr, NULL );
if( length != sizeof( address.sin_addr.s_addr )){
result = packet_get_addr( packet, & addr, NULL );
if( result != sizeof( address.sin_addr.s_addr )){
pq_release( udp_globals.net_phone, packet_id );
return EINVAL;
}
599,7 → 601,7
++ fragments;
}
// compute and store the fragment lengths
lengths = ( int * ) malloc( sizeof( int ) * ( fragments + 1 ));
lengths = ( size_t * ) malloc( sizeof( size_t ) * fragments + sizeof( size_t ));
if( ! lengths ) return ENOMEM;
lengths[ 0 ] = packet_get_data_length( packet ) - sizeof( udp_header_t );
lengths[ fragments ] = lengths[ 0 ];
627,7 → 629,7
dyn_fifo_pop( & socket->received );
pq_release( udp_globals.net_phone, packet_get_id( packet ));
// return the total length
return length;
return ( int ) length;
}
 
int socket_write_data( void * data, size_t data_length ){
682,7 → 684,7
pq_release( udp_globals.net_phone, packet_get_id( * packet ));
return ERROR_CODE;
}
return length;
return ( int ) length;
}
 
static int release_and_return( packet_t packet, int result ){
705,10 → 707,10
&& ( ! error )
&& ( udp_globals.icmp_phone >= 0 )
// set both addresses to the source one (avoids the source address deletion before setting the destination one)
&& ( packet_set_addr( packet, src, src, length ) == EOK )){
&& ( packet_set_addr( packet, src, src, ( size_t ) length ) == EOK )){
icmp_destination_unreachable_msg( udp_globals.icmp_phone, ICMP_PORT_UNREACH, 0, packet );
}else{
return release_and_return( packet, EINVAL );
release_and_return( packet, EINVAL );
}
}
 
/branches/network/uspace/srv/net/app/echo/echo.c
234,7 → 234,7
int main( int argc, char * argv[] ){
ERROR_DECLARE;
 
int size = 1024;
size_t size = 1024;
int verbose = 0;
char * reply = NULL;
sock_type_t type = SOCK_DGRAM;
245,7 → 245,7
int address_length;
char address_string[ INET_ADDRSTRLEN ];
char * data;
int length;
size_t length;
int index;
size_t reply_length;
int value;
265,13 → 265,15
return EOK;
break;
case 'p': ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & value, "port number", 0 ));
address.sin_port = value;
address.sin_port = ( uint16_t ) value;
break;
case 'r': ERROR_PROPAGATE( parse_parameter_string( argc, argv, & index, & reply, "reply string", 0 ));
break;
case 's': ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & size, "receive size", 0 ));
case 's': ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & value, "receive size", 0 ));
size = (value >= 0 ) ? ( size_t ) value : 0;
break;
case 't': ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, ( int * ) & type, "socket_type", 0, parse_socket_type ));
case 't': ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, & value, "socket_type", 0, parse_socket_type ));
type = ( sock_type_t ) value;
break;
case 'v': verbose = 1;
break;
279,19 → 281,21
ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & count, "received count", 8 ))
}else if( str_lcmp( argv[ index ] + 2, "family=", 7 ) == 0 ){
ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, & value, "protocol family", 9, parse_protocol_family ));
address.sin_family = value;
address.sin_family = ( uint16_t ) value;
}else if( str_lcmp( argv[ index ] + 2, "help", 5 ) == 0 ){
print_help();
return EOK;
}else if( str_lcmp( argv[ index ] + 2, "port=", 5 ) == 0 ){
ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & value, "port number", 7 ));
address.sin_port = value;
address.sin_port = ( uint16_t ) value;
}else if( str_lcmp( argv[ index ] + 2, "reply=", 6 ) == 0 ){
ERROR_PROPAGATE( parse_parameter_string( argc, argv, & index, & reply, "reply string", 8 ));
}else if( str_lcmp( argv[ index ] + 2, "size=", 5 ) == 0 ){
ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & size, "receive size", 7 ));
ERROR_PROPAGATE( parse_parameter_int( argc, argv, & index, & value, "receive size", 7 ));
size = (value >= 0 ) ? ( size_t ) value : 0;
}else if( str_lcmp( argv[ index ] + 2, "type=", 5 ) == 0 ){
ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, ( int * ) & type, "socket_type", 7, parse_socket_type ));
ERROR_PROPAGATE( parse_parameter_name_int( argc, argv, & index, & value, "socket_type", 7, parse_socket_type ));
type = ( sock_type_t ) value;
}else if( str_lcmp( argv[ index ] + 2, "verbose", 8 ) == 0 ){
verbose = 1;
}else{
335,10 → 339,11
 
while( count ){
address_length = sizeof( address );
length = recvfrom( socket_id, data, size, 0, ( struct sockaddr * ) & address, & address_length );
if( length < 0 ){
fprintf( stderr, "Socket receive error %d\n", length );
value = recvfrom( socket_id, data, size, 0, ( struct sockaddr * ) & address, & address_length );
if( value < 0 ){
fprintf( stderr, "Socket receive error %d\n", value );
}else{
length = ( size_t ) value;
if( verbose ){
if( ERROR_OCCURRED( inet_ntop( address.sin_family, ( uint8_t * ) & address.sin_addr.s_addr, address_string, sizeof( address_string )))){
fprintf( stderr, "Received address error %d\n", ERROR_CODE );
348,7 → 353,7
printf( "Received from %s:%d\n%s\n", address_string, address.sin_port, data );
}
}
if( ERROR_OCCURRED( sendto( socket_id, reply ? reply : data, reply ? reply_length : ( size_t ) length, 0, ( struct sockaddr * ) & address, sizeof( address )))){
if( ERROR_OCCURRED( sendto( socket_id, reply ? reply : data, reply ? reply_length : length, 0, ( struct sockaddr * ) & address, sizeof( address )))){
fprintf( stderr, "Socket send error %d\n", ERROR_CODE );
}
}
/branches/network/uspace/srv/net/nil/nildummy/nildummy.c
337,7 → 337,7
switch( IPC_GET_METHOD( * icall )){
case NET_NIL_DEVICE_STATE:
ERROR_CODE = nil_device_state_msg( 0, IPC_GET_DEVICE( icall ), IPC_GET_STATE( icall ));
ipc_answer_0( iid, ERROR_CODE );
ipc_answer_0( iid, ( ipcarg_t ) ERROR_CODE );
break;
case NET_NIL_RECEIVED:
if( ! ERROR_OCCURRED( packet_translate( nildummy_globals.net_phone, & packet, IPC_GET_PACKET( icall )))){
/branches/network/uspace/srv/net/structures/measured_strings.c
248,7 → 248,7
 
size_t * prepare_lengths( const measured_string_ref strings, size_t count ){
size_t * lengths;
int index;
size_t index;
size_t length;
 
lengths = ( size_t * ) malloc( sizeof( size_t ) * ( count + 1 ));
/branches/network/uspace/srv/net/include/protocol_map.h
94,7 → 94,7
* @returns Ethernet protocol identifier of the link service access point identifier.
* @returns ETH_LSAP_NULL if mapping is not found.
*/
static inline int lsap_map( eth_lsap_t lsap ){
static inline eth_type_t lsap_map( eth_lsap_t lsap ){
switch( lsap ){
case ETH_LSAP_IP:
return ETH_P_IP;
/branches/network/uspace/srv/net/include/il_interface.h
85,8 → 85,8
* @param target The target internetwork module service to be delivered to. Input parameter.
* @returns EOK on success.
*/
inline static int il_mtu_changed_msg( int il_phone, device_id_t device_id, int mtu, services_t target ){
return generic_device_state_msg( il_phone, NET_IL_MTU_CHANGED, device_id, mtu, target );
inline static int il_mtu_changed_msg( int il_phone, device_id_t device_id, size_t mtu, services_t target ){
return generic_device_state_msg( il_phone, NET_IL_MTU_CHANGED, device_id, ( int ) mtu, target );
}
 
/*@}*/
/branches/network/uspace/srv/net/net/net_bundle.c
69,6 → 69,8
return ip_message( callid, call, answer, answer_count );
case SERVICE_ARP:
return arp_message( callid, call, answer, answer_count );
case SERVICE_ICMP:
return icmp_message( callid, call, answer, answer_count );
case SERVICE_UDP:
return udp_message( callid, call, answer, answer_count );
case SERVICE_TCP:
/branches/network/uspace/srv/net/socket/socket_core.c
86,10 → 86,8
return socket_bind_insert( global_sockets, socket, address_in->sin_port );
break;
// TODO IPv6
default:
return EAFNOSUPPORT;
}
return EOK;
return EAFNOSUPPORT;
}
 
int socket_bind_free_port( socket_ports_ref global_sockets, socket_core_ref socket, int free_ports_start, int free_ports_end, int last_used_port ){
/branches/network/uspace/srv/net/socket/socket_messages.h
44,6 → 44,8
 
#include "../messages.h"
 
#include "../include/socket.h"
 
typedef enum{
NET_SOCKET = NET_SOCKET_FIRST,
NET_SOCKET_BIND,
77,11 → 79,11
#define SOCKET_GET_OPT_LEVEL( call ) ( int ) IPC_GET_ARG2( call )
#define SOCKET_SET_DATA_FRAGMENTS( call ) ( int * ) & IPC_GET_ARG2( call )
#define SOCKET_GET_DATA_FRAGMENTS( call ) ( int ) IPC_GET_ARG2( call )
#define SOCKET_SET_ADDRESS_LENGTH( call ) ( size_t * ) & IPC_GET_ARG2( call )
#define SOCKET_GET_ADDRESS_LENGTH( call ) ( size_t ) IPC_GET_ARG2( call )
#define SOCKET_SET_ADDRESS_LENGTH( call ) ( socklen_t * ) & IPC_GET_ARG2( call )
#define SOCKET_GET_ADDRESS_LENGTH( call ) ( socklen_t ) IPC_GET_ARG2( call )
 
#define SOCKET_SET_DATA_FRAGMENT_SIZE( call ) ( int * ) & IPC_GET_ARG3( call )
#define SOCKET_GET_DATA_FRAGMENT_SIZE( call ) ( int ) IPC_GET_ARG3( call )
#define SOCKET_SET_DATA_FRAGMENT_SIZE( call ) ( size_t * ) & IPC_GET_ARG3( call )
#define SOCKET_GET_DATA_FRAGMENT_SIZE( call ) ( size_t ) IPC_GET_ARG3( call )
 
#define SOCKET_GET_FLAGS( call ) ( int ) IPC_GET_ARG4( call )
 
/branches/network/uspace/srv/net/socket/socket_client.c
95,11 → 95,11
/** Underlying protocol header size.
* Sending and receiving optimalization.
*/
int header_size;
size_t header_size;
/** Packet data fragment size.
* Sending and receiving optimalization.
*/
int data_fragment_size;
size_t data_fragment_size;
/** Received packets queue.
*/
dyn_fifo_t received;
146,18 → 146,18
* Connects to the TCP module if necessary.
* @returns The TCP module phone.
*/
static int socket_get_tcp_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_tcp_phone();
static int socket_get_udp_phone( void );
 
/** Returns the active sockets.
* @returns The active sockets.
*/
static sockets_ref socket_get_sockets();
static sockets_ref socket_get_sockets( void );
 
/** Default thread for new connections.
* @param iid The initial message identifier. Input parameter.
177,7 → 177,7
* @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, int message, ipcarg_t arg2, const void * data, size_t datalength );
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.
206,7 → 206,7
* @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( int message, int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * addrlen );
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.
223,9 → 223,9
* @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( int message, int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t 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 );
 
static int socket_get_tcp_phone(){
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 );
}
232,7 → 232,7
return socket_globals.tcp_phone;
}
 
static int socket_get_udp_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 );
}
239,7 → 239,7
return socket_globals.udp_phone;
}
 
static sockets_ref socket_get_sockets(){
static sockets_ref socket_get_sockets( void ){
if( ! socket_globals.sockets ){
socket_globals.sockets = ( sockets_ref ) malloc( sizeof( sockets_t ));
if( ! socket_globals.sockets ) return NULL;
335,7 → 335,7
default:
ERROR_CODE = ENOTSUP;
}
ipc_answer_0( callid, ERROR_CODE );
ipc_answer_0( callid, ( ipcarg_t ) ERROR_CODE );
}
}
 
395,7 → 395,7
return ERROR_CODE;
}
// request a new socket
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 ))){
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 );
409,7 → 409,7
dyn_fifo_destroy( & socket->received );
dyn_fifo_destroy( & socket->accepted );
free( socket );
async_msg_3( phone, NET_SOCKET_CLOSE, socket_id, 0, service );
async_msg_3( phone, NET_SOCKET_CLOSE, ( ipcarg_t ) socket_id, 0, service );
return ERROR_CODE;
}
 
416,7 → 416,7
return socket_id;
}
 
int socket_send_data( int socket_id, int message, ipcarg_t arg2, const void * data, size_t datalength ){
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;
427,7 → 427,7
socket = sockets_find( socket_get_sockets(), socket_id );
if( ! socket ) return ENOTSOCK;
// request the message
message_id = async_send_3( socket->phone, message, socket->socket_id, arg2, socket->service, NULL );
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 );
435,8 → 435,9
}
 
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, addrlen );
return socket_send_data( socket_id, NET_SOCKET_BIND, 0, my_addr, ( size_t ) addrlen );
}
 
int listen( int socket_id, int backlog ){
447,7 → 448,7
socket = sockets_find( socket_get_sockets(), socket_id );
if( ! socket ) return ENOTSOCK;
// request listen backlog change
return async_req_3_0( socket->phone, NET_SOCKET_LISTEN, socket->socket_id, backlog, socket->service );
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 ){
465,7 → 466,7
fibril_condvar_wait( & socket->accept_signal, & socket->accept_lock );
}
// request accept
message_id = async_send_3( socket->phone, NET_SOCKET_ACCEPT, socket->socket_id, dyn_fifo_value( & socket->accepted ), socket->service, NULL );
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 );
490,7 → 491,7
socket = sockets_find( socket_get_sockets(), socket_id );
if( ! socket ) return ENOTSOCK;
// request close
ERROR_PROPAGATE( async_req_3_0( socket->phone, NET_SOCKET_CLOSE, socket->socket_id, 0, socket->service ));
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;
520,11 → 521,11
return sendto_core( NET_SOCKET_SENDTO, socket_id, data, datalength, flags, toaddr, addrlen );
}
 
int sendto_core( int message, int socket_id, const void * data, size_t datalength, int flags, const struct sockaddr * toaddr, socklen_t 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;
int fragments;
size_t fragments;
 
if( ! data ) return EBADMEM;
if( ! datalength ) return NO_DATA;
535,7 → 536,7
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, socket->socket_id, fragments, socket->service, flags, NULL );
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 ){
544,11 → 545,11
}else{
// send the first fragment
ipc_data_write_start( socket->phone, data, socket->data_fragment_size - socket->header_size );
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 += 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 );
570,13 → 571,13
return recvfrom_core( NET_SOCKET_RECVFROM, socket_id, data, datalength, flags, fromaddr, addrlen );
}
 
int recvfrom_core( int message, int socket_id, void * data, size_t datalength, int flags, struct sockaddr * fromaddr, socklen_t * 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;
int fragments;
int * lengths;
int index;
size_t fragments;
size_t * lengths;
size_t index;
ipc_call_t answer;
 
if( ! data ) return EBADMEM;
587,39 → 588,41
if( ! socket ) return ENOTSOCK;
fibril_mutex_lock( & socket->receive_lock );
// wait for a received packet
while(( fragments = dyn_fifo_value( & socket->received )) <= 0 ){
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 = ( int * ) malloc( sizeof( int ) * ( 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, socket->socket_id, 0, socket->service, flags, & answer );
// read the address if desired
if(( ! fromaddr ) || ( ipc_data_read_start( socket->phone, fromaddr, * addrlen ) == EOK )){
if( fragments == 1 ){
// read all if only one fragment
ipc_data_read_start( socket->phone, data, datalength );
}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 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
// read all fragments if long enough
for( index = 0; index < fragments; ++ index ){
ipc_data_read_start( socket->phone, data, lengths[ index ] );
data += lengths[ index ];
data = (( uint8_t * ) data ) + lengths[ index ];
}
}
}
free( lengths );
}
}else if( fragments > 1 ){
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
646,7 → 649,7
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, socket->socket_id, optname, socket->service, NULL );
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
658,7 → 661,7
 
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, optname, value, optlen );
return socket_send_data( socket_id, NET_SOCKET_SETSOCKOPT, ( ipcarg_t ) optname, value, optlen );
 
}
 
/branches/network/uspace/srv/net/crc.c
43,7 → 43,7
#define CRC_DIVIDER_LE 0xEDB88320
 
uint32_t compute_crc32_le( uint32_t seed, uint8_t * data, size_t length ){
int index;
size_t index;
 
while( length >= 8 ){
seed ^= ( * data );
72,7 → 72,7
}
 
uint32_t compute_crc32_be( uint32_t seed, uint8_t * data, size_t length ){
int index;
size_t index;
 
while( length >= 8 ){
seed ^= ( * data ) << 24;
/branches/network/uspace/srv/net/il/arp/arp.c
437,8 → 437,7
if( ! device ) return ENOENT;
header = ( arp_header_ref ) packet_get_data( packet );
if(( ntohs( header->hardware ) != device->hardware )
// TODO how remove conversion from int '2' to uint?
|| ( length < sizeof( arp_header_t ) + ( header->hardware_length + header->protocol_length ) * 2u )){
|| ( length < sizeof( arp_header_t ) + header->hardware_length * 2u + header->protocol_length * 2u )){
return EINVAL;
}
proto = arp_protos_find( & device->protos, protocol_unmap( device->service, ntohs( header->protocol )));
496,6 → 495,7
}
 
int arp_connect_module( services_t service ){
if( service != SERVICE_ARP ) return EINVAL;
return EOK;
}
 
/branches/network/uspace/srv/net/il/arp/arp_remote.c
84,6 → 84,7
}
 
int arp_connect_module( services_t service ){
if( service != SERVICE_ARP ) return EINVAL;
return connect_to_service( SERVICE_ARP );
}
 
/branches/network/uspace/srv/net/il/icmp/icmp.c
214,14 → 214,15
}
 
int icmp_process_packet( packet_t packet ){
int length;
size_t length;
int result;
void * data;
icmp_header_ref header;
 
// get rid of the ip header
length = ip_client_process_packet( packet, NULL, NULL, NULL, NULL, NULL );
if( length < 0 ) return length;
packet_trim( packet, length, 0 );
result = ip_client_process_packet( packet, NULL, NULL, NULL, NULL, NULL );
if( result < 0 ) return result;
packet_trim( packet, ( size_t ) result, 0 );
 
length = packet_get_data_length( packet );
if( length <= 0 ) return EINVAL;
/branches/network/uspace/srv/net/il/ip/ip.c
233,7 → 233,7
checksum = compact_checksum(compute_checksum( 0, data, length ));
 
// flip, zero is returned as 0xFFFF (not flipped)
return ( ~ checksum ) ? ~ checksum : IP_HEADER_CHECKSUM_ZERO;
return ( ~ checksum ) ? ( uint16_t ) ( ~ checksum ) : IP_HEADER_CHECKSUM_ZERO;
}
 
int ip_initialize( async_client_conn_t client_connection ){
906,10 → 906,12
ip_header_ref last_header;
uint8_t * src;
uint8_t * dest;
int address_length;
size_t address_length;
int result;
 
address_length = packet_get_addr( packet, & src, & dest );
if( address_length <= 0 ) return EINVAL;
result = packet_get_addr( packet, & src, & dest );
if( result <= 0 ) return EINVAL;
address_length = ( size_t ) result;
if( packet_get_data_length( packet ) <= sizeof( ip_header_t )) return ENOMEM;
// get header
header = ( ip_header_ref ) packet_get_data( packet );
994,7 → 996,7
next = sizeof( ip_header_t );
// process all ip options
while( next < first->ihl ){
option = ( ip_option_ref ) ((( void * ) first ) + next );
option = ( ip_option_ref ) ((( uint8_t * ) first ) + next );
// skip end or noop
if(( option->type == IPOPT_END ) || ( option->type == IPOPT_NOOP )){
++ next;
1001,7 → 1003,7
}else{
// copy if said so or skip
if( IPOPT_COPIED( option->type )){
memcpy((( void * ) last ) + length, (( void * ) first ) + next, option->length );
memcpy((( uint8_t * ) last ) + length, (( uint8_t * ) first ) + next, option->length );
length += option->length;
}
// next option
1010,7 → 1012,7
}
// align 4 byte boundary
if( length % 4 ){
bzero((( void * ) last ) + length, 4 - ( length % 4 ));
bzero((( uint8_t * ) last ) + length, 4 - ( length % 4 ));
last->ihl = length / 4 + 1;
}else{
last->ihl = length / 4;
/branches/network/uspace/srv/net/netif/dp8390/dp8390.c
1585,7 → 1585,7
size_t i;
 
for( i = 0; i < size; ++ i ){
*(( uint8_t * )( buf + i )) = inb( port );
*(( uint8_t * ) buf + i ) = inb( port );
}
}
 
1593,8 → 1593,8
{
size_t i;
 
for( i = 0; i < size; i += 2 ){
*(( uint16_t * )( buf + i )) = inw( port );
for( i = 0; i * 2 < size; ++ i ){
*(( uint16_t * ) buf + i ) = inw( port );
}
}
 
1603,7 → 1603,7
size_t i;
 
for( i = 0; i < size; ++ i ){
outb( port, *(( uint8_t * )( buf + i )));
outb( port, *(( uint8_t * ) buf + i ));
}
}
 
1611,8 → 1611,8
{
size_t i;
 
for( i = 0; i < size; i += 2 ){
outw( port, *(( uint16_t * )( buf + i )));
for( i = 0; i * 2 < size; ++ i ){
outw( port, *(( uint16_t * ) buf + i ));
}
}