Subversion Repositories HelenOS

Compare Revisions

Ignore whitespace Rev 3665 → Rev 3666

/branches/network/uspace/srv/net/networking/networking.c
34,16 → 34,27
*/
 
#include <async.h>
#include <ctype.h>
#include <errno.h>
#include <malloc.h>
#include <stdio.h>
#include <task.h>
//#include <thread.h>
#include <unistd.h>
#include <ipc/ipc.h>
#include <ipc/services.h>
//#include <sys/mman.h>
 
#include "../char_map.h"
#include "../err.h"
#include "../generic_char_map.h"
#include "../measured_strings.h"
#include "../messages.h"
#include "../modules.h"
#include "../messages.h"
//#include "../self_test.h"
 
#include "../netif/netif_device_id_type.h"
 
#ifdef NETWORKING_module
 
#include "../ip/ip.h"
51,101 → 62,126
 
#endif
 
#define IS_IN_INTERVAL( item, first_inclusive, last_exclusive ) ((( item ) >= ( first_inclusive )) && (( item ) < ( last_exclusive )))
#define LO_NAME "lo"
#define LO_FILENAME "/sbin/lo"
#define DP8390_ISA_NAME "dp8390_isa"
#define DP8390_ISA_FILENAME "/sbin/dp8380_isa"
#define ETHERNET_NAME "ethernet"
#define ETHERNET_FILENAME "/sbin/ethernet"
#define IP_NAME "ip"
#define IP_FILENAME "/sbin/ip"
 
#define IS_NET_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( call ), NET_FIRST, NET_LAST )
#define IS_NET_NETWORKING_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( call ), NET_NETWORKING_FIRST, NET_NETWORKING_LAST )
#define IS_NET_IP_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( call ), NET_IP_FIRST, NET_IP_LAST )
#define IS_NET_ARP_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( call ), NET_ARP_FIRST, NET_ARP_LAST )
#define IS_NET_RARP_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( call ), NET_RARP_FIRST, NET_RARP_LAST )
#define IS_NET_UDP_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( call ), NET_UDP_FIRST, NET_UDP_LAST )
#define IS_NET_TCP_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( call ), NET_TCP_FIRST, NET_TCP_LAST )
#define IS_NET_SOCKET_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( call ), NET_SOCKET_FIRST, NET_SOCKET_LAST )
#define IS_NET_ETHERNET_MESSAGE( call ) IS_IN_INTERVAL( IPC_GET_METHOD( call ), NET_ETHERNET_FIRST, NET_SOCKET_LAST )
typedef struct module_struct module_t;
typedef module_t * module_ref;
 
int networking_initialize( void );
static void client_connection( ipc_callid_t iid, ipc_call_t * icall );
int main( int argc, char * argv[] );
int spawn( const char * fname );
int networking_call( ipc_callid_t callid );
int networking_message( ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t *result1, ipcarg_t *result2, ipcarg_t *result3 );
typedef struct netif netif_t;
typedef netif_t * netif_ref;
 
int networking_call( ipc_callid_t callid ){
return EOK;
}
typedef struct networking_globals networking_globals_t;
 
int networking_message( ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t *result1, ipcarg_t *result2, ipcarg_t *result3 ){
switch( method ){
case IPC_M_PHONE_HUNGUP:
return EOK;
}
return ENOTSUP;
}
DEVICE_MAP_DECLARE( netifs, netif_t )
 
int spawn(const char *fname)
{
const char *argv[2];
int res;
GENERIC_CHAR_MAP_DECLARE( measured_strings, measured_string_t )
 
printf("Spawning %s\n", fname);
GENERIC_CHAR_MAP_DECLARE( modules, module_t )
 
argv[0] = fname;
argv[1] = NULL;
struct module_struct{
task_id_t task_id;
services_t service;
int phone;
int usage;
const char * name;
const char * filename;
};
 
res = task_spawn(fname, argv);
if( res != 0 ){
/* Success */
sleep(1);
}else return EINVAL;
/** A present network interface device.
*/
struct netif{
/** A system-unique network interface identifier.
*/
netif_device_id_t id;
/** A serving network interface driver module index.
*/
module_ref driver_module;
/** A serving link layer module index.
*/
module_ref link_layer_module;
/** A serving internet layer module index.
*/
module_ref internet_layer_module;
/** A system-unique network interface name.
*/
char * name;
/** Configuration.
*/
measured_strings_t configuration;
};
 
return EOK;
}
/** 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;
};
 
/** Initializes the module.
*/
int networking_initialize( void ){
int add_module( module_ref * module, modules_ref modules, const char const * name, const char const * filename, services_t service, task_id_t task_id );
static void client_connection( ipc_callid_t iid, ipc_call_t * icall );
measured_string_ref configuration_find( measured_strings_ref configuration, const char * name );
int main( int argc, char * argv[] );
int networking_call( ipc_callid_t callid );
int networking_initialize( void );
int networking_message( ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t * result1, ipcarg_t * result2, ipcarg_t * result3 );
//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 );
task_id_t spawn( const char * fname );
int startup( void );
netif_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 )
 
