Subversion Repositories HelenOS

Rev

Rev 4153 | Rev 4243 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
3992 mejdrech 1
/*
2
 * Copyright (c) 2009 Lukas Mejdrech
3
 * All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 *
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
14
 * - The name of the author may not be used to endorse or promote products
15
 *   derived from this software without specific prior written permission.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
28
 
29
/** @addtogroup eth
30
 *  @{
31
 */
32
 
33
/** @file
34
 *  Ethernet module implementation.
35
 *  @see eth.h
36
 */
37
 
38
#include <async.h>
39
#include <malloc.h>
40
#include <stdio.h>
41
#include <string.h>
42
 
43
#include <ipc/ipc.h>
44
#include <ipc/services.h>
45
 
46
#include "../../err.h"
47
#include "../../messages.h"
48
#include "../../modules.h"
49
 
50
#include "../../include/byteorder.h"
4075 mejdrech 51
#include "../../include/crc.h"
52
#include "../../include/ethernet_lsap.h"
3992 mejdrech 53
#include "../../include/ethernet_protocols.h"
54
#include "../../include/protocol_map.h"
55
#include "../../netif/device.h"
56
 
57
#include "../../structures/measured_strings.h"
58
#include "../../structures/packet/packet.h"
59
#include "../../structures/packet/packet_client.h"
60
 
61
#include "eth.h"
62
#include "eth_header.h"
63
//#include "eth_messages.h"
64
#include "eth_module.h"
65
 
66
#define ETH_PREFIX      ( sizeof( eth_header_t ) + sizeof( eth_header_lsap_t ) + sizeof( eth_header_snap_t ))
4075 mejdrech 67
#define ETH_SUFFIX      sizeof( eth_fcs_t )
68
#define ETH_MAX_CONTENT 1500
3992 mejdrech 69
#define ETH_MIN_CONTENT 46
70
 
71
/** Returns the device identifier message parameter.
72
 */
73
#define IPC_GET_DEVICE( call )      ( device_id_t ) IPC_GET_ARG1( * call )
74
 
75
/** Returns the packet identifier message parameter.
76
 */
77
#define IPC_GET_PACKET( call )      ( packet_id_t ) IPC_GET_ARG2( * call )
78
 
79
/** Returns the protocol service message parameter.
80
 */
81
#define IPC_GET_PROTO( call )       ( services_t ) IPC_GET_ARG1( * call )
82
 
83
/** Returns the device driver service message parameter.
84
 */
85
#define IPC_GET_SERVICE( call )     ( services_t ) IPC_GET_ARG2( * call )
86
 
87
#define IPC_GET_MTU( call )         ( size_t ) IPC_GET_ARG3( * call )
88
 
89
#define IPC_GET_PHONE( call )       ( int ) IPC_GET_ARG5( * call )
90
 
91
#define IPC_SET_ADDR( answer )      (( size_t * ) & IPC_GET_ARG1( * answer ))
92
#define IPC_SET_PREFIX( answer )    (( size_t * ) & IPC_GET_ARG2( * answer ))
93
#define IPC_SET_CONTENT( answer )   (( size_t * ) & IPC_GET_ARG3( * answer ))
94
#define IPC_SET_SUFFIX( answer )    (( size_t * ) & IPC_GET_ARG4( * answer ))
95
 
96
typedef enum eth_addr_type  eth_addr_type_t;
97
typedef eth_addr_type_t *   eth_addr_type_ref;
98
 
99
enum eth_addr_type{
100
    ETH_LOCAL_ADDR,
101
    ETH_BROADCAST_ADDR
102
};
103
 
104
/** Ethernet global data.
105
 */
106
eth_globals_t   eth_globals;
107
 
108
/** Processes IPC messages from the registered device driver modules in an infinite loop.
109
 *  @param iid The message identifier. Input parameter.
110
 *  @param icall The message parameters. Input/output parameter.
111
 */
112
void    eth_receiver( ipc_callid_t iid, ipc_call_t * icall );
113
 
114
DEVICE_MAP_IMPLEMENT( eth_devices, eth_device_t )
115
 
116
INT_MAP_IMPLEMENT( eth_protos, eth_proto_t )
117
 
