Subversion Repositories HelenOS

Rev

Rev 4350 | Rev 4582 | Go to most recent revision | 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>
3846 mejdrech 43
 
3466 mejdrech 44
#include <ipc/ipc.h>
45
#include <ipc/services.h>
46
 
3666 mejdrech 47
#include "../err.h"
48
#include "../messages.h"
3466 mejdrech 49
#include "../modules.h"
3666 mejdrech 50
//#include "../self_test.h"
3466 mejdrech 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"
3466 mejdrech 66
 
4350 mejdrech 67
/** Networking module name.
68
 */
3901 mejdrech 69
#define NAME    "Networking"
70
 
4350 mejdrech 71
/** Prints the module name.
72
 *  @see NAME
73
 */
4307 mejdrech 74
void    module_print_name( void );
4350 mejdrech 75
 
76
/** Starts the networking module.
77
 *  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.
78
 *  @param client_connection The client connection processing function. The module skeleton propagates its own one. Input parameter.
79
 *  @returns EOK on successful module termination.
80
 *  @returns Other error codes as defined for the net_initialize() function.
81
 *  @returns Other error codes as defined for the REGISTER_ME() macro function.
82
 */
4307 mejdrech 83
int module_start( async_client_conn_t client_connection );
4350 mejdrech 84
 
3666 mejdrech 85
//int       parse_line( measured_strings_ref configuration, char * line );
4350 mejdrech 86
 
87
/** Reads the networking subsystem global configuration.
88
 *  @returns EOK on success.
89
 *  @returns Other error codes as defined for the add_configuration() function.
90
 */
3666 mejdrech 91
int     read_configuration( void );
4350 mejdrech 92
 
93
/** Starts the network interface according to its configuration.
94
 *  Registers the network interface with the subsystem modules.
95
 *  Starts the needed subsystem modules.
96
 *  @param netif The network interface specific data.
97
 *  @returns EOK on success.
98
 *  @returns EINVAL if there are some settings missing.
99
 *  @returns ENOENT if the internet protocol module is not known.
100
 *  @returns Other error codes as defined for the netif_probe_req() function.
101
 *  @returns Other error codes as defined for the nil_device_req() function.
102
 *  @returns Other error codes as defined for the needed internet layer registering function.
103
 */
4192 mejdrech 104
int     start_device( netif_ref netif );
4350 mejdrech 105
 
106
/** Reads the configuration and starts all network interfaces.
107
 *  @returns EOK on success.
108
 *  @returns EXDEV if there is no available system-unique device identifier.
109
 *  @returns EINVAL if any of the network interface names are not configured.
110
 *  @returns ENOMEM if there is not enough memory left.
111
 *  @returns Other error codes as defined for the read_configuration() function.
112
 *  @returns Other error codes as defined for the read_netif_configuration() function.
113
 *  @returns Other error codes as defined for the start_device() function.
114
 */
3666 mejdrech 115
int     startup( void );
4350 mejdrech 116
 
117
/** Generates new system-unique device identifier.
118
 *  @returns The system-unique devic identifier.
119
 */
3846 mejdrech 120
device_id_t generate_new_device_id( void );
3666 mejdrech 121
 
4350 mejdrech 122
/** Returns the configured values.
123
 *  The network interface configuration is searched first.
124
 *  @param netif_conf The network interface configuration setting. Input parameter.
125
 *  @param configuration The found configured values. Output parameter.
126
 *  @param count The desired settings count. Input parameter.
127
 *  @param data The found configuration settings data. Output parameter.
128
 *  @returns EOK.
129
 */
130
int net_get_conf( measured_strings_ref netif_conf, measured_string_ref configuration, int count, char ** data );
131
 
132
/** Networking module global data.
133
 */
4307 mejdrech 134
net_globals_t   net_globals;
3666 mejdrech 135
 
136
DEVICE_MAP_IMPLEMENT( netifs, netif_t )
137
 
138
GENERIC_CHAR_MAP_IMPLEMENT( measured_strings, measured_string_t )
139
 
4307 mejdrech 140
void module_print_name( void ){
4197 mejdrech 141
    printf( "%s", NAME );
3901 mejdrech 142
}
143
 