GENERIC_CHAR_MAP_IMPLEMENT( modules, module_t )
 
int add_module( module_ref * module, modules_ref modules, const char * name, const char * filename, services_t service, task_id_t task_id ){
ERROR_DECLARE;
 
#ifdef NETWORKING_modular
ERROR_PROPAGATE( spawn("/sbin/ip"));
// ERROR_PROPAGATE( spawn("/sbin/arp"));
// ERROR_PROPAGATE( spawn("/sbin/rarp"));
// ERROR_PROPAGATE( spawn("/sbin/icmp"));
// ERROR_PROPAGATE( spawn("/sbin/udp"));
ERROR_PROPAGATE( spawn("/sbin/tcp"));
// ERROR_PROPAGATE( spawn("/sbin/socket"));
#else
#ifdef NETWORKING_module
ipcarg_t phonehash;
module_ref tmp_module;
 
ERROR_PROPAGATE( REGISTER_ME( SERVICE_IP, & phonehash ));
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
tmp_module = ( module_ref ) malloc( sizeof( module_t ));
if( ! tmp_module ) return ENOMEM;
tmp_module->task_id = task_id;
tmp_module->phone = 0;
tmp_module->usage = 0;
tmp_module->name = name;
tmp_module->filename = filename;
tmp_module->service = service;
if( ERROR_OCCURED( modules_add( modules, tmp_module->name, tmp_module ))){
free( tmp_module );
return ERROR_CODE;
}
if( module ) * module = tmp_module;
return EOK;
}
 
/** Default thread for new connections.
*/
static void client_connection( ipc_callid_t iid, ipc_call_t * icall ){
ipc_callid_t callid;
ipc_call_t call;
ipcarg_t arg1, arg2, arg3;
int res;
ipc_callid_t callid;
ipc_call_t call;
ipcarg_t arg1, arg2, arg3;
int res;
 
/* Accept the connection */
ipc_answer_0( iid, EOK );
156,7 → 192,7
arg2 = 0;
arg3 = 0;
#ifdef NETWORKING_module
if( IS_NET_IP_MESSAGE( call )){
if( IS_NET_IL_MESSAGE( call ) || IS_NET_IP_MESSAGE( call )){
res = ip_call( callid );
if( res == EOK ){
res = ip_message( IPC_GET_METHOD( call ), IPC_GET_ARG1( call ), IPC_GET_ARG2( call ), IPC_GET_ARG3( call ), & arg1, & arg2, & arg3 );
191,7 → 227,7
if( res == EOK ){
res = socket_message( IPC_GET_METHOD( call ), IPC_GET_ARG1( call ), IPC_GET_ARG2( call ), IPC_GET_ARG3( call ), & arg1, & arg2, & arg3 );
}
*//* }else if( IS_NET_ETHERNET_MESSAGE( call )){
*//* }else if( IS_NET_LL_MESSAGE( call ) || IS_NET_ETHERNET_MESSAGE( call )){
res = ethernet_call( callid );
if( res == EOK ){
res = ethernet_message( IPC_GET_METHOD( call ), IPC_GET_ARG1( call ), IPC_GET_ARG2( call ), IPC_GET_ARG3( call ), & arg1, & arg2, & arg3 );
205,19 → 241,406
#ifdef NETWORKING_module
}
#endif
ipc_answer_2( callid, EOK, arg1, arg2 );
ipc_answer_2( callid, res, arg1, arg2 );
}
}
 
/** Starts the module.
* Parameters are ignored.
*/
int main( int argc, char * argv[] ){
 
printf("networking : HelenOS Networking subsystem\n");
printf("\nTask %d - Networking: HelenOS Networking subsystem\n", task_get_id());
 
return start_service( SERVICE_NETWORKING, NULL, NULL, client_connection, networking_initialize );
}
 
int networking_call( ipc_callid_t callid ){
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_ISA_NAME, DP8390_ISA_FILENAME, SERVICE_DP8390_ISA, 0 ));
ERROR_PROPAGATE( add_module( NULL, & networking_globals.modules, ETHERNET_NAME, ETHERNET_FILENAME, SERVICE_ETHERNET, 0 ));
 
#ifdef NETWORKING_modular
task_id = spawn( "/sbin/ip" );
if( ! task_id ) return EINVAL;
ERROR_PROPAGATE( add_module( NULL, & networking_globals.modules, IP_NAME, IP_FILENAME, SERVICE_IP, task_id ));
// if( ! spawn( "/sbin/udp" )) return EINVAL;
if( ! spawn( "/sbin/tcp" )) return EINVAL;
// if( ! spawn( "/sbin/socket" )) return EINVAL;
// not always necesssary
// if( ! spawn( "/sbin/arp" )) return EINVAL;
// if( ! spawn( "/sbin/rarp" )) return EINVAL;
// if( ! spawn( "/sbin/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;
}
 
