Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4581 → Rev 4582

/branches/network/uspace/srv/net/il/arp/arp.c
38,7 → 38,7
#include <async.h>
#include <malloc.h>
#include <mem.h>
#include <rwlock.h>
#include <fibril_sync.h>
#include <stdio.h>
#include <string.h>
#include <task.h>
140,15 → 140,15
int arp_clear_device_req( int arp_phone, device_id_t device_id ){
arp_device_ref device;
 
rwlock_write_lock( & arp_globals.lock );
fibril_rwlock_write_lock( & arp_globals.lock );
device = arp_cache_find( & arp_globals.cache, device_id );
if( ! device ){
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
return ENOENT;
}
clear_device( device );
printf( "Device %d cleared\n", device_id );
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
return EOK;
}
 
156,7 → 156,7
int count;
arp_device_ref device;
 
rwlock_write_lock( & arp_globals.lock );
fibril_rwlock_write_lock( & arp_globals.lock );
for( count = arp_cache_count( & arp_globals.cache ) - 1; count >= 0; -- count ){
device = arp_cache_get_index( & arp_globals.cache, count );
if( device ){
166,7 → 166,7
}
}
arp_cache_clear( & arp_globals.cache );
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
printf( "Cache cleaned\n" );
return EOK;
}
187,11 → 187,11
int arp_translate_req( int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address, measured_string_ref * translation, char ** data ){
measured_string_ref tmp;
 
rwlock_read_lock( & arp_globals.lock );
fibril_rwlock_read_lock( & arp_globals.lock );
tmp = arp_translate_message( device_id, protocol, address );
if( tmp ){
* translation = measured_string_copy( tmp );
rwlock_read_unlock( & arp_globals.lock );
fibril_rwlock_read_unlock( & arp_globals.lock );
if( * translation ){
* data = ( ** translation ).value;
return EOK;
199,7 → 199,7
return ENOMEM;
}
}else{
rwlock_read_unlock( & arp_globals.lock );
fibril_rwlock_read_unlock( & arp_globals.lock );
return ENOENT;
}
}
207,11 → 207,11
int arp_initialize( async_client_conn_t client_connection ){
ERROR_DECLARE;
 
rwlock_initialize( & arp_globals.lock );
rwlock_write_lock( & arp_globals.lock );
fibril_rwlock_initialize( & arp_globals.lock );
fibril_rwlock_write_lock( & arp_globals.lock );
arp_globals.client_connection = client_connection;
ERROR_PROPAGATE( arp_cache_initialize( & arp_globals.cache ));
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
return EOK;
}
 
238,13 → 238,13
int index;
hw_type_t hardware;
 
rwlock_write_lock( & arp_globals.lock );
fibril_rwlock_write_lock( & arp_globals.lock );
// an existing device?
device = arp_cache_find( & arp_globals.cache, device_id );
if( device ){
if( device->service != service ){
printf( "Device %d already exists\n", device->device_id );
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
return EEXIST;
}
proto = arp_protos_find( & device->protos, protocol );
255,12 → 255,12
proto->addr_data = address->value;
}else{
if( ERROR_OCCURRED( arp_proto_create( & proto, protocol, address ))){
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
return ERROR_CODE;
}
index = arp_protos_add( & device->protos, proto->service, proto );
if( index < 0 ){
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
free( proto );
return index;
}
272,7 → 272,7
// create a new device
device = ( arp_device_ref ) malloc( sizeof( arp_device_t ));
if( ! device ){
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
return ENOMEM;
}
device->hardware = hardware;
279,13 → 279,13
device->device_id = device_id;
if( ERROR_OCCURRED( arp_protos_initialize( & device->protos ))
|| ERROR_OCCURRED( arp_proto_create( & proto, protocol, address ))){
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
free( device );
return ERROR_CODE;
}
index = arp_protos_add( & device->protos, proto->service, proto );
if( index < 0 ){
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
arp_protos_destroy( & device->protos );
free( device );
return index;
294,7 → 294,7
// bind the new one
device->phone = bind_service( device->service, ( ipcarg_t ) device->device_id, SERVICE_ARP, 0, arp_globals.client_connection );
if( device->phone < 0 ){
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
arp_protos_destroy( & device->protos );
free( device );
return EREFUSED;
301,7 → 301,7
}
// get packet dimensions
if( ERROR_OCCURRED( nil_packet_size_req( device->phone, device_id, & device->addr_len, & device->prefix, & device->content, & device->suffix ))){
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
arp_protos_destroy( & device->protos );
free( device );
return ERROR_CODE;
308,7 → 308,7
}
// get hardware address
if( ERROR_OCCURRED( nil_get_addr( device->phone, device_id, & device->addr, & device->addr_data ))){
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
arp_protos_destroy( & device->protos );
free( device );
return ERROR_CODE;
315,7 → 315,7
}
// get broadcast address
if( ERROR_OCCURRED( nil_get_broadcast_addr( device->phone, device_id, & device->broadcast_addr, & device->broadcast_data ))){
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
free( device->addr );
free( device->addr_data );
arp_protos_destroy( & device->protos );
323,7 → 323,7
return ERROR_CODE;
}
if( ERROR_OCCURRED( arp_cache_add( & arp_globals.cache, device->device_id, device ))){
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
free( device->addr );
free( device->addr_data );
free( device->broadcast_addr );
334,7 → 334,7
}
printf( "New device registered:\n\tid\t= %d\n\ttype\t= 0x%x\n\tservice\t= %d\n\tproto\t= %d\n", device->device_id, device->hardware, device->service, protocol );
}
rwlock_write_unlock( & arp_globals.lock );
fibril_rwlock_write_unlock( & arp_globals.lock );
return EOK;
}
 
