Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 4328 → Rev 4332

/branches/network/contrib/conf/qemu.sh
1,3 → 1,4
#!/bin/sh
 
qemu $@ -std-vga -no-kqemu -M isapc -net nic,model=ne2k_isa -net user -boot d -cdrom image.iso
#qemu 0.10.2 only (NOT qemu 0.9.1!)
qemu $@ -vga std -no-kqemu -M isapc -net nic,model=ne2k_isa -net user -boot d -cdrom image.iso -redir tcp:8080:10.0.2.15:8080
/branches/network/uspace/srv/net/nil/eth/eth.c
54,6 → 54,7
#include "../../include/protocol_map.h"
#include "../../include/device.h"
#include "../../include/netif_interface.h"
#include "../../include/net_interface.h"
#include "../../include/nil_interface.h"
#include "../../include/il_interface.h"
 
69,9 → 70,31
#define ETH_SUFFIX sizeof( eth_fcs_t )
#define ETH_MAX_CONTENT 1500
#define ETH_MIN_CONTENT 46
#define ETH_MAX_TAGGED_CONTENT ( ETH_MAX_CONTENT - sizeof( eth_header_lsap_t ) - sizeof( eth_header_snap_t ))
#define ETH_MIN_TAGGED_CONTENT ( ETH_MIN_CONTENT - sizeof( eth_header_lsap_t ) - sizeof( eth_header_snap_t ))
#define ETH_MAX_TAGGED_CONTENT( flags ) ( ETH_MAX_CONTENT - (( IS_8023_2_LSAP( flags ) || IS_8023_2_SNAP( flags )) ? sizeof( eth_header_lsap_t ) : 0 ) - ( IS_8023_2_SNAP( flags ) ? sizeof( eth_header_snap_t ) : 0 ))
#define ETH_MIN_TAGGED_CONTENT( flags ) ( ETH_MIN_CONTENT - (( IS_8023_2_LSAP( flags ) || IS_8023_2_SNAP( flags )) ? sizeof( eth_header_lsap_t ) : 0 ) - ( IS_8023_2_SNAP( flags ) ? sizeof( eth_header_snap_t ) : 0 ))
 
#define ETH_DUMMY_SHIFT 0
#define ETH_MODE_SHIFT 1
 
/** Dummy device flag.
* Preamble and FCS are mandatory part of the packets.
*/
#define ETH_DUMMY ( 1 << ETH_DUMMY_SHIFT )
#define IS_DUMMY( flags ) (( flags ) & ETH_DUMMY )
 
/** Device mode flags.
* @see ETH_DIX
* @see ETH_8023_2_LSAP
* @see ETH_8023_2_SNAP
*/
#define ETH_MODE_MASK ( 3 << ETH_MODE_SHIFT )
#define ETH_DIX ( 1 << ETH_MODE_SHIFT )
#define IS_DIX( flags ) ((( flags ) & ETH_MODE_MASK ) == ETH_DIX )
#define ETH_8023_2_LSAP ( 2 << ETH_MODE_SHIFT )
#define IS_8023_2_LSAP( flags ) ((( flags ) & ETH_MODE_MASK ) == ETH_8023_2_LSAP )
#define ETH_8023_2_SNAP ( 3 << ETH_MODE_SHIFT )
#define IS_8023_2_SNAP( flags ) ((( flags ) & ETH_MODE_MASK ) == ETH_8023_2_SNAP )
 
typedef enum eth_addr_type eth_addr_type_t;
typedef eth_addr_type_t * eth_addr_type_ref;
 
100,8 → 123,8
int eth_packet_space_message( device_id_t device_id, size_t * addr_len, size_t * prefix, size_t * content, size_t * suffix );
int eth_addr_message( device_id_t device_id, eth_addr_type_t type, measured_string_ref * address );
int eth_send_message( device_id_t device_id, packet_t packet, services_t sender );
eth_proto_ref eth_process_packet( int dummy, packet_t packet );
int eth_prepare_packet( int dummy, packet_t packet, uint8_t * src_addr, int ethertype );
eth_proto_ref eth_process_packet( int flags, packet_t packet );
int eth_prepare_packet( int flags, packet_t packet, uint8_t * src_addr, int ethertype );
 
