Subversion Repositories HelenOS

Rev

Rev 4752 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
3466 mejdrech 1
/*
3912 mejdrech 2
 * Copyright (c) 2009 Lukas Mejdrech
3466 mejdrech 3
 * All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 *
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
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
15
 *   derived from this software without specific prior written permission.
16
 *
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
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
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
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
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
28
 
29
/** @addtogroup net
3912 mejdrech 30
 *  @{
3466 mejdrech 31
 */
32
 
33
/** @file
4350 mejdrech 34
 *  Networking subsystem central module implementation.
3466 mejdrech 35
 */
36
 
37
#include <async.h>
3666 mejdrech 38
#include <ctype.h>
4163 mejdrech 39
#include <ddi.h>
3466 mejdrech 40
#include <errno.h>
3666 mejdrech 41
#include <malloc.h>
3466 mejdrech 42
#include <stdio.h>
4582 mejdrech 43
#include <string.h>
3846 mejdrech 44
 
3466 mejdrech 45
#include <ipc/ipc.h>
46
#include <ipc/services.h>
47
 
3666 mejdrech 48
#include "../err.h"
49
#include "../messages.h"
3466 mejdrech 50
#include "../modules.h"
51
 
3886 mejdrech 52
#include "../structures/char_map.h"
53
#include "../structures/generic_char_map.h"
54
#include "../structures/measured_strings.h"
4192 mejdrech 55
#include "../structures/module_map.h"
3901 mejdrech 56
#include "../structures/packet/packet.h"
3886 mejdrech 57
 
4307 mejdrech 58
#include "../il/il_messages.h"
4243 mejdrech 59
#include "../include/device.h"
4307 mejdrech 60
#include "../include/netif_interface.h"
61
#include "../include/nil_interface.h"
62
#include "../include/net_interface.h"
63
#include "../include/ip_interface.h"
3466 mejdrech 64
 
4307 mejdrech 65
#include "net.h"
4743 mejdrech 66
#include "net_messages.h"
3466 mejdrech 67
 
4350 mejdrech 68
/** Networking module name.
69
 */
3901 mejdrech 70
#define NAME    "Networking"
71
 
4350 mejdrech 72
/** Prints the module name.
73
 *  @see NAME
74
 */
4307 mejdrech 75
void    module_print_name( void );
4350 mejdrech 76
 
77
/** Starts the networking module.
78
 *  Initializes the client connection serving function, initializes the module, registers the module service and starts the async manager, processing IPC messages in an infinite loop.
4756 mejdrech 79
 *  @param[in] client_connection The client connection processing function. The module skeleton propagates its own one.
4350 mejdrech 80
 *  @returns EOK on successful module termination.
81
 *  @returns Other error codes as defined for the net_initialize() function.
82
 *  @returns Other error codes as defined for the REGISTER_ME() macro function.
83
 */
4307 mejdrech 84
int module_start( async_client_conn_t client_connection );
4350 mejdrech 85
 
3666 mejdrech 86
//int       parse_line( measured_strings_ref configuration, char * line );
4350 mejdrech 87
 
88
/** Reads the networking subsystem global configuration.
89
 *  @returns EOK on success.
90
 *  @returns Other error codes as defined for the add_configuration() function.
91
 */
3666 mejdrech 92
int     read_configuration( void );
4350 mejdrech 93
 
94
/** Starts the network interface according to its configuration.
95
 *  Registers the network interface with the subsystem modules.
96
 *  Starts the needed subsystem modules.
4756 mejdrech 97
 *  @param[in] netif The network interface specific data.
4350 mejdrech 98
 *  @returns EOK on success.
99
 *  @returns EINVAL if there are some settings missing.
100
 *  @returns ENOENT if the internet protocol module is not known.
101
 *  @returns Other error codes as defined for the netif_probe_req() function.
102
 *  @returns Other error codes as defined for the nil_device_req() function.
103
 *  @returns Other error codes as defined for the needed internet layer registering function.
104
 */
4192 mejdrech 105
int     start_device( netif_ref netif );
4350 mejdrech 106
 
