Subversion Repositories HelenOS

Rev

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

Rev Author Line No. Line
3846 mejdrech 1
/*
3912 mejdrech 2
 * Copyright (c) 2009 Lukas Mejdrech
3846 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 arp
30
 *  @{
31
 */
32
 
33
/** @file
3912 mejdrech 34
 *  ARP module implementation.
35
 *  @see arp.h
3846 mejdrech 36
 */
37
 
38
#include <async.h>
39
#include <malloc.h>
4192 mejdrech 40
#include <mem.h>
4582 mejdrech 41
#include <fibril_sync.h>
3846 mejdrech 42
#include <stdio.h>
4327 mejdrech 43
#include <string.h>
4307 mejdrech 44
#include <task.h>
3846 mejdrech 45
 
46
#include <ipc/ipc.h>
47
#include <ipc/services.h>
48
 
3886 mejdrech 49
#include "../../err.h"
50
#include "../../messages.h"
51
#include "../../modules.h"
3846 mejdrech 52
 
4243 mejdrech 53
#include "../../include/byteorder.h"
54
#include "../../include/device.h"
4307 mejdrech 55
#include "../../include/arp_interface.h"
56
#include "../../include/nil_interface.h"
3886 mejdrech 57
#include "../../include/protocol_map.h"
3846 mejdrech 58
 
3886 mejdrech 59
#include "../../structures/measured_strings.h"
60
#include "../../structures/packet/packet.h"
3901 mejdrech 61
#include "../../structures/packet/packet_client.h"
3886 mejdrech 62
 
4307 mejdrech 63
#include "../il_messages.h"
64
 
3846 mejdrech 65
#include "arp.h"
66
#include "arp_header.h"
67
#include "arp_oc.h"
68
#include "arp_module.h"
4307 mejdrech 69
#include "arp_messages.h"
3846 mejdrech 70
 
3912 mejdrech 71
/** ARP global data.
72
 */
3846 mejdrech 73
arp_globals_t   arp_globals;
74
 
3912 mejdrech 75
/** Creates new protocol specific data.
4723 mejdrech 76
 *  Allocates and returns the needed memory block as the proto parameter.
77
 *  @param proto The allocated protocol specific data. Output parameter.
78
 *  @param service The protocol module service. Input parameter.
79
 *  @param address The actual protocol device address. Input parameter.
3912 mejdrech 80
 *  @returns EOK on success.
81
 *  @returns ENOMEM if there is not enough memory left.
82
 */
83
int arp_proto_create( arp_proto_ref * proto, services_t service, measured_string_ref address );
84
 
4702 mejdrech 85
/** Clears the device specific data.
86
 *  @param device The device specific data.
87
 */
88
void    clear_device( arp_device_ref device );
89
 
90
/** @name Message processing functions
91
 */
92
/*@{*/
93
 
3912 mejdrech 94
/** Registers the device.
95
 *  Creates new device entry in the cache or updates the protocol address if the device with the device identifier and the driver service exists.
96
 *  @param device_id The device identifier. Input parameter.
97
 *  @param service The device driver service. Input parameter.
98
 *  @param protocol The protocol service. Input parameter.
99
 *  @param address The actual device protocol address.
100
 *  @returns EOK on success.
101
 *  @returns EEXIST if another device with the same device identifier and different driver service exists.
102
 *  @returns ENOMEM if there is not enough memory left.
103
 *  @returns Other error codes as defined for the measured_strings_return() function.
104
 */
105
int arp_device_message( device_id_t device_id, services_t service, services_t protocol, measured_string_ref address );
106
 
107
/** Returns the hardware address for the given protocol address.
108
 *  Sends the ARP request packet if the hardware address is not found in the cache.
109
 *  @param device_id The device identifier. Input parameter.
110
 *  @param protocol The protocol service. Input parameter.
111
 *  @param target The target protocol address. Input parameter.
112
 *  @returns The hardware address of the target.
113
 *  @returns NULL if the target parameter is NULL.
114
 *  @returns NULL if the device is not found.
115
 *  @returns NULL if the device packet is too small to send a&nbsp;request.
116
 *  @returns NULL if the hardware address is not found in the cache.
117
 */
118
measured_string_ref arp_translate_message( device_id_t device_id, services_t protocol, measured_string_ref target );
119
 