118
int eth_device_message( device_id_t device_id, services_t service, size_t mtu );
119
int eth_receive_message( device_id_t device_id, packet_t packet );
120
int eth_packet_space_message( device_id_t device_id, size_t * addr_len, size_t * prefix, size_t * content, size_t * suffix );
121
int eth_addr_message( device_id_t device_id, eth_addr_type_t type, measured_string_ref * address );
122
int eth_register_message( services_t service, int phone );
123
int eth_send_message( device_id_t device_id, packet_t packet, services_t sender );
124
int eth_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count );
125
void    eth_receiver( ipc_callid_t iid, ipc_call_t * icall );
4153 mejdrech 126
eth_proto_ref   eth_proccess_packet( int dummy, packet_t packet );
127
int eth_prepare_packet( int dummy, packet_t packet, uint8_t * src_addr, int ethertype );
3992 mejdrech 128
 
129
int eth_initialize( void ){
130
    ERROR_DECLARE;
131
 
132
    rwlock_initialize( & eth_globals.devices_lock );
133
    rwlock_initialize( & eth_globals.protos_lock );
134
    rwlock_write_lock( & eth_globals.devices_lock );
135
    rwlock_write_lock( & eth_globals.protos_lock );
136
    eth_globals.broadcast_addr = measured_string_create_bulk( "\xFF\xFF\xFF\xFF\xFF\xFF", CONVERT_SIZE( uint8_t, char, ETH_ADDR ));
137
    if( ! eth_globals.broadcast_addr ) return ENOMEM;
138
    ERROR_PROPAGATE( eth_devices_initialize( & eth_globals.devices ));
139
    if( ERROR_OCCURRED( eth_protos_initialize( & eth_globals.protos ))){
140
        eth_devices_destroy( & eth_globals.devices );
141
        return ERROR_CODE;
142
    }
143
    rwlock_write_unlock( & eth_globals.protos_lock );
144
    rwlock_write_unlock( & eth_globals.devices_lock );
145
    return EOK;
146
}
147
 
148
int eth_device_message( device_id_t device_id, services_t service, size_t mtu ){
149
    ERROR_DECLARE;
150
 
151
    aid_t           message;
152
    ipc_call_t      answer;
153
    eth_device_ref  device;
154
    int             result;
155
 
156
    rwlock_write_lock( & eth_globals.devices_lock );
157
    // an existing device?
158
    device = eth_devices_find( & eth_globals.devices, device_id );
159
    if( device ){
4163 mejdrech 160
        if( device->service != service ){
161
            printf( "\nDevice %d already exists", device->device_id );
162
            rwlock_write_unlock( & eth_globals.devices_lock );
163
            return EEXIST;
164
        }else{
3992 mejdrech 165
            // update mtu
166
            device->mtu = mtu;
4163 mejdrech 167
            printf( "\nDevice %d already exists:\tMTU\t= %d", device->device_id, device->mtu );
3992 mejdrech 168
        }
169
    }else{
170
        // create a new device
171
        device = ( eth_device_ref ) malloc( sizeof( eth_device_t ));
172
        if( ! device ) return ENOMEM;
173
        device->device_id = device_id;
174
        device->service = service;
4163 mejdrech 175
        device->mtu = ( mtu > 0 ) ? mtu : ETH_MAX_CONTENT;
4153 mejdrech 176
        // TODO get dummy setting
177
        device->dummy = 0;
3992 mejdrech 178
        // bind the device driver
179
        device->phone = bind_service( device->service, device->device_id, SERVICE_ETHERNET, 0, eth_receiver );
4163 mejdrech 180
        if( device->phone < 0 ){
181
            rwlock_write_unlock( & eth_globals.devices_lock );
182
            free( device );
183
            return device->phone;
184
        }
3992 mejdrech 185
        // get hardware address
186
        message = async_send_1( device->phone, NET_NETIF_GET_ADDR, device->device_id, & answer );
187
        if( ERROR_OCCURRED( measured_strings_return( device->phone, & device->addr, & device->addr_data, 1 ))){
188
            rwlock_write_unlock( & eth_globals.devices_lock );
189
            free( device );
190
            async_wait_for( message, NULL );
191
            return ERROR_CODE;
192
        }
193
        async_wait_for( message, ( ipcarg_t * ) & result );
194
        if( ERROR_OCCURRED( result )){
195
            rwlock_write_unlock( & eth_globals.devices_lock );
196
            free( device->addr );
197
            free( device->addr_data );
198
            free( device );
199
            return ERROR_CODE;
200
        }
201
        // add to the cache
202
        if( ERROR_OCCURRED( eth_devices_add( & eth_globals.devices, device->device_id, device ))){
203
            rwlock_write_unlock( & eth_globals.devices_lock );
204
            free( device->addr );
205
            free( device->addr_data );
206
            free( device );
207
            return ERROR_CODE;
208
        }
4163 mejdrech 209
        printf( "\nNew device registered:\n\tid\t= %d\n\tservice\t= %d\n\tMTU\t= %d\n\taddress\t= %X:%X:%X:%X:%X:%X", 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 ] );
3992 mejdrech 210
    }