107
/** Reads the configuration and starts all network interfaces.
108
 *  @returns EOK on success.
109
 *  @returns EXDEV if there is no available system-unique device identifier.
110
 *  @returns EINVAL if any of the network interface names are not configured.
111
 *  @returns ENOMEM if there is not enough memory left.
112
 *  @returns Other error codes as defined for the read_configuration() function.
113
 *  @returns Other error codes as defined for the read_netif_configuration() function.
114
 *  @returns Other error codes as defined for the start_device() function.
115
 */
3666 mejdrech 116
int     startup( void );
4350 mejdrech 117
 
118
/** Generates new system-unique device identifier.
119
 *  @returns The system-unique devic identifier.
120
 */
3846 mejdrech 121
device_id_t generate_new_device_id( void );
3666 mejdrech 122
 
4350 mejdrech 123
/** Returns the configured values.
124
 *  The network interface configuration is searched first.
4756 mejdrech 125
 *  @param[in] netif_conf The network interface configuration setting.
126
 *  @param[out] configuration The found configured values.
127
 *  @param[in] count The desired settings count.
128
 *  @param[out] data The found configuration settings data.
4350 mejdrech 129
 *  @returns EOK.
130
 */
4505 mejdrech 131
int net_get_conf( measured_strings_ref netif_conf, measured_string_ref configuration, size_t count, char ** data );
4350 mejdrech 132
 
4720 mejdrech 133
/** Initializes the networking module.
4756 mejdrech 134
 *  @param[in] client_connection The client connection processing function. The module skeleton propagates its own one.
4720 mejdrech 135
 *  @returns EOK on success.
136
 *  @returns ENOMEM if there is not enough memory left.
137
 */
138
int net_initialize( async_client_conn_t client_connection );
139
 
140
/** Reads the network interface specific configuration.
4756 mejdrech 141
 *  @param[in] name The network interface name.
142
 *  @param[in,out] netif The network interface structure.
4720 mejdrech 143
 *  @returns EOK on success.
144
 *  @returns Other error codes as defined for the add_configuration() function.
145
 */
146
int read_netif_configuration( char * name, netif_ref netif );
147
 
4350 mejdrech 148
/** Networking module global data.
149
 */
4307 mejdrech 150
net_globals_t   net_globals;
3666 mejdrech 151
 
152
DEVICE_MAP_IMPLEMENT( netifs, netif_t )
153
 
154
GENERIC_CHAR_MAP_IMPLEMENT( measured_strings, measured_string_t )
155
 
4307 mejdrech 156
void module_print_name( void ){
4197 mejdrech 157
    printf( "%s", NAME );
3901 mejdrech 158
}
159
 
4307 mejdrech 160
int module_start( async_client_conn_t client_connection ){
3846 mejdrech 161
    ERROR_DECLARE;
3466 mejdrech 162
 
3846 mejdrech 163
    ipcarg_t    phonehash;
164
 
165
    async_set_client_connection( client_connection );
3901 mejdrech 166
    ERROR_PROPAGATE( pm_init());
4351 mejdrech 167
    if( ERROR_OCCURRED( net_initialize( client_connection ))
3914 mejdrech 168
    || ERROR_OCCURRED( REGISTER_ME( SERVICE_NETWORKING, & phonehash ))){
169
        pm_destroy();
170
        return ERROR_CODE;
171
    }
172
 
3846 mejdrech 173
    async_manager();
174
 
3914 mejdrech 175
    pm_destroy();
3666 mejdrech 176
    return EOK;
177
}
178
 