int nil_device_state_msg( int nil_phone, device_id_t device_id, int state ){
int index;
142,6 → 165,10
 
eth_device_ref device;
int index;
measured_string_t names[ 2 ] = {{ "ETH_MODE", 8 }, { "ETH_DUMMY", 9 }};
measured_string_ref configuration;
int count = 2;
char * data;
 
rwlock_write_lock( & eth_globals.devices_lock );
// an existing device?
162,9 → 189,29
if( ! device ) return ENOMEM;
device->device_id = device_id;
device->service = service;
device->mtu = (( mtu > 0 ) && ( mtu <= ETH_MAX_TAGGED_CONTENT )) ? mtu : ETH_MAX_TAGGED_CONTENT;
// TODO get dummy setting
device->dummy = 0;
device->flags = 0;
device->mtu = (( mtu > 0 ) && ( mtu <= ETH_MAX_TAGGED_CONTENT( device->flags ))) ? mtu : ETH_MAX_TAGGED_CONTENT( device->flags );
configuration = & names[ 0 ];
if( ERROR_OCCURRED( net_get_device_conf_req( eth_globals.net_phone, device->device_id, & configuration, count, & data ))){
rwlock_write_unlock( & eth_globals.devices_lock );
free( device );
return ERROR_CODE;
}
if( configuration ){
if( ! str_lcmp( configuration[ 0 ].value, "DIX", configuration[ 0 ].length )){
device->flags |= ETH_DIX;
}else if( ! str_lcmp( configuration[ 0 ].value, "8023_2_LSAP", configuration[ 0 ].length )){
// TODO 8023_2_LSAP
printf( "8023_2_LSAP is not supported (yet?), DIX used instead\n" );
device->flags |= ETH_DIX;
}else device->flags |= ETH_8023_2_SNAP;
if(( configuration[ 1 ].value ) && ( configuration[ 1 ].value[ 0 ] == 'y' )){
device->flags |= ETH_DUMMY;
}
net_free_settings( configuration, data );
}else{
device->flags |= ETH_8023_2_SNAP;
}
// bind the device driver
device->phone = netif_bind_service( device->service, device->device_id, SERVICE_ETHERNET, eth_receiver );
if( device->phone < 0 ){
187,13 → 234,13
free( device );
return index;
}
printf( "New device registered:\n\tid\t= %d\n\tservice\t= %d\n\tMTU\t= %d\n\taddress\t= %X:%X:%X:%X:%X:%X\n", device->device_id, device->service, device->mtu, device->addr_data[ 0 ], device->addr_data[ 1 ], device->addr_data[ 2 ], device->addr_data[ 3 ], device->addr_data[ 4 ], device->addr_data[ 5 ] );
printf( "New device registered:\n\tid\t= %d\n\tservice\t= %d\n\tMTU\t= %d\n\taddress\t= %X:%X:%X:%X:%X:%X\n\tflags\t= 0x%x\n", device->device_id, device->service, device->mtu, device->addr_data[ 0 ], device->addr_data[ 1 ], device->addr_data[ 2 ], device->addr_data[ 3 ], device->addr_data[ 4 ], device->addr_data[ 5 ], device->flags );
}
rwlock_write_unlock( & eth_globals.devices_lock );
return EOK;
}
 