488,16 → 488,16
return ERROR_CODE;
case NET_ARP_TRANSLATE:
ERROR_PROPAGATE( measured_strings_receive( & address, & data, 1 ));
rwlock_read_lock( & arp_globals.lock );
fibril_rwlock_read_lock( & arp_globals.lock );
translation = arp_translate_message( IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ), address );
free( address );
free( data );
if( ! translation ){
rwlock_read_unlock( & arp_globals.lock );
fibril_rwlock_read_unlock( & arp_globals.lock );
return ENOENT;
}
ERROR_CODE = measured_strings_reply( translation, 1 );
rwlock_read_unlock( & arp_globals.lock );
fibril_rwlock_read_unlock( & arp_globals.lock );
return ERROR_CODE;
case NET_ARP_CLEAR_DEVICE:
return arp_clear_device_req( 0, IPC_GET_DEVICE( call ));
508,7 → 508,7
return EOK;
case NET_IL_RECEIVED:
if( ! ERROR_OCCURRED( packet_translate( arp_globals.net_phone, & packet, IPC_GET_PACKET( call )))){
rwlock_read_lock( & arp_globals.lock );
fibril_rwlock_read_lock( & arp_globals.lock );
do{
next = pq_detach( packet );
ERROR_CODE = arp_receive_message( IPC_GET_DEVICE( call ), packet );
515,7 → 515,7
if( ERROR_CODE != 1 ) pq_release( arp_globals.net_phone, packet_get_id( packet ));
packet = next;
}while( packet );
rwlock_read_unlock( & arp_globals.lock );
fibril_rwlock_read_unlock( & arp_globals.lock );
}
return ERROR_CODE;
}
/branches/network/uspace/srv/net/il/arp/arp.h
37,7 → 37,7
#ifndef __NET_ARP_H__
#define __NET_ARP_H__
 
#include <rwlock.h>
#include <fibril_sync.h>
 
#include <ipc/ipc.h>
#include <ipc/services.h>
164,7 → 164,7
int net_phone;
/** Safety lock.
*/
rwlock_t lock;
fibril_rwlock_t lock;
/** ARP address cache.
*/
arp_cache_t cache;
/branches/network/uspace/srv/net/il/ip/ip.c
35,7 → 35,7
 
#include <async.h>
#include <errno.h>
#include <rwlock.h>
#include <fibril_sync.h>
#include <stdio.h>
#include <string.h>
 
146,10 → 146,10
int ip_initialize( async_client_conn_t client_connection ){
ERROR_DECLARE;
 
rwlock_initialize( & ip_globals.lock );
rwlock_write_lock( & ip_globals.lock );
rwlock_initialize( & ip_globals.protos_lock );
rwlock_initialize( & ip_globals.netifs_lock );
fibril_rwlock_initialize( & ip_globals.lock );
fibril_rwlock_write_lock( & ip_globals.lock );
fibril_rwlock_initialize( & ip_globals.protos_lock );
fibril_rwlock_initialize( & ip_globals.netifs_lock );
ip_globals.packet_counter = 0;
ip_globals.gateway.address.s_addr = 0;
ip_globals.gateway.netmask.s_addr = 0;
160,7 → 160,7
ip_globals.client_connection = client_connection;
ERROR_PROPAGATE( modules_initialize( & ip_globals.modules ));
ERROR_PROPAGATE( add_module( NULL, & ip_globals.modules, ARP_NAME, ARP_FILENAME, SERVICE_ARP, arp_task_get_id(), arp_connect_module ));
rwlock_write_unlock( & ip_globals.lock );
fibril_rwlock_write_unlock( & ip_globals.lock );
return EOK;
}
 