120
/** Processes the received ARP packet.
121
 *  Updates the source hardware address if the source entry exists or the packet is targeted to my protocol address.
122
 *  Responses to the ARP request if the packet is the ARP request and is targeted to my address.
123
 *  @param device_id The source device identifier. Input parameter.
124
 *  @param packet The received packet. Input/output parameter.
4394 mejdrech 125
 *  @returns EOK on success and the packet is no longer needed.
126
 *  @returns 1 on success and the packet has been reused.
4702 mejdrech 127
 *  @returns EINVAL if the packet is too small to carry an ARP packet.
3912 mejdrech 128
 *  @returns EINVAL if the received address lengths differs from the registered values.
129
 *  @returns ENOENT if the device is not found in the cache.
130
 *  @returns ENOENT if the protocol for the device is not found in the cache.
131
 *  @returns ENOMEM if there is not enough memory left.
132
 */
133
int arp_receive_message( device_id_t device_id, packet_t packet );
134
 
4695 mejdrech 135
/** Updates the device content length according to the new MTU value.
136
 *  @param device_id The device identifier. Input parameter.
137
 *  @param mtu The new mtu value. Input parameter.
4702 mejdrech 138
 *  @returns ENOENT if device is not found.
4695 mejdrech 139
 *  @returns EOK on success.
140
 */
4702 mejdrech 141
int arp_mtu_changed_message( device_id_t device_id, size_t mtu );
4695 mejdrech 142
 
4702 mejdrech 143
/*@}*/
144
 
3846 mejdrech 145
DEVICE_MAP_IMPLEMENT( arp_cache, arp_device_t )
146
 
147
INT_MAP_IMPLEMENT( arp_protos, arp_proto_t )
148
 
149
GENERIC_CHAR_MAP_IMPLEMENT( arp_addr, measured_string_t )
150
 
4501 mejdrech 151
task_id_t arp_task_get_id( void ){
4307 mejdrech 152
    return task_get_id();
153
}
154
 
155
int arp_clear_device_req( int arp_phone, device_id_t device_id ){
4271 mejdrech 156
    arp_device_ref  device;
157
 
4582 mejdrech 158
    fibril_rwlock_write_lock( & arp_globals.lock );
4271 mejdrech 159
    device = arp_cache_find( & arp_globals.cache, device_id );
160
    if( ! device ){
4582 mejdrech 161
        fibril_rwlock_write_unlock( & arp_globals.lock );
4271 mejdrech 162
        return ENOENT;
163
    }
164
    clear_device( device );
4307 mejdrech 165
    printf( "Device %d cleared\n", device_id );
4582 mejdrech 166
    fibril_rwlock_write_unlock( & arp_globals.lock );
4271 mejdrech 167
    return EOK;
168
}
169
 
4695 mejdrech 170
int arp_clear_address_req( int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address ){
171
    arp_device_ref  device;
172
    arp_proto_ref   proto;
173
 
174
    fibril_rwlock_write_lock( & arp_globals.lock );
175
    device = arp_cache_find( & arp_globals.cache, device_id );
176
    if( ! device ){
177
        fibril_rwlock_write_unlock( & arp_globals.lock );
178
        return ENOENT;
179
    }
180
    proto = arp_protos_find( & device->protos, protocol );
181
    if( ! proto ){
182
        fibril_rwlock_write_unlock( & arp_globals.lock );
183
        return ENOENT;
184
    }
185
    arp_addr_exclude( & proto->addresses, address->value, address->length );
186
    fibril_rwlock_write_unlock( & arp_globals.lock );
187
    return EOK;
188
}
189
 
4307 mejdrech 190
int arp_clean_cache_req( int arp_phone ){
4271 mejdrech 191
    int             count;
192
    arp_device_ref  device;
193
 
4582 mejdrech 194
    fibril_rwlock_write_lock( & arp_globals.lock );
4271 mejdrech 195
    for( count = arp_cache_count( & arp_globals.cache ) - 1; count >= 0; -- count ){
196
        device = arp_cache_get_index( & arp_globals.cache, count );
197
        if( device ){
198
            clear_device( device );
199
            if( device->addr_data ) free( device->addr_data );
200
            if( device->broadcast_data ) free( device->broadcast_data );
201
        }
202
    }
203
    arp_cache_clear( & arp_globals.cache );
4582 mejdrech 204
    fibril_rwlock_write_unlock( & arp_globals.lock );
4307 mejdrech 205
    printf( "Cache cleaned\n" );
4271 mejdrech 206
    return EOK;
207
}
208
 
