/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,11 → 540,9 |
// 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; |
} |
int udp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags ){ |
ERROR_DECLARE; |
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,11 → 86,9 |
return socket_bind_insert( global_sockets, socket, address_in->sin_port ); |
break; |
// TODO IPv6 |
default: |
} |
return EAFNOSUPPORT; |
} |
return EOK; |
} |
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 ){ |
int index; |
/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,25 → 588,21 |
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 ); |
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 )){ |
if( fragments == 1 ){ |
// read all if only one fragment |
ipc_data_read_start( socket->phone, data, datalength ); |
}else{ |
// read the fragment lengths |
if( ipc_data_read_start( socket->phone, lengths, sizeof( int ) * ( fragments + 1 )) == EOK ){ |
if( lengths[ fragments ] <= datalength ){ |
612,15 → 609,21 |
// 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 |
if( result == EOK ){ |
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 )); |
} |
} |