4720 mejdrech 179
int net_initialize( async_client_conn_t client_connection ){
180
    ERROR_DECLARE;
181
 
182
    netifs_initialize( & net_globals.netifs );
183
    char_map_initialize( & net_globals.netif_names );
184
    modules_initialize( & net_globals.modules );
185
    measured_strings_initialize( & net_globals.configuration );
186
 
187
    // TODO dynamic configuration
188
    ERROR_PROPAGATE( read_configuration());
189
 
190
    ERROR_PROPAGATE( add_module( NULL, & net_globals.modules, LO_NAME, LO_FILENAME, SERVICE_LO, 0, connect_to_service ));
191
    ERROR_PROPAGATE( add_module( NULL, & net_globals.modules, DP8390_NAME, DP8390_FILENAME, SERVICE_DP8390, 0, connect_to_service ));
192
    ERROR_PROPAGATE( add_module( NULL, & net_globals.modules, ETHERNET_NAME, ETHERNET_FILENAME, SERVICE_ETHERNET, 0, connect_to_service ));
193
    ERROR_PROPAGATE( add_module( NULL, & net_globals.modules, NILDUMMY_NAME, NILDUMMY_FILENAME, SERVICE_NILDUMMY, 0, connect_to_service ));
194
 
195
    // build specific initialization
196
    return net_initialize_build( client_connection );
197
}
198
 
4505 mejdrech 199
int net_get_device_conf_req( int net_phone, device_id_t device_id, measured_string_ref * configuration, size_t count, char ** data ){
4307 mejdrech 200
    netif_ref   netif;
3666 mejdrech 201
 
4307 mejdrech 202
    if( !( configuration && ( count > 0 ))) return EINVAL;
203
    netif = netifs_find( & net_globals.netifs, device_id );
204
    if( netif ){
205
        return net_get_conf( & netif->configuration, * configuration, count, data );
206
    }else{
207
        return net_get_conf( NULL, * configuration, count, data );
208
    }
209
}
3666 mejdrech 210
 
4505 mejdrech 211
int net_get_conf_req( int net_phone, measured_string_ref * configuration, size_t count, char ** data ){
4307 mejdrech 212
    if( !( configuration && ( count > 0 ))) return EINVAL;
213
    return net_get_conf( NULL, * configuration, count, data );
214
}
3666 mejdrech 215
 
4505 mejdrech 216
int net_get_conf( measured_strings_ref netif_conf, measured_string_ref configuration, size_t count, char ** data ){
4307 mejdrech 217
    measured_string_ref setting;
4505 mejdrech 218
    size_t              index;
3666 mejdrech 219
 
4307 mejdrech 220
    if( data ) * data = NULL;
221
    for( index = 0; index < count; ++ index ){
4350 mejdrech 222
        setting = measured_strings_find( netif_conf, configuration[ index ].value, 0 );
4307 mejdrech 223
        if( ! setting ){
224
            setting = measured_strings_find( & net_globals.configuration, configuration[ index ].value, 0 );
225
        }
226
        if( setting ){
227
            configuration[ index ].length = setting->length;
228
            configuration[ index ].value = setting->value;
229
        }else{
230
            configuration[ index ].length = 0;
231
            configuration[ index ].value = NULL;
232
        }
233
    }
234
    return EOK;
235
}
3666 mejdrech 236
 
4307 mejdrech 237
void net_free_settings( measured_string_ref settings, char * data ){
238
}
3666 mejdrech 239
 
4307 mejdrech 240
int net_connect_module( services_t service ){
3666 mejdrech 241
    return EOK;
242
}
243
 
3901 mejdrech 244
int net_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
3666 mejdrech 245
    ERROR_DECLARE;
246
 
247
    measured_string_ref strings;
4307 mejdrech 248
    char *              data;
3666 mejdrech 249
 
3901 mejdrech 250
    * answer_count = 0;
251
    switch( IPC_GET_METHOD( * call )){
3666 mejdrech 252
        case IPC_M_PHONE_HUNGUP:
253
            return EOK;
3846 mejdrech 254
        case NET_NET_GET_DEVICE_CONF:
3901 mejdrech 255
            ERROR_PROPAGATE( measured_strings_receive( & strings, & data, IPC_GET_COUNT( call )));
4307 mejdrech 256
            net_get_device_conf_req( 0, IPC_GET_DEVICE( call ), & strings, IPC_GET_COUNT( call ), NULL );
3666 mejdrech 257
            // strings should not contain received data anymore
258
            free( data );
3901 mejdrech 259
            ERROR_CODE = measured_strings_reply( strings, IPC_GET_COUNT( call ));
3666 mejdrech 260
            free( strings );
261
            return ERROR_CODE;
3846 mejdrech 262
        case NET_NET_GET_CONF:
3901 mejdrech 263
            ERROR_PROPAGATE( measured_strings_receive( & strings, & data, IPC_GET_COUNT( call )));
4307 mejdrech 264
            net_get_conf_req( 0, & strings, IPC_GET_COUNT( call ), NULL );
3666 mejdrech 265
            // strings should not contain received data anymore
266
            free( data );
3901 mejdrech 267
            ERROR_CODE = measured_strings_reply( strings, IPC_GET_COUNT( call ));
3666 mejdrech 268
            free( strings );
269
            return ERROR_CODE;
3846 mejdrech 270
        case NET_NET_STARTUP:
3666 mejdrech 271
            return startup();
272
    }