4307 mejdrech 209
int arp_device_req( int arp_phone, device_id_t device_id, services_t protocol, services_t netif, measured_string_ref address ){
4271 mejdrech 210
    ERROR_DECLARE;
211
 
212
    measured_string_ref tmp;
213
 
4723 mejdrech 214
    // copy the given address for exclusive use
4271 mejdrech 215
    tmp = measured_string_copy( address );
216
    if( ERROR_OCCURRED( arp_device_message( device_id, netif, protocol, tmp ))){
217
        free( tmp->value );
218
        free( tmp );
219
    }
220
    return ERROR_CODE;
221
}
222
 
4307 mejdrech 223
int arp_translate_req( int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address, measured_string_ref * translation, char ** data ){
4271 mejdrech 224
    measured_string_ref tmp;
225
 
4582 mejdrech 226
    fibril_rwlock_read_lock( & arp_globals.lock );
4271 mejdrech 227
    tmp = arp_translate_message( device_id, protocol, address );
228
    if( tmp ){
229
        * translation = measured_string_copy( tmp );
4582 mejdrech 230
        fibril_rwlock_read_unlock( & arp_globals.lock );
4271 mejdrech 231
        if( * translation ){
232
            * data = ( ** translation ).value;
233
            return EOK;
234
        }else{
235
            return ENOMEM;
236
        }
237
    }else{
4582 mejdrech 238
        fibril_rwlock_read_unlock( & arp_globals.lock );
4271 mejdrech 239
        return ENOENT;
240
    }
241
}
242
 
4351 mejdrech 243
int arp_initialize( async_client_conn_t client_connection ){
3991 mejdrech 244
    ERROR_DECLARE;
245
 
4582 mejdrech 246
    fibril_rwlock_initialize( & arp_globals.lock );
247
    fibril_rwlock_write_lock( & arp_globals.lock );
4351 mejdrech 248
    arp_globals.client_connection = client_connection;
3991 mejdrech 249
    ERROR_PROPAGATE( arp_cache_initialize( & arp_globals.cache ));
4582 mejdrech 250
    fibril_rwlock_write_unlock( & arp_globals.lock );
3991 mejdrech 251
    return EOK;
3846 mejdrech 252
}
253
 
254
int arp_proto_create( arp_proto_ref * proto, services_t service, measured_string_ref address ){
255
    ERROR_DECLARE;
256
 
257
    * proto = ( arp_proto_ref ) malloc( sizeof( arp_proto_t ));
258
    if( !( * proto )) return ENOMEM;
259
    ( ** proto ).service = service;
260
    ( ** proto ).addr = address;
261
    ( ** proto ).addr_data = address->value;
3912 mejdrech 262
    if( ERROR_OCCURRED( arp_addr_initialize( &( ** proto).addresses ))){
3846 mejdrech 263
        free( * proto );
264
        return ERROR_CODE;
265
    }
266
    return EOK;
267
}
268
 