int networking_message( ipcarg_t method, ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t * result1, ipcarg_t * result2, ipcarg_t * result3 ){
ERROR_DECLARE;
 
measured_string_ref strings;
char * data;
int index;
measured_string_ref setting;
measured_strings_ref configuration;
netif_ref netif;
 
// printf( "\nNetworking message: %d\n", method );
switch( method ){
// case IPC_M_CONNECT_ME_TO:
case IPC_M_PHONE_HUNGUP:
return EOK;
case NET_NETWORKING_DEVICE:
// TODO configure, register
// arg1 = netif id
printf( "\nNetworking: new netif %d", arg1 );
return EOK;
case NET_NETWORKING_GET_DEVICE_CONFIGURATION:
// arg1 = netif id
// arg2 = count
ERROR_PROPAGATE( measured_strings_receive( & strings, & data, arg2 ));
netif = netifs_find( & networking_globals.netifs, arg1 );
if( netif ){
configuration = & netif->configuration;
}else{
configuration = NULL;
}
for( index = 0; index < arg2; ++ index ){
setting = measured_strings_find( configuration, strings[ index ].value );
if( ! setting ){
setting = measured_strings_find( & networking_globals.configuration, strings[ index ].value );
}
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, arg2 );
free( strings );
return ERROR_CODE;
case NET_NETWORKING_GET_CONFIGURATION:
// arg1 = count
ERROR_PROPAGATE( measured_strings_receive( & strings, & data, arg1 ));
for( index = 0; index < arg1; ++ index ){
setting = measured_strings_find( & networking_globals.configuration, strings[ index ].value );
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, arg1 );
free( strings );
return ERROR_CODE;
case NET_NETWORKING_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_OCCURED( measured_strings_add( configuration, name, 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_OCCURED( measured_strings_add( configuration, name, setting ))){
free( setting );
return ERROR_CODE;
}
return EOK;
}
 
netif_device_id_t generate_new_device_id( void ){
return netifs_count( & networking_globals.netifs ) + 1;
}
 
int read_configuration( void ){
ERROR_DECLARE;
 
netif_ref netif;
measured_string_ref setting;
services_t internet_service;
 
// read general configuration
ERROR_PROPAGATE( add_configuration( & networking_globals.configuration, "IPV", "4" ));
 
// read network interfaces configuration
 
// static loopback initialization
printf( "\nloopback initialization" );
netif = ( netif_ref ) malloc( sizeof( netif_t ));
if( ! netif ) return ENOMEM;
netif->id = generate_new_device_id();
ERROR_PROPAGATE( measured_strings_initialize( & netif->configuration ));
if( ERROR_OCCURED( add_configuration( & netif->configuration, "NAME", LO_NAME ))
|| ERROR_OCCURED( add_configuration( & netif->configuration, "NETIF", LO_NAME ))
|| ERROR_OCCURED( add_configuration( & netif->configuration, "IL", IP_NAME ))
|| ERROR_OCCURED( add_configuration( & netif->configuration, "IP_CONFIG", "STATIC" ))
|| ERROR_OCCURED( add_configuration( & netif->configuration, "IP_ADDR", "127.0.0.1" ))
|| ERROR_OCCURED( add_configuration( & netif->configuration, "NETMASK", "255.255.255.255" ))
){
measured_strings_destroy( & netif->configuration );
free( netif );
return ERROR_CODE;
}
// mandatory name
printf( "\n\tname" );
setting = measured_strings_find( & netif->configuration, "NAME" );
if( ! setting ){
measured_strings_destroy( & netif->configuration );
free( netif );
return EINVAL;
}
netif->name = setting->value;
printf( " %s OK", netif->name );
// mandatory netif
printf( "\n\tnetif" );
setting = measured_strings_find( & netif->configuration, "NETIF" );
if( ! setting ){
printf( " unknown" );
measured_strings_destroy( & netif->configuration );
free( netif );
return EINVAL;
}
// printf( " find %s in %d?", setting->value, modules_count( & networking_globals.modules ));
netif->driver_module = modules_find( & networking_globals.modules, setting->value );
if( ! netif->driver_module ){
printf( " not found" );
// TODO register the unknown one
measured_strings_destroy( & netif->configuration );
free( netif );
return EINVAL;
}
printf( " found" );
if( ! netif->driver_module->task_id ){
netif->driver_module->task_id = spawn( netif->driver_module->filename );
if( ! netif->driver_module->task_id ){
measured_strings_destroy( & netif->configuration );
free( netif );
return EINVAL;
}
}
if( ! netif->driver_module->phone ){
printf( " connect?" );
netif->driver_module->phone = connect_to_service( netif->driver_module->service );
}
printf( " connected" );
if( ERROR_OCCURED( ipc_call_sync_1_0( netif->driver_module->phone, NET_NETIF_PROBE, netif->id ))){
measured_strings_destroy( & netif->configuration );
free( netif );
return ERROR_CODE;
}
++ netif->driver_module->usage;
printf( " OK" );
// optional link layer
printf( "\n\tlink layer" );
setting = measured_strings_find( & netif->configuration, "LL" );
if( setting ){
netif->link_layer_module = modules_find( & networking_globals.modules, setting->value );
if( ! netif->link_layer_module ){
// TODO register the unknown one
-- netif->driver_module->usage;
measured_strings_destroy( & netif->configuration );
free( netif );
return EINVAL;
}
if( ! netif->link_layer_module->task_id ){
netif->link_layer_module->task_id = spawn( netif->link_layer_module->filename );
if( ! netif->link_layer_module->task_id ){
-- netif->driver_module->usage;
measured_strings_destroy( & netif->configuration );
free( netif );
return EINVAL;
}
}
if( ! netif->link_layer_module->phone ){
netif->link_layer_module->phone = connect_to_service( netif->link_layer_module->service );
}
if( ERROR_OCCURED( ipc_call_sync_2_0( netif->link_layer_module->phone, NET_LL_DEVICE, netif->id, netif->driver_module->service ))){
-- netif->driver_module->usage;
measured_strings_destroy( & netif->configuration );
free( netif );
return ERROR_CODE;
}
++ netif->link_layer_module->usage;
internet_service = netif->link_layer_module->service;
printf( " OK" );
}else{
internet_service = netif->driver_module->service;
printf( " none" );
}
// mandatory internet layer
printf( "\n\tinternet layer" );
setting = measured_strings_find( & netif->configuration, "IL" );
if( ! setting ){
-- netif->driver_module->usage;
-- netif->link_layer_module->usage;
measured_strings_destroy( & netif->configuration );
free( netif );
return EINVAL;
}
printf( " set %s", setting->value );
netif->internet_layer_module = modules_find( & networking_globals.modules, setting->value );
if( ! netif->internet_layer_module ){
// TODO register the unknown one
-- netif->driver_module->usage;
-- netif->link_layer_module->usage;
measured_strings_destroy( & netif->configuration );
free( netif );
return EINVAL;
}
printf( " found" );
if( ! netif->internet_layer_module->task_id ){
netif->internet_layer_module->task_id = spawn( netif->internet_layer_module->filename );
if( ! netif->internet_layer_module->task_id ){
-- netif->driver_module->usage;
-- netif->link_layer_module->usage;
measured_strings_destroy( & netif->configuration );
free( netif );
return EINVAL;
}
}
if( ! netif->internet_layer_module->phone ){
printf( " connect" );
netif->internet_layer_module->phone = connect_to_service( netif->internet_layer_module->service );
}
if( ERROR_OCCURED( ipc_call_sync_2_0( netif->internet_layer_module->phone, NET_IL_DEVICE, netif->id, internet_service ))){
measured_strings_destroy( & netif->configuration );
free( netif );
return ERROR_CODE;
}
++ netif->internet_layer_module->usage;
printf( " OK" );
if( ERROR_OCCURED( netifs_add( & networking_globals.netifs, netif->id, netif ))){
free( netif );
return ERROR_CODE;
}
printf( "\nloopback OK" );
// end of static loopback initialization
return EOK;
}
 
task_id_t spawn( const char * fname ){
const char * argv[ 2 ];
task_id_t res;
 
// printf( "Spawning %s\n", fname );
argv[ 0 ] = fname;
argv[ 1 ] = NULL;
res = task_spawn( fname, argv );
if( res != 0 ){
/* Success */
usleep( 50000 );
}
return res;
}
 
int startup( void ){
ERROR_DECLARE;
 
// read configuration files
if( ERROR_OCCURED( read_configuration())) return ERROR_CODE;
 
// start network interfaces and needed modules
// start_device( "/sbin/lo", "/sbin/dummy_link_layer" );
return EOK;
}
 
/** @}
*/