Changeset 89c57b6 in mainline for uspace/srv/net/il/arp/arp.c

Timestamp:

2011-04-13T14:45:41Z (14 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

88634420

Parents:

cefb126 (diff), 17279ead (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 mainline changes.

File:

• uspace/srv/net/il/arp/arp.c (modified) (3 diffs)

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

@@ -28 +28 @@
 
 /** @addtogroup arp
- *  @{
+ * @{
  */
 
 /** @file
- *  ARP module implementation.
- *  @see arp.h
+ * ARP module implementation.
+ * @see arp.h
  */
 
@@ -40 +40 @@
 #include <mem.h>
 #include <fibril_synch.h>
+#include <assert.h>
 #include <stdio.h>
 #include <str.h>
 #include <task.h>
-#include <ipc/ipc.h>
+#include <adt/measured_strings.h>
 #include <ipc/services.h>
-
-#include <net_err.h>
-#include <net_messages.h>
-#include <net_modules.h>
-#include <net_byteorder.h>
-#include <net_device.h>
-#include <arp_interface.h>
-#include <nil_interface.h>
+#include <ipc/net.h>
+#include <ipc/arp.h>
+#include <ipc/il.h>
+#include <ipc/nil.h>
+#include <byteorder.h>
+#include <errno.h>
+#include <net/modules.h>
+#include <net/device.h>
+#include <net/packet.h>
+#include <nil_remote.h>
 #include <protocol_map.h>
-#include <adt/measured_strings.h>
-#include <packet/packet.h>
-#include <packet/packet_client.h>
+#include <packet_client.h>
 #include <packet_remote.h>
-#include <il_messages.h>
-#include <il_interface.h>
-#include <il_local.h>
-#include <arp_messages.h>
-
+#include <il_remote.h>
+#include <il_skel.h>
 #include "arp.h"
-#include "arp_header.h"
-#include "arp_oc.h"
-#include "arp_module.h"
-
-
-/** ARP module name.
- */
+
+/** ARP module name. */
 #define NAME  "arp"
 
-/** ARP global data.
- */
-arp_globals_t   arp_globals;
-
-/** Clears the device specific data.
- *  @param[in] device The device specific data.
- */
-void arp_clear_device(arp_device_ref device);
-
-/** Creates new protocol specific data.
- *  Allocates and returns the needed memory block as the proto parameter.
- *  @param[out] proto The allocated protocol specific data.
- *  @param[in] service The protocol module service.
- *  @param[in] address The actual protocol device address.
- *  @returns EOK on success.
- *  @returns ENOMEM if there is not enough memory left.
- */
-int arp_proto_create(arp_proto_ref * proto, services_t service, measured_string_ref address);
-
-/** @name Message processing functions
- */
+/** Number of microseconds to wait for an ARP reply. */
+#define ARP_TRANS_WAIT  1000000
+
+/** @name ARP operation codes definitions */
 /*@{*/
 
-/** Registers the device.
- *  Creates new device entry in the cache or updates the protocol address if the device with the device identifier and the driver service exists.
- *  @param[in] device_id The device identifier.
- *  @param[in] service The device driver service.
- *  @param[in] protocol The protocol service.
- *  @param[in] address The actual device protocol address.
- *  @returns EOK on success.
- *  @returns EEXIST if another device with the same device identifier and different driver service exists.
- *  @returns ENOMEM if there is not enough memory left.
- *  @returns Other error codes as defined for the measured_strings_return() function.
- */
-int arp_device_message(device_id_t device_id, services_t service, services_t protocol, measured_string_ref address);
-
-/** Updates the device content length according to the new MTU value.
- *  @param[in] device_id The device identifier.
- *  @param[in] mtu The new mtu value.
- *  @returns ENOENT if device is not found.
- *  @returns EOK on success.
- */
-int arp_mtu_changed_message(device_id_t device_id, size_t mtu);
-
-/** Processes the received ARP packet.
- *  Updates the source hardware address if the source entry exists or the packet is targeted to my protocol address.
- *  Responses to the ARP request if the packet is the ARP request and is targeted to my address.
- *  @param[in] device_id The source device identifier.
- *  @param[in,out] packet The received packet.
- *  @returns EOK on success and the packet is no longer needed.
- *  @returns 1 on success and the packet has been reused.
- *  @returns EINVAL if the packet is too small to carry an ARP packet.
- *  @returns EINVAL if the received address lengths differs from the registered values.
- *  @returns ENOENT if the device is not found in the cache.
- *  @returns ENOENT if the protocol for the device is not found in the cache.
- *  @returns ENOMEM if there is not enough memory left.
- */
-int arp_receive_message(device_id_t device_id, packet_t packet);
-
-/** Returns the hardware address for the given protocol address.
- *  Sends the ARP request packet if the hardware address is not found in the cache.
- *  @param[in] device_id The device identifier.
- *  @param[in] protocol The protocol service.
- *  @param[in] target The target protocol address.
- *  @returns The hardware address of the target.
- *  @returns NULL if the target parameter is NULL.
- *  @returns NULL if the device is not found.
- *  @returns NULL if the device packet is too small to send a&nbsp;request.
- *  @returns NULL if the hardware address is not found in the cache.
- */
-measured_string_ref arp_translate_message(device_id_t device_id, services_t protocol, measured_string_ref target);
+/** REQUEST operation code. */
+#define ARPOP_REQUEST  1
+
+/** REPLY operation code. */
+#define ARPOP_REPLY  2
 
 /*@}*/
 
-DEVICE_MAP_IMPLEMENT(arp_cache, arp_device_t)
-
-INT_MAP_IMPLEMENT(arp_protos, arp_proto_t)
-
-GENERIC_CHAR_MAP_IMPLEMENT(arp_addr, measured_string_t)
-
-int arp_clean_cache_req(int arp_phone){
+/** Type definition of an ARP protocol header.
+ * @see arp_header
+ */
+typedef struct arp_header arp_header_t;
+
+/** ARP protocol header. */
+struct arp_header {
+        /**
+         * Hardware type identifier.
+         * @see hardware.h
+         */
+        uint16_t hardware;
+        
+        /** Protocol identifier. */
+        uint16_t protocol;
+        /** Hardware address length in bytes. */
+        uint8_t hardware_length;
+        /** Protocol address length in bytes. */
+        uint8_t protocol_length;
+        
+        /**
+         * ARP packet type.
+         * @see arp_oc.h
+         */
+        uint16_t operation;
+} __attribute__ ((packed));
+
+/** ARP global data. */
+arp_globals_t arp_globals;
+
+DEVICE_MAP_IMPLEMENT(arp_cache, arp_device_t);
+INT_MAP_IMPLEMENT(arp_protos, arp_proto_t);
+GENERIC_CHAR_MAP_IMPLEMENT(arp_addr, arp_trans_t);
+
+static void arp_clear_trans(arp_trans_t *trans)
+{
+        if (trans->hw_addr) {
+                free(trans->hw_addr);
+                trans->hw_addr = NULL;
+        }
+        
+        fibril_condvar_broadcast(&trans->cv);
+}
+
+static void arp_clear_addr(arp_addr_t *addresses)
+{
         int count;
-        arp_device_ref device;
-
-        fibril_rwlock_write_lock(&arp_globals.lock);
-        for(count = arp_cache_count(&arp_globals.cache) - 1; count >= 0; -- count){
-                device = arp_cache_get_index(&arp_globals.cache, count);
-                if(device){
+        
+        for (count = arp_addr_count(addresses) - 1; count >= 0; count--) {
+                arp_trans_t *trans = arp_addr_items_get_index(&addresses->values,
+                    count);
+                if (trans)
+                        arp_clear_trans(trans);
+        }
+}
+
+/** Clear the device specific data.
+ *
+ * @param[in] device Device specific data.
+ */
+static void arp_clear_device(arp_device_t *device)
+{
+        int count;
+        
+        for (count = arp_protos_count(&device->protos) - 1; count >= 0;
+            count--) {
+                arp_proto_t *proto = arp_protos_get_index(&device->protos,
+                    count);
+                
+                if (proto) {
+                        if (proto->addr)
+                                free(proto->addr);
+                        
+                        if (proto->addr_data)
+                                free(proto->addr_data);
+                        
+                        arp_clear_addr(&proto->addresses);
+                        arp_addr_destroy(&proto->addresses, free);
+                }
+        }
+        
+        arp_protos_clear(&device->protos, free);
+}
+
+static int arp_clean_cache_req(int arp_phone)
+{
+        int count;
+        
+        fibril_mutex_lock(&arp_globals.lock);
+        for (count = arp_cache_count(&arp_globals.cache) - 1; count >= 0;
+            count--) {
+                arp_device_t *device = arp_cache_get_index(&arp_globals.cache,
+                    count);
+                
+                if (device) {
                         arp_clear_device(device);
-                        if(device->addr_data){
+                        if (device->addr_data)
                                 free(device->addr_data);
+                        
+                        if (device->broadcast_data)
+                                free(device->broadcast_data);
+                }
+        }
+        
+        arp_cache_clear(&arp_globals.cache, free);
+        fibril_mutex_unlock(&arp_globals.lock);
+        
+        return EOK;
+}
+
+static int arp_clear_address_req(int arp_phone, device_id_t device_id,
+    services_t protocol, measured_string_t *address)
+{
+        fibril_mutex_lock(&arp_globals.lock);
+        
+        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
+        if (!device) {
+                fibril_mutex_unlock(&arp_globals.lock);
+                return ENOENT;
+        }
+        
+        arp_proto_t *proto = arp_protos_find(&device->protos, protocol);
+        if (!proto) {
+                fibril_mutex_unlock(&arp_globals.lock);
+                return ENOENT;
+        }
+        
+        arp_trans_t *trans = arp_addr_find(&proto->addresses, address->value,
+            address->length);
+        if (trans)
+                arp_clear_trans(trans);
+        
+        arp_addr_exclude(&proto->addresses, address->value, address->length, free);
+        
+        fibril_mutex_unlock(&arp_globals.lock);
+        return EOK;
+}
+
+static int arp_clear_device_req(int arp_phone, device_id_t device_id)
+{
+        fibril_mutex_lock(&arp_globals.lock);
+        
+        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
+        if (!device) {
+                fibril_mutex_unlock(&arp_globals.lock);
+                return ENOENT;
+        }
+        
+        arp_clear_device(device);
+        
+        fibril_mutex_unlock(&arp_globals.lock);
+        return EOK;
+}
+
+/** Create new protocol specific data.
+ *
+ * Allocate and return the needed memory block as the proto parameter.
+ *
+ * @param[out] proto   Allocated protocol specific data.
+ * @param[in]  service Protocol module service.
+ * @param[in]  address Actual protocol device address.
+ *
+ * @return EOK on success.
+ * @return ENOMEM if there is not enough memory left.
+ *
+ */
+static int arp_proto_create(arp_proto_t **proto, services_t service,
+    measured_string_t *address)
+{
+        *proto = (arp_proto_t *) malloc(sizeof(arp_proto_t));
+        if (!*proto)
+                return ENOMEM;
+        
+        (*proto)->service = service;
+        (*proto)->addr = address;
+        (*proto)->addr_data = address->value;
+        
+        int rc = arp_addr_initialize(&(*proto)->addresses);
+        if (rc != EOK) {
+                free(*proto);
+                return rc;
+        }
+        
+        return EOK;
+}
+
+/** Process the received ARP packet.
+ *
+ * Update the source hardware address if the source entry exists or the packet
+ * is targeted to my protocol address.
+ *
+ * Respond to the ARP request if the packet is the ARP request and is
+ * targeted to my address.
+ *
+ * @param[in]     device_id Source device identifier.
+ * @param[in,out] packet    Received packet.
+ *
+ * @return EOK on success and the packet is no longer needed.
+ * @return One on success and the packet has been reused.
+ * @return EINVAL if the packet is too small to carry an ARP
+ *         packet.
+ * @return EINVAL if the received address lengths differs from
+ *         the registered values.
+ * @return ENOENT if the device is not found in the cache.
+ * @return ENOENT if the protocol for the device is not found in
+ *         the cache.
+ * @return ENOMEM if there is not enough memory left.
+ *
+ */
+static int arp_receive_message(device_id_t device_id, packet_t *packet)
+{
+        int rc;
+        
+        size_t length = packet_get_data_length(packet);
+        if (length <= sizeof(arp_header_t))
+                return EINVAL;
+        
+        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
+        if (!device)
+                return ENOENT;
+        
+        arp_header_t *header = (arp_header_t *) packet_get_data(packet);
+        if ((ntohs(header->hardware) != device->hardware) ||
+            (length < sizeof(arp_header_t) + header->hardware_length * 2U +
+            header->protocol_length * 2U)) {
+                return EINVAL;
+        }
+        
+        arp_proto_t *proto = arp_protos_find(&device->protos,
+            protocol_unmap(device->service, ntohs(header->protocol)));
+        if (!proto)
+                return ENOENT;
+        
+        uint8_t *src_hw = ((uint8_t *) header) + sizeof(arp_header_t);
+        uint8_t *src_proto = src_hw + header->hardware_length;
+        uint8_t *des_hw = src_proto + header->protocol_length;
+        uint8_t *des_proto = des_hw + header->hardware_length;
+        
+        arp_trans_t *trans = arp_addr_find(&proto->addresses, src_proto,
+            header->protocol_length);
+        
+        if ((trans) && (trans->hw_addr)) {
+                /* Translation exists */
+                if (trans->hw_addr->length != header->hardware_length)
+                        return EINVAL;
+                
+                memcpy(trans->hw_addr->value, src_hw, trans->hw_addr->length);
+        }
+        
+        /* Is my protocol address? */
+        if (proto->addr->length != header->protocol_length)
+                return EINVAL;
+        
+        if (!bcmp(proto->addr->value, des_proto, proto->addr->length)) {
+                if (!trans) {
+                        /* Update the translation */
+                        trans = (arp_trans_t *) malloc(sizeof(arp_trans_t));
+                        if (!trans)
+                                return ENOMEM;
+                        
+                        trans->hw_addr = NULL;
+                        fibril_condvar_initialize(&trans->cv);
+                        rc = arp_addr_add(&proto->addresses, src_proto,
+                            header->protocol_length, trans);
+                        if (rc != EOK) {
+                                free(trans);
+                                return rc;
                         }
-                        if(device->broadcast_data){
-                                free(device->broadcast_data);
+                }
+                
+                if (!trans->hw_addr) {
+                        trans->hw_addr = measured_string_create_bulk(src_hw,
+                            header->hardware_length);
+                        if (!trans->hw_addr)
+                                return ENOMEM;
+                        
+                        /* Notify the fibrils that wait for the translation. */
+                        fibril_condvar_broadcast(&trans->cv);
+                }
+                
+                if (ntohs(header->operation) == ARPOP_REQUEST) {
+                        header->operation = htons(ARPOP_REPLY);
+                        memcpy(des_proto, src_proto, header->protocol_length);
+                        memcpy(src_proto, proto->addr->value,
+                            header->protocol_length);
+                        memcpy(src_hw, device->addr->value,
+                            device->packet_dimension.addr_len);
+                        memcpy(des_hw, trans->hw_addr->value,
+                            header->hardware_length);
+                        
+                        rc = packet_set_addr(packet, src_hw, des_hw,
+                            header->hardware_length);
+                        if (rc != EOK)
+                                return rc;
+                        
+                        nil_send_msg(device->phone, device_id, packet,
+                            SERVICE_ARP);
+                        return 1;
+                }
+        }
+        
+        return EOK;
+}
+
+/** Update the device content length according to the new MTU value.
+ *
+ * @param[in] device_id Device identifier.
+ * @param[in] mtu       New MTU value.
+ *
+ * @return ENOENT if device is not found.
+ * @return EOK on success.
+ *
+ */
+static int arp_mtu_changed_message(device_id_t device_id, size_t mtu)
+{
+        fibril_mutex_lock(&arp_globals.lock);
+        
+        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
+        if (!device) {
+                fibril_mutex_unlock(&arp_globals.lock);
+                return ENOENT;
+        }
+        
+        device->packet_dimension.content = mtu;
+        
+        fibril_mutex_unlock(&arp_globals.lock);
+        
+        printf("%s: Device %d changed MTU to %zu\n", NAME, device_id, mtu);
+        
+        return EOK;
+}
+
+/** Process IPC messages from the registered device driver modules
+ *
+ * @param[in]     iid   Message identifier.
+ * @param[in,out] icall Message parameters.
+ *
+ */
+static void arp_receiver(ipc_callid_t iid, ipc_call_t *icall)
+{
+        packet_t *packet;
+        int rc;
+        
+        while (true) {
+                switch (IPC_GET_IMETHOD(*icall)) {
+                case NET_IL_DEVICE_STATE:
+                        /* Do nothing - keep the cache */
+                        async_answer_0(iid, (sysarg_t) EOK);
+                        break;
+                
+                case NET_IL_RECEIVED:
+                        rc = packet_translate_remote(arp_globals.net_phone, &packet,
+                            IPC_GET_PACKET(*icall));
+                        if (rc == EOK) {
+                                fibril_mutex_lock(&arp_globals.lock);
+                                do {
+                                        packet_t *next = pq_detach(packet);
+                                        rc = arp_receive_message(IPC_GET_DEVICE(*icall), packet);
+                                        if (rc != 1) {
+                                                pq_release_remote(arp_globals.net_phone,
+                                                    packet_get_id(packet));
+                                        }
+                                        
+                                        packet = next;
+                                } while (packet);
+                                fibril_mutex_unlock(&arp_globals.lock);
                         }
-                }
-        }
-        arp_cache_clear(&arp_globals.cache);
-        fibril_rwlock_write_unlock(&arp_globals.lock);
-        printf("Cache cleaned\n");
-        return EOK;
-}
-
-int arp_clear_address_req(int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address){
-        arp_device_ref device;
-        arp_proto_ref proto;
-
-        fibril_rwlock_write_lock(&arp_globals.lock);
-        device = arp_cache_find(&arp_globals.cache, device_id);
-        if(! device){
-                fibril_rwlock_write_unlock(&arp_globals.lock);
-                return ENOENT;
-        }
-        proto = arp_protos_find(&device->protos, protocol);
-        if(! proto){
-                fibril_rwlock_write_unlock(&arp_globals.lock);
-                return ENOENT;
-        }
-        arp_addr_exclude(&proto->addresses, address->value, address->length);
-        fibril_rwlock_write_unlock(&arp_globals.lock);
-        return EOK;
-}
-
-void arp_clear_device(arp_device_ref device){
-        int count;
-        arp_proto_ref proto;
-
-        for(count = arp_protos_count(&device->protos) - 1; count >= 0; -- count){
-                proto = arp_protos_get_index(&device->protos, count);
-                if(proto){
-                        if(proto->addr){
-                                free(proto->addr);
-                        }
-                        if(proto->addr_data){
-                                free(proto->addr_data);
-                        }
-                        arp_addr_destroy(&proto->addresses);
-                }
-        }
-        arp_protos_clear(&device->protos);
-}
-
-int arp_clear_device_req(int arp_phone, device_id_t device_id){
-        arp_device_ref device;
-
-        fibril_rwlock_write_lock(&arp_globals.lock);
-        device = arp_cache_find(&arp_globals.cache, device_id);
-        if(! device){
-                fibril_rwlock_write_unlock(&arp_globals.lock);
-                return ENOENT;
-        }
-        arp_clear_device(device);
-        printf("Device %d cleared\n", device_id);
-        fibril_rwlock_write_unlock(&arp_globals.lock);
-        return EOK;
-}
-
-int arp_connect_module(services_t service){
-        if(service != SERVICE_ARP){
-                return EINVAL;
-        }
-        return EOK;
-}
-
-int arp_device_message(device_id_t device_id, services_t service, services_t protocol, measured_string_ref address){
-        ERROR_DECLARE;
-
-        arp_device_ref device;
-        arp_proto_ref proto;
+                        async_answer_0(iid, (sysarg_t) rc);
+                        break;
+                
+                case NET_IL_MTU_CHANGED:
+                        rc = arp_mtu_changed_message(IPC_GET_DEVICE(*icall),
+                            IPC_GET_MTU(*icall));
+                        async_answer_0(iid, (sysarg_t) rc);
+                        break;
+                
+                default:
+                        async_answer_0(iid, (sysarg_t) ENOTSUP);
+                }
+                
+                iid = async_get_call(icall);
+        }
+}
+
+/** Register the device.
+ *
+ * Create new device entry in the cache or update the protocol address if the
+ * device with the device identifier and the driver service exists.
+ *
+ * @param[in] device_id Device identifier.
+ * @param[in] service   Device driver service.
+ * @param[in] protocol  Protocol service.
+ * @param[in] address   Actual device protocol address.
+ *
+ * @return EOK on success.
+ * @return EEXIST if another device with the same device identifier
+ *         and different driver service exists.
+ * @return ENOMEM if there is not enough memory left.
+ * @return Other error codes as defined for the
+ *         measured_strings_return() function.
+ *
+ */
+static int arp_device_message(device_id_t device_id, services_t service,
+    services_t protocol, measured_string_t *address)
+{
         int index;
-        hw_type_t hardware;
-
-        fibril_rwlock_write_lock(&arp_globals.lock);
-        // an existing device?
-        device = arp_cache_find(&arp_globals.cache, device_id);
-        if(device){
-                if(device->service != service){
-                        printf("Device %d already exists\n", device->device_id);
-                        fibril_rwlock_write_unlock(&arp_globals.lock);
+        int rc;
+        
+        fibril_mutex_lock(&arp_globals.lock);
+        
+        /* An existing device? */
+        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
+        if (device) {
+                if (device->service != service) {
+                        printf("%s: Device %d already exists\n", NAME,
+                            device->device_id);
+                        fibril_mutex_unlock(&arp_globals.lock);
                         return EEXIST;
                 }
-                proto = arp_protos_find(&device->protos, protocol);
-                if(proto){
+                
+                arp_proto_t *proto = arp_protos_find(&device->protos, protocol);
+                if (proto) {
                         free(proto->addr);
                         free(proto->addr_data);
                         proto->addr = address;
                         proto->addr_data = address->value;
-                }else{
-                        if(ERROR_OCCURRED(arp_proto_create(&proto, protocol, address))){
-                                fibril_rwlock_write_unlock(&arp_globals.lock);
-                                return ERROR_CODE;
+                } else {
+                        rc = arp_proto_create(&proto, protocol, address);
+                        if (rc != EOK) {
+                                fibril_mutex_unlock(&arp_globals.lock);
+                                return rc;
                         }
-                        index = arp_protos_add(&device->protos, proto->service, proto);
-                        if(index < 0){
-                                fibril_rwlock_write_unlock(&arp_globals.lock);
+                        
+                        index = arp_protos_add(&device->protos, proto->service,
+                            proto);
+                        if (index < 0) {
+                                fibril_mutex_unlock(&arp_globals.lock);
                                 free(proto);
                                 return index;
                         }
-                        printf("New protocol added:\n\tdevice id\t= %d\n\tproto\t= %d", device_id, protocol);
-                }
-        }else{
-                hardware = hardware_map(service);
-                if(! hardware){
+                        
+                        printf("%s: New protocol added (id: %d, proto: %d)\n", NAME,
+                            device_id, protocol);
+                }
+        } else {
+                hw_type_t hardware = hardware_map(service);
+                if (!hardware)
                         return ENOENT;
-                }
-                // create a new device
-                device = (arp_device_ref) malloc(sizeof(arp_device_t));
-                if(! device){
-                        fibril_rwlock_write_unlock(&arp_globals.lock);
+                
+                /* Create new device */
+                device = (arp_device_t *) malloc(sizeof(arp_device_t));
+                if (!device) {
+                        fibril_mutex_unlock(&arp_globals.lock);
                         return ENOMEM;
                 }
+                
                 device->hardware = hardware;
                 device->device_id = device_id;
-                if(ERROR_OCCURRED(arp_protos_initialize(&device->protos))
-                        || ERROR_OCCURRED(arp_proto_create(&proto, protocol, address))){
-                        fibril_rwlock_write_unlock(&arp_globals.lock);
+                rc = arp_protos_initialize(&device->protos);
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&arp_globals.lock);
                         free(device);
-                        return ERROR_CODE;
-                }
+                        return rc;
+                }
+                
+                arp_proto_t *proto;
+                rc = arp_proto_create(&proto, protocol, address);
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        free(device);
+                        return rc;
+                }
+                
                 index = arp_protos_add(&device->protos, proto->service, proto);
-                if(index < 0){
-                        fibril_rwlock_write_unlock(&arp_globals.lock);
-                        arp_protos_destroy(&device->protos);
+                if (index < 0) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        arp_protos_destroy(&device->protos, free);
                         free(device);
                         return index;
                 }
+                
                 device->service = service;
-                // bind the new one
-                device->phone = nil_bind_service(device->service, (ipcarg_t) device->device_id, SERVICE_ARP, arp_globals.client_connection);
-                if(device->phone < 0){
-                        fibril_rwlock_write_unlock(&arp_globals.lock);
-                        arp_protos_destroy(&device->protos);
+                
+                /* Bind */
+                device->phone = nil_bind_service(device->service,
+                    (sysarg_t) device->device_id, SERVICE_ARP,
+                    arp_receiver);
+                if (device->phone < 0) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        arp_protos_destroy(&device->protos, free);
                         free(device);
                         return EREFUSED;
                 }
-                // get packet dimensions
-                if(ERROR_OCCURRED(nil_packet_size_req(device->phone, device_id, &device->packet_dimension))){
-                        fibril_rwlock_write_unlock(&arp_globals.lock);
-                        arp_protos_destroy(&device->protos);
+                
+                /* Get packet dimensions */
+                rc = nil_packet_size_req(device->phone, device_id,
+                    &device->packet_dimension);
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        arp_protos_destroy(&device->protos, free);
                         free(device);
-                        return ERROR_CODE;
-                }
-                // get hardware address
-                if(ERROR_OCCURRED(nil_get_addr_req(device->phone, device_id, &device->addr, &device->addr_data))){
-                        fibril_rwlock_write_unlock(&arp_globals.lock);
-                        arp_protos_destroy(&device->protos);
+                        return rc;
+                }
+                
+                /* Get hardware address */
+                rc = nil_get_addr_req(device->phone, device_id, &device->addr,
+                    &device->addr_data);
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        arp_protos_destroy(&device->protos, free);
                         free(device);
-                        return ERROR_CODE;
-                }
-                // get broadcast address
-                if(ERROR_OCCURRED(nil_get_broadcast_addr_req(device->phone, device_id, &device->broadcast_addr, &device->broadcast_data))){
-                        fibril_rwlock_write_unlock(&arp_globals.lock);
+                        return rc;
+                }
+                
+                /* Get broadcast address */
+                rc = nil_get_broadcast_addr_req(device->phone, device_id,
+                    &device->broadcast_addr, &device->broadcast_data);
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&arp_globals.lock);
                         free(device->addr);
                         free(device->addr_data);
-                        arp_protos_destroy(&device->protos);
+                        arp_protos_destroy(&device->protos, free);
                         free(device);
-                        return ERROR_CODE;
-                }
-                if(ERROR_OCCURRED(arp_cache_add(&arp_globals.cache, device->device_id, device))){
-                        fibril_rwlock_write_unlock(&arp_globals.lock);
+                        return rc;
+                }
+                
+                rc = arp_cache_add(&arp_globals.cache, device->device_id,
+                    device);
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&arp_globals.lock);
                         free(device->addr);
                         free(device->addr_data);
                         free(device->broadcast_addr);
                         free(device->broadcast_data);
-                        arp_protos_destroy(&device->protos);
+                        arp_protos_destroy(&device->protos, free);
                         free(device);
-                        return ERROR_CODE;
-                }
-                printf("%s: Device registered (id: %d, type: 0x%x, service: %d, proto: %d)\n",
-                    NAME, device->device_id, device->hardware, device->service, protocol);
-        }
-        fibril_rwlock_write_unlock(&arp_globals.lock);
+                        return rc;
+                }
+                printf("%s: Device registered (id: %d, type: 0x%x, service: %d,"
+                    " proto: %d)\n", NAME, device->device_id, device->hardware,
+                    device->service, protocol);
+        }
+        
+        fibril_mutex_unlock(&arp_globals.lock);
         return EOK;
 }
 