269
int arp_device_message( device_id_t device_id, services_t service, services_t protocol, measured_string_ref address ){
270
    ERROR_DECLARE;
271
 
272
    arp_device_ref  device;
273
    arp_proto_ref   proto;
4192 mejdrech 274
    int             index;
4558 mejdrech 275
    hw_type_t       hardware;
3846 mejdrech 276
 
4582 mejdrech 277
    fibril_rwlock_write_lock( & arp_globals.lock );
3846 mejdrech 278
    // an existing device?
279
    device = arp_cache_find( & arp_globals.cache, device_id );
280
    if( device ){
3991 mejdrech 281
        if( device->service != service ){
4307 mejdrech 282
            printf( "Device %d already exists\n", device->device_id );
4582 mejdrech 283
            fibril_rwlock_write_unlock( & arp_globals.lock );
3991 mejdrech 284
            return EEXIST;
285
        }
3846 mejdrech 286
        proto = arp_protos_find( & device->protos, protocol );
287
        if( proto ){
288
            free( proto->addr );
289
            free( proto->addr_data );
290
            proto->addr = address;
291
            proto->addr_data = address->value;
292
        }else{
3991 mejdrech 293
            if( ERROR_OCCURRED( arp_proto_create( & proto, protocol, address ))){
4582 mejdrech 294
                fibril_rwlock_write_unlock( & arp_globals.lock );
3991 mejdrech 295
                return ERROR_CODE;
296
            }
4192 mejdrech 297
            index = arp_protos_add( & device->protos, proto->service, proto );
298
            if( index < 0 ){
4582 mejdrech 299
                fibril_rwlock_write_unlock( & arp_globals.lock );
3846 mejdrech 300
                free( proto );
4261 mejdrech 301
                return index;
3846 mejdrech 302
            }
4332 mejdrech 303
            printf( "New protocol added:\n\tdevice id\t= %d\n\tproto\t= %d", device_id, protocol );
3846 mejdrech 304
        }
305
    }else{
4558 mejdrech 306
        hardware = hardware_map( service );
307
        if( ! hardware ) return ENOENT;
3846 mejdrech 308
        // create a new device
309
        device = ( arp_device_ref ) malloc( sizeof( arp_device_t ));
3991 mejdrech 310
        if( ! device ){
4582 mejdrech 311
            fibril_rwlock_write_unlock( & arp_globals.lock );
3991 mejdrech 312
            return ENOMEM;
313
        }
4558 mejdrech 314
        device->hardware = hardware;
3846 mejdrech 315
        device->device_id = device_id;
3912 mejdrech 316
        if( ERROR_OCCURRED( arp_protos_initialize( & device->protos ))
317
        || ERROR_OCCURRED( arp_proto_create( & proto, protocol, address ))){
4582 mejdrech 318
            fibril_rwlock_write_unlock( & arp_globals.lock );
3846 mejdrech 319
            free( device );
320
            return ERROR_CODE;
321
        }
4192 mejdrech 322
        index = arp_protos_add( & device->protos, proto->service, proto );
323
        if( index < 0 ){
4582 mejdrech 324
            fibril_rwlock_write_unlock( & arp_globals.lock );
3846 mejdrech 325
            arp_protos_destroy( & device->protos );
326
            free( device );
4192 mejdrech 327
            return index;
3846 mejdrech 328
        }
329
        device->service = service;
330
        // bind the new one
4743 mejdrech 331
        device->phone = nil_bind_service( device->service, ( ipcarg_t ) device->device_id, SERVICE_ARP, arp_globals.client_connection );
4192 mejdrech 332
        if( device->phone < 0 ){
4582 mejdrech 333
            fibril_rwlock_write_unlock( & arp_globals.lock );
4192 mejdrech 334
            arp_protos_destroy( & device->protos );
335
            free( device );
336
            return EREFUSED;
337
        }
3846 mejdrech 338
        // get packet dimensions
4261 mejdrech 339
        if( ERROR_OCCURRED( nil_packet_size_req( device->phone, device_id, & device->addr_len, & device->prefix, & device->content, & device->suffix ))){
4582 mejdrech 340
            fibril_rwlock_write_unlock( & arp_globals.lock );
3846 mejdrech 341
            arp_protos_destroy( & device->protos );
342
            free( device );
343
            return ERROR_CODE;
344
        }
345
        // get hardware address
4743 mejdrech 346
        if( ERROR_OCCURRED( nil_get_addr_req( device->phone, device_id, & device->addr, & device->addr_data ))){
4582 mejdrech 347
            fibril_rwlock_write_unlock( & arp_globals.lock );
3846 mejdrech 348
            arp_protos_destroy( & device->protos );
349
            free( device );
350
            return ERROR_CODE;
351
        }
352
        // get broadcast address
4743 mejdrech 353
        if( ERROR_OCCURRED( nil_get_broadcast_addr_req( device->phone, device_id, & device->broadcast_addr, & device->broadcast_data ))){
4582 mejdrech 354
            fibril_rwlock_write_unlock( & arp_globals.lock );
3846 mejdrech 355
            free( device->addr );
356
            free( device->addr_data );
357
            arp_protos_destroy( & device->protos );
358
            free( device );
359
            return ERROR_CODE;
360
        }
4261 mejdrech 361
        if( ERROR_OCCURRED( arp_cache_add( & arp_globals.cache, device->device_id, device ))){
4582 mejdrech 362
            fibril_rwlock_write_unlock( & arp_globals.lock );
3846 mejdrech 363
            free( device->addr );
364
            free( device->addr_data );
365
            free( device->broadcast_addr );
366
            free( device->broadcast_data );
367
            arp_protos_destroy( & device->protos );
368
            free( device );
369
            return ERROR_CODE;
370
        }
4332 mejdrech 371
        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 );
3846 mejdrech 372
    }
