WebSVN – HelenOS – Diff – /branches/network/uspace/srv/net/net/net.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 net
 *  @{
 */
 
/** @file
 */
 
#include <async.h>
#include <ctype.h>
#include <ddi.h>
#include <errno.h>
#include <malloc.h>
#include <stdio.h>
 
#include <ipc/ipc.h>
#include <ipc/services.h>
 
#include "../err.h"
#include "../messages.h"
#include "../modules.h"
//#include "../self_test.h"
 
#include "../structures/char_map.h"
#include "../structures/generic_char_map.h"
#include "../structures/measured_strings.h"
#include "../structures/module_map.h"
#include "../structures/packet/packet.h"
#include "../structures/packet/packet_server.h"
 
#include "../il/ip/ip_messages.h"
#include "../netif/device.h"
 
#if IP_BUNDLE
 
    #include "../ip/ip_module.h"
 
#endif
 
#if TCP_BUNDLE
 
    #include "../tcp/tcp_module.h"
 
#endif
 
#define NAME    "Networking"
 
#define LO_NAME             "lo"
#define LO_FILENAME         "/srv/lo"
#define DP8390_NAME         "dp8390"
#define DP8390_FILENAME     "/srv/dp8390"
#define ETHERNET_NAME       "ethernet"
#define ETHERNET_FILENAME   "/srv/eth"
#define IP_NAME             "ip"
#define IP_FILENAME         "/srv/ip"
 
#define CONF_NAME           "NAME"
#define CONF_NETIF          "NETIF"
#define CONF_NIL            "NIL"
#define CONF_IL             "IL"
#define CONF_IRQ            "IRQ"
#define CONF_IO             "IO"
#define CONF_MTU            "MTU"
 
#define IPC_GET_DEVICE( call )  ( device_id_t ) IPC_GET_ARG1( * call )
#define IPC_GET_COUNT( call )   ( int ) IPC_GET_ARG2( * call )
 
typedef struct netif        netif_t;
typedef netif_t *       netif_ref;
 
typedef struct networking_globals   networking_globals_t;
 
DEVICE_MAP_DECLARE( netifs, netif_t )
 
GENERIC_CHAR_MAP_DECLARE( measured_strings, measured_string_t )
 
/** A present network interface device.
 */
struct netif{
    /** A system-unique network interface identifier.
     */
    device_id_t     id;
    /** A serving network interface driver module index.
     */
    module_ref      driver;
    /** A serving link layer module index.
     */
    module_ref      nil;
    /** A serving internet layer module index.
     */
    module_ref      il;
    /** A system-unique network interface name.
     */
    char *          name;
    /** Configuration.
     */
    measured_strings_t  configuration;
};
 
/** A networking module global variables.
 */
struct networking_globals{
    /** Present network interfaces.
     */
    netifs_t        netifs;
    /** Network interface structure indices by names.
     */
    char_map_t      netif_names;
    /** Available modules.
     */
    modules_t       modules;
    /** Global configuration.
     */
    measured_strings_t  configuration;
};
 
void    networking_print_name( void );
measured_string_ref configuration_find( measured_strings_ref configuration, const char * name );
int networking_start_module( async_client_conn_t client_connection );
int     networking_initialize( void );
int networking_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count );
int net_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count );
//int       parse_line( measured_strings_ref configuration, char * line );
int     add_configuration( measured_strings_ref configuration, const char * name, const char * value );
int     read_configuration( void );
int     read_netif_configuration( char * name, netif_ref netif );
int     start_device( netif_ref netif );
int     startup( void );
device_id_t generate_new_device_id( void );
 
static networking_globals_t networking_globals;
 
DEVICE_MAP_IMPLEMENT( netifs, netif_t )
 
GENERIC_CHAR_MAP_IMPLEMENT( measured_strings, measured_string_t )
 
void networking_print_name( void ){
    printf( "%s", NAME );
}
 
int networking_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
#ifdef NETWORKING_module
        //TODO map to *_message
        if( IS_NET_IL_MESSAGE( call ) || IS_NET_IP_MESSAGE( call )){
            return ip_message( callid, call, answer, answer_count );
/*      }else if( IS_NET_ARP_MESSAGE( call )){
            return arp_message( callid, call, answer, answer_count );
*//*        }else if( IS_NET_RARP_MESSAGE( call )){
            return rarp_message( callid, call, answer, answer_count );
*//*        }else if( IS_NET_ICMP_MESSAGE( call )){
            return icmp_message( callid, call, answer, answer_count );
*//*        }else if( IS_NET_UDP_MESSAGE( call )){
            return udp_message( callid, call, answer, answer_count );
*/      }else if( IS_NET_TCP_MESSAGE( call )){
            return tcp_message( callid, call, answer, answer_count );
/*      }else if( IS_NET_SOCKET_MESSAGE( call )){
            return socket_message( callid, call, answer, answer_count );
*//*        }else if( IS_NET_NIL_MESSAGE( call ) || IS_NET_ETHERNET_MESSAGE( call )){
            return ethernet_message( callid, call, answer, answer_count );
*/      }else{
#endif
            if( IS_NET_PACKET_MESSAGE( call )){
                return packet_server_message( callid, call, answer, answer_count );
            }else{
                return net_message( callid, call, answer, answer_count );
            }
#ifdef NETWORKING_module
        }
#endif
}
 
int networking_start_module( async_client_conn_t client_connection ){
    ERROR_DECLARE;
 
    ipcarg_t    phonehash;
 
    async_set_client_connection( client_connection );
    ERROR_PROPAGATE( pm_init());
    if( ERROR_OCCURRED( networking_initialize())
    || ERROR_OCCURRED( REGISTER_ME( SERVICE_NETWORKING, & phonehash ))){
        pm_destroy();
        return ERROR_CODE;
    }
 
    async_manager();
 
    pm_destroy();
    return EOK;
}
 
