Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset f2d2c604 in mainline


Ignore:
Timestamp:
2010-10-27T21:51:14Z (11 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master
Children:
069015f2
Parents:
e7f6389 (diff), 0a3fbc7 (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 from lp:~jakub/helenos/net.

Location:
uspace
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/c/generic/adt/measured_strings.c

    re7f6389 rf2d2c604  
    5252 * @param[in] string    The initial character string to be stored.
    5353 * @param[in] length    The length of the given string without the terminating
    54  *                      zero ('/0') character. If the length is zero (0), the
    55  *                      actual length is computed. The given length is used and
    56  *                      appended with the terminating zero ('\\0') character
     54 *                      zero ('\0') character. If the length is zero, the actual
     55 *                      length is computed. The given length is used and
     56 *                      appended with the terminating zero ('\0') character
    5757 *                      otherwise.
    5858 * @returns             The new bundled character string with measured length.
     
    6060 */
    6161measured_string_ref
    62 measured_string_create_bulk(const char * string, size_t length)
     62measured_string_create_bulk(const char *string, size_t length)
    6363{
    6464        measured_string_ref new;
     
    6666        if (length == 0) {
    6767                while (string[length])
    68                         ++length;
     68                        length++;
    6969        }
    7070        new = (measured_string_ref) malloc(sizeof(measured_string_t) +
     
    104104                        new->value[new->length] = '\0';
    105105                        return new;
    106                 } else {
    107                         free(new);
    108106                }
     107                free(new);
    109108        }
    110109
     
    156155                return EINVAL;
    157156        }
    158         if(ERROR_OCCURRED(async_data_write_finalize(callid, lengths,
    159             sizeof(size_t) * (count + 1)))) {
     157        if (ERROR_OCCURRED(async_data_write_finalize(callid, lengths,
     158            length))) {
    160159                free(lengths);
    161160                return ERROR_CODE;
     
    163162
    164163        *data = malloc(lengths[count]);
    165         if (!(*data)) {
     164        if (!*data) {
    166165                free(lengths);
    167166                return ENOMEM;
     
    171170        *strings = (measured_string_ref) malloc(sizeof(measured_string_t) *
    172171            count);
    173         if (!(*strings)) {
     172        if (!*strings) {
    174173                free(lengths);
    175174                free(*data);
     
    178177
    179178        next = *data;
    180         for (index = 0; index < count; ++index) {
     179        for (index = 0; index < count; index++) {
    181180                (*strings)[index].length = lengths[index];
    182181                if (lengths[index] > 0) {
    183                         if ((!async_data_write_receive(&callid, &length)) ||
     182                        if (!async_data_write_receive(&callid, &length) ||
    184183                            (length != lengths[index])) {
    185184                                free(*data);
     
    188187                                return EINVAL;
    189188                        }
    190                         ERROR_PROPAGATE(async_data_write_finalize(callid, next,
    191                             lengths[index]));
     189                        if (ERROR_OCCURRED(async_data_write_finalize(callid,
     190                            next, lengths[index]))) {
     191                                free(*data);
     192                                free(*strings);
     193                                free(lengths);
     194                                return ERROR_CODE;
     195                        }
    192196                        (*strings)[index].value = next;
    193197                        next += lengths[index];
    194                         *next = '\0';
    195                         ++next;
     198                        *next++ = '\0';
    196199                } else {
    197200                        (*strings)[index].value = NULL;
     
    221224
    222225        length = 0;
    223         for (index = 0; index < count; ++ index) {
     226        for (index = 0; index < count; index++) {
    224227                lengths[index] = strings[index].length;
    225228                length += lengths[index] + 1;
     
    262265                return ENOMEM;
    263266
    264         if ((!async_data_read_receive(&callid, &length)) ||
     267        if (!async_data_read_receive(&callid, &length) ||
    265268            (length != sizeof(size_t) * (count + 1))) {
    266269                free(lengths);
    267270                return EINVAL;
    268271        }
    269         if (ERROR_OCCURRED(async_data_read_finalize(callid, lengths,
    270             sizeof(size_t) * (count + 1)))) {
     272        if (ERROR_OCCURRED(async_data_read_finalize(callid, lengths, length))) {
    271273                free(lengths);
    272274                return ERROR_CODE;
     
    274276        free(lengths);
    275277
    276         for (index = 0; index < count; ++ index) {
     278        for (index = 0; index < count; index++) {
    277279                if (strings[index].length > 0) {
    278                         if((!async_data_read_receive(&callid, &length)) ||
     280                        if (!async_data_read_receive(&callid, &length) ||
    279281                            (length != strings[index].length)) {
    280282                                return EINVAL;
     
    317319        char *next;
    318320
    319         if ((phone <= 0) || (!strings) || (!data) || (count <= 0))
     321        if ((phone < 0) || (!strings) || (!data) || (count <= 0))
    320322                return EINVAL;
    321323
     
    331333
    332334        *data = malloc(lengths[count]);
    333         if (!(*data)) {
     335        if (!*data) {
    334336                free(lengths);
    335337                return ENOMEM;
     
    338340        *strings = (measured_string_ref) malloc(sizeof(measured_string_t) *
    339341            count);
    340         if (!(*strings)) {
     342        if (!*strings) {
    341343                free(lengths);
    342344                free(*data);
     
    345347
    346348        next = *data;
    347         for (index = 0; index < count; ++ index) {
     349        for (index = 0; index < count; index++) {
    348350                (*strings)[index].length = lengths[index];
    349351                if (lengths[index] > 0) {
    350                         ERROR_PROPAGATE(async_data_read_start(phone, next,
    351                             lengths[index]));
     352                        if (ERROR_OCCURRED(async_data_read_start(phone, next,
     353                            lengths[index]))) {
     354                                free(lengths);
     355                                free(data);
     356                                free(strings);
     357                                return ERROR_CODE;
     358                        }
    352359                        (*strings)[index].value = next;
    353360                        next += lengths[index];
    354                         *next = '\0';
    355                         ++ next;
     361                        *next++ = '\0';
    356362                } else {
    357363                        (*strings)[index].value = NULL;
     
    386392        size_t index;
    387393
    388         if ((phone <= 0) || (!strings) || (count <= 0))
     394        if ((phone < 0) || (!strings) || (count <= 0))
    389395                return EINVAL;
    390396
     
    401407        free(lengths);
    402408
    403         for (index = 0; index < count; ++index) {
     409        for (index = 0; index < count; index++) {
    404410                if (strings[index].length > 0) {
    405411                        ERROR_PROPAGATE(async_data_write_start(phone,
  • uspace/lib/c/include/adt/measured_strings.h

    re7f6389 rf2d2c604  
    4343
    4444/** Type definition of the character string with measured length.
    45  *  @see measured_string
     45 * @see measured_string
    4646 */
    4747typedef struct measured_string measured_string_t;
    4848
    4949/** Type definition of the character string with measured length pointer.
    50  *  @see measured_string
     50 * @see measured_string
    5151 */
    5252typedef measured_string_t *measured_string_ref;
     
    5959struct measured_string {
    6060        /** Character string data. */
    61         char * value;
     61        char *value;
    6262        /** Character string length. */
    6363        size_t length;
  • uspace/srv/net/nil/eth/eth.c

    re7f6389 rf2d2c604  
    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;
     154 * @see eth_addr_type
     155 */
     156typedef enum eth_addr_type eth_addr_type_t;
    155157
    156158/** 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          */
     159 * @see eth_addr_type
     160 */
     161typedef eth_addr_type_t *eth_addr_type_ref;
     162
     163/** Ethernet address type. */
     164enum eth_addr_type {
     165        /** Local address. */
    166166        ETH_LOCAL_ADDR,
    167         /** Broadcast address.
    168          */
     167        /** Broadcast address. */
    169168        ETH_BROADCAST_ADDR
    170169};
    171170
    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){
     171/** Ethernet module global data. */
     172eth_globals_t eth_globals;
     173
     174DEVICE_MAP_IMPLEMENT(eth_devices, eth_device_t);
     175INT_MAP_IMPLEMENT(eth_protos, eth_proto_t);
     176
     177int nil_device_state_msg_local(int nil_phone, device_id_t device_id, int state)
     178{
    275179        int index;
    276180        eth_proto_ref proto;
    277181
    278182        fibril_rwlock_read_lock(&eth_globals.protos_lock);
    279         for(index = eth_protos_count(&eth_globals.protos) - 1; index >= 0; -- index){
     183        for (index = eth_protos_count(&eth_globals.protos) - 1; index >= 0;
     184            index--) {
    280185                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);
     186                if (proto && proto->phone) {
     187                        il_device_state_msg(proto->phone, device_id, state,
     188                            proto->service);
    283189                }
    284190        }
    285191        fibril_rwlock_read_unlock(&eth_globals.protos_lock);
     192       
    286193        return EOK;
    287194}
    288195
    289 int nil_initialize(int net_phone){
     196int nil_initialize(int net_phone)
     197{
    290198        ERROR_DECLARE;
    291199
    292200        fibril_rwlock_initialize(&eth_globals.devices_lock);
    293201        fibril_rwlock_initialize(&eth_globals.protos_lock);
     202       
    294203        fibril_rwlock_write_lock(&eth_globals.devices_lock);
    295204        fibril_rwlock_write_lock(&eth_globals.protos_lock);
    296205        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))){
     206        eth_globals.broadcast_addr =
     207            measured_string_create_bulk("\xFF\xFF\xFF\xFF\xFF\xFF",
     208            CONVERT_SIZE(uint8_t, char, ETH_ADDR));
     209        if (!eth_globals.broadcast_addr) {
     210                ERROR_CODE = ENOMEM;
     211                goto out;
     212        }
     213        if (ERROR_OCCURRED(eth_devices_initialize(&eth_globals.devices))) {
     214                free(eth_globals.broadcast_addr);
     215                goto out;
     216        }
     217        if (ERROR_OCCURRED(eth_protos_initialize(&eth_globals.protos))) {
     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){
     224       
     225        return ERROR_CODE;
     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        ERROR_DECLARE;
     237
     238        packet_t packet;
     239
     240        while (true) {
     241                switch (IPC_GET_METHOD(*icall)) {
     242                case NET_NIL_DEVICE_STATE:
     243                        nil_device_state_msg_local(0, IPC_GET_DEVICE(icall),
     244                            IPC_GET_STATE(icall));
     245                        ipc_answer_0(iid, EOK);
     246                        break;
     247                case NET_NIL_RECEIVED:
     248                        if (ERROR_NONE(packet_translate_remote(
     249                            eth_globals.net_phone, &packet,
     250                            IPC_GET_PACKET(icall)))) {
     251                                ERROR_CODE = nil_received_msg_local(0,
     252                                    IPC_GET_DEVICE(icall), packet, 0);
     253                        }
     254                        ipc_answer_0(iid, (ipcarg_t) ERROR_CODE);
     255                        break;
     256                default:
     257                        ipc_answer_0(iid, (ipcarg_t) ENOTSUP);
     258                }
     259               
     260                iid = async_get_call(icall);
     261        }
     262}
     263
     264/** Registers new device or updates the MTU of an existing one.
     265 *
     266 * Determines the device local hardware address.
     267 *
     268 * @param[in] device_id The new device identifier.
     269 * @param[in] service   The device driver service.
     270 * @param[in] mtu       The device maximum transmission unit.
     271 * @returns             EOK on success.
     272 * @returns             EEXIST if the device with the different service exists.
     273 * @returns             ENOMEM if there is not enough memory left.
     274 * @returns             Other error codes as defined for the
     275 *                      net_get_device_conf_req() function.
     276 * @returns             Other error codes as defined for the
     277 *                      netif_bind_service() function.
     278 * @returns             Other error codes as defined for the
     279 *                      netif_get_addr_req() function.
     280 */
     281static int
     282eth_device_message(device_id_t device_id, services_t service, size_t mtu)
     283{
    312284        ERROR_DECLARE;
    313285
    314286        eth_device_ref device;
    315287        int index;
    316         measured_string_t names[2] = {{str_dup("ETH_MODE"), 8}, {str_dup("ETH_DUMMY"), 9}};
     288        measured_string_t names[2] = {
     289                {
     290                        (char *) "ETH_MODE",
     291                        8
     292                },
     293                {
     294                        (char *) "ETH_DUMMY",
     295                        9
     296                }
     297        };
    317298        measured_string_ref configuration;
    318299        size_t count = sizeof(names) / sizeof(measured_string_t);
    319         char * data;
     300        char *data;
    320301        eth_proto_ref proto;
    321302
     
    323304        // an existing device?
    324305        device = eth_devices_find(&eth_globals.devices, device_id);
    325         if(device){
    326                 if(device->service != service){
     306        if (device) {
     307                if (device->service != service) {
    327308                        printf("Device %d already exists\n", device->device_id);
    328309                        fibril_rwlock_write_unlock(&eth_globals.devices_lock);
    329310                        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);
     311                }
     312               
     313                // update mtu
     314                if ((mtu > 0) && (mtu <= ETH_MAX_TAGGED_CONTENT(device->flags)))
     315                        device->mtu = mtu;
     316                else
     317                        device->mtu = ETH_MAX_TAGGED_CONTENT(device->flags);
     318               
     319                printf("Device %d already exists:\tMTU\t= %d\n",
     320                    device->device_id, device->mtu);
     321                fibril_rwlock_write_unlock(&eth_globals.devices_lock);
     322               
     323                // notify all upper layer modules
     324                fibril_rwlock_read_lock(&eth_globals.protos_lock);
     325                for (index = 0; index < eth_protos_count(&eth_globals.protos);
     326                    index++) {
     327                        proto = eth_protos_get_index(&eth_globals.protos,
     328                            index);
     329                        if (proto->phone) {
     330                                il_mtu_changed_msg(proto->phone,
     331                                    device->device_id, device->mtu,
     332                                    proto->service);
    336333                        }
    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{
     334                }
     335                fibril_rwlock_read_unlock(&eth_globals.protos_lock);
     336                return EOK;
     337        }
     338       
     339        // create a new device
     340        device = (eth_device_ref) malloc(sizeof(eth_device_t));
     341        if (!device)
     342                return ENOMEM;
     343
     344        device->device_id = device_id;
     345        device->service = service;
     346        device->flags = 0;
     347        if ((mtu > 0) && (mtu <= ETH_MAX_TAGGED_CONTENT(device->flags)))
     348                device->mtu = mtu;
     349        else
     350                device->mtu = ETH_MAX_TAGGED_CONTENT(device->flags);
     351
     352        configuration = &names[0];
     353        if (ERROR_OCCURRED(net_get_device_conf_req(eth_globals.net_phone,
     354            device->device_id, &configuration, count, &data))) {
     355                fibril_rwlock_write_unlock(&eth_globals.devices_lock);
     356                free(device);
     357                return ERROR_CODE;
     358        }
     359        if (configuration) {
     360                if (!str_lcmp(configuration[0].value, "DIX",
     361                    configuration[0].length)) {
     362                        device->flags |= ETH_DIX;
     363                } else if(!str_lcmp(configuration[0].value, "8023_2_LSAP",
     364                    configuration[0].length)) {
     365                        device->flags |= ETH_8023_2_LSAP;
     366                } else {
    381367                        device->flags |= ETH_8023_2_SNAP;
    382368                }
    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         }
     369               
     370                if (configuration[1].value &&
     371                    (configuration[1].value[0] == 'y')) {
     372                        device->flags |= ETH_DUMMY;
     373                }
     374                net_free_settings(configuration, data);
     375        } else {
     376                device->flags |= ETH_8023_2_SNAP;
     377        }
     378       
     379        // bind the device driver
     380        device->phone = netif_bind_service(device->service, device->device_id,
     381            SERVICE_ETHERNET, eth_receiver);
     382        if (device->phone < 0) {
     383                fibril_rwlock_write_unlock(&eth_globals.devices_lock);
     384                free(device);
     385                return device->phone;
     386        }
     387       
     388        // get hardware address
     389        if (ERROR_OCCURRED(netif_get_addr_req(device->phone, device->device_id,
     390            &device->addr, &device->addr_data))) {
     391                fibril_rwlock_write_unlock(&eth_globals.devices_lock);
     392                free(device);
     393                return ERROR_CODE;
     394        }
     395       
     396        // add to the cache
     397        index = eth_devices_add(&eth_globals.devices, device->device_id,
     398            device);
     399        if (index < 0) {
     400                fibril_rwlock_write_unlock(&eth_globals.devices_lock);
     401                free(device->addr);
     402                free(device->addr_data);
     403                free(device);
     404                return index;
     405        }
     406       
     407        printf("%s: Device registered (id: %d, service: %d: mtu: %d, "
     408            "mac: %x:%x:%x:%x:%x:%x, flags: 0x%x)\n",
     409            NAME, device->device_id, device->service, device->mtu,
     410            device->addr_data[0], device->addr_data[1],
     411            device->addr_data[2], device->addr_data[3],
     412            device->addr_data[4], device->addr_data[5], device->flags);
     413
    412414        fibril_rwlock_write_unlock(&eth_globals.devices_lock);
    413415        return EOK;
    414416}
    415417
    416 eth_proto_ref eth_process_packet(int flags, packet_t packet){
     418/** Processes the received packet and chooses the target registered module.
     419 *
     420 * @param[in] flags     The device flags.
     421 * @param[in] packet    The packet.
     422 * @returns             The target registered module.
     423 * @returns             NULL if the packet is not long enough.
     424 * @returns             NULL if the packet is too long.
     425 * @returns             NULL if the raw ethernet protocol is used.
     426 * @returns             NULL if the dummy device FCS checksum is invalid.
     427 * @returns             NULL if the packet address length is not big enough.
     428 */
     429static eth_proto_ref eth_process_packet(int flags, packet_t packet)
     430{
    417431        ERROR_DECLARE;
    418432
     
    426440
    427441        length = packet_get_data_length(packet);
    428         if(IS_DUMMY(flags)){
     442       
     443        if (IS_DUMMY(flags))
    429444                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;
     445        if (length < sizeof(eth_header_t) + ETH_MIN_CONTENT +
     446            (IS_DUMMY(flags) ? ETH_SUFFIX : 0))
     447                return NULL;
     448       
    432449        data = packet_get_data(packet);
    433450        header = (eth_header_snap_ref) data;
    434451        type = ntohs(header->header.ethertype);
    435         if(type >= ETH_MIN_PROTO){
     452       
     453        if (type >= ETH_MIN_PROTO) {
    436454                // DIX Ethernet
    437455                prefix = sizeof(eth_header_t);
     
    439457                fcs = (eth_fcs_ref) data + length - sizeof(eth_fcs_t);
    440458                length -= sizeof(eth_fcs_t);
    441         }else if(type <= ETH_MAX_CONTENT){
     459        } else if(type <= ETH_MAX_CONTENT) {
    442460                // translate "LSAP" values
    443                 if((header->lsap.dsap == ETH_LSAP_GLSAP) && (header->lsap.ssap == ETH_LSAP_GLSAP)){
     461                if ((header->lsap.dsap == ETH_LSAP_GLSAP) &&
     462                    (header->lsap.ssap == ETH_LSAP_GLSAP)) {
    444463                        // raw packet
    445464                        // discard
    446465                        return NULL;
    447                 }else if((header->lsap.dsap == ETH_LSAP_SNAP) && (header->lsap.ssap == ETH_LSAP_SNAP)){
     466                } else if((header->lsap.dsap == ETH_LSAP_SNAP) &&
     467                    (header->lsap.ssap == ETH_LSAP_SNAP)) {
    448468                        // IEEE 802.3 + 802.2 + LSAP + SNAP
    449469                        // organization code not supported
    450470                        type = ntohs(header->snap.ethertype);
    451                         prefix = sizeof(eth_header_t) + sizeof(eth_header_lsap_t) + sizeof(eth_header_snap_t);
    452                 }else{
     471                        prefix = sizeof(eth_header_t) +
     472                            sizeof(eth_header_lsap_t) +
     473                            sizeof(eth_header_snap_t);
     474                } else {
    453475                        // IEEE 802.3 + 802.2 LSAP
    454476                        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;
     477                        prefix = sizeof(eth_header_t) +
     478                            sizeof(eth_header_lsap_t);
     479                }
     480                suffix = (type < ETH_MIN_CONTENT) ? ETH_MIN_CONTENT - type : 0U;
    458481                fcs = (eth_fcs_ref) data + prefix + type + suffix;
    459482                suffix += length - prefix - type;
    460483                length = prefix + type + suffix;
    461         }else{
     484        } else {
    462485                // invalid length/type, should not occurr
    463486                return NULL;
    464487        }
    465         if(IS_DUMMY(flags)){
    466                 if((~ compute_crc32(~ 0u, data, length * 8)) != ntohl(*fcs)){
     488       
     489        if (IS_DUMMY(flags)) {
     490                if ((~compute_crc32(~0U, data, length * 8)) != ntohl(*fcs))
    467491                        return NULL;
    468                 }
    469492                suffix += sizeof(eth_fcs_t);
    470493        }
    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))){
     494       
     495        if (ERROR_OCCURRED(packet_set_addr(packet,
     496            header->header.source_address, header->header.destination_address,
     497            ETH_ADDR)) || ERROR_OCCURRED(packet_trim(packet, prefix, suffix))) {
    473498                return NULL;
    474499        }
     500       
    475501        return eth_protos_find(&eth_globals.protos, type);
    476502}
    477503
    478 int nil_received_msg_local(int nil_phone, device_id_t device_id, packet_t packet, services_t target){
     504int
     505nil_received_msg_local(int nil_phone, device_id_t device_id, packet_t packet,
     506    services_t target)
     507{
    479508        eth_proto_ref proto;
    480509        packet_t next;
     
    484513        fibril_rwlock_read_lock(&eth_globals.devices_lock);
    485514        device = eth_devices_find(&eth_globals.devices, device_id);
    486         if(! device){
     515        if (!device) {
    487516                fibril_rwlock_read_unlock(&eth_globals.devices_lock);
    488517                return ENOENT;
     
    490519        flags = device->flags;
    491520        fibril_rwlock_read_unlock(&eth_globals.devices_lock);
     521       
    492522        fibril_rwlock_read_lock(&eth_globals.protos_lock);
    493         do{
     523        do {
    494524                next = pq_detach(packet);
    495525                proto = eth_process_packet(flags, packet);
    496                 if(proto){
    497                         il_received_msg(proto->phone, device_id, packet, proto->service);
    498                 }else{
     526                if (proto) {
     527                        il_received_msg(proto->phone, device_id, packet,
     528                            proto->service);
     529                } else {
    499530                        // drop invalid/unknown
    500                         pq_release_remote(eth_globals.net_phone, packet_get_id(packet));
     531                        pq_release_remote(eth_globals.net_phone,
     532                            packet_get_id(packet));
    501533                }
    502534                packet = next;
    503         }while(packet);
     535        } while(packet);
    504536        fibril_rwlock_read_unlock(&eth_globals.protos_lock);
     537       
    505538        return EOK;
    506539}
    507540
    508 int eth_packet_space_message(device_id_t device_id, size_t * addr_len, size_t * prefix, size_t * content, size_t * suffix){
     541/** Returns the device packet dimensions for sending.
     542 *
     543 * @param[in] device_id The device identifier.
     544 * @param[out] addr_len The minimum reserved address length.
     545 * @param[out] prefix   The minimum reserved prefix size.
     546 * @param[out] content  The maximum content size.
     547 * @param[out] suffix   The minimum reserved suffix size.
     548 * @returns             EOK on success.
     549 * @returns             EBADMEM if either one of the parameters is NULL.
     550 * @returns             ENOENT if there is no such device.
     551 */
     552static int
     553eth_packet_space_message(device_id_t device_id, size_t *addr_len,
     554    size_t *prefix, size_t *content, size_t *suffix)
     555{
    509556        eth_device_ref device;
    510557
    511         if(!(addr_len && prefix && content && suffix)){
     558        if (!addr_len || !prefix || !content || !suffix)
    512559                return EBADMEM;
    513         }
     560       
    514561        fibril_rwlock_read_lock(&eth_globals.devices_lock);
    515562        device = eth_devices_find(&eth_globals.devices, device_id);
    516         if(! device){
     563        if (!device) {
    517564                fibril_rwlock_read_unlock(&eth_globals.devices_lock);
    518565                return ENOENT;
     
    520567        *content = device->mtu;
    521568        fibril_rwlock_read_unlock(&eth_globals.devices_lock);
     569       
    522570        *addr_len = ETH_ADDR;
    523571        *prefix = ETH_PREFIX;
     
    526574}
    527575
    528 int eth_addr_message(device_id_t device_id, eth_addr_type_t type, measured_string_ref * address){
     576/** Returns the device hardware address.
     577 *
     578 * @param[in] device_id The device identifier.
     579 * @param[in] type      Type of the desired address.
     580 * @param[out] address  The device hardware address.
     581 * @returns             EOK on success.
     582 * @returns             EBADMEM if the address parameter is NULL.
     583 * @returns             ENOENT if there no such device.
     584 */
     585static int
     586eth_addr_message(device_id_t device_id, eth_addr_type_t type,
     587    measured_string_ref *address)
     588{
    529589        eth_device_ref device;
    530590
    531         if(! address){
     591        if (!address)
    532592                return EBADMEM;
    533         }
    534         if(type == ETH_BROADCAST_ADDR){
     593
     594        if (type == ETH_BROADCAST_ADDR) {
    535595                *address = eth_globals.broadcast_addr;
    536         }else{
     596        } else {
    537597                fibril_rwlock_read_lock(&eth_globals.devices_lock);
    538598                device = eth_devices_find(&eth_globals.devices, device_id);
    539                 if(! device){
     599                if (!device) {
    540600                        fibril_rwlock_read_unlock(&eth_globals.devices_lock);
    541601                        return ENOENT;
     
    544604                fibril_rwlock_read_unlock(&eth_globals.devices_lock);
    545605        }
     606       
    546607        return (*address) ? EOK : ENOENT;
    547608}
    548609
    549 int eth_register_message(services_t service, int phone){
     610/** Registers receiving module service.
     611 *
     612 * Passes received packets for this service.
     613 *
     614 * @param[in] service   The module service.
     615 * @param[in] phone     The service phone.
     616 * @returns             EOK on success.
     617 * @returns             ENOENT if the service is not known.
     618 * @returns             ENOMEM if there is not enough memory left.
     619 */
     620static int eth_register_message(services_t service, int phone)
     621{
    550622        eth_proto_ref proto;
    551623        int protocol;
     
    553625
    554626        protocol = protocol_map(SERVICE_ETHERNET, service);
    555         if(! protocol){
     627        if (!protocol)
    556628                return ENOENT;
    557         }
     629
    558630        fibril_rwlock_write_lock(&eth_globals.protos_lock);
    559631        proto = eth_protos_find(&eth_globals.protos, protocol);
    560         if(proto){
     632        if (proto) {
    561633                proto->phone = phone;
    562634                fibril_rwlock_write_unlock(&eth_globals.protos_lock);
    563635                return EOK;
    564         }else{
     636        } else {
    565637                proto = (eth_proto_ref) malloc(sizeof(eth_proto_t));
    566                 if(! proto){
     638                if (!proto) {
    567639                        fibril_rwlock_write_unlock(&eth_globals.protos_lock);
    568640                        return ENOMEM;
     
    572644                proto->phone = phone;
    573645                index = eth_protos_add(&eth_globals.protos, protocol, proto);
    574                 if(index < 0){
     646                if (index < 0) {
    575647                        fibril_rwlock_write_unlock(&eth_globals.protos_lock);
    576648                        free(proto);
     
    579651        }
    580652       
    581         printf("%s: Protocol registered (protocol: %d, service: %d, phone: %d)\n",
    582             NAME, proto->protocol, proto->service, proto->phone);
     653        printf("%s: Protocol registered (protocol: %d, service: %d, phone: "
     654            "%d)\n", NAME, proto->protocol, proto->service, proto->phone);
    583655       
    584656        fibril_rwlock_write_unlock(&eth_globals.protos_lock);
     
    586658}
    587659
    588 int eth_prepare_packet(int flags, packet_t packet, uint8_t * src_addr, int ethertype, size_t mtu){
     660/** Prepares the packet for sending.
     661 *
     662 * @param[in] flags     The device flags.
     663 * @param[in] packet    The packet.
     664 * @param[in] src_addr  The source hardware address.
     665 * @param[in] ethertype The ethernet protocol type.
     666 * @param[in] mtu       The device maximum transmission unit.
     667 * @returns             EOK on success.
     668 * @returns             EINVAL if the packet addresses length is not long
     669 *                      enough.
     670 * @returns             EINVAL if the packet is bigger than the device MTU.
     671 * @returns             ENOMEM if there is not enough memory in the packet.
     672 */
     673static int
     674eth_prepare_packet(int flags, packet_t packet, uint8_t *src_addr, int ethertype,
     675    size_t mtu)
     676{
    589677        eth_header_snap_ref header;
    590678        eth_header_lsap_ref header_lsap;
    591679        eth_header_ref header_dix;
    592680        eth_fcs_ref fcs;
    593         uint8_t * src;
    594         uint8_t * dest;
     681        uint8_t *src;
     682        uint8_t *dest;
    595683        size_t length;
    596684        int i;
    597         void * padding;
     685        void *padding;
    598686        eth_preamble_ref preamble;
    599687
    600688        i = packet_get_addr(packet, &src, &dest);
    601         if(i < 0){
     689        if (i < 0)
    602690                return i;
    603         }
    604         if(i != ETH_ADDR){
     691        if (i != ETH_ADDR)
    605692                return EINVAL;
    606         }
     693
    607694        length = packet_get_data_length(packet);
    608         if(length > mtu){
     695        if (length > mtu)
    609696                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){
     697       
     698        if (length < ETH_MIN_TAGGED_CONTENT(flags)) {
     699                padding = packet_suffix(packet,
     700                    ETH_MIN_TAGGED_CONTENT(flags) - length);
     701                if (!padding)
    614702                        return ENOMEM;
    615                 }
    616703                bzero(padding, ETH_MIN_TAGGED_CONTENT(flags) - length);
    617704        }
    618         if(IS_DIX(flags)){
     705       
     706        if (IS_DIX(flags)) {
    619707                header_dix = PACKET_PREFIX(packet, eth_header_t);
    620                 if(! header_dix){
     708                if (!header_dix)
    621709                        return ENOMEM;
    622                 }
     710               
    623711                header_dix->ethertype = (uint16_t) ethertype;
    624712                memcpy(header_dix->source_address, src_addr, ETH_ADDR);
    625713                memcpy(header_dix->destination_address, dest, ETH_ADDR);
    626714                src = &header_dix->destination_address[0];
    627         }else if(IS_8023_2_LSAP(flags)){
     715        } else if(IS_8023_2_LSAP(flags)) {
    628716                header_lsap = PACKET_PREFIX(packet, eth_header_lsap_t);
    629                 if(! header_lsap){
     717                if (!header_lsap)
    630718                        return ENOMEM;
    631                 }
    632                 header_lsap->header.ethertype = htons(length + sizeof(eth_header_lsap_t));
     719               
     720                header_lsap->header.ethertype = htons(length +
     721                    sizeof(eth_header_lsap_t));
    633722                header_lsap->lsap.dsap = lsap_unmap(ntohs(ethertype));
    634723                header_lsap->lsap.ssap = header_lsap->lsap.dsap;
     
    637726                memcpy(header_lsap->header.destination_address, dest, ETH_ADDR);
    638727                src = &header_lsap->header.destination_address[0];
    639         }else if(IS_8023_2_SNAP(flags)){
     728        } else if(IS_8023_2_SNAP(flags)) {
    640729                header = PACKET_PREFIX(packet, eth_header_snap_t);
    641                 if(! header){
     730                if (!header)
    642731                        return ENOMEM;
    643                 }
    644                 header->header.ethertype = htons(length + sizeof(eth_header_lsap_t) + sizeof(eth_header_snap_t));
     732               
     733                header->header.ethertype = htons(length +
     734                    sizeof(eth_header_lsap_t) + sizeof(eth_header_snap_t));
    645735                header->lsap.dsap = (uint16_t) ETH_LSAP_SNAP;
    646736                header->lsap.ssap = header->lsap.dsap;
    647737                header->lsap.ctrl = IEEE_8023_2_UI;
    648                 for(i = 0; i < 3; ++ i){
     738               
     739                for (i = 0; i < 3; ++ i)
    649740                        header->snap.protocol[i] = 0;
    650                 }
     741               
    651742                header->snap.ethertype = (uint16_t) ethertype;
    652743                memcpy(header->header.source_address, src_addr, ETH_ADDR);
     
    654745                src = &header->header.destination_address[0];
    655746        }
    656         if(IS_DUMMY(flags)){
     747       
     748        if (IS_DUMMY(flags)) {
    657749                preamble = PACKET_PREFIX(packet, eth_preamble_t);
    658                 if(! preamble){
     750                if (!preamble)
    659751                        return ENOMEM;
    660                 }
    661                 for(i = 0; i < 7; ++ i){
     752               
     753                for (i = 0; i < 7; ++ i)
    662754                        preamble->preamble[i] = ETH_PREAMBLE;
    663                 }
     755               
    664756                preamble->sfd = ETH_SFD;
     757               
    665758                fcs = PACKET_SUFFIX(packet, eth_fcs_t);
    666                 if(! fcs){
     759                if (!fcs)
    667760                        return ENOMEM;
    668                 }
    669                 *fcs = htonl(~ compute_crc32(~ 0u, src, length * 8));
    670         }
     761
     762                *fcs = htonl(~compute_crc32(~0U, src, length * 8));
     763        }
     764       
    671765        return EOK;
    672766}
    673767
    674 int eth_send_message(device_id_t device_id, packet_t packet, services_t sender){
     768/** Sends the packet queue.
     769 *
     770 * Sends only packet successfully processed by the eth_prepare_packet()
     771 * function.
     772 *
     773 * @param[in] device_id The device identifier.
     774 * @param[in] packet    The packet queue.
     775 * @param[in] sender    The sending module service.
     776 * @returns             EOK on success.
     777 * @returns             ENOENT if there no such device.
     778 * @returns             EINVAL if the service parameter is not known.
     779 */
     780static int
     781eth_send_message(device_id_t device_id, packet_t packet, services_t sender)
     782{
    675783        ERROR_DECLARE;
    676784
     
    681789
    682790        ethertype = htons(protocol_map(SERVICE_ETHERNET, sender));
    683         if(! ethertype){
     791        if (!ethertype) {
    684792                pq_release_remote(eth_globals.net_phone, packet_get_id(packet));
    685793                return EINVAL;
    686794        }
     795       
    687796        fibril_rwlock_read_lock(&eth_globals.devices_lock);
    688797        device = eth_devices_find(&eth_globals.devices, device_id);
    689         if(! device){
     798        if (!device) {
    690799                fibril_rwlock_read_unlock(&eth_globals.devices_lock);
    691800                return ENOENT;
    692801        }
     802       
    693803        // process packet queue
    694804        next = packet;
    695         do{
    696                 if(ERROR_OCCURRED(eth_prepare_packet(device->flags, next, (uint8_t *) device->addr->value, ethertype, device->mtu))){
     805        do {
     806                if (ERROR_OCCURRED(eth_prepare_packet(device->flags, next,
     807                    (uint8_t *) device->addr->value, ethertype, device->mtu))) {
    697808                        // release invalid packet
    698809                        tmp = pq_detach(next);
    699                         if(next == packet){
     810                        if (next == packet)
    700811                                packet = tmp;
    701                         }
    702                         pq_release_remote(eth_globals.net_phone, packet_get_id(next));
     812                        pq_release_remote(eth_globals.net_phone,
     813                            packet_get_id(next));
    703814                        next = tmp;
    704                 }else{
     815                } else {
    705816                        next = pq_next(next);
    706817                }
    707         }while(next);
     818        } while(next);
     819       
    708820        // send packet queue
    709         if(packet){
    710                 netif_send_msg(device->phone, device_id, packet, SERVICE_ETHERNET);
     821        if (packet) {
     822                netif_send_msg(device->phone, device_id, packet,
     823                    SERVICE_ETHERNET);
    711824        }
    712825        fibril_rwlock_read_unlock(&eth_globals.devices_lock);
     826       
    713827        return EOK;
    714828}
    715829
    716 int nil_message_standalone(const char *name, ipc_callid_t callid, ipc_call_t *call,
     830int
     831nil_message_standalone(const char *name, ipc_callid_t callid, ipc_call_t *call,
    717832    ipc_call_t *answer, int *answer_count)
    718833{
     
    728843        *answer_count = 0;
    729844        switch (IPC_GET_METHOD(*call)) {
    730                 case IPC_M_PHONE_HUNGUP:
    731                         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));
     845        case IPC_M_PHONE_HUNGUP:
     846                return EOK;
     847       
     848        case NET_NIL_DEVICE:
     849                return eth_device_message(IPC_GET_DEVICE(call),
     850                    IPC_GET_SERVICE(call), IPC_GET_MTU(call));
     851        case NET_NIL_SEND:
     852                ERROR_PROPAGATE(packet_translate_remote(eth_globals.net_phone,
     853                    &packet, IPC_GET_PACKET(call)));
     854                return eth_send_message(IPC_GET_DEVICE(call), packet,
     855                    IPC_GET_SERVICE(call));
     856        case NET_NIL_PACKET_SPACE:
     857                ERROR_PROPAGATE(eth_packet_space_message(IPC_GET_DEVICE(call),
     858                    &addrlen, &prefix, &content, &suffix));
     859                IPC_SET_ADDR(answer, addrlen);
     860                IPC_SET_PREFIX(answer, prefix);
     861                IPC_SET_CONTENT(answer, content);
     862                IPC_SET_SUFFIX(answer, suffix);
     863                *answer_count = 4;
     864                return EOK;
     865        case NET_NIL_ADDR:
     866                ERROR_PROPAGATE(eth_addr_message(IPC_GET_DEVICE(call),
     867                    ETH_LOCAL_ADDR, &address));
     868                return measured_strings_reply(address, 1);
     869        case NET_NIL_BROADCAST_ADDR:
     870                ERROR_PROPAGATE(eth_addr_message(IPC_GET_DEVICE(call),
     871                    ETH_BROADCAST_ADDR, &address));
     872                return measured_strings_reply(address, 1);
     873        case IPC_M_CONNECT_TO_ME:
     874                return eth_register_message(NIL_GET_PROTO(call),
     875                    IPC_GET_PHONE(call));
    760876        }
    761877       
     
    763879}
    764880
    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 
    790881/** Default thread for new connections.
    791882 *
    792  * @param[in] iid The initial message identifier.
    793  * @param[in] icall The initial message call structure.
     883 * @param[in] iid       The initial message identifier.
     884 * @param[in] icall     The initial message call structure.
    794885 *
    795886 */
     
    802893        ipc_answer_0(iid, EOK);
    803894       
    804         while(true) {
     895        while (true) {
    805896                ipc_call_t answer;
    806897                int answer_count;
     
    814905               
    815906                /* Process the message */
    816                 int res = nil_module_message_standalone(NAME, callid, &call, &answer,
    817                     &answer_count);
    818                
    819                 /* End if said to either by the message or the processing result */
    820                 if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) || (res == EHANGUP))
     907                int res = nil_module_message_standalone(NAME, callid, &call,
     908                    &answer, &answer_count);
     909               
     910                /*
     911                 * End if told to either by the message or the processing
     912                 * result.
     913                 */
     914                if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
     915                    (res == EHANGUP))
    821916                        return;
    822917               
     
    831926       
    832927        /* Start the module */
    833         if (ERROR_OCCURRED(nil_module_start_standalone(nil_client_connection)))
    834                 return ERROR_CODE;
    835        
     928        ERROR_PROPAGATE(nil_module_start_standalone(nil_client_connection));
    836929        return EOK;
    837930}
  • uspace/srv/net/nil/eth/eth.h

    re7f6389 rf2d2c604  
    3232
    3333/** @file
    34  *  Ethernet module.
     34 * Ethernet module.
    3535 */
    3636
    37 #ifndef __NET_ETH_H__
    38 #define __NET_ETH_H__
     37#ifndef NET_ETH_H_
     38#define NET_ETH_H_
    3939
    4040#include <fibril_synch.h>
     
    4545
    4646/** Type definition of the Ethernet global data.
    47  *  @see eth_globals
     47 * @see eth_globals
    4848 */
    49 typedef struct eth_globals      eth_globals_t;
     49typedef struct eth_globals eth_globals_t;
    5050
    5151/** Type definition of the Ethernet device specific data.
    52  *  @see eth_device
     52 * @see eth_device
    5353 */
    54 typedef struct eth_device       eth_device_t;
     54typedef struct eth_device eth_device_t;
    5555
    5656/** Type definition of the Ethernet device specific data pointer.
    57  *  @see eth_device
     57 * @see eth_device
    5858 */
    59 typedef eth_device_t *          eth_device_ref;
     59typedef eth_device_t *eth_device_ref;
    6060
    6161/** Type definition of the Ethernet protocol specific data.
    62  *  @see eth_proto
     62 * @see eth_proto
    6363 */
    64 typedef struct eth_proto        eth_proto_t;
     64typedef struct eth_proto eth_proto_t;
    6565
    6666/** Type definition of the Ethernet protocol specific data pointer.
    67  *  @see eth_proto
     67 * @see eth_proto
    6868 */
    69 typedef eth_proto_t *           eth_proto_ref;
     69typedef eth_proto_t *eth_proto_ref;
    7070
    7171/** Ethernet device map.
    72  *  Maps devices to the Ethernet device specific data.
    73  *  @see device.h
     72 * Maps devices to the Ethernet device specific data.
     73 * @see device.h
    7474 */
    75 DEVICE_MAP_DECLARE(eth_devices, eth_device_t)
     75DEVICE_MAP_DECLARE(eth_devices, eth_device_t);
    7676
    7777/** Ethernet protocol map.
    78  *  Maps protocol identifiers to the Ethernet protocol specific data.
    79  *  @see int_map.h
     78 * Maps protocol identifiers to the Ethernet protocol specific data.
     79 * @see int_map.h
    8080 */
    81 INT_MAP_DECLARE(eth_protos, eth_proto_t)
     81INT_MAP_DECLARE(eth_protos, eth_proto_t);
    8282
    83 /** Ethernet device specific data.
    84  */
    85 struct  eth_device{
    86         /** Device identifier.
    87          */
     83/** Ethernet device specific data. */
     84struct eth_device {
     85        /** Device identifier. */
    8886        device_id_t device_id;
    89         /** Device driver service.
    90          */
     87        /** Device driver service. */
    9188        services_t service;
    92         /** Driver phone.
    93          */
     89        /** Driver phone. */
    9490        int phone;
    95         /** Maximal transmission unit.
    96          */
     91        /** Maximal transmission unit. */
    9792        size_t mtu;
    98         /** Various device flags.
    99          *  @see ETH_DUMMY
    100          *  @see ETH_MODE_MASK
     93       
     94        /**
     95         * Various device flags.
     96         * @see ETH_DUMMY
     97         * @see ETH_MODE_MASK
    10198         */
    10299        int flags;
    103         /** Actual device hardware address.
    104         */
     100       
     101        /** Actual device hardware address. */
    105102        measured_string_ref addr;
    106         /** Actual device hardware address data.
    107          */
    108         char * addr_data;
     103        /** Actual device hardware address data. */
     104        char *addr_data;
    109105};
    110106
    111 /** Ethernet protocol specific data.
    112  */
    113 struct eth_proto{
    114         /** Protocol service.
    115          */
     107/** Ethernet protocol specific data. */
     108struct eth_proto {
     109        /** Protocol service. */
    116110        services_t service;
    117         /** Protocol identifier.
    118          */
     111        /** Protocol identifier. */
    119112        int protocol;
    120         /** Protocol module phone.
    121          */
     113        /** Protocol module phone. */
    122114        int phone;
    123115};
    124116
    125 /** Ethernet global data.
    126  */
    127 struct  eth_globals{
    128         /** Networking module phone.
    129          */
     117/** Ethernet global data. */
     118struct eth_globals {
     119        /** Networking module phone. */
    130120        int net_phone;
    131         /** Safety lock for devices.
    132          */
     121        /** Safety lock for devices. */
    133122        fibril_rwlock_t devices_lock;
    134         /** All known Ethernet devices.
    135          */
     123        /** All known Ethernet devices. */
    136124        eth_devices_t devices;
    137         /** Safety lock for protocols.
    138          */
     125        /** Safety lock for protocols. */
    139126        fibril_rwlock_t protos_lock;
    140         /** Protocol map.
    141          *  Service phone map for each protocol.
     127       
     128        /**
     129         * Protocol map.
     130         * Service phone map for each protocol.
    142131         */
    143132        eth_protos_t protos;
    144         /** Broadcast device hardware address.
    145         */
     133       
     134        /** Broadcast device hardware address. */
    146135        measured_string_ref broadcast_addr;
    147136};
  • uspace/srv/net/nil/eth/eth_header.h

    re7f6389 rf2d2c604  
    3232
    3333/** @file
    34  *  Ethernet protocol header definitions.
    35  *  Based on the IEEE~802.3-2005
    36  */
    37 
    38 #ifndef __NET_ETH_HEADER_H__
    39 #define __NET_ETH_HEADER_H__
     34 * Ethernet protocol header definitions.
     35 * Based on the IEEE 802.3-2005
     36 */
     37
     38#ifndef NET_ETH_HEADER_H_
     39#define NET_ETH_HEADER_H_
    4040
    4141#include <sys/types.h>
    4242
    43 /** Ethernet address length.
    44  */
    45 #define ETH_ADDR                6
    46 
    47 /** Ethernet header preamble value.
    48  */
     43/** Ethernet address length. */
     44#define ETH_ADDR        6
     45
     46/** Ethernet header preamble value. */
    4947#define ETH_PREAMBLE    0x55
    5048
    51 /** Ethernet header start of frame value.
    52  */
    53 #define ETH_SFD                 0xD5
    54 
    55 /** IEEE 802.2 unordered information control field.
    56  */
     49/** Ethernet header start of frame value. */
     50#define ETH_SFD         0xD5
     51
     52/** IEEE 802.2 unordered information control field. */
    5753#define IEEE_8023_2_UI  0x03
    5854
    5955/** Type definition of the Ethernet header IEEE 802.3 + 802.2 + SNAP extensions.
    60  *  @see eth_header_snap
    61  */
    62 typedef struct eth_header_snap  eth_header_snap_t;
    63 
    64 /** Type definition of the Ethernet header IEEE 802.3 + 802.2 + SNAP extensions pointer.
    65  *  @see eth_header_snap
    66  */
    67 typedef eth_header_snap_t *             eth_header_snap_ref;
     56 * @see eth_header_snap
     57 */
     58typedef struct eth_header_snap eth_header_snap_t;
     59
     60/** Type definition of the Ethernet header IEEE 802.3 + 802.2 + SNAP extensions
     61 * pointer.
     62 *
     63 * @see eth_header_snap
     64 */
     65typedef eth_header_snap_t *eth_header_snap_ref;
    6866
    6967/** Type definition of the Ethernet header IEEE 802.3 + 802.2 + SNAP extensions.
    70  *  @see eth_header_lsap
    71  */
    72 typedef struct eth_header_lsap  eth_header_lsap_t;
     68 * @see eth_header_lsap
     69 */
     70typedef struct eth_header_lsap eth_header_lsap_t;
    7371
    7472/** Type definition of the Ethernet header IEEE 802.3 + 802.2 extension pointer.
    75  *  @see eth_header_lsap
    76  */
    77 typedef eth_header_lsap_t *             eth_header_lsap_ref;
     73 * @see eth_header_lsap
     74 */
     75typedef eth_header_lsap_t *eth_header_lsap_ref;
    7876
    7977/** Type definition of the Ethernet header LSAP extension.
    80  *  @see eth_ieee_lsap
    81  */
    82 typedef struct eth_ieee_lsap    eth_ieee_lsap_t;
     78 * @see eth_ieee_lsap
     79 */
     80typedef struct eth_ieee_lsap eth_ieee_lsap_t;
    8381
    8482/** Type definition of the Ethernet header LSAP extension pointer.
    85  *  @see eth_ieee_lsap
    86  */
    87 typedef eth_ieee_lsap_t *               eth_ieee_lsap_ref;
     83 * @see eth_ieee_lsap
     84 */
     85typedef eth_ieee_lsap_t *eth_ieee_lsap_ref;
    8886
    8987/** Type definition of the Ethernet header SNAP extension.
    90  *  @see eth_snap
    91  */
    92 typedef struct eth_snap         eth_snap_t;
     88 * @see eth_snap
     89 */
     90typedef struct eth_snap eth_snap_t;
    9391
    9492/** Type definition of the Ethernet header SNAP extension pointer.
    95  *  @see eth_snap
    96  */
    97 typedef eth_snap_t *            eth_snap_ref;
     93 * @see eth_snap
     94 */
     95typedef eth_snap_t *eth_snap_ref;
    9896
    9997/** Type definition of the Ethernet header preamble.
    100  *  @see preamble
    101  */
    102 typedef struct eth_preamble     eth_preamble_t;
     98 * @see preamble
     99 */
     100typedef struct eth_preamble eth_preamble_t;
    103101
    104102/** Type definition of the Ethernet header preamble pointer.
    105  *  @see eth_preamble
    106  */
    107 typedef eth_preamble_t *        eth_preamble_ref;
     103 * @see eth_preamble
     104 */
     105typedef eth_preamble_t *eth_preamble_ref;
    108106
    109107/** Type definition of the Ethernet header.
    110  *  @see eth_header
    111  */
    112 typedef struct eth_header       eth_header_t;
     108 * @see eth_header
     109 */
     110typedef struct eth_header eth_header_t;
    113111
    114112/** Type definition of the Ethernet header pointer.
    115  *  @see eth_header
    116  */
    117 typedef eth_header_t *          eth_header_ref;
    118 
    119 /** Ethernet header Link Service Access Point extension.
    120  */
    121 struct eth_ieee_lsap{
    122         /** Destination Service Access Point identifier.
     113 * @see eth_header
     114 */
     115typedef eth_header_t *eth_header_ref;
     116
     117/** Ethernet header Link Service Access Point extension. */
     118struct eth_ieee_lsap {
     119        /**
     120         * Destination Service Access Point identifier.
    123121         * The possible values are assigned by an IEEE committee.
    124122         */
    125123        uint8_t dsap;
    126         /** Source Service Access Point identifier.
     124       
     125        /**
     126         * Source Service Access Point identifier.
    127127         * The possible values are assigned by an IEEE committee.
    128128         */
    129129        uint8_t ssap;
    130         /** Control parameter.
     130       
     131        /**
     132         * Control parameter.
    131133         * The possible values are assigned by an IEEE committee.
    132134         */
     
    134136} __attribute__ ((packed));
    135137
    136 /** Ethernet header SNAP extension.
    137  */
    138 struct eth_snap{
    139         /** Protocol identifier or organization code.
    140          */
     138/** Ethernet header SNAP extension. */
     139struct eth_snap {
     140        /** Protocol identifier or organization code. */
    141141        uint8_t protocol[3];
    142         /** Ethernet protocol identifier in the network byte order (big endian).
    143          *  @see ethernet_protocols.h
     142       
     143        /**
     144         * Ethernet protocol identifier in the network byte order (big endian).
     145         * @see ethernet_protocols.h
    144146         */
    145147        uint16_t ethertype;
     
    147149
    148150/** Ethernet header preamble.
    149  *  Used for dummy devices.
    150  */
    151 struct eth_preamble{
    152         /** Controlling preamble used for the frame transmission synchronization.
    153          *  All should be set to ETH_PREAMBLE.
     151 *
     152 * Used for dummy devices.
     153 */
     154struct eth_preamble {
     155        /**
     156         * Controlling preamble used for the frame transmission synchronization.
     157         * All should be set to ETH_PREAMBLE.
    154158         */
    155159        uint8_t preamble[7];
    156         /** Start of Frame Delimiter used for the frame transmission synchronization.
    157          *  Should be set to ETH_SFD.
     160       
     161        /**
     162         * Start of Frame Delimiter used for the frame transmission
     163         * synchronization.
     164         * Should be set to ETH_SFD.
    158165         */
    159166        uint8_t sfd;
    160167} __attribute__ ((packed));
    161168
    162 /** Ethernet header.
    163  */
    164 struct eth_header{
    165         /** Destination host Ethernet address (MAC address).
    166          */
     169/** Ethernet header. */
     170struct eth_header {
     171        /** Destination host Ethernet address (MAC address). */
    167172        uint8_t destination_address[ETH_ADDR];
    168         /** Source host Ethernet address (MAC address).
    169          */
     173        /** Source host Ethernet address (MAC address). */
    170174        uint8_t source_address[ETH_ADDR];
    171         /** Ethernet protocol identifier in the network byte order (big endian).
    172          *  @see ethernet_protocols.h
     175       
     176        /**
     177         * Ethernet protocol identifier in the network byte order (big endian).
     178         * @see ethernet_protocols.h
    173179         */
    174180        uint16_t ethertype;
    175181} __attribute__ ((packed));
    176182
    177 /** Ethernet header IEEE 802.3 + 802.2 extension.
    178  */
    179 struct eth_header_lsap{
    180         /** Ethernet header.
    181          */
     183/** Ethernet header IEEE 802.3 + 802.2 extension. */
     184struct eth_header_lsap {
     185        /** Ethernet header. */
    182186        eth_header_t header;
    183         /** LSAP extension.
    184          *  If DSAP and SSAP are set to ETH_LSAP_SNAP the SNAP extension is being used.
    185          *  If DSAP and SSAP fields are equal to ETH_RAW the raw Ethernet packet without any extensions is being used and the frame content starts rigth after the two fields.
     187       
     188        /**
     189         * LSAP extension.
     190         * If DSAP and SSAP are set to ETH_LSAP_SNAP the SNAP extension is being
     191         * used.
     192         * If DSAP and SSAP fields are equal to ETH_RAW the raw Ethernet packet
     193         * without any extensions is being used and the frame content starts
     194         * rigth after the two fields.
    186195         */
    187196        eth_ieee_lsap_t lsap;
    188197} __attribute__ ((packed));
    189198
    190 /** Ethernet header IEEE 802.3 + 802.2 + SNAP extensions.
    191  */
    192 struct eth_header_snap{
    193         /** Ethernet header.
    194          */
     199/** Ethernet header IEEE 802.3 + 802.2 + SNAP extensions. */
     200struct eth_header_snap {
     201        /** Ethernet header. */
    195202        eth_header_t header;
    196         /** LSAP extension.
    197          *  If DSAP and SSAP are set to ETH_LSAP_SNAP the SNAP extension is being used.
    198          *  If DSAP and SSAP fields are equal to ETH_RAW the raw Ethernet packet without any extensions is being used and the frame content starts rigth after the two fields.
     203       
     204        /**
     205         * LSAP extension.
     206         * If DSAP and SSAP are set to ETH_LSAP_SNAP the SNAP extension is being
     207         * used.
     208         * If DSAP and SSAP fields are equal to ETH_RAW the raw Ethernet packet
     209         * without any extensions is being used and the frame content starts
     210         * rigth after the two fields.
    199211         */
    200212        eth_ieee_lsap_t lsap;
    201         /** SNAP extension.
    202         */
     213       
     214        /** SNAP extension. */
    203215        eth_snap_t snap;
    204216} __attribute__ ((packed));
    205217
    206 /** Ethernet Frame Check Sequence.
    207  */
    208 typedef uint32_t                eth_fcs_t;
    209 
    210 /** Ethernet Frame Check Sequence pointer.
    211  */
    212 typedef eth_fcs_t *             eth_fcs_ref;
     218/** Ethernet Frame Check Sequence. */
     219typedef uint32_t eth_fcs_t;
     220
     221/** Ethernet Frame Check Sequence pointer. */
     222typedef eth_fcs_t *eth_fcs_ref;
    213223
    214224#endif
  • uspace/srv/net/nil/eth/eth_module.c

    re7f6389 rf2d2c604  
    3636 */
    3737
     38#include "eth.h"
     39
    3840#include <async.h>
    3941#include <stdio.h>
     
    4850#include <nil_local.h>
    4951
    50 #include "eth.h"
    51 
    5252int nil_module_start_standalone(async_client_conn_t client_connection)
    5353{
     
    5959       
    6060        ipcarg_t phonehash;
    61         if (ERROR_OCCURRED(nil_initialize(net_phone))
    62             || ERROR_OCCURRED(REGISTER_ME(SERVICE_ETHERNET, &phonehash))) {
     61        if (ERROR_OCCURRED(nil_initialize(net_phone)) ||
     62            ERROR_OCCURRED(REGISTER_ME(SERVICE_ETHERNET, &phonehash))) {
    6363                pm_destroy();
    6464                return ERROR_CODE;
     
    7171}
    7272
    73 int nil_module_message_standalone(const char *name, ipc_callid_t callid, ipc_call_t *call,
    74     ipc_call_t *answer, int *answer_count)
     73int
     74nil_module_message_standalone(const char *name, ipc_callid_t callid,
     75    ipc_call_t *call, ipc_call_t *answer, int *answer_count)
    7576{
    7677        return nil_message_standalone(name, callid, call, answer, answer_count);
  • uspace/srv/net/nil/nildummy/nildummy.h

    re7f6389 rf2d2c604  
    2828
    2929/** @addtogroup nildummy
    30  *  @{
     30 * @{
    3131 */
    3232
    3333/** @file
    34  *  Dummy network interface layer module.
     34 * Dummy network interface layer module.
    3535 */
    3636
    37 #ifndef __NET_NILDUMMY_H__
    38 #define __NET_NILDUMMY_H__
     37#ifndef NET_NILDUMMY_H_
     38#define NET_NILDUMMY_H_
    3939
    4040#include <fibril_synch.h>
     
    4545
    4646/** Type definition of the dummy nil global data.
    47  *  @see nildummy_globals
     47 * @see nildummy_globals
    4848 */
    49 typedef struct nildummy_globals nildummy_globals_t;
     49typedef struct nildummy_globals nildummy_globals_t;
    5050
    5151/** Type definition of the dummy nil device specific data.
    52  *  @see nildummy_device
     52 * @see nildummy_device
    5353 */
    54 typedef struct nildummy_device  nildummy_device_t;
     54typedef struct nildummy_device nildummy_device_t;
    5555
    5656/** Type definition of the dummy nil device specific data pointer.
    57  *  @see nildummy_device
     57 * @see nildummy_device
    5858 */
    59 typedef nildummy_device_t *             nildummy_device_ref;
     59typedef nildummy_device_t *nildummy_device_ref;
    6060
    6161/** Type definition of the dummy nil protocol specific data.
    62  *  @see nildummy_proto
     62 * @see nildummy_proto
    6363 */
    6464typedef struct nildummy_proto   nildummy_proto_t;
    6565
    6666/** Type definition of the dummy nil protocol specific data pointer.
    67  *  @see nildummy_proto
     67 * @see nildummy_proto
    6868 */
    69 typedef nildummy_proto_t *              nildummy_proto_ref;
     69typedef nildummy_proto_t *nildummy_proto_ref;
    7070
    7171/** Dummy nil device map.
    72  *  Maps devices to the dummy nil device specific data.
    73  *  @see device.h
     72 * Maps devices to the dummy nil device specific data.
     73 * @see device.h
    7474 */
    75 DEVICE_MAP_DECLARE(nildummy_devices, nildummy_device_t)
     75DEVICE_MAP_DECLARE(nildummy_devices, nildummy_device_t);
    7676
    77 /** Dummy nil device specific data.
    78  */
    79 struct  nildummy_device{
    80         /** Device identifier.
    81          */
     77/** Dummy nil device specific data. */
     78struct nildummy_device {
     79        /** Device identifier. */
    8280        device_id_t device_id;
    83         /** Device driver service.
    84          */
     81        /** Device driver service. */
    8582        services_t service;
    86         /** Driver phone.
    87          */
     83        /** Driver phone. */
    8884        int phone;
    89         /** Maximal transmission unit.
    90          */
     85        /** Maximal transmission unit. */
    9186        size_t mtu;
    92         /** Actual device hardware address.
    93          */
     87        /** Actual device hardware address. */
    9488        measured_string_ref addr;
    95         /** Actual device hardware address data.
    96          */
    97         char * addr_data;
     89        /** Actual device hardware address data. */
     90        char *addr_data;
    9891};
    9992
    100 /** Dummy nil protocol specific data.
    101  */
    102 struct nildummy_proto{
    103         /** Protocol service.
    104          */
     93/** Dummy nil protocol specific data. */
     94struct nildummy_proto {
     95        /** Protocol service. */
    10596        services_t service;
    106         /** Protocol module phone.
    107          */
     97        /** Protocol module phone. */
    10898        int phone;
    10999};
    110100
    111 /** Dummy nil global data.
    112  */
    113 struct  nildummy_globals{
    114         /** Networking module phone.
    115          */
     101/** Dummy nil global data. */
     102struct  nildummy_globals {
     103        /** Networking module phone. */
    116104        int net_phone;
    117         /** Safety lock for devices.
    118          */
     105        /** Safety lock for devices. */
    119106        fibril_rwlock_t devices_lock;
    120         /** All known Ethernet devices.
    121          */
     107        /** All known Ethernet devices. */
    122108        nildummy_devices_t devices;
    123         /** Safety lock for protocols.
    124          */
     109        /** Safety lock for protocols. */
    125110        fibril_rwlock_t protos_lock;
    126         /** Default protocol.
    127          */
     111        /** Default protocol. */
    128112        nildummy_proto_t proto;
    129113};
  • uspace/srv/net/nil/nildummy/nildummy_module.c

    re7f6389 rf2d2c604  
    5959       
    6060        ipcarg_t phonehash;
    61         if (ERROR_OCCURRED(nil_initialize(net_phone))
    62             || ERROR_OCCURRED(REGISTER_ME(SERVICE_NILDUMMY, &phonehash))){
     61        if (ERROR_OCCURRED(nil_initialize(net_phone)) ||
     62            ERROR_OCCURRED(REGISTER_ME(SERVICE_NILDUMMY, &phonehash))) {
    6363                pm_destroy();
    6464                return ERROR_CODE;
     
    7171}
    7272
    73 int nil_module_message_standalone(const char *name, ipc_callid_t callid,
     73int
     74nil_module_message_standalone(const char *name, ipc_callid_t callid,
    7475    ipc_call_t *call, ipc_call_t *answer, int *answer_count)
    7576{
Note: See TracChangeset for help on using the changeset viewer.