211
    rwlock_write_unlock( & eth_globals.devices_lock );
212
    return EOK;
213
}
214
 
4153 mejdrech 215
eth_proto_ref eth_proccess_packet( int dummy, packet_t packet ){
3992 mejdrech 216
    ERROR_DECLARE;
217
 
218
    eth_header_ex_ref   header;
219
    size_t              length;
220
    int                 type;
4075 mejdrech 221
    size_t              prefix;
222
    size_t              suffix;
223
    eth_fcs_ref         fcs;
3992 mejdrech 224
 
225
    length = packet_get_data_length( packet );
4153 mejdrech 226
    if( dummy ){
227
        packet_trim( packet, sizeof( eth_preamble_t ), 0 );
228
    }
4075 mejdrech 229
    if( length <= sizeof( eth_header_t ) + ETH_MIN_CONTENT + ETH_SUFFIX ) return NULL;
3992 mejdrech 230
    header = ( eth_header_ex_ref ) packet_get_data( packet );
231
    type = ntohs( header->header.ethertype );
232
    if( type >= ETH_MIN_PROTO ){
233
        // DIX Ethernet
4075 mejdrech 234
        prefix = sizeof( eth_header_t );
235
        suffix = sizeof( eth_fcs_t );
236
        fcs = (( void * ) header ) + length - suffix;
237
    }else if( type <= ETH_MAX_CONTENT ){
3992 mejdrech 238
        // translate "LSAP" values
4075 mejdrech 239
        if(( header->lsap.dsap == ETH_LSAP_GLSAP ) && ( header->lsap.ssap == ETH_LSAP_GLSAP )){
3992 mejdrech 240
            // raw packet
241
            // discard
4075 mejdrech 242
            return NULL;
3992 mejdrech 243
        }else if(( header->lsap.dsap == ETH_LSAP_SNAP ) && ( header->lsap.ssap == ETH_LSAP_SNAP )){
4075 mejdrech 244
            // IEEE 802.3 + 802.2 + LSAP + SNAP
3992 mejdrech 245
            // organization code not supported
246
            type = ntohs( header->snap.ethertype );
4075 mejdrech 247
            prefix = sizeof( eth_header_t ) + sizeof( eth_header_lsap_t) + sizeof( eth_header_snap_t);
3992 mejdrech 248
        }else{
249
            // IEEE 802.3 + 802.2 LSAP
4075 mejdrech 250
            type = lsap_map( header->lsap.dsap );
251
            prefix = sizeof( eth_header_t ) + sizeof( eth_header_lsap_t);
3992 mejdrech 252
        }
4075 mejdrech 253
        suffix = ( type < ETH_MIN_CONTENT ) ? ETH_MIN_CONTENT - type : 0;
254
        fcs = (( void * ) header ) + prefix + type + suffix;
255
        suffix += length - prefix - type;
256
    }else{
257
        // invalid length/type, should not occurr
258
        return NULL;
3992 mejdrech 259
    }
4153 mejdrech 260
    if( dummy ){
261
        if(( ~ compute_crc32( ~ 0, & header->header.dest, ((( void * ) fcs ) - (( void * ) & header->header.dest )) * 8 )) != ntohl( * fcs )){
262
            return NULL;
263
        }
3992 mejdrech 264
    }
265
    if( ERROR_OCCURRED( packet_set_addr( packet, header->header.src, header->header.dest, ETH_ADDR ))
4075 mejdrech 266
    || ERROR_OCCURRED( packet_trim( packet, prefix, suffix ))){
267
        return NULL;
3992 mejdrech 268
    }
4075 mejdrech 269
    return eth_protos_find( & eth_globals.protos, type );
270
}
271
 
