WebSVN – HelenOS – Diff – /branches/network/uspace/srv/net/il/ip/ip.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 ip
 *  @{
 */
 
/** @file
 */
 
#include <async.h>
#include <errno.h>
#include <stdio.h>
 
#include <ipc/ipc.h>
#include <ipc/services.h>
 
#include "../../err.h"
#include "../../messages.h"
#include "../../modules.h"
 
#include "../../include/sockaddr.h"
#include "../../include/socket.h"
#include "../../include/device.h"
#include "../../structures/measured_strings.h"
#include "../../structures/module_map.h"
#include "../../structures/packet/packet_client.h"
 
#include "ip.h"
#include "ip_messages.h"
#include "ip_module.h"
 
#define DEFAULT_IPV     4
 
#define ARP_NAME                "arp"
#define ARP_FILENAME            "/srv/arp"
 
#define IPC_GET_DEVICE( call )      ( device_id_t ) IPC_GET_ARG1( * call )
#define IPC_GET_PACKET( call )      ( packet_id_t ) IPC_GET_ARG1( * call )
#define IPC_GET_PROTO( call )       ( int ) IPC_GET_ARG1( * call )
#define IPC_GET_SERVICE( call )     ( services_t ) IPC_GET_ARG2( * call )
#define IPC_GET_STATE( call )       ( device_state_t ) IPC_GET_ARG2( * call )
#define IPC_GET_PHONE( call )       ( int ) IPC_GET_ARG5( * call )
 
ip_globals_t    ip_globals;
 
DEVICE_MAP_IMPLEMENT( ip_netifs, ip_netif_t )
 
INT_MAP_IMPLEMENT( ip_protos, ip_proto_t )
 
int ip_register_message( int protocol, int phone );
int ip_state_message( device_id_t device_id, device_state_t state );
void    ip_driver_receiver( ipc_callid_t iid, ipc_call_t * icall );
 
/** Initializes the module.
 */
int ip_initialize( void ){
    ERROR_DECLARE;
 
    ERROR_PROPAGATE( ip_netifs_initialize( & ip_globals.netifs ));
    ERROR_PROPAGATE( ip_protos_initialize( & ip_globals.protos ));
    ERROR_PROPAGATE( modules_initialize( & ip_globals.modules ));
    ERROR_PROPAGATE( add_module( NULL, & ip_globals.modules, ARP_NAME, ARP_FILENAME, SERVICE_ARP, 0 ));
    return EOK;
}
 
int ip_echo_message( ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, ipcarg_t * answer1, ipcarg_t * answer2, ipcarg_t * answer3, ipcarg_t * answer4, ipcarg_t * answer5 ){
    if( answer1 ) * answer1 = arg1;
    if( answer2 ) * answer2 = arg2;
    if( answer3 ) * answer3 = arg3;
    if( answer4 ) * answer4 = arg4;
    if( answer5 ) * answer5 = arg5;
    return EOK;
}
 
int ip_device_message( device_id_t device_id, services_t service ){
    ERROR_DECLARE;
 
    ip_netif_ref    ip_netif;
    aid_t           message;
    ipc_call_t      answer;
    measured_string_t   configuration[ 9 ] = {{ "IPV", 3 }, { "IP_CONFIG", 9 }, { "IP_ADDR", 7 }, { "NETMASK", 7 }, { "GATEWAY", 7 }, { "BROADCAST", 9 }, { "DNS1", 4 }, { "DNS2", 4 }, { "ARP", 3 }};
    int         count = 9;
    measured_string_ref settings;
    char *          data;
    ipcarg_t        result;
    int             index;
 
    ip_netif = ( ip_netif_ref ) malloc( sizeof( ip_netif_t ));
    if( ! ip_netif ) return ENOMEM;
    ip_netif->device_id = device_id;
    // get configuration
    // TODO mapping
    message = async_send_2( ip_globals.networking_phone, NET_NET_GET_DEVICE_CONF, ip_netif->device_id, count, & answer );
    // send names and get settings
    if( ERROR_OCCURRED( measured_strings_send( ip_globals.networking_phone, configuration, count ))
    || ERROR_OCCURRED( measured_strings_return( ip_globals.networking_phone, & settings, & data, count ))){
        async_wait_for( message, NULL );
        free( ip_netif );
        return ERROR_CODE;
    }
    async_wait_for( message, & result );
    if( ERROR_OCCURRED( result )){
        if( settings ){
            free( settings );
            free( data );
        };
        free( ip_netif );
        return ERROR_CODE;
    }
    if( settings ){
        if( settings[ 0 ].value ){
            ip_netif->ipv = strtol( settings[ 0 ].value, NULL, 0 );
        }else{
            ip_netif->ipv = DEFAULT_IPV;
        }
        ip_netif->dhcp = ! strncmp( settings[ 1 ].value, "dhcp", 4 );
        if( ip_netif->dhcp ){
            // TODO dhcp
            free( settings );
            free( data );
            free( ip_netif );
            return ENOTSUP;
        }else if( ip_netif->ipv == 4 ){
            if( ERROR_OCCURRED( inet_pton( AF_INET, settings[ 2 ].value, ( uint8_t * ) & ip_netif->address ))
            || ERROR_OCCURRED( inet_pton( AF_INET, settings[ 3 ].value, ( uint8_t * ) & ip_netif->netmask ))
            || ( inet_pton( AF_INET, settings[ 4 ].value, ( uint8_t * ) & ip_netif->gateway ) == EINVAL )
            || ( inet_pton( AF_INET, settings[ 5 ].value, ( uint8_t * ) & ip_netif->broadcast ) == EINVAL )
            || ( inet_pton( AF_INET, settings[ 6 ].value, ( uint8_t * ) & ip_netif->dns1 ) == EINVAL )
            || ( inet_pton( AF_INET, settings[ 7 ].value, ( uint8_t * ) & ip_netif->dns2 ) == EINVAL )){
                free( settings );
                free( data );
                free( ip_netif );
                return EINVAL;
            }
        }else{
            // TODO ipv6
            free( settings );
            free( data );
            free( ip_netif );
            return ENOTSUP;
        }
        if( settings[ 8 ].value ){
            ip_netif->arp = get_running_module( & ip_globals.modules, settings[ 8 ].value );
            if( ! ip_netif->arp ){
                printf( "\nFailed to start the arp %s", settings[ 8 ].value );
                free( settings );
                free( data );
                free( ip_netif );
                return EINVAL;
            }
        }else{
            ip_netif->arp = NULL;
        }
        free( settings );
        free( data );
    }
    // TODO mapping
    ip_netif->phone = bind_service( service, ip_netif->device_id, SERVICE_IP, 0, ip_driver_receiver );
    if( ip_netif->phone < 0 ){
        printf( "\nFailed to contact the nil service %d", service );
        free( ip_netif );
        return ip_netif->phone;
    }
    if( ip_netif->arp ){
        message = async_send_3( ip_netif->arp->phone, NET_ARP_DEVICE, ip_netif->device_id, SERVICE_IP, service, & answer );
        configuration[ 0 ].value = ( char * ) & ip_netif->address;
        configuration[ 0 ].length = CONVERT_SIZE( in_addr_t, char, 1 );
        if( ERROR_OCCURRED( measured_strings_send( ip_netif->arp->phone, & configuration[ 0 ], 1 ))){
            free( ip_netif );
            return ERROR_CODE;
        }
        async_wait_for( message, & result );
        if( ERROR_OCCURRED( result )){
            free( ip_netif );
            return ERROR_CODE;
        }
    }
    index = ip_netifs_add( & ip_globals.netifs, ip_netif->device_id, ip_netif );
    if( index < 0 ){
        free( ip_netif );
        return index;
    }
    if( ip_netif->arp ) ++ ip_netif->arp->usage;
    // print the settings
    printf( "\nNew device registered:\n\tid\t= %d\n\tphone\t= %d\n\tIPV\t= %d", ip_netif->device_id, ip_netif->phone, ip_netif->ipv );
    printf( "\n\tconfiguration\t= %s", ip_netif->dhcp ? "dhcp" : "static" );
    // TODO ipv6 addresses
    data = malloc( INET_ADDRSTRLEN );
    if( data ){
        inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->address, data, INET_ADDRSTRLEN );
        printf( "\n\taddress\t= %s", data );
        inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->netmask, data, INET_ADDRSTRLEN );
        printf( "\n\tnetmask\t= %s", data );
        inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->gateway, data, INET_ADDRSTRLEN );
        printf( "\n\tgateway\t= %s", data );
        inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->broadcast, data, INET_ADDRSTRLEN );
        printf( "\n\tbroadcast\t= %s", data );
        inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->dns1, data, INET_ADDRSTRLEN );
        printf( "\n\tdns1\t= %s", data );
        inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->dns2, data, INET_ADDRSTRLEN );
        printf( "\n\tdns2\t= %s", data );
        free( data );
    }
    return EOK;
}
 
