/branches/network/contrib/conf/qemu.sh |
---|
1,4 → 1,3 |
#!/bin/sh |
#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 |
qemu $@ -std-vga -no-kqemu -M isapc -net nic,model=ne2k_isa -net user -boot d -cdrom image.iso |
/branches/network/uspace/srv/net/net/net_standalone.c |
---|
103,8 → 103,6 |
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,7 → 135,6 |
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/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\tproto\t= %d\n", device->device_id, device->hardware, device->service, protocol ); |
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 ); |
} |
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->protocol_length )){ |
if( proto->addr->length != CONVERT_SIZE( uint8_t, char, header->hardware_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, device->addr->value, device->addr_len ); |
memcpy( src_hw, des_hw, header->hardware_length ); |
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", configuration[ 1 ].length ); |
ip_netif->dhcp = ! str_lcmp( configuration[ 1 ].value, "dhcp", 4 ); |
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,9 → 775,8 |
} |
isr = inb_reg0(dep, DP_ISR); |
} |
// if ((dep->de_flags & (DEF_READING|DEF_STOPPED)) == |
// (DEF_READING|DEF_STOPPED)) |
if ((dep->de_flags & DEF_STOPPED) == DEF_STOPPED ) |
if ((dep->de_flags & (DEF_READING|DEF_STOPPED)) == |
(DEF_READING|DEF_STOPPED)) |
{ |
/* The chip is stopped, and all arrived packets are |
* delivered. |
978,8 → 977,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; |
1009,7 → 1008,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,35 → 148,42 |
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 )); |
dp_check_ints( dep, IPC_GET_ISR( call )); |
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 )); |
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 ){ |
241,6 → 248,7 |
} |
packet = next; |
}while( packet ); |
dp8390_dump( dep ); |
return EOK; |
} |
/branches/network/uspace/srv/net/nil/eth/eth.c |
---|
54,7 → 54,6 |
#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" |
70,31 → 69,9 |
#define ETH_SUFFIX sizeof( eth_fcs_t ) |
#define ETH_MAX_CONTENT 1500 |
#define ETH_MIN_CONTENT 46 |
#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_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_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; |
123,8 → 100,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 flags, packet_t packet ); |
int eth_prepare_packet( int flags, packet_t packet, uint8_t * src_addr, int ethertype ); |
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 ); |
int nil_device_state_msg( int nil_phone, device_id_t device_id, int state ){ |
int index; |
165,10 → 142,6 |
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? |
189,29 → 162,9 |
if( ! device ) return ENOMEM; |
device->device_id = device_id; |
device->service = service; |
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; |
} |
device->mtu = (( mtu > 0 ) && ( mtu <= ETH_MAX_TAGGED_CONTENT )) ? mtu : ETH_MAX_TAGGED_CONTENT; |
// TODO get dummy setting |
device->dummy = 0; |
// bind the device driver |
device->phone = netif_bind_service( device->service, device->device_id, SERVICE_ETHERNET, eth_receiver ); |
if( device->phone < 0 ){ |
234,13 → 187,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\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 ); |
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 ] ); |
} |
rwlock_write_unlock( & eth_globals.devices_lock ); |
return EOK; |
} |
eth_proto_ref eth_process_packet( int flags, packet_t packet ){ |
eth_proto_ref eth_process_packet( int dummy, packet_t packet ){ |
ERROR_DECLARE; |
eth_header_ex_ref header; |
251,17 → 204,17 |
eth_fcs_ref fcs; |
length = packet_get_data_length( packet ); |
if( IS_DUMMY( flags )){ |
if( dummy ){ |
packet_trim( packet, sizeof( eth_preamble_t ), 0 ); |
} |
if( length < sizeof( eth_header_t ) + ETH_MIN_CONTENT + ( IS_DUMMY( flags ) ? ETH_SUFFIX : 0 )) return NULL; |
if( length <= sizeof( eth_header_t ) + ETH_MIN_CONTENT + ETH_SUFFIX ) 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 = 0; |
fcs = (( void * ) header ) + length - sizeof( eth_fcs_t ); |
suffix = sizeof( eth_fcs_t ); |
fcs = (( void * ) header ) + length - suffix; |
}else if( type <= ETH_MAX_CONTENT ){ |
// translate "LSAP" values |
if(( header->lsap.dsap == ETH_LSAP_GLSAP ) && ( header->lsap.ssap == ETH_LSAP_GLSAP )){ |
285,11 → 238,10 |
// invalid length/type, should not occurr |
return NULL; |
} |
if( IS_DUMMY( flags )){ |
if( dummy ){ |
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 ))){ |
302,7 → 254,7 |
eth_proto_ref proto; |
packet_t next; |
eth_device_ref device; |
int flags; |
int dummy; |
rwlock_read_lock( & eth_globals.devices_lock ); |
device = eth_devices_find( & eth_globals.devices, device_id ); |
310,12 → 262,12 |
rwlock_read_unlock( & eth_globals.devices_lock ); |
return ENOENT; |
} |
flags = device->flags; |
dummy = device->dummy; |
rwlock_read_unlock( & eth_globals.devices_lock ); |
rwlock_read_lock( & eth_globals.protos_lock ); |
do{ |
next = pq_detach( packet ); |
proto = eth_process_packet( flags, packet ); |
proto = eth_process_packet( dummy, packet ); |
if( proto ){ |
il_received_msg( proto->phone, device_id, packet, proto->service ); |
}else{ |
399,9 → 351,8 |
return EOK; |
} |
int eth_prepare_packet( int flags, packet_t packet, uint8_t * src_addr, int ethertype ){ |
int eth_prepare_packet( int dummy, 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; |
410,30 → 361,19 |
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( flags )) return EINVAL; |
if( length < ETH_MIN_TAGGED_CONTENT( flags )){ |
padding = packet_suffix( packet, ETH_MIN_TAGGED_CONTENT( flags ) - length ); |
if( length > ETH_MAX_TAGGED_CONTENT ) return EINVAL; |
if( length < ETH_MIN_TAGGED_CONTENT ){ |
padding = packet_suffix( packet, ETH_MIN_TAGGED_CONTENT - length ); |
if( ! padding ) return ENOMEM; |
bzero( padding, ETH_MIN_TAGGED_CONTENT( flags ) - length ); |
bzero( padding, ETH_MIN_TAGGED_CONTENT - length ); |
} |
if( IS_DUMMY( flags )){ |
if( dummy ){ |
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; |
} |
// 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 )); |
442,14 → 382,15 |
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 ); |
src = & header->header.dest[ 0 ]; |
} |
if( IS_DUMMY( flags )){ |
if( dummy ){ |
fcs = PACKET_SUFFIX( packet, eth_fcs_t ); |
if( ! fcs ) return ENOMEM; |
* fcs = htonl( ~ compute_crc32( ~ 0, src, ((( void * ) fcs ) - (( void * ) src )) * 8 )); |
* fcs = htonl( ~ compute_crc32( ~ 0, & header->header.dest, ((( void * ) fcs ) - (( void * ) & header->header.dest )) * 8 )); |
} |
return EOK; |
} |
476,7 → 417,7 |
// process packet queue |
next = packet; |
do{ |
if( ERROR_OCCURRED( eth_prepare_packet( device->flags, next, ( uint8_t * ) device->addr->value, ethertype ))){ |
if( ERROR_OCCURRED( eth_prepare_packet( device->dummy, next, ( uint8_t * ) device->addr->value, ethertype ))){ |
// release invalid packet |
tmp = pq_detach( next ); |
pq_release( eth_globals.net_phone, packet_get_id( next )); |
529,7 → 470,6 |
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,11 → 95,10 |
/** Maximal transmission unit. |
*/ |
size_t mtu; |
/** Various device flags. |
* @see ETH_DUMMY |
* @see ETH_MODE_MASK |
/** Dummy device. |
* Preamble and FCS are mandatory part of the packets. |
*/ |
int flags; |
int dummy; |
/** Actual device hardware address. |
*/ |
measured_string_ref addr; |
/branches/network/uspace/srv/net/structures/char_map.c |
---|
81,8 → 81,9 |
for( index = 0; index < map->next; ++ index ){ |
if( map->items[ index ]->c == * identifier ){ |
++ identifier; |
if(( length > 1 ) || (( length == 0 ) && ( * identifier ))){ |
return char_map_add( map->items[ index ], identifier, length ? length - 1 : 0, value ); |
if( length ) -- length; |
if( length || ( * identifier )){ |
return char_map_add( map->items[ index ], identifier, length, value ); |
}else{ |
if( map->items[ index ]->value != CHAR_MAP_NULL ) return EEXISTS; |
map->items[ index ]->value = value; |
113,10 → 114,11 |
} |
map->items[ map->next ]->c = * identifier; |
++ identifier; |
if( length ) -- length; |
++ map->next; |
if(( length > 1 ) || (( length == 0 ) && ( * identifier ))){ |
if( length || ( * identifier )){ |
map->items[ map->next - 1 ]->value = CHAR_MAP_NULL; |
return char_map_add_item( map->items[ map->next - 1 ], identifier, length ? length - 1 : 0, value ); |
return char_map_add_item( map->items[ map->next - 1 ], identifier, length, value ); |
}else{ |
map->items[ map->next - 1 ]->value = value; |
} |
159,6 → 161,7 |
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; |
165,8 → 168,7 |
for( index = 0; index < map->next; ++ index ){ |
if( map->items[ index ]->c == * identifier ){ |
++ identifier; |
if( length == 1 ) return map->items[ index ]; |
return char_map_find_node( map->items[ index ], identifier, length ? length - 1 : 0 ); |
return char_map_find_node( map->items[ index ], identifier, length ); |
} |
} |
return NULL; |
/branches/network/uspace/srv/net/Makefile.module |
---|
47,7 → 47,7 |
.PHONY: all clean depend disasm |
all: $(OUTPUT) $(DISASMS) |
all: $(OUTPUT) $(DISAMS) |
check: |
$(CC) $(DEFS) $(CFLAGS) $(CHECK_CFLAGS) *.c |
65,7 → 65,7 |
disasm: $(DISASMS) |
%.disasm: % |
%.disasm: $@ |
$(OBJDUMP) -d $< >$@ |
%.o: %.S |
/branches/network/uspace/srv/net/self_test.c |
---|
130,11 → 130,6 |
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 ); |