273
    return ENOTSUP;
274
}
275
 
276
/*
277
int parse_line( measured_strings_ref configuration, char * line ){
278
    ERROR_DECLARE;
279
 
280
    measured_string_ref setting;
281
    char *          name;
282
    char *          value;
283
 
284
    // from the beginning
285
    name = line;
286
    // skip spaces
287
    while( isspace( * name )) ++ name;
288
    // remember the name start
289
    value = name;
290
    // skip the name
291
    while( isalnum( * value ) || ( * value == '_' )){
292
        // make uppercase
293
//      * value = toupper( * value );
294
        ++ value;
295
    }
296
    if( * value == '=' ){
297
        // terminate the name
298
        * value = '\0';
299
    }else{
300
        // terminate the name
301
        * value = '\0';
302
        // skip until '='
303
        ++ value;
304
        while(( * value ) && ( * value != '=' )) ++ value;
305
        // not found?
306
        if( * value != '=' ) return EINVAL;
307
    }
308
    ++ value;
309
    // skip spaces
310
    while( isspace( * value )) ++ value;
311
    // create a bulk measured string till the end
312
    setting = measured_string_create_bulk( value, -1 );
313
    if( ! setting ) return ENOMEM;
314
    // add the configuration setting
3912 mejdrech 315
    if( ERROR_OCCURRED( measured_strings_add( configuration, name, 0, setting ))){
3666 mejdrech 316
        free( setting );
317
        return ERROR_CODE;
318
    }
319
    return EOK;
320
}
321
*/
322
 
323
int add_configuration( measured_strings_ref configuration, const char * name, const char * value ){
324
    ERROR_DECLARE;
325
 
326
    measured_string_ref setting;
327
 
328
    setting = measured_string_create_bulk( value, 0 );
329
    if( ! setting ) return ENOMEM;
330
    // add the configuration setting
3912 mejdrech 331
    if( ERROR_OCCURRED( measured_strings_add( configuration, name, 0, setting ))){
3666 mejdrech 332
        free( setting );
333
        return ERROR_CODE;
334
    }
335
    return EOK;
336
}
337
 
3846 mejdrech 338
device_id_t generate_new_device_id( void ){
4163 mejdrech 339
    return device_assign_devno();
3666 mejdrech 340
}
341
 
342
int read_configuration( void ){
343
    ERROR_DECLARE;
344
 
4192 mejdrech 345
    // read general configuration
4307 mejdrech 346
    ERROR_PROPAGATE( add_configuration( & net_globals.configuration, "IPV", "4" ));
4743 mejdrech 347
    ERROR_PROPAGATE( add_configuration( & net_globals.configuration, "IP_ROUTING", "no" ));
4307 mejdrech 348
    ERROR_PROPAGATE( add_configuration( & net_globals.configuration, "MTU", "1500" ));
4720 mejdrech 349
    ERROR_PROPAGATE( add_configuration( & net_globals.configuration, "ICMP_ERROR_REPORTING", "yes" ));  //anything else not starting with 'y'
350
    ERROR_PROPAGATE( add_configuration( & net_globals.configuration, "ICMP_ECHO_REPLYING", "yes" ));  //anything else not starting with 'y'
4722 mejdrech 351
    ERROR_PROPAGATE( add_configuration( & net_globals.configuration, "UDP_CHECKSUM_COMPUTING", "yes" ));  //anything else not starting with 'y'
4730 mejdrech 352
    ERROR_PROPAGATE( add_configuration( & net_globals.configuration, "UDP_AUTOBINDING", "yes" ));  //anything else not starting with 'y'
4192 mejdrech 353
    return EOK;
354
}
355
 
