WebSVN – HelenOS – Diff – /branches/network/uspace/srv/net/il/arp/arp.c


/*
 * Copyright (c) 2009 Lukas Mejdrech
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup arp
 *  @{
 */
 
/** @file
 *  ARP module implementation.
 *  @see arp.h
 */
 
#include <async.h>
#include <malloc.h>
#include <rwlock.h>
#include <stdio.h>
#include <string.h>
 
#include <ipc/ipc.h>
#include <ipc/services.h>
 
#include "../../err.h"
#include "../../messages.h"
#include "../../modules.h"
 
#include "../../include/protocol_map.h"
#include "../../netif/device.h"
 
#include "../../structures/measured_strings.h"
#include "../../structures/packet/packet.h"
#include "../../structures/packet/packet_client.h"
 
#include "arp.h"
#include "arp_header.h"
#include "arp_oc.h"
//#include "arp_messages.h"
#include "arp_module.h"
 
/** Returns the device identifier message parameter.
 */
#define IPC_GET_DEVICE( call )      ( device_id_t ) IPC_GET_ARG1( * call )
 
/** Returns the packet identifier message parameter.
 */
#define IPC_GET_PACKET( call )      ( packet_id_t ) IPC_GET_ARG2( * call )
 
/** Returns the protocol service message parameter.
 */
#define IPC_GET_PROTO( call )       ( services_t ) IPC_GET_ARG2( * call )
 
/** Returns the device driver service message parameter.
 */
#define IPC_GET_SERVICE( call )     ( services_t ) IPC_GET_ARG3( * call )
 
/** ARP global data.
 */
arp_globals_t   arp_globals;
 
/** Creates new protocol specific data.
 *  @param proto Protocol specific data. Output parameter.
 *  @param service Protocol module service. Input parameter.
 *  @param address Actual protocol device address. Input parameter.
 *  @returns EOK on success.
 *  @returns ENOMEM if there is not enough memory left.
 */
int arp_proto_create( arp_proto_ref * proto, services_t service, measured_string_ref address );
 
/** Registers the device.
 *  Creates new device entry in the cache or updates the protocol address if the device with the device identifier and the driver service exists.
 *  @param device_id The device identifier. Input parameter.
 *  @param service The device driver service. Input parameter.
 *  @param protocol The protocol service. Input parameter.
 *  @param address The actual device protocol address.
 *  @returns EOK on success.
 *  @returns EEXIST if another device with the same device identifier and different driver service exists.
 *  @returns ENOMEM if there is not enough memory left.
 *  @returns Other error codes as defined for the measured_strings_return() function.
 */
int arp_device_message( device_id_t device_id, services_t service, services_t protocol, measured_string_ref address );
 
/** Returns the hardware address for the given protocol address.
 *  Sends the ARP request packet if the hardware address is not found in the cache.
 *  @param device_id The device identifier. Input parameter.
 *  @param protocol The protocol service. Input parameter.
 *  @param target The target protocol address. Input parameter.
 *  @returns The hardware address of the target.
 *  @returns NULL if the target parameter is NULL.
 *  @returns NULL if the device is not found.
 *  @returns NULL if the device packet is too small to send a&nbsp;request.
 *  @returns NULL if the hardware address is not found in the cache.
 */
measured_string_ref arp_translate_message( device_id_t device_id, services_t protocol, measured_string_ref target );
 
/** Processes the received ARP packet.
 *  Updates the source hardware address if the source entry exists or the packet is targeted to my protocol address.
 *  Responses to the ARP request if the packet is the ARP request and is targeted to my address.
 *  @param device_id The source device identifier. Input parameter.
 *  @param packet The received packet. Input/output parameter.
 *  @returns EOK on success.
 *  @returns EINVAL if the packet is too small to carry the ARP packet.
 *  @returns EINVAL if the received address lengths differs from the registered values.
 *  @returns ENOENT if the device is not found in the cache.
 *  @returns ENOENT if the protocol for the device is not found in the cache.
 *  @returns ENOMEM if there is not enough memory left.
 */
int arp_receive_message( device_id_t device_id, packet_t packet );
 
/** Clears the device specific data from the cache.
 *  @param device_id The device identifier. Input parameter.
 *  @returns EOK on success.
 *  @returns ENOENT  if the device is not found in the cache.
 */
int arp_clear_device_message( device_id_t device_id );
 
/** Clears the device specific data.
 *  @param device The device specific data.
 */
void    clear_device( arp_device_ref device );
 
/** Clears the whole cache.
 *  @returns EOK on success.
 */
int arp_clean_cache_message( void );
 
/** Processes IPC messages from the registered device driver modules in an infinite loop.
 *  @param iid The message identifier. Input parameter.
 *  @param icall The message parameters. Input/output parameter.
 */
void    arp_receiver( ipc_callid_t iid, ipc_call_t * icall );
 
DEVICE_MAP_IMPLEMENT( arp_cache, arp_device_t )
 
INT_MAP_IMPLEMENT( arp_protos, arp_proto_t )
 
GENERIC_CHAR_MAP_IMPLEMENT( arp_addr, measured_string_t )
 
int arp_initialize( void ){
    ERROR_DECLARE;
 
    rwlock_initialize( & arp_globals.lock );
    rwlock_write_lock( & arp_globals.lock );
    ERROR_PROPAGATE( arp_cache_initialize( & arp_globals.cache ));
    rwlock_write_unlock( & arp_globals.lock );
    return EOK;
}
 
int arp_proto_create( arp_proto_ref * proto, services_t service, measured_string_ref address ){
    ERROR_DECLARE;
 
    * proto = ( arp_proto_ref ) malloc( sizeof( arp_proto_t ));
    if( !( * proto )) return ENOMEM;
    ( ** proto ).service = service;
    ( ** proto ).addr = address;
    ( ** proto ).addr_data = address->value;
    if( ERROR_OCCURRED( arp_addr_initialize( &( ** proto).addresses ))){
        free( * proto );
        return ERROR_CODE;
    }
    return EOK;
}
 