4582 mejdrech 373
    fibril_rwlock_write_unlock( & arp_globals.lock );
3846 mejdrech 374
    return EOK;
375
}
376
 
377
measured_string_ref arp_translate_message( device_id_t device_id, services_t protocol, measured_string_ref target ){
378
    arp_device_ref      device;
379
    arp_proto_ref       proto;
380
    measured_string_ref addr;
381
    size_t              length;
382
    packet_t            packet;
383
    arp_header_ref      header;
384
 
385
    if( ! target ) return NULL;
386
    device = arp_cache_find( & arp_globals.cache, device_id );
4243 mejdrech 387
    if( ! device ) return NULL;
3846 mejdrech 388
    proto = arp_protos_find( & device->protos, protocol );
4243 mejdrech 389
    if(( ! proto ) || ( proto->addr->length != target->length )) return NULL;
3846 mejdrech 390
    addr = arp_addr_find( & proto->addresses, target->value, target->length );
4243 mejdrech 391
    if( addr ) return addr;
3846 mejdrech 392
    // ARP packet content size = header + ( address + translation ) * 2
393
    length = 8 + ( CONVERT_SIZE( char, uint8_t, proto->addr->length ) + CONVERT_SIZE( char, uint8_t, device->addr->length )) * 2;
4243 mejdrech 394
    if( length > device->content ) return NULL;
4307 mejdrech 395
    packet = packet_get_4( arp_globals.net_phone, device->addr_len, device->prefix, length, device->suffix );
4243 mejdrech 396
    if( ! packet ) return NULL;
3912 mejdrech 397
    header = ( arp_header_ref ) packet_suffix( packet, length );
4394 mejdrech 398
    if( ! header ){
4396 mejdrech 399
        pq_release( arp_globals.net_phone, packet_get_id( packet ));
4394 mejdrech 400
        return NULL;
401
    }
4243 mejdrech 402
    header->hardware = htons( device->hardware );
4558 mejdrech 403
    header->hardware_length = ( uint8_t ) device->addr->length;
4243 mejdrech 404
    header->protocol = htons( protocol_map( device->service, protocol ));
4558 mejdrech 405
    header->protocol_length = ( uint8_t ) proto->addr->length;
4243 mejdrech 406
    header->operation = htons( ARPOP_REQUEST );
3846 mejdrech 407
    length = sizeof( arp_header_t );
408
    memcpy((( uint8_t * ) header ) + length, device->addr->value, device->addr->length );
409
    length += device->addr->length;
410
    memcpy((( uint8_t * ) header ) + length, proto->addr->value, proto->addr->length );
411
    length += proto->addr->length;
4192 mejdrech 412
    bzero((( uint8_t * ) header ) + length, device->addr->length );
3846 mejdrech 413
    length += device->addr->length;
414
    memcpy((( uint8_t * ) header ) + length, target->value, target->length );
4394 mejdrech 415
    if( packet_set_addr( packet, ( uint8_t * ) device->addr->value, ( uint8_t * ) device->broadcast_addr->value, CONVERT_SIZE( char, uint8_t, device->addr->length )) != EOK ){
4396 mejdrech 416
        pq_release( arp_globals.net_phone, packet_get_id( packet ));
4394 mejdrech 417
        return NULL;
418
    }
4261 mejdrech 419
    nil_send_msg( device->phone, device_id, packet, SERVICE_ARP );
3846 mejdrech 420
    return NULL;
421
}
422
 