4720 mejdrech 356
int read_netif_configuration( char * name, netif_ref netif ){
357
    ERROR_DECLARE;
358
 
359
    if( str_lcmp( name, "lo", 2 ) == 0 ){
360
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "NAME", LO_NAME ));
361
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "NETIF", LO_NAME ));
362
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "IL", IP_NAME ));
363
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "IP_CONFIG", "static" ));
364
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "IP_ADDR", "127.0.0.1" ));
4743 mejdrech 365
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "IP_NETMASK", "255.0.0.0" ));
4720 mejdrech 366
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "MTU", "15535" ));
367
    }else if( str_lcmp( name, "ne2k", 4 ) == 0 ){
368
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "NAME", "eth0" ));
369
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "NETIF", DP8390_NAME ));
370
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "ETH_MODE", "DIX" )); //8023_2_LSAP( not supported ), 8023_2_SNAP
371
//      ERROR_PROPAGATE( add_configuration( & netif->configuration, "ETH_DUMMY", "yes" )); //anything else not starting with 'y'
372
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "IL", IP_NAME ));
373
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "IRQ", "9" ));
374
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "IO", "300" ));
4752 mejdrech 375
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "MTU", "1492" ));
4720 mejdrech 376
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "IP_CONFIG", "static" ));
377
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "IP_ADDR", "10.0.2.15" ));
378
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "IP_ROUTING", "yes" ));
4743 mejdrech 379
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "IP_NETMASK", "255.255.255.240" ));
380
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "IP_BROADCAST", "10.0.2.255" ));
381
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "IP_GATEWAY", "10.0.2.2" ));
4720 mejdrech 382
        ERROR_PROPAGATE( add_configuration( & netif->configuration, "ARP", "arp" ));
383
    }
384
    return read_netif_configuration_build( name, netif );
385
}
386
 
4192 mejdrech 387
int start_device( netif_ref netif ){
388
    ERROR_DECLARE;
389
 
3666 mejdrech 390
    measured_string_ref setting;
4163 mejdrech 391
    services_t          internet_service;
392
    int                 irq;
393
    int                 io;
394
    int                 mtu;
3666 mejdrech 395
 
396
    // mandatory netif
4163 mejdrech 397
    setting = measured_strings_find( & netif->configuration, CONF_NETIF, 0 );
4307 mejdrech 398
    netif->driver = get_running_module( & net_globals.modules, setting->value );
3846 mejdrech 399
    if( ! netif->driver ){
4307 mejdrech 400
        printf( "Failed to start the network interface driver %s\n", setting->value );
3666 mejdrech 401
        return EINVAL;
402
    }
4163 mejdrech 403
    // optional network interface layer
404
    setting = measured_strings_find( & netif->configuration, CONF_NIL, 0 );
3666 mejdrech 405
    if( setting ){
4307 mejdrech 406
        netif->nil = get_running_module( & net_globals.modules, setting->value );
3846 mejdrech 407
        if( ! netif->nil ){
4307 mejdrech 408
            printf( "Failed to start the network interface layer %s\n", setting->value );
3666 mejdrech 409
            return EINVAL;
410
        }
411
    }else{
3846 mejdrech 412
        netif->nil = NULL;
3666 mejdrech 413
    }
414
    // mandatory internet layer
4163 mejdrech 415
    setting = measured_strings_find( & netif->configuration, CONF_IL, 0 );
4307 mejdrech 416
    netif->il = get_running_module( & net_globals.modules, setting->value );
3846 mejdrech 417
    if( ! netif->il ){
4307 mejdrech 418
        printf( "Failed to start the internet layer %s\n", setting->value );
3666 mejdrech 419
        return EINVAL;
420
    }
3685 mejdrech 421
    // end of the static loopback initialization
422
    // startup the loopback interface
4163 mejdrech 423
    setting = measured_strings_find( & netif->configuration, CONF_IRQ, 0 );
424
    irq = setting ? strtol( setting->value, NULL, 10 ) : 0;
425
    setting = measured_strings_find( & netif->configuration, CONF_IO, 0 );
426
    io = setting ? strtol( setting->value, NULL, 16 ) : 0;
4243 mejdrech 427
    ERROR_PROPAGATE( netif_probe_req( netif->driver->phone, netif->id, irq, io ));
3846 mejdrech 428
    if( netif->nil ){
4163 mejdrech 429
        setting = measured_strings_find( & netif->configuration, CONF_MTU, 0 );
430
        if( ! setting ){
4307 mejdrech 431
            setting = measured_strings_find( & net_globals.configuration, CONF_MTU, 0 );
4163 mejdrech 432
        }
433
        mtu = setting ? strtol( setting->value, NULL, 10 ) : 0;
4261 mejdrech 434
        ERROR_PROPAGATE( nil_device_req( netif->nil->phone, netif->id, mtu, netif->driver->service ));
3846 mejdrech 435
        internet_service = netif->nil->service;
3685 mejdrech 436
    }else{
3846 mejdrech 437
        internet_service = netif->driver->service;
3685 mejdrech 438
    }
4307 mejdrech 439
    switch( netif->il->service ){
440
        case SERVICE_IP:
441
            ERROR_PROPAGATE( ip_device_req( netif->il->phone, netif->id, internet_service ));
442
            break;
443
        default:
444
            return ENOENT;
445
    }
4243 mejdrech 446
    ERROR_PROPAGATE( netif_start_req( netif->driver->phone, netif->id ));
3666 mejdrech 447
    return EOK;
448
}
449
 