void ip_driver_receiver( ipc_callid_t iid, ipc_call_t * icall ){
    ERROR_DECLARE;
 
    ipc_callid_t    callid;
    ipc_call_t  call;
//  ipc_call_t  answer;
//  int     count;
    int     result;
    packet_t    packet;
 
    /*
     * Accept the connection
     *  - Answer the first IPC_M_CONNECT_ME_TO call.
     */
    ipc_answer_0( iid, EOK );
 
    while( true ){
/*      // refresh data
        count = 0;
        IPC_SET_RETVAL( answer, 0 );
        // just to be precize
        IPC_SET_RETVAL( answer, 0 );
        IPC_SET_ARG1( answer, 0 );
        IPC_SET_ARG2( answer, 0 );
        IPC_SET_ARG3( answer, 0 );
        IPC_SET_ARG4( answer, 0 );
        IPC_SET_ARG5( answer, 0 );
*/
        callid = async_get_call( & call );
        switch( IPC_GET_METHOD( call )){
            case NET_IL_DEVICE_STATE:
            case NET_NIL_DEVICE_STATE:
                result = ip_state_message( IPC_GET_DEVICE( & call ), IPC_GET_STATE( & call ));
                ipc_answer_0( callid, result );
            // TODO packer received
            case NET_IL_RECEIVED:
            case NET_NIL_RECEIVED:
                if( ! ERROR_OCCURRED( result = packet_translate( ip_globals.networking_phone, & packet, IPC_GET_PACKET( & call )))){
                    //result = ip_receive_message( IPC_GET_DEVICE( call ), packet );
                }
                ipc_answer_0( callid, result );
        }
    }
}
 
