Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/srv/net/il/arp/arp.c

    re9caf47 raf7638e  
    2828
    2929/** @addtogroup arp
    30  * @{
     30 *  @{
    3131 */
    3232
    3333/** @file
    34  * ARP module implementation.
    35  * @see arp.h
    36  */
    37 
    38 #include "arp.h"
    39 #include "arp_header.h"
    40 #include "arp_oc.h"
    41 #include "arp_module.h"
     34 *  ARP module implementation.
     35 *  @see arp.h
     36 */
    4237
    4338#include <async.h>
    … …  
    4843#include <str.h>
    4944#include <task.h>
    50 #include <adt/measured_strings.h>
    5145#include <ipc/ipc.h>
    5246#include <ipc/services.h>
    … …  
    5953#include <net/modules.h>
    6054#include <net/device.h>
    61 #include <net/packet.h>
    62 
     55#include <arp_interface.h>
    6356#include <nil_interface.h>
    6457#include <protocol_map.h>
     58#include <adt/measured_strings.h>
     59#include <net/packet.h>
    6560#include <packet_client.h>
    6661#include <packet_remote.h>
    … …  
    6863#include <il_local.h>
    6964
    70 
    71 /** ARP module name. */
     65#include "arp.h"
     66#include "arp_header.h"
     67#include "arp_oc.h"
     68#include "arp_module.h"
     69
     70
     71/** ARP module name.
     72 */
    7273#define NAME  "arp"
    7374
    74 /** ARP global data. */
    75 arp_globals_t arp_globals;
    76 
    77 DEVICE_MAP_IMPLEMENT(arp_cache, arp_device_t);
    78 INT_MAP_IMPLEMENT(arp_protos, arp_proto_t);
    79 GENERIC_CHAR_MAP_IMPLEMENT(arp_addr, measured_string_t);
     75/** ARP global data.
     76 */
     77arp_globals_t   arp_globals;
    8078
    8179/** Clears the device specific data.
    82  *
    83  * @param[in] device    The device specific data.
    84  */
    85 static void arp_clear_device(arp_device_ref device)
    86 {
    87         int count;
    88         arp_proto_ref proto;
    89 
    90         for (count = arp_protos_count(&device->protos) - 1; count >= 0;
    91             count--) {
    92                 proto = arp_protos_get_index(&device->protos, count);
    93                 if (proto) {
    94                         if (proto->addr)
    95                                 free(proto->addr);
    96                         if (proto->addr_data)
    97                                 free(proto->addr_data);
    98                         arp_addr_destroy(&proto->addresses);
    99                 }
    100         }
    101         arp_protos_clear(&device->protos);
    102 }
    103 
    104 static int arp_clean_cache_req(int arp_phone)
    105 {
     80 *  @param[in] device The device specific data.
     81 */
     82void arp_clear_device(arp_device_ref device);
     83
     84/** Creates new protocol specific data.
     85 *  Allocates and returns the needed memory block as the proto parameter.
     86 *  @param[out] proto The allocated protocol specific data.
     87 *  @param[in] service The protocol module service.
     88 *  @param[in] address The actual protocol device address.
     89 *  @returns EOK on success.
     90 *  @returns ENOMEM if there is not enough memory left.
     91 */
     92int arp_proto_create(arp_proto_ref * proto, services_t service, measured_string_ref address);
     93
     94/** @name Message processing functions
     95 */
     96/*@{*/
     97
     98/** Registers the device.
     99 *  Creates new device entry in the cache or updates the protocol address if the device with the device identifier and the driver service exists.
     100 *  @param[in] device_id The device identifier.
     101 *  @param[in] service The device driver service.
     102 *  @param[in] protocol The protocol service.
     103 *  @param[in] address The actual device protocol address.
     104 *  @returns EOK on success.
     105 *  @returns EEXIST if another device with the same device identifier and different driver service exists.
     106 *  @returns ENOMEM if there is not enough memory left.
     107 *  @returns Other error codes as defined for the measured_strings_return() function.
     108 */
     109int arp_device_message(device_id_t device_id, services_t service, services_t protocol, measured_string_ref address);
     110
     111/** Updates the device content length according to the new MTU value.
     112 *  @param[in] device_id The device identifier.
     113 *  @param[in] mtu The new mtu value.
     114 *  @returns ENOENT if device is not found.
     115 *  @returns EOK on success.
     116 */
     117int arp_mtu_changed_message(device_id_t device_id, size_t mtu);
     118
     119/** Processes the received ARP packet.
     120 *  Updates the source hardware address if the source entry exists or the packet is targeted to my protocol address.
     121 *  Responses to the ARP request if the packet is the ARP request and is targeted to my address.
     122 *  @param[in] device_id The source device identifier.
     123 *  @param[in,out] packet The received packet.
     124 *  @returns EOK on success and the packet is no longer needed.
     125 *  @returns 1 on success and the packet has been reused.
     126 *  @returns EINVAL if the packet is too small to carry an ARP packet.
     127 *  @returns EINVAL if the received address lengths differs from the registered values.
     128 *  @returns ENOENT if the device is not found in the cache.
     129 *  @returns ENOENT if the protocol for the device is not found in the cache.
     130 *  @returns ENOMEM if there is not enough memory left.
     131 */
     132int arp_receive_message(device_id_t device_id, packet_t packet);
     133
     134/** Returns the hardware address for the given protocol address.
     135 *  Sends the ARP request packet if the hardware address is not found in the cache.
     136 *  @param[in] device_id The device identifier.
     137 *  @param[in] protocol The protocol service.
     138 *  @param[in] target The target protocol address.
     139 *  @returns The hardware address of the target.
     140 *  @returns NULL if the target parameter is NULL.
     141 *  @returns NULL if the device is not found.
     142 *  @returns NULL if the device packet is too small to send a&nbsp;request.
     143 *  @returns NULL if the hardware address is not found in the cache.
     144 */
     145measured_string_ref arp_translate_message(device_id_t device_id, services_t protocol, measured_string_ref target);
     146
     147/*@}*/
     148
     149DEVICE_MAP_IMPLEMENT(arp_cache, arp_device_t)
     150
     151INT_MAP_IMPLEMENT(arp_protos, arp_proto_t)
     152
     153GENERIC_CHAR_MAP_IMPLEMENT(arp_addr, measured_string_t)
     154
     155int arp_clean_cache_req(int arp_phone){
    106156        int count;
    107157        arp_device_ref device;
    108158
    109159        fibril_rwlock_write_lock(&arp_globals.lock);
    110         for (count = arp_cache_count(&arp_globals.cache) - 1; count >= 0;
    111             count--) {
     160        for(count = arp_cache_count(&arp_globals.cache) - 1; count >= 0; -- count){
    112161                device = arp_cache_get_index(&arp_globals.cache, count);
    113                 if (device) {
     162                if(device){
    114163                        arp_clear_device(device);
    115                         if (device->addr_data)
     164                        if(device->addr_data){
    116165                                free(device->addr_data);
    117                         if (device->broadcast_data)
     166                        }
     167                        if(device->broadcast_data){
    118168                                free(device->broadcast_data);
     169                        }
    119170                }
    120171        }
    … …  
    125176}
    126177
    127 static int
    128 arp_clear_address_req(int arp_phone, device_id_t device_id, services_t protocol,
    129     measured_string_ref address)
    130 {
     178int arp_clear_address_req(int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address){
    131179        arp_device_ref device;
    132180        arp_proto_ref proto;
    … …  
    134182        fibril_rwlock_write_lock(&arp_globals.lock);
    135183        device = arp_cache_find(&arp_globals.cache, device_id);
    136         if (!device) {
     184        if(! device){
    137185                fibril_rwlock_write_unlock(&arp_globals.lock);
    138186                return ENOENT;
    139187        }
    140188        proto = arp_protos_find(&device->protos, protocol);
    141         if (!proto) {
     189        if(! proto){
    142190                fibril_rwlock_write_unlock(&arp_globals.lock);
    143191                return ENOENT;
    … …  
    148196}
    149197
    150 
    151 static int arp_clear_device_req(int arp_phone, device_id_t device_id)
    152 {
     198void arp_clear_device(arp_device_ref device){
     199        int count;
     200        arp_proto_ref proto;
     201
     202        for(count = arp_protos_count(&device->protos) - 1; count >= 0; -- count){
     203                proto = arp_protos_get_index(&device->protos, count);
     204                if(proto){
     205                        if(proto->addr){
     206                                free(proto->addr);
     207                        }
     208                        if(proto->addr_data){
     209                                free(proto->addr_data);
     210                        }
     211                        arp_addr_destroy(&proto->addresses);
     212                }
     213        }
     214        arp_protos_clear(&device->protos);
     215}
     216
     217int arp_clear_device_req(int arp_phone, device_id_t device_id){
    153218        arp_device_ref device;
    154219
    155220        fibril_rwlock_write_lock(&arp_globals.lock);
    156221        device = arp_cache_find(&arp_globals.cache, device_id);
    157         if (!device) {
     222        if(! device){
    158223                fibril_rwlock_write_unlock(&arp_globals.lock);
    159224                return ENOENT;
    … …  
    165230}
    166231
    167 /** Creates new protocol specific data.
    168  *
    169  * Allocates and returns the needed memory block as the proto parameter.
    170  *
    171  * @param[out] proto    The allocated protocol specific data.
    172  * @param[in] service   The protocol module service.
    173  * @param[in] address   The actual protocol device address.
    174  * @returns             EOK on success.
    175  * @returns             ENOMEM if there is not enough memory left.
    176  */
    177 static int
    178 arp_proto_create(arp_proto_ref *proto, services_t service,
    179     measured_string_ref address)
    180 {
    181         ERROR_DECLARE;
    182 
    183         *proto = (arp_proto_ref) malloc(sizeof(arp_proto_t));
    184         if (!*proto)
    185                 return ENOMEM;
    186         (*proto)->service = service;
    187         (*proto)->addr = address;
    188         (*proto)->addr_data = address->value;
    189         if (ERROR_OCCURRED(arp_addr_initialize(&(*proto)->addresses))) {
    190                 free(*proto);
    191                 return ERROR_CODE;
    192         }
    193         return EOK;
    194 }
    195 
    196 /** Registers the device.
    197  *
    198  * Creates new device entry in the cache or updates the protocol address if the
    199  * device with the device identifier and the driver service exists.
    200  *
    201  * @param[in] device_id The device identifier.
    202  * @param[in] service   The device driver service.
    203  * @param[in] protocol  The protocol service.
    204  * @param[in] address   The actual device protocol address.
    205  * @returns             EOK on success.
    206  * @returns             EEXIST if another device with the same device identifier
    207  *                      and different driver service exists.
    208  * @returns             ENOMEM if there is not enough memory left.
    209  * @returns             Other error codes as defined for the
    210  *                      measured_strings_return() function.
    211  */
    212 static int
    213 arp_device_message(device_id_t device_id, services_t service,
    214     services_t protocol, measured_string_ref address)
    215 {
     232int arp_device_message(device_id_t device_id, services_t service, services_t protocol, measured_string_ref address){
    216233        ERROR_DECLARE;
    217234
    … …  
    224241        // an existing device?
    225242        device = arp_cache_find(&arp_globals.cache, device_id);
    226         if (device) {
    227                 if (device->service != service) {
     243        if(device){
     244                if(device->service != service){
    228245                        printf("Device %d already exists\n", device->device_id);
    229246                        fibril_rwlock_write_unlock(&arp_globals.lock);
    … …  
    231248                }
    232249                proto = arp_protos_find(&device->protos, protocol);
    233                 if (proto) {
     250                if(proto){
    234251                        free(proto->addr);
    235252                        free(proto->addr_data);
    236253                        proto->addr = address;
    237254                        proto->addr_data = address->value;
    238                 } else {
    239                         if (ERROR_OCCURRED(arp_proto_create(&proto, protocol,
    240                             address))) {
     255                }else{
     256                        if(ERROR_OCCURRED(arp_proto_create(&proto, protocol, address))){
    241257                                fibril_rwlock_write_unlock(&arp_globals.lock);
    242258                                return ERROR_CODE;
    243259                        }
    244                         index = arp_protos_add(&device->protos, proto->service,
    245                             proto);
    246                         if (index < 0) {
     260                        index = arp_protos_add(&device->protos, proto->service, proto);
     261                        if(index < 0){
    247262                                fibril_rwlock_write_unlock(&arp_globals.lock);
    248263                                free(proto);
    249264                                return index;
    250265                        }
    251                         printf("New protocol added:\n\tdevice id\t= "
    252                             "%d\n\tproto\t= %d", device_id, protocol);
    253                 }
    254         } else {
     266                        printf("New protocol added:\n\tdevice id\t= %d\n\tproto\t= %d", device_id, protocol);
     267                }
     268        }else{
    255269                hardware = hardware_map(service);
    256                 if (!hardware)
     270                if(! hardware){
    257271                        return ENOENT;
    258                
     272                }
    259273                // create a new device
    260274                device = (arp_device_ref) malloc(sizeof(arp_device_t));
    261                 if (!device) {
     275                if(! device){
    262276                        fibril_rwlock_write_unlock(&arp_globals.lock);
    263277                        return ENOMEM;
    … …  
    265279                device->hardware = hardware;
    266280                device->device_id = device_id;
    267                 if (ERROR_OCCURRED(arp_protos_initialize(&device->protos)) ||
    268                     ERROR_OCCURRED(arp_proto_create(&proto, protocol,
    269                     address))) {
     281                if(ERROR_OCCURRED(arp_protos_initialize(&device->protos))
     282                        || ERROR_OCCURRED(arp_proto_create(&proto, protocol, address))){
    270283                        fibril_rwlock_write_unlock(&arp_globals.lock);
    271284                        free(device);
    … …  
    273286                }
    274287                index = arp_protos_add(&device->protos, proto->service, proto);
    275                 if (index < 0) {
     288                if(index < 0){
    276289                        fibril_rwlock_write_unlock(&arp_globals.lock);
    277290                        arp_protos_destroy(&device->protos);
    … …  
    280293                }
    281294                device->service = service;
    282                
    283295                // bind the new one
    284                 device->phone = nil_bind_service(device->service,
    285                     (ipcarg_t) device->device_id, SERVICE_ARP,
    286                     arp_globals.client_connection);
    287                 if (device->phone < 0) {
     296                device->phone = nil_bind_service(device->service, (ipcarg_t) device->device_id, SERVICE_ARP, arp_globals.client_connection);
     297                if(device->phone < 0){
    288298                        fibril_rwlock_write_unlock(&arp_globals.lock);
    289299                        arp_protos_destroy(&device->protos);
    … …  
    291301                        return EREFUSED;
    292302                }
    293                
    294303                // get packet dimensions
    295                 if (ERROR_OCCURRED(nil_packet_size_req(device->phone, device_id,
    296                     &device->packet_dimension))) {
     304                if(ERROR_OCCURRED(nil_packet_size_req(device->phone, device_id, &device->packet_dimension))){
    297305                        fibril_rwlock_write_unlock(&arp_globals.lock);
    298306                        arp_protos_destroy(&device->protos);
    … …  
    300308                        return ERROR_CODE;
    301309                }
    302                
    303310                // get hardware address
    304                 if (ERROR_OCCURRED(nil_get_addr_req(device->phone, device_id,
    305                     &device->addr, &device->addr_data))) {
     311                if(ERROR_OCCURRED(nil_get_addr_req(device->phone, device_id, &device->addr, &device->addr_data))){
    306312                        fibril_rwlock_write_unlock(&arp_globals.lock);
    307313                        arp_protos_destroy(&device->protos);
    … …  
    309315                        return ERROR_CODE;
    310316                }
    311                
    312317                // get broadcast address
    313                 if (ERROR_OCCURRED(nil_get_broadcast_addr_req(device->phone,
    314                     device_id, &device->broadcast_addr,
    315                     &device->broadcast_data))) {
     318                if(ERROR_OCCURRED(nil_get_broadcast_addr_req(device->phone, device_id, &device->broadcast_addr, &device->broadcast_data))){
    316319                        fibril_rwlock_write_unlock(&arp_globals.lock);
    317320                        free(device->addr);
    … …  
    321324                        return ERROR_CODE;
    322325                }
    323                
    324                 if (ERROR_OCCURRED(arp_cache_add(&arp_globals.cache,
    325                     device->device_id, device))) {
     326                if(ERROR_OCCURRED(arp_cache_add(&arp_globals.cache, device->device_id, device))){
    326327                        fibril_rwlock_write_unlock(&arp_globals.lock);
    327328                        free(device->addr);
    … …  
    333334                        return ERROR_CODE;
    334335                }
    335                 printf("%s: Device registered (id: %d, type: 0x%x, service: %d,"
    336                     " proto: %d)\n", NAME, device->device_id, device->hardware,
    337                     device->service, protocol);
     336                printf("%s: Device registered (id: %d, type: 0x%x, service: %d, proto: %d)\n",
     337                    NAME, device->device_id, device->hardware, device->service, protocol);
    338338        }
    339339        fibril_rwlock_write_unlock(&arp_globals.lock);
    340        
    341         return EOK;
    342 }
    343 
    344 /** Initializes the ARP module.
    345  *
    346  *  @param[in] client_connection The client connection processing function.
    347  *                      The module skeleton propagates its own one.
    348  *  @returns            EOK on success.
    349  *  @returns            ENOMEM if there is not enough memory left.
    350  */
    351 int arp_initialize(async_client_conn_t client_connection)
    352 {
     340        return EOK;
     341}
     342
     343int arp_device_req(int arp_phone, device_id_t device_id, services_t protocol, services_t netif, measured_string_ref address){
     344        ERROR_DECLARE;
     345
     346        measured_string_ref tmp;
     347
     348        // copy the given address for exclusive use
     349        tmp = measured_string_copy(address);
     350        if(ERROR_OCCURRED(arp_device_message(device_id, netif, protocol, tmp))){
     351                free(tmp->value);
     352                free(tmp);
     353        }
     354        return ERROR_CODE;
     355}
     356
     357int arp_initialize(async_client_conn_t client_connection){
    353358        ERROR_DECLARE;
    354359
    … …  
    361366}
    362367
    363 /** Updates the device content length according to the new MTU value.
    364  *
    365  * @param[in] device_id The device identifier.
    366  * @param[in] mtu       The new mtu value.
    367  * @returns             ENOENT if device is not found.
    368  * @returns             EOK on success.
    369  */
    370 static int arp_mtu_changed_message(device_id_t device_id, size_t mtu)
     368int arp_message_standalone(ipc_callid_t callid, ipc_call_t *call,
     369    ipc_call_t *answer, int *answer_count)
    371370{
     371        ERROR_DECLARE;
     372       
     373        measured_string_ref address;
     374        measured_string_ref translation;
     375        char * data;
     376        packet_t packet;
     377        packet_t next;
     378       
     379        *answer_count = 0;
     380        switch (IPC_GET_METHOD(*call)) {
     381                case IPC_M_PHONE_HUNGUP:
     382                        return EOK;
     383                case NET_ARP_DEVICE:
     384                        ERROR_PROPAGATE(measured_strings_receive(&address, &data, 1));
     385                        if(ERROR_OCCURRED(arp_device_message(IPC_GET_DEVICE(call), IPC_GET_SERVICE(call), ARP_GET_NETIF(call), address))){
     386                                free(address);
     387                                free(data);
     388                        }
     389                        return ERROR_CODE;
     390                case NET_ARP_TRANSLATE:
     391                        ERROR_PROPAGATE(measured_strings_receive(&address, &data, 1));
     392                        fibril_rwlock_read_lock(&arp_globals.lock);
     393                        translation = arp_translate_message(IPC_GET_DEVICE(call), IPC_GET_SERVICE(call), address);
     394                        free(address);
     395                        free(data);
     396                        if(! translation){
     397                                fibril_rwlock_read_unlock(&arp_globals.lock);
     398                                return ENOENT;
     399                        }
     400                        ERROR_CODE = measured_strings_reply(translation, 1);
     401                        fibril_rwlock_read_unlock(&arp_globals.lock);
     402                        return ERROR_CODE;
     403                case NET_ARP_CLEAR_DEVICE:
     404                        return arp_clear_device_req(0, IPC_GET_DEVICE(call));
     405                case NET_ARP_CLEAR_ADDRESS:
     406                        ERROR_PROPAGATE(measured_strings_receive(&address, &data, 1));
     407                        arp_clear_address_req(0, IPC_GET_DEVICE(call), IPC_GET_SERVICE(call), address);
     408                        free(address);
     409                        free(data);
     410                        return EOK;
     411                case NET_ARP_CLEAN_CACHE:
     412                        return arp_clean_cache_req(0);
     413                case NET_IL_DEVICE_STATE:
     414                        // do nothing - keep the cache
     415                        return EOK;
     416                case NET_IL_RECEIVED:
     417                        if(! ERROR_OCCURRED(packet_translate_remote(arp_globals.net_phone, &packet, IPC_GET_PACKET(call)))){
     418                                fibril_rwlock_read_lock(&arp_globals.lock);
     419                                do{
     420                                        next = pq_detach(packet);
     421                                        ERROR_CODE = arp_receive_message(IPC_GET_DEVICE(call), packet);
     422                                        if(ERROR_CODE != 1){
     423                                                pq_release_remote(arp_globals.net_phone, packet_get_id(packet));
     424                                        }
     425                                        packet = next;
     426                                }while(packet);
     427                                fibril_rwlock_read_unlock(&arp_globals.lock);
     428                        }
     429                        return ERROR_CODE;
     430                case NET_IL_MTU_CHANGED:
     431                        return arp_mtu_changed_message(IPC_GET_DEVICE(call), IPC_GET_MTU(call));
     432        }
     433       
     434        return ENOTSUP;
     435}
     436
     437int arp_mtu_changed_message(device_id_t device_id, size_t mtu){
    372438        arp_device_ref device;
    373439
    374440        fibril_rwlock_write_lock(&arp_globals.lock);
    375441        device = arp_cache_find(&arp_globals.cache, device_id);
    376         if (!device) {
     442        if(! device){
    377443                fibril_rwlock_write_unlock(&arp_globals.lock);
    378444                return ENOENT;
    379445        }
    380446        device->packet_dimension.content = mtu;
     447        printf("arp - device %d changed mtu to %d\n\n", device_id, mtu);
    381448        fibril_rwlock_write_unlock(&arp_globals.lock);
    382         printf("arp - device %d changed mtu to %d\n\n", device_id, mtu);
    383         return EOK;
    384 }
    385 
    386 /** Processes the received ARP packet.
    387  *
    388  * Updates the source hardware address if the source entry exists or the packet
    389  * is targeted to my protocol address.
    390  * Responses to the ARP request if the packet is the ARP request and is
    391  * targeted to my address.
    392  *
    393  * @param[in] device_id The source device identifier.
    394  * @param[in,out] packet The received packet.
    395  * @returns             EOK on success and the packet is no longer needed.
    396  * @returns             One on success and the packet has been reused.
    397  * @returns             EINVAL if the packet is too small to carry an ARP
    398  *                      packet.
    399  * @returns             EINVAL if the received address lengths differs from
    400  *                      the registered values.
    401  * @returns             ENOENT if the device is not found in the cache.
    402  * @returns             ENOENT if the protocol for the device is not found in
    403  *                      the cache.
    404  * @returns             ENOMEM if there is not enough memory left.
    405  */
    406 static int arp_receive_message(device_id_t device_id, packet_t packet)
    407 {
     449        return EOK;
     450}
     451
     452int arp_proto_create(arp_proto_ref * proto, services_t service, measured_string_ref address){
     453        ERROR_DECLARE;
     454
     455        *proto = (arp_proto_ref) malloc(sizeof(arp_proto_t));
     456        if(!(*proto)){
     457                return ENOMEM;
     458        }
     459        (** proto).service = service;
     460        (** proto).addr = address;
     461        (** proto).addr_data = address->value;
     462        if(ERROR_OCCURRED(arp_addr_initialize(&(** proto).addresses))){
     463                free(*proto);
     464                return ERROR_CODE;
     465        }
     466        return EOK;
     467}
     468
     469int arp_receive_message(device_id_t device_id, packet_t packet){
    408470        ERROR_DECLARE;
    409471
    … …  
    413475        arp_proto_ref proto;
    414476        measured_string_ref hw_source;
    415         uint8_t *src_hw;
    416         uint8_t *src_proto;
    417         uint8_t *des_hw;
    418         uint8_t *des_proto;
     477        uint8_t * src_hw;
     478        uint8_t * src_proto;
     479        uint8_t * des_hw;
     480        uint8_t * des_proto;
    419481
    420482        length = packet_get_data_length(packet);
    421         if (length <= sizeof(arp_header_t))
     483        if(length <= sizeof(arp_header_t)){
    422484                return EINVAL;
    423 
     485        }
    424486        device = arp_cache_find(&arp_globals.cache, device_id);
    425         if (!device)
     487        if(! device){
    426488                return ENOENT;
    427 
     489        }
    428490        header = (arp_header_ref) packet_get_data(packet);
    429         if ((ntohs(header->hardware) != device->hardware) ||
    430             (length < sizeof(arp_header_t) + header->hardware_length * 2U +
    431             header->protocol_length * 2U)) {
     491        if((ntohs(header->hardware) != device->hardware)
     492                || (length < sizeof(arp_header_t) + header->hardware_length * 2u + header->protocol_length * 2u)){
    432493                return EINVAL;
    433494        }
    434 
    435         proto = arp_protos_find(&device->protos,
    436             protocol_unmap(device->service, ntohs(header->protocol)));
    437         if (!proto)
     495        proto = arp_protos_find(&device->protos, protocol_unmap(device->service, ntohs(header->protocol)));
     496        if(! proto){
    438497                return ENOENT;
    439 
     498        }
    440499        src_hw = ((uint8_t *) header) + sizeof(arp_header_t);
    441500        src_proto = src_hw + header->hardware_length;
    442501        des_hw = src_proto + header->protocol_length;
    443502        des_proto = des_hw + header->hardware_length;
    444         hw_source = arp_addr_find(&proto->addresses, (char *) src_proto,
    445             CONVERT_SIZE(uint8_t, char, header->protocol_length));
     503        hw_source = arp_addr_find(&proto->addresses, (char *) src_proto, CONVERT_SIZE(uint8_t, char, header->protocol_length));
    446504        // exists?
    447         if (hw_source) {
    448                 if (hw_source->length != CONVERT_SIZE(uint8_t, char,
    449                     header->hardware_length)) {
     505        if(hw_source){
     506                if(hw_source->length != CONVERT_SIZE(uint8_t, char, header->hardware_length)){
    450507                        return EINVAL;
    451508                }
    … …  
    453510        }
    454511        // is my protocol address?
    455         if (proto->addr->length != CONVERT_SIZE(uint8_t, char,
    456             header->protocol_length)) {
     512        if(proto->addr->length != CONVERT_SIZE(uint8_t, char, header->protocol_length)){
    457513                return EINVAL;
    458514        }
    459         if (!str_lcmp(proto->addr->value, (char *) des_proto,
    460             proto->addr->length)) {
     515        if(! str_lcmp(proto->addr->value, (char *) des_proto, proto->addr->length)){
    461516                // not already upadted?
    462                 if (!hw_source) {
    463                         hw_source = measured_string_create_bulk((char *) src_hw,
    464                             CONVERT_SIZE(uint8_t, char,
    465                             header->hardware_length));
    466                         if (!hw_source)
     517                if(! hw_source){
     518                        hw_source = measured_string_create_bulk((char *) src_hw, CONVERT_SIZE(uint8_t, char, header->hardware_length));
     519                        if(! hw_source){
    467520                                return ENOMEM;
    468 
    469                         ERROR_PROPAGATE(arp_addr_add(&proto->addresses,
    470                             (char *) src_proto, CONVERT_SIZE(uint8_t, char,
    471                             header->protocol_length), hw_source));
    472                 }
    473                 if (ntohs(header->operation) == ARPOP_REQUEST) {
     521                        }
     522                        ERROR_PROPAGATE(arp_addr_add(&proto->addresses, (char *) src_proto, CONVERT_SIZE(uint8_t, char, header->protocol_length), hw_source));
     523                }
     524                if(ntohs(header->operation) == ARPOP_REQUEST){
    474525                        header->operation = htons(ARPOP_REPLY);
    475526                        memcpy(des_proto, src_proto, header->protocol_length);
    476                         memcpy(src_proto, proto->addr->value,
    477                             header->protocol_length);
    478                         memcpy(src_hw, device->addr->value,
    479                             device->packet_dimension.addr_len);
    480                         memcpy(des_hw, hw_source->value,
    481                             header->hardware_length);
    482                         ERROR_PROPAGATE(packet_set_addr(packet, src_hw, des_hw,
    483                             header->hardware_length));
    484                         nil_send_msg(device->phone, device_id, packet,
    485                             SERVICE_ARP);
     527                        memcpy(src_proto, proto->addr->value, header->protocol_length);
     528                        memcpy(src_hw, device->addr->value, device->packet_dimension.addr_len);
     529                        memcpy(des_hw, hw_source->value, header->hardware_length);
     530                        ERROR_PROPAGATE(packet_set_addr(packet, src_hw, des_hw, header->hardware_length));
     531                        nil_send_msg(device->phone, device_id, packet, SERVICE_ARP);
    486532                        return 1;
    487533                }
    488534        }
    489 
    490         return EOK;
    491 }
    492 
    493 
    494 /** Returns the hardware address for the given protocol address.
    495  *
    496  * Sends the ARP request packet if the hardware address is not found in the
    497  * cache.
    498  *
    499  * @param[in] device_id The device identifier.
    500  * @param[in] protocol  The protocol service.
    501  * @param[in] target    The target protocol address.
    502  * @returns             The hardware address of the target.
    503  * @returns             NULL if the target parameter is NULL.
    504  * @returns             NULL if the device is not found.
    505  * @returns             NULL if the device packet is too small to send a
    506  *                      request.
    507  * @returns             NULL if the hardware address is not found in the cache.
    508  */
    509 static measured_string_ref
    510 arp_translate_message(device_id_t device_id, services_t protocol,
    511     measured_string_ref target)
    512 {
     535        return EOK;
     536}
     537
     538measured_string_ref arp_translate_message(device_id_t device_id, services_t protocol, measured_string_ref target){
    513539        arp_device_ref device;
    514540        arp_proto_ref proto;
    … …  
    518544        arp_header_ref header;
    519545
    520         if (!target)
     546        if(! target){
    521547                return NULL;
    522 
     548        }
    523549        device = arp_cache_find(&arp_globals.cache, device_id);
    524         if (!device)
     550        if(! device){
    525551                return NULL;
    526 
     552        }
    527553        proto = arp_protos_find(&device->protos, protocol);
    528         if (!proto || (proto->addr->length != target->length))
     554        if((! proto) || (proto->addr->length != target->length)){
    529555                return NULL;
    530 
     556        }
    531557        addr = arp_addr_find(&proto->addresses, target->value, target->length);
    532         if (addr)
     558        if(addr){
    533559                return addr;
    534 
     560        }
    535561        // ARP packet content size = header + (address + translation) * 2
    536         length = 8 + 2 * (CONVERT_SIZE(char, uint8_t, proto->addr->length) +
    537             CONVERT_SIZE(char, uint8_t, device->addr->length));
    538         if (length > device->packet_dimension.content)
     562        length = 8 + (CONVERT_SIZE(char, uint8_t, proto->addr->length) + CONVERT_SIZE(char, uint8_t, device->addr->length)) * 2;
     563        if(length > device->packet_dimension.content){
    539564                return NULL;
    540 
    541         packet = packet_get_4_remote(arp_globals.net_phone,
    542             device->packet_dimension.addr_len, device->packet_dimension.prefix,
    543             length, device->packet_dimension.suffix);
    544         if (!packet)
     565        }
     566        packet = packet_get_4_remote(arp_globals.net_phone, device->packet_dimension.addr_len, device->packet_dimension.prefix, length, device->packet_dimension.suffix);
     567        if(! packet){
    545568                return NULL;
    546 
     569        }
    547570        header = (arp_header_ref) packet_suffix(packet, length);
    548         if (!header) {
     571        if(! header){
    549572                pq_release_remote(arp_globals.net_phone, packet_get_id(packet));
    550573                return NULL;
    551574        }
    552 
    553575        header->hardware = htons(device->hardware);
    554576        header->hardware_length = (uint8_t) device->addr->length;
    … …  
    557579        header->operation = htons(ARPOP_REQUEST);
    558580        length = sizeof(arp_header_t);
    559         memcpy(((uint8_t *) header) + length, device->addr->value,
    560             device->addr->length);
     581        memcpy(((uint8_t *) header) + length, device->addr->value, device->addr->length);
    561582        length += device->addr->length;
    562         memcpy(((uint8_t *) header) + length, proto->addr->value,
    563             proto->addr->length);
     583        memcpy(((uint8_t *) header) + length, proto->addr->value, proto->addr->length);
    564584        length += proto->addr->length;
    565585        bzero(((uint8_t *) header) + length, device->addr->length);
    566586        length += device->addr->length;
    567587        memcpy(((uint8_t *) header) + length, target->value, target->length);
    568 
    569         if (packet_set_addr(packet, (uint8_t *) device->addr->value,
    570             (uint8_t *) device->broadcast_addr->value,
    571             CONVERT_SIZE(char, uint8_t, device->addr->length)) != EOK) {
     588        if(packet_set_addr(packet, (uint8_t *) device->addr->value, (uint8_t *) device->broadcast_addr->value, CONVERT_SIZE(char, uint8_t, device->addr->length)) != EOK){
    572589                pq_release_remote(arp_globals.net_phone, packet_get_id(packet));
    573590                return NULL;
    574591        }
    575 
    576592        nil_send_msg(device->phone, device_id, packet, SERVICE_ARP);
    577593        return NULL;
    578594}
    579595
    580 
    581 /** Processes the ARP message.
    582  *
    583  * @param[in] callid    The message identifier.
    584  * @param[in] call      The message parameters.
    585  * @param[out] answer   The message answer parameters.
    586  * @param[out] answer_count The last parameter for the actual answer in the
    587  *                      answer parameter.
    588  * @returns             EOK on success.
    589  * @returns             ENOTSUP if the message is not known.
    590  *
    591  * @see arp_interface.h
    592  * @see IS_NET_ARP_MESSAGE()
    593  */
    594 int
    595 arp_message_standalone(ipc_callid_t callid, ipc_call_t *call,
    596     ipc_call_t *answer, int *answer_count)
    597 {
    598         ERROR_DECLARE;
    599        
    600         measured_string_ref address;
    601         measured_string_ref translation;
    602         char *data;
    603         packet_t packet;
    604         packet_t next;
    605        
    606         *answer_count = 0;
    607         switch (IPC_GET_METHOD(*call)) {
    608         case IPC_M_PHONE_HUNGUP:
    609                 return EOK;
    610        
    611         case NET_ARP_DEVICE:
    612                 ERROR_PROPAGATE(measured_strings_receive(&address, &data, 1));
    613                 if (ERROR_OCCURRED(arp_device_message(IPC_GET_DEVICE(call),
    614                     IPC_GET_SERVICE(call), ARP_GET_NETIF(call), address))) {
    615                         free(address);
    616                         free(data);
    617                 }
    618                 return ERROR_CODE;
    619        
    620         case NET_ARP_TRANSLATE:
    621                 ERROR_PROPAGATE(measured_strings_receive(&address, &data, 1));
    622                 fibril_rwlock_read_lock(&arp_globals.lock);
    623                 translation = arp_translate_message(IPC_GET_DEVICE(call),
    624                     IPC_GET_SERVICE(call), address);
    625                 free(address);
    626                 free(data);
    627                 if (!translation) {
    628                         fibril_rwlock_read_unlock(&arp_globals.lock);
    629                         return ENOENT;
    630                 }
    631                 ERROR_CODE = measured_strings_reply(translation, 1);
    632                 fibril_rwlock_read_unlock(&arp_globals.lock);
    633                 return ERROR_CODE;
    634 
    635         case NET_ARP_CLEAR_DEVICE:
    636                 return arp_clear_device_req(0, IPC_GET_DEVICE(call));
    637 
    638         case NET_ARP_CLEAR_ADDRESS:
    639                 ERROR_PROPAGATE(measured_strings_receive(&address, &data, 1));
    640                 arp_clear_address_req(0, IPC_GET_DEVICE(call),
    641                     IPC_GET_SERVICE(call), address);
    642                 free(address);
    643                 free(data);
    644                 return EOK;
    645        
    646         case NET_ARP_CLEAN_CACHE:
    647                 return arp_clean_cache_req(0);
    648        
    649         case NET_IL_DEVICE_STATE:
    650                 // do nothing - keep the cache
    651                 return EOK;
    652        
    653         case NET_IL_RECEIVED:
    654                 if (ERROR_NONE(packet_translate_remote(arp_globals.net_phone,
    655                     &packet, IPC_GET_PACKET(call)))) {
    656                         fibril_rwlock_read_lock(&arp_globals.lock);
    657                         do {
    658                                 next = pq_detach(packet);
    659                                 ERROR_CODE =
    660                                     arp_receive_message(IPC_GET_DEVICE(call),
    661                                     packet);
    662                                 if (ERROR_CODE != 1) {
    663                                         pq_release_remote(arp_globals.net_phone,
    664                                             packet_get_id(packet));
    665                                 }
    666                                 packet = next;
    667                         } while (packet);
    668                         fibril_rwlock_read_unlock(&arp_globals.lock);
    669                 }
    670                 return ERROR_CODE;
    671        
    672         case NET_IL_MTU_CHANGED:
    673                 return arp_mtu_changed_message(IPC_GET_DEVICE(call),
    674                     IPC_GET_MTU(call));
    675         }
    676        
    677         return ENOTSUP;
    678 }
    679 
    680596/** Default thread for new connections.
    681597 *
    682  * @param[in] iid       The initial message identifier.
    683  * @param[in] icall     The initial message call structure.
    684  */
    685 static void il_client_connection(ipc_callid_t iid, ipc_call_t *icall)
     598 *  @param[in] iid The initial message identifier.
     599 *  @param[in] icall The initial message call structure.
     600 *
     601 */
     602static void il_client_connection(ipc_callid_t iid, ipc_call_t * icall)
    686603{
    687604        /*
    … …  
    691608        ipc_answer_0(iid, EOK);
    692609       
    693         while (true) {
     610        while(true) {
    694611                ipc_call_t answer;
    695612                int answer_count;
    … …  
    706623                    &answer_count);
    707624               
    708                 /*
    709                  * End if told to either by the message or the processing
    710                  * result.
    711                  */
    712                 if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
    713                     (res == EHANGUP))
     625                /* End if said to either by the message or the processing result */
     626                if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) || (res == EHANGUP))
    714627                        return;
    715628               
    … …  
    721634/** Starts the module.
    722635 *
    723  * @returns             EOK on success.
    724  * @returns             Other error codes as defined for each specific module
    725  *                      start function.
     636 *  @param argc The count of the command line arguments. Ignored parameter.
     637 *  @param argv The command line parameters. Ignored parameter.
     638 *
     639 *  @returns EOK on success.
     640 *  @returns Other error codes as defined for each specific module start function.
     641 *
    726642 */
    727643int main(int argc, char *argv[])
    … …  
    730646       
    731647        /* Start the module */
    732         ERROR_PROPAGATE(il_module_start_standalone(il_client_connection));
     648        if (ERROR_OCCURRED(il_module_start_standalone(il_client_connection)))
     649                return ERROR_CODE;
     650       
    733651        return EOK;
    734652}
    … …  
    736654/** @}
    737655 */
    738 
Note: See TracChangeset for help on using the changeset viewer.