450
int startup( void ){
451
    ERROR_DECLARE;
452
 
4192 mejdrech 453
    char *      conf_files[] = { "lo", "ne2k" };
454
    int         count = sizeof( conf_files ) / sizeof( char * );
455
    int         index;
456
    netif_ref   netif;
457
    int         i;
458
    measured_string_ref setting;
3666 mejdrech 459
 
4192 mejdrech 460
    for( i = 0; i < count; ++ i ){
461
        netif = ( netif_ref ) malloc( sizeof( netif_t ));
462
        if( ! netif ) return ENOMEM;
463
 
464
        netif->id = generate_new_device_id();
465
        if( ! netif->id ) return EXDEV;
466
        ERROR_PROPAGATE( measured_strings_initialize( & netif->configuration ));
467
        // read configuration files
468
        if( ERROR_OCCURRED( read_netif_configuration( conf_files[ i ], netif ))){
469
            measured_strings_destroy( & netif->configuration );
470
            free( netif );
471
            return ERROR_CODE;
472
        }
473
        // mandatory name
474
        setting = measured_strings_find( & netif->configuration, CONF_NAME, 0 );
475
        if( ! setting ){
4307 mejdrech 476
            printf( "The name is missing\n" );
4192 mejdrech 477
            measured_strings_destroy( & netif->configuration );
478
            free( netif );
479
            return EINVAL;
480
        }
481
        netif->name = setting->value;
482
        // add to the netifs map
4307 mejdrech 483
        index = netifs_add( & net_globals.netifs, netif->id, netif );
4192 mejdrech 484
        if( index < 0 ){
485
            measured_strings_destroy( & netif->configuration );
486
            free( netif );
487
            return index;
488
        }
489
        // add to the netif names map
4307 mejdrech 490
        if( ERROR_OCCURRED( char_map_add( & net_globals.netif_names, netif->name, 0, index ))
4192 mejdrech 491
        // start network interfaces and needed modules
492
        || ERROR_OCCURRED( start_device( netif ))){
493
            measured_strings_destroy( & netif->configuration );
4307 mejdrech 494
            netifs_exclude_index( & net_globals.netifs, index );
4192 mejdrech 495
            return ERROR_CODE;
496
        }
497
        // increment modules' usage
498
        ++ netif->driver->usage;
499
        if( netif->nil ) ++ netif->nil->usage;
500
        ++ netif->il->usage;
4307 mejdrech 501
        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 );
4192 mejdrech 502
    }
3666 mejdrech 503
    return EOK;
504
}
505
 
3466 mejdrech 506
/** @}
507
 */