4307 mejdrech 144
int module_start( async_client_conn_t client_connection ){
3846 mejdrech 145
    ERROR_DECLARE;
3466 mejdrech 146
 
3846 mejdrech 147
    ipcarg_t    phonehash;
148
 
149
    async_set_client_connection( client_connection );
3901 mejdrech 150
    ERROR_PROPAGATE( pm_init());
4351 mejdrech 151
    if( ERROR_OCCURRED( net_initialize( client_connection ))
3914 mejdrech 152
    || ERROR_OCCURRED( REGISTER_ME( SERVICE_NETWORKING, & phonehash ))){
153
        pm_destroy();
154
        return ERROR_CODE;
155
    }
156
 
3846 mejdrech 157
    async_manager();
158
 
3914 mejdrech 159
    pm_destroy();
3666 mejdrech 160
    return EOK;
161
}
162
 
4307 mejdrech 163
int net_get_device_conf_req( int net_phone, device_id_t device_id, measured_string_ref * configuration, int count, char ** data ){
164
    netif_ref   netif;
3666 mejdrech 165
 
4307 mejdrech 166
    if( !( configuration && ( count > 0 ))) return EINVAL;
167
    netif = netifs_find( & net_globals.netifs, device_id );
168
    if( netif ){
169
        return net_get_conf( & netif->configuration, * configuration, count, data );
170
    }else{
171
        return net_get_conf( NULL, * configuration, count, data );
172
    }
173
}
3666 mejdrech 174
 
4307 mejdrech 175
int net_get_conf_req( int net_phone, measured_string_ref * configuration, int count, char ** data ){
176
    if( !( configuration && ( count > 0 ))) return EINVAL;
177
    return net_get_conf( NULL, * configuration, count, data );
178
}
3666 mejdrech 179
 
4350 mejdrech 180
int net_get_conf( measured_strings_ref netif_conf, measured_string_ref configuration, int count, char ** data ){
4307 mejdrech 181
    measured_string_ref setting;
182
    int                 index;
3666 mejdrech 183
 
4307 mejdrech 184
    if( data ) * data = NULL;
185
    for( index = 0; index < count; ++ index ){
4350 mejdrech 186
        setting = measured_strings_find( netif_conf, configuration[ index ].value, 0 );
4307 mejdrech 187
        if( ! setting ){
188
            setting = measured_strings_find( & net_globals.configuration, configuration[ index ].value, 0 );
189
        }
190
        if( setting ){
191
            configuration[ index ].length = setting->length;
192
            configuration[ index ].value = setting->value;
193
        }else{
194
            configuration[ index ].length = 0;
195
            configuration[ index ].value = NULL;
196
        }
197
    }
198
    return EOK;
199
}
3666 mejdrech 200
 
4307 mejdrech 201
void net_free_settings( measured_string_ref settings, char * data ){
202
}
3666 mejdrech 203
 
4307 mejdrech 204
int net_connect_module( services_t service ){
3666 mejdrech 205
    return EOK;
206
}
207
 
3901 mejdrech 208
int net_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
3666 mejdrech 209
    ERROR_DECLARE;
210
 
211
    measured_string_ref strings;
4307 mejdrech 212
    char *              data;
3666 mejdrech 213
 
3901 mejdrech 214
    * answer_count = 0;
215
    switch( IPC_GET_METHOD( * call )){
3666 mejdrech 216
        case IPC_M_PHONE_HUNGUP:
217
            return EOK;
3846 mejdrech 218
        case NET_NET_DEVICE:
3666 mejdrech 219
            // TODO configure, register
4307 mejdrech 220
            printf( "Networking: new netif %d\n", IPC_GET_DEVICE( call ));
3666 mejdrech 221
            return EOK;
3846 mejdrech 222
        case NET_NET_GET_DEVICE_CONF:
3901 mejdrech 223
            ERROR_PROPAGATE( measured_strings_receive( & strings, & data, IPC_GET_COUNT( call )));
4307 mejdrech 224
            net_get_device_conf_req( 0, IPC_GET_DEVICE( call ), & strings, IPC_GET_COUNT( call ), NULL );
3666 mejdrech 225
            // strings should not contain received data anymore
226
            free( data );
3901 mejdrech 227
            ERROR_CODE = measured_strings_reply( strings, IPC_GET_COUNT( call ));
3666 mejdrech 228
            free( strings );
229
            return ERROR_CODE;
3846 mejdrech 230
        case NET_NET_GET_CONF:
3901 mejdrech 231
            ERROR_PROPAGATE( measured_strings_receive( & strings, & data, IPC_GET_COUNT( call )));
4307 mejdrech 232
            net_get_conf_req( 0, & strings, IPC_GET_COUNT( call ), NULL );
3666 mejdrech 233
            // strings should not contain received data anymore
234
            free( data );
3901 mejdrech 235
            ERROR_CODE = measured_strings_reply( strings, IPC_GET_COUNT( call ));
3666 mejdrech 236
            free( strings );
237
            return ERROR_CODE;
3846 mejdrech 238
        case NET_NET_STARTUP:
3666 mejdrech 239
            return startup();
240
    }
