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 <mem.h>
#include <rwlock.h>
#include <stdio.h>
#include <string.h>
#include <task.h>
 
#include <ipc/ipc.h>
#include <ipc/services.h>
 
#include "../../err.h"
#include "../../messages.h"
#include "../../modules.h"
 
#include "../../include/byteorder.h"
#include "../../include/device.h"
#include "../../include/arp_interface.h"
#include "../../include/nil_interface.h"
#include "../../include/protocol_map.h"
 
#include "../../structures/measured_strings.h"
#include "../../structures/packet/packet.h"
#include "../../structures/packet/packet_client.h"
 
#include "../il_messages.h"
 
#include "arp.h"
#include "arp_header.h"
#include "arp_oc.h"
#include "arp_module.h"
#include "arp_messages.h"
 
/** ARP global data.
 */
arp_globals_t   arp_globals;
 
/** Clears the whole cache.
 *  @returns EOK on success.
 */
int arp_clean_cache_req( int arp_phone );
 
/** Clears the device specific data from the cache.
 *  @param arp_phone The ARP module phone used for (semi)remote calls. Input parameter.
 *  @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_req( int arp_phone, device_id_t device_id );
 
/** 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 and the packet is no longer needed.
 *  @returns 1 on success and the packet has been reused.
 *  @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.
 *  @param device The device specific data.
 */
void    clear_device( arp_device_ref device );
 
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_task_get_id( void ){
    return task_get_id();
}
 
int arp_clear_device_req( int arp_phone, 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( "Device %d cleared\n", device_id );
    rwlock_write_unlock( & arp_globals.lock );
    return EOK;
}
 
int arp_clean_cache_req( int arp_phone ){
    int             count;
    arp_device_ref  device;
 
    rwlock_write_lock( & arp_globals.lock );
    for( count = arp_cache_count( & arp_globals.cache ) - 1; count >= 0; -- count ){
        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( "Cache cleaned\n" );
    return EOK;
}
 
int arp_device_req( int arp_phone, device_id_t device_id, services_t protocol, services_t netif, measured_string_ref address ){
    ERROR_DECLARE;
 
    measured_string_ref tmp;
 
    tmp = measured_string_copy( address );
    if( ERROR_OCCURRED( arp_device_message( device_id, netif, protocol, tmp ))){
        free( tmp->value );
        free( tmp );
    }
    return ERROR_CODE;
}
 
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 ){
    measured_string_ref tmp;
 
    rwlock_read_lock( & arp_globals.lock );
    tmp = arp_translate_message( device_id, protocol, address );
    if( tmp ){
        * translation = measured_string_copy( tmp );
        rwlock_read_unlock( & arp_globals.lock );
        if( * translation ){
            * data = ( ** translation ).value;
            return EOK;
        }else{
            return ENOMEM;
        }
    }else{
        rwlock_read_unlock( & arp_globals.lock );
        return ENOENT;
    }
}
 
int arp_initialize( async_client_conn_t client_connection ){
    ERROR_DECLARE;
 
    rwlock_initialize( & arp_globals.lock );
    rwlock_write_lock( & arp_globals.lock );
    arp_globals.client_connection = client_connection;
    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;
    arp_proto_ref   proto;
    int             index;
 
    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( "Device %d already exists\n", 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;
            }
            index = arp_protos_add( & device->protos, proto->service, proto );
            if( index < 0 ){
                rwlock_write_unlock( & arp_globals.lock );
                free( proto );
                return index;
            }
            printf( "New protocol added:\n\tdevice id\t= %d\n\tproto\t= %d", device_id, protocol );
        }
    }else{
        index = hardware_map( service );
        if( ! index ) return ENOENT;
        // create a new device
        device = ( arp_device_ref ) malloc( sizeof( arp_device_t ));
        if( ! device ){
            rwlock_write_unlock( & arp_globals.lock );
            return ENOMEM;
        }
        device->hardware = index;
        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;
        }
        index = arp_protos_add( & device->protos, proto->service, proto );
        if( index < 0 ){
            rwlock_write_unlock( & arp_globals.lock );
            arp_protos_destroy( & device->protos );
            free( device );
            return index;
        }
        device->service = service;
        // bind the new one
        device->phone = bind_service( device->service, device->device_id, SERVICE_ARP, 0, arp_globals.client_connection );
        if( device->phone < 0 ){
            rwlock_write_unlock( & arp_globals.lock );
            arp_protos_destroy( & device->protos );
            free( device );
            return EREFUSED;
        }
        // get packet dimensions
        if( ERROR_OCCURRED( nil_packet_size_req( device->phone, 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
        if( ERROR_OCCURRED( nil_get_addr( device->phone, device_id, & device->addr, & device->addr_data ))){
            rwlock_write_unlock( & arp_globals.lock );
            arp_protos_destroy( & device->protos );
            free( device );
            return ERROR_CODE;
        }
        // get broadcast address
        if( ERROR_OCCURRED( nil_get_broadcast_addr( device->phone, device_id, & device->broadcast_addr, & device->broadcast_data ))){
            rwlock_write_unlock( & arp_globals.lock );
            free( device->addr );
            free( device->addr_data );
            arp_protos_destroy( & device->protos );
            free( device );
            return ERROR_CODE;
        }
        if( 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( "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 );
    }
    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;
    device = arp_cache_find( & arp_globals.cache, device_id );
    if( ! device ) return NULL;
    proto = arp_protos_find( & device->protos, protocol );
    if(( ! proto ) || ( proto->addr->length != target->length )) return NULL;
    addr = arp_addr_find( & proto->addresses, target->value, target->length );
    if( addr ) 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 ) return NULL;
    packet = packet_get_4( arp_globals.net_phone, device->addr_len, device->prefix, length, device->suffix );
    if( ! packet ) return NULL;
    header = ( arp_header_ref ) packet_suffix( packet, length );
    if( ! header ){
        pq_release( packet );
        return NULL;
    }
    header->hardware = htons( device->hardware );
    header->hardware_length = device->addr->length;
    header->protocol = htons( protocol_map( device->service, protocol ));
    header->protocol_length = proto->addr->length;
    header->operation = htons( 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;
    bzero((( uint8_t * ) header ) + length, device->addr->length );
    length += device->addr->length;
    memcpy((( uint8_t * ) header ) + length, target->value, target->length );
    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 ){
        pq_release( packet );
        return NULL;
    }
    nil_send_msg( device->phone, device_id, packet, SERVICE_ARP );
    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;
    device = arp_cache_find( & arp_globals.cache, device_id );
    if( ! device ) return ENOENT;
    header = ( arp_header_ref ) packet_get_data( packet );
    if(( ntohs( header->hardware ) != device->hardware )
    || ( length < sizeof( arp_header_t ) + ( header->hardware_length + header->protocol_length ) * 2 )){
        return EINVAL;
    }
    proto = arp_protos_find( & device->protos, protocol_unmap( device->service, ntohs( header->protocol )));
    if( ! proto ) 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 )){
            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->protocol_length )){
        return EINVAL;
    }
    if( ! str_lcmp( 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 ) return ENOMEM;
            ERROR_PROPAGATE( arp_addr_add( & proto->addresses, ( char * ) src_proto, CONVERT_SIZE( uint8_t, char, header->protocol_length ), hw_source ));
        }
        if( ntohs( header->operation ) == ARPOP_REQUEST ){
            header->operation = htons( ARPOP_REPLY );
            memcpy( des_proto, src_proto, header->protocol_length );
            memcpy( src_proto, proto->addr->value, header->protocol_length );
            memcpy( src_hw, device->addr->value, device->addr_len );
            memcpy( des_hw, hw_source->value, header->hardware_length );
            ERROR_PROPAGATE( packet_set_addr( packet, src_hw, des_hw, header->hardware_length ));
            nil_send_msg( device->phone, device_id, packet, SERVICE_ARP );
            return 1;
 
        }
    }
    return EOK;
}
 