eth_proto_ref eth_process_packet( int dummy, packet_t packet ){
eth_proto_ref eth_process_packet( int flags, packet_t packet ){
ERROR_DECLARE;
 
eth_header_ex_ref header;
204,17 → 251,17
eth_fcs_ref fcs;
 
length = packet_get_data_length( packet );
if( dummy ){
if( IS_DUMMY( flags )){
packet_trim( packet, sizeof( eth_preamble_t ), 0 );
}
if( length <= sizeof( eth_header_t ) + ETH_MIN_CONTENT + ETH_SUFFIX ) return NULL;
if( length < sizeof( eth_header_t ) + ETH_MIN_CONTENT + ( IS_DUMMY( flags ) ? ETH_SUFFIX : 0 )) return NULL;
header = ( eth_header_ex_ref ) packet_get_data( packet );
type = ntohs( header->header.ethertype );
if( type >= ETH_MIN_PROTO ){
// DIX Ethernet
prefix = sizeof( eth_header_t );
suffix = sizeof( eth_fcs_t );
fcs = (( void * ) header ) + length - suffix;
suffix = 0;
fcs = (( void * ) header ) + length - sizeof( eth_fcs_t );
}else if( type <= ETH_MAX_CONTENT ){
// translate "LSAP" values
if(( header->lsap.dsap == ETH_LSAP_GLSAP ) && ( header->lsap.ssap == ETH_LSAP_GLSAP )){
238,10 → 285,11
// invalid length/type, should not occurr
return NULL;
}
if( dummy ){
if( IS_DUMMY( flags )){
if(( ~ compute_crc32( ~ 0, & header->header.dest, ((( void * ) fcs ) - (( void * ) & header->header.dest )) * 8 )) != ntohl( * fcs )){
return NULL;
}
suffix += sizeof( eth_fcs_t );
}
if( ERROR_OCCURRED( packet_set_addr( packet, header->header.src, header->header.dest, ETH_ADDR ))
|| ERROR_OCCURRED( packet_trim( packet, prefix, suffix ))){
254,7 → 302,7
eth_proto_ref proto;
packet_t next;
eth_device_ref device;
int dummy;
int flags;
 
rwlock_read_lock( & eth_globals.devices_lock );
device = eth_devices_find( & eth_globals.devices, device_id );
262,12 → 310,12
rwlock_read_unlock( & eth_globals.devices_lock );
return ENOENT;
}
dummy = device->dummy;
flags = device->flags;
rwlock_read_unlock( & eth_globals.devices_lock );
rwlock_read_lock( & eth_globals.protos_lock );
do{
next = pq_detach( packet );
proto = eth_process_packet( dummy, packet );
proto = eth_process_packet( flags, packet );
if( proto ){
il_received_msg( proto->phone, device_id, packet, proto->service );
}else{
351,8 → 399,9
return EOK;
}
 
int eth_prepare_packet( int dummy, packet_t packet, uint8_t * src_addr, int ethertype ){
int eth_prepare_packet( int flags, packet_t packet, uint8_t * src_addr, int ethertype ){
eth_header_ex_ref header;
eth_header_ref header_dix;
eth_fcs_ref fcs;
uint8_t * src;
uint8_t * dest;
361,36 → 410,46
void * padding;
eth_preamble_ref preamble;
 
length = packet_get_addr( packet, & src, & dest );
if( length < 0 ) return length;
if( length < ETH_ADDR ) return EINVAL;
length = packet_get_data_length( packet );
if( length > ETH_MAX_TAGGED_CONTENT ) return EINVAL;
if( length < ETH_MIN_TAGGED_CONTENT ){
padding = packet_suffix( packet, ETH_MIN_TAGGED_CONTENT - length );
if( length > ETH_MAX_TAGGED_CONTENT( flags )) return EINVAL;
if( length < ETH_MIN_TAGGED_CONTENT( flags )){
padding = packet_suffix( packet, ETH_MIN_TAGGED_CONTENT( flags ) - length );
if( ! padding ) return ENOMEM;
bzero( padding, ETH_MIN_TAGGED_CONTENT - length );
bzero( padding, ETH_MIN_TAGGED_CONTENT( flags ) - length );
}
if( dummy ){
if( IS_DUMMY( flags )){
preamble = PACKET_PREFIX( packet, eth_preamble_t );
if( ! preamble ) return ENOMEM;
for( i = 0; i < 7; ++ i ) preamble->preamble[ i ] = ETH_PREAMBLE;
preamble->sfd = ETH_SFD;
}
header = PACKET_PREFIX( packet, eth_header_ex_t );
if( ! header ) return ENOMEM;
header->header.ethertype = htons( length + sizeof( eth_header_lsap_t ) + sizeof( eth_header_snap_t ));
header->lsap.dsap = ( uint16_t ) ETH_LSAP_SNAP;
header->lsap.ssap = header->lsap.dsap;
header->lsap.ctrl = 0;
for( i = 0; i < 3; ++ i ) header->snap.proto[ i ] = 0;
header->snap.ethertype = ( uint16_t ) ethertype;
length = packet_get_addr( packet, & src, & dest );
if( length < 0 ) return length;
if( length < ETH_ADDR ) return EINVAL;
memcpy( header->header.src, src_addr, ETH_ADDR );
memcpy( header->header.dest, dest, ETH_ADDR );
if( dummy ){
// TODO LSAP only device
if( IS_DIX( flags ) || IS_8023_2_LSAP( flags )){
header_dix = PACKET_PREFIX( packet, eth_header_t );
header_dix->ethertype = ( uint16_t ) ethertype;
memcpy( header_dix->src, src_addr, ETH_ADDR );
memcpy( header_dix->dest, dest, ETH_ADDR );
src = & header_dix->dest[ 0 ];
}else if( IS_8023_2_SNAP( flags )){
header = PACKET_PREFIX( packet, eth_header_ex_t );
if( ! header ) return ENOMEM;
header->header.ethertype = htons( length + sizeof( eth_header_lsap_t ) + sizeof( eth_header_snap_t ));
header->lsap.dsap = ( uint16_t ) ETH_LSAP_SNAP;
header->lsap.ssap = header->lsap.dsap;
header->lsap.ctrl = 0;
for( i = 0; i < 3; ++ i ) header->snap.proto[ i ] = 0;
header->snap.ethertype = ( uint16_t ) ethertype;
memcpy( header->header.src, src_addr, ETH_ADDR );
memcpy( header->header.dest, dest, ETH_ADDR );
src = & header->header.dest[ 0 ];
}
if( IS_DUMMY( flags )){
fcs = PACKET_SUFFIX( packet, eth_fcs_t );
if( ! fcs ) return ENOMEM;
* fcs = htonl( ~ compute_crc32( ~ 0, & header->header.dest, ((( void * ) fcs ) - (( void * ) & header->header.dest )) * 8 ));
* fcs = htonl( ~ compute_crc32( ~ 0, src, ((( void * ) fcs ) - (( void * ) src )) * 8 ));
}
return EOK;
}
417,7 → 476,7
// process packet queue
next = packet;
do{
if( ERROR_OCCURRED( eth_prepare_packet( device->dummy, next, ( uint8_t * ) device->addr->value, ethertype ))){
if( ERROR_OCCURRED( eth_prepare_packet( device->flags, next, ( uint8_t * ) device->addr->value, ethertype ))){
// release invalid packet
tmp = pq_detach( next );
pq_release( eth_globals.net_phone, packet_get_id( next ));
470,6 → 529,7
packet_t packet;
 
while( true ){
// printf( "message %d - %d\n", IPC_GET_METHOD( * icall ), NET_NIL_FIRST );
switch( IPC_GET_METHOD( * icall )){
case NET_NIL_DEVICE_STATE:
nil_device_state_msg( 0, IPC_GET_DEVICE( icall ), IPC_GET_STATE( icall ));
/branches/network/uspace/srv/net/nil/eth/eth.h
95,10 → 95,11
/** Maximal transmission unit.
*/
size_t mtu;
/** Dummy device.
* Preamble and FCS are mandatory part of the packets.
/** Various device flags.
* @see ETH_DUMMY
* @see ETH_MODE_MASK
*/
int dummy;
int flags;
/** Actual device hardware address.
*/
measured_string_ref addr;
/branches/network/uspace/srv/net/structures/char_map.c
81,9 → 81,8
for( index = 0; index < map->next; ++ index ){
if( map->items[ index ]->c == * identifier ){
++ identifier;
if( length ) -- length;
if( length || ( * identifier )){
return char_map_add( map->items[ index ], identifier, length, value );
if(( length > 1 ) || (( length == 0 ) && ( * identifier ))){
return char_map_add( map->items[ index ], identifier, length ? length - 1 : 0, value );
}else{
if( map->items[ index ]->value != CHAR_MAP_NULL ) return EEXISTS;
map->items[ index ]->value = value;
114,11 → 113,10
}
map->items[ map->next ]->c = * identifier;
++ identifier;
if( length ) -- length;
++ map->next;
if( length || ( * identifier )){
if(( length > 1 ) || (( length == 0 ) && ( * identifier ))){
map->items[ map->next - 1 ]->value = CHAR_MAP_NULL;
return char_map_add_item( map->items[ map->next - 1 ], identifier, length, value );
return char_map_add_item( map->items[ map->next - 1 ], identifier, length ? length - 1 : 0, value );
}else{
map->items[ map->next - 1 ]->value = value;
}
161,7 → 159,6
 
char_map_ref char_map_find_node( const char_map_ref map, const char * identifier, size_t length ){
if( ! char_map_is_valid( map )) return NULL;
if( length ) -- length;
if( length || ( * identifier )){
int index;
 
168,7 → 165,8
for( index = 0; index < map->next; ++ index ){
if( map->items[ index ]->c == * identifier ){
++ identifier;
return char_map_find_node( map->items[ index ], identifier, length );
if( length == 1 ) return map->items[ index ];
return char_map_find_node( map->items[ index ], identifier, length ? length - 1 : 0 );
}
}
return NULL;
/branches/network/uspace/srv/net/net/net_standalone.c
103,6 → 103,8
ERROR_PROPAGATE( add_configuration( & netif->configuration, "NETIF", DP8390_NAME ));
// standalone ethernet
ERROR_PROPAGATE( add_configuration( & netif->configuration, "NIL", ETHERNET_NAME ));
ERROR_PROPAGATE( add_configuration( & netif->configuration, "ETH_MODE", "DIX" )); //8023_2_LSAP( not supported ), 8023_2_SNAP
// ERROR_PROPAGATE( add_configuration( & netif->configuration, "ETH_DUMMY", "yes" )); //anything else not starting with 'y'
ERROR_PROPAGATE( add_configuration( & netif->configuration, "IL", IP_NAME ));
ERROR_PROPAGATE( add_configuration( & netif->configuration, "IRQ", "9" ));
ERROR_PROPAGATE( add_configuration( & netif->configuration, "IO", "300" ));
/branches/network/uspace/srv/net/net/net_bundle.c
135,6 → 135,7
ERROR_PROPAGATE( add_configuration( & netif->configuration, "NETIF", DP8390_NAME ));
// ethernet bundled in dp8390
ERROR_PROPAGATE( add_configuration( & netif->configuration, "NIL", DP8390_NAME ));
ERROR_PROPAGATE( add_configuration( & netif->configuration, "ETH_MODE", "DIX" ));
ERROR_PROPAGATE( add_configuration( & netif->configuration, "IL", IP_NAME ));
ERROR_PROPAGATE( add_configuration( & netif->configuration, "IRQ", "9" ));
ERROR_PROPAGATE( add_configuration( & netif->configuration, "IO", "300" ));
/branches/network/uspace/srv/net/Makefile.module
47,7 → 47,7
 
.PHONY: all clean depend disasm
 
all: $(OUTPUT) $(DISAMS)
all: $(OUTPUT) $(DISASMS)
 
check:
$(CC) $(DEFS) $(CFLAGS) $(CHECK_CFLAGS) *.c
65,7 → 65,7
 
disasm: $(DISASMS)
 
%.disasm: $@
%.disasm: %
$(OBJDUMP) -d $< >$@
 
%.o: %.S
/branches/network/uspace/srv/net/il/arp/arp.c
282,8 → 282,8
free( proto );
return index;
}
printf( "New protocol added:\n\tdevice id\t= %d\n\tproto\t= %d", device_id, protocol );
}
printf( "Cache of the existing device %d cleaned\n", device->device_id );
}else{
index = hardware_map( service );
if( ! index ) return ENOENT;
350,7 → 350,7
free( device );
return ERROR_CODE;
}
printf( "New device registered:\n\tid\t= %d\n\ttype\t= 0x%x\n\tservice\t= %d\n", device->device_id, device->hardware, device->service );
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 );
return EOK;
432,7 → 432,7
memcpy( hw_source->value, src_hw, hw_source->length );
}
// is my protocol address?
if( proto->addr->length != CONVERT_SIZE( uint8_t, char, header->hardware_length )){
if( proto->addr->length != CONVERT_SIZE( uint8_t, char, header->protocol_length )){
return EINVAL;
}
if( ! str_lcmp( proto->addr->value, ( char * ) des_proto, proto->addr->length )){
446,7 → 446,7
header->operation = htons( ARPOP_REPLY );
memcpy( des_proto, src_proto, header->protocol_length );
memcpy( src_proto, proto->addr->value, header->protocol_length );
memcpy( src_hw, des_hw, header->hardware_length );
memcpy( src_hw, device->addr->value, device->addr_len );
memcpy( des_hw, hw_source->value, header->hardware_length );
packet_set_addr( packet, src_hw, des_hw, header->hardware_length );
nil_send_msg( device->phone, device_id, packet, SERVICE_ARP );
/branches/network/uspace/srv/net/il/ip/ip.c
113,7 → 113,7
}else{
ip_netif->ipv = DEFAULT_IPV;
}
ip_netif->dhcp = ! str_lcmp( configuration[ 1 ].value, "dhcp", 4 );
ip_netif->dhcp = ! str_lcmp( configuration[ 1 ].value, "dhcp", configuration[ 1 ].length );
if( ip_netif->dhcp ){
// TODO dhcp
net_free_settings( configuration, data );
240,19 → 240,19
}
 
int ip_device_state_msg( int il_phone, device_id_t device_id, device_state_t state ){
ERROR_DECLARE;
// ERROR_DECLARE;
 
ip_netif_ref netif;
 
measured_string_t address;
/* measured_string_t address;
measured_string_ref translation;
char * data;
 
*/
netif = ip_netifs_find( & ip_globals.netifs, device_id );
if( ! netif ) return ENOENT;
// TODO state
printf( "ip - device %d changed state to %d\n\n", device_id, state );
if( netif->arp ){
/* if( netif->arp ){
address.value = ( char * ) & netif->gateway;
address.length = CONVERT_SIZE( in_addr_t, char, 1 );
if( ERROR_OCCURRED( arp_translate_req( netif->arp->phone, netif->device_id, SERVICE_IP, & address, & translation, & data ))){
263,7 → 263,7
free( translation );
free( data );
}
return EOK;
*/ return EOK;
}
 
int ip_bind_service( services_t service, services_t me, async_client_conn_t receiver ){
/branches/network/uspace/srv/net/netif/dp8390/dp8390.c
730,7 → 730,7
if (isr & ISR_PRX)
{
/* Only call dp_recv if there is a read request */
if (dep->de_flags & DEF_READING)
// if (dep->de_flags) & DEF_READING)
dp_recv(dep);
}
748,13 → 748,13
{ printW(); printf(
"%s: got overwrite warning\n", dep->de_name); }
#endif
if (dep->de_flags & DEF_READING)
/* if (dep->de_flags & DEF_READING)
{
printf(
"dp_check_ints: strange: overwrite warning and pending read request\n");
dp_recv(dep);
}
}
*/ }
if (isr & ISR_RDC)
{
/* Nothing to do */
775,8 → 775,9
}
isr = inb_reg0(dep, DP_ISR);
}
if ((dep->de_flags & (DEF_READING|DEF_STOPPED)) ==
(DEF_READING|DEF_STOPPED))
// if ((dep->de_flags & (DEF_READING|DEF_STOPPED)) ==
// (DEF_READING|DEF_STOPPED))
if ((dep->de_flags & DEF_STOPPED) == DEF_STOPPED )
{
/* The chip is stopped, and all arrived packets are
* delivered.
977,8 → 978,8
packet_t packet;
packet_t queue;
 
if (!(dep->de_flags & DEF_READING))
return EGENERIC;
// if (!(dep->de_flags & DEF_READING))
// return EGENERIC;
 
packet = netif_packet_get_1( length );
if( ! packet ) return ENOMEM;
1008,7 → 1009,7
 
dep->de_read_s = length;
dep->de_flags |= DEF_PACK_RECV;
dep->de_flags &= ~DEF_READING;
// dep->de_flags &= ~DEF_READING;
 
queue = pq_add( dep->received_queue, packet, 0, 0 );
if( queue ){
/branches/network/uspace/srv/net/netif/dp8390/dp8390_module.c
148,42 → 148,35
device_id_t device_id;
int phone;
 
// async_serialize_start();
device_id = IRQ_GET_DEVICE( call );
rwlock_write_lock( & netif_globals.lock );
if( find_device( device_id, & device ) != EOK ){
rwlock_write_unlock( & netif_globals.lock );
// async_serialize_end()
return;
}
dep = ( dpeth_t * ) device->specific;
if ( dep->de_mode != DEM_ENABLED){
rwlock_write_unlock( & netif_globals.lock );
// async_serialize_end()
return;
}
assert( dep->de_flags & DEF_ENABLED);
dep->de_int_pending= 0;
printf( "I%d -%d\n", device_id, IPC_GET_ISR( call ));
/* putchar( 'I' );
putchar( '0' + device_id );
putchar( '-' );
putchar( '0' + IPC_GET_ISR( call ) / 100 );
putchar( '0' + ( IPC_GET_ISR( call ) % 100 ) / 10 );
putchar( '0' + IPC_GET_ISR( call ) % 10 );
putchar( '\n' );
*/ dp_check_ints( dep, IPC_GET_ISR( call ));
printf( "I%d: %d\n", device_id, IPC_GET_ISR( call ));
dp_check_ints( dep, IPC_GET_ISR( call ));
if( dep->received_queue ){
received = dep->received_queue;
phone = device->nil_phone;
dep->received_queue = NULL;
rwlock_write_unlock( & netif_globals.lock );
// TODO remove debug dump:
uint8_t * data;
data = packet_get_data( received );
printf( "Receiving packet:\n\tid\t= %d\n\tlength\t= %d\n\tdata\t= %.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX\n\t\t%.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX:%.2hhX %.2hhX %.2hhX %.2hhX\n", packet_get_id( received ), packet_get_data_length( received ), data[ 0 ], data[ 1 ], data[ 2 ], data[ 3 ], data[ 4 ], data[ 5 ], data[ 6 ], data[ 7 ], data[ 8 ], data[ 9 ], data[ 10 ], data[ 11 ], data[ 12 ], data[ 13 ], data[ 14 ], data[ 15 ], data[ 16 ], data[ 17 ], data[ 18 ], data[ 19 ], data[ 20 ], data[ 21 ], data[ 22 ], data[ 23 ], data[ 24 ], data[ 25 ], data[ 26 ], data[ 27 ], data[ 28 ], data[ 29 ], data[ 30 ], data[ 31 ], data[ 32 ], data[ 33 ], data[ 34 ], data[ 35 ], data[ 36 ], data[ 37 ], data[ 38 ], data[ 39 ], data[ 40 ], data[ 41 ], data[ 42 ], data[ 43 ], data[ 44 ], data[ 45 ], data[ 46 ], data[ 47 ], data[ 48 ], data[ 49 ], data[ 50 ], data[ 51 ], data[ 52 ], data[ 53 ], data[ 54 ], data[ 55 ], data[ 56 ], data[ 57 ], data[ 58 ], data[ 59 ] );
nil_received_msg( phone, device_id, received, NULL );
}else{
rwlock_write_unlock( & netif_globals.lock );
}
ipc_answer_0( iid, EOK );
// async_serialize_end()
}
 
int netif_probe_auto_message( void ){
248,7 → 241,6
}
packet = next;
}while( packet );
dp8390_dump( dep );
return EOK;
}
 
/branches/network/uspace/srv/net/self_test.c
130,6 → 130,11
TEST( "add nic 9 eok", char_map_add( & cm, "nic", 0, 9 ), EOK );
TEST( "find nic 9", char_map_find( & cm, "nic", 0 ), 9 );
TEST( "find blabla 5", char_map_find( & cm, "blabla", 0 ), 5 );
TEST( "add micnicnic 5 9 eok", char_map_add( & cm, "micnicnic", 5, 9 ), EOK );
TEST( "find micni 9", char_map_find( & cm, "micni", 0 ), 9 );
TEST( "find micnicn 5 9", char_map_find( & cm, "micnicn", 5 ), 9 );
TEST( "add 10.0.2.2 4 15 eok", char_map_add( & cm, "\x10\x0\x2\x2", 4, 15 ), EOK );
TEST( "find 10.0.2.2 4 15", char_map_find( & cm, "\x10\x0\x2\x2", 4 ), 15 );
printf( "\n\tdestroy" );
char_map_destroy( & cm );
TEST( "update ucho 3 einval", char_map_update( & cm, "ucho", 0, 3 ), EINVAL );