Changeset 00d7e1b in mainline


Ignore:
Timestamp:
2011-10-07T20:20:33Z (12 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
49bd793b
Parents:
e2c50e1
Message:

networking improvements

  • start the networking stack from init
  • add loopback network interface driver (cherrypicked and sanitized from lp:~helenos-nicf/helenos/nicf)
  • add libnic and various small pieces from lp:~helenos-nicf/helenos/nicf
  • fix client side of NIC_GET_ADDRESS
  • net binary overhaul

Note: "ping 127.0.0.1" works, but the first three pings timeout for some reason

Files:
17 added
1 deleted
23 edited

Legend:

Unmodified
Added
Removed
  • boot/Makefile.common

    re2c50e1 r00d7e1b  
    122122        test/test1 \
    123123        test/test2 \
    124         test/test3
     124        test/test3 \
     125        nic/lo
    125126
    126127RD_DRV_CFG =
  • uspace/Makefile

    re2c50e1 r00d7e1b  
    117117        drv/bus/usb/usbmid \
    118118        drv/bus/usb/usbmouse \
    119         drv/bus/usb/vhc
     119        drv/bus/usb/vhc \
     120        drv/nic/lo
    120121
    121122ifeq ($(CONFIG_PCC),y)
     
    181182        lib/fb \
    182183        lib/net \
     184        lib/nic \
    183185        lib/ext2 \
    184186        lib/usb \
  • uspace/Makefile.common

    re2c50e1 r00d7e1b  
    124124LIBDRV_PREFIX = $(LIB_PREFIX)/drv
    125125LIBNET_PREFIX = $(LIB_PREFIX)/net
     126LIBNIC_PREFIX = $(LIB_PREFIX)/nic
    126127LIBMINIX_PREFIX = $(LIB_PREFIX)/minix
    127128
  • uspace/app/init/init.c

    re2c50e1 r00d7e1b  
    306306        srv_start("/srv/s3c24ts");
    307307       
     308        spawn("/srv/net");
     309       
    308310        spawn("/srv/fb");
    309311        spawn("/srv/input");
  • uspace/doc/doxygroups.h

    re2c50e1 r00d7e1b  
    3333
    3434                /**
    35                  * @defgroup netif Network interface drivers
    36                  * @ingroup net
    37                  */
    38 
    39                         /**
    40                          * @defgroup lo Loopback Service
    41                          * @ingroup netif
    42                          */
    43 
    44                         /**
    45                          * @defgroup ne2000 NE2000 network interface service
    46                          * @ingroup netif
     35                 * @defgroup nic Network interface controllers
     36                 * @ingroup net
     37                 */
     38
     39                        /**
     40                         * @defgroup libnic Base NIC framework library
     41                         * @ingroup nic
     42                         */
     43
     44                        /**
     45                         * @defgroup nic_drivers Drivers using the NICF
     46                         * @ingroup nic
    4747                         */
    4848
  • uspace/drv/infrastructure/rootvirt/devices.def

    re2c50e1 r00d7e1b  
    44 * Unless the list is empty, the last item shall be followed by a comma.
    55 */
     6
     7/* Loopback network interface */
     8{
     9    .name = "lo",
     10    .match_id = "virtual&loopback"
     11},
     12
    613#ifdef CONFIG_TEST_DRIVERS
     14
    715{
    816        .name = "test1",
     
    2533        .match_id = "virtual&test3"
    2634},
     35
    2736#endif
     37
    2838#ifdef CONFIG_RUN_VIRTUAL_USB_HC
     39
    2940/* Virtual USB host controller. */
    3041{
     
    3243        .match_id = "usb&hc=vhc"
    3344},
     45
    3446#endif
  • uspace/lib/c/Makefile

    re2c50e1 r00d7e1b  
    6767        generic/devman.c \
    6868        generic/device/hw_res.c \
     69        generic/device/hw_res_parsed.c \
    6970        generic/device/char_dev.c \
    7071        generic/device/nic.c \
     
    104105        generic/adt/list.c \
    105106        generic/adt/hash_table.c \
     107        generic/adt/hash_set.c \
    106108        generic/adt/dynamic_fifo.c \
    107109        generic/adt/measured_strings.c \
  • uspace/lib/c/generic/device/nic.c

    re2c50e1 r00d7e1b  
    137137       
    138138        async_exch_t *exch = async_exchange_begin(dev_sess);
    139        
    140         int rc = async_req_1_0(exch, DEV_IFACE_ID(NIC_DEV_IFACE), NIC_GET_ADDRESS);
    141         if (rc != EOK) {
    142                 async_exchange_end(exch);
    143                 return rc;
    144         }
    145        
    146         rc = async_data_read_start(exch, address, sizeof(nic_address_t));
    147        
    148         async_exchange_end(exch);
    149        
    150         return rc;
     139        aid_t aid = async_send_1(exch, DEV_IFACE_ID(NIC_DEV_IFACE),
     140            NIC_GET_ADDRESS, NULL);
     141        int rc = async_data_read_start(exch, address, sizeof(nic_address_t));
     142        async_exchange_end(exch);
     143       
     144        sysarg_t res;
     145        async_wait_for(aid, &res);
     146       
     147        if (rc != EOK)
     148                return rc;
     149       
     150        return (int) res;
    151151}
    152152
     
    164164       
    165165        async_exch_t *exch = async_exchange_begin(dev_sess);
    166         aid_t message_id = async_send_1(exch, DEV_IFACE_ID(NIC_DEV_IFACE),
     166        aid_t aid = async_send_1(exch, DEV_IFACE_ID(NIC_DEV_IFACE),
    167167            NIC_SET_ADDRESS, NULL);
    168168        int rc = async_data_write_start(exch, address, sizeof(nic_address_t));
     
    170170       
    171171        sysarg_t res;
    172         async_wait_for(message_id, &res);
     172        async_wait_for(aid, &res);
    173173       
    174174        if (rc != EOK)
  • uspace/lib/c/include/net/device.h

    re2c50e1 r00d7e1b  
    4141#include <adt/int_map.h>
    4242#include <net/eth_phys.h>
     43#include <bool.h>
    4344
    4445/** Ethernet address length. */
     
    5152#define ARGSMAC(__a) \
    5253        (__a)[0], (__a)[1], (__a)[2], (__a)[3], (__a)[4], (__a)[5]
     54
     55/* Compare MAC address with specific value */
     56#define MAC_EQUALS_VALUE(__a, __a0, __a1, __a2, __a3, __a4, __a5) \
     57        ((__a)[0] == (__a0) && (__a)[1] == (__a1) && (__a)[2] == (__a2) \
     58        && (__a)[3] == (__a3) && (__a)[4] == (__a4) && (__a)[5] == (__a5))
     59
     60#define MAC_IS_ZERO(__x) \
     61        MAC_EQUALS_VALUE(__x, 0, 0, 0, 0, 0, 0)
    5362
    5463/** Device identifier to generic type map declaration. */
     
    221230} nic_device_stats_t;
    222231
     232/** Errors corresponding to those in the nic_device_stats_t */
     233typedef enum {
     234        NIC_SEC_BUFFER_FULL,
     235        NIC_SEC_ABORTED,
     236        NIC_SEC_CARRIER_LOST,
     237        NIC_SEC_FIFO_OVERRUN,
     238        NIC_SEC_HEARTBEAT,
     239        NIC_SEC_WINDOW_ERROR,
     240        /* Error encountered during TX but with other type of error */
     241        NIC_SEC_OTHER
     242} nic_send_error_cause_t;
     243
     244/** Errors corresponding to those in the nic_device_stats_t */
     245typedef enum {
     246        NIC_REC_BUFFER_FULL,
     247        NIC_REC_LENGTH,
     248        NIC_REC_BUFFER_OVERFLOW,
     249        NIC_REC_CRC,
     250        NIC_REC_FRAME_ALIGNMENT,
     251        NIC_REC_FIFO_OVERRUN,
     252        NIC_REC_MISSED,
     253        /* Error encountered during RX but with other type of error */
     254        NIC_REC_OTHER
     255} nic_receive_error_cause_t;
     256
    223257/**
    224258 * Information about the NIC that never changes - name, vendor, model,
     
    246280
    247281/**
     282 * Type of the ethernet frame
     283 */
     284typedef enum nic_frame_type {
     285        NIC_FRAME_UNICAST,
     286        NIC_FRAME_MULTICAST,
     287        NIC_FRAME_BROADCAST
     288} nic_frame_type_t;
     289
     290/**
    248291 * Specifies which unicast frames is the NIC receiving.
    249292 */
     
    292335
    293336/**
     337 * Structure passed as argument for virtue NIC_WV_MAGIC_PACKET.
     338 */
     339typedef struct nic_wv_magic_packet_data {
     340        uint8_t password[6];
     341} nic_wv_magic_packet_data_t;
     342
     343/**
     344 * Structure passed as argument for virtue NIC_WV_DIRECTED_IPV4
     345 */
     346typedef struct nic_wv_ipv4_data {
     347        uint8_t address[4];
     348} nic_wv_ipv4_data_t;
     349
     350/**
     351 * Structure passed as argument for virtue NIC_WV_DIRECTED_IPV6
     352 */
     353typedef struct nic_wv_ipv6_data {
     354        uint8_t address[16];
     355} nic_wv_ipv6_data_t;
     356
     357/**
    294358 * WOL virtue types defining the interpretation of data passed to the virtue.
    295359 * Those tagged with S can have only single virtue active at one moment, those
     
    376440        NIC_POLL_SOFTWARE_PERIODIC
    377441} nic_poll_mode_t;
     442
     443/**
     444 * Says if this virtue type is a multi-virtue (there can be multiple virtues of
     445 * this type at once).
     446 *
     447 * @param type
     448 *
     449 * @return true or false
     450 */
     451static inline int nic_wv_is_multi(nic_wv_type_t type) {
     452        switch (type) {
     453        case NIC_WV_FULL_MATCH:
     454        case NIC_WV_DESTINATION:
     455        case NIC_WV_DIRECTED_IPV4:
     456        case NIC_WV_DIRECTED_IPV6:
     457                return true;
     458        default:
     459                return false;
     460        }
     461}
    378462
    379463static inline const char *nic_device_state_to_string(nic_device_state_t state)
  • uspace/lib/net/generic/generic.c

    re2c50e1 r00d7e1b  
    7979{
    8080        async_exch_t *exch = async_exchange_begin(sess);
    81         int rc = async_req_2_0(exch, message, (sysarg_t) device_id,
     81        int rc = async_req_3_0(exch, message, (sysarg_t) device_id, 0,
    8282            (sysarg_t) service);
    8383        async_exchange_end(exch);
  • uspace/lib/net/generic/net_checksum.c

    re2c50e1 r00d7e1b  
    4545#define CRC_DIVIDER_LE  0xedb88320
    4646
     47/** Polynomial used in multicast address hashing */
     48#define CRC_MCAST_POLYNOMIAL  0x04c11db6
     49
    4750/** Compacts the computed checksum to the 16 bit number adding the carries.
    4851 *
     
    221224}
    222225
     226/** Compute the standard hash from MAC
     227 *
     228 * Hashing MAC into 64 possible values and using the value as index to
     229 * 64bit number.
     230 *
     231 * The code is copied from qemu-0.13's implementation of ne2000 and rt8139
     232 * drivers, but according to documentation there it originates in FreeBSD.
     233 *
     234 * @param[in] addr The 6-byte MAC address to be hashed
     235 *
     236 * @return 64-bit number with only single bit set to 1
     237 *
     238 */
     239uint64_t multicast_hash(const uint8_t addr[6])
     240{
     241        uint32_t crc;
     242    int carry, i, j;
     243    uint8_t b;
     244
     245    crc = 0xffffffff;
     246    for (i = 0; i < 6; i++) {
     247        b = addr[i];
     248        for (j = 0; j < 8; j++) {
     249            carry = ((crc & 0x80000000L) ? 1 : 0) ^ (b & 0x01);
     250            crc <<= 1;
     251            b >>= 1;
     252            if (carry)
     253                crc = ((crc ^ CRC_MCAST_POLYNOMIAL) | carry);
     254        }
     255    }
     256       
     257    uint64_t one64 = 1;
     258    return one64 << (crc >> 26);
     259}
     260
    223261/** @}
    224262 */
  • uspace/lib/net/il/ip_remote.c

    re2c50e1 r00d7e1b  
    123123 *
    124124 */
    125 int ip_device_req_remote(async_sess_t *sess, nic_device_id_t device_id,
     125int ip_device_req(async_sess_t *sess, nic_device_id_t device_id,
    126126    services_t service)
    127127{
  • uspace/lib/net/include/ip_interface.h

    re2c50e1 r00d7e1b  
    4646#define ip_set_gateway_req     ip_set_gateway_req_remote
    4747#define ip_packet_size_req     ip_packet_size_req_remote
    48 #define ip_device_req          ip_device_req_remote
    4948#define ip_add_route_req       ip_add_route_req_remote
    5049#define ip_send_msg            ip_send_msg_remote
  • uspace/lib/net/include/ip_remote.h

    re2c50e1 r00d7e1b  
    4848extern int ip_received_error_msg_remote(async_sess_t *, nic_device_id_t, packet_t *,
    4949    services_t, services_t);
    50 extern int ip_device_req_remote(async_sess_t *, nic_device_id_t, services_t);
     50extern int ip_device_req(async_sess_t *, nic_device_id_t, services_t);
    5151extern int ip_add_route_req_remote(async_sess_t *, nic_device_id_t, in_addr_t,
    5252    in_addr_t, in_addr_t);
  • uspace/lib/net/include/net_checksum.h

    re2c50e1 r00d7e1b  
    6767extern uint16_t flip_checksum(uint16_t);
    6868extern uint16_t ip_checksum(uint8_t *, size_t);
     69extern uint64_t multicast_hash(const uint8_t addr[6]);
    6970
    7071#endif
  • uspace/lib/net/tl/tl_skel.c

    re2c50e1 r00d7e1b  
    123123                goto out;
    124124       
     125        task_retval(0);
    125126        async_manager();
    126127       
  • uspace/srv/net/il/ip/ip.c

    re2c50e1 r00d7e1b  
    354354        ip_netif->routing = NET_DEFAULT_IP_ROUTING;
    355355        configuration = &names[0];
    356 
     356       
    357357        /* Get configuration */
    358358        rc = net_get_device_conf_req(ip_globals.net_sess, ip_netif->device_id,
     
    406406                        return ENOTSUP;
    407407                }
    408 
     408               
    409409                if (configuration[6].value) {
    410410                        ip_netif->arp = get_running_module(&ip_globals.modules,
     
    417417                        }
    418418                }
     419               
    419420                if (configuration[7].value)
    420421                        ip_netif->routing = (configuration[7].value[0] == 'y');
    421 
     422               
    422423                net_free_settings(configuration, data);
    423424        }
    424 
     425       
    425426        /* Bind netif service which also initializes the device */
    426427        ip_netif->sess = nil_bind_service(ip_netif->service,
     
    432433                return ENOENT;
    433434        }
    434 
     435       
    435436        /* Has to be after the device netif module initialization */
    436437        if (ip_netif->arp) {
     
    448449                }
    449450        }
    450 
     451       
    451452        /* Get packet dimensions */
    452453        rc = nil_packet_size_req(ip_netif->sess, ip_netif->device_id,
     
    461462                ip_netif->packet_dimension.content = IP_MIN_CONTENT;
    462463        }
    463 
     464       
    464465        index = ip_netifs_add(&ip_globals.netifs, ip_netif->device_id, ip_netif);
    465466        if (index < 0)
     
    478479                printf("%s: Default gateway (%s)\n", NAME, defgateway);
    479480        }
    480 
     481       
    481482        return EOK;
    482483}
     
    498499                return rc;
    499500        }
    500 
     501       
    501502        ip_netif->device_id = device_id;
    502503        ip_netif->service = netif;
    503504        ip_netif->state = NIC_STATE_STOPPED;
    504 
     505       
    505506        fibril_rwlock_write_lock(&ip_globals.netifs_lock);
    506507
  • uspace/srv/net/net/Makefile

    re2c50e1 r00d7e1b  
    4343SOURCES = \
    4444        net.c \
    45         net_standalone.c \
    4645        packet_server.c
    4746
  • uspace/srv/net/net/net.c

    re2c50e1 r00d7e1b  
    3030/** @addtogroup net
    3131 * @{
    32  */
    33 
    34 /** @file
    35  * Networking subsystem central module implementation.
    36  *
    3732 */
    3833
     
    5550#include <ipc/ip.h>
    5651#include <ipc/nil.h>
    57 #include <net/modules.h>
    5852#include <net/packet.h>
    5953#include <net/device.h>
     
    7266#include "packet_server.h"
    7367
    74 /** Networking module name. */
    75 #define NAME  "net"
    76 
    7768#define MAX_PATH_LENGTH  1024
    7869
     
    8273GENERIC_CHAR_MAP_IMPLEMENT(measured_strings, measured_string_t);
    8374DEVICE_MAP_IMPLEMENT(netifs, netif_t);
    84 
    85 static int startup(void);
    8675
    8776/** Add the configured setting to the configuration map.
     
    9584 *
    9685 */
    97 int add_configuration(measured_strings_t *configuration, const uint8_t *name,
    98     const uint8_t *value)
     86static int add_configuration(measured_strings_t *configuration,
     87    const uint8_t *name, const uint8_t *value)
    9988{
    10089        int rc;
     
    146135                    (uint8_t *) entry->key, (uint8_t *) entry->value);
    147136                if (rc != EOK) {
    148                         printf("%s: Error processing configuration\n", NAME);
    149137                        cfg_unload(&cfg);
    150138                        return rc;
     
    180168        return read_configuration_file(CONF_DIR, CONF_GENERAL_FILE,
    181169            &net_globals.configuration);
    182 }
    183 
    184 /** Initialize the networking module.
    185  *
    186  * @param[in] client_connection The client connection processing
    187  *                              function. The module skeleton propagates
    188  *                              its own one.
    189  *
    190  * @return EOK on success.
    191  * @return ENOMEM if there is not enough memory left.
    192  *
    193  */
    194 static int net_initialize(async_client_conn_t client_connection)
    195 {
    196         int rc;
    197        
    198         netifs_initialize(&net_globals.netifs);
    199         char_map_initialize(&net_globals.netif_hwpaths);
    200         modules_initialize(&net_globals.modules);
    201         measured_strings_initialize(&net_globals.configuration);
    202        
    203         rc = read_configuration();
    204         if (rc != EOK)
    205                 return rc;
    206        
    207         rc = add_module(NULL, &net_globals.modules, (uint8_t *) ETHERNET_NAME,
    208             (uint8_t *) ETHERNET_FILENAME, SERVICE_ETHERNET, 0, connect_to_service);
    209         if (rc != EOK)
    210                 return rc;
    211        
    212         rc = add_module(NULL, &net_globals.modules, (uint8_t *) NILDUMMY_NAME,
    213             (uint8_t *) NILDUMMY_FILENAME, SERVICE_NILDUMMY, 0, connect_to_service);
    214         if (rc != EOK)
    215                 return rc;
    216        
    217         /* Build specific initialization */
    218         return net_initialize_build(client_connection);
    219 }
    220 
    221 /** Start the networking module.
    222  *
    223  * Initializes the client connection serving function,
    224  * initializes the module, registers the module service
    225  * and starts the async manager, processing IPC messages
    226  * in an infinite loop.
    227  *
    228  * @param[in] client_connection The client connection
    229  *                              processing function. The
    230  *                              module skeleton propagates
    231  *                              its own one.
    232  *
    233  * @return EOK on successful module termination.
    234  * @return Other error codes as defined for the net_initialize() function.
    235  * @return Other error codes as defined for the REGISTER_ME() macro function.
    236  *
    237  */
    238 static int net_module_start(async_client_conn_t client_connection)
    239 {
    240         int rc;
    241        
    242         async_set_client_connection(client_connection);
    243         rc = pm_init();
    244         if (rc != EOK)
    245                 return rc;
    246        
    247         rc = packet_server_init();
    248         if (rc != EOK)
    249                 goto out;
    250        
    251         rc = net_initialize(client_connection);
    252         if (rc != EOK)
    253                 goto out;
    254        
    255         rc = startup();
    256         if (rc != EOK)
    257                 goto out;
    258        
    259         rc = service_register(SERVICE_NETWORKING);
    260         if (rc != EOK)
    261                 goto out;
    262        
    263         task_retval(0);
    264         async_manager();
    265 
    266 out:
    267         pm_destroy();
    268         return rc;
    269170}
    270171
     
    388289static int init_device(netif_t *netif, devman_handle_t handle)
    389290{
     291        printf("%s: Initializing device '%s'\n", NAME, netif->name);
     292       
    390293        netif->handle = handle;
    391294        netif->sess = devman_device_connect(EXCHANGE_SERIALIZE, netif->handle,
     
    459362        }
    460363       
     364        printf("%s: Activating device '%s'\n", NAME, netif->name);
    461365        return nic_set_state(netif->sess, NIC_STATE_ACTIVE);
    462366}
    463367
    464 static int net_driver_port_ready(devman_handle_t handle)
     368static int net_port_ready(devman_handle_t handle)
    465369{
    466370        char hwpath[MAX_PATH_LENGTH];
     
    500404       
    501405        for (size_t i = 0; i < count; i++) {
    502                 rc = net_driver_port_ready(funs[i]);
     406                rc = net_port_ready(funs[i]);
    503407                if (rc != EOK)
    504408                        return rc;
    505409        }
    506410       
    507         return EOK;
    508 }
    509 
    510 /** Read the configuration and start all network interfaces.
    511  *
    512  * @return EOK on success.
    513  * @return EXDEV if there is no available system-unique device identifier.
    514  * @return EINVAL if any of the network interface names are not configured.
    515  * @return ENOMEM if there is not enough memory left.
    516  * @return Other error codes as defined for the read_configuration()
    517  *         function.
    518  * @return Other error codes as defined for the read_netif_configuration()
    519  *         function.
    520  * @return Other error codes as defined for the start_device() function.
    521  *
    522  */
    523 static int startup(void)
    524 {
    525         int rc;
    526        
    527         DIR *config_dir = opendir(CONF_DIR);
    528         if (config_dir == NULL)
    529                 return ENOENT;
    530        
    531         struct dirent *dir_entry;
    532         while ((dir_entry = readdir(config_dir))) {
    533                 if (str_cmp(dir_entry->d_name + str_length(dir_entry->d_name)
    534                         - str_length(CONF_EXT), CONF_EXT) != 0)
    535                         continue;
    536                
    537                 netif_t *netif = (netif_t *) malloc(sizeof(netif_t));
    538                 if (!netif)
    539                         continue;
    540                
    541                 netif->handle = -1;
    542                 netif->sess = NULL;
    543                
    544                 netif->id = generate_new_device_id();
    545                 if (!netif->id) {
    546                         free(netif);
    547                         continue;
    548                 }
    549                
    550                 rc = measured_strings_initialize(&netif->configuration);
    551                 if (rc != EOK) {
    552                         free(netif);
    553                         continue;
    554                 }
    555                
    556                 rc = read_netif_configuration(dir_entry->d_name, netif);
    557                 if (rc != EOK) {
    558                         free(netif);
    559                         continue;
    560                 }
    561                
    562                 /* Mandatory name */
    563                 measured_string_t *name = measured_strings_find(&netif->configuration,
    564                     (uint8_t *) CONF_NAME, 0);
    565                 if (!name) {
    566                         printf("%s: Network interface name is missing\n", NAME);
    567                         measured_strings_destroy(&netif->configuration, free);
    568                         free(netif);
    569                         continue;
    570                 }
    571                
    572                 netif->name = name->value;
    573                
    574                 /* Mandatory hardware path */
    575                 measured_string_t *hwpath = measured_strings_find(
    576                     &netif->configuration, (const uint8_t *) CONF_HWPATH, 0);
    577                 if (!hwpath) {
    578                         measured_strings_destroy(&netif->configuration, free);
    579                         free(netif);
    580                 }
    581                
    582                 /* Add to the netifs map */
    583                 int index = netifs_add(&net_globals.netifs, netif->id, netif);
    584                 if (index < 0) {
    585                         measured_strings_destroy(&netif->configuration, free);
    586                         free(netif);
    587                         continue;
    588                 }
    589                
    590                 /*
    591                  * Add to the hardware paths map and init network interfaces
    592                  * and needed modules.
    593                  */
    594                 rc = char_map_add(&net_globals.netif_hwpaths, hwpath->value, 0, index);
    595                 if (rc != EOK) {
    596                         measured_strings_destroy(&netif->configuration, free);
    597                         netifs_exclude_index(&net_globals.netifs, index, free);
    598                         continue;
    599                 }
    600         }
    601        
    602         closedir(config_dir);
    603411        return EOK;
    604412}
     
    619427 *
    620428 */
    621 int net_message(ipc_callid_t callid, ipc_call_t *call, ipc_call_t *answer,
    622     size_t *answer_count)
     429static int net_message(ipc_callid_t callid, ipc_call_t *call,
     430    ipc_call_t *answer, size_t *answer_count)
    623431{
    624432        measured_string_t *strings;
     
    699507                /* Clear the answer structure */
    700508                ipc_call_t answer;
    701                 size_t answer_count;
    702                 refresh_answer(&answer, &answer_count);
     509                size_t count;
     510                refresh_answer(&answer, &count);
    703511               
    704512                /* Fetch the next message */
     
    707515               
    708516                /* Process the message */
    709                 int res = net_module_message(callid, &call, &answer, &answer_count);
     517                int res;
     518                if (IS_NET_PACKET_MESSAGE(call))
     519                        res = packet_server_message(callid, &call, &answer, &count);
     520                else
     521                        res = net_message(callid, &call, &answer, &count);
    710522               
    711523                /* End if told to either by the message or the processing result */
     
    714526               
    715527                /* Answer the message */
    716                 answer_call(callid, res, &answer, answer_count);
     528                answer_call(callid, res, &answer, count);
    717529        }
    718530}
     
    720532int main(int argc, char *argv[])
    721533{
    722         return net_module_start(net_client_connection);
     534        netifs_initialize(&net_globals.netifs);
     535        char_map_initialize(&net_globals.netif_hwpaths);
     536        modules_initialize(&net_globals.modules);
     537        measured_strings_initialize(&net_globals.configuration);
     538        async_set_client_connection(net_client_connection);
     539       
     540        int rc = pm_init();
     541        if (rc != EOK) {
     542                printf("%s: Unable to initialize packet management\n", NAME);
     543                return rc;
     544        }
     545       
     546        rc = packet_server_init();
     547        if (rc != EOK) {
     548                printf("%s: Unable to initialize packet server\n", NAME);
     549                pm_destroy();
     550                return rc;
     551        }
     552       
     553        rc = read_configuration();
     554        if (rc != EOK) {
     555                printf("%s: Error reading configuration\n", NAME);
     556                pm_destroy();
     557                return rc;
     558        }
     559       
     560        DIR *config_dir = opendir(CONF_DIR);
     561        if (config_dir != NULL) {
     562                struct dirent *dir_entry;
     563                while ((dir_entry = readdir(config_dir))) {
     564                        /* Ignore files without the CONF_EXT extension */
     565                        if ((str_size(dir_entry->d_name) < str_size(CONF_EXT)) ||
     566                            (str_cmp(dir_entry->d_name + str_size(dir_entry->d_name) -
     567                            str_size(CONF_EXT), CONF_EXT) != 0))
     568                                continue;
     569                       
     570                       
     571                        netif_t *netif = (netif_t *) malloc(sizeof(netif_t));
     572                        if (!netif)
     573                                continue;
     574                       
     575                        netif->handle = -1;
     576                        netif->sess = NULL;
     577                       
     578                        netif->id = generate_new_device_id();
     579                        if (!netif->id) {
     580                                free(netif);
     581                                continue;
     582                        }
     583                       
     584                        rc = measured_strings_initialize(&netif->configuration);
     585                        if (rc != EOK) {
     586                                free(netif);
     587                                continue;
     588                        }
     589                       
     590                        rc = read_netif_configuration(dir_entry->d_name, netif);
     591                        if (rc != EOK) {
     592                                printf("%s: Error reading configuration %s\n", NAME,
     593                                    dir_entry->d_name);
     594                                free(netif);
     595                                continue;
     596                        }
     597                       
     598                        measured_string_t *name = measured_strings_find(&netif->configuration,
     599                            (uint8_t *) CONF_NAME, 0);
     600                        if (!name) {
     601                                printf("%s: Network interface name is missing in %s\n",
     602                                    NAME, dir_entry->d_name);
     603                                measured_strings_destroy(&netif->configuration, free);
     604                                free(netif);
     605                                continue;
     606                        }
     607                       
     608                        netif->name = name->value;
     609                       
     610                        /* Mandatory hardware path */
     611                        measured_string_t *hwpath = measured_strings_find(
     612                            &netif->configuration, (const uint8_t *) CONF_HWPATH, 0);
     613                        if (!hwpath) {
     614                                printf("%s: Hardware path is missing in %s\n",
     615                                    NAME, dir_entry->d_name);
     616                                measured_strings_destroy(&netif->configuration, free);
     617                                free(netif);
     618                                continue;
     619                        }
     620                       
     621                        int index = netifs_add(&net_globals.netifs, netif->id, netif);
     622                        if (index < 0) {
     623                                measured_strings_destroy(&netif->configuration, free);
     624                                free(netif);
     625                                continue;
     626                        }
     627                       
     628                        /*
     629                         * Add to the hardware paths map and init network interfaces
     630                         * and needed modules.
     631                         */
     632                        rc = char_map_add(&net_globals.netif_hwpaths, hwpath->value, 0, index);
     633                        if (rc != EOK) {
     634                                measured_strings_destroy(&netif->configuration, free);
     635                                netifs_exclude_index(&net_globals.netifs, index, free);
     636                                continue;
     637                        }
     638                }
     639               
     640                closedir(config_dir);
     641        }
     642       
     643        rc = add_module(NULL, &net_globals.modules, (uint8_t *) ETHERNET_NAME,
     644            (uint8_t *) ETHERNET_FILENAME, SERVICE_ETHERNET, 0, connect_to_service);
     645        if (rc != EOK) {
     646                printf("%s: Error adding module '%s'\n", NAME, ETHERNET_NAME);
     647                pm_destroy();
     648                return rc;
     649        }
     650       
     651        rc = add_module(NULL, &net_globals.modules, (uint8_t *) NILDUMMY_NAME,
     652            (uint8_t *) NILDUMMY_FILENAME, SERVICE_NILDUMMY, 0, connect_to_service);
     653        if (rc != EOK) {
     654                printf("%s: Error adding module '%s'\n", NAME, NILDUMMY_NAME);
     655                pm_destroy();
     656                return rc;
     657        }
     658       
     659        task_id_t task_id = net_spawn((uint8_t *) IP_FILENAME);
     660        if (!task_id) {
     661                printf("%s: Error spawning IP module\n", NAME);
     662                pm_destroy();
     663                return EINVAL;
     664        }
     665       
     666        rc = add_module(NULL, &net_globals.modules, (uint8_t *) IP_NAME,
     667            (uint8_t *) IP_FILENAME, SERVICE_IP, task_id, ip_connect_module);
     668        if (rc != EOK) {
     669                printf("%s: Error adding module '%s'\n", NAME, IP_NAME);
     670                pm_destroy();
     671                return rc;
     672        }
     673       
     674        if (!net_spawn((uint8_t *) "/srv/icmp")) {
     675                printf("%s: Error spawning ICMP module\n", NAME);
     676                pm_destroy();
     677                return EINVAL;
     678        }
     679       
     680        if (!net_spawn((uint8_t *) "/srv/udp")) {
     681                printf("%s: Error spawning UDP module\n", NAME);
     682                pm_destroy();
     683                return EINVAL;
     684        }
     685       
     686        if (!net_spawn((uint8_t *) "/srv/tcp")) {
     687                printf("%s: Error spawning TCP module\n", NAME);
     688                pm_destroy();
     689                return EINVAL;
     690        }
     691       
     692        rc = service_register(SERVICE_NETWORKING);
     693        if (rc != EOK) {
     694                printf("%s: Error registering service\n", NAME);
     695                pm_destroy();
     696                return rc;
     697        }
     698       
     699        task_retval(0);
     700        async_manager();
     701        return 0;
    723702}
    724703
  • uspace/srv/net/net/net.h

    re2c50e1 r00d7e1b  
    3232 */
    3333
    34 /** @file
    35  * Networking subsystem central module.
    36  *
    37  */
    38 
    3934#ifndef NET_NET_H_
    4035#define NET_NET_H_
     
    4843#include <devman.h>
    4944
    50 /** @name Modules definitions
    51  * @{
    52  */
     45#define NAME  "net"
    5346
    5447#define ETHERNET_FILENAME  "/srv/eth"
     
    9588 */
    9689typedef struct {
    97         uint8_t *name;                          /**< System-unique network interface name. */
    98         nic_device_id_t id;             /**< System-unique network interface identifier. */
    99         measured_strings_t configuration;  /**< Configuration. */
     90        /** System-unique network interface name. */
     91        uint8_t *name;
     92        /** System-unique network interface identifier. */
     93        nic_device_id_t id;
     94        /** Configuration. */
     95        measured_strings_t configuration;
    10096       
    10197        /** Serving network interface driver module index. */
    102         devman_handle_t handle;         /**< Handle for devman */
    103         async_sess_t *sess;                     /**< Driver session. */
     98        devman_handle_t handle;  /**< Handle for devman */
     99        async_sess_t *sess;      /**< Driver session. */
    104100       
    105         module_t *nil;   /**< Serving link layer module index. */
    106         module_t *il;    /**< Serving internet layer module index. */
     101        module_t *nil;  /**< Serving link layer module index. */
     102        module_t *il;   /**< Serving internet layer module index. */
    107103} netif_t;
    108104
     
    129125} net_globals_t;
    130126
    131 extern int add_configuration(measured_strings_t *, const uint8_t *,
    132     const uint8_t *);
    133 extern int net_module_message(ipc_callid_t, ipc_call_t *, ipc_call_t *, size_t *);
    134 extern int net_initialize_build(async_client_conn_t);
    135 extern int net_message(ipc_callid_t, ipc_call_t *, ipc_call_t *, size_t *);
    136 
    137127#endif
    138128
  • uspace/srv/net/net/packet_server.h

    re2c50e1 r00d7e1b  
    4343 */
    4444
    45 #ifndef LIBPACKET_PACKET_SERVER_H_
    46 #define LIBPACKET_PACKET_SERVER_H_
     45#ifndef NET_PACKET_SERVER_H_
     46#define NET_PACKET_SERVER_H_
    4747
    4848#include <ipc/common.h>
  • uspace/srv/net/nil/eth/eth.c

    re2c50e1 r00d7e1b  
    629629        }
    630630       
    631         printf("%s: Protocol registered (protocol: %d, service: %d)\n",
     631        printf("%s: Protocol registered (protocol: %d, service: %#x)\n",
    632632            NAME, proto->protocol, proto->service);
    633633       
  • uspace/srv/net/nil/nildummy/nildummy.c

    re2c50e1 r00d7e1b  
    324324        nildummy_globals.proto.sess = sess;
    325325       
    326         printf("%s: Protocol registered (service: %d)\n",
     326        printf("%s: Protocol registered (service: %#x)\n",
    327327            NAME, nildummy_globals.proto.service);
    328328       
Note: See TracChangeset for help on using the changeset viewer.