void clear_device( arp_device_ref device ){
    int             count;
    arp_proto_ref   proto;
 
    for( count = arp_protos_count( & device->protos ) - 1; count >= 0; -- count ){
        proto = arp_protos_get_index( & device->protos, count );
        if( proto ){
            if( proto->addr ) free( proto->addr );
            if( proto->addr_data ) free( proto->addr_data );
            arp_addr_destroy( & proto->addresses );
        }
    }
    arp_protos_clear( & device->protos );
}
 
int arp_connect_module( services_t service ){
    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;
    packet_t            packet;
    packet_t            next;
 
//  printf( "message %d - %d\n", IPC_GET_METHOD( * call ), NET_ARP_FIRST );
    * 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 ), ARP_GET_NETIF( call ), address ))){
                free( address );
                free( data );
            }
            return ERROR_CODE;
        case NET_ARP_TRANSLATE:
            ERROR_PROPAGATE( measured_strings_receive( & address, & data, 1 ));
            rwlock_read_lock( & arp_globals.lock );
            translation = arp_translate_message( IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ), address );
            free( address );
            free( data );
            if( ! translation ){
                rwlock_read_unlock( & arp_globals.lock );
                return ENOENT;
            }
            ERROR_CODE = measured_strings_reply( translation, 1 );
            rwlock_read_unlock( & arp_globals.lock );
            return ERROR_CODE;
        case NET_ARP_CLEAR_DEVICE:
            return arp_clear_device_req( 0, IPC_GET_DEVICE( call ));
        case NET_ARP_CLEAN_CACHE:
            return arp_clean_cache_req( 0 );
        case NET_IL_DEVICE_STATE:
            // do nothing - keep the cache
            return EOK;
        case NET_IL_RECEIVED:
            if( ! ERROR_OCCURRED( packet_translate( arp_globals.net_phone, & packet, IPC_GET_PACKET( call )))){
                rwlock_read_lock( & arp_globals.lock );
                do{
                    next = pq_next( packet );
                    packet_detach( packet );
                    ERROR_CODE = arp_receive_message( IPC_GET_DEVICE( call ), packet );
                    if( ERROR_CODE != 1 ) pq_release( arp_globals.net_phone, packet_get_id( packet ));
                    packet = next;
                }while( packet );
                rwlock_read_unlock( & arp_globals.lock );
            }
            return ERROR_CODE;
    }
    return ENOTSUP;
}
 
/** @}
 */
 

