Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4191 → Rev 4192

/branches/network/uspace/srv/net/netif/lo/lo.c
48,33 → 48,46
#include "../../structures/packet/packet_client.h"
 
#include "../netif.h"
#include "../netif_interface.h"
 
#define DEFAULT_MTU 1500
 
#define DEFAULT_ADDR "\0\0\0\0\0\0"
#define DEFAULT_ADDR_LEN ( sizeof( DEFAULT_ADDR ) / sizeof( char ))
 
#define NAME "lo - loopback interface"
 
netif_globals_t netif_globals;
 
static struct lo_globals{
measured_string_ref addr;
int mtu;
} lo_globals;
 
int change_state_message( device_id_t device_id, device_state_t state );
int create( device_id_t device_id, device_ref * device );
int initialize( void );
void netif_print_name( void );
int probe_auto_message( void );
int probe_message( device_id_t device_id, int irq, int io );
int send_message( device_id_t device_id, packet_t packet );
int start_message( device_id_t device_id );
int stop_message( device_id_t device_id );
measured_string_ref get_addr_message( device_id_t device_id );
 
measured_string_ref get_addr_message( device_id_t device_id ){
return lo_globals.addr;
int specific_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
return ENOTSUP;
}
 
int get_addr_message( device_id_t device_id, measured_string_ref address ){
if( ! address ) return EBADMEM;
address->value = DEFAULT_ADDR;
address->length = DEFAULT_ADDR_LEN;
}
 
int get_device_stats( device_id_t device_id, device_stats_ref stats ){
ERROR_DECLARE;
 
device_ref device;
 
if( ! stats ) return EBADMEM;
ERROR_PROPAGATE( find_device( device_id, & device ));
memcpy( stats, ( device_stats_ref ) device->specific, sizeof( device_stats_t ));
return EOK;
}
 
int change_state_message( device_id_t device_id, device_state_t state ){
ERROR_DECLARE;
 
90,7 → 103,7
}
 
int create( device_id_t device_id, device_ref * device ){
ERROR_DECLARE;
int index;
 
if( device_map_count( & netif_globals.device_map ) > 0 ){
return EXDEV;
97,15 → 110,21
}else{
* device = ( device_ref ) malloc( sizeof( device_t ));
if( !( * device )) return ENOMEM;
( ** device ).specific = malloc( sizeof( device_stats_t ));
if( ! ( ** device ).specific ){
free( * device );
return ENOMEM;
}
null_device_stats(( device_stats_ref )( ** device ).specific );
( ** device ).device_id = device_id;
( ** device ).nil_phone = -1;
( ** device ).specific = NULL;
null_device_stats( &(( ** device ).stats ));
( ** device ).state = NETIF_STOPPED;
if( ERROR_OCCURRED( device_map_add( & netif_globals.device_map, ( ** device ).device_id, * device ))){
index = device_map_add( & netif_globals.device_map, ( ** device ).device_id, * device );
if( index < 0 ){
free( * device );
free(( ** device ).specific );
* device = NULL;
return ERROR_CODE;
return index;
}
}
return EOK;
114,8 → 133,6
int initialize( void ){
ipcarg_t phonehash;
 
lo_globals.addr = measured_string_create_bulk( "\0\0\0\0\0\0", 0 );
if( ! lo_globals.addr ) return ENOMEM;
return REGISTER_ME( SERVICE_LO, & phonehash );
}
 
143,6 → 160,7
int count = 1;
measured_string_ref settings;
char * data;
ipcarg_t result;
 
// create a new device
ERROR_PROPAGATE( create( device_id, & device ));
154,16 → 172,23
async_wait_for( message, NULL );
return ERROR_CODE;
}
// end request
async_wait_for( message, & result );
if( ERROR_OCCURRED( result )){
if( settings ){
free( settings );
free( data );
}
return ERROR_CODE;
}
// MTU is the first one
if( settings && ( settings[ 0 ].value )){
lo_globals.mtu = strtoul( settings[ 0 ].value, NULL, 0 );
free( settings );
free( data );
}else{
lo_globals.mtu = DEFAULT_MTU;
}
free( settings );
free( data );
// end request
async_wait_for( message, NULL );
// print the settings
printf("\nNew device registered:\n\tid\t= %d\n\tMTU\t= %d", device->device_id, lo_globals.mtu );
return EOK;
180,11 → 205,11
if( device->state != NETIF_ACTIVE ) return EPERM;
next = packet;
do{
++ device->stats.tx_packets;
++ device->stats.rx_packets;
++ (( device_stats_ref ) device->specific )->tx_packets;
++ (( device_stats_ref ) device->specific )->rx_packets;
length = packet_get_data_length( next );
device->stats.tx_bytes += length;
device->stats.rx_bytes += length;
(( device_stats_ref ) device->specific )->tx_bytes += length;
(( device_stats_ref ) device->specific )->rx_bytes += length;
next = pq_next( next );
}while( next );
nil_message( device, NET_NIL_RECEIVED, packet_get_id( packet ), PACKET_SELF );