Subversion Repositories HelenOS

/*

 * 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 "../il/il_messages.h"

#include "../include/device.h"

#include "../include/netif_interface.h"

#include "../include/nil_interface.h"

#include "../include/net_interface.h"

#include "../include/ip_interface.h"

#include "net.h"

#define NAME	"Networking"

void	module_print_name( void );

measured_string_ref	configuration_find( measured_strings_ref configuration, const char * name );

int module_start( async_client_conn_t client_connection );

//int		parse_line( measured_strings_ref configuration, char * line );

int		read_configuration( void );

int		start_device( netif_ref netif );

int		startup( void );

device_id_t	generate_new_device_id( void );

int	net_get_conf( measured_strings_ref device_conf, measured_string_ref configuration, int count, char ** data );

net_globals_t	net_globals;

DEVICE_MAP_IMPLEMENT( netifs, netif_t )

GENERIC_CHAR_MAP_IMPLEMENT( measured_strings, measured_string_t )

void module_print_name( void ){

	printf( "%s", NAME );

}

int module_start( async_client_conn_t client_connection ){

	ERROR_DECLARE;

	ipcarg_t	phonehash;

	async_set_client_connection( client_connection );

	ERROR_PROPAGATE( pm_init());

	if( ERROR_OCCURRED( net_initialize())

	|| ERROR_OCCURRED( REGISTER_ME( SERVICE_NETWORKING, & phonehash ))){

		pm_destroy();

		return ERROR_CODE;

	}

	async_manager();

	pm_destroy();

	return EOK;

}

int	net_get_device_conf_req( int net_phone, device_id_t device_id, measured_string_ref * configuration, int count, char ** data ){

	netif_ref	netif;

	if( !( configuration && ( count > 0 ))) return EINVAL;

	netif = netifs_find( & net_globals.netifs, device_id );

	if( netif ){

		return net_get_conf( & netif->configuration, * configuration, count, data );

	}else{

		return net_get_conf( NULL, * configuration, count, data );

	}

}

int	net_get_conf_req( int net_phone, measured_string_ref * configuration, int count, char ** data ){

	if( !( configuration && ( count > 0 ))) return EINVAL;

	return net_get_conf( NULL, * configuration, count, data );

}

int	net_get_conf( measured_strings_ref device_conf, measured_string_ref configuration, int count, char ** data ){

	measured_string_ref	setting;

	int					index;

	if( data ) * data = NULL;

	for( index = 0; index < count; ++ index ){

		setting = measured_strings_find( device_conf, configuration[ index ].value, 0 );

		if( ! setting ){

			setting = measured_strings_find( & net_globals.configuration, configuration[ index ].value, 0 );

		}

		if( setting ){

			configuration[ index ].length = setting->length;

			configuration[ index ].value = setting->value;

		}else{

			configuration[ index ].length = 0;

			configuration[ index ].value = NULL;

		}

	}

	return EOK;

}

void net_free_settings( measured_string_ref settings, char * data ){

}

int net_connect_module( services_t service ){

	return EOK;

}

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;

	* answer_count = 0;

	switch( IPC_GET_METHOD( * call )){

		case IPC_M_PHONE_HUNGUP:

			return EOK;

		case NET_NET_DEVICE:

			// TODO configure, register

			printf( "Networking: new netif %d\n", IPC_GET_DEVICE( call ));

			return EOK;

		case NET_NET_GET_DEVICE_CONF:

			ERROR_PROPAGATE( measured_strings_receive( & strings, & data, IPC_GET_COUNT( call )));

			net_get_device_conf_req( 0, IPC_GET_DEVICE( call ), & strings, IPC_GET_COUNT( call ), 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:

			ERROR_PROPAGATE( measured_strings_receive( & strings, & data, IPC_GET_COUNT( call )));

			net_get_conf_req( 0, & strings, IPC_GET_COUNT( call ), 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( & net_globals.configuration, "IPV", "4" ));

	ERROR_PROPAGATE( add_configuration( & net_globals.configuration, "MTU", "1500" ));

	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( & net_globals.modules, setting->value );

	if( ! netif->driver ){

		printf( "Failed to start the network interface driver %s\n", setting->value );

		return EINVAL;

	}

	// optional network interface layer

	setting = measured_strings_find( & netif->configuration, CONF_NIL, 0 );

	if( setting ){

		netif->nil = get_running_module( & net_globals.modules, setting->value );

		if( ! netif->nil ){

			printf( "Failed to start the network interface layer %s\n", 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( & net_globals.modules, setting->value );

	if( ! netif->il ){

		printf( "Failed to start the internet layer %s\n", 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( netif_probe_req( netif->driver->phone, netif->id, irq, io ));

	if( netif->nil ){

		setting = measured_strings_find( & netif->configuration, CONF_MTU, 0 );

		if( ! setting ){

			setting = measured_strings_find( & net_globals.configuration, CONF_MTU, 0 );

		}

		mtu = setting ? strtol( setting->value, NULL, 10 ) : 0;

		ERROR_PROPAGATE( nil_device_req( netif->nil->phone, netif->id, mtu, netif->driver->service ));

		internet_service = netif->nil->service;

	}else{

		internet_service = netif->driver->service;

	}

	switch( netif->il->service ){

		case SERVICE_IP:

			ERROR_PROPAGATE( ip_device_req( netif->il->phone, netif->id, internet_service ));

			break;

		default:

			return ENOENT;

	}

	ERROR_PROPAGATE( netif_start_req( netif->driver->phone, 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( "The name is missing\n" );

			measured_strings_destroy( & netif->configuration );

			free( netif );

			return EINVAL;

		}

		netif->name = setting->value;

		// add to the netifs map

		index = netifs_add( & net_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( & net_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( & net_globals.netifs, index );

			return ERROR_CODE;

		}

		// increment modules' usage

		++ netif->driver->usage;

		if( netif->nil ) ++ netif->nil->usage;

		++ netif->il->usage;

		printf( "New network interface started:\n\tname\t= %s\n\tid\t= %d\n\tdriver\t= %s\n\tnil\t= %s\n\til\t= %s\n", netif->name, netif->id, netif->driver->name, netif->nil ? netif->nil->name : NULL, netif->il->name );

	}

	return EOK;

}

/** @}

 */