int ip_state_message( device_id_t device_id, device_state_t state ){
    ERROR_DECLARE;
 
    ip_netif_ref    netif;
 
    aid_t           message;
    ipc_call_t      answer;
    measured_string_t address;
    measured_string_ref translation;
    char *          data;
    ipcarg_t        result;
 
    netif = ip_netifs_find( & ip_globals.netifs, device_id );
    if( ! netif ) return ENOENT;
    // TODO state
    printf( "\nip - device %d changed state to %d\n", device_id, state );
    if( netif->arp ){
        message = async_send_2( netif->arp->phone, NET_ARP_TRANSLATE, netif->device_id, SERVICE_IP, & answer );
        address.value = ( char * ) & netif->gateway;
        address.length = CONVERT_SIZE( in_addr_t, char, 1 );
        if( ERROR_OCCURRED( measured_strings_send( netif->arp->phone, & address, 1 ))
        || ERROR_OCCURRED( measured_strings_return( netif->arp->phone, & translation, & data, 1 ))){
            async_wait_for( message, & result );
            return result;
        }
        async_wait_for( message, & result );
        if( ! ERROR_OCCURRED( result )){
            printf( "\n\tgateway translated to\t= %X:%X:%X:%X:%X:%X", data[ 0 ], data[ 1 ], data[ 2 ], data[ 3 ], data[ 4 ], data[ 5 ] );
        }
        free( translation );
        free( data );
        return result;
    }
    return EOK;
}
 
int ip_register_message( int protocol, int phone ){
    ip_proto_ref    proto;
    int             index;
 
    proto = ( ip_proto_ref ) malloc( sizeof( ip_protos_t ));
    if( ! proto ) return ENOMEM;
    proto->protocol = protocol;
    proto->phone = phone;
    index = ip_protos_add( & ip_globals.protos, proto->protocol, proto );
    if( index < 0 ){
        free( proto );
        return index;
    }
    printf( "\nNew protocol registered:\n\tprotocol\t= %d\n\tphone\t= %d", proto->protocol, proto->phone );
    return EOK;
}
 
int ip_send_message( device_id_t device_id, packet_t packet ){
    // TODO send packet
    printf( "Packet to send via %d: %s", device_id, packet_get_data( packet ));
    pq_release( ip_globals.networking_phone, packet_get_id( packet ));
    return EOK;
}
 
int ip_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
    ERROR_DECLARE;
 
    packet_t    packet;
 
    * answer_count = 0;
    switch( IPC_GET_METHOD( * call )){
        case IPC_M_PHONE_HUNGUP:
            return EOK;
        case NET_IP_ECHO:
            * answer_count = 5;
            return ip_echo_message( IPC_GET_ARG1( * call ), IPC_GET_ARG2( * call ), IPC_GET_ARG3( * call ), IPC_GET_ARG4( * call ), IPC_GET_ARG5( * call ), & IPC_GET_ARG1( * answer ), & IPC_GET_ARG2( * answer ), & IPC_GET_ARG3( * answer ), & IPC_GET_ARG4( * answer ), & IPC_GET_ARG5( * answer ) );
        case NET_IL_DEVICE:
            return ip_device_message( IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ));
        case IPC_M_CONNECT_TO_ME:
            return ip_register_message( IPC_GET_PROTO( call ), IPC_GET_PHONE( call ));
        case NET_IP_SEND:
            ERROR_PROPAGATE( packet_translate( ip_globals.networking_phone, & packet, IPC_GET_PACKET( call )));
            return ip_send_message( IPC_GET_DEVICE( call ), packet );
    }
    return ENOTSUP;
}
 
/** @}
 */
 