423
int arp_receive_message( device_id_t device_id, packet_t packet ){
424
    ERROR_DECLARE;
425
 
426
    size_t              length;
427
    arp_header_ref      header;
428
    arp_device_ref      device;
429
    arp_proto_ref       proto;
430
    measured_string_ref hw_source;
3991 mejdrech 431
    uint8_t *           src_hw;
3912 mejdrech 432
    uint8_t *           src_proto;
433
    uint8_t *           des_hw;
434
    uint8_t *           des_proto;
3846 mejdrech 435
 
436
    length = packet_get_data_length( packet );
437
    if( length <= sizeof( arp_header_t )) return EINVAL;
438
    device = arp_cache_find( & arp_globals.cache, device_id );
4243 mejdrech 439
    if( ! device ) return ENOENT;
3846 mejdrech 440
    header = ( arp_header_ref ) packet_get_data( packet );
4243 mejdrech 441
    if(( ntohs( header->hardware ) != device->hardware )
4708 mejdrech 442
    || ( length < sizeof( arp_header_t ) + header->hardware_length * 2u + header->protocol_length * 2u )){
3991 mejdrech 443
        return EINVAL;
444
    }
4243 mejdrech 445
    proto = arp_protos_find( & device->protos, protocol_unmap( device->service, ntohs( header->protocol )));
446
    if( ! proto ) return ENOENT;
3912 mejdrech 447
    src_hw = (( uint8_t * ) header ) + sizeof( arp_header_t );
3846 mejdrech 448
    src_proto = src_hw + header->hardware_length;
449
    des_hw = src_proto + header->protocol_length;
450
    des_proto = des_hw + header->hardware_length;
3912 mejdrech 451
    hw_source = arp_addr_find( & proto->addresses, ( char * ) src_proto, CONVERT_SIZE( uint8_t, char, header->protocol_length ));
3846 mejdrech 452
    // exists?
453
    if( hw_source ){
3991 mejdrech 454
        if( hw_source->length != CONVERT_SIZE( uint8_t, char, header->hardware_length )){
455
            return EINVAL;
456
        }
3912 mejdrech 457
        memcpy( hw_source->value, src_hw, hw_source->length );
3846 mejdrech 458
    }
459
    // is my protocol address?
4332 mejdrech 460
    if( proto->addr->length != CONVERT_SIZE( uint8_t, char, header->protocol_length )){
3991 mejdrech 461
        return EINVAL;
3846 mejdrech 462
    }
4327 mejdrech 463
    if( ! str_lcmp( proto->addr->value, ( char * ) des_proto, proto->addr->length )){
3846 mejdrech 464
        // not already upadted?
465
        if( ! hw_source ){
3912 mejdrech 466
            hw_source = measured_string_create_bulk(( char * ) src_hw, CONVERT_SIZE( uint8_t, char, header->hardware_length ));
4243 mejdrech 467
            if( ! hw_source ) return ENOMEM;
468
            ERROR_PROPAGATE( arp_addr_add( & proto->addresses, ( char * ) src_proto, CONVERT_SIZE( uint8_t, char, header->protocol_length ), hw_source ));
3846 mejdrech 469
        }
4243 mejdrech 470
        if( ntohs( header->operation ) == ARPOP_REQUEST ){
471
            header->operation = htons( ARPOP_REPLY );
3991 mejdrech 472
            memcpy( des_proto, src_proto, header->protocol_length );
3846 mejdrech 473
            memcpy( src_proto, proto->addr->value, header->protocol_length );
4332 mejdrech 474
            memcpy( src_hw, device->addr->value, device->addr_len );
3912 mejdrech 475
            memcpy( des_hw, hw_source->value, header->hardware_length );
4394 mejdrech 476
            ERROR_PROPAGATE( packet_set_addr( packet, src_hw, des_hw, header->hardware_length ));
4261 mejdrech 477
            nil_send_msg( device->phone, device_id, packet, SERVICE_ARP );
4394 mejdrech 478
            return 1;
3846 mejdrech 479
        }
480
    }
481
    return EOK;
482
}
483
 
484
void clear_device( arp_device_ref device ){
485
    int             count;
486
    arp_proto_ref   proto;
487
 
4192 mejdrech 488
    for( count = arp_protos_count( & device->protos ) - 1; count >= 0; -- count ){
3846 mejdrech 489
        proto = arp_protos_get_index( & device->protos, count );
4192 mejdrech 490
        if( proto ){
491
            if( proto->addr ) free( proto->addr );
492
            if( proto->addr_data ) free( proto->addr_data );
493
            arp_addr_destroy( & proto->addresses );
494
        }
3846 mejdrech 495
    }
496
    arp_protos_clear( & device->protos );
497
}
498
 
4307 mejdrech 499
int arp_connect_module( services_t service ){
4708 mejdrech 500
    if( service != SERVICE_ARP ) return EINVAL;
4307 mejdrech 501
    return EOK;
502
}
503
 
