Changeset 7715994 in mainline for uspace/srv/net/nil/eth/eth.c


Ignore:
Timestamp:
2010-03-13T12:17:02Z (14 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
6ba20a6b
Parents:
d0febca (diff), 2070570 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/nil/eth/eth.c

    rd0febca r7715994  
    7070/** Reserved packet prefix length.
    7171 */
    72 #define ETH_PREFIX              ( sizeof( eth_header_t ) + sizeof( eth_header_lsap_t ) + sizeof( eth_header_snap_t ))
     72#define ETH_PREFIX              (sizeof(eth_header_t) + sizeof(eth_header_lsap_t) + sizeof(eth_header_snap_t))
    7373
    7474/** Reserved packet suffix length.
    7575 */
    76 #define ETH_SUFFIX              sizeof( eth_fcs_t )
     76#define ETH_SUFFIX              sizeof(eth_fcs_t)
    7777
    7878/** Maximum packet content length.
    … …  
    8686/** Maximum tagged packet content length.
    8787 */
    88 #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 ))
     88#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))
    8989
    9090/** Minimum tagged packet content length.
    9191 */
    92 #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 ))
     92#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))
    9393
    9494/** Dummy flag shift value.
    … …  
    103103 *  Preamble and FCS are mandatory part of the packets.
    104104 */
    105 #define ETH_DUMMY                               ( 1 << ETH_DUMMY_SHIFT )
     105#define ETH_DUMMY                               (1 << ETH_DUMMY_SHIFT)
    106106
    107107/** Returns the dummy flag.
    108108 *  @see ETH_DUMMY
    109109 */
    110 #define IS_DUMMY( flags )               (( flags ) & ETH_DUMMY )
     110#define IS_DUMMY(flags)         ((flags) &ETH_DUMMY)
    111111
    112112/** Device mode flags.
    … …  
    115115 *  @see ETH_8023_2_SNAP
    116116 */
    117 #define ETH_MODE_MASK                   ( 3 << ETH_MODE_SHIFT )
     117#define ETH_MODE_MASK                   (3 << ETH_MODE_SHIFT)
    118118
    119119/** DIX Ethernet mode flag.
    120120 */
    121 #define ETH_DIX                                 ( 1 << ETH_MODE_SHIFT )
     121#define ETH_DIX                                 (1 << ETH_MODE_SHIFT)
    122122
    123123/** Returns whether the DIX Ethernet mode flag is set.
    … …  
    125125 *  @see ETH_DIX
    126126 */
    127 #define IS_DIX( flags )                 ((( flags ) & ETH_MODE_MASK ) == ETH_DIX )
     127#define IS_DIX(flags)                   (((flags) &ETH_MODE_MASK) == ETH_DIX)
    128128
    129129/** 802.3 + 802.2 + LSAP mode flag.
    130130 */
    131 #define ETH_8023_2_LSAP                 ( 2 << ETH_MODE_SHIFT )
     131#define ETH_8023_2_LSAP                 (2 << ETH_MODE_SHIFT)
    132132
    133133/** Returns whether the 802.3 + 802.2 + LSAP mode flag is set.
    … …  
    135135 *  @see ETH_8023_2_LSAP
    136136 */
    137 #define IS_8023_2_LSAP( flags ) ((( flags ) & ETH_MODE_MASK ) == ETH_8023_2_LSAP )
     137#define IS_8023_2_LSAP(flags)   (((flags) &ETH_MODE_MASK) == ETH_8023_2_LSAP)
    138138
    139139/** 802.3 + 802.2 + LSAP + SNAP mode flag.
    140140 */
    141 #define ETH_8023_2_SNAP                 ( 3 << ETH_MODE_SHIFT )
     141#define ETH_8023_2_SNAP                 (3 << ETH_MODE_SHIFT)
    142142
    143143/** Returns whether the 802.3 + 802.2 + LSAP + SNAP mode flag is set.
    … …  
    145145 *  @see ETH_8023_2_SNAP
    146146 */
    147 #define IS_8023_2_SNAP( flags ) ((( flags ) & ETH_MODE_MASK ) == ETH_8023_2_SNAP )
     147#define IS_8023_2_SNAP(flags)   (((flags) &ETH_MODE_MASK) == ETH_8023_2_SNAP)
    148148
    149149/** Type definition of the ethernet address type.
    … …  
    180180 *  @param[in,out] icall The message parameters.
    181181 */
    182 void    eth_receiver( ipc_callid_t iid, ipc_call_t * icall );
     182void eth_receiver(ipc_callid_t iid, ipc_call_t * icall);
    183183
    184184/** Registers new device or updates the MTU of an existing one.
    … …  
    194194 *  @returns Other error codes as defined for the netif_get_addr_req() function.
    195195 */
    196 int     eth_device_message( device_id_t device_id, services_t service, size_t mtu );
     196int eth_device_message(device_id_t device_id, services_t service, size_t mtu);
    197197
    198198/** Registers receiving module service.
    … …  
    204204 *  @returns ENOMEM if there is not enough memory left.
    205205 */
    206 int     eth_register_message( services_t service, int phone );
     206int eth_register_message(services_t service, int phone);
    207207
    208208/** Returns the device packet dimensions for sending.
    … …  
    216216 *  @returns ENOENT if there is no such device.
    217217 */
    218 int     eth_packet_space_message( device_id_t device_id, size_t * addr_len, size_t * prefix, size_t * content, size_t * suffix );
     218int eth_packet_space_message(device_id_t device_id, size_t * addr_len, size_t * prefix, size_t * content, size_t * suffix);
    219219
    220220/** Returns the device hardware address.
    … …  
    226226 *  @returns ENOENT if there no such device.
    227227 */
    228 int     eth_addr_message( device_id_t device_id, eth_addr_type_t type, measured_string_ref * address );
     228int eth_addr_message(device_id_t device_id, eth_addr_type_t type, measured_string_ref * address);
    229229
    230230/** Sends the packet queue.
    … …  
    237237 *  @returns EINVAL if the service parameter is not known.
    238238 */
    239 int     eth_send_message( device_id_t device_id, packet_t packet, services_t sender );
     239int eth_send_message(device_id_t device_id, packet_t packet, services_t sender);
    240240
    241241/*@}*/
    … …  
    251251 *  @returns NULL if the packet address length is not big enough.
    252252 */
    253 eth_proto_ref   eth_process_packet( int flags, packet_t packet );
     253eth_proto_ref eth_process_packet(int flags, packet_t packet);
    254254
    255255/** Prepares the packet for sending.
    … …  
    264264 *  @returns ENOMEM if there is not enough memory in the packet.
    265265 */
    266 int     eth_prepare_packet( int flags, packet_t packet, uint8_t * src_addr, int ethertype, size_t mtu );
    267 
    268 DEVICE_MAP_IMPLEMENT( eth_devices, eth_device_t )
    269 
    270 INT_MAP_IMPLEMENT( eth_protos, eth_proto_t )
    271 
    272 int     nil_device_state_msg( int nil_phone, device_id_t device_id, int state ){
    273         int                             index;
    274         eth_proto_ref   proto;
    275 
    276         fibril_rwlock_read_lock( & eth_globals.protos_lock );
    277         for( index = eth_protos_count( & eth_globals.protos ) - 1; index >= 0; -- index ){
    278                 proto = eth_protos_get_index( & eth_globals.protos, index );
    279                 if( proto && proto->phone ) il_device_state_msg( proto->phone, device_id, state, proto->service );
    280         }
    281         fibril_rwlock_read_unlock( & eth_globals.protos_lock );
     266int eth_prepare_packet(int flags, packet_t packet, uint8_t * src_addr, int ethertype, size_t mtu);
     267
     268DEVICE_MAP_IMPLEMENT(eth_devices, eth_device_t)
     269
     270INT_MAP_IMPLEMENT(eth_protos, eth_proto_t)
     271
     272int nil_device_state_msg(int nil_phone, device_id_t device_id, int state){
     273        int index;
     274        eth_proto_ref proto;
     275
     276        fibril_rwlock_read_lock(&eth_globals.protos_lock);
     277        for(index = eth_protos_count(&eth_globals.protos) - 1; index >= 0; -- index){
     278                proto = eth_protos_get_index(&eth_globals.protos, index);
     279                if(proto && proto->phone){
     280                        il_device_state_msg(proto->phone, device_id, state, proto->service);
     281                }
     282        }
     283        fibril_rwlock_read_unlock(&eth_globals.protos_lock);
    282284        return EOK;
    283285}
    284286
    285 int nil_initialize( int net_phone ){
     287int nil_initialize(int net_phone){
    286288        ERROR_DECLARE;
    287289
    288         fibril_rwlock_initialize( & eth_globals.devices_lock );
    289         fibril_rwlock_initialize( & eth_globals.protos_lock );
    290         fibril_rwlock_write_lock( & eth_globals.devices_lock );
    291         fibril_rwlock_write_lock( & eth_globals.protos_lock );
     290        fibril_rwlock_initialize(&eth_globals.devices_lock);
     291        fibril_rwlock_initialize(&eth_globals.protos_lock);
     292        fibril_rwlock_write_lock(&eth_globals.devices_lock);
     293        fibril_rwlock_write_lock(&eth_globals.protos_lock);
    292294        eth_globals.net_phone = net_phone;
    293         eth_globals.broadcast_addr = measured_string_create_bulk( "\xFF\xFF\xFF\xFF\xFF\xFF", CONVERT_SIZE( uint8_t, char, ETH_ADDR ));
    294         if( ! eth_globals.broadcast_addr ) return ENOMEM;
    295         ERROR_PROPAGATE( eth_devices_initialize( & eth_globals.devices ));
    296         if( ERROR_OCCURRED( eth_protos_initialize( & eth_globals.protos ))){
    297                 eth_devices_destroy( & eth_globals.devices );
     295        eth_globals.broadcast_addr = measured_string_create_bulk("\xFF\xFF\xFF\xFF\xFF\xFF", CONVERT_SIZE(uint8_t, char, ETH_ADDR));
     296        if(! eth_globals.broadcast_addr){
     297                return ENOMEM;
     298        }
     299        ERROR_PROPAGATE(eth_devices_initialize(&eth_globals.devices));
     300        if(ERROR_OCCURRED(eth_protos_initialize(&eth_globals.protos))){
     301                eth_devices_destroy(&eth_globals.devices);
    298302                return ERROR_CODE;
    299303        }
    300         fibril_rwlock_write_unlock( & eth_globals.protos_lock );
    301         fibril_rwlock_write_unlock( & eth_globals.devices_lock );
     304        fibril_rwlock_write_unlock(&eth_globals.protos_lock);
     305        fibril_rwlock_write_unlock(&eth_globals.devices_lock);
    302306        return EOK;
    303307}
    304308
    305 int eth_device_message( device_id_t device_id, services_t service, size_t mtu ){
     309int eth_device_message(device_id_t device_id, services_t service, size_t mtu){
    306310        ERROR_DECLARE;
    307311
    308         eth_device_ref  device;
    309         int                             index;
    310         measured_string_t       names[ 2 ] = {{ "ETH_MODE", 8 }, { "ETH_DUMMY", 9 }};
    311         measured_string_ref     configuration;
    312         size_t                          count = sizeof( names ) / sizeof( measured_string_t );
    313         char *                          data;
    314         eth_proto_ref           proto;
    315 
    316         fibril_rwlock_write_lock( & eth_globals.devices_lock );
     312        eth_device_ref device;
     313        int index;
     314        measured_string_t names[2] = {{str_dup("ETH_MODE"), 8}, {str_dup("ETH_DUMMY"), 9}};
     315        measured_string_ref configuration;
     316        size_t count = sizeof(names) / sizeof(measured_string_t);
     317        char * data;
     318        eth_proto_ref proto;
     319
     320        fibril_rwlock_write_lock(&eth_globals.devices_lock);
    317321        // an existing device?
    318         device = eth_devices_find( & eth_globals.devices, device_id );
    319         if( device ){
    320                 if( device->service != service ){
    321                         printf( "Device %d already exists\n", device->device_id );
    322                         fibril_rwlock_write_unlock( & eth_globals.devices_lock );
     322        device = eth_devices_find(&eth_globals.devices, device_id);
     323        if(device){
     324                if(device->service != service){
     325                        printf("Device %d already exists\n", device->device_id);
     326                        fibril_rwlock_write_unlock(&eth_globals.devices_lock);
    323327                        return EEXIST;
    324328                }else{
    325329                        // update mtu
    326                         if(( mtu > 0 ) && ( mtu <= ETH_MAX_TAGGED_CONTENT( device->flags ))){
     330                        if((mtu > 0) && (mtu <= ETH_MAX_TAGGED_CONTENT(device->flags))){
    327331                                device->mtu = mtu;
    328332                        }else{
    329                                  device->mtu = ETH_MAX_TAGGED_CONTENT( device->flags );
     333                                 device->mtu = ETH_MAX_TAGGED_CONTENT(device->flags);
    330334                        }
    331                         printf( "Device %d already exists:\tMTU\t= %d\n", device->device_id, device->mtu );
    332                         fibril_rwlock_write_unlock( & eth_globals.devices_lock );
     335                        printf("Device %d already exists:\tMTU\t= %d\n", device->device_id, device->mtu);
     336                        fibril_rwlock_write_unlock(&eth_globals.devices_lock);
    333337                        // notify all upper layer modules
    334                         fibril_rwlock_read_lock( & eth_globals.protos_lock );
    335                         for( index = 0; index < eth_protos_count( & eth_globals.protos ); ++ index ){
    336                                 proto = eth_protos_get_index( & eth_globals.protos, index );
    337                                 if ( proto->phone ){
    338                                         il_mtu_changed_msg( proto->phone, device->device_id, device->mtu, proto->service );
     338                        fibril_rwlock_read_lock(&eth_globals.protos_lock);
     339                        for(index = 0; index < eth_protos_count(&eth_globals.protos); ++ index){
     340                                proto = eth_protos_get_index(&eth_globals.protos, index);
     341                                if (proto->phone){
     342                                        il_mtu_changed_msg(proto->phone, device->device_id, device->mtu, proto->service);
    339343                                }
    340344                        }
    341                         fibril_rwlock_read_unlock( & eth_globals.protos_lock );
     345                        fibril_rwlock_read_unlock(&eth_globals.protos_lock);
    342346                        return EOK;
    343347                }
    344348        }else{
    345349                // create a new device
    346                 device = ( eth_device_ref ) malloc( sizeof( eth_device_t ));
    347                 if( ! device ) return ENOMEM;
     350                device = (eth_device_ref) malloc(sizeof(eth_device_t));
     351                if(! device){
     352                        return ENOMEM;
     353                }
    348354                device->device_id = device_id;
    349355                device->service = service;
    350356                device->flags = 0;
    351                 if(( mtu > 0 ) && ( mtu <= ETH_MAX_TAGGED_CONTENT( device->flags ))){
     357                if((mtu > 0) && (mtu <= ETH_MAX_TAGGED_CONTENT(device->flags))){
    352358                        device->mtu = mtu;
    353359                }else{
    354                          device->mtu = ETH_MAX_TAGGED_CONTENT( device->flags );
    355                 }
    356                 configuration = & names[ 0 ];
    357                 if( ERROR_OCCURRED( net_get_device_conf_req( eth_globals.net_phone, device->device_id, & configuration, count, & data ))){
    358                         fibril_rwlock_write_unlock( & eth_globals.devices_lock );
    359                         free( device );
     360                         device->mtu = ETH_MAX_TAGGED_CONTENT(device->flags);
     361                }
     362                configuration = &names[0];
     363                if(ERROR_OCCURRED(net_get_device_conf_req(eth_globals.net_phone, device->device_id, &configuration, count, &data))){
     364                        fibril_rwlock_write_unlock(&eth_globals.devices_lock);
     365                        free(device);
    360366                        return ERROR_CODE;
    361367                }
    362                 if( configuration ){
    363                         if( ! str_lcmp( configuration[ 0 ].value, "DIX", configuration[ 0 ].length )){
     368                if(configuration){
     369                        if(! str_lcmp(configuration[0].value, "DIX", configuration[0].length)){
    364370                                device->flags |= ETH_DIX;
    365                         }else if( ! str_lcmp( configuration[ 0 ].value, "8023_2_LSAP", configuration[ 0 ].length )){
     371                        }else if(! str_lcmp(configuration[0].value, "8023_2_LSAP", configuration[0].length)){
    366372                                device->flags |= ETH_8023_2_LSAP;
    367373                        }else device->flags |= ETH_8023_2_SNAP;
    368                         if(( configuration[ 1 ].value ) && ( configuration[ 1 ].value[ 0 ] == 'y' )){
     374                        if((configuration[1].value) && (configuration[1].value[0] == 'y')){
    369375                                device->flags |= ETH_DUMMY;
    370376                        }
    371                         net_free_settings( configuration, data );
     377                        net_free_settings(configuration, data);
    372378                }else{
    373379                        device->flags |= ETH_8023_2_SNAP;
    374380                }
    375381                // bind the device driver
    376                 device->phone = netif_bind_service( device->service, device->device_id, SERVICE_ETHERNET, eth_receiver );
    377                 if( device->phone < 0 ){
    378                         fibril_rwlock_write_unlock( & eth_globals.devices_lock );
    379                         free( device );
     382                device->phone = netif_bind_service(device->service, device->device_id, SERVICE_ETHERNET, eth_receiver);
     383                if(device->phone < 0){
     384                        fibril_rwlock_write_unlock(&eth_globals.devices_lock);
     385                        free(device);
    380386                        return device->phone;
    381387                }
    382388                // get hardware address
    383                 if( ERROR_OCCURRED( netif_get_addr_req( device->phone, device->device_id, & device->addr, & device->addr_data ))){
    384                         fibril_rwlock_write_unlock( & eth_globals.devices_lock );
    385                         free( device );
     389                if(ERROR_OCCURRED(netif_get_addr_req(device->phone, device->device_id, &device->addr, &device->addr_data))){
     390                        fibril_rwlock_write_unlock(&eth_globals.devices_lock);
     391                        free(device);
    386392                        return ERROR_CODE;
    387393                }
    388394                // add to the cache
    389                 index = eth_devices_add( & eth_globals.devices, device->device_id, device );
    390                 if( index < 0 ){
    391                         fibril_rwlock_write_unlock( & eth_globals.devices_lock );
    392                         free( device->addr );
    393                         free( device->addr_data );
    394                         free( device );
     395                index = eth_devices_add(&eth_globals.devices, device->device_id, device);
     396                if(index < 0){
     397                        fibril_rwlock_write_unlock(&eth_globals.devices_lock);
     398                        free(device->addr);
     399                        free(device->addr_data);
     400                        free(device);
    395401                        return index;
    396402                }
    397                 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 );
    398         }
    399         fibril_rwlock_write_unlock( & eth_globals.devices_lock );
     403                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);
     404        }
     405        fibril_rwlock_write_unlock(&eth_globals.devices_lock);
    400406        return EOK;
    401407}
    402408
    403 eth_proto_ref eth_process_packet( int flags, packet_t packet ){
     409eth_proto_ref eth_process_packet(int flags, packet_t packet){
    404410        ERROR_DECLARE;
    405411
    406         eth_header_snap_ref     header;
    407         size_t                          length;
    408         eth_type_t                      type;
    409         size_t                          prefix;
    410         size_t                          suffix;
    411         eth_fcs_ref                     fcs;
    412         uint8_t *                       data;
    413 
    414         length = packet_get_data_length( packet );
    415         if( IS_DUMMY( flags )){
    416                 packet_trim( packet, sizeof( eth_preamble_t ), 0 );
    417         }
    418         if( length < sizeof( eth_header_t ) + ETH_MIN_CONTENT + ( IS_DUMMY( flags ) ? ETH_SUFFIX : 0 )) return NULL;
    419         data = packet_get_data( packet );
    420         header = ( eth_header_snap_ref ) data;
    421         type = ntohs( header->header.ethertype );
    422         if( type >= ETH_MIN_PROTO ){
     412        eth_header_snap_ref header;
     413        size_t length;
     414        eth_type_t type;
     415        size_t prefix;
     416        size_t suffix;
     417        eth_fcs_ref fcs;
     418        uint8_t * data;
     419
     420        length = packet_get_data_length(packet);
     421        if(IS_DUMMY(flags)){
     422                packet_trim(packet, sizeof(eth_preamble_t), 0);
     423        }
     424        if(length < sizeof(eth_header_t) + ETH_MIN_CONTENT + (IS_DUMMY(flags) ? ETH_SUFFIX : 0)) return NULL;
     425        data = packet_get_data(packet);
     426        header = (eth_header_snap_ref) data;
     427        type = ntohs(header->header.ethertype);
     428        if(type >= ETH_MIN_PROTO){
    423429                // DIX Ethernet
    424                 prefix = sizeof( eth_header_t );
     430                prefix = sizeof(eth_header_t);
    425431                suffix = 0;
    426                 fcs = ( eth_fcs_ref ) data + length - sizeof( eth_fcs_t );
    427                 length -= sizeof( eth_fcs_t );
    428         }else if( type <= ETH_MAX_CONTENT ){
     432                fcs = (eth_fcs_ref) data + length - sizeof(eth_fcs_t);
     433                length -= sizeof(eth_fcs_t);
     434        }else if(type <= ETH_MAX_CONTENT){
    429435                // translate "LSAP" values
    430                 if(( header->lsap.dsap == ETH_LSAP_GLSAP ) && ( header->lsap.ssap == ETH_LSAP_GLSAP )){
     436                if((header->lsap.dsap == ETH_LSAP_GLSAP) && (header->lsap.ssap == ETH_LSAP_GLSAP)){
    431437                        // raw packet
    432438                        // discard
    433439                        return NULL;
    434                 }else if(( header->lsap.dsap == ETH_LSAP_SNAP ) && ( header->lsap.ssap == ETH_LSAP_SNAP )){
     440                }else if((header->lsap.dsap == ETH_LSAP_SNAP) && (header->lsap.ssap == ETH_LSAP_SNAP)){
    435441                        // IEEE 802.3 + 802.2 + LSAP + SNAP
    436442                        // organization code not supported
    437                         type = ntohs( header->snap.ethertype );
    438                         prefix = sizeof( eth_header_t ) + sizeof( eth_header_lsap_t ) + sizeof( eth_header_snap_t );
     443                        type = ntohs(header->snap.ethertype);
     444                        prefix = sizeof(eth_header_t) + sizeof(eth_header_lsap_t) + sizeof(eth_header_snap_t);
    439445                }else{
    440446                        // IEEE 802.3 + 802.2 LSAP
    441                         type = lsap_map( header->lsap.dsap );
    442                         prefix = sizeof( eth_header_t ) + sizeof( eth_header_lsap_t);
    443                 }
    444                 suffix = ( type < ETH_MIN_CONTENT ) ? ETH_MIN_CONTENT - type : 0u;
    445                 fcs = ( eth_fcs_ref ) data + prefix + type + suffix;
     447                        type = lsap_map(header->lsap.dsap);
     448                        prefix = sizeof(eth_header_t) + sizeof(eth_header_lsap_t);
     449                }
     450                suffix = (type < ETH_MIN_CONTENT) ? ETH_MIN_CONTENT - type : 0u;
     451                fcs = (eth_fcs_ref) data + prefix + type + suffix;
    446452                suffix += length - prefix - type;
    447453                length = prefix + type + suffix;
    … …  
    450456                return NULL;
    451457        }
    452         if( IS_DUMMY( flags )){
    453                 if(( ~ compute_crc32( ~ 0u, data, length * 8 )) != ntohl( * fcs )){
     458        if(IS_DUMMY(flags)){
     459                if((~ compute_crc32(~ 0u, data, length * 8)) != ntohl(*fcs)){
    454460                        return NULL;
    455461                }
    456                 suffix += sizeof( eth_fcs_t );
    457         }
    458         if( ERROR_OCCURRED( packet_set_addr( packet, header->header.source_address, header->header.destination_address, ETH_ADDR ))
    459         || ERROR_OCCURRED( packet_trim( packet, prefix, suffix ))){
     462                suffix += sizeof(eth_fcs_t);
     463        }
     464        if(ERROR_OCCURRED(packet_set_addr(packet, header->header.source_address, header->header.destination_address, ETH_ADDR))
     465                || ERROR_OCCURRED(packet_trim(packet, prefix, suffix))){
    460466                return NULL;
    461467        }
    462         return eth_protos_find( & eth_globals.protos, type );
    463 }
    464 
    465 int nil_received_msg( int nil_phone, device_id_t device_id, packet_t packet, services_t target ){
    466         eth_proto_ref   proto;
    467         packet_t                next;
    468         eth_device_ref  device;
    469         int                             flags;
    470 
    471         fibril_rwlock_read_lock( & eth_globals.devices_lock );
    472         device = eth_devices_find( & eth_globals.devices, device_id );
    473         if( ! device ){
    474                 fibril_rwlock_read_unlock( & eth_globals.devices_lock );
     468        return eth_protos_find(&eth_globals.protos, type);
     469}
     470
     471int nil_received_msg(int nil_phone, device_id_t device_id, packet_t packet, services_t target){
     472        eth_proto_ref proto;
     473        packet_t next;
     474        eth_device_ref device;
     475        int flags;
     476
     477        fibril_rwlock_read_lock(&eth_globals.devices_lock);
     478        device = eth_devices_find(&eth_globals.devices, device_id);
     479        if(! device){
     480                fibril_rwlock_read_unlock(&eth_globals.devices_lock);
    475481                return ENOENT;
    476482        }
    477483        flags = device->flags;
    478         fibril_rwlock_read_unlock( & eth_globals.devices_lock );
    479         fibril_rwlock_read_lock( & eth_globals.protos_lock );
     484        fibril_rwlock_read_unlock(&eth_globals.devices_lock);
     485        fibril_rwlock_read_lock(&eth_globals.protos_lock);
    480486        do{
    481                 next = pq_detach( packet );
    482                 proto = eth_process_packet( flags, packet );
    483                 if( proto ){
    484                         il_received_msg( proto->phone, device_id, packet, proto->service );
     487                next = pq_detach(packet);
     488                proto = eth_process_packet(flags, packet);
     489                if(proto){
     490                        il_received_msg(proto->phone, device_id, packet, proto->service);
    485491                }else{
    486492                        // drop invalid/unknown
    487                         pq_release( eth_globals.net_phone, packet_get_id( packet ));
     493                        pq_release(eth_globals.net_phone, packet_get_id(packet));
    488494                }
    489495                packet = next;
    490         }while( packet );
    491         fibril_rwlock_read_unlock( & eth_globals.protos_lock );
     496        }while(packet);
     497        fibril_rwlock_read_unlock(&eth_globals.protos_lock);
    492498        return EOK;
    493499}
    494500
    495 int eth_packet_space_message( device_id_t device_id, size_t * addr_len, size_t * prefix, size_t * content, size_t * suffix ){
    496         eth_device_ref  device;
    497 
    498         if( !( addr_len && prefix && content && suffix )) return EBADMEM;
    499         fibril_rwlock_read_lock( & eth_globals.devices_lock );
    500         device = eth_devices_find( & eth_globals.devices, device_id );
    501         if( ! device ){
    502                 fibril_rwlock_read_unlock( & eth_globals.devices_lock );
     501int eth_packet_space_message(device_id_t device_id, size_t * addr_len, size_t * prefix, size_t * content, size_t * suffix){
     502        eth_device_ref device;
     503
     504        if(!(addr_len && prefix && content && suffix)){
     505                return EBADMEM;
     506        }
     507        fibril_rwlock_read_lock(&eth_globals.devices_lock);
     508        device = eth_devices_find(&eth_globals.devices, device_id);
     509        if(! device){
     510                fibril_rwlock_read_unlock(&eth_globals.devices_lock);
    503511                return ENOENT;
    504512        }
    505         * content = device->mtu;
    506         fibril_rwlock_read_unlock( & eth_globals.devices_lock );
    507         * addr_len = ETH_ADDR;
    508         * prefix = ETH_PREFIX;
    509         * suffix = ETH_MIN_CONTENT + ETH_SUFFIX;
     513        *content = device->mtu;
     514        fibril_rwlock_read_unlock(&eth_globals.devices_lock);
     515        *addr_len = ETH_ADDR;
     516        *prefix = ETH_PREFIX;
     517        *suffix = ETH_MIN_CONTENT + ETH_SUFFIX;
    510518        return EOK;
    511519}
    512520
    513 int eth_addr_message( device_id_t device_id, eth_addr_type_t type, measured_string_ref * address ){
    514         eth_device_ref  device;
    515 
    516         if( ! address ) return EBADMEM;
    517         if( type == ETH_BROADCAST_ADDR ){
    518                 * address = eth_globals.broadcast_addr;
     521int eth_addr_message(device_id_t device_id, eth_addr_type_t type, measured_string_ref * address){
     522        eth_device_ref device;
     523
     524        if(! address){
     525                return EBADMEM;
     526        }
     527        if(type == ETH_BROADCAST_ADDR){
     528                *address = eth_globals.broadcast_addr;
    519529        }else{
    520                 fibril_rwlock_read_lock( & eth_globals.devices_lock );
    521                 device = eth_devices_find( & eth_globals.devices, device_id );
    522                 if( ! device ){
    523                         fibril_rwlock_read_unlock( & eth_globals.devices_lock );
     530                fibril_rwlock_read_lock(&eth_globals.devices_lock);
     531                device = eth_devices_find(&eth_globals.devices, device_id);
     532                if(! device){
     533                        fibril_rwlock_read_unlock(&eth_globals.devices_lock);
    524534                        return ENOENT;
    525535                }
    526                 * address = device->addr;
    527                 fibril_rwlock_read_unlock( & eth_globals.devices_lock );
    528         }
    529         return ( * address ) ? EOK : ENOENT;
    530 }
    531 
    532 int eth_register_message( services_t service, int phone ){
    533         eth_proto_ref   proto;
    534         int                             protocol;
    535         int                             index;
    536 
    537         protocol = protocol_map( SERVICE_ETHERNET, service );
    538         if( ! protocol ) return ENOENT;
    539         fibril_rwlock_write_lock( & eth_globals.protos_lock );
    540         proto = eth_protos_find( & eth_globals.protos, protocol );
    541         if( proto ){
     536                *address = device->addr;
     537                fibril_rwlock_read_unlock(&eth_globals.devices_lock);
     538        }
     539        return (*address) ? EOK : ENOENT;
     540}
     541
     542int eth_register_message(services_t service, int phone){
     543        eth_proto_ref proto;
     544        int protocol;
     545        int index;
     546
     547        protocol = protocol_map(SERVICE_ETHERNET, service);
     548        if(! protocol){
     549                return ENOENT;
     550        }
     551        fibril_rwlock_write_lock(&eth_globals.protos_lock);
     552        proto = eth_protos_find(&eth_globals.protos, protocol);
     553        if(proto){
    542554                proto->phone = phone;
    543                 fibril_rwlock_write_unlock( & eth_globals.protos_lock );
     555                fibril_rwlock_write_unlock(&eth_globals.protos_lock);
    544556                return EOK;
    545557        }else{
    546                 proto = ( eth_proto_ref ) malloc( sizeof( eth_proto_t ));
    547                 if( ! proto ){
    548                         fibril_rwlock_write_unlock( & eth_globals.protos_lock );
     558                proto = (eth_proto_ref) malloc(sizeof(eth_proto_t));
     559                if(! proto){
     560                        fibril_rwlock_write_unlock(&eth_globals.protos_lock);
    549561                        return ENOMEM;
    550562                }
    … …  
    552564                proto->protocol = protocol;
    553565                proto->phone = phone;
    554                 index = eth_protos_add( & eth_globals.protos, protocol, proto );
    555                 if( index < 0 ){
    556                         fibril_rwlock_write_unlock( & eth_globals.protos_lock );
    557                         free( proto );
     566                index = eth_protos_add(&eth_globals.protos, protocol, proto);
     567                if(index < 0){
     568                        fibril_rwlock_write_unlock(&eth_globals.protos_lock);
     569                        free(proto);
    558570                        return index;
    559571                }
    560572        }
    561         printf( "New protocol registered:\n\tprotocol\t= 0x%x\n\tservice\t= %d\n\tphone\t= %d\n", proto->protocol, proto->service, proto->phone );
    562         fibril_rwlock_write_unlock( & eth_globals.protos_lock );
     573        printf("New protocol registered:\n\tprotocol\t= 0x%x\n\tservice\t= %d\n\tphone\t= %d\n", proto->protocol, proto->service, proto->phone);
     574        fibril_rwlock_write_unlock(&eth_globals.protos_lock);
    563575        return EOK;
    564576}
    565577
    566 int eth_prepare_packet( int flags, packet_t packet, uint8_t * src_addr, int ethertype, size_t mtu ){
    567         eth_header_snap_ref     header;
    568         eth_header_lsap_ref     header_lsap;
    569         eth_header_ref          header_dix;
    570         eth_fcs_ref                     fcs;
    571         uint8_t *                       src;
    572         uint8_t *                       dest;
    573         size_t                          length;
    574         int                                     i;
    575         void *                          padding;
    576         eth_preamble_ref        preamble;
    577 
    578         i = packet_get_addr( packet, & src, & dest );
    579         if( i < 0 ) return i;
    580         if( i != ETH_ADDR ) return EINVAL;
    581         length = packet_get_data_length( packet );
    582         if( length > mtu ) return EINVAL;
    583         if( length < ETH_MIN_TAGGED_CONTENT( flags )){
    584                 padding = packet_suffix( packet, ETH_MIN_TAGGED_CONTENT( flags ) - length );
    585                 if( ! padding ) return ENOMEM;
    586                 bzero( padding, ETH_MIN_TAGGED_CONTENT( flags ) - length );
    587         }
    588         if( IS_DIX( flags )){
    589                 header_dix = PACKET_PREFIX( packet, eth_header_t );
    590                 if( ! header_dix ) return ENOMEM;
    591                 header_dix->ethertype = ( uint16_t ) ethertype;
    592                 memcpy( header_dix->source_address, src_addr, ETH_ADDR );
    593                 memcpy( header_dix->destination_address, dest, ETH_ADDR );
    594                 src = & header_dix->destination_address[ 0 ];
    595         }else if( IS_8023_2_LSAP( flags )){
    596                 header_lsap = PACKET_PREFIX( packet, eth_header_lsap_t );
    597                 if( ! header_lsap ) return ENOMEM;
    598                 header_lsap->header.ethertype = htons( length + sizeof( eth_header_lsap_t ));
    599                 header_lsap->lsap.dsap = lsap_unmap( ntohs( ethertype ));
     578int eth_prepare_packet(int flags, packet_t packet, uint8_t * src_addr, int ethertype, size_t mtu){
     579        eth_header_snap_ref header;
     580        eth_header_lsap_ref header_lsap;
     581        eth_header_ref header_dix;
     582        eth_fcs_ref fcs;
     583        uint8_t * src;
     584        uint8_t * dest;
     585        size_t length;
     586        int i;
     587        void * padding;
     588        eth_preamble_ref preamble;
     589
     590        i = packet_get_addr(packet, &src, &dest);
     591        if(i < 0){
     592                return i;
     593        }
     594        if(i != ETH_ADDR){
     595                return EINVAL;
     596        }
     597        length = packet_get_data_length(packet);
     598        if(length > mtu){
     599                return EINVAL;
     600        }
     601        if(length < ETH_MIN_TAGGED_CONTENT(flags)){
     602                padding = packet_suffix(packet, ETH_MIN_TAGGED_CONTENT(flags) - length);
     603                if(! padding){
     604                        return ENOMEM;
     605                }
     606                bzero(padding, ETH_MIN_TAGGED_CONTENT(flags) - length);
     607        }
     608        if(IS_DIX(flags)){
     609                header_dix = PACKET_PREFIX(packet, eth_header_t);
     610                if(! header_dix){
     611                        return ENOMEM;
     612                }
     613                header_dix->ethertype = (uint16_t) ethertype;
     614                memcpy(header_dix->source_address, src_addr, ETH_ADDR);
     615                memcpy(header_dix->destination_address, dest, ETH_ADDR);
     616                src = &header_dix->destination_address[0];
     617        }else if(IS_8023_2_LSAP(flags)){
     618                header_lsap = PACKET_PREFIX(packet, eth_header_lsap_t);
     619                if(! header_lsap){
     620                        return ENOMEM;
     621                }
     622                header_lsap->header.ethertype = htons(length + sizeof(eth_header_lsap_t));
     623                header_lsap->lsap.dsap = lsap_unmap(ntohs(ethertype));
    600624                header_lsap->lsap.ssap = header_lsap->lsap.dsap;
    601625                header_lsap->lsap.ctrl = IEEE_8023_2_UI;
    602                 memcpy( header_lsap->header.source_address, src_addr, ETH_ADDR );
    603                 memcpy( header_lsap->header.destination_address, dest, ETH_ADDR );
    604                 src = & header_lsap->header.destination_address[ 0 ];
    605         }else if( IS_8023_2_SNAP( flags )){
    606                 header = PACKET_PREFIX( packet, eth_header_snap_t );
    607                 if( ! header ) return ENOMEM;
    608                 header->header.ethertype = htons( length + sizeof( eth_header_lsap_t ) + sizeof( eth_header_snap_t ));
    609                 header->lsap.dsap = ( uint16_t ) ETH_LSAP_SNAP;
     626                memcpy(header_lsap->header.source_address, src_addr, ETH_ADDR);
     627                memcpy(header_lsap->header.destination_address, dest, ETH_ADDR);
     628                src = &header_lsap->header.destination_address[0];
     629        }else if(IS_8023_2_SNAP(flags)){
     630                header = PACKET_PREFIX(packet, eth_header_snap_t);
     631                if(! header){
     632                        return ENOMEM;
     633                }
     634                header->header.ethertype = htons(length + sizeof(eth_header_lsap_t) + sizeof(eth_header_snap_t));
     635                header->lsap.dsap = (uint16_t) ETH_LSAP_SNAP;
    610636                header->lsap.ssap = header->lsap.dsap;
    611637                header->lsap.ctrl = IEEE_8023_2_UI;
    612                 for( i = 0; i < 3; ++ i ) header->snap.protocol[ i ] = 0;
    613                 header->snap.ethertype = ( uint16_t ) ethertype;
    614                 memcpy( header->header.source_address, src_addr, ETH_ADDR );
    615                 memcpy( header->header.destination_address, dest, ETH_ADDR );
    616                 src = & header->header.destination_address[ 0 ];
    617         }
    618         if( IS_DUMMY( flags )){
    619                 preamble = PACKET_PREFIX( packet, eth_preamble_t );
    620                 if( ! preamble ) return ENOMEM;
    621                 for( i = 0; i < 7; ++ i ) preamble->preamble[ i ] = ETH_PREAMBLE;
     638                for(i = 0; i < 3; ++ i){
     639                        header->snap.protocol[i] = 0;
     640                }
     641                header->snap.ethertype = (uint16_t) ethertype;
     642                memcpy(header->header.source_address, src_addr, ETH_ADDR);
     643                memcpy(header->header.destination_address, dest, ETH_ADDR);
     644                src = &header->header.destination_address[0];
     645        }
     646        if(IS_DUMMY(flags)){
     647                preamble = PACKET_PREFIX(packet, eth_preamble_t);
     648                if(! preamble){
     649                        return ENOMEM;
     650                }
     651                for(i = 0; i < 7; ++ i){
     652                        preamble->preamble[i] = ETH_PREAMBLE;
     653                }
    622654                preamble->sfd = ETH_SFD;
    623                 fcs = PACKET_SUFFIX( packet, eth_fcs_t );
    624                 if( ! fcs ) return ENOMEM;
    625                 * fcs = htonl( ~ compute_crc32( ~ 0u, src, length * 8 ));
     655                fcs = PACKET_SUFFIX(packet, eth_fcs_t);
     656                if(! fcs){
     657                        return ENOMEM;
     658                }
     659                *fcs = htonl(~ compute_crc32(~ 0u, src, length * 8));
    626660        }
    627661        return EOK;
    628662}
    629663
    630 int eth_send_message( device_id_t device_id, packet_t packet, services_t sender ){
     664int eth_send_message(device_id_t device_id, packet_t packet, services_t sender){
    631665        ERROR_DECLARE;
    632666
    633         eth_device_ref          device;
    634         packet_t                        next;
    635         packet_t                        tmp;
    636         int                                     ethertype;
    637 
    638         ethertype = htons( protocol_map( SERVICE_ETHERNET, sender ));
    639         if( ! ethertype ){
    640                 pq_release( eth_globals.net_phone, packet_get_id( packet ));
     667        eth_device_ref device;
     668        packet_t next;
     669        packet_t tmp;
     670        int ethertype;
     671
     672        ethertype = htons(protocol_map(SERVICE_ETHERNET, sender));
     673        if(! ethertype){
     674                pq_release(eth_globals.net_phone, packet_get_id(packet));
    641675                return EINVAL;
    642676        }
    643         fibril_rwlock_read_lock( & eth_globals.devices_lock );
    644         device = eth_devices_find( & eth_globals.devices, device_id );
    645         if( ! device ){
    646                 fibril_rwlock_read_unlock( & eth_globals.devices_lock );
     677        fibril_rwlock_read_lock(&eth_globals.devices_lock);
     678        device = eth_devices_find(&eth_globals.devices, device_id);
     679        if(! device){
     680                fibril_rwlock_read_unlock(&eth_globals.devices_lock);
    647681                return ENOENT;
    648682        }
    … …  
    650684        next = packet;
    651685        do{
    652                 if( ERROR_OCCURRED( eth_prepare_packet( device->flags, next, ( uint8_t * ) device->addr->value, ethertype, device->mtu ))){
     686                if(ERROR_OCCURRED(eth_prepare_packet(device->flags, next, (uint8_t *) device->addr->value, ethertype, device->mtu))){
    653687                        // release invalid packet
    654                         tmp = pq_detach( next );
    655                         if( next == packet ) packet = tmp;
    656                         pq_release( eth_globals.net_phone, packet_get_id( next ));
     688                        tmp = pq_detach(next);
     689                        if(next == packet){
     690                                packet = tmp;
     691                        }
     692                        pq_release(eth_globals.net_phone, packet_get_id(next));
    657693                        next = tmp;
    658694                }else{
    659                         next = pq_next( next );
    660                 }
    661         }while( next );
     695                        next = pq_next(next);
     696                }
     697        }while(next);
    662698        // send packet queue
    663         if( packet ){
    664                 netif_send_msg( device->phone, device_id, packet, SERVICE_ETHERNET );
    665         }
    666         fibril_rwlock_read_unlock( & eth_globals.devices_lock );
     699        if(packet){
     700                netif_send_msg(device->phone, device_id, packet, SERVICE_ETHERNET);
     701        }
     702        fibril_rwlock_read_unlock(&eth_globals.devices_lock);
    667703        return EOK;
    668704}
    669705
    670 int nil_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
     706int nil_message(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
    671707        ERROR_DECLARE;
    672708
    673         measured_string_ref     address;
    674         packet_t                        packet;
    675 
    676 //      printf( "message %d - %d\n", IPC_GET_METHOD( * call ), NET_NIL_FIRST );
    677         * answer_count = 0;
    678         switch( IPC_GET_METHOD( * call )){
     709        measured_string_ref address;
     710        packet_t packet;
     711
     712//      printf("message %d - %d\n", IPC_GET_METHOD(*call), NET_NIL_FIRST);
     713        *answer_count = 0;
     714        switch(IPC_GET_METHOD(*call)){
    679715                case IPC_M_PHONE_HUNGUP:
    680716                        return EOK;
    681717                case NET_NIL_DEVICE:
    682                         return eth_device_message( IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ), IPC_GET_MTU( call ));
     718                        return eth_device_message(IPC_GET_DEVICE(call), IPC_GET_SERVICE(call), IPC_GET_MTU(call));
    683719                case NET_NIL_SEND:
    684                         ERROR_PROPAGATE( packet_translate( eth_globals.net_phone, & packet, IPC_GET_PACKET( call )));
    685                         return eth_send_message( IPC_GET_DEVICE( call ), packet, IPC_GET_SERVICE( call ));
     720                        ERROR_PROPAGATE(packet_translate(eth_globals.net_phone, &packet, IPC_GET_PACKET(call)));
     721                        return eth_send_message(IPC_GET_DEVICE(call), packet, IPC_GET_SERVICE(call));
    686722                case NET_NIL_PACKET_SPACE:
    687                         ERROR_PROPAGATE( eth_packet_space_message( IPC_GET_DEVICE( call ), IPC_SET_ADDR( answer ), IPC_SET_PREFIX( answer ), IPC_SET_CONTENT( answer ), IPC_SET_SUFFIX( answer )));
    688                         * answer_count = 4;
     723                        ERROR_PROPAGATE(eth_packet_space_message(IPC_GET_DEVICE(call), IPC_SET_ADDR(answer), IPC_SET_PREFIX(answer), IPC_SET_CONTENT(answer), IPC_SET_SUFFIX(answer)));
     724                        *answer_count = 4;
    689725                        return EOK;
    690726                case NET_NIL_ADDR:
    691                         ERROR_PROPAGATE( eth_addr_message( IPC_GET_DEVICE( call ), ETH_LOCAL_ADDR, & address ));
    692                         return measured_strings_reply( address, 1 );
     727                        ERROR_PROPAGATE(eth_addr_message(IPC_GET_DEVICE(call), ETH_LOCAL_ADDR, &address));
     728                        return measured_strings_reply(address, 1);
    693729                case NET_NIL_BROADCAST_ADDR:
    694                         ERROR_PROPAGATE( eth_addr_message( IPC_GET_DEVICE( call ), ETH_BROADCAST_ADDR, & address ));
    695                         return measured_strings_reply( address, 1 );
     730                        ERROR_PROPAGATE(eth_addr_message(IPC_GET_DEVICE(call), ETH_BROADCAST_ADDR, &address));
     731                        return measured_strings_reply(address, 1);
    696732                case IPC_M_CONNECT_TO_ME:
    697                         return eth_register_message( NIL_GET_PROTO( call ), IPC_GET_PHONE( call ));
     733                        return eth_register_message(NIL_GET_PROTO(call), IPC_GET_PHONE(call));
    698734        }
    699735        return ENOTSUP;
    700736}
    701737
    702 void eth_receiver( ipc_callid_t iid, ipc_call_t * icall ){
     738void eth_receiver(ipc_callid_t iid, ipc_call_t * icall){
    703739        ERROR_DECLARE;
    704740
    705         packet_t                packet;
    706 
    707         while( true ){
    708 //              printf( "message %d - %d\n", IPC_GET_METHOD( * icall ), NET_NIL_FIRST );
    709                 switch( IPC_GET_METHOD( * icall )){
     741        packet_t packet;
     742
     743        while(true){
     744//              printf("message %d - %d\n", IPC_GET_METHOD(*icall), NET_NIL_FIRST);
     745                switch(IPC_GET_METHOD(*icall)){
    710746                        case NET_NIL_DEVICE_STATE:
    711                                 nil_device_state_msg( 0, IPC_GET_DEVICE( icall ), IPC_GET_STATE( icall ));
    712                                 ipc_answer_0( iid, EOK );
     747                                nil_device_state_msg(0, IPC_GET_DEVICE(icall), IPC_GET_STATE(icall));
     748                                ipc_answer_0(iid, EOK);
    713749                                break;
    714750                        case NET_NIL_RECEIVED:
    715                                 if( ! ERROR_OCCURRED( packet_translate( eth_globals.net_phone, & packet, IPC_GET_PACKET( icall )))){
    716                                         ERROR_CODE = nil_received_msg( 0, IPC_GET_DEVICE( icall ), packet, 0 );
     751                                if(! ERROR_OCCURRED(packet_translate(eth_globals.net_phone, &packet, IPC_GET_PACKET(icall)))){
     752                                        ERROR_CODE = nil_received_msg(0, IPC_GET_DEVICE(icall), packet, 0);
    717753                                }
    718                                 ipc_answer_0( iid, ( ipcarg_t ) ERROR_CODE );
     754                                ipc_answer_0(iid, (ipcarg_t) ERROR_CODE);
    719755                                break;
    720756                        default:
    721                                 ipc_answer_0( iid, ( ipcarg_t ) ENOTSUP );
    722                 }
    723                 iid = async_get_call( icall );
     757                                ipc_answer_0(iid, (ipcarg_t) ENOTSUP);
     758                }
     759                iid = async_get_call(icall);
    724760        }
    725761}
Note: See TracChangeset for help on using the changeset viewer.