272
int eth_receive_message( device_id_t device_id, packet_t packet ){
273
    eth_proto_ref   proto;
274
    packet_t        next;
4153 mejdrech 275
    eth_device_ref  device;
276
    int             dummy;
4075 mejdrech 277
 
4153 mejdrech 278
    rwlock_read_lock( & eth_globals.devices_lock );
279
    device = eth_devices_find( & eth_globals.devices, device_id );
280
    if( ! device ){
281
        rwlock_read_unlock( & eth_globals.devices_lock );
282
        return ENOENT;
283
    }
284
    dummy = device->dummy;
285
    rwlock_read_unlock( & eth_globals.devices_lock );
4075 mejdrech 286
    rwlock_read_lock( & eth_globals.protos_lock );
287
    do{
288
        next = pq_detach( packet );
4153 mejdrech 289
        proto = eth_proccess_packet( dummy, packet );
4075 mejdrech 290
        if( proto ){
291
            async_msg_2( proto->phone, NET_IL_RECEIVED, device_id, packet_get_id( packet ));
292
        }else{
293
            // drop invalid/unknown
294
            packet_release( eth_globals.networking_phone, packet_get_id( packet ));
295
        }
296
        packet = next;
297
    }while( packet );
298
    rwlock_read_unlock( & eth_globals.protos_lock );
3992 mejdrech 299
    return EOK;
300
}
301
 
302
int eth_packet_space_message( device_id_t device_id, size_t * addr_len, size_t * prefix, size_t * content, size_t * suffix ){
303
    eth_device_ref  device;
304
 
305
    if( !( addr_len && prefix && content && suffix )) return EINVAL;
306
    rwlock_write_lock( & eth_globals.devices_lock );
307
    device = eth_devices_find( & eth_globals.devices, device_id );
308
    if( ! device ){
309
        rwlock_write_unlock( & eth_globals.devices_lock );
310
        return ENOENT;
311
    }
4163 mejdrech 312
    * content = ( ETH_MAX_CONTENT > device->mtu ) ? device->mtu : ETH_MAX_CONTENT;
3992 mejdrech 313
    rwlock_write_unlock( & eth_globals.devices_lock );
314
    * addr_len = ETH_ADDR;
315
    * prefix = ETH_PREFIX;
4075 mejdrech 316
    * suffix = ETH_MIN_CONTENT + ETH_SUFFIX;
3992 mejdrech 317
    return EOK;
318
}
319
 
320
int eth_addr_message( device_id_t device_id, eth_addr_type_t type, measured_string_ref * address ){
321
    eth_device_ref  device;
322
 
323
    if( ! address ) return EINVAL;
324
    if( type == ETH_BROADCAST_ADDR ){
325
        * address = eth_globals.broadcast_addr;
326
    }else{
327
        rwlock_write_lock( & eth_globals.devices_lock );
328
        device = eth_devices_find( & eth_globals.devices, device_id );
329
        if( ! device ){
330
            rwlock_write_unlock( & eth_globals.devices_lock );
331
            return ENOENT;
332
        }
333
        * address = device->addr;
334
        rwlock_write_unlock( & eth_globals.devices_lock );
335
    }
336
    return ( * address ) ? EOK : ENOENT;
337
}
338
 