int networking_initialize( void ){
    ERROR_DECLARE;
 
    task_id_t   task_id;
 
    netifs_initialize( & networking_globals.netifs );
    char_map_initialize( & networking_globals.netif_names );
    modules_initialize( & networking_globals.modules );
    measured_strings_initialize( & networking_globals.configuration );
 
    // run self tests
//  ERROR_PROPAGATE( self_test());
 
    ERROR_PROPAGATE( add_module( NULL, & networking_globals.modules, LO_NAME, LO_FILENAME, SERVICE_LO, 0 ));
    ERROR_PROPAGATE( add_module( NULL, & networking_globals.modules, DP8390_NAME, DP8390_FILENAME, SERVICE_DP8390, 0 ));
    ERROR_PROPAGATE( add_module( NULL, & networking_globals.modules, ETHERNET_NAME, ETHERNET_FILENAME, SERVICE_ETHERNET, 0 ));
 
#ifdef NETWORKING_modular
    task_id = spawn( "/srv/ip" );
    if( ! task_id ) return EINVAL;
    ERROR_PROPAGATE( add_module( NULL, & networking_globals.modules, IP_NAME, IP_FILENAME, SERVICE_IP, task_id ));
//  if( ! spawn( "/srv/udp" )) return EINVAL;
//  if( ! spawn( "/srv/tcp" )) return EINVAL;
//  if( ! spawn( "/srv/socket" )) return EINVAL;
//  not always necesssary
//  if( ! spawn( "/srv/arp" )) return EINVAL;
//  if( ! spawn( "/srv/rarp" )) return EINVAL;
//  if( ! spawn( "/srv/icmp" )) return EINVAL;
 
#else
#ifdef NETWORKING_module
    ipcarg_t    phonehash;
 
    ERROR_PROPAGATE( REGISTER_ME( SERVICE_IP, & phonehash ));
    ERROR_PROPAGATE( add_module( NULL, & networking_globals.modules, IP_NAME, IP_FILENAME, SERVICE_IP, task_get_id()));
    ERROR_PROPAGATE( ip_initialize());
//  ERROR_PROPAGATE( REGISTER_ME( SERVICE_ARP, & phonehash ));
//  ERROR_PROPAGATE( arp_initialize());
//  ERROR_PROPAGATE( REGISTER_ME( SERVICE_RARP, & phonehash ));
//  ERROR_PROPAGATE( rarp_initialize());
//  ERROR_PROPAGATE( REGISTER_ME( SERVICE_ICMP, & phonehash ));
//  ERROR_PROPAGATE( icmp_initialize());
//  ERROR_PROPAGATE( REGISTER_ME( SERVICE_UDP, & phonehash ));
//  ERROR_PROPAGATE( udp_initialize());
    ERROR_PROPAGATE( REGISTER_ME( SERVICE_TCP, & phonehash ));
    ERROR_PROPAGATE( tcp_initialize());
//  ERROR_PROPAGATE( REGISTER_ME( SERVICE_SOCKET, & phonehash ));
//  ERROR_PROPAGATE( socket_initialize());
//  ERROR_PROPAGATE( REGISTER_ME( SERVICE_ETHERNET, & phonehash ));
//  ERROR_PROPAGATE( ethernet_initialize());
#endif
#endif
 
    return EOK;
}
 
//TODO as ip.c
int net_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
    ERROR_DECLARE;
 
    measured_string_ref strings;
    char *          data;
    int         index;
    measured_string_ref setting;
    measured_strings_ref    configuration;
    netif_ref       netif;
 
    * answer_count = 0;
    switch( IPC_GET_METHOD( * call )){
        case IPC_M_PHONE_HUNGUP:
            return EOK;
        case NET_NET_DEVICE:
            // TODO configure, register
            printf( "\nNetworking: new netif %d", IPC_GET_DEVICE( call ));
            return EOK;
        case NET_NET_GET_DEVICE_CONF:
            ERROR_PROPAGATE( measured_strings_receive( & strings, & data, IPC_GET_COUNT( call )));
            netif = netifs_find( & networking_globals.netifs, IPC_GET_DEVICE( call ));
            if( netif ){
                configuration = & netif->configuration;
            }else{
                configuration = NULL;
            }
            for( index = 0; index < IPC_GET_COUNT( call ); ++ index ){
                setting = measured_strings_find( configuration, strings[ index ].value, 0 );
                if( ! setting ){
                    setting = measured_strings_find( & networking_globals.configuration, strings[ index ].value, 0 );
                }
                if( setting ){
                    strings[ index ].length = setting->length;
                    strings[ index ].value = setting->value;
                }else{
                    strings[ index ].length = 0;
                    strings[ index ].value = NULL;
                }
            }
            // strings should not contain received data anymore
            free( data );
            ERROR_CODE = measured_strings_reply( strings, IPC_GET_COUNT( call ));
            free( strings );
            return ERROR_CODE;
        case NET_NET_GET_CONF:
            // arg1 = count
            ERROR_PROPAGATE( measured_strings_receive( & strings, & data, IPC_GET_COUNT( call )));
            for( index = 0; index < IPC_GET_COUNT( call ); ++ index ){
                setting = measured_strings_find( & networking_globals.configuration, strings[ index ].value, 0 );
                if( setting ){
                    strings[ index ].length = setting->length;
                    strings[ index ].value = setting->value;
                }else{
                    strings[ index ].length = 0;
                    strings[ index ].value = NULL;
                }
            }
            // strings should not contain received data anymore
            free( data );
            ERROR_CODE = measured_strings_reply( strings, IPC_GET_COUNT( call ));
            free( strings );
            return ERROR_CODE;
        case NET_NET_STARTUP:
            return startup();
    }
    return ENOTSUP;
}
 
/*
int parse_line( measured_strings_ref configuration, char * line ){
    ERROR_DECLARE;
 
    measured_string_ref setting;
    char *          name;
    char *          value;
 
    // from the beginning
    name = line;
    // skip spaces
    while( isspace( * name )) ++ name;
    // remember the name start
    value = name;
    // skip the name
    while( isalnum( * value ) || ( * value == '_' )){
        // make uppercase
//      * value = toupper( * value );
        ++ value;
    }
    if( * value == '=' ){
        // terminate the name
        * value = '\0';
    }else{
        // terminate the name
        * value = '\0';
        // skip until '='
        ++ value;
        while(( * value ) && ( * value != '=' )) ++ value;
        // not found?
        if( * value != '=' ) return EINVAL;
    }
    ++ value;
    // skip spaces
    while( isspace( * value )) ++ value;
    // create a bulk measured string till the end
    setting = measured_string_create_bulk( value, -1 );
    if( ! setting ) return ENOMEM;
    // add the configuration setting
    if( ERROR_OCCURRED( measured_strings_add( configuration, name, 0, setting ))){
        free( setting );
        return ERROR_CODE;
    }
    return EOK;
}
*/
 
int add_configuration( measured_strings_ref configuration, const char * name, const char * value ){
    ERROR_DECLARE;
 
    measured_string_ref setting;
 
    setting = measured_string_create_bulk( value, 0 );
    if( ! setting ) return ENOMEM;
    // add the configuration setting
    if( ERROR_OCCURRED( measured_strings_add( configuration, name, 0, setting ))){
        free( setting );
        return ERROR_CODE;
    }
    return EOK;
}
 
device_id_t generate_new_device_id( void ){
    return device_assign_devno();
}
 
int read_configuration( void ){
    ERROR_DECLARE;
 
    // read general configuration
    ERROR_PROPAGATE( add_configuration( & networking_globals.configuration, "IPV", "4" ));
    ERROR_PROPAGATE( add_configuration( & networking_globals.configuration, "MTU", "1500" ));
    return EOK;
}
 
int read_netif_configuration( char * name, netif_ref netif ){
    ERROR_DECLARE;
 
    if( strncmp( name, "lo", 2 ) == 0 ){
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "NAME", LO_NAME ));
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "NETIF", LO_NAME ));
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "IL", IP_NAME ));
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "IP_CONFIG", "static" ));
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "IP_ADDR", "127.0.0.1" ));
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "NETMASK", "255.0.0.0" ));
    }else if( strncmp( name, "ne2k", 4 ) == 0 ){
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "NAME", "eth0" ));
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "NETIF", DP8390_NAME ));
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "NIL", ETHERNET_NAME ));
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "IL", IP_NAME ));
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "IRQ", "9" ));
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "IO", "300" ));
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "IP_CONFIG", "static" ));
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "IP_ADDR", "10.0.2.5" ));
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "NETMASK", "255.255.255.0" ));
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "BROADCAST", "10.0.2.255" ));
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "GATEWAY", "10.0.2.2" ));
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "DNS1", "10.0.2.2" ));
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "DNS2", "10.0.2.2" ));
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "ARP", "arp" ));
    }
    return EOK;
}
 