Rev 4192	Rev 4243
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 ip	29	/** @addtogroup ip
30	* @{	30	* @{
31	*/	31	*/
32		32
33	/** @file	33	/** @file
34	*/	34	*/
35		35
36	#include <async.h>	36	#include <async.h>
37	#include <errno.h>	37	#include <errno.h>
38	#include <stdio.h>	38	#include <stdio.h>
39		39
40	#include <ipc/ipc.h>	40	#include <ipc/ipc.h>
41	#include <ipc/services.h>	41	#include <ipc/services.h>
42		42
43	#include "../../err.h"	43	#include "../../err.h"
44	#include "../../messages.h"	44	#include "../../messages.h"
45	#include "../../modules.h"	45	#include "../../modules.h"
46		46
47	#include "../../include/sockaddr.h"	47	#include "../../include/sockaddr.h"
48	#include "../../include/socket.h"	48	#include "../../include/socket.h"
49	#include "../../netif/device.h"	49	#include "../../include/device.h"
50	#include "../../structures/measured_strings.h"	50	#include "../../structures/measured_strings.h"
51	#include "../../structures/module_map.h"	51	#include "../../structures/module_map.h"
52	#include "../../structures/packet/packet_client.h"	52	#include "../../structures/packet/packet_client.h"
53		53
54	#include "ip.h"	54	#include "ip.h"
55	#include "ip_messages.h"	55	#include "ip_messages.h"
56	#include "ip_module.h"	56	#include "ip_module.h"
57		57
58	#define DEFAULT_IPV 4	58	#define DEFAULT_IPV 4
59		59
60	#define ARP_NAME "arp"	60	#define ARP_NAME "arp"
61	#define ARP_FILENAME "/srv/arp"	61	#define ARP_FILENAME "/srv/arp"
62		62
63	#define IPC_GET_DEVICE( call ) ( device_id_t ) IPC_GET_ARG1( * call )	63	#define IPC_GET_DEVICE( call ) ( device_id_t ) IPC_GET_ARG1( * call )
64	#define IPC_GET_PACKET( call ) ( packet_id_t ) IPC_GET_ARG1( * call )	64	#define IPC_GET_PACKET( call ) ( packet_id_t ) IPC_GET_ARG1( * call )
65	#define IPC_GET_PROTO( call ) ( int ) IPC_GET_ARG1( * call )	65	#define IPC_GET_PROTO( call ) ( int ) IPC_GET_ARG1( * call )
66	#define IPC_GET_SERVICE( call ) ( services_t ) IPC_GET_ARG2( * call )	66	#define IPC_GET_SERVICE( call ) ( services_t ) IPC_GET_ARG2( * call )
67	#define IPC_GET_STATE( call ) ( device_state_t ) IPC_GET_ARG2( * call )	67	#define IPC_GET_STATE( call ) ( device_state_t ) IPC_GET_ARG2( * call )
68	#define IPC_GET_PHONE( call ) ( int ) IPC_GET_ARG5( * call )	68	#define IPC_GET_PHONE( call ) ( int ) IPC_GET_ARG5( * call )
69		69
70	ip_globals_t ip_globals;	70	ip_globals_t ip_globals;
71		71
72	DEVICE_MAP_IMPLEMENT( ip_netifs, ip_netif_t )	72	DEVICE_MAP_IMPLEMENT( ip_netifs, ip_netif_t )
73		73
74	INT_MAP_IMPLEMENT( ip_protos, ip_proto_t )	74	INT_MAP_IMPLEMENT( ip_protos, ip_proto_t )
75		75
76	int ip_register_message( int protocol, int phone );	76	int ip_register_message( int protocol, int phone );
77	int ip_state_message( device_id_t device_id, device_state_t state );	77	int ip_state_message( device_id_t device_id, device_state_t state );
78	void ip_driver_receiver( ipc_callid_t iid, ipc_call_t * icall );	78	void ip_driver_receiver( ipc_callid_t iid, ipc_call_t * icall );
79		79
80	/** Initializes the module.	80	/** Initializes the module.
81	*/	81	*/
82	int ip_initialize( void ){	82	int ip_initialize( void ){
83	ERROR_DECLARE;	83	ERROR_DECLARE;
84		84
85	ERROR_PROPAGATE( ip_netifs_initialize( & ip_globals.netifs ));	85	ERROR_PROPAGATE( ip_netifs_initialize( & ip_globals.netifs ));
86	ERROR_PROPAGATE( ip_protos_initialize( & ip_globals.protos ));	86	ERROR_PROPAGATE( ip_protos_initialize( & ip_globals.protos ));
87	ERROR_PROPAGATE( modules_initialize( & ip_globals.modules ));	87	ERROR_PROPAGATE( modules_initialize( & ip_globals.modules ));
88	ERROR_PROPAGATE( add_module( NULL, & ip_globals.modules, ARP_NAME, ARP_FILENAME, SERVICE_ARP, 0 ));	88	ERROR_PROPAGATE( add_module( NULL, & ip_globals.modules, ARP_NAME, ARP_FILENAME, SERVICE_ARP, 0 ));
89	return EOK;	89	return EOK;
90	}	90	}
91		91
92	int ip_echo_message( ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, ipcarg_t * answer1, ipcarg_t * answer2, ipcarg_t * answer3, ipcarg_t * answer4, ipcarg_t * answer5 ){	92	int ip_echo_message( ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5, ipcarg_t * answer1, ipcarg_t * answer2, ipcarg_t * answer3, ipcarg_t * answer4, ipcarg_t * answer5 ){
93	if( answer1 ) * answer1 = arg1;	93	if( answer1 ) * answer1 = arg1;
94	if( answer2 ) * answer2 = arg2;	94	if( answer2 ) * answer2 = arg2;
95	if( answer3 ) * answer3 = arg3;	95	if( answer3 ) * answer3 = arg3;
96	if( answer4 ) * answer4 = arg4;	96	if( answer4 ) * answer4 = arg4;
97	if( answer5 ) * answer5 = arg5;	97	if( answer5 ) * answer5 = arg5;
98	return EOK;	98	return EOK;
99	}	99	}
100		100
101	int ip_device_message( device_id_t device_id, services_t service ){	101	int ip_device_message( device_id_t device_id, services_t service ){
102	ERROR_DECLARE;	102	ERROR_DECLARE;
103		103
104	ip_netif_ref ip_netif;	104	ip_netif_ref ip_netif;
105	aid_t message;	105	aid_t message;
106	ipc_call_t answer;	106	ipc_call_t answer;
107	measured_string_t configuration[ 9 ] = {{ "IPV", 3 }, { "IP_CONFIG", 9 }, { "IP_ADDR", 7 }, { "NETMASK", 7 }, { "GATEWAY", 7 }, { "BROADCAST", 9 }, { "DNS1", 4 }, { "DNS2", 4 }, { "ARP", 3 }};	107	measured_string_t configuration[ 9 ] = {{ "IPV", 3 }, { "IP_CONFIG", 9 }, { "IP_ADDR", 7 }, { "NETMASK", 7 }, { "GATEWAY", 7 }, { "BROADCAST", 9 }, { "DNS1", 4 }, { "DNS2", 4 }, { "ARP", 3 }};
108	int count = 9;	108	int count = 9;
109	measured_string_ref settings;	109	measured_string_ref settings;
110	char * data;	110	char * data;
111	ipcarg_t result;	111	ipcarg_t result;
112	int index;	112	int index;
113		113
114	ip_netif = ( ip_netif_ref ) malloc( sizeof( ip_netif_t ));	114	ip_netif = ( ip_netif_ref ) malloc( sizeof( ip_netif_t ));
115	if( ! ip_netif ) return ENOMEM;	115	if( ! ip_netif ) return ENOMEM;
116	ip_netif->device_id = device_id;	116	ip_netif->device_id = device_id;
117	// get configuration	117	// get configuration
118	// TODO mapping	118	// TODO mapping
119	message = async_send_2( ip_globals.networking_phone, NET_NET_GET_DEVICE_CONF, ip_netif->device_id, count, & answer );	119	message = async_send_2( ip_globals.networking_phone, NET_NET_GET_DEVICE_CONF, ip_netif->device_id, count, & answer );
120	// send names and get settings	120	// send names and get settings
121	if( ERROR_OCCURRED( measured_strings_send( ip_globals.networking_phone, configuration, count ))	121	if( ERROR_OCCURRED( measured_strings_send( ip_globals.networking_phone, configuration, count ))
122	\|\| ERROR_OCCURRED( measured_strings_return( ip_globals.networking_phone, & settings, & data, count ))){	122	\|\| ERROR_OCCURRED( measured_strings_return( ip_globals.networking_phone, & settings, & data, count ))){
123	async_wait_for( message, NULL );	123	async_wait_for( message, NULL );
124	free( ip_netif );	124	free( ip_netif );
125	return ERROR_CODE;	125	return ERROR_CODE;
126	}	126	}
127	async_wait_for( message, & result );	127	async_wait_for( message, & result );
128	if( ERROR_OCCURRED( result )){	128	if( ERROR_OCCURRED( result )){
129	if( settings ){	129	if( settings ){
130	free( settings );	130	free( settings );
131	free( data );	131	free( data );
132	};	132	};
133	free( ip_netif );	133	free( ip_netif );
134	return ERROR_CODE;	134	return ERROR_CODE;
135	}	135	}
136	if( settings ){	136	if( settings ){
137	if( settings[ 0 ].value ){	137	if( settings[ 0 ].value ){
138	ip_netif->ipv = strtol( settings[ 0 ].value, NULL, 0 );	138	ip_netif->ipv = strtol( settings[ 0 ].value, NULL, 0 );
139	}else{	139	}else{
140	ip_netif->ipv = DEFAULT_IPV;	140	ip_netif->ipv = DEFAULT_IPV;
141	}	141	}
142	ip_netif->dhcp = ! strncmp( settings[ 1 ].value, "dhcp", 4 );	142	ip_netif->dhcp = ! strncmp( settings[ 1 ].value, "dhcp", 4 );
143	if( ip_netif->dhcp ){	143	if( ip_netif->dhcp ){
144	// TODO dhcp	144	// TODO dhcp
145	free( settings );	145	free( settings );
146	free( data );	146	free( data );
147	free( ip_netif );	147	free( ip_netif );
148	return ENOTSUP;	148	return ENOTSUP;
149	}else if( ip_netif->ipv == 4 ){	149	}else if( ip_netif->ipv == 4 ){
150	if( ERROR_OCCURRED( inet_pton( AF_INET, settings[ 2 ].value, ( uint8_t * ) & ip_netif->address ))	150	if( ERROR_OCCURRED( inet_pton( AF_INET, settings[ 2 ].value, ( uint8_t * ) & ip_netif->address ))
151	\|\| ERROR_OCCURRED( inet_pton( AF_INET, settings[ 3 ].value, ( uint8_t * ) & ip_netif->netmask ))	151	\|\| ERROR_OCCURRED( inet_pton( AF_INET, settings[ 3 ].value, ( uint8_t * ) & ip_netif->netmask ))
152	\|\| ( inet_pton( AF_INET, settings[ 4 ].value, ( uint8_t * ) & ip_netif->gateway ) == EINVAL )	152	\|\| ( inet_pton( AF_INET, settings[ 4 ].value, ( uint8_t * ) & ip_netif->gateway ) == EINVAL )
153	\|\| ( inet_pton( AF_INET, settings[ 5 ].value, ( uint8_t * ) & ip_netif->broadcast ) == EINVAL )	153	\|\| ( inet_pton( AF_INET, settings[ 5 ].value, ( uint8_t * ) & ip_netif->broadcast ) == EINVAL )
154	\|\| ( inet_pton( AF_INET, settings[ 6 ].value, ( uint8_t * ) & ip_netif->dns1 ) == EINVAL )	154	\|\| ( inet_pton( AF_INET, settings[ 6 ].value, ( uint8_t * ) & ip_netif->dns1 ) == EINVAL )
155	\|\| ( inet_pton( AF_INET, settings[ 7 ].value, ( uint8_t * ) & ip_netif->dns2 ) == EINVAL )){	155	\|\| ( inet_pton( AF_INET, settings[ 7 ].value, ( uint8_t * ) & ip_netif->dns2 ) == EINVAL )){
156	free( settings );	156	free( settings );
157	free( data );	157	free( data );
158	free( ip_netif );	158	free( ip_netif );
159	return EINVAL;	159	return EINVAL;
160	}	160	}
161	}else{	161	}else{
162	// TODO ipv6	162	// TODO ipv6
163	free( settings );	163	free( settings );
164	free( data );	164	free( data );
165	free( ip_netif );	165	free( ip_netif );
166	return ENOTSUP;	166	return ENOTSUP;
167	}	167	}
168	if( settings[ 8 ].value ){	168	if( settings[ 8 ].value ){
169	ip_netif->arp = get_running_module( & ip_globals.modules, settings[ 8 ].value );	169	ip_netif->arp = get_running_module( & ip_globals.modules, settings[ 8 ].value );
170	if( ! ip_netif->arp ){	170	if( ! ip_netif->arp ){
171	printf( "\nFailed to start the arp %s", settings[ 8 ].value );	171	printf( "\nFailed to start the arp %s", settings[ 8 ].value );
172	free( settings );	172	free( settings );
173	free( data );	173	free( data );
174	free( ip_netif );	174	free( ip_netif );
175	return EINVAL;	175	return EINVAL;
176	}	176	}
177	}else{	177	}else{
178	ip_netif->arp = NULL;	178	ip_netif->arp = NULL;
179	}	179	}
180	free( settings );	180	free( settings );
181	free( data );	181	free( data );
182	}	182	}
183	// TODO mapping	183	// TODO mapping
184	ip_netif->phone = bind_service( service, ip_netif->device_id, SERVICE_IP, 0, ip_driver_receiver );	184	ip_netif->phone = bind_service( service, ip_netif->device_id, SERVICE_IP, 0, ip_driver_receiver );
185	if( ip_netif->phone < 0 ){	185	if( ip_netif->phone < 0 ){
186	printf( "\nFailed to contact the nil service %d", service );	186	printf( "\nFailed to contact the nil service %d", service );
187	free( ip_netif );	187	free( ip_netif );
188	return ip_netif->phone;	188	return ip_netif->phone;
189	}	189	}
190	if( ip_netif->arp ){	190	if( ip_netif->arp ){
191	message = async_send_3( ip_netif->arp->phone, NET_ARP_DEVICE, ip_netif->device_id, SERVICE_IP, service, & answer );	191	message = async_send_3( ip_netif->arp->phone, NET_ARP_DEVICE, ip_netif->device_id, SERVICE_IP, service, & answer );
192	configuration[ 0 ].value = ( char * ) & ip_netif->address;	192	configuration[ 0 ].value = ( char * ) & ip_netif->address;
193	configuration[ 0 ].length = CONVERT_SIZE( in_addr_t, char, 1 );	193	configuration[ 0 ].length = CONVERT_SIZE( in_addr_t, char, 1 );
194	if( ERROR_OCCURRED( measured_strings_send( ip_netif->arp->phone, & configuration[ 0 ], 1 ))){	194	if( ERROR_OCCURRED( measured_strings_send( ip_netif->arp->phone, & configuration[ 0 ], 1 ))){
195	free( ip_netif );	195	free( ip_netif );
196	return ERROR_CODE;	196	return ERROR_CODE;
197	}	197	}
198	async_wait_for( message, & result );	198	async_wait_for( message, & result );
199	if( ERROR_OCCURRED( result )){	199	if( ERROR_OCCURRED( result )){
200	free( ip_netif );	200	free( ip_netif );
201	return ERROR_CODE;	201	return ERROR_CODE;
202	}	202	}
203	}	203	}
204	index = ip_netifs_add( & ip_globals.netifs, ip_netif->device_id, ip_netif );	204	index = ip_netifs_add( & ip_globals.netifs, ip_netif->device_id, ip_netif );
205	if( index < 0 ){	205	if( index < 0 ){
206	free( ip_netif );	206	free( ip_netif );
207	return index;	207	return index;
208	}	208	}
209	if( ip_netif->arp ) ++ ip_netif->arp->usage;	209	if( ip_netif->arp ) ++ ip_netif->arp->usage;
210	// print the settings	210	// print the settings
211	printf( "\nNew device registered:\n\tid\t= %d\n\tphone\t= %d\n\tIPV\t= %d", ip_netif->device_id, ip_netif->phone, ip_netif->ipv );	211	printf( "\nNew device registered:\n\tid\t= %d\n\tphone\t= %d\n\tIPV\t= %d", ip_netif->device_id, ip_netif->phone, ip_netif->ipv );
212	printf( "\n\tconfiguration\t= %s", ip_netif->dhcp ? "dhcp" : "static" );	212	printf( "\n\tconfiguration\t= %s", ip_netif->dhcp ? "dhcp" : "static" );
213	// TODO ipv6 addresses	213	// TODO ipv6 addresses
214	data = malloc( INET_ADDRSTRLEN );	214	data = malloc( INET_ADDRSTRLEN );
215	if( data ){	215	if( data ){
216	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->address, data, INET_ADDRSTRLEN );	216	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->address, data, INET_ADDRSTRLEN );
217	printf( "\n\taddress\t= %s", data );	217	printf( "\n\taddress\t= %s", data );
218	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->netmask, data, INET_ADDRSTRLEN );	218	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->netmask, data, INET_ADDRSTRLEN );
219	printf( "\n\tnetmask\t= %s", data );	219	printf( "\n\tnetmask\t= %s", data );
220	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->gateway, data, INET_ADDRSTRLEN );	220	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->gateway, data, INET_ADDRSTRLEN );
221	printf( "\n\tgateway\t= %s", data );	221	printf( "\n\tgateway\t= %s", data );
222	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->broadcast, data, INET_ADDRSTRLEN );	222	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->broadcast, data, INET_ADDRSTRLEN );
223	printf( "\n\tbroadcast\t= %s", data );	223	printf( "\n\tbroadcast\t= %s", data );
224	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->dns1, data, INET_ADDRSTRLEN );	224	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->dns1, data, INET_ADDRSTRLEN );
225	printf( "\n\tdns1\t= %s", data );	225	printf( "\n\tdns1\t= %s", data );
226	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->dns2, data, INET_ADDRSTRLEN );	226	inet_ntop( AF_INET, ( uint8_t * ) & ip_netif->dns2, data, INET_ADDRSTRLEN );
227	printf( "\n\tdns2\t= %s", data );	227	printf( "\n\tdns2\t= %s", data );
228	free( data );	228	free( data );
229	}	229	}
230	return EOK;	230	return EOK;
231	}	231	}
232		232
233	void ip_driver_receiver( ipc_callid_t iid, ipc_call_t * icall ){	233	void ip_driver_receiver( ipc_callid_t iid, ipc_call_t * icall ){
234	ERROR_DECLARE;	234	ERROR_DECLARE;
235		235
236	ipc_callid_t callid;	236	ipc_callid_t callid;
237	ipc_call_t call;	237	ipc_call_t call;
238	// ipc_call_t answer;	238	// ipc_call_t answer;
239	// int count;	239	// int count;
240	int result;	240	int result;
241	packet_t packet;	241	packet_t packet;
242		242
243	/*	243	/*
244	* Accept the connection	244	* Accept the connection
245	* - Answer the first IPC_M_CONNECT_ME_TO call.	245	* - Answer the first IPC_M_CONNECT_ME_TO call.
246	*/	246	*/
247	ipc_answer_0( iid, EOK );	247	ipc_answer_0( iid, EOK );
248		248
249	while( true ){	249	while( true ){
250	/* // refresh data	250	/* // refresh data
251	count = 0;	251	count = 0;
252	IPC_SET_RETVAL( answer, 0 );	252	IPC_SET_RETVAL( answer, 0 );
253	// just to be precize	253	// just to be precize
254	IPC_SET_RETVAL( answer, 0 );	254	IPC_SET_RETVAL( answer, 0 );
255	IPC_SET_ARG1( answer, 0 );	255	IPC_SET_ARG1( answer, 0 );
256	IPC_SET_ARG2( answer, 0 );	256	IPC_SET_ARG2( answer, 0 );
257	IPC_SET_ARG3( answer, 0 );	257	IPC_SET_ARG3( answer, 0 );
258	IPC_SET_ARG4( answer, 0 );	258	IPC_SET_ARG4( answer, 0 );
259	IPC_SET_ARG5( answer, 0 );	259	IPC_SET_ARG5( answer, 0 );
260	*/	260	*/
261	callid = async_get_call( & call );	261	callid = async_get_call( & call );
262	switch( IPC_GET_METHOD( call )){	262	switch( IPC_GET_METHOD( call )){
263	case NET_IL_DEVICE_STATE:	263	case NET_IL_DEVICE_STATE:
264	case NET_NIL_DEVICE_STATE:	264	case NET_NIL_DEVICE_STATE:
265	result = ip_state_message( IPC_GET_DEVICE( & call ), IPC_GET_STATE( & call ));	265	result = ip_state_message( IPC_GET_DEVICE( & call ), IPC_GET_STATE( & call ));
266	ipc_answer_0( callid, result );	266	ipc_answer_0( callid, result );
267	// TODO packer received	267	// TODO packer received
268	case NET_IL_RECEIVED:	268	case NET_IL_RECEIVED:
269	case NET_NIL_RECEIVED:	269	case NET_NIL_RECEIVED:
270	if( ! ERROR_OCCURRED( result = packet_translate( ip_globals.networking_phone, & packet, IPC_GET_PACKET( & call )))){	270	if( ! ERROR_OCCURRED( result = packet_translate( ip_globals.networking_phone, & packet, IPC_GET_PACKET( & call )))){
271	//result = ip_receive_message( IPC_GET_DEVICE( call ), packet );	271	//result = ip_receive_message( IPC_GET_DEVICE( call ), packet );
272	}	272	}
273	ipc_answer_0( callid, result );	273	ipc_answer_0( callid, result );
274	}	274	}
275	}	275	}
276	}	276	}
277		277
278	int ip_state_message( device_id_t device_id, device_state_t state ){	278	int ip_state_message( device_id_t device_id, device_state_t state ){
-		279	ERROR_DECLARE;
-		280
-		281	ip_netif_ref netif;
-		282
-		283	aid_t message;
-		284	ipc_call_t answer;
-		285	measured_string_t address;
-		286	measured_string_ref translation;
-		287	char * data;
-		288	ipcarg_t result;
-		289
-		290	netif = ip_netifs_find( & ip_globals.netifs, device_id );
-		291	if( ! netif ) return ENOENT;
279	// TODO state	292	// TODO state
280	printf( "\nip - device %d changed state to %d\n", device_id, state );	293	printf( "\nip - device %d changed state to %d\n", device_id, state );
-		294	if( netif->arp ){
-		295	message = async_send_2( netif->arp->phone, NET_ARP_TRANSLATE, netif->device_id, SERVICE_IP, & answer );
-		296	address.value = ( char * ) & netif->gateway;
-		297	address.length = CONVERT_SIZE( in_addr_t, char, 1 );
-		298	if( ERROR_OCCURRED( measured_strings_send( netif->arp->phone, & address, 1 ))
-		299	\|\| ERROR_OCCURRED( measured_strings_return( netif->arp->phone, & translation, & data, 1 ))){
-		300	async_wait_for( message, & result );
-		301	return result;
-		302	}
-		303	async_wait_for( message, & result );
-		304	if( ! ERROR_OCCURRED( result )){
-		305	printf( "\n\tgateway translated to\t= %X:%X:%X:%X:%X:%X", data[ 0 ], data[ 1 ], data[ 2 ], data[ 3 ], data[ 4 ], data[ 5 ] );
-		306	}
-		307	free( translation );
-		308	free( data );
-		309	return result;
-		310	}
281	return EOK;	311	return EOK;
282	}	312	}
283		313
284	int ip_register_message( int protocol, int phone ){	314	int ip_register_message( int protocol, int phone ){
285	ip_proto_ref proto;	315	ip_proto_ref proto;
286	int index;	316	int index;
287		317
288	proto = ( ip_proto_ref ) malloc( sizeof( ip_protos_t ));	318	proto = ( ip_proto_ref ) malloc( sizeof( ip_protos_t ));
289	if( ! proto ) return ENOMEM;	319	if( ! proto ) return ENOMEM;
290	proto->protocol = protocol;	320	proto->protocol = protocol;
291	proto->phone = phone;	321	proto->phone = phone;
292	index = ip_protos_add( & ip_globals.protos, proto->protocol, proto );	322	index = ip_protos_add( & ip_globals.protos, proto->protocol, proto );
293	if( index < 0 ){	323	if( index < 0 ){
294	free( proto );	324	free( proto );
295	return index;	325	return index;
296	}	326	}
297	printf( "\nNew protocol registered:\n\tprotocol\t= %d\n\tphone\t= %d", proto->protocol, proto->phone );	327	printf( "\nNew protocol registered:\n\tprotocol\t= %d\n\tphone\t= %d", proto->protocol, proto->phone );
298	return EOK;	328	return EOK;
299	}	329	}
300		330
301	int ip_send_message( device_id_t device_id, packet_t packet ){	331	int ip_send_message( device_id_t device_id, packet_t packet ){
302	// TODO send packet	332	// TODO send packet
303	printf( "Packet to send via %d: %s", device_id, packet_get_data( packet ));	333	printf( "Packet to send via %d: %s", device_id, packet_get_data( packet ));
304	pq_release( ip_globals.networking_phone, packet_get_id( packet ));	334	pq_release( ip_globals.networking_phone, packet_get_id( packet ));
305	return EOK;	335	return EOK;
306	}	336	}
307		337
308	int ip_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){	338	int ip_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
309	ERROR_DECLARE;	339	ERROR_DECLARE;
310		340
311	packet_t packet;	341	packet_t packet;
312		342
313	* answer_count = 0;	343	* answer_count = 0;
314	switch( IPC_GET_METHOD( * call )){	344	switch( IPC_GET_METHOD( * call )){
315	case IPC_M_PHONE_HUNGUP:	345	case IPC_M_PHONE_HUNGUP:
316	return EOK;	346	return EOK;
317	case NET_IP_ECHO:	347	case NET_IP_ECHO:
318	* answer_count = 5;	348	* answer_count = 5;
319	return ip_echo_message( IPC_GET_ARG1( * call ), IPC_GET_ARG2( * call ), IPC_GET_ARG3( * call ), IPC_GET_ARG4( * call ), IPC_GET_ARG5( * call ), & IPC_GET_ARG1( * answer ), & IPC_GET_ARG2( * answer ), & IPC_GET_ARG3( * answer ), & IPC_GET_ARG4( * answer ), & IPC_GET_ARG5( * answer ) );	349	return ip_echo_message( IPC_GET_ARG1( * call ), IPC_GET_ARG2( * call ), IPC_GET_ARG3( * call ), IPC_GET_ARG4( * call ), IPC_GET_ARG5( * call ), & IPC_GET_ARG1( * answer ), & IPC_GET_ARG2( * answer ), & IPC_GET_ARG3( * answer ), & IPC_GET_ARG4( * answer ), & IPC_GET_ARG5( * answer ) );
320	case NET_IL_DEVICE:	350	case NET_IL_DEVICE:
321	return ip_device_message( IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ));	351	return ip_device_message( IPC_GET_DEVICE( call ), IPC_GET_SERVICE( call ));
322	case IPC_M_CONNECT_TO_ME:	352	case IPC_M_CONNECT_TO_ME:
323	return ip_register_message( IPC_GET_PROTO( call ), IPC_GET_PHONE( call ));	353	return ip_register_message( IPC_GET_PROTO( call ), IPC_GET_PHONE( call ));
324	case NET_IP_SEND:	354	case NET_IP_SEND:
325	ERROR_PROPAGATE( packet_translate( ip_globals.networking_phone, & packet, IPC_GET_PACKET( call )));	355	ERROR_PROPAGATE( packet_translate( ip_globals.networking_phone, & packet, IPC_GET_PACKET( call )));
326	return ip_send_message( IPC_GET_DEVICE( call ), packet );	356	return ip_send_message( IPC_GET_DEVICE( call ), packet );
327	}	357	}
328	return ENOTSUP;	358	return ENOTSUP;
329	}	359	}
330		360
331	/** @}	361	/** @}
332	*/	362	*/
333		363

Subversion Repositories HelenOS

(root)/branches/network/uspace/srv/net/il/ip/ip.c – Rev 4192 → 4243