-int arp_device_req(int arp_phone, device_id_t device_id, services_t protocol, services_t netif, measured_string_ref address){
-        ERROR_DECLARE;
-
-        measured_string_ref tmp;
-
-        // copy the given address for exclusive use
-        tmp = measured_string_copy(address);
-        if(ERROR_OCCURRED(arp_device_message(device_id, netif, protocol, tmp))){
-                free(tmp->value);
-                free(tmp);
-        }
-        return ERROR_CODE;
-}
-
-int arp_initialize(async_client_conn_t client_connection){
-        ERROR_DECLARE;
-
-        fibril_rwlock_initialize(&arp_globals.lock);
-        fibril_rwlock_write_lock(&arp_globals.lock);
-        arp_globals.client_connection = client_connection;
-        ERROR_PROPAGATE(arp_cache_initialize(&arp_globals.cache));
-        fibril_rwlock_write_unlock(&arp_globals.lock);
-        return EOK;
-}
-
-int arp_message_standalone(ipc_callid_t callid, ipc_call_t *call,
-    ipc_call_t *answer, int *answer_count)
-{
-        ERROR_DECLARE;
-        
-        measured_string_ref address;
-        measured_string_ref translation;
-        char * data;
-        packet_t packet;
-        packet_t next;
-        
-        *answer_count = 0;
-        switch (IPC_GET_METHOD(*call)) {
-                case IPC_M_PHONE_HUNGUP:
-                        return EOK;
-                case NET_ARP_DEVICE:
-                        ERROR_PROPAGATE(measured_strings_receive(&address, &data, 1));
-                        if(ERROR_OCCURRED(arp_device_message(IPC_GET_DEVICE(call), IPC_GET_SERVICE(call), ARP_GET_NETIF(call), address))){
-                                free(address);
-                                free(data);
-                        }
-                        return ERROR_CODE;
-                case NET_ARP_TRANSLATE:
-                        ERROR_PROPAGATE(measured_strings_receive(&address, &data, 1));
-                        fibril_rwlock_read_lock(&arp_globals.lock);
-                        translation = arp_translate_message(IPC_GET_DEVICE(call), IPC_GET_SERVICE(call), address);
-                        free(address);
-                        free(data);
-                        if(! translation){
-                                fibril_rwlock_read_unlock(&arp_globals.lock);
-                                return ENOENT;
-                        }
-                        ERROR_CODE = measured_strings_reply(translation, 1);
-                        fibril_rwlock_read_unlock(&arp_globals.lock);
-                        return ERROR_CODE;
-                case NET_ARP_CLEAR_DEVICE:
-                        return arp_clear_device_req(0, IPC_GET_DEVICE(call));
-                case NET_ARP_CLEAR_ADDRESS:
-                        ERROR_PROPAGATE(measured_strings_receive(&address, &data, 1));
-                        arp_clear_address_req(0, IPC_GET_DEVICE(call), IPC_GET_SERVICE(call), address);
-                        free(address);
-                        free(data);
-                        return EOK;
-                case NET_ARP_CLEAN_CACHE:
-                        return arp_clean_cache_req(0);
-                case NET_IL_DEVICE_STATE:
-                        // do nothing - keep the cache
-                        return EOK;
-                case NET_IL_RECEIVED:
-                        if(! ERROR_OCCURRED(packet_translate_remote(arp_globals.net_phone, &packet, IPC_GET_PACKET(call)))){
-                                fibril_rwlock_read_lock(&arp_globals.lock);
-                                do{
-                                        next = pq_detach(packet);
-                                        ERROR_CODE = arp_receive_message(IPC_GET_DEVICE(call), packet);
-                                        if(ERROR_CODE != 1){
-                                                pq_release_remote(arp_globals.net_phone, packet_get_id(packet));
-                                        }
-                                        packet = next;
-                                }while(packet);
-                                fibril_rwlock_read_unlock(&arp_globals.lock);
-                        }
-                        return ERROR_CODE;
-                case NET_IL_MTU_CHANGED:
-                        return arp_mtu_changed_message(IPC_GET_DEVICE(call), IPC_GET_MTU(call));
-        }
-        
-        return ENOTSUP;
-}
-
-int arp_mtu_changed_message(device_id_t device_id, size_t mtu){
-        arp_device_ref device;
-
-        fibril_rwlock_write_lock(&arp_globals.lock);
-        device = arp_cache_find(&arp_globals.cache, device_id);
-        if(! device){
-                fibril_rwlock_write_unlock(&arp_globals.lock);
-                return ENOENT;
-        }
-        device->packet_dimension.content = mtu;
-        printf("arp - device %d changed mtu to %d\n\n", device_id, mtu);
-        fibril_rwlock_write_unlock(&arp_globals.lock);
-        return EOK;
-}
-
-int arp_proto_create(arp_proto_ref * proto, services_t service, measured_string_ref address){
-        ERROR_DECLARE;
-
-        *proto = (arp_proto_ref) malloc(sizeof(arp_proto_t));
-        if(!(*proto)){
+int il_initialize(int net_phone)
+{
+        fibril_mutex_initialize(&arp_globals.lock);
+        
+        fibril_mutex_lock(&arp_globals.lock);
+        arp_globals.net_phone = net_phone;
+        int rc = arp_cache_initialize(&arp_globals.cache);
+        fibril_mutex_unlock(&arp_globals.lock);
+        
+        return rc;
+}
+
+static int arp_send_request(device_id_t device_id, services_t protocol,
+    measured_string_t *target, arp_device_t *device, arp_proto_t *proto)
+{
+        /* ARP packet content size = header + (address + translation) * 2 */
+        size_t length = 8 + 2 * (proto->addr->length + device->addr->length);
+        if (length > device->packet_dimension.content)
+                return ELIMIT;
+        
+        packet_t *packet = packet_get_4_remote(arp_globals.net_phone,
+            device->packet_dimension.addr_len, device->packet_dimension.prefix,
+            length, device->packet_dimension.suffix);
+        if (!packet)
                 return ENOMEM;
-        }
-        (** proto).service = service;
-        (** proto).addr = address;
-        (** proto).addr_data = address->value;
-        if(ERROR_OCCURRED(arp_addr_initialize(&(** proto).addresses))){
-                free(*proto);
-                return ERROR_CODE;
-        }
-        return EOK;
-}
-
-int arp_receive_message(device_id_t device_id, packet_t packet){
-        ERROR_DECLARE;
-
-        size_t length;
-        arp_header_ref header;
-        arp_device_ref device;
-        arp_proto_ref proto;
-        measured_string_ref hw_source;
-        uint8_t * src_hw;
-        uint8_t * src_proto;
-        uint8_t * des_hw;
-        uint8_t * des_proto;
-
-        length = packet_get_data_length(packet);
-        if(length <= sizeof(arp_header_t)){
-                return EINVAL;
-        }
-        device = arp_cache_find(&arp_globals.cache, device_id);
-        if(! device){
-                return ENOENT;
-        }
-        header = (arp_header_ref) packet_get_data(packet);
-        if((ntohs(header->hardware) != device->hardware)
-                || (length < sizeof(arp_header_t) + header->hardware_length * 2u + header->protocol_length * 2u)){
-                return EINVAL;
-        }
-        proto = arp_protos_find(&device->protos, protocol_unmap(device->service, ntohs(header->protocol)));
-        if(! proto){
-                return ENOENT;
-        }
-        src_hw = ((uint8_t *) header) + sizeof(arp_header_t);
-        src_proto = src_hw + header->hardware_length;
-        des_hw = src_proto + header->protocol_length;
-        des_proto = des_hw + header->hardware_length;
-        hw_source = arp_addr_find(&proto->addresses, (char *) src_proto, CONVERT_SIZE(uint8_t, char, header->protocol_length));
-        // exists?
-        if(hw_source){
-                if(hw_source->length != CONVERT_SIZE(uint8_t, char, header->hardware_length)){
-                        return EINVAL;
-                }
-                memcpy(hw_source->value, src_hw, hw_source->length);
-        }
-        // is my protocol address?
-        if(proto->addr->length != CONVERT_SIZE(uint8_t, char, header->protocol_length)){
-                return EINVAL;
-        }
-        if(! str_lcmp(proto->addr->value, (char *) des_proto, proto->addr->length)){
-                // not already upadted?
-                if(! hw_source){
-                        hw_source = measured_string_create_bulk((char *) src_hw, CONVERT_SIZE(uint8_t, char, header->hardware_length));
-                        if(! hw_source){
-                                return ENOMEM;
-                        }
-                        ERROR_PROPAGATE(arp_addr_add(&proto->addresses, (char *) src_proto, CONVERT_SIZE(uint8_t, char, header->protocol_length), hw_source));
-                }
-                if(ntohs(header->operation) == ARPOP_REQUEST){
-                        header->operation = htons(ARPOP_REPLY);
-                        memcpy(des_proto, src_proto, header->protocol_length);
-                        memcpy(src_proto, proto->addr->value, header->protocol_length);
-                        memcpy(src_hw, device->addr->value, device->packet_dimension.addr_len);
-                        memcpy(des_hw, hw_source->value, header->hardware_length);
-                        ERROR_PROPAGATE(packet_set_addr(packet, src_hw, des_hw, header->hardware_length));
-                        nil_send_msg(device->phone, device_id, packet, SERVICE_ARP);
-                        return 1;
-                }
-        }
-        return EOK;
-}
-
-task_id_t arp_task_get_id(void){
-        return task_get_id();
-}
-
-measured_string_ref arp_translate_message(device_id_t device_id, services_t protocol, measured_string_ref target){
-        arp_device_ref device;
-        arp_proto_ref proto;
-        measured_string_ref addr;
-        size_t length;
-        packet_t packet;
-        arp_header_ref header;
-
-        if(! target){
-                return NULL;
-        }
-        device = arp_cache_find(&arp_globals.cache, device_id);
-        if(! device){
-                return NULL;
-        }
-        proto = arp_protos_find(&device->protos, protocol);
-        if((! proto) || (proto->addr->length != target->length)){
-                return NULL;
-        }
-        addr = arp_addr_find(&proto->addresses, target->value, target->length);
-        if(addr){
-                return addr;
-        }
-        // ARP packet content size = header + (address + translation) * 2
-        length = 8 + (CONVERT_SIZE(char, uint8_t, proto->addr->length) + CONVERT_SIZE(char, uint8_t, device->addr->length)) * 2;
-        if(length > device->packet_dimension.content){
-                return NULL;
-        }
-        packet = packet_get_4_remote(arp_globals.net_phone, device->packet_dimension.addr_len, device->packet_dimension.prefix, length, device->packet_dimension.suffix);
-        if(! packet){
-                return NULL;
-        }
-        header = (arp_header_ref) packet_suffix(packet, length);
-        if(! header){
+        
+        arp_header_t *header = (arp_header_t *) packet_suffix(packet, length);
+        if (!header) {
                 pq_release_remote(arp_globals.net_phone, packet_get_id(packet));
-                return NULL;
-        }
+                return ENOMEM;
+        }
+        
         header->hardware = htons(device->hardware);
         header->hardware_length = (uint8_t) device->addr->length;
@@ -589 +664 @@
         header->protocol_length = (uint8_t) proto->addr->length;
         header->operation = htons(ARPOP_REQUEST);
+        
         length = sizeof(arp_header_t);
-        memcpy(((uint8_t *) header) + length, device->addr->value, device->addr->length);
+        
+        memcpy(((uint8_t *) header) + length, device->addr->value,
+            device->addr->length);
         length += device->addr->length;
-        memcpy(((uint8_t *) header) + length, proto->addr->value, proto->addr->length);
+        memcpy(((uint8_t *) header) + length, proto->addr->value,
+            proto->addr->length);
         length += proto->addr->length;
         bzero(((uint8_t *) header) + length, device->addr->length);
         length += device->addr->length;
         memcpy(((uint8_t *) header) + length, target->value, target->length);
-        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){
+        
+        int rc = packet_set_addr(packet, (uint8_t *) device->addr->value,
+            (uint8_t *) device->broadcast_addr->value, device->addr->length);
+        if (rc != EOK) {
                 pq_release_remote(arp_globals.net_phone, packet_get_id(packet));
-                return NULL;
-        }
+                return rc;
+        }
+        
         nil_send_msg(device->phone, device_id, packet, SERVICE_ARP);
-        return NULL;
-}
-
-int arp_translate_req(int arp_phone, device_id_t device_id, services_t protocol, measured_string_ref address, measured_string_ref * translation, char ** data){
-        measured_string_ref tmp;
-
-        fibril_rwlock_read_lock(&arp_globals.lock);
-        tmp = arp_translate_message(device_id, protocol, address);
-        if(tmp){
-                *translation = measured_string_copy(tmp);
-                fibril_rwlock_read_unlock(&arp_globals.lock);
-                if(*translation){
-                        *data = (** translation).value;
+        return EOK;
+}
+
+/** Return the hardware address for the given protocol address.
+ *
+ * Send the ARP request packet if the hardware address is not found in the
+ * cache.
+ *
+ * @param[in]  device_id   Device identifier.
+ * @param[in]  protocol    Protocol service.
+ * @param[in]  target      Target protocol address.
+ * @param[out] translation Where the hardware address of the target is stored.
+ *
+ * @return EOK on success.
+ * @return EAGAIN if the caller should try again.
+ * @return Other error codes in case of error.
+ *
+ */
+static int arp_translate_message(device_id_t device_id, services_t protocol,
+    measured_string_t *target, measured_string_t **translation)
+{
+        bool retry = false;
+        int rc;
+
+        assert(fibril_mutex_is_locked(&arp_globals.lock));
+        
+restart:
+        if ((!target) || (!translation))
+                return EBADMEM;
+        
+        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
+        if (!device)
+                return ENOENT;
+        
+        arp_proto_t *proto = arp_protos_find(&device->protos, protocol);
+        if ((!proto) || (proto->addr->length != target->length))
+                return ENOENT;
+        
+        arp_trans_t *trans = arp_addr_find(&proto->addresses, target->value,
+            target->length);
+        if (trans) {
+                if (trans->hw_addr) {
+                        /* The translation is in place. */
+                        *translation = trans->hw_addr;
                         return EOK;
-                }else{
-                        return ENOMEM;
-                }
-        }else{
-                fibril_rwlock_read_unlock(&arp_globals.lock);
+                }
+                
+                if (retry) {
+                        /*
+                         * We may get here as a result of being signalled for
+                         * some reason while waiting for the translation (e.g.
+                         * translation becoming available, record being removed
+                         * from the table) and then losing the race for
+                         * the arp_globals.lock with someone else who modified
+                         * the table.
+                         *
+                         * Remove the incomplete record so that it is possible
+                         * to make new ARP requests.
+                         */
+                        arp_clear_trans(trans);
+                        arp_addr_exclude(&proto->addresses, target->value,
+                            target->length, free);
+                        return EAGAIN;
+                }
+                
+                /*
+                 * We are a random passer-by who merely joins an already waiting
+                 * fibril in waiting for the translation.
+                 */
+                rc = fibril_condvar_wait_timeout(&trans->cv, &arp_globals.lock,
+                    ARP_TRANS_WAIT);
+                if (rc == ETIMEOUT)
+                        return ENOENT;
+                
+                /*
+                 * Need to recheck because we did not hold the lock while
+                 * sleeping on the condition variable.
+                 */
+                retry = true;
+                goto restart;
+        }
+        
+        if (retry)
+                return EAGAIN;
+
+        /*
+         * We are under the protection of arp_globals.lock, so we can afford to
+         * first send the ARP request and then insert an incomplete ARP record.
+         * The incomplete record is used to tell any other potential waiter
+         * that this fibril has already sent the request and that it is waiting
+         * for the answer. Lastly, any fibril which sees the incomplete request
+         * can perform a timed wait on its condition variable to wait for the
+         * ARP reply to arrive.
+         */
+
+        rc = arp_send_request(device_id, protocol, target, device, proto);
+        if (rc != EOK)
+                return rc;
+        
+        trans = (arp_trans_t *) malloc(sizeof(arp_trans_t));
+        if (!trans)
+                return ENOMEM;
+        
+        trans->hw_addr = NULL;
+        fibril_condvar_initialize(&trans->cv);
+        
+        rc = arp_addr_add(&proto->addresses, target->value, target->length,
+            trans);
+        if (rc != EOK) {
+                free(trans);
+                return rc;
+        }
+        
+        rc = fibril_condvar_wait_timeout(&trans->cv, &arp_globals.lock,
+            ARP_TRANS_WAIT);
+        if (rc == ETIMEOUT) {
+                /*
+                 * Remove the incomplete record so that it is possible to make 
+                 * new ARP requests.
+                 */
+                arp_clear_trans(trans);
+                arp_addr_exclude(&proto->addresses, target->value,
+                    target->length, free);
                 return ENOENT;
         }
-}
-
-/** Default thread for new connections.
- *
- *  @param[in] iid The initial message identifier.
- *  @param[in] icall The initial message call structure.
- *
- */
-static void il_client_connection(ipc_callid_t iid, ipc_call_t * icall)
-{
+        
         /*
-         * Accept the connection
-         *  - Answer the first IPC_M_CONNECT_ME_TO call.
+         * We need to recheck that the translation has indeed become available,
+         * because we dropped the arp_globals.lock while sleeping on the
+         * condition variable and someone else might have e.g. removed the
+         * translation before we managed to lock arp_globals.lock again.
          */
-        ipc_answer_0(iid, EOK);
-        
-        while(true) {
-                ipc_call_t answer;
-                int answer_count;
-                
-                /* Clear the answer structure */
-                refresh_answer(&answer, &answer_count);
-                
-                /* Fetch the next message */
-                ipc_call_t call;
-                ipc_callid_t callid = async_get_call(&call);
-                
-                /* Process the message */
-                int res = il_module_message_standalone(callid, &call, &answer,
-                    &answer_count);
-                
-                /* End if said to either by the message or the processing result */
-                if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) || (res == EHANGUP))
-                        return;
-                
-                /* Answer the message */
-                answer_call(callid, res, &answer, answer_count);
-        }
-}
-
-/** Starts the module.
- *
- *  @param argc The count of the command line arguments. Ignored parameter.
- *  @param argv The command line parameters. Ignored parameter.
- *
- *  @returns EOK on success.
- *  @returns Other error codes as defined for each specific module start function.
- *
- */
+
+        retry = true;
+        goto restart;
+}
+
+/** Process the ARP message.
+ *
+ * @param[in]  callid Message identifier.
+ * @param[in]  call   Message parameters.
+ * @param[out] answer Answer.
+ * @param[out] count  Number of arguments of the answer.
+ *
+ * @return EOK on success.
+ * @return ENOTSUP if the message is not known.
+ *
+ * @see arp_interface.h
+ * @see IS_NET_ARP_MESSAGE()
+ *
+ */
+int il_module_message(ipc_callid_t callid, ipc_call_t *call, ipc_call_t *answer,
+    size_t *count)
+{
+        measured_string_t *address;
+        measured_string_t *translation;
+        uint8_t *data;
+        int rc;
+        
+        *count = 0;
+        switch (IPC_GET_IMETHOD(*call)) {
+        case IPC_M_PHONE_HUNGUP:
+                return EOK;
+        
+        case NET_ARP_DEVICE:
+                rc = measured_strings_receive(&address, &data, 1);
+                if (rc != EOK)
+                        return rc;
+                
+                rc = arp_device_message(IPC_GET_DEVICE(*call),
+                    IPC_GET_SERVICE(*call), ARP_GET_NETIF(*call), address);
+                if (rc != EOK) {
+                        free(address);
+                        free(data);
+                }
+                
+                return rc;
+        
+        case NET_ARP_TRANSLATE:
+                rc = measured_strings_receive(&address, &data, 1);
+                if (rc != EOK)
+                        return rc;
+                
+                fibril_mutex_lock(&arp_globals.lock);
+                rc = arp_translate_message(IPC_GET_DEVICE(*call),
+                    IPC_GET_SERVICE(*call), address, &translation);
+                free(address);
+                free(data);
+                
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        return rc;
+                }
+                
+                if (!translation) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        return ENOENT;
+                }
+                
+                rc = measured_strings_reply(translation, 1);
+                fibril_mutex_unlock(&arp_globals.lock);
+                return rc;
+        
+        case NET_ARP_CLEAR_DEVICE:
+                return arp_clear_device_req(0, IPC_GET_DEVICE(*call));
+        
+        case NET_ARP_CLEAR_ADDRESS:
+                rc = measured_strings_receive(&address, &data, 1);
+                if (rc != EOK)
+                        return rc;
+                
+                arp_clear_address_req(0, IPC_GET_DEVICE(*call),
+                    IPC_GET_SERVICE(*call), address);
+                free(address);
+                free(data);
+                return EOK;
+        
+        case NET_ARP_CLEAN_CACHE:
+                return arp_clean_cache_req(0);
+        }
+        
+        return ENOTSUP;
+}
+
 int main(int argc, char *argv[])
 {
-        ERROR_DECLARE;
-        
         /* Start the module */
-        if (ERROR_OCCURRED(il_module_start_standalone(il_client_connection)))
-                return ERROR_CODE;
-        
-        return EOK;
+        return il_module_start(SERVICE_ARP);
 }