int arp_device_message( device_id_t device_id, services_t service, services_t protocol, measured_string_ref address ){
    ERROR_DECLARE;
 
    arp_device_ref  device;
    aid_t           message;
    ipc_call_t      answer;
    ipcarg_t        result;
    arp_proto_ref   proto;
 
    rwlock_write_lock( & arp_globals.lock );
    // an existing device?
    device = arp_cache_find( & arp_globals.cache, device_id );
    if( device ){
        if( device->service != service ){
            printf( "\nDevice %d already exists", device->device_id );
            rwlock_write_unlock( & arp_globals.lock );
            return EEXIST;
        }
        proto = arp_protos_find( & device->protos, protocol );
        if( proto ){
            free( proto->addr );
            free( proto->addr_data );
            proto->addr = address;
            proto->addr_data = address->value;
        }else{
            if( ERROR_OCCURRED( arp_proto_create( & proto, protocol, address ))){
                rwlock_write_unlock( & arp_globals.lock );
                return ERROR_CODE;
            }
            if( ERROR_OCCURRED( arp_protos_add( & device->protos, proto->service, proto ))){
                rwlock_write_unlock( & arp_globals.lock );
                free( proto );
                return ERROR_CODE;
            }
        }
        printf( "\nCache of the existing device %d cleaned", device->device_id );
    }else{
        // create a new device
        device = ( arp_device_ref ) malloc( sizeof( arp_device_t ));
        if( ! device ){
            rwlock_write_unlock( & arp_globals.lock );
            return ENOMEM;
        }
        device->device_id = device_id;
        if( ERROR_OCCURRED( arp_protos_initialize( & device->protos ))
        || ERROR_OCCURRED( arp_proto_create( & proto, protocol, address ))){
            rwlock_write_unlock( & arp_globals.lock );
            free( device );
            return ERROR_CODE;
        }
        if( ERROR_OCCURRED( arp_protos_add( & device->protos, proto->service, proto ))){
            rwlock_write_unlock( & arp_globals.lock );
            arp_protos_destroy( & device->protos );
            free( device );
            return ERROR_CODE;
        }
        device->service = service;
        // bind the new one
        device->phone = bind_service( device->service, device->device_id, SERVICE_ARP, 0, arp_receiver );
        // get packet dimensions
        if( ERROR_OCCURRED( async_req_1_4( device->phone, NET_NIL_PACKET_SPACE, device_id, & device->addr_len, & device->prefix, & device->content, & device->suffix ))){
            rwlock_write_unlock( & arp_globals.lock );
            arp_protos_destroy( & device->protos );
            free( device );
            return ERROR_CODE;
        }
        // get hardware address
        message = async_send_1( device->phone, NET_NIL_ADDR, device->device_id, & answer );
        if( ERROR_OCCURRED( measured_strings_return( device->phone, & device->addr, & device->addr_data, 1 ))){
            rwlock_write_unlock( & arp_globals.lock );
            arp_protos_destroy( & device->protos );
            free( device );
            async_wait_for( message, NULL );
            return ERROR_CODE;
        }
        async_wait_for( message, & result );
        if( ERROR_OCCURRED( result )){
            rwlock_write_unlock( & arp_globals.lock );
            free( device->addr );
            free( device->addr_data );
            arp_protos_destroy( & device->protos );
            free( device );
            return ERROR_CODE;
        }
        // get broadcast address
        message = async_send_1( device->phone, NET_NIL_BROADCAST_ADDR, device->device_id, & answer );
        if( ERROR_OCCURRED( measured_strings_return( device->phone, & device->broadcast_addr, & device->broadcast_data, 1 ))){
            rwlock_write_unlock( & arp_globals.lock );
            free( device->addr );
            free( device->addr_data );
            arp_protos_destroy( & device->protos );
            free( device );
            async_wait_for( message, NULL );
            return ERROR_CODE;
        }
        async_wait_for( message, & result );
        // add to the cache
        if( ERROR_OCCURRED( result )
        || ERROR_OCCURRED( arp_cache_add( & arp_globals.cache, device->device_id, device ))){
            rwlock_write_unlock( & arp_globals.lock );
            free( device->addr );
            free( device->addr_data );
            free( device->broadcast_addr );
            free( device->broadcast_data );
            arp_protos_destroy( & device->protos );
            free( device );
            return ERROR_CODE;
        }
        printf( "\nNew device registered:\n\tid\t= %d\n\ttype\t= %x\n\tservice\t= %d", device->device_id, device->hardware, device->service );
    }
    rwlock_write_unlock( & arp_globals.lock );
    return EOK;
}
 
measured_string_ref arp_translate_message( device_id_t device_id, services_t protocol, measured_string_ref target ){
    arp_device_ref      device;
    arp_proto_ref       proto;
    measured_string_ref addr;
    size_t              length;
    packet_t            packet;
    arp_header_ref      header;
 
    if( ! target ) return NULL;
    rwlock_read_lock( & arp_globals.lock );
    device = arp_cache_find( & arp_globals.cache, device_id );
    if( ! device ){
        rwlock_read_unlock( & arp_globals.lock );
        return NULL;
    }
    proto = arp_protos_find( & device->protos, protocol );
    if(( ! proto ) || ( proto->addr->length != target->length )){
        rwlock_read_unlock( & arp_globals.lock );
        return NULL;
    }
    addr = arp_addr_find( & proto->addresses, target->value, target->length );
    if( addr ){
        rwlock_read_unlock( & arp_globals.lock );
        return addr;
    }
    // ARP packet content size = header + ( address + translation ) * 2
    length = 8 + ( CONVERT_SIZE( char, uint8_t, proto->addr->length ) + CONVERT_SIZE( char, uint8_t, device->addr->length )) * 2;
    if( length > device->content ){
        rwlock_read_unlock( & arp_globals.lock );
        return NULL;
    }
    packet = packet_get_4( arp_globals.networking_phone, device->addr_len, device->prefix, length, device->suffix );
    if( ! packet ){
        rwlock_read_unlock( & arp_globals.lock );
        return NULL;
    }
    header = ( arp_header_ref ) packet_suffix( packet, length );
    header->hardware = device->hardware;
    header->hardware_length = device->addr->length;
    header->protocol = protocol_map( device->service, protocol );
    header->protocol_length = proto->addr->length;
    header->operation = ARPOP_REQUEST;
    length = sizeof( arp_header_t );
    memcpy((( uint8_t * ) header ) + length, device->addr->value, device->addr->length );
    length += device->addr->length;
    memcpy((( uint8_t * ) header ) + length, proto->addr->value, proto->addr->length );
    length += proto->addr->length;
    memset((( uint8_t * ) header ) + length, 0, device->addr->length );
    length += device->addr->length;
    memcpy((( uint8_t * ) header ) + length, target->value, target->length );
    packet_set_addr( packet, ( uint8_t * ) device->addr->value, ( uint8_t * ) device->broadcast_addr->value, CONVERT_SIZE( char, uint8_t, device->addr->length ));
    async_msg_3( device->phone, NET_NETIF_SEND, device_id, SERVICE_ARP, packet_get_id( packet ));
    rwlock_read_unlock( & arp_globals.lock );
    return NULL;
}
 
int arp_receive_message( device_id_t device_id, packet_t packet ){
    ERROR_DECLARE;
 
    size_t              length;
    arp_header_ref      header;
    arp_device_ref      device;
    arp_proto_ref       proto;
    measured_string_ref hw_source;
    uint8_t *           src_hw;
    uint8_t *           src_proto;
    uint8_t *           des_hw;
    uint8_t *           des_proto;
 
    length = packet_get_data_length( packet );
    if( length <= sizeof( arp_header_t )) return EINVAL;
    rwlock_read_lock( & arp_globals.lock );
    device = arp_cache_find( & arp_globals.cache, device_id );
    if( ! device ){
        rwlock_read_unlock( & arp_globals.lock );
        return ENOENT;
    }
    header = ( arp_header_ref ) packet_get_data( packet );
    if(( header->hardware != device->hardware )
    || ( length < sizeof( arp_header_t ) + ( header->hardware_length + header->protocol_length ) * 2 )){
        rwlock_read_unlock( & arp_globals.lock );
        return EINVAL;
    }
    proto = arp_protos_find( & device->protos, protocol_unmap( device->service, header->protocol ));
    if( ! proto ){
        rwlock_read_unlock( & arp_globals.lock );
        return ENOENT;
    }
    src_hw = (( uint8_t * ) header ) + sizeof( arp_header_t );
    src_proto = src_hw + header->hardware_length;
    des_hw = src_proto + header->protocol_length;
    des_proto = des_hw + header->hardware_length;
    hw_source = arp_addr_find( & proto->addresses, ( char * ) src_proto, CONVERT_SIZE( uint8_t, char, header->protocol_length ));
    // exists?
    if( hw_source ){
        if( hw_source->length != CONVERT_SIZE( uint8_t, char, header->hardware_length )){
            rwlock_read_unlock( & arp_globals.lock );
            return EINVAL;
        }
        memcpy( hw_source->value, src_hw, hw_source->length );
    }
    // is my protocol address?
    if( proto->addr->length != CONVERT_SIZE( uint8_t, char, header->hardware_length )){
        rwlock_read_unlock( & arp_globals.lock );
        return EINVAL;
    }
    if( ! strncmp( proto->addr->value, ( char * ) des_proto, proto->addr->length )){
        // not already upadted?
        if( ! hw_source ){
            hw_source = measured_string_create_bulk(( char * ) src_hw, CONVERT_SIZE( uint8_t, char, header->hardware_length ));
            if( ! hw_source ){
                rwlock_read_unlock( & arp_globals.lock );
                return ENOMEM;
            }
            if( ERROR_OCCURRED( arp_addr_add( & proto->addresses, ( char * ) src_proto, CONVERT_SIZE( uint8_t, char, header->protocol_length ), hw_source ))){
                rwlock_read_unlock( & arp_globals.lock );
                return ERROR_CODE;
            }
        }
        if( header->operation == ARPOP_REQUEST ){
            header->operation = ARPOP_REPLY;
            memcpy( des_proto, src_proto, header->protocol_length );
            memcpy( src_proto, proto->addr->value, header->protocol_length );
            memcpy( src_hw, des_hw, header->hardware_length );
            memcpy( des_hw, hw_source->value, header->hardware_length );
            packet_set_addr( packet, src_hw, des_hw, header->hardware_length );
            async_msg_3( device->phone, NET_NETIF_SEND, device_id, SERVICE_ARP, packet_get_id( packet ));
            rwlock_read_unlock( & arp_globals.lock );
        }else{
            rwlock_read_unlock( & arp_globals.lock );
            packet_release( arp_globals.networking_phone, packet_get_id( packet ));
        }
    }
    return EOK;
}
 