4702 mejdrech 504
int arp_mtu_changed_message( device_id_t device_id, size_t mtu ){
4695 mejdrech 505
    arp_device_ref  device;
506
 
507
    fibril_rwlock_write_lock( & arp_globals.lock );
508
    device = arp_cache_find( & arp_globals.cache, device_id );
509
    if( ! device ){
510
        fibril_rwlock_write_unlock( & arp_globals.lock );
511
        return ENOENT;
512
    }
513
    device->content = mtu;
514
    printf( "arp - device %d changed mtu to %d\n\n", device_id, mtu );
515
    fibril_rwlock_write_unlock( & arp_globals.lock );
516
    return EOK;
517
}
518
 
3846 mejdrech 519
int arp_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
520
    ERROR_DECLARE;
521
 
522
    measured_string_ref address;
523
    measured_string_ref translation;
524
    char *              data;
4351 mejdrech 525
    packet_t            packet;
4394 mejdrech 526
    packet_t            next;
3846 mejdrech 527
 
4307 mejdrech 528
//  printf( "message %d - %d\n", IPC_GET_METHOD( * call ), NET_ARP_FIRST );
3846 mejdrech 529
    * answer_count = 0;
530
    switch( IPC_GET_METHOD( * call )){
531
        case IPC_M_PHONE_HUNGUP:
532
            return EOK;
533
        case NET_ARP_DEVICE:
534
            ERROR_PROPAGATE( measured_strings_receive( & address, & data, 1 ));
4307 mejdrech 535
            if( ERROR_OCCURRED( arp_device_message( IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ), ARP_GET_NETIF( call ), address ))){
3846 mejdrech 536
                free( address );
537
                free( data );
538
            }
539
            return ERROR_CODE;
540
        case NET_ARP_TRANSLATE:
541
            ERROR_PROPAGATE( measured_strings_receive( & address, & data, 1 ));
4582 mejdrech 542
            fibril_rwlock_read_lock( & arp_globals.lock );
4307 mejdrech 543
            translation = arp_translate_message( IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ), address );
3846 mejdrech 544
            free( address );
545
            free( data );
4243 mejdrech 546
            if( ! translation ){
4582 mejdrech 547
                fibril_rwlock_read_unlock( & arp_globals.lock );
4243 mejdrech 548
                return ENOENT;
549
            }
550
            ERROR_CODE = measured_strings_reply( translation, 1 );
4582 mejdrech 551
            fibril_rwlock_read_unlock( & arp_globals.lock );
4243 mejdrech 552
            return ERROR_CODE;
3846 mejdrech 553
        case NET_ARP_CLEAR_DEVICE:
4307 mejdrech 554
            return arp_clear_device_req( 0, IPC_GET_DEVICE( call ));
4695 mejdrech 555
        case NET_ARP_CLEAR_ADDRESS:
556
            ERROR_PROPAGATE( measured_strings_receive( & address, & data, 1 ));
557
            arp_clear_address_req( 0, IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ), address );
558
            free( address );
559
            free( data );
560
            return EOK;
3846 mejdrech 561
        case NET_ARP_CLEAN_CACHE:
4307 mejdrech 562
            return arp_clean_cache_req( 0 );
4351 mejdrech 563
        case NET_IL_DEVICE_STATE:
564
            // do nothing - keep the cache
565
            return EOK;
566
        case NET_IL_RECEIVED:
567
            if( ! ERROR_OCCURRED( packet_translate( arp_globals.net_phone, & packet, IPC_GET_PACKET( call )))){
4582 mejdrech 568
                fibril_rwlock_read_lock( & arp_globals.lock );
4394 mejdrech 569
                do{
4501 mejdrech 570
                    next = pq_detach( packet );
4394 mejdrech 571
                    ERROR_CODE = arp_receive_message( IPC_GET_DEVICE( call ), packet );
572
                    if( ERROR_CODE != 1 ) pq_release( arp_globals.net_phone, packet_get_id( packet ));
573
                    packet = next;
574
                }while( packet );
4582 mejdrech 575
                fibril_rwlock_read_unlock( & arp_globals.lock );
4351 mejdrech 576
            }
577
            return ERROR_CODE;
4695 mejdrech 578
        case NET_IL_MTU_CHANGED:
4702 mejdrech 579
            return arp_mtu_changed_message( IPC_GET_DEVICE( call ), IPC_GET_MTU( call ));
3846 mejdrech 580
    }
581
    return ENOTSUP;
582
}
583
 
584
/** @}
585
 */