181,9 → 181,9
ip_netif->device_id = device_id;
ip_netif->service = netif;
ip_netif->state = NETIF_STOPPED;
rwlock_write_lock( & ip_globals.netifs_lock );
fibril_rwlock_write_lock( & ip_globals.netifs_lock );
if( ERROR_OCCURRED( ip_netif_initialize( ip_netif ))){
rwlock_write_unlock( & ip_globals.netifs_lock );
fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
ip_routes_destroy( & ip_netif->routes );
free( ip_netif );
return ERROR_CODE;
215,7 → 215,7
printf( "\tdns2\t= %s\n", data );
free( data );
}
rwlock_write_unlock( & ip_globals.netifs_lock );
fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
return EOK;
}
 
333,16 → 333,16
*/
ip_netif_ref netif;
 
rwlock_write_lock( & ip_globals.netifs_lock );
fibril_rwlock_write_lock( & ip_globals.netifs_lock );
netif = ip_netifs_find( & ip_globals.netifs, device_id );
if( ! netif ){
rwlock_write_unlock( & ip_globals.netifs_lock );
fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
return ENOENT;
}
netif->state = state;
// TODO state
printf( "ip - device %d changed state to %d\n\n", device_id, state );
rwlock_write_unlock( & ip_globals.netifs_lock );
fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
// if( netif->arp ){
/* address.value = ( char * ) & ip_globals.gateway.gateway.s_addr;
address.length = CONVERT_SIZE( ip_globals.gateway.gateway.s_addr, char, 1 );
406,15 → 406,15
proto->service = service;
proto->phone = phone;
proto->received_msg = received_msg;
rwlock_write_lock( & ip_globals.protos_lock );
fibril_rwlock_write_lock( & ip_globals.protos_lock );
index = ip_protos_add( & ip_globals.protos, proto->protocol, proto );
if( index < 0 ){
rwlock_write_unlock( & ip_globals.protos_lock );
fibril_rwlock_write_unlock( & ip_globals.protos_lock );
free( proto );
return index;
}
printf( "New protocol registered:\n\tprotocol\t= %d\n\tphone\t= %d\n", proto->protocol, proto->phone );
rwlock_write_unlock( & ip_globals.protos_lock );
fibril_rwlock_write_unlock( & ip_globals.protos_lock );
return EOK;
}
 
439,7 → 439,7
pq_release( ip_globals.net_phone, packet_get_id( packet ));
return EINVAL;
}
rwlock_read_lock( & ip_globals.netifs_lock );
fibril_rwlock_read_lock( & ip_globals.netifs_lock );
// device specified?
// dest.s_addr = ntohl( dest.s_addr );
if( device_id > 0 ){
451,7 → 451,7
netif = route ? route->netif : NULL;
}
if( !( netif && route )){
rwlock_read_unlock( & ip_globals.netifs_lock );
fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
pq_release( ip_globals.net_phone, packet_get_id( packet ));
return ENOENT;
}
458,13 → 458,13
// to me?
if( route->address.s_addr == dest->s_addr ){
// TODO loopback deliver
rwlock_read_unlock( & ip_globals.netifs_lock );
fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
return ip_deliver_local( -1, packet, ( ip_header_ref ) packet_get_data( packet ));
}
 
src = ip_netif_addr( netif );
if( ! src ){
rwlock_read_unlock( & ip_globals.netifs_lock );
fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
pq_release( ip_globals.net_phone, packet_get_id( packet ));
return ENOENT;
}
471,7 → 471,7
if( ERROR_OCCURRED( ip_send_route( packet, netif, route, src, * dest ))){
pq_release( ip_globals.net_phone, packet_get_id( packet ));
}
rwlock_read_unlock( & ip_globals.netifs_lock );
fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
return ERROR_CODE;
}
 
496,7 → 496,7
destination.value = route->gateway.s_addr ? ( char * ) & route->gateway.s_addr : ( char * ) & dest.s_addr;
destination.length = CONVERT_SIZE( dest.s_addr, char, 1 );
if( ERROR_OCCURRED( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & destination, & translation, & data ))){
usleep( 200000 );
sleep( 1 );
ERROR_PROPAGATE( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & destination, & translation, & data ));
}
// TODO unreachable
552,10 → 552,10
header->fragment_offset = 0;
if( source ) header->source_address = source->s_addr;
header->destination_address = dest.s_addr;
rwlock_write_lock( & ip_globals.lock );
fibril_rwlock_write_lock( & ip_globals.lock );
++ ip_globals.packet_counter;
header->identification = htons( ip_globals.packet_counter );
rwlock_write_unlock( & ip_globals.lock );
fibril_rwlock_write_unlock( & ip_globals.lock );
header->header_checksum = 0;
// unnecessary for all protocols
header->header_checksum = IP_HEADER_CHECKSUM( header );
603,7 → 603,7
 
if( !( addr_len && prefix && content && suffix )) return EBADMEM;
* content = IP_MAX_CONTENT - IP_PREFIX;
rwlock_read_lock( & ip_globals.netifs_lock );
fibril_rwlock_read_lock( & ip_globals.netifs_lock );
if( device_id < 0 ){
* addr_len = IP_ADDR;
* prefix = 0;
621,7 → 621,7
}else{
netif = ip_netifs_find( & ip_globals.netifs, device_id );
if( ! netif ){
rwlock_read_unlock( & ip_globals.netifs_lock );
fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
return ENOENT;
}
* addr_len = ( netif->addr_len > IP_ADDR ) ? netif->addr_len : IP_ADDR;
628,7 → 628,7
* prefix = netif->prefix + IP_PREFIX;
* suffix = netif->suffix + IP_SUFFIX;
}
rwlock_read_unlock( & ip_globals.netifs_lock );
fibril_rwlock_read_unlock( & ip_globals.netifs_lock );
return EOK;
}
 
637,15 → 637,15
ip_netif_ref netif;
int index;
 
rwlock_write_lock( & ip_globals.netifs_lock );
fibril_rwlock_write_lock( & ip_globals.netifs_lock );
netif = ip_netifs_find( & ip_globals.netifs, device_id );
if( ! netif ){
rwlock_write_unlock( & ip_globals.netifs_lock );
fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
return ENOENT;
}
route = ( ip_route_ref ) malloc( sizeof( ip_route_t ));
if( ! route ){
rwlock_write_unlock( & ip_globals.netifs_lock );
fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
return ENOMEM;
}
route->address.s_addr = address.s_addr;
654,7 → 654,7
route->netif = netif;
index = ip_routes_add( & netif->routes, route );
if( index < 0 ) free( route );
rwlock_write_unlock( & ip_globals.netifs_lock );
fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
return index;
}
 
695,10 → 695,10
int ip_set_gateway_req( int ip_phone, device_id_t device_id, in_addr_t gateway ){
ip_netif_ref netif;
 
rwlock_write_lock( & ip_globals.netifs_lock );
fibril_rwlock_write_lock( & ip_globals.netifs_lock );
netif = ip_netifs_find( & ip_globals.netifs, device_id );
if( ! netif ){
rwlock_write_unlock( & ip_globals.netifs_lock );
fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
return ENOENT;
}
ip_globals.gateway.address.s_addr = 0;
705,7 → 705,7
ip_globals.gateway.netmask.s_addr = 0;
ip_globals.gateway.gateway.s_addr = gateway.s_addr;
ip_globals.gateway.netif = netif;
rwlock_write_unlock( & ip_globals.netifs_lock );
fibril_rwlock_write_unlock( & ip_globals.netifs_lock );
return EOK;
}
 
915,10 → 915,10
return ENOTSUP;
}else{
ERROR_PROPAGATE( packet_set_addr( packet, ( uint8_t * ) & header->source_address, ( uint8_t * ) & header->destination_address, IP_ADDR ));
rwlock_read_lock( & ip_globals.protos_lock );
fibril_rwlock_read_lock( & ip_globals.protos_lock );
proto = ip_protos_find( & ip_globals.protos, header->protocol );
if( ! proto ){
rwlock_read_unlock( & ip_globals.protos_lock );
fibril_rwlock_read_unlock( & ip_globals.protos_lock );
return ENOENT;
}
if( proto->received_msg ){
926,7 → 926,7
}else{
ERROR_CODE = tl_received_msg( proto->phone, device_id, packet, proto->service );
}
rwlock_read_unlock( & ip_globals.protos_lock );
fibril_rwlock_read_unlock( & ip_globals.protos_lock );
return ERROR_CODE;
}
}
/branches/network/uspace/srv/net/il/ip/ip.h
37,7 → 37,7
#ifndef __NET_IP_H__
#define __NET_IP_H__
 
#include <rwlock.h>
#include <fibril_sync.h>
 
#include <ipc/ipc.h>
#include <ipc/services.h>
111,14 → 111,14
struct ip_globals{
int net_phone;
ip_netifs_t netifs;
rwlock_t netifs_lock;
fibril_rwlock_t netifs_lock;
ip_protos_t protos;
rwlock_t protos_lock;
fibril_rwlock_t protos_lock;
ip_route_t gateway;
modules_t modules;
async_client_conn_t client_connection;
uint16_t packet_counter;
rwlock_t lock;
fibril_rwlock_t lock;
};
 
#endif