int arp_clear_device_message( device_id_t device_id ){
    arp_device_ref  device;
 
    rwlock_write_lock( & arp_globals.lock );
    device = arp_cache_find( & arp_globals.cache, device_id );
    if( ! device ){
        rwlock_write_unlock( & arp_globals.lock );
        return ENOENT;
    }
    clear_device( device );
    printf( "\nDevice %d cleared", device_id );
    rwlock_write_unlock( & arp_globals.lock );
    return EOK;
}
 
void clear_device( arp_device_ref device ){
    int             count;
    arp_proto_ref   proto;
 
    count = arp_protos_count( & device->protos );
    while( count > 0 ){
        proto = arp_protos_get_index( & device->protos, count );
        if( proto->addr ) free( proto->addr );
        if( proto->addr_data ) free( proto->addr_data );
        arp_addr_destroy( & proto->addresses );
        -- count;
    }
    arp_protos_clear( & device->protos );
}
 
int arp_clean_cache_message( void ){
    int             count;
    arp_device_ref  device;
 
    rwlock_write_lock( & arp_globals.lock );
    count = arp_cache_count( & arp_globals.cache );
    while( count > 0 ){
        device = arp_cache_get_index( & arp_globals.cache, count );
        if( device ){
            clear_device( device );
            if( device->addr_data ) free( device->addr_data );
            if( device->broadcast_data ) free( device->broadcast_data );
        }
    }
    arp_cache_clear( & arp_globals.cache );
    rwlock_write_unlock( & arp_globals.lock );
    printf( "\nCache cleaned" );
    return EOK;
}
 
int arp_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
    ERROR_DECLARE;
 
    measured_string_ref address;
    measured_string_ref translation;
    char *              data;
 
    * answer_count = 0;
    switch( IPC_GET_METHOD( * call )){
        case IPC_M_PHONE_HUNGUP:
            return EOK;
        case NET_ARP_DEVICE:
            ERROR_PROPAGATE( measured_strings_receive( & address, & data, 1 ));
            if( ERROR_OCCURRED( arp_device_message( IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ), IPC_GET_PROTO( call ), address ))){
                free( address );
                free( data );
            }
            return ERROR_CODE;
        case NET_ARP_TRANSLATE:
            ERROR_PROPAGATE( measured_strings_receive( & address, & data, 1 ));
            translation = arp_translate_message( IPC_GET_DEVICE( call ), IPC_GET_PROTO( call ), address );
            free( address );
            free( data );
            if( ! translation ) return ENOENT;
            return measured_strings_reply( translation, 1 );
        case NET_ARP_CLEAR_DEVICE:
            return arp_clear_device_message( IPC_GET_DEVICE( call ));
        case NET_ARP_CLEAN_CACHE:
            return arp_clean_cache_message();
    }
    return ENOTSUP;
}
 
void arp_receiver( ipc_callid_t iid, ipc_call_t * icall ){
    ERROR_DECLARE;
 
    packet_t        packet;
 
    while( true ){
        switch( IPC_GET_METHOD( * icall )){
            case NET_IL_DEVICE_STATE:
                // do nothing - keep the cache
                ipc_answer_0( iid, EOK );
                break;
            case NET_IL_RECEIVED:
                if( ! ERROR_OCCURRED( packet_translate( arp_globals.networking_phone, & packet, IPC_GET_PACKET( icall )))){
                    ERROR_CODE = arp_receive_message( IPC_GET_DEVICE( icall ), packet );
                }
                ipc_answer_0( iid, ERROR_CODE );
                break;
            default:
                ipc_answer_0( iid, ENOTSUP );
        }
        iid = async_get_call( icall );
    }
}
 
/** @}
 */
 