241
    return ENOTSUP;
242
}
243
 
244
/*
245
int parse_line( measured_strings_ref configuration, char * line ){
246
    ERROR_DECLARE;
247
 
248
    measured_string_ref setting;
249
    char *          name;
250
    char *          value;
251
 
252
    // from the beginning
253
    name = line;
254
    // skip spaces
255
    while( isspace( * name )) ++ name;
256
    // remember the name start
257
    value = name;
258
    // skip the name
259
    while( isalnum( * value ) || ( * value == '_' )){
260
        // make uppercase
261
//      * value = toupper( * value );
262
        ++ value;
263
    }
264
    if( * value == '=' ){
265
        // terminate the name
266
        * value = '\0';
267
    }else{
268
        // terminate the name
269
        * value = '\0';
270
        // skip until '='
271
        ++ value;
272
        while(( * value ) && ( * value != '=' )) ++ value;
273
        // not found?
274
        if( * value != '=' ) return EINVAL;
275
    }
276
    ++ value;
277
    // skip spaces
278
    while( isspace( * value )) ++ value;
279
    // create a bulk measured string till the end
280
    setting = measured_string_create_bulk( value, -1 );
281
    if( ! setting ) return ENOMEM;
282
    // add the configuration setting
3912 mejdrech 283
    if( ERROR_OCCURRED( measured_strings_add( configuration, name, 0, setting ))){
3666 mejdrech 284
        free( setting );
285
        return ERROR_CODE;
286
    }
287
    return EOK;
288
}
289
*/
290
 
291
int add_configuration( measured_strings_ref configuration, const char * name, const char * value ){
292
    ERROR_DECLARE;
293
 
294
    measured_string_ref setting;
295
 
296
    setting = measured_string_create_bulk( value, 0 );
297
    if( ! setting ) return ENOMEM;
298
    // add the configuration setting
3912 mejdrech 299
    if( ERROR_OCCURRED( measured_strings_add( configuration, name, 0, setting ))){
3666 mejdrech 300
        free( setting );
301
        return ERROR_CODE;
302
    }
303
    return EOK;
304
}
305
 
3846 mejdrech 306
device_id_t generate_new_device_id( void ){
4163 mejdrech 307
    return device_assign_devno();
3666 mejdrech 308
}
309
 
310
int read_configuration( void ){
311
    ERROR_DECLARE;
312
 
4192 mejdrech 313
    // read general configuration
4307 mejdrech 314
    ERROR_PROPAGATE( add_configuration( & net_globals.configuration, "IPV", "4" ));
315
    ERROR_PROPAGATE( add_configuration( & net_globals.configuration, "MTU", "1500" ));
4192 mejdrech 316
    return EOK;
317
}
318
 