339
int eth_register_message( services_t service, int phone ){
340
    ERROR_DECLARE;
341
 
342
    eth_proto_ref   proto;
343
    int             protocol;
344
 
345
    protocol = protocol_map( SERVICE_ETHERNET, service );
346
    if( ! protocol ) return ENOENT;
347
    rwlock_write_lock( & eth_globals.protos_lock );
348
    proto = eth_protos_find( & eth_globals.protos, protocol );
349
    if( proto ){
350
        proto->phone = phone;
351
        rwlock_write_unlock( & eth_globals.protos_lock );
352
        return EOK;
353
    }else{
354
        proto = ( eth_proto_ref ) malloc( sizeof( eth_proto_t ));
355
        if( ! proto ){
356
            rwlock_write_unlock( & eth_globals.protos_lock );
357
            return ENOMEM;
358
        }
359
        proto->service = service;
360
        proto->protocol = protocol;
361
        proto->phone = phone;
362
        if( ERROR_OCCURRED( eth_protos_add( & eth_globals.protos, protocol, proto ))){
363
            rwlock_write_unlock( & eth_globals.protos_lock );
364
            free( proto );
365
            return ERROR_CODE;
366
        }
367
    }
4163 mejdrech 368
    printf( "\nNew protocol registered:\n\tprotocol\t= %d\n\tservice\t= %d\n\tphone\t= %d", proto->protocol, proto->service, proto->phone );
3992 mejdrech 369
    rwlock_write_unlock( & eth_globals.protos_lock );
370
    return EOK;
371
}
372
 
4153 mejdrech 373
int eth_prepare_packet( int dummy, packet_t packet, uint8_t * src_addr, int ethertype ){
3992 mejdrech 374
    eth_header_ex_ref   header;
4075 mejdrech 375
    eth_fcs_ref         fcs;
3992 mejdrech 376
    uint8_t *           src;
377
    uint8_t *           dest;
378
    int                 length;
379
    int                 i;
4075 mejdrech 380
    void *              padding;
4153 mejdrech 381
    eth_preamble_ref    preamble;
3992 mejdrech 382
 
4153 mejdrech 383
    if( dummy ){
384
        preamble = PACKET_PREFIX( packet, eth_preamble_t );
385
        if( ! preamble ) return ENOMEM;
386
        for( i = 0; i < 7; ++ i ) preamble->preamble[ i ] = ETH_PREAMBLE;
387
        preamble->sfd = ETH_SFD;
388
    }
3992 mejdrech 389
    header = PACKET_PREFIX( packet, eth_header_ex_t );
390
    if( ! header ) return ENOMEM;
391
    length = packet_get_addr( packet, & src, & dest );
392
    if( length < 0 ) return length;
393
    if( length < ETH_ADDR ) return EINVAL;
4075 mejdrech 394
    memcpy( header->header.src, src_addr, ETH_ADDR );
395
    memcpy( & header->header.dest, dest, ETH_ADDR );
3992 mejdrech 396
    length = packet_get_data_length( packet );
397
    if( length > ETH_MAX_CONTENT ) return EINVAL;
398
    if( length < ETH_MIN_CONTENT ){
4075 mejdrech 399
        padding = packet_suffix( packet, ETH_MIN_CONTENT - length );
400
        if( ! padding ) return ENOMEM;
401
        memset( padding, 0, ETH_MIN_CONTENT - length );
3992 mejdrech 402
    }
403
    header->header.ethertype = htons( length );
404
    header->lsap.dsap = 0xAA;
405
    header->lsap.ssap = header->lsap.dsap;
406
    header->lsap.ctrl = 0;
407
    for( i = 0; i < 3; ++ i ) header->snap.proto[ i ] = 0;
4075 mejdrech 408
    header->snap.ethertype = ethertype;
4153 mejdrech 409
    if( dummy ){
410
        fcs = PACKET_SUFFIX( packet, eth_fcs_t );
411
        if( ! fcs ) return ENOMEM;
412
        * fcs = htonl( ~ compute_crc32( ~ 0, & header->header.dest, ((( void * ) fcs ) - (( void * ) & header->header.dest )) * 8 ));
413
    }
4075 mejdrech 414
    return EOK;
415
}
416
 