Rev 3991	Rev 4163
1	/*	1	/*
2	* Copyright (c) 2009 Lukas Mejdrech	2	* Copyright (c) 2009 Lukas Mejdrech
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	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	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.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	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	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	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	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	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	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.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup arp	29	/** @addtogroup arp
30	* @{	30	* @{
31	*/	31	*/
32		32
33	/** @file	33	/** @file
34	* ARP module implementation.	34	* ARP module implementation.
35	* @see arp.h	35	* @see arp.h
36	*/	36	*/
37		37
38	#include <async.h>	38	#include <async.h>
39	#include <malloc.h>	39	#include <malloc.h>
40	#include <rwlock.h>	40	#include <rwlock.h>
41	#include <stdio.h>	41	#include <stdio.h>
42	#include <string.h>	42	#include <string.h>
43		43
44	#include <ipc/ipc.h>	44	#include <ipc/ipc.h>
45	#include <ipc/services.h>	45	#include <ipc/services.h>
46		46
47	#include "../../err.h"	47	#include "../../err.h"
48	#include "../../messages.h"	48	#include "../../messages.h"
49	#include "../../modules.h"	49	#include "../../modules.h"
50		50
51	#include "../../include/protocol_map.h"	51	#include "../../include/protocol_map.h"
52	#include "../../netif/device.h"	52	#include "../../netif/device.h"
53		53
54	#include "../../structures/measured_strings.h"	54	#include "../../structures/measured_strings.h"
55	#include "../../structures/packet/packet.h"	55	#include "../../structures/packet/packet.h"
56	#include "../../structures/packet/packet_client.h"	56	#include "../../structures/packet/packet_client.h"
57		57
58	#include "arp.h"	58	#include "arp.h"
59	#include "arp_header.h"	59	#include "arp_header.h"
60	#include "arp_oc.h"	60	#include "arp_oc.h"
61	//#include "arp_messages.h"	61	//#include "arp_messages.h"
62	#include "arp_module.h"	62	#include "arp_module.h"
63		63
64	/** Returns the device identifier message parameter.	64	/** Returns the device identifier message parameter.
65	*/	65	*/
66	#define IPC_GET_DEVICE( call ) ( device_id_t ) IPC_GET_ARG1( * call )	66	#define IPC_GET_DEVICE( call ) ( device_id_t ) IPC_GET_ARG1( * call )
67		67
68	/** Returns the packet identifier message parameter.	68	/** Returns the packet identifier message parameter.
69	*/	69	*/
70	#define IPC_GET_PACKET( call ) ( packet_id_t ) IPC_GET_ARG2( * call )	70	#define IPC_GET_PACKET( call ) ( packet_id_t ) IPC_GET_ARG2( * call )
71		71
72	/** Returns the protocol service message parameter.	72	/** Returns the protocol service message parameter.
73	*/	73	*/
74	#define IPC_GET_PROTO( call ) ( services_t ) IPC_GET_ARG2( * call )	74	#define IPC_GET_PROTO( call ) ( services_t ) IPC_GET_ARG2( * call )
75		75
76	/** Returns the device driver service message parameter.	76	/** Returns the device driver service message parameter.
77	*/	77	*/
78	#define IPC_GET_SERVICE( call ) ( services_t ) IPC_GET_ARG3( * call )	78	#define IPC_GET_SERVICE( call ) ( services_t ) IPC_GET_ARG3( * call )
79		79
80	/** ARP global data.	80	/** ARP global data.
81	*/	81	*/
82	arp_globals_t arp_globals;	82	arp_globals_t arp_globals;
83		83
84	/** Creates new protocol specific data.	84	/** Creates new protocol specific data.
85	* @param proto Protocol specific data. Output parameter.	85	* @param proto Protocol specific data. Output parameter.
86	* @param service Protocol module service. Input parameter.	86	* @param service Protocol module service. Input parameter.
87	* @param address Actual protocol device address. Input parameter.	87	* @param address Actual protocol device address. Input parameter.
88	* @returns EOK on success.	88	* @returns EOK on success.
89	* @returns ENOMEM if there is not enough memory left.	89	* @returns ENOMEM if there is not enough memory left.
90	*/	90	*/
91	int arp_proto_create( arp_proto_ref * proto, services_t service, measured_string_ref address );	91	int arp_proto_create( arp_proto_ref * proto, services_t service, measured_string_ref address );
92		92
93	/** Registers the device.	93	/** Registers the device.
94	* Creates new device entry in the cache or updates the protocol address if the device with the device identifier and the driver service exists.	94	* Creates new device entry in the cache or updates the protocol address if the device with the device identifier and the driver service exists.
95	* @param device_id The device identifier. Input parameter.	95	* @param device_id The device identifier. Input parameter.
96	* @param service The device driver service. Input parameter.	96	* @param service The device driver service. Input parameter.
97	* @param protocol The protocol service. Input parameter.	97	* @param protocol The protocol service. Input parameter.
98	* @param address The actual device protocol address.	98	* @param address The actual device protocol address.
99	* @returns EOK on success.	99	* @returns EOK on success.
100	* @returns EEXIST if another device with the same device identifier and different driver service exists.	100	* @returns EEXIST if another device with the same device identifier and different driver service exists.
101	* @returns ENOMEM if there is not enough memory left.	101	* @returns ENOMEM if there is not enough memory left.
102	* @returns Other error codes as defined for the measured_strings_return() function.	102	* @returns Other error codes as defined for the measured_strings_return() function.
103	*/	103	*/
104	int arp_device_message( device_id_t device_id, services_t service, services_t protocol, measured_string_ref address );	104	int arp_device_message( device_id_t device_id, services_t service, services_t protocol, measured_string_ref address );
105		105
106	/** Returns the hardware address for the given protocol address.	106	/** Returns the hardware address for the given protocol address.
107	* Sends the ARP request packet if the hardware address is not found in the cache.	107	* Sends the ARP request packet if the hardware address is not found in the cache.
108	* @param device_id The device identifier. Input parameter.	108	* @param device_id The device identifier. Input parameter.
109	* @param protocol The protocol service. Input parameter.	109	* @param protocol The protocol service. Input parameter.
110	* @param target The target protocol address. Input parameter.	110	* @param target The target protocol address. Input parameter.
111	* @returns The hardware address of the target.	111	* @returns The hardware address of the target.
112	* @returns NULL if the target parameter is NULL.	112	* @returns NULL if the target parameter is NULL.
113	* @returns NULL if the device is not found.	113	* @returns NULL if the device is not found.
114	* @returns NULL if the device packet is too small to send a request.	114	* @returns NULL if the device packet is too small to send a request.
115	* @returns NULL if the hardware address is not found in the cache.	115	* @returns NULL if the hardware address is not found in the cache.
116	*/	116	*/
117	measured_string_ref arp_translate_message( device_id_t device_id, services_t protocol, measured_string_ref target );	117	measured_string_ref arp_translate_message( device_id_t device_id, services_t protocol, measured_string_ref target );
118		118
119	/** Processes the received ARP packet.	119	/** Processes the received ARP packet.
120	* Updates the source hardware address if the source entry exists or the packet is targeted to my protocol address.	120	* Updates the source hardware address if the source entry exists or the packet is targeted to my protocol address.
121	* Responses to the ARP request if the packet is the ARP request and is targeted to my address.	121	* Responses to the ARP request if the packet is the ARP request and is targeted to my address.
122	* @param device_id The source device identifier. Input parameter.	122	* @param device_id The source device identifier. Input parameter.
123	* @param packet The received packet. Input/output parameter.	123	* @param packet The received packet. Input/output parameter.
124	* @returns EOK on success.	124	* @returns EOK on success.
125	* @returns EINVAL if the packet is too small to carry the ARP packet.	125	* @returns EINVAL if the packet is too small to carry the ARP packet.
126	* @returns EINVAL if the received address lengths differs from the registered values.	126	* @returns EINVAL if the received address lengths differs from the registered values.
127	* @returns ENOENT if the device is not found in the cache.	127	* @returns ENOENT if the device is not found in the cache.
128	* @returns ENOENT if the protocol for the device is not found in the cache.	128	* @returns ENOENT if the protocol for the device is not found in the cache.
129	* @returns ENOMEM if there is not enough memory left.	129	* @returns ENOMEM if there is not enough memory left.
130	*/	130	*/
131	int arp_receive_message( device_id_t device_id, packet_t packet );	131	int arp_receive_message( device_id_t device_id, packet_t packet );
132		132
133	/** Clears the device specific data from the cache.	133	/** Clears the device specific data from the cache.
134	* @param device_id The device identifier. Input parameter.	134	* @param device_id The device identifier. Input parameter.
135	* @returns EOK on success.	135	* @returns EOK on success.
136	* @returns ENOENT if the device is not found in the cache.	136	* @returns ENOENT if the device is not found in the cache.
137	*/	137	*/
138	int arp_clear_device_message( device_id_t device_id );	138	int arp_clear_device_message( device_id_t device_id );
139		139
140	/** Clears the device specific data.	140	/** Clears the device specific data.
141	* @param device The device specific data.	141	* @param device The device specific data.
142	*/	142	*/
143	void clear_device( arp_device_ref device );	143	void clear_device( arp_device_ref device );
144		144
145	/** Clears the whole cache.	145	/** Clears the whole cache.
146	* @returns EOK on success.	146	* @returns EOK on success.
147	*/	147	*/
148	int arp_clean_cache_message( void );	148	int arp_clean_cache_message( void );
149		149
150	/** Processes IPC messages from the registered device driver modules in an infinite loop.	150	/** Processes IPC messages from the registered device driver modules in an infinite loop.
151	* @param iid The message identifier. Input parameter.	151	* @param iid The message identifier. Input parameter.
152	* @param icall The message parameters. Input/output parameter.	152	* @param icall The message parameters. Input/output parameter.
153	*/	153	*/
154	void arp_receiver( ipc_callid_t iid, ipc_call_t * icall );	154	void arp_receiver( ipc_callid_t iid, ipc_call_t * icall );
155		155
156	DEVICE_MAP_IMPLEMENT( arp_cache, arp_device_t )	156	DEVICE_MAP_IMPLEMENT( arp_cache, arp_device_t )
157		157
158	INT_MAP_IMPLEMENT( arp_protos, arp_proto_t )	158	INT_MAP_IMPLEMENT( arp_protos, arp_proto_t )
159		159
160	GENERIC_CHAR_MAP_IMPLEMENT( arp_addr, measured_string_t )	160	GENERIC_CHAR_MAP_IMPLEMENT( arp_addr, measured_string_t )
161		161
162	int arp_initialize( void ){	162	int arp_initialize( void ){
163	ERROR_DECLARE;	163	ERROR_DECLARE;
164		164
165	rwlock_initialize( & arp_globals.lock );	165	rwlock_initialize( & arp_globals.lock );
166	rwlock_write_lock( & arp_globals.lock );	166	rwlock_write_lock( & arp_globals.lock );
167	ERROR_PROPAGATE( arp_cache_initialize( & arp_globals.cache ));	167	ERROR_PROPAGATE( arp_cache_initialize( & arp_globals.cache ));
168	rwlock_write_unlock( & arp_globals.lock );	168	rwlock_write_unlock( & arp_globals.lock );
169	return EOK;	169	return EOK;
170	}	170	}
171		171
172	int arp_proto_create( arp_proto_ref * proto, services_t service, measured_string_ref address ){	172	int arp_proto_create( arp_proto_ref * proto, services_t service, measured_string_ref address ){
173	ERROR_DECLARE;	173	ERROR_DECLARE;
174		174
175	* proto = ( arp_proto_ref ) malloc( sizeof( arp_proto_t ));	175	* proto = ( arp_proto_ref ) malloc( sizeof( arp_proto_t ));
176	if( !( * proto )) return ENOMEM;	176	if( !( * proto )) return ENOMEM;
177	( ** proto ).service = service;	177	( ** proto ).service = service;
178	( ** proto ).addr = address;	178	( ** proto ).addr = address;
179	( ** proto ).addr_data = address->value;	179	( ** proto ).addr_data = address->value;
180	if( ERROR_OCCURRED( arp_addr_initialize( &( ** proto).addresses ))){	180	if( ERROR_OCCURRED( arp_addr_initialize( &( ** proto).addresses ))){
181	free( * proto );	181	free( * proto );
182	return ERROR_CODE;	182	return ERROR_CODE;
183	}	183	}
184	return EOK;	184	return EOK;
185	}	185	}
186		186
187	int arp_device_message( device_id_t device_id, services_t service, services_t protocol, measured_string_ref address ){	187	int arp_device_message( device_id_t device_id, services_t service, services_t protocol, measured_string_ref address ){
188	ERROR_DECLARE;	188	ERROR_DECLARE;
189		189
190	arp_device_ref device;	190	arp_device_ref device;
191	aid_t message;	191	aid_t message;
192	ipc_call_t answer;	192	ipc_call_t answer;
193	ipcarg_t result;	193	ipcarg_t result;
194	arp_proto_ref proto;	194	arp_proto_ref proto;
195		195
196	rwlock_write_lock( & arp_globals.lock );	196	rwlock_write_lock( & arp_globals.lock );
197	// an existing device?	197	// an existing device?
198	device = arp_cache_find( & arp_globals.cache, device_id );	198	device = arp_cache_find( & arp_globals.cache, device_id );
199	if( device ){	199	if( device ){
200	if( device->service != service ){	200	if( device->service != service ){
-		201	printf( "\nDevice %d already exists", device->device_id );
201	rwlock_write_unlock( & arp_globals.lock );	202	rwlock_write_unlock( & arp_globals.lock );
202	return EEXIST;	203	return EEXIST;
203	}	204	}
204	proto = arp_protos_find( & device->protos, protocol );	205	proto = arp_protos_find( & device->protos, protocol );
205	if( proto ){	206	if( proto ){
206	free( proto->addr );	207	free( proto->addr );
207	free( proto->addr_data );	208	free( proto->addr_data );
208	proto->addr = address;	209	proto->addr = address;
209	proto->addr_data = address->value;	210	proto->addr_data = address->value;
210	}else{	211	}else{
211	if( ERROR_OCCURRED( arp_proto_create( & proto, protocol, address ))){	212	if( ERROR_OCCURRED( arp_proto_create( & proto, protocol, address ))){
212	rwlock_write_unlock( & arp_globals.lock );	213	rwlock_write_unlock( & arp_globals.lock );
213	return ERROR_CODE;	214	return ERROR_CODE;
214	}	215	}
215	if( ERROR_OCCURRED( arp_protos_add( & device->protos, proto->service, proto ))){	216	if( ERROR_OCCURRED( arp_protos_add( & device->protos, proto->service, proto ))){
216	rwlock_write_unlock( & arp_globals.lock );	217	rwlock_write_unlock( & arp_globals.lock );
217	free( proto );	218	free( proto );
218	return ERROR_CODE;	219	return ERROR_CODE;
219	}	220	}
220	}	221	}
221	return EOK;	222	printf( "\nCache of the existing device %d cleaned", device->device_id );
222	}else{	223	}else{
223	// create a new device	224	// create a new device
224	device = ( arp_device_ref ) malloc( sizeof( arp_device_t ));	225	device = ( arp_device_ref ) malloc( sizeof( arp_device_t ));
225	if( ! device ){	226	if( ! device ){
226	rwlock_write_unlock( & arp_globals.lock );	227	rwlock_write_unlock( & arp_globals.lock );
227	return ENOMEM;	228	return ENOMEM;
228	}	229	}
229	device->device_id = device_id;	230	device->device_id = device_id;
230	if( ERROR_OCCURRED( arp_protos_initialize( & device->protos ))	231	if( ERROR_OCCURRED( arp_protos_initialize( & device->protos ))
231	\|\| ERROR_OCCURRED( arp_proto_create( & proto, protocol, address ))){	232	\|\| ERROR_OCCURRED( arp_proto_create( & proto, protocol, address ))){
232	rwlock_write_unlock( & arp_globals.lock );	233	rwlock_write_unlock( & arp_globals.lock );
233	free( device );	234	free( device );
234	return ERROR_CODE;	235	return ERROR_CODE;
235	}	236	}
236	if( ERROR_OCCURRED( arp_protos_add( & device->protos, proto->service, proto ))){	237	if( ERROR_OCCURRED( arp_protos_add( & device->protos, proto->service, proto ))){
237	rwlock_write_unlock( & arp_globals.lock );	238	rwlock_write_unlock( & arp_globals.lock );
238	arp_protos_destroy( & device->protos );	239	arp_protos_destroy( & device->protos );
239	free( device );	240	free( device );
240	return ERROR_CODE;	241	return ERROR_CODE;
241	}	242	}
242	device->service = service;	243	device->service = service;
243	// bind the new one	244	// bind the new one
244	device->phone = bind_service( device->service, device->device_id, SERVICE_ARP, 0, arp_receiver );	245	device->phone = bind_service( device->service, device->device_id, SERVICE_ARP, 0, arp_receiver );
245	// get packet dimensions	246	// get packet dimensions
246	if( ERROR_OCCURRED( async_req_1_4( device->phone, NET_NIL_PACKET_SPACE, device_id, & device->addr_len, & device->prefix, & device->content, & device->suffix ))){	247	if( ERROR_OCCURRED( async_req_1_4( device->phone, NET_NIL_PACKET_SPACE, device_id, & device->addr_len, & device->prefix, & device->content, & device->suffix ))){
247	rwlock_write_unlock( & arp_globals.lock );	248	rwlock_write_unlock( & arp_globals.lock );
248	arp_protos_destroy( & device->protos );	249	arp_protos_destroy( & device->protos );
249	free( device );	250	free( device );
250	return ERROR_CODE;	251	return ERROR_CODE;
251	}	252	}
252	// get hardware address	253	// get hardware address
253	message = async_send_1( device->phone, NET_NIL_ADDR, device->device_id, & answer );	254	message = async_send_1( device->phone, NET_NIL_ADDR, device->device_id, & answer );
254	if( ERROR_OCCURRED( measured_strings_return( device->phone, & device->addr, & device->addr_data, 1 ))){	255	if( ERROR_OCCURRED( measured_strings_return( device->phone, & device->addr, & device->addr_data, 1 ))){
255	rwlock_write_unlock( & arp_globals.lock );	256	rwlock_write_unlock( & arp_globals.lock );
256	arp_protos_destroy( & device->protos );	257	arp_protos_destroy( & device->protos );
257	free( device );	258	free( device );
258	async_wait_for( message, NULL );	259	async_wait_for( message, NULL );
259	return ERROR_CODE;	260	return ERROR_CODE;
260	}	261	}
261	async_wait_for( message, & result );	262	async_wait_for( message, & result );
262	if( ERROR_OCCURRED( result )){	263	if( ERROR_OCCURRED( result )){
263	rwlock_write_unlock( & arp_globals.lock );	264	rwlock_write_unlock( & arp_globals.lock );
264	free( device->addr );	265	free( device->addr );
265	free( device->addr_data );	266	free( device->addr_data );
266	arp_protos_destroy( & device->protos );	267	arp_protos_destroy( & device->protos );
267	free( device );	268	free( device );
268	return ERROR_CODE;	269	return ERROR_CODE;
269	}	270	}
270	// get broadcast address	271	// get broadcast address
271	message = async_send_1( device->phone, NET_NIL_BROADCAST_ADDR, device->device_id, & answer );	272	message = async_send_1( device->phone, NET_NIL_BROADCAST_ADDR, device->device_id, & answer );
272	if( ERROR_OCCURRED( measured_strings_return( device->phone, & device->broadcast_addr, & device->broadcast_data, 1 ))){	273	if( ERROR_OCCURRED( measured_strings_return( device->phone, & device->broadcast_addr, & device->broadcast_data, 1 ))){
273	rwlock_write_unlock( & arp_globals.lock );	274	rwlock_write_unlock( & arp_globals.lock );
274	free( device->addr );	275	free( device->addr );
275	free( device->addr_data );	276	free( device->addr_data );
276	arp_protos_destroy( & device->protos );	277	arp_protos_destroy( & device->protos );
277	free( device );	278	free( device );
278	async_wait_for( message, NULL );	279	async_wait_for( message, NULL );
279	return ERROR_CODE;	280	return ERROR_CODE;
280	}	281	}
281	async_wait_for( message, & result );	282	async_wait_for( message, & result );
282	// add to the cache	283	// add to the cache
283	if( ERROR_OCCURRED( result )	284	if( ERROR_OCCURRED( result )
284	\|\| ERROR_OCCURRED( arp_cache_add( & arp_globals.cache, device->device_id, device ))){	285	\|\| ERROR_OCCURRED( arp_cache_add( & arp_globals.cache, device->device_id, device ))){
285	rwlock_write_unlock( & arp_globals.lock );	286	rwlock_write_unlock( & arp_globals.lock );
286	free( device->addr );	287	free( device->addr );
287	free( device->addr_data );	288	free( device->addr_data );
288	free( device->broadcast_addr );	289	free( device->broadcast_addr );
289	free( device->broadcast_data );	290	free( device->broadcast_data );
290	arp_protos_destroy( & device->protos );	291	arp_protos_destroy( & device->protos );
291	free( device );	292	free( device );
292	return ERROR_CODE;	293	return ERROR_CODE;
293	}	294	}
-		295	printf( "\nNew device registered:\n\tid\t= %d\n\ttype\t= %x\n\tservice\t= %d", device->device_id, device->hardware, device->service );
294	}	296	}
295	rwlock_write_unlock( & arp_globals.lock );	297	rwlock_write_unlock( & arp_globals.lock );
296	return EOK;	298	return EOK;
297	}	299	}
298		300
299	measured_string_ref arp_translate_message( device_id_t device_id, services_t protocol, measured_string_ref target ){	301	measured_string_ref arp_translate_message( device_id_t device_id, services_t protocol, measured_string_ref target ){
300	arp_device_ref device;	302	arp_device_ref device;
301	arp_proto_ref proto;	303	arp_proto_ref proto;
302	measured_string_ref addr;	304	measured_string_ref addr;
303	size_t length;	305	size_t length;
304	packet_t packet;	306	packet_t packet;
305	arp_header_ref header;	307	arp_header_ref header;
306		308
307	if( ! target ) return NULL;	309	if( ! target ) return NULL;
308	rwlock_read_lock( & arp_globals.lock );	310	rwlock_read_lock( & arp_globals.lock );
309	device = arp_cache_find( & arp_globals.cache, device_id );	311	device = arp_cache_find( & arp_globals.cache, device_id );
310	if( ! device ){	312	if( ! device ){
311	rwlock_read_unlock( & arp_globals.lock );	313	rwlock_read_unlock( & arp_globals.lock );
312	return NULL;	314	return NULL;
313	}	315	}
314	proto = arp_protos_find( & device->protos, protocol );	316	proto = arp_protos_find( & device->protos, protocol );
315	if(( ! proto ) \|\| ( proto->addr->length != target->length )){	317	if(( ! proto ) \|\| ( proto->addr->length != target->length )){
316	rwlock_read_unlock( & arp_globals.lock );	318	rwlock_read_unlock( & arp_globals.lock );
317	return NULL;	319	return NULL;
318	}	320	}
319	addr = arp_addr_find( & proto->addresses, target->value, target->length );	321	addr = arp_addr_find( & proto->addresses, target->value, target->length );
320	if( addr ){	322	if( addr ){
321	rwlock_read_unlock( & arp_globals.lock );	323	rwlock_read_unlock( & arp_globals.lock );
322	return addr;	324	return addr;
323	}	325	}
324	// ARP packet content size = header + ( address + translation ) * 2	326	// ARP packet content size = header + ( address + translation ) * 2
325	length = 8 + ( CONVERT_SIZE( char, uint8_t, proto->addr->length ) + CONVERT_SIZE( char, uint8_t, device->addr->length )) * 2;	327	length = 8 + ( CONVERT_SIZE( char, uint8_t, proto->addr->length ) + CONVERT_SIZE( char, uint8_t, device->addr->length )) * 2;
326	if( length > device->content ){	328	if( length > device->content ){
327	rwlock_read_unlock( & arp_globals.lock );	329	rwlock_read_unlock( & arp_globals.lock );
328	return NULL;	330	return NULL;
329	}	331	}
330	packet = packet_get_4( arp_globals.networking_phone, device->addr_len, device->prefix, length, device->suffix );	332	packet = packet_get_4( arp_globals.networking_phone, device->addr_len, device->prefix, length, device->suffix );
331	if( ! packet ){	333	if( ! packet ){
332	rwlock_read_unlock( & arp_globals.lock );	334	rwlock_read_unlock( & arp_globals.lock );
333	return NULL;	335	return NULL;
334	}	336	}
335	header = ( arp_header_ref ) packet_suffix( packet, length );	337	header = ( arp_header_ref ) packet_suffix( packet, length );
336	header->hardware = device->hardware;	338	header->hardware = device->hardware;
337	header->hardware_length = device->addr->length;	339	header->hardware_length = device->addr->length;
338	header->protocol = protocol_map( device->service, protocol );	340	header->protocol = protocol_map( device->service, protocol );
339	header->protocol_length = proto->addr->length;	341	header->protocol_length = proto->addr->length;
340	header->operation = ARPOP_REQUEST;	342	header->operation = ARPOP_REQUEST;
341	length = sizeof( arp_header_t );	343	length = sizeof( arp_header_t );
342	memcpy((( uint8_t * ) header ) + length, device->addr->value, device->addr->length );	344	memcpy((( uint8_t * ) header ) + length, device->addr->value, device->addr->length );
343	length += device->addr->length;	345	length += device->addr->length;
344	memcpy((( uint8_t * ) header ) + length, proto->addr->value, proto->addr->length );	346	memcpy((( uint8_t * ) header ) + length, proto->addr->value, proto->addr->length );
345	length += proto->addr->length;	347	length += proto->addr->length;
346	memset((( uint8_t * ) header ) + length, 0, device->addr->length );	348	memset((( uint8_t * ) header ) + length, 0, device->addr->length );
347	length += device->addr->length;	349	length += device->addr->length;
348	memcpy((( uint8_t * ) header ) + length, target->value, target->length );	350	memcpy((( uint8_t * ) header ) + length, target->value, target->length );
349	packet_set_addr( packet, ( uint8_t * ) device->addr->value, ( uint8_t * ) device->broadcast_addr->value, CONVERT_SIZE( char, uint8_t, device->addr->length ));	351	packet_set_addr( packet, ( uint8_t * ) device->addr->value, ( uint8_t * ) device->broadcast_addr->value, CONVERT_SIZE( char, uint8_t, device->addr->length ));
350	async_msg_3( device->phone, NET_NETIF_SEND, device_id, SERVICE_ARP, packet_get_id( packet ));	352	async_msg_3( device->phone, NET_NETIF_SEND, device_id, SERVICE_ARP, packet_get_id( packet ));
351	rwlock_read_unlock( & arp_globals.lock );	353	rwlock_read_unlock( & arp_globals.lock );
352	return NULL;	354	return NULL;
353	}	355	}
354		356
355	int arp_receive_message( device_id_t device_id, packet_t packet ){	357	int arp_receive_message( device_id_t device_id, packet_t packet ){
356	ERROR_DECLARE;	358	ERROR_DECLARE;
357		359
358	size_t length;	360	size_t length;
359	arp_header_ref header;	361	arp_header_ref header;
360	arp_device_ref device;	362	arp_device_ref device;
361	arp_proto_ref proto;	363	arp_proto_ref proto;
362	measured_string_ref hw_source;	364	measured_string_ref hw_source;
363	uint8_t * src_hw;	365	uint8_t * src_hw;
364	uint8_t * src_proto;	366	uint8_t * src_proto;
365	uint8_t * des_hw;	367	uint8_t * des_hw;
366	uint8_t * des_proto;	368	uint8_t * des_proto;
367		369
368	length = packet_get_data_length( packet );	370	length = packet_get_data_length( packet );
369	if( length <= sizeof( arp_header_t )) return EINVAL;	371	if( length <= sizeof( arp_header_t )) return EINVAL;
370	rwlock_read_lock( & arp_globals.lock );	372	rwlock_read_lock( & arp_globals.lock );
371	device = arp_cache_find( & arp_globals.cache, device_id );	373	device = arp_cache_find( & arp_globals.cache, device_id );
372	if( ! device ){	374	if( ! device ){
373	rwlock_read_unlock( & arp_globals.lock );	375	rwlock_read_unlock( & arp_globals.lock );
374	return ENOENT;	376	return ENOENT;
375	}	377	}
376	header = ( arp_header_ref ) packet_get_data( packet );	378	header = ( arp_header_ref ) packet_get_data( packet );
377	if(( header->hardware != device->hardware )	379	if(( header->hardware != device->hardware )
378	\|\| ( length < sizeof( arp_header_t ) + ( header->hardware_length + header->protocol_length ) * 2 )){	380	\|\| ( length < sizeof( arp_header_t ) + ( header->hardware_length + header->protocol_length ) * 2 )){
379	rwlock_read_unlock( & arp_globals.lock );	381	rwlock_read_unlock( & arp_globals.lock );
380	return EINVAL;	382	return EINVAL;
381	}	383	}
382	proto = arp_protos_find( & device->protos, protocol_unmap( device->service, header->protocol ));	384	proto = arp_protos_find( & device->protos, protocol_unmap( device->service, header->protocol ));
383	if( ! proto ){	385	if( ! proto ){
384	rwlock_read_unlock( & arp_globals.lock );	386	rwlock_read_unlock( & arp_globals.lock );
385	return ENOENT;	387	return ENOENT;
386	}	388	}
387	src_hw = (( uint8_t * ) header ) + sizeof( arp_header_t );	389	src_hw = (( uint8_t * ) header ) + sizeof( arp_header_t );
388	src_proto = src_hw + header->hardware_length;	390	src_proto = src_hw + header->hardware_length;
389	des_hw = src_proto + header->protocol_length;	391	des_hw = src_proto + header->protocol_length;
390	des_proto = des_hw + header->hardware_length;	392	des_proto = des_hw + header->hardware_length;
391	hw_source = arp_addr_find( & proto->addresses, ( char * ) src_proto, CONVERT_SIZE( uint8_t, char, header->protocol_length ));	393	hw_source = arp_addr_find( & proto->addresses, ( char * ) src_proto, CONVERT_SIZE( uint8_t, char, header->protocol_length ));
392	// exists?	394	// exists?
393	if( hw_source ){	395	if( hw_source ){
394	if( hw_source->length != CONVERT_SIZE( uint8_t, char, header->hardware_length )){	396	if( hw_source->length != CONVERT_SIZE( uint8_t, char, header->hardware_length )){
395	rwlock_read_unlock( & arp_globals.lock );	397	rwlock_read_unlock( & arp_globals.lock );
396	return EINVAL;	398	return EINVAL;
397	}	399	}
398	memcpy( hw_source->value, src_hw, hw_source->length );	400	memcpy( hw_source->value, src_hw, hw_source->length );
399	}	401	}
400	// is my protocol address?	402	// is my protocol address?
401	if( proto->addr->length != CONVERT_SIZE( uint8_t, char, header->hardware_length )){	403	if( proto->addr->length != CONVERT_SIZE( uint8_t, char, header->hardware_length )){
402	rwlock_read_unlock( & arp_globals.lock );	404	rwlock_read_unlock( & arp_globals.lock );
403	return EINVAL;	405	return EINVAL;
404	}	406	}
405	if( ! strncmp( proto->addr->value, ( char * ) des_proto, proto->addr->length )){	407	if( ! strncmp( proto->addr->value, ( char * ) des_proto, proto->addr->length )){
406	// not already upadted?	408	// not already upadted?
407	if( ! hw_source ){	409	if( ! hw_source ){
408	hw_source = measured_string_create_bulk(( char * ) src_hw, CONVERT_SIZE( uint8_t, char, header->hardware_length ));	410	hw_source = measured_string_create_bulk(( char * ) src_hw, CONVERT_SIZE( uint8_t, char, header->hardware_length ));
409	if( ! hw_source ){	411	if( ! hw_source ){
410	rwlock_read_unlock( & arp_globals.lock );	412	rwlock_read_unlock( & arp_globals.lock );
411	return ENOMEM;	413	return ENOMEM;
412	}	414	}
413	if( ERROR_OCCURRED( arp_addr_add( & proto->addresses, ( char * ) src_proto, CONVERT_SIZE( uint8_t, char, header->protocol_length ), hw_source ))){	415	if( ERROR_OCCURRED( arp_addr_add( & proto->addresses, ( char * ) src_proto, CONVERT_SIZE( uint8_t, char, header->protocol_length ), hw_source ))){
414	rwlock_read_unlock( & arp_globals.lock );	416	rwlock_read_unlock( & arp_globals.lock );
415	return ERROR_CODE;	417	return ERROR_CODE;
416	}	418	}
417	}	419	}
418	if( header->operation == ARPOP_REQUEST ){	420	if( header->operation == ARPOP_REQUEST ){
419	header->operation = ARPOP_REPLY;	421	header->operation = ARPOP_REPLY;
420	memcpy( des_proto, src_proto, header->protocol_length );	422	memcpy( des_proto, src_proto, header->protocol_length );
421	memcpy( src_proto, proto->addr->value, header->protocol_length );	423	memcpy( src_proto, proto->addr->value, header->protocol_length );
422	memcpy( src_hw, des_hw, header->hardware_length );	424	memcpy( src_hw, des_hw, header->hardware_length );
423	memcpy( des_hw, hw_source->value, header->hardware_length );	425	memcpy( des_hw, hw_source->value, header->hardware_length );
424	packet_set_addr( packet, src_hw, des_hw, header->hardware_length );	426	packet_set_addr( packet, src_hw, des_hw, header->hardware_length );
425	async_msg_3( device->phone, NET_NETIF_SEND, device_id, SERVICE_ARP, packet_get_id( packet ));	427	async_msg_3( device->phone, NET_NETIF_SEND, device_id, SERVICE_ARP, packet_get_id( packet ));
426	rwlock_read_unlock( & arp_globals.lock );	428	rwlock_read_unlock( & arp_globals.lock );
427	}else{	429	}else{
428	rwlock_read_unlock( & arp_globals.lock );	430	rwlock_read_unlock( & arp_globals.lock );
429	packet_release( arp_globals.networking_phone, packet_get_id( packet ));	431	packet_release( arp_globals.networking_phone, packet_get_id( packet ));
430	}	432	}
431	}	433	}
432	return EOK;	434	return EOK;
433	}	435	}
434		436
435	int arp_clear_device_message( device_id_t device_id ){	437	int arp_clear_device_message( device_id_t device_id ){
436	arp_device_ref device;	438	arp_device_ref device;
437		439
438	rwlock_write_lock( & arp_globals.lock );	440	rwlock_write_lock( & arp_globals.lock );
439	device = arp_cache_find( & arp_globals.cache, device_id );	441	device = arp_cache_find( & arp_globals.cache, device_id );
440	if( ! device ){	442	if( ! device ){
441	rwlock_write_unlock( & arp_globals.lock );	443	rwlock_write_unlock( & arp_globals.lock );
442	return ENOENT;	444	return ENOENT;
443	}	445	}
444	clear_device( device );	446	clear_device( device );
-		447	printf( "\nDevice %d cleared", device_id );
445	rwlock_write_unlock( & arp_globals.lock );	448	rwlock_write_unlock( & arp_globals.lock );
446	return EOK;	449	return EOK;
447	}	450	}
448		451
449	void clear_device( arp_device_ref device ){	452	void clear_device( arp_device_ref device ){
450	int count;	453	int count;
451	arp_proto_ref proto;	454	arp_proto_ref proto;
452		455
453	count = arp_protos_count( & device->protos );	456	count = arp_protos_count( & device->protos );
454	while( count > 0 ){	457	while( count > 0 ){
455	proto = arp_protos_get_index( & device->protos, count );	458	proto = arp_protos_get_index( & device->protos, count );
456	if( proto->addr ) free( proto->addr );	459	if( proto->addr ) free( proto->addr );
457	if( proto->addr_data ) free( proto->addr_data );	460	if( proto->addr_data ) free( proto->addr_data );
458	arp_addr_destroy( & proto->addresses );	461	arp_addr_destroy( & proto->addresses );
459	-- count;	462	-- count;
460	}	463	}
461	arp_protos_clear( & device->protos );	464	arp_protos_clear( & device->protos );
462	}	465	}
463		466
464	int arp_clean_cache_message( void ){	467	int arp_clean_cache_message( void ){
465	int count;	468	int count;
466	arp_device_ref device;	469	arp_device_ref device;
467		470
468	rwlock_write_lock( & arp_globals.lock );	471	rwlock_write_lock( & arp_globals.lock );
469	count = arp_cache_count( & arp_globals.cache );	472	count = arp_cache_count( & arp_globals.cache );
470	while( count > 0 ){	473	while( count > 0 ){
471	device = arp_cache_get_index( & arp_globals.cache, count );	474	device = arp_cache_get_index( & arp_globals.cache, count );
472	if( device ){	475	if( device ){
473	clear_device( device );	476	clear_device( device );
474	if( device->addr_data ) free( device->addr_data );	477	if( device->addr_data ) free( device->addr_data );
475	if( device->broadcast_data ) free( device->broadcast_data );	478	if( device->broadcast_data ) free( device->broadcast_data );
476	}	479	}
477	}	480	}
478	arp_cache_clear( & arp_globals.cache );	481	arp_cache_clear( & arp_globals.cache );
479	rwlock_write_lock( & arp_globals.lock );	482	rwlock_write_unlock( & arp_globals.lock );
-		483	printf( "\nCache cleaned" );
480	return EOK;	484	return EOK;
481	}	485	}
482		486
483	int arp_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){	487	int arp_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
484	ERROR_DECLARE;	488	ERROR_DECLARE;
485		489
486	measured_string_ref address;	490	measured_string_ref address;
487	measured_string_ref translation;	491	measured_string_ref translation;
488	char * data;	492	char * data;
489		493
490	* answer_count = 0;	494	* answer_count = 0;
491	switch( IPC_GET_METHOD( * call )){	495	switch( IPC_GET_METHOD( * call )){
492	case IPC_M_PHONE_HUNGUP:	496	case IPC_M_PHONE_HUNGUP:
493	return EOK;	497	return EOK;
494	case NET_ARP_DEVICE:	498	case NET_ARP_DEVICE:
495	ERROR_PROPAGATE( measured_strings_receive( & address, & data, 1 ));	499	ERROR_PROPAGATE( measured_strings_receive( & address, & data, 1 ));
496	if( ERROR_OCCURRED( arp_device_message( IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ), IPC_GET_PROTO( call ), address ))){	500	if( ERROR_OCCURRED( arp_device_message( IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ), IPC_GET_PROTO( call ), address ))){

Subversion Repositories HelenOS

(root)/branches/network/uspace/srv/net/il/arp/arp.c – Rev 3991 → 4163