Changeset 0b749a3 in mainline for uspace/srv/net/nil/eth/eth.c


Ignore:
Timestamp:
2010-11-22T15:39:53Z (13 years ago)
Author:
Vojtech Horky <vojtechhorky@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
0eddb76, aae339e9
Parents:
9a1d8ab (diff), 8cd1aa5e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge development/ changes

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/nil/eth/eth.c

    r9a1d8ab r0b749a3  
    4040#include <mem.h>
    4141#include <stdio.h>
     42#include <byteorder.h>
    4243#include <str.h>
     44#include <errno.h>
    4345
    4446#include <ipc/ipc.h>
     47#include <ipc/net.h>
    4548#include <ipc/services.h>
    4649
    47 #include <net_err.h>
    48 #include <net_messages.h>
    49 #include <net_modules.h>
    50 #include <net_byteorder.h>
     50#include <net/modules.h>
    5151#include <net_checksum.h>
    5252#include <ethernet_lsap.h>
    5353#include <ethernet_protocols.h>
    5454#include <protocol_map.h>
    55 #include <net_device.h>
     55#include <net/device.h>
    5656#include <netif_interface.h>
    5757#include <net_interface.h>
    … …  
    5959#include <il_interface.h>
    6060#include <adt/measured_strings.h>
    61 #include <packet/packet_client.h>
     61#include <packet_client.h>
    6262#include <packet_remote.h>
    6363#include <nil_local.h>
    … …  
    6666#include "eth_header.h"
    6767
    68 /** The module name.
    69  */
     68/** The module name. */
    7069#define NAME  "eth"
    7170
    72 /** Reserved packet prefix length.
    73  */
    74 #define ETH_PREFIX              (sizeof(eth_header_t) + sizeof(eth_header_lsap_t) + sizeof(eth_header_snap_t))
    75 
    76 /** Reserved packet suffix length.
    77  */
    78 #define ETH_SUFFIX              sizeof(eth_fcs_t)
    79 
    80 /** Maximum packet content length.
    81  */
     71/** Reserved packet prefix length. */
     72#define ETH_PREFIX \
     73        (sizeof(eth_header_t) + sizeof(eth_header_lsap_t) + \
     74        sizeof(eth_header_snap_t))
     75
     76/** Reserved packet suffix length. */
     77#define ETH_SUFFIX \
     78        sizeof(eth_fcs_t)
     79
     80/** Maximum packet content length. */
    8281#define ETH_MAX_CONTENT 1500u
    8382
    84 /** Minimum packet content length.
    85  */
     83/** Minimum packet content length. */
    8684#define ETH_MIN_CONTENT 46u
    8785
    88 /** Maximum tagged packet content length.
    89  */
    90 #define ETH_MAX_TAGGED_CONTENT(flags)   (ETH_MAX_CONTENT - ((IS_8023_2_LSAP(flags) || IS_8023_2_SNAP(flags)) ? sizeof(eth_header_lsap_t) : 0) - (IS_8023_2_SNAP(flags) ? sizeof(eth_header_snap_t) : 0))
    91 
    92 /** Minimum tagged packet content length.
    93  */
    94 #define ETH_MIN_TAGGED_CONTENT(flags)   (ETH_MIN_CONTENT - ((IS_8023_2_LSAP(flags) || IS_8023_2_SNAP(flags)) ? sizeof(eth_header_lsap_t) : 0) - (IS_8023_2_SNAP(flags) ? sizeof(eth_header_snap_t) : 0))
    95 
    96 /** Dummy flag shift value.
    97  */
     86/** Maximum tagged packet content length. */
     87#define ETH_MAX_TAGGED_CONTENT(flags) \
     88        (ETH_MAX_CONTENT - \
     89        ((IS_8023_2_LSAP(flags) || IS_8023_2_SNAP(flags)) ? \
     90        sizeof(eth_header_lsap_t) : 0) - \
     91        (IS_8023_2_SNAP(flags) ? sizeof(eth_header_snap_t) : 0))
     92
     93/** Minimum tagged packet content length. */
     94#define ETH_MIN_TAGGED_CONTENT(flags) \
     95        (ETH_MIN_CONTENT - \
     96        ((IS_8023_2_LSAP(flags) || IS_8023_2_SNAP(flags)) ? \
     97        sizeof(eth_header_lsap_t) : 0) - \
     98        (IS_8023_2_SNAP(flags) ? sizeof(eth_header_snap_t) : 0))
     99
     100/** Dummy flag shift value. */
    98101#define ETH_DUMMY_SHIFT 0
    99102
    100 /** Mode flag shift value.
    101  */
     103/** Mode flag shift value. */
    102104#define ETH_MODE_SHIFT  1
    103105
    104106/** Dummy device flag.
    105  *  Preamble and FCS are mandatory part of the packets.
    106  */
    107 #define ETH_DUMMY                               (1 << ETH_DUMMY_SHIFT)
     107 * Preamble and FCS are mandatory part of the packets.
     108 */
     109#define ETH_DUMMY               (1 << ETH_DUMMY_SHIFT)
    108110
    109111/** Returns the dummy flag.
    110  *  @see ETH_DUMMY
    111  */
    112 #define IS_DUMMY(flags)         ((flags) &ETH_DUMMY)
     112 * @see ETH_DUMMY
     113 */
     114#define IS_DUMMY(flags)         ((flags) & ETH_DUMMY)
    113115
    114116/** Device mode flags.
    115  *  @see ETH_DIX
    116  *  @see ETH_8023_2_LSAP
    117  *  @see ETH_8023_2_SNAP
    118  */
    119 #define ETH_MODE_MASK                   (3 << ETH_MODE_SHIFT)
    120 
    121 /** DIX Ethernet mode flag.
    122  */
    123 #define ETH_DIX                                 (1 << ETH_MODE_SHIFT)
     117 * @see ETH_DIX
     118 * @see ETH_8023_2_LSAP
     119 * @see ETH_8023_2_SNAP
     120 */
     121#define ETH_MODE_MASK           (3 << ETH_MODE_SHIFT)
     122
     123/** DIX Ethernet mode flag. */
     124#define ETH_DIX                 (1 << ETH_MODE_SHIFT)
    124125
    125126/** Returns whether the DIX Ethernet mode flag is set.
    126  *  @param[in] flags The ethernet flags.
    127  *  @see ETH_DIX
    128  */
    129 #define IS_DIX(flags)                   (((flags) &ETH_MODE_MASK) == ETH_DIX)
    130 
    131 /** 802.3 + 802.2 + LSAP mode flag.
    132  */
    133 #define ETH_8023_2_LSAP                 (2 << ETH_MODE_SHIFT)
     127 *
     128 * @param[in] flags     The ethernet flags.
     129 * @see ETH_DIX
     130 */
     131#define IS_DIX(flags)           (((flags) & ETH_MODE_MASK) == ETH_DIX)
     132
     133/** 802.3 + 802.2 + LSAP mode flag. */
     134#define ETH_8023_2_LSAP         (2 << ETH_MODE_SHIFT)
    134135
    135136/** Returns whether the 802.3 + 802.2 + LSAP mode flag is set.
    136  *  @param[in] flags The ethernet flags.
    137  *  @see ETH_8023_2_LSAP
    138  */
    139 #define IS_8023_2_LSAP(flags)   (((flags) &ETH_MODE_MASK) == ETH_8023_2_LSAP)
    140 
    141 /** 802.3 + 802.2 + LSAP + SNAP mode flag.
    142  */
    143 #define ETH_8023_2_SNAP                 (3 << ETH_MODE_SHIFT)
     137 *
     138 * @param[in] flags     The ethernet flags.
     139 * @see ETH_8023_2_LSAP
     140 */
     141#define IS_8023_2_LSAP(flags)   (((flags) & ETH_MODE_MASK) == ETH_8023_2_LSAP)
     142
     143/** 802.3 + 802.2 + LSAP + SNAP mode flag. */
     144#define ETH_8023_2_SNAP         (3 << ETH_MODE_SHIFT)
    144145
    145146/** Returns whether the 802.3 + 802.2 + LSAP + SNAP mode flag is set.
    146  *  @param[in] flags The ethernet flags.
    147  *  @see ETH_8023_2_SNAP
    148  */
    149 #define IS_8023_2_SNAP(flags)   (((flags) &ETH_MODE_MASK) == ETH_8023_2_SNAP)
     147 *
     148 * @param[in] flags     The ethernet flags.
     149 * @see ETH_8023_2_SNAP
     150 */
     151#define IS_8023_2_SNAP(flags)   (((flags) & ETH_MODE_MASK) == ETH_8023_2_SNAP)
    150152
    151153/** Type definition of the ethernet address type.
    152  *  @see eth_addr_type
    153  */
    154 typedef enum eth_addr_type      eth_addr_type_t;
    155 
    156 /** Type definition of the ethernet address type pointer.
    157  *  @see eth_addr_type
    158  */
    159 typedef eth_addr_type_t *       eth_addr_type_ref;
    160 
    161 /** Ethernet address type.
    162  */
    163 enum eth_addr_type{
    164         /** Local address.
    165          */
     154 * @see eth_addr_type
     155 */
     156typedef enum eth_addr_type eth_addr_type_t;
     157
     158/** Ethernet address type. */
     159enum eth_addr_type {
     160        /** Local address. */
    166161        ETH_LOCAL_ADDR,
    167         /** Broadcast address.
    168          */
     162        /** Broadcast address. */
    169163        ETH_BROADCAST_ADDR
    170164};
    171165
    172 /** Ethernet module global data.
    173  */
    174 eth_globals_t   eth_globals;
    175 
    176 /** @name Message processing functions
    177  */
    178 /*@{*/
    179 
    180 /** Processes IPC messages from the registered device driver modules in an infinite loop.
    181  *  @param[in] iid The message identifier.
    182  *  @param[in,out] icall The message parameters.
    183  */
    184 void eth_receiver(ipc_callid_t iid, ipc_call_t * icall);
    185 
    186 /** Registers new device or updates the MTU of an existing one.
    187  *  Determines the device local hardware address.
    188  *  @param[in] device_id The new device identifier.
    189  *  @param[in] service The device driver service.
    190  *  @param[in] mtu The device maximum transmission unit.
    191  *  @returns EOK on success.
    192  *  @returns EEXIST if the device with the different service exists.
    193  *  @returns ENOMEM if there is not enough memory left.
    194  *  @returns Other error codes as defined for the net_get_device_conf_req() function.
    195  *  @returns Other error codes as defined for the netif_bind_service() function.
    196  *  @returns Other error codes as defined for the netif_get_addr_req() function.
    197  */
    198 int eth_device_message(device_id_t device_id, services_t service, size_t mtu);
    199 
    200 /** Registers receiving module service.
    201  *  Passes received packets for this service.
    202  *  @param[in] service The module service.
    203  *  @param[in] phone The service phone.
    204  *  @returns EOK on success.
    205  *  @returns ENOENT if the service is not known.
    206  *  @returns ENOMEM if there is not enough memory left.
    207  */
    208 int eth_register_message(services_t service, int phone);
    209 
    210 /** Returns the device packet dimensions for sending.
    211  *  @param[in] device_id The device identifier.
    212  *  @param[out] addr_len The minimum reserved address length.
    213  *  @param[out] prefix The minimum reserved prefix size.
    214  *  @param[out] content The maximum content size.
    215  *  @param[out] suffix The minimum reserved suffix size.
    216  *  @returns EOK on success.
    217  *  @returns EBADMEM if either one of the parameters is NULL.
    218  *  @returns ENOENT if there is no such device.
    219  */
    220 int eth_packet_space_message(device_id_t device_id, size_t * addr_len, size_t * prefix, size_t * content, size_t * suffix);
    221 
    222 /** Returns the device hardware address.
    223  *  @param[in] device_id The device identifier.
    224  *  @param[in] type Type of the desired address.
    225  *  @param[out] address The device hardware address.
    226  *  @returns EOK on success.
    227  *  @returns EBADMEM if the address parameter is NULL.
    228  *  @returns ENOENT if there no such device.
    229  */
    230 int eth_addr_message(device_id_t device_id, eth_addr_type_t type, measured_string_ref * address);
    231 
    232 /** Sends the packet queue.
    233  *  Sends only packet successfully processed by the eth_prepare_packet() function.
    234  *  @param[in] device_id The device identifier.
    235  *  @param[in] packet The packet queue.
    236  *  @param[in] sender The sending module service.
    237  *  @returns EOK on success.
    238  *  @returns ENOENT if there no such device.
    239  *  @returns EINVAL if the service parameter is not known.
    240  */
    241 int eth_send_message(device_id_t device_id, packet_t packet, services_t sender);
    242 
    243 /*@}*/
    244 
    245 /** Processes the received packet and chooses the target registered module.
    246  *  @param[in] flags The device flags.
    247  *  @param[in] packet The packet.
    248  *  @returns The target registered module.
    249  *  @returns NULL if the packet is not long enough.
    250  *  @returns NULL if the packet is too long.
    251  *  @returns NULL if the raw ethernet protocol is used.
    252  *  @returns NULL if the dummy device FCS checksum is invalid.
    253  *  @returns NULL if the packet address length is not big enough.
    254  */
    255 eth_proto_ref eth_process_packet(int flags, packet_t packet);
    256 
    257 /** Prepares the packet for sending.
    258  *  @param[in] flags The device flags.
    259  *  @param[in] packet The packet.
    260  *  @param[in] src_addr The source hardware address.
    261  *  @param[in] ethertype The ethernet protocol type.
    262  *  @param[in] mtu The device maximum transmission unit.
    263  *  @returns EOK on success.
    264  *  @returns EINVAL if the packet addresses length is not long enough.
    265  *  @returns EINVAL if the packet is bigger than the device MTU.
    266  *  @returns ENOMEM if there is not enough memory in the packet.
    267  */
    268 int eth_prepare_packet(int flags, packet_t packet, uint8_t * src_addr, int ethertype, size_t mtu);
    269 
    270 DEVICE_MAP_IMPLEMENT(eth_devices, eth_device_t)
    271 
    272 INT_MAP_IMPLEMENT(eth_protos, eth_proto_t)
    273 
    274 int nil_device_state_msg_local(int nil_phone, device_id_t device_id, int state){
     166/** Ethernet module global data. */
     167eth_globals_t eth_globals;
     168
     169DEVICE_MAP_IMPLEMENT(eth_devices, eth_device_t);
     170INT_MAP_IMPLEMENT(eth_protos, eth_proto_t);
     171
     172int nil_device_state_msg_local(int nil_phone, device_id_t device_id, int state)
     173{
    275174        int index;
    276         eth_proto_ref proto;
     175        eth_proto_t *proto;
    277176
    278177        fibril_rwlock_read_lock(&eth_globals.protos_lock);
    279         for(index = eth_protos_count(&eth_globals.protos) - 1; index >= 0; -- index){
     178        for (index = eth_protos_count(&eth_globals.protos) - 1; index >= 0;
     179            index--) {
    280180                proto = eth_protos_get_index(&eth_globals.protos, index);
    281                 if(proto && proto->phone){
    282                         il_device_state_msg(proto->phone, device_id, state, proto->service);
     181                if (proto && proto->phone) {
     182                        il_device_state_msg(proto->phone, device_id, state,
     183                            proto->service);
    283184                }
    284185        }
    285186        fibril_rwlock_read_unlock(&eth_globals.protos_lock);
     187       
    286188        return EOK;
    287189}
    288190
    289 int nil_initialize(int net_phone){
    290         ERROR_DECLARE;
     191int nil_initialize(int net_phone)
     192{
     193        int rc;
    291194
    292195        fibril_rwlock_initialize(&eth_globals.devices_lock);
    293196        fibril_rwlock_initialize(&eth_globals.protos_lock);
     197       
    294198        fibril_rwlock_write_lock(&eth_globals.devices_lock);
    295199        fibril_rwlock_write_lock(&eth_globals.protos_lock);
    296200        eth_globals.net_phone = net_phone;
    297         eth_globals.broadcast_addr = measured_string_create_bulk("\xFF\xFF\xFF\xFF\xFF\xFF", CONVERT_SIZE(uint8_t, char, ETH_ADDR));
    298         if(! eth_globals.broadcast_addr){
    299                 return ENOMEM;
    300         }
    301         ERROR_PROPAGATE(eth_devices_initialize(&eth_globals.devices));
    302         if(ERROR_OCCURRED(eth_protos_initialize(&eth_globals.protos))){
     201
     202        eth_globals.broadcast_addr =
     203            measured_string_create_bulk("\xFF\xFF\xFF\xFF\xFF\xFF",
     204            CONVERT_SIZE(uint8_t, char, ETH_ADDR));
     205        if (!eth_globals.broadcast_addr) {
     206                rc = ENOMEM;
     207                goto out;
     208        }
     209
     210        rc = eth_devices_initialize(&eth_globals.devices);
     211        if (rc != EOK) {
     212                free(eth_globals.broadcast_addr);
     213                goto out;
     214        }
     215
     216        rc = eth_protos_initialize(&eth_globals.protos);
     217        if (rc != EOK) {
     218                free(eth_globals.broadcast_addr);
    303219                eth_devices_destroy(&eth_globals.devices);
    304                 return ERROR_CODE;
    305         }
     220        }
     221out:
    306222        fibril_rwlock_write_unlock(&eth_globals.protos_lock);
    307223        fibril_rwlock_write_unlock(&eth_globals.devices_lock);
    308         return EOK;
    309 }
    310 
    311 int eth_device_message(device_id_t device_id, services_t service, size_t mtu){
    312         ERROR_DECLARE;
    313 
    314         eth_device_ref device;
     224       
     225        return rc;
     226}
     227
     228/** Processes IPC messages from the registered device driver modules in an
     229 * infinite loop.
     230 *
     231 * @param[in] iid       The message identifier.
     232 * @param[in,out] icall The message parameters.
     233 */
     234static void eth_receiver(ipc_callid_t iid, ipc_call_t *icall)
     235{
     236        packet_t *packet;
     237        int rc;
     238
     239        while (true) {
     240                switch (IPC_GET_METHOD(*icall)) {
     241                case NET_NIL_DEVICE_STATE:
     242                        nil_device_state_msg_local(0, IPC_GET_DEVICE(icall),
     243                            IPC_GET_STATE(icall));
     244                        ipc_answer_0(iid, EOK);
     245                        break;
     246                case NET_NIL_RECEIVED:
     247                        rc = packet_translate_remote(eth_globals.net_phone,
     248                            &packet, IPC_GET_PACKET(icall));
     249                        if (rc == EOK) {
     250                                rc = nil_received_msg_local(0,
     251                                    IPC_GET_DEVICE(icall), packet, 0);
     252                        }
     253                        ipc_answer_0(iid, (ipcarg_t) rc);
     254                        break;
     255                default:
     256                        ipc_answer_0(iid, (ipcarg_t) ENOTSUP);
     257                }
     258               
     259                iid = async_get_call(icall);
     260        }
     261}
     262
     263/** Registers new device or updates the MTU of an existing one.
     264 *
     265 * Determines the device local hardware address.
     266 *
     267 * @param[in] device_id The new device identifier.
     268 * @param[in] service   The device driver service.
     269 * @param[in] mtu       The device maximum transmission unit.
     270 * @return              EOK on success.
     271 * @return              EEXIST if the device with the different service exists.
     272 * @return              ENOMEM if there is not enough memory left.
     273 * @return              Other error codes as defined for the
     274 *                      net_get_device_conf_req() function.
     275 * @return              Other error codes as defined for the
     276 *                      netif_bind_service() function.
     277 * @return              Other error codes as defined for the
     278 *                      netif_get_addr_req() function.
     279 */
     280static int eth_device_message(device_id_t device_id, services_t service,
     281    size_t mtu)
     282{
     283        eth_device_t *device;
    315284        int index;
    316         measured_string_t names[2] = {{str_dup("ETH_MODE"), 8}, {str_dup("ETH_DUMMY"), 9}};
    317         measured_string_ref configuration;
     285        measured_string_t names[2] = {
     286                {
     287                        (char *) "ETH_MODE",
     288                        8
     289                },
     290                {
     291                        (char *) "ETH_DUMMY",
     292                        9
     293                }
     294        };
     295        measured_string_t *configuration;
    318296        size_t count = sizeof(names) / sizeof(measured_string_t);
    319         char * data;
    320         eth_proto_ref proto;
     297        char *data;
     298        eth_proto_t *proto;
     299        int rc;
    321300
    322301        fibril_rwlock_write_lock(&eth_globals.devices_lock);
    323         // an existing device?
     302        /* An existing device? */
    324303        device = eth_devices_find(&eth_globals.devices, device_id);
    325         if(device){
    326                 if(device->service != service){
     304        if (device) {
     305                if (device->service != service) {
    327306                        printf("Device %d already exists\n", device->device_id);
    328307                        fibril_rwlock_write_unlock(&eth_globals.devices_lock);
    329308                        return EEXIST;
    330                 }else{
    331                         // update mtu
    332                         if((mtu > 0) && (mtu <= ETH_MAX_TAGGED_CONTENT(device->flags))){
    333                                 device->mtu = mtu;
    334                         }else{
    335                                  device->mtu = ETH_MAX_TAGGED_CONTENT(device->flags);
     309                }
     310               
     311                /* Update mtu */
     312                if ((mtu > 0) && (mtu <= ETH_MAX_TAGGED_CONTENT(device->flags)))
     313                        device->mtu = mtu;
     314                else
     315                        device->mtu = ETH_MAX_TAGGED_CONTENT(device->flags);
     316               
     317                printf("Device %d already exists:\tMTU\t= %d\n",
     318                    device->device_id, device->mtu);
     319                fibril_rwlock_write_unlock(&eth_globals.devices_lock);
     320               
     321                /* Notify all upper layer modules */
     322                fibril_rwlock_read_lock(&eth_globals.protos_lock);
     323                for (index = 0; index < eth_protos_count(&eth_globals.protos);
     324                    index++) {
     325                        proto = eth_protos_get_index(&eth_globals.protos,
     326                            index);
     327                        if (proto->phone) {
     328                                il_mtu_changed_msg(proto->phone,
     329                                    device->device_id, device->mtu,
     330                                    proto->service);
    336331                        }
    337                         printf("Device %d already exists:\tMTU\t= %d\n", device->device_id, device->mtu);
    338                         fibril_rwlock_write_unlock(&eth_globals.devices_lock);
    339                         // notify all upper layer modules
    340                         fibril_rwlock_read_lock(&eth_globals.protos_lock);
    341                         for(index = 0; index < eth_protos_count(&eth_globals.protos); ++ index){
    342                                 proto = eth_protos_get_index(&eth_globals.protos, index);
    343                                 if (proto->phone){
    344                                         il_mtu_changed_msg(proto->phone, device->device_id, device->mtu, proto->service);
    345                                 }
    346                         }
    347                         fibril_rwlock_read_unlock(&eth_globals.protos_lock);
    348                         return EOK;
    349                 }
    350         }else{
    351                 // create a new device
    352                 device = (eth_device_ref) malloc(sizeof(eth_device_t));
    353                 if(! device){
    354                         return ENOMEM;
    355                 }
    356                 device->device_id = device_id;
    357                 device->service = service;
    358                 device->flags = 0;
    359                 if((mtu > 0) && (mtu <= ETH_MAX_TAGGED_CONTENT(device->flags))){
    360                         device->mtu = mtu;
    361                 }else{
    362                          device->mtu = ETH_MAX_TAGGED_CONTENT(device->flags);
    363                 }
    364                 configuration = &names[0];
    365                 if(ERROR_OCCURRED(net_get_device_conf_req(eth_globals.net_phone, device->device_id, &configuration, count, &data))){
    366                         fibril_rwlock_write_unlock(&eth_globals.devices_lock);
    367                         free(device);
    368                         return ERROR_CODE;
    369                 }
    370                 if(configuration){
    371                         if(! str_lcmp(configuration[0].value, "DIX", configuration[0].length)){
    372                                 device->flags |= ETH_DIX;
    373                         }else if(! str_lcmp(configuration[0].value, "8023_2_LSAP", configuration[0].length)){
    374                                 device->flags |= ETH_8023_2_LSAP;
    375                         }else device->flags |= ETH_8023_2_SNAP;
    376                         if((configuration[1].value) && (configuration[1].value[0] == 'y')){
    377                                 device->flags |= ETH_DUMMY;
    378                         }
    379                         net_free_settings(configuration, data);
    380                 }else{
     332                }
     333
     334                fibril_rwlock_read_unlock(&eth_globals.protos_lock);
     335                return EOK;
     336        }
     337       
     338        /* Create a new device */
     339        device = (eth_device_t *) malloc(sizeof(eth_device_t));
     340        if (!device)
     341                return ENOMEM;
     342
     343        device->device_id = device_id;
     344        device->service = service;
     345        device->flags = 0;
     346        if ((mtu > 0) && (mtu <= ETH_MAX_TAGGED_CONTENT(device->flags)))
     347                device->mtu = mtu;
     348        else
     349                device->mtu = ETH_MAX_TAGGED_CONTENT(device->flags);
     350
     351        configuration = &names[0];
     352        rc = net_get_device_conf_req(eth_globals.net_phone, device->device_id,
     353            &configuration, count, &data);
     354        if (rc != EOK) {
     355                fibril_rwlock_write_unlock(&eth_globals.devices_lock);
     356                free(device);
     357                return rc;
     358        }
     359
     360        if (configuration) {
     361                if (!str_lcmp(configuration[0].value, "DIX",
     362                    configuration[0].length)) {
     363                        device->flags |= ETH_DIX;
     364                } else if(!str_lcmp(configuration[0].value, "8023_2_LSAP",
     365                    configuration[0].length)) {
     366                        device->flags |= ETH_8023_2_LSAP;
     367                } else {
    381368                        device->flags |= ETH_8023_2_SNAP;
    382369                }
    383                 // bind the device driver
    384                 device->phone = netif_bind_service(device->service, device->device_id, SERVICE_ETHERNET, eth_receiver);
    385                 if(device->phone < 0){
    386                         fibril_rwlock_write_unlock(&eth_globals.devices_lock);
    387                         free(device);
    388                         return device->phone;
    389                 }
    390                 // get hardware address
    391                 if(ERROR_OCCURRED(netif_get_addr_req(device->phone, device->device_id, &device->addr, &device->addr_data))){
    392                         fibril_rwlock_write_unlock(&eth_globals.devices_lock);
    393                         free(device);
    394                         return ERROR_CODE;
    395                 }
    396                 // add to the cache
    397                 index = eth_devices_add(&eth_globals.devices, device->device_id, device);
    398                 if(index < 0){
    399                         fibril_rwlock_write_unlock(&eth_globals.devices_lock);
    400                         free(device->addr);
    401                         free(device->addr_data);
    402                         free(device);
    403                         return index;
    404                 }
    405                 printf("%s: Device registered (id: %d, service: %d: mtu: %d, "
    406                     "mac: %x:%x:%x:%x:%x:%x, flags: 0x%x)\n",
    407                     NAME, device->device_id, device->service, device->mtu,
    408                     device->addr_data[0], device->addr_data[1],
    409                     device->addr_data[2], device->addr_data[3],
    410                     device->addr_data[4], device->addr_data[5], device->flags);
    411         }
     370               
     371                if (configuration[1].value &&
     372                    (configuration[1].value[0] == 'y')) {
     373                        device->flags |= ETH_DUMMY;
     374                }
     375                net_free_settings(configuration, data);
     376        } else {
     377                device->flags |= ETH_8023_2_SNAP;
     378        }
     379       
     380        /* Bind the device driver */
     381        device->phone = netif_bind_service(device->service, device->device_id,
     382            SERVICE_ETHERNET, eth_receiver);
     383        if (device->phone < 0) {
     384                fibril_rwlock_write_unlock(&eth_globals.devices_lock);
     385                free(device);
     386                return device->phone;
     387        }
     388       
     389        /* Get hardware address */
     390        rc = netif_get_addr_req(device->phone, device->device_id, &device->addr,
     391            &device->addr_data);
     392        if (rc != EOK) {
     393                fibril_rwlock_write_unlock(&eth_globals.devices_lock);
     394                free(device);
     395                return rc;
     396        }
     397       
     398        /* Add to the cache */
     399        index = eth_devices_add(&eth_globals.devices, device->device_id,
     400            device);
     401        if (index < 0) {
     402                fibril_rwlock_write_unlock(&eth_globals.devices_lock);
     403                free(device->addr);
     404                free(device->addr_data);
     405                free(device);
     406                return index;
     407        }
     408       
     409        printf("%s: Device registered (id: %d, service: %d: mtu: %d, "
     410            "mac: %x:%x:%x:%x:%x:%x, flags: 0x%x)\n",
     411            NAME, device->device_id, device->service, device->mtu,
     412            device->addr_data[0], device->addr_data[1],
     413            device->addr_data[2], device->addr_data[3],
     414            device->addr_data[4], device->addr_data[5], device->flags);
     415
    412416        fibril_rwlock_write_unlock(&eth_globals.devices_lock);
    413417        return EOK;
    414418}
    415419
    416 eth_proto_ref eth_process_packet(int flags, packet_t packet){
    417         ERROR_DECLARE;
    418 
    419         eth_header_snap_ref header;
     420/** Processes the received packet and chooses the target registered module.
     421 *
     422 * @param[in] flags     The device flags.
     423 * @param[in] packet    The packet.
     424 * @return              The target registered module.
     425 * @return              NULL if the packet is not long enough.
     426 * @return              NULL if the packet is too long.
     427 * @return              NULL if the raw ethernet protocol is used.
     428 * @return              NULL if the dummy device FCS checksum is invalid.
     429 * @return              NULL if the packet address length is not big enough.
     430 */
     431static eth_proto_t *eth_process_packet(int flags, packet_t *packet)
     432{
     433        eth_header_snap_t *header;
    420434        size_t length;
    421435        eth_type_t type;
    422436        size_t prefix;
    423437        size_t suffix;
    424         eth_fcs_ref fcs;
    425         uint8_t * data;
     438        eth_fcs_t *fcs;
     439        uint8_t *data;
     440        int rc;
    426441
    427442        length = packet_get_data_length(packet);
    428         if(IS_DUMMY(flags)){
     443       
     444        if (IS_DUMMY(flags))
    429445                packet_trim(packet, sizeof(eth_preamble_t), 0);
    430         }
    431         if(length < sizeof(eth_header_t) + ETH_MIN_CONTENT + (IS_DUMMY(flags) ? ETH_SUFFIX : 0)) return NULL;
     446        if (length < sizeof(eth_header_t) + ETH_MIN_CONTENT +
     447            (IS_DUMMY(flags) ? ETH_SUFFIX : 0))
     448                return NULL;
     449       
    432450        data = packet_get_data(packet);
    433         header = (eth_header_snap_ref) data;
     451        header = (eth_header_snap_t *) data;
    434452        type = ntohs(header->header.ethertype);
    435         if(type >= ETH_MIN_PROTO){
    436                 // DIX Ethernet
     453       
     454        if (type >= ETH_MIN_PROTO) {
     455                /* DIX Ethernet */
    437456                prefix = sizeof(eth_header_t);
    438457                suffix = 0;
    439                 fcs = (eth_fcs_ref) data + length - sizeof(eth_fcs_t);
     458                fcs = (eth_fcs_t *) data + length - sizeof(eth_fcs_t);
    440459                length -= sizeof(eth_fcs_t);
    441         }else if(type <= ETH_MAX_CONTENT){
    442                 // translate "LSAP" values
    443                 if((header->lsap.dsap == ETH_LSAP_GLSAP) && (header->lsap.ssap == ETH_LSAP_GLSAP)){
    444                         // raw packet
    445                         // discard
     460        } else if(type <= ETH_MAX_CONTENT) {
     461                /* Translate "LSAP" values */
     462                if ((header->lsap.dsap == ETH_LSAP_GLSAP) &&
     463                    (header->lsap.ssap == ETH_LSAP_GLSAP)) {
     464                        /* Raw packet -- discard */
    446465                        return NULL;
    447                 }else if((header->lsap.dsap == ETH_LSAP_SNAP) && (header->lsap.ssap == ETH_LSAP_SNAP)){
    448                         // IEEE 802.3 + 802.2 + LSAP + SNAP
    449                         // organization code not supported
     466                } else if((header->lsap.dsap == ETH_LSAP_SNAP) &&
     467                    (header->lsap.ssap == ETH_LSAP_SNAP)) {
     468                        /*
     469                         * IEEE 802.3 + 802.2 + LSAP + SNAP
     470                         * organization code not supported
     471                         */
    450472                        type = ntohs(header->snap.ethertype);
    451                         prefix = sizeof(eth_header_t) + sizeof(eth_header_lsap_t) + sizeof(eth_header_snap_t);
    452                 }else{
    453                         // IEEE 802.3 + 802.2 LSAP
     473                        prefix = sizeof(eth_header_t) +
     474                            sizeof(eth_header_lsap_t) +
     475                            sizeof(eth_header_snap_t);
     476                } else {
     477                        /* IEEE 802.3 + 802.2 LSAP */
    454478                        type = lsap_map(header->lsap.dsap);
    455                         prefix = sizeof(eth_header_t) + sizeof(eth_header_lsap_t);
    456                 }
    457                 suffix = (type < ETH_MIN_CONTENT) ? ETH_MIN_CONTENT - type : 0u;
    458                 fcs = (eth_fcs_ref) data + prefix + type + suffix;
     479                        prefix = sizeof(eth_header_t) +
     480                            sizeof(eth_header_lsap_t);
     481                }
     482
     483                suffix = (type < ETH_MIN_CONTENT) ? ETH_MIN_CONTENT - type : 0U;
     484                fcs = (eth_fcs_t *) data + prefix + type + suffix;
    459485                suffix += length - prefix - type;
    460486                length = prefix + type + suffix;
    461         }else{
    462                 // invalid length/type, should not occurr
     487        } else {
     488                /* Invalid length/type, should not occur */
    463489                return NULL;
    464490        }
    465         if(IS_DUMMY(flags)){
    466                 if((~ compute_crc32(~ 0u, data, length * 8)) != ntohl(*fcs)){
     491       
     492        if (IS_DUMMY(flags)) {
     493                if (~compute_crc32(~0U, data, length * 8) != ntohl(*fcs))
    467494                        return NULL;
    468                 }
    469495                suffix += sizeof(eth_fcs_t);
    470496        }
    471         if(ERROR_OCCURRED(packet_set_addr(packet, header->header.source_address, header->header.destination_address, ETH_ADDR))
    472                 || ERROR_OCCURRED(packet_trim(packet, prefix, suffix))){
     497       
     498        rc = packet_set_addr(packet, header->header.source_address,
     499            header->header.destination_address, ETH_ADDR);
     500        if (rc != EOK)
    473501                return NULL;
    474         }
     502
     503        rc = packet_trim(packet, prefix, suffix);
     504        if (rc != EOK)
     505                return NULL;
     506       
    475507        return eth_protos_find(&eth_globals.protos, type);
    476508}
    477509
    478 int nil_received_msg_local(int nil_phone, device_id_t device_id, packet_t packet, services_t target){
    479         eth_proto_ref proto;
    480         packet_t next;
    481         eth_device_ref device;
     510int nil_received_msg_local(int nil_phone, device_id_t device_id,
     511    packet_t *packet, services_t target)
     512{
     513        eth_proto_t *proto;
     514        packet_t *next;
     515        eth_device_t *device;
    482516        int flags;
    483517
    484518        fibril_rwlock_read_lock(&eth_globals.devices_lock);
    485519        device = eth_devices_find(&eth_globals.devices, device_id);
    486         if(! device){
     520        if (!device) {
    487521                fibril_rwlock_read_unlock(&eth_globals.devices_lock);
    488522                return ENOENT;
    489523        }
     524
    490525        flags = device->flags;
    491526        fibril_rwlock_read_unlock(&eth_globals.devices_lock);
     527       
    492528        fibril_rwlock_read_lock(&eth_globals.protos_lock);
    493         do{
     529        do {
    494530                next = pq_detach(packet);
    495531                proto = eth_process_packet(flags, packet);
    496                 if(proto){
    497                         il_received_msg(proto->phone, device_id, packet, proto->service);
    498                 }else{
     532                if (proto) {
     533                        il_received_msg(proto->phone, device_id, packet,
     534                            proto->service);
     535                } else {
    499536                        // drop invalid/unknown
    500                         pq_release_remote(eth_globals.net_phone, packet_get_id(packet));
     537                        pq_release_remote(eth_globals.net_phone,
     538                            packet_get_id(packet));
    501539                }
    502540                packet = next;
    503         }while(packet);
     541        } while(packet);
     542
    504543        fibril_rwlock_read_unlock(&eth_globals.protos_lock);
    505544        return EOK;
    506545}
    507546
    508 int eth_packet_space_message(device_id_t device_id, size_t * addr_len, size_t * prefix, size_t * content, size_t * suffix){
    509         eth_device_ref device;
    510 
    511         if(!(addr_len && prefix && content && suffix)){
     547/** Returns the device packet dimensions for sending.
     548 *
     549 * @param[in] device_id The device identifier.
     550 * @param[out] addr_len The minimum reserved address length.
     551 * @param[out] prefix   The minimum reserved prefix size.
     552 * @param[out] content  The maximum content size.
     553 * @param[out] suffix   The minimum reserved suffix size.
     554 * @return              EOK on success.
     555 * @return              EBADMEM if either one of the parameters is NULL.
     556 * @return              ENOENT if there is no such device.
     557 */
     558static int eth_packet_space_message(device_id_t device_id, size_t *addr_len,
     559    size_t *prefix, size_t *content, size_t *suffix)
     560{
     561        eth_device_t *device;
     562
     563        if (!addr_len || !prefix || !content || !suffix)
    512564                return EBADMEM;
    513         }
     565       
    514566        fibril_rwlock_read_lock(&eth_globals.devices_lock);
    515567        device = eth_devices_find(&eth_globals.devices, device_id);
    516         if(! device){
     568        if (!device) {
    517569                fibril_rwlock_read_unlock(&eth_globals.devices_lock);
    518570                return ENOENT;
    519571        }
     572
    520573        *content = device->mtu;
    521574        fibril_rwlock_read_unlock(&eth_globals.devices_lock);
     575       
    522576        *addr_len = ETH_ADDR;
    523577        *prefix = ETH_PREFIX;
    524578        *suffix = ETH_MIN_CONTENT + ETH_SUFFIX;
     579
    525580        return EOK;
    526581}
    527582
    528 int eth_addr_message(device_id_t device_id, eth_addr_type_t type, measured_string_ref * address){
    529         eth_device_ref device;
    530 
    531         if(! address){
     583/** Returns the device hardware address.
     584 *
     585 * @param[in] device_id The device identifier.
     586 * @param[in] type      Type of the desired address.
     587 * @param[out] address  The device hardware address.
     588 * @return              EOK on success.
     589 * @return              EBADMEM if the address parameter is NULL.
     590 * @return              ENOENT if there no such device.
     591 */
     592static int eth_addr_message(device_id_t device_id, eth_addr_type_t type,
     593    measured_string_t **address)
     594{
     595        eth_device_t *device;
     596
     597        if (!address)
    532598                return EBADMEM;
    533         }
    534         if(type == ETH_BROADCAST_ADDR){
     599
     600        if (type == ETH_BROADCAST_ADDR) {
    535601                *address = eth_globals.broadcast_addr;
    536         }else{
     602        } else {
    537603                fibril_rwlock_read_lock(&eth_globals.devices_lock);
    538604                device = eth_devices_find(&eth_globals.devices, device_id);
    539                 if(! device){
     605                if (!device) {
    540606                        fibril_rwlock_read_unlock(&eth_globals.devices_lock);
    541607                        return ENOENT;
    … …  
    544610                fibril_rwlock_read_unlock(&eth_globals.devices_lock);
    545611        }
     612       
    546613        return (*address) ? EOK : ENOENT;
    547614}
    548615
    549 int eth_register_message(services_t service, int phone){
    550         eth_proto_ref proto;
     616/** Registers receiving module service.
     617 *
     618 * Passes received packets for this service.
     619 *
     620 * @param[in] service   The module service.
     621 * @param[in] phone     The service phone.
     622 * @return              EOK on success.
     623 * @return              ENOENT if the service is not known.
     624 * @return              ENOMEM if there is not enough memory left.
     625 */
     626static int eth_register_message(services_t service, int phone)
     627{
     628        eth_proto_t *proto;
    551629        int protocol;
    552630        int index;
    553631
    554632        protocol = protocol_map(SERVICE_ETHERNET, service);
    555         if(! protocol){
     633        if (!protocol)
    556634                return ENOENT;
    557         }
     635
    558636        fibril_rwlock_write_lock(&eth_globals.protos_lock);
    559637        proto = eth_protos_find(&eth_globals.protos, protocol);
    560         if(proto){
     638        if (proto) {
    561639                proto->phone = phone;
    562640                fibril_rwlock_write_unlock(&eth_globals.protos_lock);
    563641                return EOK;
    564         }else{
    565                 proto = (eth_proto_ref) malloc(sizeof(eth_proto_t));
    566                 if(! proto){
     642        } else {
     643                proto = (eth_proto_t *) malloc(sizeof(eth_proto_t));
     644                if (!proto) {
    567645                        fibril_rwlock_write_unlock(&eth_globals.protos_lock);
    568646                        return ENOMEM;
    569647                }
     648
    570649                proto->service = service;
    571650                proto->protocol = protocol;
    572651                proto->phone = phone;
     652
    573653                index = eth_protos_add(&eth_globals.protos, protocol, proto);
    574                 if(index < 0){
     654                if (index < 0) {
    575655                        fibril_rwlock_write_unlock(&eth_globals.protos_lock);
    576656                        free(proto);
    … …  
    579659        }
    580660       
    581         printf("%s: Protocol registered (protocol: %d, service: %d, phone: %d)\n",
    582             NAME, proto->protocol, proto->service, proto->phone);
     661        printf("%s: Protocol registered (protocol: %d, service: %d, phone: "
     662            "%d)\n", NAME, proto->protocol, proto->service, proto->phone);
    583663       
    584664        fibril_rwlock_write_unlock(&eth_globals.protos_lock);
    … …  
    586666}
    587667
    588 int eth_prepare_packet(int flags, packet_t packet, uint8_t * src_addr, int ethertype, size_t mtu){
    589         eth_header_snap_ref header;
    590         eth_header_lsap_ref header_lsap;
    591         eth_header_ref header_dix;
    592         eth_fcs_ref fcs;
    593         uint8_t * src;
    594         uint8_t * dest;
     668/** Prepares the packet for sending.
     669 *
     670 * @param[in] flags     The device flags.
     671 * @param[in] packet    The packet.
     672 * @param[in] src_addr  The source hardware address.
     673 * @param[in] ethertype The ethernet protocol type.
     674 * @param[in] mtu       The device maximum transmission unit.
     675 * @return              EOK on success.
     676 * @return              EINVAL if the packet addresses length is not long
     677 *                      enough.
     678 * @return              EINVAL if the packet is bigger than the device MTU.
     679 * @return              ENOMEM if there is not enough memory in the packet.
     680 */
     681static int
     682eth_prepare_packet(int flags, packet_t *packet, uint8_t *src_addr, int ethertype,
     683    size_t mtu)
     684{
     685        eth_header_snap_t *header;
     686        eth_header_lsap_t *header_lsap;
     687        eth_header_t *header_dix;
     688        eth_fcs_t *fcs;
     689        uint8_t *src;
     690        uint8_t *dest;
    595691        size_t length;
    596692        int i;
    597         void * padding;
    598         eth_preamble_ref preamble;
     693        void *padding;
     694        eth_preamble_t *preamble;
    599695
    600696        i = packet_get_addr(packet, &src, &dest);
    601         if(i < 0){
     697        if (i < 0)
    602698                return i;
    603         }
    604         if(i != ETH_ADDR){
     699        if (i != ETH_ADDR)
    605700                return EINVAL;
    606         }
     701
    607702        length = packet_get_data_length(packet);
    608         if(length > mtu){
     703        if (length > mtu)
    609704                return EINVAL;
    610         }
    611         if(length < ETH_MIN_TAGGED_CONTENT(flags)){
    612                 padding = packet_suffix(packet, ETH_MIN_TAGGED_CONTENT(flags) - length);
    613                 if(! padding){
     705       
     706        if (length < ETH_MIN_TAGGED_CONTENT(flags)) {
     707                padding = packet_suffix(packet,
     708                    ETH_MIN_TAGGED_CONTENT(flags) - length);
     709                if (!padding)
    614710                        return ENOMEM;
    615                 }
     711
    616712                bzero(padding, ETH_MIN_TAGGED_CONTENT(flags) - length);
    617713        }
    618         if(IS_DIX(flags)){
     714       
     715        if (IS_DIX(flags)) {
    619716                header_dix = PACKET_PREFIX(packet, eth_header_t);
    620                 if(! header_dix){
     717                if (!header_dix)
    621718                        return ENOMEM;
    622                 }
     719               
    623720                header_dix->ethertype = (uint16_t) ethertype;
    624721                memcpy(header_dix->source_address, src_addr, ETH_ADDR);
    625722                memcpy(header_dix->destination_address, dest, ETH_ADDR);
    626723                src = &header_dix->destination_address[0];
    627         }else if(IS_8023_2_LSAP(flags)){
     724        } else if(IS_8023_2_LSAP(flags)) {
    628725                header_lsap = PACKET_PREFIX(packet, eth_header_lsap_t);
    629                 if(! header_lsap){
     726                if (!header_lsap)
    630727                        return ENOMEM;
    631                 }
    632                 header_lsap->header.ethertype = htons(length + sizeof(eth_header_lsap_t));
     728               
     729                header_lsap->header.ethertype = htons(length +
     730                    sizeof(eth_header_lsap_t));
    633731                header_lsap->lsap.dsap = lsap_unmap(ntohs(ethertype));
    634732                header_lsap->lsap.ssap = header_lsap->lsap.dsap;
    … …  
    637735                memcpy(header_lsap->header.destination_address, dest, ETH_ADDR);
    638736                src = &header_lsap->header.destination_address[0];
    639         }else if(IS_8023_2_SNAP(flags)){
     737        } else if(IS_8023_2_SNAP(flags)) {
    640738                header = PACKET_PREFIX(packet, eth_header_snap_t);
    641                 if(! header){
     739                if (!header)
    642740                        return ENOMEM;
    643                 }
    644                 header->header.ethertype = htons(length + sizeof(eth_header_lsap_t) + sizeof(eth_header_snap_t));
     741               
     742                header->header.ethertype = htons(length +
     743                    sizeof(eth_header_lsap_t) + sizeof(eth_header_snap_t));
    645744                header->lsap.dsap = (uint16_t) ETH_LSAP_SNAP;
    646745                header->lsap.ssap = header->lsap.dsap;
    647746                header->lsap.ctrl = IEEE_8023_2_UI;
    648                 for(i = 0; i < 3; ++ i){
     747               
     748                for (i = 0; i < 3; ++ i)
    649749                        header->snap.protocol[i] = 0;
    650                 }
     750               
    651751                header->snap.ethertype = (uint16_t) ethertype;
    652752                memcpy(header->header.source_address, src_addr, ETH_ADDR);
    … …  
    654754                src = &header->header.destination_address[0];
    655755        }
    656         if(IS_DUMMY(flags)){
     756       
     757        if (IS_DUMMY(flags)) {
    657758                preamble = PACKET_PREFIX(packet, eth_preamble_t);
    658                 if(! preamble){
     759                if (!preamble)
    659760                        return ENOMEM;
    660                 }
    661                 for(i = 0; i < 7; ++ i){
     761               
     762                for (i = 0; i < 7; ++ i)
    662763                        preamble->preamble[i] = ETH_PREAMBLE;
    663                 }
     764               
    664765                preamble->sfd = ETH_SFD;
     766               
    665767                fcs = PACKET_SUFFIX(packet, eth_fcs_t);
    666                 if(! fcs){
     768                if (!fcs)
    667769                        return ENOMEM;
    668                 }
    669                 *fcs = htonl(~ compute_crc32(~ 0u, src, length * 8));
    670         }
     770
     771                *fcs = htonl(~compute_crc32(~0U, src, length * 8));
     772        }
     773       
    671774        return EOK;
    672775}
    673776
    674 int eth_send_message(device_id_t device_id, packet_t packet, services_t sender){
    675         ERROR_DECLARE;
    676 
    677         eth_device_ref device;
    678         packet_t next;
    679         packet_t tmp;
     777/** Sends the packet queue.
     778 *
     779 * Sends only packet successfully processed by the eth_prepare_packet()
     780 * function.
     781 *
     782 * @param[in] device_id The device identifier.
     783 * @param[in] packet    The packet queue.
     784 * @param[in] sender    The sending module service.
     785 * @return              EOK on success.
     786 * @return              ENOENT if there no such device.
     787 * @return              EINVAL if the service parameter is not known.
     788 */
     789static int eth_send_message(device_id_t device_id, packet_t *packet,
     790    services_t sender)
     791{
     792        eth_device_t *device;
     793        packet_t *next;
     794        packet_t *tmp;
    680795        int ethertype;
     796        int rc;
    681797
    682798        ethertype = htons(protocol_map(SERVICE_ETHERNET, sender));
    683         if(! ethertype){
     799        if (!ethertype) {
    684800                pq_release_remote(eth_globals.net_phone, packet_get_id(packet));
    685801                return EINVAL;
    686802        }
     803       
    687804        fibril_rwlock_read_lock(&eth_globals.devices_lock);
    688805        device = eth_devices_find(&eth_globals.devices, device_id);
    689         if(! device){
     806        if (!device) {
    690807                fibril_rwlock_read_unlock(&eth_globals.devices_lock);
    691808                return ENOENT;
    692809        }
    693         // process packet queue
     810       
     811        /* Process packet queue */
    694812        next = packet;
    695         do{
    696                 if(ERROR_OCCURRED(eth_prepare_packet(device->flags, next, (uint8_t *) device->addr->value, ethertype, device->mtu))){
    697                         // release invalid packet
     813        do {
     814                rc = eth_prepare_packet(device->flags, next,
     815                    (uint8_t *) device->addr->value, ethertype, device->mtu);
     816                if (rc != EOK) {
     817                        /* Release invalid packet */
    698818                        tmp = pq_detach(next);
    699                         if(next == packet){
     819                        if (next == packet)
    700820                                packet = tmp;
    701                         }
    702                         pq_release_remote(eth_globals.net_phone, packet_get_id(next));
     821                        pq_release_remote(eth_globals.net_phone,
     822                            packet_get_id(next));
    703823                        next = tmp;
    704                 }else{
     824                } else {
    705825                        next = pq_next(next);
    706826                }
    707         }while(next);
    708         // send packet queue
    709         if(packet){
    710                 netif_send_msg(device->phone, device_id, packet, SERVICE_ETHERNET);
    711         }
     827        } while(next);
     828       
     829        /* Send packet queue */
     830        if (packet) {
     831                netif_send_msg(device->phone, device_id, packet,
     832                    SERVICE_ETHERNET);
     833        }
     834
    712835        fibril_rwlock_read_unlock(&eth_globals.devices_lock);
    713836        return EOK;
    714837}
    715838
    716 int nil_message_standalone(const char *name, ipc_callid_t callid, ipc_call_t *call,
    717     ipc_call_t *answer, int *answer_count)
    718 {
    719         ERROR_DECLARE;
    720        
    721         measured_string_ref address;
    722         packet_t packet;
     839int nil_message_standalone(const char *name, ipc_callid_t callid,
     840    ipc_call_t *call, ipc_call_t *answer, int *answer_count)
     841{
     842        measured_string_t *address;
     843        packet_t *packet;
    723844        size_t addrlen;
    724845        size_t prefix;
    725846        size_t suffix;
    726847        size_t content;
     848        int rc;
    727849       
    728850        *answer_count = 0;
    729851        switch (IPC_GET_METHOD(*call)) {
    730                 case IPC_M_PHONE_HUNGUP:
     852        case IPC_M_PHONE_HUNGUP:
     853                return EOK;
     854       
     855        case NET_NIL_DEVICE:
     856                return eth_device_message(IPC_GET_DEVICE(call),
     857                    IPC_GET_SERVICE(call), IPC_GET_MTU(call));
     858        case NET_NIL_SEND:
     859                rc = packet_translate_remote(eth_globals.net_phone, &packet,
     860                    IPC_GET_PACKET(call));
     861                if (rc != EOK)
     862                        return rc;
     863                return eth_send_message(IPC_GET_DEVICE(call), packet,
     864                    IPC_GET_SERVICE(call));
     865        case NET_NIL_PACKET_SPACE:
     866                rc = eth_packet_space_message(IPC_GET_DEVICE(call), &addrlen,
     867                    &prefix, &content, &suffix);
     868                if (rc != EOK)
     869                        return rc;
     870                IPC_SET_ADDR(answer, addrlen);
     871                IPC_SET_PREFIX(answer, prefix);
     872                IPC_SET_CONTENT(answer, content);
     873                IPC_SET_SUFFIX(answer, suffix);
     874                *answer_count = 4;
     875                return EOK;
     876        case NET_NIL_ADDR:
     877                rc = eth_addr_message(IPC_GET_DEVICE(call), ETH_LOCAL_ADDR,
     878                    &address);
     879                if (rc != EOK)
     880                        return rc;
     881                return measured_strings_reply(address, 1);
     882        case NET_NIL_BROADCAST_ADDR:
     883                rc = eth_addr_message(IPC_GET_DEVICE(call), ETH_BROADCAST_ADDR,
     884                    &address);
     885                if (rc != EOK)
    731886                        return EOK;
    732                 case NET_NIL_DEVICE:
    733                         return eth_device_message(IPC_GET_DEVICE(call),
    734                             IPC_GET_SERVICE(call), IPC_GET_MTU(call));
    735                 case NET_NIL_SEND:
    736                         ERROR_PROPAGATE(packet_translate_remote(eth_globals.net_phone, &packet,
    737                             IPC_GET_PACKET(call)));
    738                         return eth_send_message(IPC_GET_DEVICE(call), packet,
    739                             IPC_GET_SERVICE(call));
    740                 case NET_NIL_PACKET_SPACE:
    741                         ERROR_PROPAGATE(eth_packet_space_message(IPC_GET_DEVICE(call),
    742                             &addrlen, &prefix, &content, &suffix));
    743                         IPC_SET_ADDR(answer, addrlen);
    744                         IPC_SET_PREFIX(answer, prefix);
    745                         IPC_SET_CONTENT(answer, content);
    746                         IPC_SET_SUFFIX(answer, suffix);
    747                         *answer_count = 4;
    748                         return EOK;
    749                 case NET_NIL_ADDR:
    750                         ERROR_PROPAGATE(eth_addr_message(IPC_GET_DEVICE(call),
    751                             ETH_LOCAL_ADDR, &address));
    752                         return measured_strings_reply(address, 1);
    753                 case NET_NIL_BROADCAST_ADDR:
    754                         ERROR_PROPAGATE(eth_addr_message(IPC_GET_DEVICE(call),
    755                             ETH_BROADCAST_ADDR, &address));
    756                         return measured_strings_reply(address, 1);
    757                 case IPC_M_CONNECT_TO_ME:
    758                         return eth_register_message(NIL_GET_PROTO(call),
    759                             IPC_GET_PHONE(call));
     887                return measured_strings_reply(address, 1);
     888        case IPC_M_CONNECT_TO_ME:
     889                return eth_register_message(NIL_GET_PROTO(call),
     890                    IPC_GET_PHONE(call));
    760891        }
    761892       
    … …  
    763894}
    764895
    765 void eth_receiver(ipc_callid_t iid, ipc_call_t * icall){
    766         ERROR_DECLARE;
    767 
    768         packet_t packet;
    769 
    770         while(true){
    771 //              printf("message %d - %d\n", IPC_GET_METHOD(*icall), NET_NIL_FIRST);
    772                 switch(IPC_GET_METHOD(*icall)){
    773                         case NET_NIL_DEVICE_STATE:
    774                                 nil_device_state_msg_local(0, IPC_GET_DEVICE(icall), IPC_GET_STATE(icall));
    775                                 ipc_answer_0(iid, EOK);
    776                                 break;
    777                         case NET_NIL_RECEIVED:
    778                                 if(! ERROR_OCCURRED(packet_translate_remote(eth_globals.net_phone, &packet, IPC_GET_PACKET(icall)))){
    779                                         ERROR_CODE = nil_received_msg_local(0, IPC_GET_DEVICE(icall), packet, 0);
    780                                 }
    781                                 ipc_answer_0(iid, (ipcarg_t) ERROR_CODE);
    782                                 break;
    783                         default:
    784                                 ipc_answer_0(iid, (ipcarg_t) ENOTSUP);
    785                 }
    786                 iid = async_get_call(icall);
    787         }
    788 }
    789 
    790 #ifndef CONFIG_NETIF_NIL_BUNDLE
    791 
    792896/** Default thread for new connections.
    793897 *
    794  * @param[in] iid The initial message identifier.
    795  * @param[in] icall The initial message call structure.
    796  *
     898 * @param[in] iid       The initial message identifier.
     899 * @param[in] icall     The initial message call structure.
    797900 */
    798901static void nil_client_connection(ipc_callid_t iid, ipc_call_t *icall)
    … …  
    804907        ipc_answer_0(iid, EOK);
    805908       
    806         while(true) {
     909        while (true) {
    807910                ipc_call_t answer;
    808911                int answer_count;
    … …  
    816919               
    817920                /* Process the message */
    818                 int res = nil_module_message_standalone(NAME, callid, &call, &answer,
    819                     &answer_count);
    820                
    821                 /* End if said to either by the message or the processing result */
    822                 if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) || (res == EHANGUP))
     921                int res = nil_module_message_standalone(NAME, callid, &call,
     922                    &answer, &answer_count);
     923               
     924                /*
     925                 * End if told to either by the message or the processing
     926                 * result.
     927                 */
     928                if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
     929                    (res == EHANGUP))
    823930                        return;
    824931               
    … …  
    830937int main(int argc, char *argv[])
    831938{
    832         ERROR_DECLARE;
     939        int rc;
    833940       
    834941        /* Start the module */
    835         if (ERROR_OCCURRED(nil_module_start_standalone(nil_client_connection)))
    836                 return ERROR_CODE;
    837        
    838         return EOK;
    839 }
    840 
    841 #endif /* CONFIG_NETIF_NIL_BUNDLE */
     942        rc = nil_module_start_standalone(nil_client_connection);
     943        return rc;
     944}
    842945
    843946/** @}
Note: See TracChangeset for help on using the changeset viewer.