int start_device( netif_ref netif ){
    ERROR_DECLARE;
 
    measured_string_ref setting;
    services_t          internet_service;
    int                 irq;
    int                 io;
    int                 mtu;
 
    // mandatory netif
    setting = measured_strings_find( & netif->configuration, CONF_NETIF, 0 );
    netif->driver = get_running_module( & networking_globals.modules, setting->value );
    if( ! netif->driver ){
        printf( "\nFailed to start the network interface driver %s", setting->value );
        return EINVAL;
    }
    // optional network interface layer
    setting = measured_strings_find( & netif->configuration, CONF_NIL, 0 );
    if( setting ){
        netif->nil = get_running_module( & networking_globals.modules, setting->value );
        if( ! netif->nil ){
            printf( "\nFailed to start the network interface layer %s", setting->value );
            return EINVAL;
        }
    }else{
        netif->nil = NULL;
    }
    // mandatory internet layer
    setting = measured_strings_find( & netif->configuration, CONF_IL, 0 );
    netif->il = get_running_module( & networking_globals.modules, setting->value );
    if( ! netif->il ){
        printf( "\nFailed to start the internet layer %s", setting->value );
        return EINVAL;
    }
    // end of the static loopback initialization
    // startup the loopback interface
    setting = measured_strings_find( & netif->configuration, CONF_IRQ, 0 );
    irq = setting ? strtol( setting->value, NULL, 10 ) : 0;
    setting = measured_strings_find( & netif->configuration, CONF_IO, 0 );
    io = setting ? strtol( setting->value, NULL, 16 ) : 0;
    ERROR_PROPAGATE( async_req_3_0( netif->driver->phone, NET_NETIF_PROBE, netif->id, irq, io ));
    if( netif->nil ){
        setting = measured_strings_find( & netif->configuration, CONF_MTU, 0 );
        if( ! setting ){
            setting = measured_strings_find( & networking_globals.configuration, CONF_MTU, 0 );
        }
        mtu = setting ? strtol( setting->value, NULL, 10 ) : 0;
        ERROR_PROPAGATE( async_req_3_0( netif->nil->phone, NET_NIL_DEVICE, netif->id, netif->driver->service, mtu ));
        internet_service = netif->nil->service;
    }else{
        internet_service = netif->driver->service;
    }
    // TODO IL_BUNDLE
    ERROR_PROPAGATE( async_req_2_0( netif->il->phone, NET_IL_DEVICE, netif->id, internet_service ));
    ERROR_PROPAGATE( async_req_1_0( netif->driver->phone, NET_NETIF_START, netif->id ));
    return EOK;
}
 
int startup( void ){
    ERROR_DECLARE;
 
    char *      conf_files[] = { "lo", "ne2k" };
    int         count = sizeof( conf_files ) / sizeof( char * );
    int         index;
    netif_ref   netif;
    int         i;
    measured_string_ref setting;
 
    // TODO dynamic configuration
    ERROR_PROPAGATE( read_configuration());
 
    for( i = 0; i < count; ++ i ){
        netif = ( netif_ref ) malloc( sizeof( netif_t ));
        if( ! netif ) return ENOMEM;
 
        netif->id = generate_new_device_id();
        if( ! netif->id ) return EXDEV;
        ERROR_PROPAGATE( measured_strings_initialize( & netif->configuration ));
        // read configuration files
        if( ERROR_OCCURRED( read_netif_configuration( conf_files[ i ], netif ))){
            measured_strings_destroy( & netif->configuration );
            free( netif );
            return ERROR_CODE;
        }
        // mandatory name
        setting = measured_strings_find( & netif->configuration, CONF_NAME, 0 );
        if( ! setting ){
            printf( "\nThe name is missing" );
            measured_strings_destroy( & netif->configuration );
            free( netif );
            return EINVAL;
        }
        netif->name = setting->value;
        // add to the netifs map
        index = netifs_add( & networking_globals.netifs, netif->id, netif );
        if( index < 0 ){
            measured_strings_destroy( & netif->configuration );
            free( netif );
            return index;
        }
        // add to the netif names map
        if( ERROR_OCCURRED( char_map_add( & networking_globals.netif_names, netif->name, 0, index ))
        // start network interfaces and needed modules
        || ERROR_OCCURRED( start_device( netif ))){
            measured_strings_destroy( & netif->configuration );
            netifs_exclude_index( & networking_globals.netifs, index );
            return ERROR_CODE;
        }
        // increment modules' usage
        ++ netif->driver->usage;
        if( netif->nil ) ++ netif->nil->usage;
        ++ netif->il->usage;
        printf( "\nNew network interface started:\n\tname\t= %s\n\tid\t= %d\n\tdriver\t= %s\n\tnil\t= %s\n\til\t= %s", netif->name, netif->id, netif->driver->name, netif->nil ? netif->nil->name : NULL, netif->il->name );
    }
    return EOK;
}
 
/** @}
 */
 