319
int start_device( netif_ref netif ){
320
    ERROR_DECLARE;
321
 
3666 mejdrech 322
    measured_string_ref setting;
4163 mejdrech 323
    services_t          internet_service;
324
    int                 irq;
325
    int                 io;
326
    int                 mtu;
3666 mejdrech 327
 
328
    // mandatory netif
4163 mejdrech 329
    setting = measured_strings_find( & netif->configuration, CONF_NETIF, 0 );
4307 mejdrech 330
    netif->driver = get_running_module( & net_globals.modules, setting->value );
3846 mejdrech 331
    if( ! netif->driver ){
4307 mejdrech 332
        printf( "Failed to start the network interface driver %s\n", setting->value );
3666 mejdrech 333
        return EINVAL;
334
    }
4163 mejdrech 335
    // optional network interface layer
336
    setting = measured_strings_find( & netif->configuration, CONF_NIL, 0 );
3666 mejdrech 337
    if( setting ){
4307 mejdrech 338
        netif->nil = get_running_module( & net_globals.modules, setting->value );
3846 mejdrech 339
        if( ! netif->nil ){
4307 mejdrech 340
            printf( "Failed to start the network interface layer %s\n", setting->value );
3666 mejdrech 341
            return EINVAL;
342
        }
343
    }else{
3846 mejdrech 344
        netif->nil = NULL;
3666 mejdrech 345
    }
346
    // mandatory internet layer
4163 mejdrech 347
    setting = measured_strings_find( & netif->configuration, CONF_IL, 0 );
4307 mejdrech 348
    netif->il = get_running_module( & net_globals.modules, setting->value );
3846 mejdrech 349
    if( ! netif->il ){
4307 mejdrech 350
        printf( "Failed to start the internet layer %s\n", setting->value );
3666 mejdrech 351
        return EINVAL;
352
    }
3685 mejdrech 353
    // end of the static loopback initialization
354
    // startup the loopback interface
4163 mejdrech 355
    setting = measured_strings_find( & netif->configuration, CONF_IRQ, 0 );
356
    irq = setting ? strtol( setting->value, NULL, 10 ) : 0;
357
    setting = measured_strings_find( & netif->configuration, CONF_IO, 0 );
358
    io = setting ? strtol( setting->value, NULL, 16 ) : 0;
4243 mejdrech 359
    ERROR_PROPAGATE( netif_probe_req( netif->driver->phone, netif->id, irq, io ));
3846 mejdrech 360
    if( netif->nil ){
4163 mejdrech 361
        setting = measured_strings_find( & netif->configuration, CONF_MTU, 0 );
362
        if( ! setting ){
4307 mejdrech 363
            setting = measured_strings_find( & net_globals.configuration, CONF_MTU, 0 );
4163 mejdrech 364
        }
365
        mtu = setting ? strtol( setting->value, NULL, 10 ) : 0;
4261 mejdrech 366
        ERROR_PROPAGATE( nil_device_req( netif->nil->phone, netif->id, mtu, netif->driver->service ));
3846 mejdrech 367
        internet_service = netif->nil->service;
3685 mejdrech 368
    }else{
3846 mejdrech 369
        internet_service = netif->driver->service;
3685 mejdrech 370
    }
4307 mejdrech 371
    switch( netif->il->service ){
372
        case SERVICE_IP:
373
            ERROR_PROPAGATE( ip_device_req( netif->il->phone, netif->id, internet_service ));
374
            break;
375
        default:
376
            return ENOENT;
377
    }
4243 mejdrech 378
    ERROR_PROPAGATE( netif_start_req( netif->driver->phone, netif->id ));
3666 mejdrech 379
    return EOK;
380
}
381
 
382
int startup( void ){
383
    ERROR_DECLARE;
384
 
4192 mejdrech 385
    char *      conf_files[] = { "lo", "ne2k" };
386
    int         count = sizeof( conf_files ) / sizeof( char * );
387
    int         index;
388
    netif_ref   netif;
389
    int         i;
390
    measured_string_ref setting;
3666 mejdrech 391
 
4192 mejdrech 392
    // TODO dynamic configuration
393
    ERROR_PROPAGATE( read_configuration());
394
 
395
    for( i = 0; i < count; ++ i ){
396
        netif = ( netif_ref ) malloc( sizeof( netif_t ));
397
        if( ! netif ) return ENOMEM;
398
 
399
        netif->id = generate_new_device_id();
400
        if( ! netif->id ) return EXDEV;
401
        ERROR_PROPAGATE( measured_strings_initialize( & netif->configuration ));
402
        // read configuration files
403
        if( ERROR_OCCURRED( read_netif_configuration( conf_files[ i ], netif ))){
404
            measured_strings_destroy( & netif->configuration );
405
            free( netif );
406
            return ERROR_CODE;
407
        }
408
        // mandatory name
409
        setting = measured_strings_find( & netif->configuration, CONF_NAME, 0 );
410
        if( ! setting ){
4307 mejdrech 411
            printf( "The name is missing\n" );
4192 mejdrech 412
            measured_strings_destroy( & netif->configuration );
413
            free( netif );
414
            return EINVAL;
415
        }
416
        netif->name = setting->value;
417
        // add to the netifs map
4307 mejdrech 418
        index = netifs_add( & net_globals.netifs, netif->id, netif );
4192 mejdrech 419
        if( index < 0 ){
420
            measured_strings_destroy( & netif->configuration );
421
            free( netif );
422
            return index;
423
        }
424
        // add to the netif names map
4307 mejdrech 425
        if( ERROR_OCCURRED( char_map_add( & net_globals.netif_names, netif->name, 0, index ))
4192 mejdrech 426
        // start network interfaces and needed modules
427
        || ERROR_OCCURRED( start_device( netif ))){
428
            measured_strings_destroy( & netif->configuration );
4307 mejdrech 429
            netifs_exclude_index( & net_globals.netifs, index );
4192 mejdrech 430
            return ERROR_CODE;
431
        }
432
        // increment modules' usage
433
        ++ netif->driver->usage;
434
        if( netif->nil ) ++ netif->nil->usage;
435
        ++ netif->il->usage;
4307 mejdrech 436
        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 437
    }
3666 mejdrech 438
    return EOK;
439
}
440
 
3466 mejdrech 441
/** @}
442
 */