Rev 4351	Rev 4394
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 <mem.h>	40	#include <mem.h>
41	#include <rwlock.h>	41	#include <rwlock.h>
42	#include <stdio.h>	42	#include <stdio.h>
43	#include <string.h>	43	#include <string.h>
44	#include <task.h>	44	#include <task.h>
45		45
46	#include <ipc/ipc.h>	46	#include <ipc/ipc.h>
47	#include <ipc/services.h>	47	#include <ipc/services.h>
48		48
49	#include "../../err.h"	49	#include "../../err.h"
50	#include "../../messages.h"	50	#include "../../messages.h"
51	#include "../../modules.h"	51	#include "../../modules.h"
52		52
53	#include "../../include/byteorder.h"	53	#include "../../include/byteorder.h"
54	#include "../../include/device.h"	54	#include "../../include/device.h"
55	#include "../../include/arp_interface.h"	55	#include "../../include/arp_interface.h"
56	#include "../../include/nil_interface.h"	56	#include "../../include/nil_interface.h"
57	#include "../../include/protocol_map.h"	57	#include "../../include/protocol_map.h"
58		58
59	#include "../../structures/measured_strings.h"	59	#include "../../structures/measured_strings.h"
60	#include "../../structures/packet/packet.h"	60	#include "../../structures/packet/packet.h"
61	#include "../../structures/packet/packet_client.h"	61	#include "../../structures/packet/packet_client.h"
62		62
63	#include "../il_messages.h"	63	#include "../il_messages.h"
64		64
65	#include "arp.h"	65	#include "arp.h"
66	#include "arp_header.h"	66	#include "arp_header.h"
67	#include "arp_oc.h"	67	#include "arp_oc.h"
68	#include "arp_module.h"	68	#include "arp_module.h"
69	#include "arp_messages.h"	69	#include "arp_messages.h"
70		70
71	/** ARP global data.	71	/** ARP global data.
72	*/	72	*/
73	arp_globals_t arp_globals;	73	arp_globals_t arp_globals;
74		74
75	/** Clears the whole cache.	75	/** Clears the whole cache.
76	* @returns EOK on success.	76	* @returns EOK on success.
77	*/	77	*/
78	int arp_clean_cache_req( int arp_phone );	78	int arp_clean_cache_req( int arp_phone );
79		79
80	/** Clears the device specific data from the cache.	80	/** Clears the device specific data from the cache.
81	* @param arp_phone The ARP module phone used for (semi)remote calls. Input parameter.	81	* @param arp_phone The ARP module phone used for (semi)remote calls. Input parameter.
82	* @param device_id The device identifier. Input parameter.	82	* @param device_id The device identifier. Input parameter.
83	* @returns EOK on success.	83	* @returns EOK on success.
84	* @returns ENOENT if the device is not found in the cache.	84	* @returns ENOENT if the device is not found in the cache.
85	*/	85	*/
86	int arp_clear_device_req( int arp_phone, device_id_t device_id );	86	int arp_clear_device_req( int arp_phone, device_id_t device_id );
87		87
88	/** Creates new protocol specific data.	88	/** Creates new protocol specific data.
89	* @param proto Protocol specific data. Output parameter.	89	* @param proto Protocol specific data. Output parameter.
90	* @param service Protocol module service. Input parameter.	90	* @param service Protocol module service. Input parameter.
91	* @param address Actual protocol device address. Input parameter.	91	* @param address Actual protocol device address. Input parameter.
92	* @returns EOK on success.	92	* @returns EOK on success.
93	* @returns ENOMEM if there is not enough memory left.	93	* @returns ENOMEM if there is not enough memory left.
94	*/	94	*/
95	int arp_proto_create( arp_proto_ref * proto, services_t service, measured_string_ref address );	95	int arp_proto_create( arp_proto_ref * proto, services_t service, measured_string_ref address );
96		96
97	/** Registers the device.	97	/** Registers the device.
98	* Creates new device entry in the cache or updates the protocol address if the device with the device identifier and the driver service exists.	98	* Creates new device entry in the cache or updates the protocol address if the device with the device identifier and the driver service exists.
99	* @param device_id The device identifier. Input parameter.	99	* @param device_id The device identifier. Input parameter.
100	* @param service The device driver service. Input parameter.	100	* @param service The device driver service. Input parameter.
101	* @param protocol The protocol service. Input parameter.	101	* @param protocol The protocol service. Input parameter.
102	* @param address The actual device protocol address.	102	* @param address The actual device protocol address.
103	* @returns EOK on success.	103	* @returns EOK on success.
104	* @returns EEXIST if another device with the same device identifier and different driver service exists.	104	* @returns EEXIST if another device with the same device identifier and different driver service exists.
105	* @returns ENOMEM if there is not enough memory left.	105	* @returns ENOMEM if there is not enough memory left.
106	* @returns Other error codes as defined for the measured_strings_return() function.	106	* @returns Other error codes as defined for the measured_strings_return() function.
107	*/	107	*/
108	int arp_device_message( device_id_t device_id, services_t service, services_t protocol, measured_string_ref address );	108	int arp_device_message( device_id_t device_id, services_t service, services_t protocol, measured_string_ref address );
109		109
110	/** Returns the hardware address for the given protocol address.	110	/** Returns the hardware address for the given protocol address.
111	* Sends the ARP request packet if the hardware address is not found in the cache.	111	* Sends the ARP request packet if the hardware address is not found in the cache.
112	* @param device_id The device identifier. Input parameter.	112	* @param device_id The device identifier. Input parameter.
113	* @param protocol The protocol service. Input parameter.	113	* @param protocol The protocol service. Input parameter.
114	* @param target The target protocol address. Input parameter.	114	* @param target The target protocol address. Input parameter.
115	* @returns The hardware address of the target.	115	* @returns The hardware address of the target.
116	* @returns NULL if the target parameter is NULL.	116	* @returns NULL if the target parameter is NULL.
117	* @returns NULL if the device is not found.	117	* @returns NULL if the device is not found.
118	* @returns NULL if the device packet is too small to send a request.	118	* @returns NULL if the device packet is too small to send a request.
119	* @returns NULL if the hardware address is not found in the cache.	119	* @returns NULL if the hardware address is not found in the cache.
120	*/	120	*/
121	measured_string_ref arp_translate_message( device_id_t device_id, services_t protocol, measured_string_ref target );	121	measured_string_ref arp_translate_message( device_id_t device_id, services_t protocol, measured_string_ref target );
122		122
123	/** Processes the received ARP packet.	123	/** Processes the received ARP packet.
124	* Updates the source hardware address if the source entry exists or the packet is targeted to my protocol address.	124	* Updates the source hardware address if the source entry exists or the packet is targeted to my protocol address.
125	* Responses to the ARP request if the packet is the ARP request and is targeted to my address.	125	* Responses to the ARP request if the packet is the ARP request and is targeted to my address.
126	* @param device_id The source device identifier. Input parameter.	126	* @param device_id The source device identifier. Input parameter.
127	* @param packet The received packet. Input/output parameter.	127	* @param packet The received packet. Input/output parameter.
128	* @returns EOK on success.	128	* @returns EOK on success and the packet is no longer needed.
-		129	* @returns 1 on success and the packet has been reused.
129	* @returns EINVAL if the packet is too small to carry the ARP packet.	130	* @returns EINVAL if the packet is too small to carry the ARP packet.
130	* @returns EINVAL if the received address lengths differs from the registered values.	131	* @returns EINVAL if the received address lengths differs from the registered values.
131	* @returns ENOENT if the device is not found in the cache.	132	* @returns ENOENT if the device is not found in the cache.
132	* @returns ENOENT if the protocol for the device is not found in the cache.	133	* @returns ENOENT if the protocol for the device is not found in the cache.
133	* @returns ENOMEM if there is not enough memory left.	134	* @returns ENOMEM if there is not enough memory left.
134	*/	135	*/
135	int arp_receive_message( device_id_t device_id, packet_t packet );	136	int arp_receive_message( device_id_t device_id, packet_t packet );
136		137
137	/** Clears the device specific data.	138	/** Clears the device specific data.
138	* @param device The device specific data.	139	* @param device The device specific data.
139	*/	140	*/
140	void clear_device( arp_device_ref device );	141	void clear_device( arp_device_ref device );
141		142
142	DEVICE_MAP_IMPLEMENT( arp_cache, arp_device_t )	143	DEVICE_MAP_IMPLEMENT( arp_cache, arp_device_t )
143		144
144	INT_MAP_IMPLEMENT( arp_protos, arp_proto_t )	145	INT_MAP_IMPLEMENT( arp_protos, arp_proto_t )
145		146
146	GENERIC_CHAR_MAP_IMPLEMENT( arp_addr, measured_string_t )	147	GENERIC_CHAR_MAP_IMPLEMENT( arp_addr, measured_string_t )
147		148
148	int arp_task_get_id( void ){	149	int arp_task_get_id( void ){
149	return task_get_id();	150	return task_get_id();
150	}	151	}
151		152
152	int arp_clear_device_req( int arp_phone, device_id_t device_id ){	153	int arp_clear_device_req( int arp_phone, device_id_t device_id ){
153	arp_device_ref device;	154	arp_device_ref device;
154		155
155	rwlock_write_lock( & arp_globals.lock );	156	rwlock_write_lock( & arp_globals.lock );
156	device = arp_cache_find( & arp_globals.cache, device_id );	157	device = arp_cache_find( & arp_globals.cache, device_id );
157	if( ! device ){	158	if( ! device ){
158	rwlock_write_unlock( & arp_globals.lock );	159	rwlock_write_unlock( & arp_globals.lock );
159	return ENOENT;	160	return ENOENT;
160	}	161	}
161	clear_device( device );	162	clear_device( device );
162	printf( "Device %d cleared\n", device_id );	163	printf( "Device %d cleared\n", device_id );
163	rwlock_write_unlock( & arp_globals.lock );	164	rwlock_write_unlock( & arp_globals.lock );
164	return EOK;	165	return EOK;
165	}	166	}
166		167
167	int arp_clean_cache_req( int arp_phone ){	168	int arp_clean_cache_req( int arp_phone ){
168	int count;	169	int count;
169	arp_device_ref device;	170	arp_device_ref device;
170		171
171	rwlock_write_lock( & arp_globals.lock );	172	rwlock_write_lock( & arp_globals.lock );
172	for( count = arp_cache_count( & arp_globals.cache ) - 1; count >= 0; -- count ){	173	for( count = arp_cache_count( & arp_globals.cache ) - 1; count >= 0; -- count ){
173	device = arp_cache_get_index( & arp_globals.cache, count );	174	device = arp_cache_get_index( & arp_globals.cache, count );
174	if( device ){	175	if( device ){
175	clear_device( device );	176	clear_device( device );
176	if( device->addr_data ) free( device->addr_data );	177	if( device->addr_data ) free( device->addr_data );
177	if( device->broadcast_data ) free( device->broadcast_data );	178	if( device->broadcast_data ) free( device->broadcast_data );
178	}	179	}
179	}	180	}
180	arp_cache_clear( & arp_globals.cache );	181	arp_cache_clear( & arp_globals.cache );
181	rwlock_write_unlock( & arp_globals.lock );	182	rwlock_write_unlock( & arp_globals.lock );
182	printf( "Cache cleaned\n" );	183	printf( "Cache cleaned\n" );
183	return EOK;	184	return EOK;
184	}	185	}
185		186
186	int arp_device_req( int arp_phone, device_id_t device_id, services_t protocol, services_t netif, measured_string_ref address ){	187	int arp_device_req( int arp_phone, device_id_t device_id, services_t protocol, services_t netif, measured_string_ref address ){
187	ERROR_DECLARE;	188	ERROR_DECLARE;
188		189
189	measured_string_ref tmp;	190	measured_string_ref tmp;
190		191
191	tmp = measured_string_copy( address );	192	tmp = measured_string_copy( address );
192	if( ERROR_OCCURRED( arp_device_message( device_id, netif, protocol, tmp ))){	193	if( ERROR_OCCURRED( arp_device_message( device_id, netif, protocol, tmp ))){
193	free( tmp->value );	194	free( tmp->value );
194	free( tmp );	195	free( tmp );
195	}	196	}
196	return ERROR_CODE;	197	return ERROR_CODE;
197	}	198	}
198		199
199	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 ){	200	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 ){
200	measured_string_ref tmp;	201	measured_string_ref tmp;
201		202
202	rwlock_read_lock( & arp_globals.lock );	203	rwlock_read_lock( & arp_globals.lock );
203	tmp = arp_translate_message( device_id, protocol, address );	204	tmp = arp_translate_message( device_id, protocol, address );
204	if( tmp ){	205	if( tmp ){
205	* translation = measured_string_copy( tmp );	206	* translation = measured_string_copy( tmp );
206	rwlock_read_unlock( & arp_globals.lock );	207	rwlock_read_unlock( & arp_globals.lock );
207	if( * translation ){	208	if( * translation ){
208	* data = ( ** translation ).value;	209	* data = ( ** translation ).value;
209	return EOK;	210	return EOK;
210	}else{	211	}else{
211	return ENOMEM;	212	return ENOMEM;
212	}	213	}
213	}else{	214	}else{
214	rwlock_read_unlock( & arp_globals.lock );	215	rwlock_read_unlock( & arp_globals.lock );
215	return ENOENT;	216	return ENOENT;
216	}	217	}
217	}	218	}
218		219
219	int arp_initialize( async_client_conn_t client_connection ){	220	int arp_initialize( async_client_conn_t client_connection ){
220	ERROR_DECLARE;	221	ERROR_DECLARE;
221		222
222	rwlock_initialize( & arp_globals.lock );	223	rwlock_initialize( & arp_globals.lock );
223	rwlock_write_lock( & arp_globals.lock );	224	rwlock_write_lock( & arp_globals.lock );
224	arp_globals.client_connection = client_connection;	225	arp_globals.client_connection = client_connection;
225	ERROR_PROPAGATE( arp_cache_initialize( & arp_globals.cache ));	226	ERROR_PROPAGATE( arp_cache_initialize( & arp_globals.cache ));
226	rwlock_write_unlock( & arp_globals.lock );	227	rwlock_write_unlock( & arp_globals.lock );
227	return EOK;	228	return EOK;
228	}	229	}
229		230
230	int arp_proto_create( arp_proto_ref * proto, services_t service, measured_string_ref address ){	231	int arp_proto_create( arp_proto_ref * proto, services_t service, measured_string_ref address ){
231	ERROR_DECLARE;	232	ERROR_DECLARE;
232		233
233	* proto = ( arp_proto_ref ) malloc( sizeof( arp_proto_t ));	234	* proto = ( arp_proto_ref ) malloc( sizeof( arp_proto_t ));
234	if( !( * proto )) return ENOMEM;	235	if( !( * proto )) return ENOMEM;
235	( ** proto ).service = service;	236	( ** proto ).service = service;
236	( ** proto ).addr = address;	237	( ** proto ).addr = address;
237	( ** proto ).addr_data = address->value;	238	( ** proto ).addr_data = address->value;
238	if( ERROR_OCCURRED( arp_addr_initialize( &( ** proto).addresses ))){	239	if( ERROR_OCCURRED( arp_addr_initialize( &( ** proto).addresses ))){
239	free( * proto );	240	free( * proto );
240	return ERROR_CODE;	241	return ERROR_CODE;
241	}	242	}
242	return EOK;	243	return EOK;
243	}	244	}
244		245
245	int arp_device_message( device_id_t device_id, services_t service, services_t protocol, measured_string_ref address ){	246	int arp_device_message( device_id_t device_id, services_t service, services_t protocol, measured_string_ref address ){
246	ERROR_DECLARE;	247	ERROR_DECLARE;
247		248
248	arp_device_ref device;	249	arp_device_ref device;
249	arp_proto_ref proto;	250	arp_proto_ref proto;
250	int index;	251	int index;
251		252
252	rwlock_write_lock( & arp_globals.lock );	253	rwlock_write_lock( & arp_globals.lock );
253	// an existing device?	254	// an existing device?
254	device = arp_cache_find( & arp_globals.cache, device_id );	255	device = arp_cache_find( & arp_globals.cache, device_id );
255	if( device ){	256	if( device ){
256	if( device->service != service ){	257	if( device->service != service ){
257	printf( "Device %d already exists\n", device->device_id );	258	printf( "Device %d already exists\n", device->device_id );
258	rwlock_write_unlock( & arp_globals.lock );	259	rwlock_write_unlock( & arp_globals.lock );
259	return EEXIST;	260	return EEXIST;
260	}	261	}
261	proto = arp_protos_find( & device->protos, protocol );	262	proto = arp_protos_find( & device->protos, protocol );
262	if( proto ){	263	if( proto ){
263	free( proto->addr );	264	free( proto->addr );
264	free( proto->addr_data );	265	free( proto->addr_data );
265	proto->addr = address;	266	proto->addr = address;
266	proto->addr_data = address->value;	267	proto->addr_data = address->value;
267	}else{	268	}else{
268	if( ERROR_OCCURRED( arp_proto_create( & proto, protocol, address ))){	269	if( ERROR_OCCURRED( arp_proto_create( & proto, protocol, address ))){
269	rwlock_write_unlock( & arp_globals.lock );	270	rwlock_write_unlock( & arp_globals.lock );
270	return ERROR_CODE;	271	return ERROR_CODE;
271	}	272	}
272	index = arp_protos_add( & device->protos, proto->service, proto );	273	index = arp_protos_add( & device->protos, proto->service, proto );
273	if( index < 0 ){	274	if( index < 0 ){
274	rwlock_write_unlock( & arp_globals.lock );	275	rwlock_write_unlock( & arp_globals.lock );
275	free( proto );	276	free( proto );
276	return index;	277	return index;
277	}	278	}
278	printf( "New protocol added:\n\tdevice id\t= %d\n\tproto\t= %d", device_id, protocol );	279	printf( "New protocol added:\n\tdevice id\t= %d\n\tproto\t= %d", device_id, protocol );
279	}	280	}
280	}else{	281	}else{
281	index = hardware_map( service );	282	index = hardware_map( service );
282	if( ! index ) return ENOENT;	283	if( ! index ) return ENOENT;
283	// create a new device	284	// create a new device
284	device = ( arp_device_ref ) malloc( sizeof( arp_device_t ));	285	device = ( arp_device_ref ) malloc( sizeof( arp_device_t ));
285	if( ! device ){	286	if( ! device ){
286	rwlock_write_unlock( & arp_globals.lock );	287	rwlock_write_unlock( & arp_globals.lock );
287	return ENOMEM;	288	return ENOMEM;
288	}	289	}
289	device->hardware = index;	290	device->hardware = index;
290	device->device_id = device_id;	291	device->device_id = device_id;
291	if( ERROR_OCCURRED( arp_protos_initialize( & device->protos ))	292	if( ERROR_OCCURRED( arp_protos_initialize( & device->protos ))
292	\|\| ERROR_OCCURRED( arp_proto_create( & proto, protocol, address ))){	293	\|\| ERROR_OCCURRED( arp_proto_create( & proto, protocol, address ))){
293	rwlock_write_unlock( & arp_globals.lock );	294	rwlock_write_unlock( & arp_globals.lock );
294	free( device );	295	free( device );
295	return ERROR_CODE;	296	return ERROR_CODE;
296	}	297	}
297	index = arp_protos_add( & device->protos, proto->service, proto );	298	index = arp_protos_add( & device->protos, proto->service, proto );
298	if( index < 0 ){	299	if( index < 0 ){
299	rwlock_write_unlock( & arp_globals.lock );	300	rwlock_write_unlock( & arp_globals.lock );
300	arp_protos_destroy( & device->protos );	301	arp_protos_destroy( & device->protos );
301	free( device );	302	free( device );
302	return index;	303	return index;
303	}	304	}
304	device->service = service;	305	device->service = service;
305	// bind the new one	306	// bind the new one
306	device->phone = bind_service( device->service, device->device_id, SERVICE_ARP, 0, arp_globals.client_connection );	307	device->phone = bind_service( device->service, device->device_id, SERVICE_ARP, 0, arp_globals.client_connection );
307	if( device->phone < 0 ){	308	if( device->phone < 0 ){
308	rwlock_write_unlock( & arp_globals.lock );	309	rwlock_write_unlock( & arp_globals.lock );
309	arp_protos_destroy( & device->protos );	310	arp_protos_destroy( & device->protos );
310	free( device );	311	free( device );
311	return EREFUSED;	312	return EREFUSED;
312	}	313	}
313	// get packet dimensions	314	// get packet dimensions
314	if( ERROR_OCCURRED( nil_packet_size_req( device->phone, device_id, & device->addr_len, & device->prefix, & device->content, & device->suffix ))){	315	if( ERROR_OCCURRED( nil_packet_size_req( device->phone, device_id, & device->addr_len, & device->prefix, & device->content, & device->suffix ))){
315	rwlock_write_unlock( & arp_globals.lock );	316	rwlock_write_unlock( & arp_globals.lock );
316	arp_protos_destroy( & device->protos );	317	arp_protos_destroy( & device->protos );
317	free( device );	318	free( device );
318	return ERROR_CODE;	319	return ERROR_CODE;
319	}	320	}
320	// get hardware address	321	// get hardware address
321	if( ERROR_OCCURRED( nil_get_addr( device->phone, device_id, & device->addr, & device->addr_data ))){	322	if( ERROR_OCCURRED( nil_get_addr( device->phone, device_id, & device->addr, & device->addr_data ))){
322	rwlock_write_unlock( & arp_globals.lock );	323	rwlock_write_unlock( & arp_globals.lock );
323	arp_protos_destroy( & device->protos );	324	arp_protos_destroy( & device->protos );
324	free( device );	325	free( device );
325	return ERROR_CODE;	326	return ERROR_CODE;
326	}	327	}
327	// get broadcast address	328	// get broadcast address
328	if( ERROR_OCCURRED( nil_get_broadcast_addr( device->phone, device_id, & device->broadcast_addr, & device->broadcast_data ))){	329	if( ERROR_OCCURRED( nil_get_broadcast_addr( device->phone, device_id, & device->broadcast_addr, & device->broadcast_data ))){
329	rwlock_write_unlock( & arp_globals.lock );	330	rwlock_write_unlock( & arp_globals.lock );
330	free( device->addr );	331	free( device->addr );
331	free( device->addr_data );	332	free( device->addr_data );
332	arp_protos_destroy( & device->protos );	333	arp_protos_destroy( & device->protos );
333	free( device );	334	free( device );
334	return ERROR_CODE;	335	return ERROR_CODE;
335	}	336	}
336	if( ERROR_OCCURRED( arp_cache_add( & arp_globals.cache, device->device_id, device ))){	337	if( ERROR_OCCURRED( arp_cache_add( & arp_globals.cache, device->device_id, device ))){
337	rwlock_write_unlock( & arp_globals.lock );	338	rwlock_write_unlock( & arp_globals.lock );
338	free( device->addr );	339	free( device->addr );
339	free( device->addr_data );	340	free( device->addr_data );
340	free( device->broadcast_addr );	341	free( device->broadcast_addr );
341	free( device->broadcast_data );	342	free( device->broadcast_data );
342	arp_protos_destroy( & device->protos );	343	arp_protos_destroy( & device->protos );
343	free( device );	344	free( device );
344	return ERROR_CODE;	345	return ERROR_CODE;
345	}	346	}
346	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 );	347	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 );
347	}	348	}
348	rwlock_write_unlock( & arp_globals.lock );	349	rwlock_write_unlock( & arp_globals.lock );
349	return EOK;	350	return EOK;
350	}	351	}
351		352
352	measured_string_ref arp_translate_message( device_id_t device_id, services_t protocol, measured_string_ref target ){	353	measured_string_ref arp_translate_message( device_id_t device_id, services_t protocol, measured_string_ref target ){
353	arp_device_ref device;	354	arp_device_ref device;
354	arp_proto_ref proto;	355	arp_proto_ref proto;
355	measured_string_ref addr;	356	measured_string_ref addr;
356	size_t length;	357	size_t length;
357	packet_t packet;	358	packet_t packet;
358	arp_header_ref header;	359	arp_header_ref header;
359		360
360	if( ! target ) return NULL;	361	if( ! target ) return NULL;
361	device = arp_cache_find( & arp_globals.cache, device_id );	362	device = arp_cache_find( & arp_globals.cache, device_id );
362	if( ! device ) return NULL;	363	if( ! device ) return NULL;
363	proto = arp_protos_find( & device->protos, protocol );	364	proto = arp_protos_find( & device->protos, protocol );
364	if(( ! proto ) \|\| ( proto->addr->length != target->length )) return NULL;	365	if(( ! proto ) \|\| ( proto->addr->length != target->length )) return NULL;
365	addr = arp_addr_find( & proto->addresses, target->value, target->length );	366	addr = arp_addr_find( & proto->addresses, target->value, target->length );
366	if( addr ) return addr;	367	if( addr ) return addr;
367	// ARP packet content size = header + ( address + translation ) * 2	368	// ARP packet content size = header + ( address + translation ) * 2
368	length = 8 + ( CONVERT_SIZE( char, uint8_t, proto->addr->length ) + CONVERT_SIZE( char, uint8_t, device->addr->length )) * 2;	369	length = 8 + ( CONVERT_SIZE( char, uint8_t, proto->addr->length ) + CONVERT_SIZE( char, uint8_t, device->addr->length )) * 2;
369	if( length > device->content ) return NULL;	370	if( length > device->content ) return NULL;
370	packet = packet_get_4( arp_globals.net_phone, device->addr_len, device->prefix, length, device->suffix );	371	packet = packet_get_4( arp_globals.net_phone, device->addr_len, device->prefix, length, device->suffix );
371	if( ! packet ) return NULL;	372	if( ! packet ) return NULL;
372	header = ( arp_header_ref ) packet_suffix( packet, length );	373	header = ( arp_header_ref ) packet_suffix( packet, length );
-		374	if( ! header ){
-		375	pq_release( packet );
-		376	return NULL;
-		377	}
373	header->hardware = htons( device->hardware );	378	header->hardware = htons( device->hardware );
374	header->hardware_length = device->addr->length;	379	header->hardware_length = device->addr->length;
375	header->protocol = htons( protocol_map( device->service, protocol ));	380	header->protocol = htons( protocol_map( device->service, protocol ));
376	header->protocol_length = proto->addr->length;	381	header->protocol_length = proto->addr->length;
377	header->operation = htons( ARPOP_REQUEST );	382	header->operation = htons( ARPOP_REQUEST );
378	length = sizeof( arp_header_t );	383	length = sizeof( arp_header_t );
379	memcpy((( uint8_t * ) header ) + length, device->addr->value, device->addr->length );	384	memcpy((( uint8_t * ) header ) + length, device->addr->value, device->addr->length );
380	length += device->addr->length;	385	length += device->addr->length;
381	memcpy((( uint8_t * ) header ) + length, proto->addr->value, proto->addr->length );	386	memcpy((( uint8_t * ) header ) + length, proto->addr->value, proto->addr->length );
382	length += proto->addr->length;	387	length += proto->addr->length;
383	bzero((( uint8_t * ) header ) + length, device->addr->length );	388	bzero((( uint8_t * ) header ) + length, device->addr->length );
384	length += device->addr->length;	389	length += device->addr->length;
385	memcpy((( uint8_t * ) header ) + length, target->value, target->length );	390	memcpy((( uint8_t * ) header ) + length, target->value, target->length );
386	packet_set_addr( packet, ( uint8_t * ) device->addr->value, ( uint8_t * ) device->broadcast_addr->value, CONVERT_SIZE( char, uint8_t, device->addr->length ));	391	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 ){
-		392	pq_release( packet );
-		393	return NULL;
-		394	}
387	nil_send_msg( device->phone, device_id, packet, SERVICE_ARP );	395	nil_send_msg( device->phone, device_id, packet, SERVICE_ARP );
388	return NULL;	396	return NULL;
389	}	397	}
390		398
391	int arp_receive_message( device_id_t device_id, packet_t packet ){	399	int arp_receive_message( device_id_t device_id, packet_t packet ){
392	ERROR_DECLARE;	400	ERROR_DECLARE;
393		401
394	size_t length;	402	size_t length;
395	arp_header_ref header;	403	arp_header_ref header;
396	arp_device_ref device;	404	arp_device_ref device;
397	arp_proto_ref proto;	405	arp_proto_ref proto;
398	measured_string_ref hw_source;	406	measured_string_ref hw_source;
399	uint8_t * src_hw;	407	uint8_t * src_hw;
400	uint8_t * src_proto;	408	uint8_t * src_proto;
401	uint8_t * des_hw;	409	uint8_t * des_hw;
402	uint8_t * des_proto;	410	uint8_t * des_proto;
403		411
404	length = packet_get_data_length( packet );	412	length = packet_get_data_length( packet );
405	if( length <= sizeof( arp_header_t )) return EINVAL;	413	if( length <= sizeof( arp_header_t )) return EINVAL;
406	device = arp_cache_find( & arp_globals.cache, device_id );	414	device = arp_cache_find( & arp_globals.cache, device_id );
407	if( ! device ) return ENOENT;	415	if( ! device ) return ENOENT;
408	header = ( arp_header_ref ) packet_get_data( packet );	416	header = ( arp_header_ref ) packet_get_data( packet );
409	if(( ntohs( header->hardware ) != device->hardware )	417	if(( ntohs( header->hardware ) != device->hardware )
410	\|\| ( length < sizeof( arp_header_t ) + ( header->hardware_length + header->protocol_length ) * 2 )){	418	\|\| ( length < sizeof( arp_header_t ) + ( header->hardware_length + header->protocol_length ) * 2 )){
411	return EINVAL;	419	return EINVAL;
412	}	420	}
413	proto = arp_protos_find( & device->protos, protocol_unmap( device->service, ntohs( header->protocol )));	421	proto = arp_protos_find( & device->protos, protocol_unmap( device->service, ntohs( header->protocol )));
414	if( ! proto ) return ENOENT;	422	if( ! proto ) return ENOENT;
415	src_hw = (( uint8_t * ) header ) + sizeof( arp_header_t );	423	src_hw = (( uint8_t * ) header ) + sizeof( arp_header_t );
416	src_proto = src_hw + header->hardware_length;	424	src_proto = src_hw + header->hardware_length;
417	des_hw = src_proto + header->protocol_length;	425	des_hw = src_proto + header->protocol_length;
418	des_proto = des_hw + header->hardware_length;	426	des_proto = des_hw + header->hardware_length;
419	hw_source = arp_addr_find( & proto->addresses, ( char * ) src_proto, CONVERT_SIZE( uint8_t, char, header->protocol_length ));	427	hw_source = arp_addr_find( & proto->addresses, ( char * ) src_proto, CONVERT_SIZE( uint8_t, char, header->protocol_length ));
420	// exists?	428	// exists?
421	if( hw_source ){	429	if( hw_source ){
422	if( hw_source->length != CONVERT_SIZE( uint8_t, char, header->hardware_length )){	430	if( hw_source->length != CONVERT_SIZE( uint8_t, char, header->hardware_length )){
423	return EINVAL;	431	return EINVAL;
424	}	432	}
425	memcpy( hw_source->value, src_hw, hw_source->length );	433	memcpy( hw_source->value, src_hw, hw_source->length );
426	}	434	}
427	// is my protocol address?	435	// is my protocol address?
428	if( proto->addr->length != CONVERT_SIZE( uint8_t, char, header->protocol_length )){	436	if( proto->addr->length != CONVERT_SIZE( uint8_t, char, header->protocol_length )){
429	return EINVAL;	437	return EINVAL;
430	}	438	}
431	if( ! str_lcmp( proto->addr->value, ( char * ) des_proto, proto->addr->length )){	439	if( ! str_lcmp( proto->addr->value, ( char * ) des_proto, proto->addr->length )){
432	// not already upadted?	440	// not already upadted?
433	if( ! hw_source ){	441	if( ! hw_source ){
434	hw_source = measured_string_create_bulk(( char * ) src_hw, CONVERT_SIZE( uint8_t, char, header->hardware_length ));	442	hw_source = measured_string_create_bulk(( char * ) src_hw, CONVERT_SIZE( uint8_t, char, header->hardware_length ));
435	if( ! hw_source ) return ENOMEM;	443	if( ! hw_source ) return ENOMEM;
436	ERROR_PROPAGATE( arp_addr_add( & proto->addresses, ( char * ) src_proto, CONVERT_SIZE( uint8_t, char, header->protocol_length ), hw_source ));	444	ERROR_PROPAGATE( arp_addr_add( & proto->addresses, ( char * ) src_proto, CONVERT_SIZE( uint8_t, char, header->protocol_length ), hw_source ));
437	}	445	}
438	if( ntohs( header->operation ) == ARPOP_REQUEST ){	446	if( ntohs( header->operation ) == ARPOP_REQUEST ){
439	header->operation = htons( ARPOP_REPLY );	447	header->operation = htons( ARPOP_REPLY );
440	memcpy( des_proto, src_proto, header->protocol_length );	448	memcpy( des_proto, src_proto, header->protocol_length );
441	memcpy( src_proto, proto->addr->value, header->protocol_length );	449	memcpy( src_proto, proto->addr->value, header->protocol_length );
442	memcpy( src_hw, device->addr->value, device->addr_len );	450	memcpy( src_hw, device->addr->value, device->addr_len );
443	memcpy( des_hw, hw_source->value, header->hardware_length );	451	memcpy( des_hw, hw_source->value, header->hardware_length );
444	packet_set_addr( packet, src_hw, des_hw, header->hardware_length );	452	ERROR_PROPAGATE( packet_set_addr( packet, src_hw, des_hw, header->hardware_length ));
445	nil_send_msg( device->phone, device_id, packet, SERVICE_ARP );	453	nil_send_msg( device->phone, device_id, packet, SERVICE_ARP );
446	}else{	454	return 1;
447	pq_release( arp_globals.net_phone, packet_get_id( packet ));	-
448	}	455	}
449	}	456	}
450	return EOK;	457	return EOK;
451	}	458	}
452		459
453	void clear_device( arp_device_ref device ){	460	void clear_device( arp_device_ref device ){
454	int count;	461	int count;
455	arp_proto_ref proto;	462	arp_proto_ref proto;
456		463
457	for( count = arp_protos_count( & device->protos ) - 1; count >= 0; -- count ){	464	for( count = arp_protos_count( & device->protos ) - 1; count >= 0; -- count ){
458	proto = arp_protos_get_index( & device->protos, count );	465	proto = arp_protos_get_index( & device->protos, count );
459	if( proto ){	466	if( proto ){
460	if( proto->addr ) free( proto->addr );	467	if( proto->addr ) free( proto->addr );
461	if( proto->addr_data ) free( proto->addr_data );	468	if( proto->addr_data ) free( proto->addr_data );
462	arp_addr_destroy( & proto->addresses );	469	arp_addr_destroy( & proto->addresses );
463	}	470	}
464	}	471	}
465	arp_protos_clear( & device->protos );	472	arp_protos_clear( & device->protos );
466	}	473	}
467		474
468	int arp_connect_module( services_t service ){	475	int arp_connect_module( services_t service ){
469	return EOK;	476	return EOK;
470	}	477	}
471		478
472	int arp_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){	479	int arp_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
473	ERROR_DECLARE;	480	ERROR_DECLARE;
474		481
475	measured_string_ref address;	482	measured_string_ref address;
476	measured_string_ref translation;	483	measured_string_ref translation;
477	char * data;	484	char * data;
478	packet_t packet;	485	packet_t packet;
-		486	packet_t next;
479		487
480	// printf( "message %d - %d\n", IPC_GET_METHOD( * call ), NET_ARP_FIRST );	488	// printf( "message %d - %d\n", IPC_GET_METHOD( * call ), NET_ARP_FIRST );
481	* answer_count = 0;	489	* answer_count = 0;
482	switch( IPC_GET_METHOD( * call )){	490	switch( IPC_GET_METHOD( * call )){
483	case IPC_M_PHONE_HUNGUP:	491	case IPC_M_PHONE_HUNGUP:
484	return EOK;	492	return EOK;
485	case NET_ARP_DEVICE:	493	case NET_ARP_DEVICE:
486	ERROR_PROPAGATE( measured_strings_receive( & address, & data, 1 ));	494	ERROR_PROPAGATE( measured_strings_receive( & address, & data, 1 ));
487	if( ERROR_OCCURRED( arp_device_message( IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ), ARP_GET_NETIF( call ), address ))){	495	if( ERROR_OCCURRED( arp_device_message( IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ), ARP_GET_NETIF( call ), address ))){
488	free( address );	496	free( address );
489	free( data );	497	free( data );
490	}	498	}
491	return ERROR_CODE;	499	return ERROR_CODE;

Subversion Repositories HelenOS

(root)/branches/network/uspace/srv/net/il/arp/arp.c @ 4408 – Rev 4351 → 4394