417
int eth_send_message( device_id_t device_id, packet_t packet, services_t sender ){
418
    ERROR_DECLARE;
419
 
420
    eth_device_ref      device;
421
    packet_t            next;
422
    packet_t            tmp;
423
    int                 ethertype;
424
 
425
    ethertype = htons( protocol_map( SERVICE_ETHERNET, sender ));
426
    if( ! ethertype ){
427
        packet_release( eth_globals.networking_phone, packet_get_id( packet ));
428
        return EINVAL;
3992 mejdrech 429
    }
4075 mejdrech 430
    rwlock_read_lock( & eth_globals.devices_lock );
431
    device = eth_devices_find( & eth_globals.devices, device_id );
432
    if( ! device ){
433
        rwlock_read_unlock( & eth_globals.devices_lock );
434
        return ENOENT;
435
    }
436
    // proccess packet queue
437
    next = packet;
438
    do{
4153 mejdrech 439
        if( ERROR_OCCURRED( eth_prepare_packet( device->dummy, next, ( uint8_t * ) device->addr->value, ethertype ))){
4075 mejdrech 440
            // release invalid packet
441
            tmp = pq_detach( next );
442
            packet_release( eth_globals.networking_phone, packet_get_id( next ));
443
            next = tmp;
444
        }else{
445
            next = pq_next( next );
446
        }
447
    }while( next );
448
    // send packet queue
449
    async_msg_2( device->phone, NET_NETIF_SEND, device_id, packet_get_id( packet ));
450
    rwlock_read_unlock( & eth_globals.devices_lock );
3992 mejdrech 451
    return EOK;
452
}
453
 
454
int eth_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
455
    ERROR_DECLARE;
456
 
457
    measured_string_ref address;
458
    packet_t            packet;
459
 
460
    * answer_count = 0;
461
    switch( IPC_GET_METHOD( * call )){
462
        case IPC_M_PHONE_HUNGUP:
463
            return EOK;
464
        case NET_NIL_DEVICE:
465
            return eth_device_message( IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ), IPC_GET_MTU( call ));
466
        case NET_NIL_SEND:
467
            ERROR_PROPAGATE( packet_translate( eth_globals.networking_phone, & packet, IPC_GET_PACKET( call )));
468
            return eth_send_message( IPC_GET_DEVICE( call ), packet, IPC_GET_SERVICE( call ));
469
        case NET_NIL_PACKET_SPACE:
470
            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 )));
471
            * answer_count = 3;
472
            return EOK;
473
        case NET_NIL_ADDR:
474
            rwlock_read_lock( & eth_globals.devices_lock );
475
            if( ! ERROR_OCCURRED( eth_addr_message( IPC_GET_DEVICE( call ), ETH_LOCAL_ADDR, & address ))){
476
                 ERROR_CODE = measured_strings_reply( address, 1 );
477
            }
478
            rwlock_read_unlock( & eth_globals.devices_lock );
479
            return ERROR_CODE;
480
        case NET_NIL_BROADCAST_ADDR:
481
            rwlock_read_lock( & eth_globals.devices_lock );
482
            if( ! ERROR_OCCURRED( eth_addr_message( IPC_GET_DEVICE( call ), ETH_BROADCAST_ADDR, & address ))){
483
                 ERROR_CODE = measured_strings_reply( address, 1 );
484
            }
485
            rwlock_read_unlock( & eth_globals.devices_lock );
486
            return ERROR_CODE;
487
        case IPC_M_CONNECT_TO_ME:
488
            return eth_register_message( IPC_GET_PROTO( call ), IPC_GET_PHONE( call ));
489
    }
490
    return ENOTSUP;
491
}
492
 
493
void eth_receiver( ipc_callid_t iid, ipc_call_t * icall ){
494
    ERROR_DECLARE;
495
 
496
    packet_t        packet;
497
 
498
    while( true ){
499
        switch( IPC_GET_METHOD( * icall )){
500
            case NET_NIL_DEVICE_STATE:
501
                //TODO clear device if off?
502
                break;
503
            case NET_NIL_RECEIVED:
504
                if( ! ERROR_OCCURRED( packet_translate( eth_globals.networking_phone, & packet, IPC_GET_PACKET( icall )))){
505
                    ERROR_CODE = eth_receive_message( IPC_GET_DEVICE( icall ), packet );
506
                }
507
                ipc_answer_0( iid, ERROR_CODE );
508
                break;
509
            default:
510
                ipc_answer_0( iid, ENOTSUP );
511
        }
512
        iid = async_get_call( icall );
513
    }
514
}
515
 
516
/** @}
517
 */