Rev 4192	Rev 4197
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 net	29	/** @addtogroup net
30	* @{	30	* @{
31	*/	31	*/
32		32
33	/** @file	33	/** @file
34	*/	34	*/
35		35
36	#include <async.h>	36	#include <async.h>
37	#include <ctype.h>	37	#include <ctype.h>
38	#include <ddi.h>	38	#include <ddi.h>
39	#include <errno.h>	39	#include <errno.h>
40	#include <malloc.h>	40	#include <malloc.h>
41	#include <stdio.h>	41	#include <stdio.h>
42		42
43	#include <ipc/ipc.h>	43	#include <ipc/ipc.h>
44	#include <ipc/services.h>	44	#include <ipc/services.h>
45		45
46	#include "../err.h"	46	#include "../err.h"
47	#include "../messages.h"	47	#include "../messages.h"
48	#include "../modules.h"	48	#include "../modules.h"
49	//#include "../self_test.h"	49	//#include "../self_test.h"
50		50
51	#include "../structures/char_map.h"	51	#include "../structures/char_map.h"
52	#include "../structures/generic_char_map.h"	52	#include "../structures/generic_char_map.h"
53	#include "../structures/measured_strings.h"	53	#include "../structures/measured_strings.h"
54	#include "../structures/module_map.h"	54	#include "../structures/module_map.h"
55	#include "../structures/packet/packet.h"	55	#include "../structures/packet/packet.h"
56	#include "../structures/packet/packet_server.h"	56	#include "../structures/packet/packet_server.h"
57		57
58	#include "../il/ip/ip_messages.h"	58	#include "../il/ip/ip_messages.h"
59	#include "../netif/device.h"	59	#include "../netif/device.h"
60		60
61	#if IP_BUNDLE	61	#if IP_BUNDLE
62		62
63	#include "../ip/ip_module.h"	63	#include "../ip/ip_module.h"
64		64
65	#endif	65	#endif
66		66
67	#if TCP_BUNDLE	67	#if TCP_BUNDLE
68		68
69	#include "../tcp/tcp_module.h"	69	#include "../tcp/tcp_module.h"
70		70
71	#endif	71	#endif
72		72
73	#define NAME "Networking"	73	#define NAME "Networking"
74		74
75	#define LO_NAME "lo"	75	#define LO_NAME "lo"
76	#define LO_FILENAME "/srv/lo"	76	#define LO_FILENAME "/srv/lo"
77	#define DP8390_NAME "dp8390"	77	#define DP8390_NAME "dp8390"
78	#define DP8390_FILENAME "/srv/dp8390"	78	#define DP8390_FILENAME "/srv/dp8390"
79	#define ETHERNET_NAME "ethernet"	79	#define ETHERNET_NAME "ethernet"
80	#define ETHERNET_FILENAME "/srv/eth"	80	#define ETHERNET_FILENAME "/srv/eth"
81	#define IP_NAME "ip"	81	#define IP_NAME "ip"
82	#define IP_FILENAME "/srv/ip"	82	#define IP_FILENAME "/srv/ip"
83		83
84	#define CONF_NAME "NAME"	84	#define CONF_NAME "NAME"
85	#define CONF_NETIF "NETIF"	85	#define CONF_NETIF "NETIF"
86	#define CONF_NIL "NIL"	86	#define CONF_NIL "NIL"
87	#define CONF_IL "IL"	87	#define CONF_IL "IL"
88	#define CONF_IRQ "IRQ"	88	#define CONF_IRQ "IRQ"
89	#define CONF_IO "IO"	89	#define CONF_IO "IO"
90	#define CONF_MTU "MTU"	90	#define CONF_MTU "MTU"
91		91
92	#define IPC_GET_DEVICE( call ) ( device_id_t ) IPC_GET_ARG1( * call )	92	#define IPC_GET_DEVICE( call ) ( device_id_t ) IPC_GET_ARG1( * call )
93	#define IPC_GET_COUNT( call ) ( int ) IPC_GET_ARG2( * call )	93	#define IPC_GET_COUNT( call ) ( int ) IPC_GET_ARG2( * call )
94		94
95	typedef struct netif netif_t;	95	typedef struct netif netif_t;
96	typedef netif_t * netif_ref;	96	typedef netif_t * netif_ref;
97		97
98	typedef struct networking_globals networking_globals_t;	98	typedef struct networking_globals networking_globals_t;
99		99
100	DEVICE_MAP_DECLARE( netifs, netif_t )	100	DEVICE_MAP_DECLARE( netifs, netif_t )
101		101
102	GENERIC_CHAR_MAP_DECLARE( measured_strings, measured_string_t )	102	GENERIC_CHAR_MAP_DECLARE( measured_strings, measured_string_t )
103		103
104	/** A present network interface device.	104	/** A present network interface device.
105	*/	105	*/
106	struct netif{	106	struct netif{
107	/** A system-unique network interface identifier.	107	/** A system-unique network interface identifier.
108	*/	108	*/
109	device_id_t id;	109	device_id_t id;
110	/** A serving network interface driver module index.	110	/** A serving network interface driver module index.
111	*/	111	*/
112	module_ref driver;	112	module_ref driver;
113	/** A serving link layer module index.	113	/** A serving link layer module index.
114	*/	114	*/
115	module_ref nil;	115	module_ref nil;
116	/** A serving internet layer module index.	116	/** A serving internet layer module index.
117	*/	117	*/
118	module_ref il;	118	module_ref il;
119	/** A system-unique network interface name.	119	/** A system-unique network interface name.
120	*/	120	*/
121	char * name;	121	char * name;
122	/** Configuration.	122	/** Configuration.
123	*/	123	*/
124	measured_strings_t configuration;	124	measured_strings_t configuration;
125	};	125	};
126		126
127	/** A networking module global variables.	127	/** A networking module global variables.
128	*/	128	*/
129	struct networking_globals{	129	struct networking_globals{
130	/** Present network interfaces.	130	/** Present network interfaces.
131	*/	131	*/
132	netifs_t netifs;	132	netifs_t netifs;
133	/** Network interface structure indices by names.	133	/** Network interface structure indices by names.
134	*/	134	*/
135	char_map_t netif_names;	135	char_map_t netif_names;
136	/** Available modules.	136	/** Available modules.
137	*/	137	*/
138	modules_t modules;	138	modules_t modules;
139	/** Global configuration.	139	/** Global configuration.
140	*/	140	*/
141	measured_strings_t configuration;	141	measured_strings_t configuration;
142	};	142	};
143		143
144	void networking_print_name( void );	144	void networking_print_name( void );
145	measured_string_ref configuration_find( measured_strings_ref configuration, const char * name );	145	measured_string_ref configuration_find( measured_strings_ref configuration, const char * name );
146	int networking_start_module( async_client_conn_t client_connection );	146	int networking_start_module( async_client_conn_t client_connection );
147	int networking_initialize( void );	147	int networking_initialize( void );
148	int networking_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count );	148	int networking_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count );
149	int net_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count );	149	int net_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count );
150	//int parse_line( measured_strings_ref configuration, char * line );	150	//int parse_line( measured_strings_ref configuration, char * line );
151	int add_configuration( measured_strings_ref configuration, const char * name, const char * value );	151	int add_configuration( measured_strings_ref configuration, const char * name, const char * value );
152	int read_configuration( void );	152	int read_configuration( void );
153	int read_netif_configuration( char * name, netif_ref netif );	153	int read_netif_configuration( char * name, netif_ref netif );
154	int start_device( netif_ref netif );	154	int start_device( netif_ref netif );
155	int startup( void );	155	int startup( void );
156	device_id_t generate_new_device_id( void );	156	device_id_t generate_new_device_id( void );
157		157
158	static networking_globals_t networking_globals;	158	static networking_globals_t networking_globals;
159		159
160	DEVICE_MAP_IMPLEMENT( netifs, netif_t )	160	DEVICE_MAP_IMPLEMENT( netifs, netif_t )
161		161
162	GENERIC_CHAR_MAP_IMPLEMENT( measured_strings, measured_string_t )	162	GENERIC_CHAR_MAP_IMPLEMENT( measured_strings, measured_string_t )
163		163
164	void networking_print_name( void ){	164	void networking_print_name( void ){
165	printf( NAME );	165	printf( "%s", NAME );
166	}	166	}
167		167
168	int networking_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){	168	int networking_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
169	#ifdef NETWORKING_module	169	#ifdef NETWORKING_module
170	//TODO map to *_message	170	//TODO map to *_message
171	if( IS_NET_IL_MESSAGE( call ) \|\| IS_NET_IP_MESSAGE( call )){	171	if( IS_NET_IL_MESSAGE( call ) \|\| IS_NET_IP_MESSAGE( call )){
172	return ip_message( callid, call, answer, answer_count );	172	return ip_message( callid, call, answer, answer_count );
173	/* }else if( IS_NET_ARP_MESSAGE( call )){	173	/* }else if( IS_NET_ARP_MESSAGE( call )){
174	return arp_message( callid, call, answer, answer_count );	174	return arp_message( callid, call, answer, answer_count );
175	// }else if( IS_NET_RARP_MESSAGE( call )){	175	// }else if( IS_NET_RARP_MESSAGE( call )){
176	return rarp_message( callid, call, answer, answer_count );	176	return rarp_message( callid, call, answer, answer_count );
177	// }else if( IS_NET_ICMP_MESSAGE( call )){	177	// }else if( IS_NET_ICMP_MESSAGE( call )){
178	return icmp_message( callid, call, answer, answer_count );	178	return icmp_message( callid, call, answer, answer_count );
179	// }else if( IS_NET_UDP_MESSAGE( call )){	179	// }else if( IS_NET_UDP_MESSAGE( call )){
180	return udp_message( callid, call, answer, answer_count );	180	return udp_message( callid, call, answer, answer_count );
181	*/ }else if( IS_NET_TCP_MESSAGE( call )){	181	*/ }else if( IS_NET_TCP_MESSAGE( call )){
182	return tcp_message( callid, call, answer, answer_count );	182	return tcp_message( callid, call, answer, answer_count );
183	/* }else if( IS_NET_SOCKET_MESSAGE( call )){	183	/* }else if( IS_NET_SOCKET_MESSAGE( call )){
184	return socket_message( callid, call, answer, answer_count );	184	return socket_message( callid, call, answer, answer_count );
185	// }else if( IS_NET_NIL_MESSAGE( call ) \|\| IS_NET_ETHERNET_MESSAGE( call )){	185	// }else if( IS_NET_NIL_MESSAGE( call ) \|\| IS_NET_ETHERNET_MESSAGE( call )){
186	return ethernet_message( callid, call, answer, answer_count );	186	return ethernet_message( callid, call, answer, answer_count );
187	*/ }else{	187	*/ }else{
188	#endif	188	#endif
189	if( IS_NET_PACKET_MESSAGE( call )){	189	if( IS_NET_PACKET_MESSAGE( call )){
190	return packet_server_message( callid, call, answer, answer_count );	190	return packet_server_message( callid, call, answer, answer_count );
191	}else{	191	}else{
192	return net_message( callid, call, answer, answer_count );	192	return net_message( callid, call, answer, answer_count );
193	}	193	}
194	#ifdef NETWORKING_module	194	#ifdef NETWORKING_module
195	}	195	}
196	#endif	196	#endif
197	}	197	}
198		198
199	int networking_start_module( async_client_conn_t client_connection ){	199	int networking_start_module( async_client_conn_t client_connection ){
200	ERROR_DECLARE;	200	ERROR_DECLARE;
201		201
202	ipcarg_t phonehash;	202	ipcarg_t phonehash;
203		203
204	async_set_client_connection( client_connection );	204	async_set_client_connection( client_connection );
205	ERROR_PROPAGATE( pm_init());	205	ERROR_PROPAGATE( pm_init());
206	if( ERROR_OCCURRED( networking_initialize())	206	if( ERROR_OCCURRED( networking_initialize())
207	\|\| ERROR_OCCURRED( REGISTER_ME( SERVICE_NETWORKING, & phonehash ))){	207	\|\| ERROR_OCCURRED( REGISTER_ME( SERVICE_NETWORKING, & phonehash ))){
208	pm_destroy();	208	pm_destroy();
209	return ERROR_CODE;	209	return ERROR_CODE;
210	}	210	}
211		211
212	async_manager();	212	async_manager();
213		213
214	pm_destroy();	214	pm_destroy();
215	return EOK;	215	return EOK;
216	}	216	}
217		217
218	int networking_initialize( void ){	218	int networking_initialize( void ){
219	ERROR_DECLARE;	219	ERROR_DECLARE;
220		220
221	task_id_t task_id;	221	task_id_t task_id;
222		222
223	netifs_initialize( & networking_globals.netifs );	223	netifs_initialize( & networking_globals.netifs );
224	char_map_initialize( & networking_globals.netif_names );	224	char_map_initialize( & networking_globals.netif_names );
225	modules_initialize( & networking_globals.modules );	225	modules_initialize( & networking_globals.modules );
226	measured_strings_initialize( & networking_globals.configuration );	226	measured_strings_initialize( & networking_globals.configuration );
227		227
228	// run self tests	228	// run self tests
229	// ERROR_PROPAGATE( self_test());	229	// ERROR_PROPAGATE( self_test());
230		230
231	ERROR_PROPAGATE( add_module( NULL, & networking_globals.modules, LO_NAME, LO_FILENAME, SERVICE_LO, 0 ));	231	ERROR_PROPAGATE( add_module( NULL, & networking_globals.modules, LO_NAME, LO_FILENAME, SERVICE_LO, 0 ));
232	ERROR_PROPAGATE( add_module( NULL, & networking_globals.modules, DP8390_NAME, DP8390_FILENAME, SERVICE_DP8390, 0 ));	232	ERROR_PROPAGATE( add_module( NULL, & networking_globals.modules, DP8390_NAME, DP8390_FILENAME, SERVICE_DP8390, 0 ));
233	ERROR_PROPAGATE( add_module( NULL, & networking_globals.modules, ETHERNET_NAME, ETHERNET_FILENAME, SERVICE_ETHERNET, 0 ));	233	ERROR_PROPAGATE( add_module( NULL, & networking_globals.modules, ETHERNET_NAME, ETHERNET_FILENAME, SERVICE_ETHERNET, 0 ));
234		234
235	#ifdef NETWORKING_modular	235	#ifdef NETWORKING_modular
236	task_id = spawn( "/srv/ip" );	236	task_id = spawn( "/srv/ip" );
237	if( ! task_id ) return EINVAL;	237	if( ! task_id ) return EINVAL;
238	ERROR_PROPAGATE( add_module( NULL, & networking_globals.modules, IP_NAME, IP_FILENAME, SERVICE_IP, task_id ));	238	ERROR_PROPAGATE( add_module( NULL, & networking_globals.modules, IP_NAME, IP_FILENAME, SERVICE_IP, task_id ));
239	// if( ! spawn( "/srv/udp" )) return EINVAL;	239	// if( ! spawn( "/srv/udp" )) return EINVAL;
240	// if( ! spawn( "/srv/tcp" )) return EINVAL;	240	// if( ! spawn( "/srv/tcp" )) return EINVAL;
241	// if( ! spawn( "/srv/socket" )) return EINVAL;	241	// if( ! spawn( "/srv/socket" )) return EINVAL;
242	// not always necesssary	242	// not always necesssary
243	// if( ! spawn( "/srv/arp" )) return EINVAL;	243	// if( ! spawn( "/srv/arp" )) return EINVAL;
244	// if( ! spawn( "/srv/rarp" )) return EINVAL;	244	// if( ! spawn( "/srv/rarp" )) return EINVAL;
245	// if( ! spawn( "/srv/icmp" )) return EINVAL;	245	// if( ! spawn( "/srv/icmp" )) return EINVAL;
246		246
247	#else	247	#else
248	#ifdef NETWORKING_module	248	#ifdef NETWORKING_module
249	ipcarg_t phonehash;	249	ipcarg_t phonehash;
250		250
251	ERROR_PROPAGATE( REGISTER_ME( SERVICE_IP, & phonehash ));	251	ERROR_PROPAGATE( REGISTER_ME( SERVICE_IP, & phonehash ));
252	ERROR_PROPAGATE( add_module( NULL, & networking_globals.modules, IP_NAME, IP_FILENAME, SERVICE_IP, task_get_id()));	252	ERROR_PROPAGATE( add_module( NULL, & networking_globals.modules, IP_NAME, IP_FILENAME, SERVICE_IP, task_get_id()));
253	ERROR_PROPAGATE( ip_initialize());	253	ERROR_PROPAGATE( ip_initialize());
254	// ERROR_PROPAGATE( REGISTER_ME( SERVICE_ARP, & phonehash ));	254	// ERROR_PROPAGATE( REGISTER_ME( SERVICE_ARP, & phonehash ));
255	// ERROR_PROPAGATE( arp_initialize());	255	// ERROR_PROPAGATE( arp_initialize());
256	// ERROR_PROPAGATE( REGISTER_ME( SERVICE_RARP, & phonehash ));	256	// ERROR_PROPAGATE( REGISTER_ME( SERVICE_RARP, & phonehash ));
257	// ERROR_PROPAGATE( rarp_initialize());	257	// ERROR_PROPAGATE( rarp_initialize());
258	// ERROR_PROPAGATE( REGISTER_ME( SERVICE_ICMP, & phonehash ));	258	// ERROR_PROPAGATE( REGISTER_ME( SERVICE_ICMP, & phonehash ));
259	// ERROR_PROPAGATE( icmp_initialize());	259	// ERROR_PROPAGATE( icmp_initialize());
260	// ERROR_PROPAGATE( REGISTER_ME( SERVICE_UDP, & phonehash ));	260	// ERROR_PROPAGATE( REGISTER_ME( SERVICE_UDP, & phonehash ));
261	// ERROR_PROPAGATE( udp_initialize());	261	// ERROR_PROPAGATE( udp_initialize());
262	ERROR_PROPAGATE( REGISTER_ME( SERVICE_TCP, & phonehash ));	262	ERROR_PROPAGATE( REGISTER_ME( SERVICE_TCP, & phonehash ));
263	ERROR_PROPAGATE( tcp_initialize());	263	ERROR_PROPAGATE( tcp_initialize());
264	// ERROR_PROPAGATE( REGISTER_ME( SERVICE_SOCKET, & phonehash ));	264	// ERROR_PROPAGATE( REGISTER_ME( SERVICE_SOCKET, & phonehash ));
265	// ERROR_PROPAGATE( socket_initialize());	265	// ERROR_PROPAGATE( socket_initialize());
266	// ERROR_PROPAGATE( REGISTER_ME( SERVICE_ETHERNET, & phonehash ));	266	// ERROR_PROPAGATE( REGISTER_ME( SERVICE_ETHERNET, & phonehash ));
267	// ERROR_PROPAGATE( ethernet_initialize());	267	// ERROR_PROPAGATE( ethernet_initialize());
268	#endif	268	#endif
269	#endif	269	#endif
270		270
271	return EOK;	271	return EOK;
272	}	272	}
273		273
274	//TODO as ip.c	274	//TODO as ip.c
275	int net_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){	275	int net_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
276	ERROR_DECLARE;	276	ERROR_DECLARE;
277		277
278	measured_string_ref strings;	278	measured_string_ref strings;
279	char * data;	279	char * data;
280	int index;	280	int index;
281	measured_string_ref setting;	281	measured_string_ref setting;
282	measured_strings_ref configuration;	282	measured_strings_ref configuration;
283	netif_ref netif;	283	netif_ref netif;
284		284
285	* answer_count = 0;	285	* answer_count = 0;
286	switch( IPC_GET_METHOD( * call )){	286	switch( IPC_GET_METHOD( * call )){
287	case IPC_M_PHONE_HUNGUP:	287	case IPC_M_PHONE_HUNGUP:
288	return EOK;	288	return EOK;
289	case NET_NET_DEVICE:	289	case NET_NET_DEVICE:
290	// TODO configure, register	290	// TODO configure, register
291	printf( "\nNetworking: new netif %d", IPC_GET_DEVICE( call ));	291	printf( "\nNetworking: new netif %d", IPC_GET_DEVICE( call ));
292	return EOK;	292	return EOK;
293	case NET_NET_GET_DEVICE_CONF:	293	case NET_NET_GET_DEVICE_CONF:
294	ERROR_PROPAGATE( measured_strings_receive( & strings, & data, IPC_GET_COUNT( call )));	294	ERROR_PROPAGATE( measured_strings_receive( & strings, & data, IPC_GET_COUNT( call )));
295	netif = netifs_find( & networking_globals.netifs, IPC_GET_DEVICE( call ));	295	netif = netifs_find( & networking_globals.netifs, IPC_GET_DEVICE( call ));
296	if( netif ){	296	if( netif ){
297	configuration = & netif->configuration;	297	configuration = & netif->configuration;
298	}else{	298	}else{
299	configuration = NULL;	299	configuration = NULL;
300	}	300	}
301	for( index = 0; index < IPC_GET_COUNT( call ); ++ index ){	301	for( index = 0; index < IPC_GET_COUNT( call ); ++ index ){
302	setting = measured_strings_find( configuration, strings[ index ].value, 0 );	302	setting = measured_strings_find( configuration, strings[ index ].value, 0 );
303	if( ! setting ){	303	if( ! setting ){
304	setting = measured_strings_find( & networking_globals.configuration, strings[ index ].value, 0 );	304	setting = measured_strings_find( & networking_globals.configuration, strings[ index ].value, 0 );
305	}	305	}
306	if( setting ){	306	if( setting ){
307	strings[ index ].length = setting->length;	307	strings[ index ].length = setting->length;
308	strings[ index ].value = setting->value;	308	strings[ index ].value = setting->value;
309	}else{	309	}else{
310	strings[ index ].length = 0;	310	strings[ index ].length = 0;
311	strings[ index ].value = NULL;	311	strings[ index ].value = NULL;
312	}	312	}
313	}	313	}
314	// strings should not contain received data anymore	314	// strings should not contain received data anymore
315	free( data );	315	free( data );
316	ERROR_CODE = measured_strings_reply( strings, IPC_GET_COUNT( call ));	316	ERROR_CODE = measured_strings_reply( strings, IPC_GET_COUNT( call ));
317	free( strings );	317	free( strings );
318	return ERROR_CODE;	318	return ERROR_CODE;
319	case NET_NET_GET_CONF:	319	case NET_NET_GET_CONF:
320	// arg1 = count	320	// arg1 = count
321	ERROR_PROPAGATE( measured_strings_receive( & strings, & data, IPC_GET_COUNT( call )));	321	ERROR_PROPAGATE( measured_strings_receive( & strings, & data, IPC_GET_COUNT( call )));
322	for( index = 0; index < IPC_GET_COUNT( call ); ++ index ){	322	for( index = 0; index < IPC_GET_COUNT( call ); ++ index ){
323	setting = measured_strings_find( & networking_globals.configuration, strings[ index ].value, 0 );	323	setting = measured_strings_find( & networking_globals.configuration, strings[ index ].value, 0 );
324	if( setting ){	324	if( setting ){
325	strings[ index ].length = setting->length;	325	strings[ index ].length = setting->length;
326	strings[ index ].value = setting->value;	326	strings[ index ].value = setting->value;
327	}else{	327	}else{
328	strings[ index ].length = 0;	328	strings[ index ].length = 0;
329	strings[ index ].value = NULL;	329	strings[ index ].value = NULL;
330	}	330	}
331	}	331	}
332	// strings should not contain received data anymore	332	// strings should not contain received data anymore
333	free( data );	333	free( data );
334	ERROR_CODE = measured_strings_reply( strings, IPC_GET_COUNT( call ));	334	ERROR_CODE = measured_strings_reply( strings, IPC_GET_COUNT( call ));
335	free( strings );	335	free( strings );
336	return ERROR_CODE;	336	return ERROR_CODE;
337	case NET_NET_STARTUP:	337	case NET_NET_STARTUP:
338	return startup();	338	return startup();
339	}	339	}
340	return ENOTSUP;	340	return ENOTSUP;
341	}	341	}
342		342
343	/*	343	/*
344	int parse_line( measured_strings_ref configuration, char * line ){	344	int parse_line( measured_strings_ref configuration, char * line ){
345	ERROR_DECLARE;	345	ERROR_DECLARE;
346		346
347	measured_string_ref setting;	347	measured_string_ref setting;
348	char * name;	348	char * name;
349	char * value;	349	char * value;
350		350
351	// from the beginning	351	// from the beginning
352	name = line;	352	name = line;
353	// skip spaces	353	// skip spaces
354	while( isspace( * name )) ++ name;	354	while( isspace( * name )) ++ name;
355	// remember the name start	355	// remember the name start
356	value = name;	356	value = name;
357	// skip the name	357	// skip the name
358	while( isalnum( * value ) \|\| ( * value == '_' )){	358	while( isalnum( * value ) \|\| ( * value == '_' )){
359	// make uppercase	359	// make uppercase
360	// * value = toupper( * value );	360	// * value = toupper( * value );
361	++ value;	361	++ value;
362	}	362	}
363	if( * value == '=' ){	363	if( * value == '=' ){
364	// terminate the name	364	// terminate the name
365	* value = '\0';	365	* value = '\0';
366	}else{	366	}else{
367	// terminate the name	367	// terminate the name
368	* value = '\0';	368	* value = '\0';
369	// skip until '='	369	// skip until '='
370	++ value;	370	++ value;
371	while(( * value ) && ( * value != '=' )) ++ value;	371	while(( * value ) && ( * value != '=' )) ++ value;
372	// not found?	372	// not found?
373	if( * value != '=' ) return EINVAL;	373	if( * value != '=' ) return EINVAL;
374	}	374	}
375	++ value;	375	++ value;
376	// skip spaces	376	// skip spaces
377	while( isspace( * value )) ++ value;	377	while( isspace( * value )) ++ value;
378	// create a bulk measured string till the end	378	// create a bulk measured string till the end
379	setting = measured_string_create_bulk( value, -1 );	379	setting = measured_string_create_bulk( value, -1 );
380	if( ! setting ) return ENOMEM;	380	if( ! setting ) return ENOMEM;
381	// add the configuration setting	381	// add the configuration setting
382	if( ERROR_OCCURRED( measured_strings_add( configuration, name, 0, setting ))){	382	if( ERROR_OCCURRED( measured_strings_add( configuration, name, 0, setting ))){
383	free( setting );	383	free( setting );
384	return ERROR_CODE;	384	return ERROR_CODE;
385	}	385	}
386	return EOK;	386	return EOK;
387	}	387	}
388	*/	388	*/
389		389
390	int add_configuration( measured_strings_ref configuration, const char * name, const char * value ){	390	int add_configuration( measured_strings_ref configuration, const char * name, const char * value ){
391	ERROR_DECLARE;	391	ERROR_DECLARE;
392		392
393	measured_string_ref setting;	393	measured_string_ref setting;
394		394
395	setting = measured_string_create_bulk( value, 0 );	395	setting = measured_string_create_bulk( value, 0 );
396	if( ! setting ) return ENOMEM;	396	if( ! setting ) return ENOMEM;
397	// add the configuration setting	397	// add the configuration setting
398	if( ERROR_OCCURRED( measured_strings_add( configuration, name, 0, setting ))){	398	if( ERROR_OCCURRED( measured_strings_add( configuration, name, 0, setting ))){
399	free( setting );	399	free( setting );
400	return ERROR_CODE;	400	return ERROR_CODE;
401	}	401	}
402	return EOK;	402	return EOK;
403	}	403	}
404		404
405	device_id_t generate_new_device_id( void ){	405	device_id_t generate_new_device_id( void ){
406	return device_assign_devno();	406	return device_assign_devno();
407	}	407	}
408		408
409	int read_configuration( void ){	409	int read_configuration( void ){
410	ERROR_DECLARE;	410	ERROR_DECLARE;
411		411
412	// read general configuration	412	// read general configuration
413	ERROR_PROPAGATE( add_configuration( & networking_globals.configuration, "IPV", "4" ));	413	ERROR_PROPAGATE( add_configuration( & networking_globals.configuration, "IPV", "4" ));
414	ERROR_PROPAGATE( add_configuration( & networking_globals.configuration, "MTU", "1500" ));	414	ERROR_PROPAGATE( add_configuration( & networking_globals.configuration, "MTU", "1500" ));
415	return EOK;	415	return EOK;
416	}	416	}
417		417
418	int read_netif_configuration( char * name, netif_ref netif ){	418	int read_netif_configuration( char * name, netif_ref netif ){
419	ERROR_DECLARE;	419	ERROR_DECLARE;
420		420
421	if( strncmp( name, "lo", 2 ) == 0 ){	421	if( strncmp( name, "lo", 2 ) == 0 ){
422	ERROR_PROPAGATE( add_configuration( & netif->configuration, "NAME", LO_NAME ));	422	ERROR_PROPAGATE( add_configuration( & netif->configuration, "NAME", LO_NAME ));
423	ERROR_PROPAGATE( add_configuration( & netif->configuration, "NETIF", LO_NAME ));	423	ERROR_PROPAGATE( add_configuration( & netif->configuration, "NETIF", LO_NAME ));
424	ERROR_PROPAGATE( add_configuration( & netif->configuration, "IL", IP_NAME ));	424	ERROR_PROPAGATE( add_configuration( & netif->configuration, "IL", IP_NAME ));
425	ERROR_PROPAGATE( add_configuration( & netif->configuration, "IP_CONFIG", "static" ));	425	ERROR_PROPAGATE( add_configuration( & netif->configuration, "IP_CONFIG", "static" ));
426	ERROR_PROPAGATE( add_configuration( & netif->configuration, "IP_ADDR", "127.0.0.1" ));	426	ERROR_PROPAGATE( add_configuration( & netif->configuration, "IP_ADDR", "127.0.0.1" ));
427	ERROR_PROPAGATE( add_configuration( & netif->configuration, "NETMASK", "255.0.0.0" ));	427	ERROR_PROPAGATE( add_configuration( & netif->configuration, "NETMASK", "255.0.0.0" ));
428	}else if( strncmp( name, "ne2k", 4 ) == 0 ){	428	}else if( strncmp( name, "ne2k", 4 ) == 0 ){
429	ERROR_PROPAGATE( add_configuration( & netif->configuration, "NAME", "eth0" ));	429	ERROR_PROPAGATE( add_configuration( & netif->configuration, "NAME", "eth0" ));
430	ERROR_PROPAGATE( add_configuration( & netif->configuration, "NETIF", DP8390_NAME ));	430	ERROR_PROPAGATE( add_configuration( & netif->configuration, "NETIF", DP8390_NAME ));
431	ERROR_PROPAGATE( add_configuration( & netif->configuration, "NIL", ETHERNET_NAME ));	431	ERROR_PROPAGATE( add_configuration( & netif->configuration, "NIL", ETHERNET_NAME ));
432	ERROR_PROPAGATE( add_configuration( & netif->configuration, "IL", IP_NAME ));	432	ERROR_PROPAGATE( add_configuration( & netif->configuration, "IL", IP_NAME ));
433	ERROR_PROPAGATE( add_configuration( & netif->configuration, "IRQ", "9" ));	433	ERROR_PROPAGATE( add_configuration( & netif->configuration, "IRQ", "9" ));
434	ERROR_PROPAGATE( add_configuration( & netif->configuration, "IO", "300" ));	434	ERROR_PROPAGATE( add_configuration( & netif->configuration, "IO", "300" ));
435	ERROR_PROPAGATE( add_configuration( & netif->configuration, "IP_CONFIG", "static" ));	435	ERROR_PROPAGATE( add_configuration( & netif->configuration, "IP_CONFIG", "static" ));
436	ERROR_PROPAGATE( add_configuration( & netif->configuration, "IP_ADDR", "10.0.2.5" ));	436	ERROR_PROPAGATE( add_configuration( & netif->configuration, "IP_ADDR", "10.0.2.5" ));
437	ERROR_PROPAGATE( add_configuration( & netif->configuration, "NETMASK", "255.255.255.0" ));	437	ERROR_PROPAGATE( add_configuration( & netif->configuration, "NETMASK", "255.255.255.0" ));
438	ERROR_PROPAGATE( add_configuration( & netif->configuration, "BROADCAST", "10.0.2.255" ));	438	ERROR_PROPAGATE( add_configuration( & netif->configuration, "BROADCAST", "10.0.2.255" ));
439	ERROR_PROPAGATE( add_configuration( & netif->configuration, "GATEWAY", "10.0.2.2" ));	439	ERROR_PROPAGATE( add_configuration( & netif->configuration, "GATEWAY", "10.0.2.2" ));
440	ERROR_PROPAGATE( add_configuration( & netif->configuration, "DNS1", "10.0.2.2" ));	440	ERROR_PROPAGATE( add_configuration( & netif->configuration, "DNS1", "10.0.2.2" ));
441	ERROR_PROPAGATE( add_configuration( & netif->configuration, "DNS2", "10.0.2.2" ));	441	ERROR_PROPAGATE( add_configuration( & netif->configuration, "DNS2", "10.0.2.2" ));
442	ERROR_PROPAGATE( add_configuration( & netif->configuration, "ARP", "arp" ));	442	ERROR_PROPAGATE( add_configuration( & netif->configuration, "ARP", "arp" ));
443	}	443	}
444	return EOK;	444	return EOK;
445	}	445	}
446		446
447	int start_device( netif_ref netif ){	447	int start_device( netif_ref netif ){
448	ERROR_DECLARE;	448	ERROR_DECLARE;
449		449
450	measured_string_ref setting;	450	measured_string_ref setting;
451	services_t internet_service;	451	services_t internet_service;
452	int irq;	452	int irq;
453	int io;	453	int io;
454	int mtu;	454	int mtu;
455		455
456	// mandatory netif	456	// mandatory netif
457	setting = measured_strings_find( & netif->configuration, CONF_NETIF, 0 );	457	setting = measured_strings_find( & netif->configuration, CONF_NETIF, 0 );
458	netif->driver = get_running_module( & networking_globals.modules, setting->value );	458	netif->driver = get_running_module( & networking_globals.modules, setting->value );
459	if( ! netif->driver ){	459	if( ! netif->driver ){
460	printf( "\nFailed to start the network interface driver %s", setting->value );	460	printf( "\nFailed to start the network interface driver %s", setting->value );
461	return EINVAL;	461	return EINVAL;
462	}	462	}
463	// optional network interface layer	463	// optional network interface layer
464	setting = measured_strings_find( & netif->configuration, CONF_NIL, 0 );	464	setting = measured_strings_find( & netif->configuration, CONF_NIL, 0 );
465	if( setting ){	465	if( setting ){
466	netif->nil = get_running_module( & networking_globals.modules, setting->value );	466	netif->nil = get_running_module( & networking_globals.modules, setting->value );
467	if( ! netif->nil ){	467	if( ! netif->nil ){
468	printf( "\nFailed to start the network interface layer %s", setting->value );	468	printf( "\nFailed to start the network interface layer %s", setting->value );
469	return EINVAL;	469	return EINVAL;
470	}	470	}
471	}else{	471	}else{
472	netif->nil = NULL;	472	netif->nil = NULL;
473	}	473	}
474	// mandatory internet layer	474	// mandatory internet layer
475	setting = measured_strings_find( & netif->configuration, CONF_IL, 0 );	475	setting = measured_strings_find( & netif->configuration, CONF_IL, 0 );
476	netif->il = get_running_module( & networking_globals.modules, setting->value );	476	netif->il = get_running_module( & networking_globals.modules, setting->value );
477	if( ! netif->il ){	477	if( ! netif->il ){
478	printf( "\nFailed to start the internet layer %s", setting->value );	478	printf( "\nFailed to start the internet layer %s", setting->value );
479	return EINVAL;	479	return EINVAL;
480	}	480	}
481	// end of the static loopback initialization	481	// end of the static loopback initialization
482	// startup the loopback interface	482	// startup the loopback interface
483	setting = measured_strings_find( & netif->configuration, CONF_IRQ, 0 );	483	setting = measured_strings_find( & netif->configuration, CONF_IRQ, 0 );
484	irq = setting ? strtol( setting->value, NULL, 10 ) : 0;	484	irq = setting ? strtol( setting->value, NULL, 10 ) : 0;
485	setting = measured_strings_find( & netif->configuration, CONF_IO, 0 );	485	setting = measured_strings_find( & netif->configuration, CONF_IO, 0 );
486	io = setting ? strtol( setting->value, NULL, 16 ) : 0;	486	io = setting ? strtol( setting->value, NULL, 16 ) : 0;
487	ERROR_PROPAGATE( async_req_3_0( netif->driver->phone, NET_NETIF_PROBE, netif->id, irq, io ));	487	ERROR_PROPAGATE( async_req_3_0( netif->driver->phone, NET_NETIF_PROBE, netif->id, irq, io ));
488	if( netif->nil ){	488	if( netif->nil ){
489	setting = measured_strings_find( & netif->configuration, CONF_MTU, 0 );	489	setting = measured_strings_find( & netif->configuration, CONF_MTU, 0 );
490	if( ! setting ){	490	if( ! setting ){
491	setting = measured_strings_find( & networking_globals.configuration, CONF_MTU, 0 );	491	setting = measured_strings_find( & networking_globals.configuration, CONF_MTU, 0 );
492	}	492	}
493	mtu = setting ? strtol( setting->value, NULL, 10 ) : 0;	493	mtu = setting ? strtol( setting->value, NULL, 10 ) : 0;
494	ERROR_PROPAGATE( async_req_3_0( netif->nil->phone, NET_NIL_DEVICE, netif->id, netif->driver->service, mtu ));	494	ERROR_PROPAGATE( async_req_3_0( netif->nil->phone, NET_NIL_DEVICE, netif->id, netif->driver->service, mtu ));
495	internet_service = netif->nil->service;	495	internet_service = netif->nil->service;
496	}else{	496	}else{
497	internet_service = netif->driver->service;	497	internet_service = netif->driver->service;
498	}	498	}
499	// TODO IL_BUNDLE	499	// TODO IL_BUNDLE
500	ERROR_PROPAGATE( async_req_2_0( netif->il->phone, NET_IL_DEVICE, netif->id, internet_service ));	500	ERROR_PROPAGATE( async_req_2_0( netif->il->phone, NET_IL_DEVICE, netif->id, internet_service ));

Subversion Repositories HelenOS

(root)/branches/network/uspace/srv/net/net/net.c @ 4720 – Rev 4192 → 4197