Changeset 80cd7cd in mainline for uspace/srv/net/il

Timestamp:

2011-01-13T20:58:24Z (15 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

87e373b

Parents:

eaef141 (diff), a613fea1 (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.

Location:

uspace/srv/net/il

Files:

• arp/Makefile (modified) (1 diff)
• arp/arp.c (modified) (22 diffs)
• arp/arp.h (modified) (4 diffs)
• arp/arp_header.h (deleted)
• arp/arp_module.c (deleted)
• arp/arp_oc.h (deleted)
• ip/Makefile (modified) (1 diff)
• ip/ip.c (modified) (33 diffs)
• ip/ip.h (modified) (1 diff)
• ip/ip_module.c (deleted)
• ip/ip_module.h (deleted)

uspace/srv/net/il/arp/Makefile

@@ -34 +34 @@
 
 SOURCES = \
-        arp.c \
-        arp_module.c
+        arp.c
 
 include $(USPACE_PREFIX)/Makefile.common

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

@@ -35 +35 @@
  * @see arp.h
  */
-
-#include "arp.h"
-#include "arp_header.h"
-#include "arp_oc.h"
-#include "arp_module.h"
 
 #include <async.h>
@@ -54 +49 @@
 #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_interface.h>
+#include <nil_remote.h>
 #include <protocol_map.h>
 #include <packet_client.h>
 #include <packet_remote.h>
-#include <il_interface.h>
-#include <il_local.h>
-
+#include <il_remote.h>
+#include <il_skel.h>
+#include "arp.h"
 
 /** ARP module name. */
@@ -73 +67 @@
 
 /** Number of microseconds to wait for an ARP reply. */
-#define ARP_TRANS_WAIT  1000000
+#define ARP_TRANS_WAIT  1000000
+
+/** @name ARP operation codes definitions */
+/*@{*/
+
+/** REQUEST operation code. */
+#define ARPOP_REQUEST  1
+
+/** REPLY operation code. */
+#define ARPOP_REPLY  2
+
+/*@}*/
+
+/** 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. */
@@ -88 +120 @@
                 trans->hw_addr = NULL;
         }
+        
         fibril_condvar_broadcast(&trans->cv);
 }
@@ -94 +127 @@
 {
         int count;
-        arp_trans_t *trans;
-
+        
         for (count = arp_addr_count(addresses) - 1; count >= 0; count--) {
-                trans = arp_addr_items_get_index(&addresses->values, count);
+                arp_trans_t *trans = arp_addr_items_get_index(&addresses->values,
+                    count);
                 if (trans)
                         arp_clear_trans(trans);
@@ -103 +136 @@
 }
 
-
-/** Clears the device specific data.
- *
- * @param[in] device    The device specific data.
+/** Clear the device specific data.
+ *
+ * @param[in] device Device specific data.
  */
 static void arp_clear_device(arp_device_t *device)
 {
         int count;
-        arp_proto_t *proto;
-
+        
         for (count = arp_protos_count(&device->protos) - 1; count >= 0;
             count--) {
-                proto = arp_protos_get_index(&device->protos, 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);
                 }
         }
+        
         arp_protos_clear(&device->protos);
 }
@@ -131 +167 @@
 {
         int count;
-        arp_device_t *device;
-
+        
         fibril_mutex_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);
+                arp_device_t *device = arp_cache_get_index(&arp_globals.cache,
+                    count);
+                
                 if (device) {
                         arp_clear_device(device);
                         if (device->addr_data)
                                 free(device->addr_data);
+                        
                         if (device->broadcast_data)
                                 free(device->broadcast_data);
                 }
         }
+        
         arp_cache_clear(&arp_globals.cache);
         fibril_mutex_unlock(&arp_globals.lock);
-        printf("Cache cleaned\n");
+        
         return EOK;
 }
@@ -154 +193 @@
     services_t protocol, measured_string_t *address)
 {
-        arp_device_t *device;
-        arp_proto_t *proto;
-        arp_trans_t *trans;
-
         fibril_mutex_lock(&arp_globals.lock);
-        device = arp_cache_find(&arp_globals.cache, device_id);
+        
+        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
         if (!device) {
                 fibril_mutex_unlock(&arp_globals.lock);
                 return ENOENT;
         }
-        proto = arp_protos_find(&device->protos, protocol);
+        
+        arp_proto_t *proto = arp_protos_find(&device->protos, protocol);
         if (!proto) {
                 fibril_mutex_unlock(&arp_globals.lock);
                 return ENOENT;
         }
-        trans = arp_addr_find(&proto->addresses, address->value, address->length);
+        
+        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);
+        
         fibril_mutex_unlock(&arp_globals.lock);
         return EOK;
 }
 
-
 static int arp_clear_device_req(int arp_phone, device_id_t device_id)
 {
-        arp_device_t *device;
-
         fibril_mutex_lock(&arp_globals.lock);
-        device = arp_cache_find(&arp_globals.cache, device_id);
+        
+        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);
-        printf("Device %d cleared\n", device_id);
+        
         fibril_mutex_unlock(&arp_globals.lock);
         return EOK;
 }
 
-/** 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.
- * @return              EOK on success.
- * @return              ENOMEM if there is not enough memory left.
+/** 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)
 {
-        int rc;
-
         *proto = (arp_proto_t *) malloc(sizeof(arp_proto_t));
         if (!*proto)
@@ -217 +257 @@
         (*proto)->addr_data = address->value;
         
-        rc = arp_addr_initialize(&(*proto)->addresses);
+        int rc = arp_addr_initialize(&(*proto)->addresses);
         if (rc != EOK) {
                 free(*proto);
@@ -226 +266 @@
 }
 
-/** 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.
- * @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)
-{
-        arp_device_t *device;
-        arp_proto_t *proto;
-        hw_type_t hardware;
-        int index;
+/** 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;
-
-        fibril_mutex_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_mutex_unlock(&arp_globals.lock);
-                        return EEXIST;
-                }
-                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 {
-                        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_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)
-                        return ENOENT;
-                
-                /* Create a 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;
-                rc = arp_protos_initialize(&device->protos);
-                if (rc != EOK) {
-                        fibril_mutex_unlock(&arp_globals.lock);
-                        free(device);
-                        return rc;
-                }
-                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_mutex_unlock(&arp_globals.lock);
-                        arp_protos_destroy(&device->protos);
-                        free(device);
-                        return index;
-                }
-                device->service = service;
-                
-                /* Bind the new one */
-                device->phone = nil_bind_service(device->service,
-                    (sysarg_t) device->device_id, SERVICE_ARP,
-                    arp_globals.client_connection);
-                if (device->phone < 0) {
-                        fibril_mutex_unlock(&arp_globals.lock);
-                        arp_protos_destroy(&device->protos);
-                        free(device);
-                        return EREFUSED;
-                }
-                
-                /* 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(device);
-                        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(device);
-                        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);
-                        free(device);
-                        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);
-                        free(device);
-                        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;
-}
-
-/** Initializes the ARP module.
- *
- *  @param[in] client_connection The client connection processing function.
- *                      The module skeleton propagates its own one.
- *  @return             EOK on success.
- *  @return             ENOMEM if there is not enough memory left.
- */
-int arp_initialize(async_client_conn_t client_connection)
-{
-        int rc;
-
-        fibril_mutex_initialize(&arp_globals.lock);
-        fibril_mutex_lock(&arp_globals.lock);
-        arp_globals.client_connection = client_connection;
-        rc = arp_cache_initialize(&arp_globals.cache);
-        fibril_mutex_unlock(&arp_globals.lock);
-        
-        return rc;
-}
-
-/** 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.
- * @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)
-{
-        arp_device_t *device;
-
-        fibril_mutex_lock(&arp_globals.lock);
-        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("arp - device %d changed mtu to %zu\n\n", device_id, mtu);
-        return EOK;
-}
-
-/** 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.
- * @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)
-{
-        size_t length;
-        arp_header_t *header;
-        arp_device_t *device;
-        arp_proto_t *proto;
-        arp_trans_t *trans;
-        uint8_t *src_hw;
-        uint8_t *src_proto;
-        uint8_t *des_hw;
-        uint8_t *des_proto;
-        int rc;
-
-        length = packet_get_data_length(packet);
+        
+        size_t length = packet_get_data_length(packet);
         if (length <= sizeof(arp_header_t))
                 return EINVAL;
-
-        device = arp_cache_find(&arp_globals.cache, device_id);
+        
+        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
         if (!device)
                 return ENOENT;
-
-        header = (arp_header_t *) packet_get_data(packet);
+        
+        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 +
@@ -472 +307 @@
                 return EINVAL;
         }
-
-        proto = arp_protos_find(&device->protos,
+        
+        arp_proto_t *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;
-        trans = arp_addr_find(&proto->addresses, (char *) src_proto,
+        
+        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);
-        /* Exists? */
-        if (trans && trans->hw_addr) {
+        
+        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 (!str_lcmp(proto->addr->value, (char *) des_proto,
-            proto->addr->length)) {
-                /* Not already updated? */
+        
+        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, (char *) src_proto,
+                        rc = arp_addr_add(&proto->addresses, src_proto,
                             header->protocol_length, trans);
                         if (rc != EOK) {
@@ -509 +349 @@
                         }
                 }
+                
                 if (!trans->hw_addr) {
-                        trans->hw_addr = measured_string_create_bulk(
-                            (char *) src_hw, header->hardware_length);
+                        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);
@@ -538 +380 @@
                 }
         }
-
+        
         return EOK;
 }
 
-
-/** 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.
- * @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)
-{
-        arp_device_t *device;
-        arp_proto_t *proto;
-        arp_trans_t *trans;
-        size_t length;
+/** 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;
-        arp_header_t *header;
-        bool retry = false;
         int rc;
-
-restart:
-        if (!target || !translation)
-                return EBADMEM;
-
-        device = arp_cache_find(&arp_globals.cache, device_id);
-        if (!device)
-                return ENOENT;
-
-        proto = arp_protos_find(&device->protos, protocol);
-        if (!proto || (proto->addr->length != target->length))
-                return ENOENT;
-
-        trans = arp_addr_find(&proto->addresses, target->value, target->length);
-        if (trans) {
-                if (trans->hw_addr) {
-                        *translation = trans->hw_addr;
-                        return EOK;
-                }
-                if (retry)
-                        return EAGAIN;
-                rc = fibril_condvar_wait_timeout(&trans->cv, &arp_globals.lock,
-                    ARP_TRANS_WAIT);
-                if (rc == ETIMEOUT)
+        
+        while (true) {
+                switch (IPC_GET_IMETHOD(*icall)) {
+                case NET_IL_DEVICE_STATE:
+                        /* Do nothing - keep the cache */
+                        ipc_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);
+                        }
+                        ipc_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));
+                        ipc_answer_0(iid, (sysarg_t) rc);
+                        break;
+                
+                default:
+                        ipc_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;
+        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;
+                }
+                
+                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 {
+                        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_mutex_unlock(&arp_globals.lock);
+                                free(proto);
+                                return index;
+                        }
+                        
+                        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;
-                retry = true;
-                goto restart;
-        }
-        if (retry)
-                return EAGAIN;
-
+                
+                /* 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;
+                rc = arp_protos_initialize(&device->protos);
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        free(device);
+                        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_mutex_unlock(&arp_globals.lock);
+                        arp_protos_destroy(&device->protos);
+                        free(device);
+                        return index;
+                }
+                
+                device->service = service;
+                
+                /* 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(device);
+                        return EREFUSED;
+                }
+                
+                /* 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(device);
+                        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(device);
+                        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);
+                        free(device);
+                        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);
+                        free(device);
+                        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 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 */
-        length = 8 + 2 * (proto->addr->length + device->addr->length);
+        size_t length = 8 + 2 * (proto->addr->length + device->addr->length);
         if (length > device->packet_dimension.content)
                 return ELIMIT;
-
-        packet = packet_get_4_remote(arp_globals.net_phone,
+        
+        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;
-
-        header = (arp_header_t *) packet_suffix(packet, length);
+        
+        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 ENOMEM;
         }
-
+        
         header->hardware = htons(device->hardware);
         header->hardware_length = (uint8_t) device->addr->length;
@@ -621 +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);
@@ -631 +676 @@
         length += device->addr->length;
         memcpy(((uint8_t *) header) + length, target->value, target->length);
-
-        rc = packet_set_addr(packet, (uint8_t *) device->addr->value,
+        
+        int rc = packet_set_addr(packet, (uint8_t *) device->addr->value,
             (uint8_t *) device->broadcast_addr->value, device->addr->length);
         if (rc != EOK) {
@@ -638 +683 @@
                 return rc;
         }
-
+        
         nil_send_msg(device->phone, device_id, packet, SERVICE_ARP);
-
+        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;
+        
+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) {
+                        *translation = trans->hw_addr;
+                        return EOK;
+                }
+                
+                if (retry) {
+                        /* Remove the translation from the map */
+                        arp_clear_trans(trans);
+                        arp_addr_exclude(&proto->addresses, target->value,
+                            target->length);
+                        return EAGAIN;
+                }
+                
+                rc = fibril_condvar_wait_timeout(&trans->cv, &arp_globals.lock,
+                    ARP_TRANS_WAIT);
+                if (rc == ETIMEOUT)
+                        return ENOENT;
+                
+                retry = true;
+                goto restart;
+        }
+        
+        if (retry)
+                return EAGAIN;
+        
         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);
@@ -653 +763 @@
         }
         
+        rc = arp_send_request(device_id, protocol, target, device, proto);
+        if (rc != EOK)
+                return rc;
+        
         rc = fibril_condvar_wait_timeout(&trans->cv, &arp_globals.lock,
             ARP_TRANS_WAIT);
         if (rc == ETIMEOUT)
                 return ENOENT;
+        
         retry = true;
         goto restart;
 }
 
-
-/** Processes the ARP message.
- *
- * @param[in] callid    The message identifier.
- * @param[in] call      The message parameters.
- * @param[out] answer   The message answer parameters.
- * @param[out] answer_count The last parameter for the actual answer in the
- *                      answer parameter.
- * @return              EOK on success.
- * @return              ENOTSUP if the message is not known.
+/** 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
-arp_message_standalone(ipc_callid_t callid, ipc_call_t *call,
-    ipc_call_t *answer, int *answer_count)
+ *
+ */
+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;
-        char *data;
-        packet_t *packet;
-        packet_t *next;
+        uint8_t *data;
         int rc;
         
-        *answer_count = 0;
+        *count = 0;
         switch (IPC_GET_IMETHOD(*call)) {
         case IPC_M_PHONE_HUNGUP:
@@ -696 +808 @@
                         return rc;
                 
-                rc = arp_device_message(IPC_GET_DEVICE(call),
-                    IPC_GET_SERVICE(call), ARP_GET_NETIF(call), address);
+                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;
         
@@ -710 +823 @@
                 
                 fibril_mutex_lock(&arp_globals.lock);
-                rc = arp_translate_message(IPC_GET_DEVICE(call),
-                    IPC_GET_SERVICE(call), address, &translation);
+                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));
-
+                return arp_clear_device_req(0, IPC_GET_DEVICE(*call));
+        
         case NET_ARP_CLEAR_ADDRESS:
                 rc = measured_strings_receive(&address, &data, 1);
@@ -734 +850 @@
                         return rc;
                 
-                arp_clear_address_req(0, IPC_GET_DEVICE(call),
-                    IPC_GET_SERVICE(call), address);
+                arp_clear_address_req(0, IPC_GET_DEVICE(*call),
+                    IPC_GET_SERVICE(*call), address);
                 free(address);
                 free(data);
@@ -742 +858 @@
         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:
-                rc = packet_translate_remote(arp_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
-                if (rc != EOK)
-                        return rc;
-                
-                fibril_mutex_lock(&arp_globals.lock);
-                do {
-                        next = pq_detach(packet);
-                        rc = arp_receive_message(IPC_GET_DEVICE(call), 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);
-                
-                return EOK;
-        
-        case NET_IL_MTU_CHANGED:
-                return arp_mtu_changed_message(IPC_GET_DEVICE(call),
-                    IPC_GET_MTU(call));
         }
         
@@ -775 +863 @@
 }
 
-/** 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.
-         */
-        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 told to either by the message or the processing
-                 * result.
-                 */
-                if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
-                    (res == EHANGUP))
-                        return;
-                
-                /* Answer the message */
-                answer_call(callid, res, &answer, answer_count);
-        }
-}
-
-/** Starts the module.
- *
- * @return              EOK on success.
- * @return              Other error codes as defined for each specific module
- *                      start function.
- */
 int main(int argc, char *argv[])
 {
-        int rc;
-        
         /* Start the module */
-        rc = il_module_start_standalone(il_client_connection);
-        return rc;
+        return il_module_start(SERVICE_ARP);
 }
 
 /** @}
  */
-

uspace/srv/net/il/arp/arp.h

@@ -96 +96 @@
         measured_string_t *addr;
         /** Actual device hardware address data. */
-        char *addr_data;
+        uint8_t *addr_data;
         /** Broadcast device hardware address. */
         measured_string_t *broadcast_addr;
         /** Broadcast device hardware address data. */
-        char *broadcast_data;
+        uint8_t *broadcast_data;
         /** Device identifier. */
         device_id_t device_id;
@@ -125 +125 @@
         arp_cache_t cache;
         
-        /**
-         * The client connection processing function.
-         * The module skeleton propagates its own one.
-         */
-        async_client_conn_t client_connection;
-        
         /** Networking module phone. */
         int net_phone;
@@ -142 +136 @@
         measured_string_t *addr;
         /** Actual device protocol address data. */
-        char *addr_data;
+        uint8_t *addr_data;
         /** Address map. */
         arp_addr_t addresses;
@@ -154 +148 @@
          * Hardware address for the translation. NULL denotes an incomplete
          * record with possible waiters.
-         */ 
+         */
         measured_string_t *hw_addr;
         /** Condition variable used for waiting for completion of the record. */

uspace/srv/net/il/ip/Makefile

@@ -34 +34 @@
 
 SOURCES = \
-        ip.c \
-        ip_module.c
+        ip.c
 
 include $(USPACE_PREFIX)/Makefile.common

uspace/srv/net/il/ip/ip.c

@@ -35 +35 @@
  * @see arp.h
  */
-
-#include "ip.h"
-#include "ip_module.h"
 
 #include <async.h>
@@ -52 +49 @@
 #include <sys/types.h>
 #include <byteorder.h>
+#include "ip.h"
 
 #include <adt/measured_strings.h>
@@ -70 +68 @@
 #include <icmp_client.h>
 #include <icmp_interface.h>
-#include <il_interface.h>
 #include <ip_client.h>
 #include <ip_interface.h>
 #include <ip_header.h>
 #include <net_interface.h>
-#include <nil_interface.h>
-#include <tl_interface.h>
+#include <nil_remote.h>
+#include <tl_remote.h>
 #include <packet_remote.h>
-#include <il_local.h>
+#include <il_remote.h>
+#include <il_skel.h>
 
 /** IP module name. */
@@ -122 +120 @@
 INT_MAP_IMPLEMENT(ip_protos, ip_proto_t);
 GENERIC_FIELD_IMPLEMENT(ip_routes, ip_route_t);
+
+static void ip_receiver(ipc_callid_t, ipc_call_t *);
 
 /** Releases the packet and returns the result.
@@ -244 +244 @@
 }
 
-/** Initializes the IP module.
- *
- * @param[in] client_connection The client connection processing function. The
- *                      module skeleton propagates its own one.
- * @return              EOK on success.
- * @return              ENOMEM if there is not enough memory left.
- */
-int ip_initialize(async_client_conn_t client_connection)
-{
-        int rc;
-
+int il_initialize(int net_phone)
+{
         fibril_rwlock_initialize(&ip_globals.lock);
         fibril_rwlock_write_lock(&ip_globals.lock);
         fibril_rwlock_initialize(&ip_globals.protos_lock);
         fibril_rwlock_initialize(&ip_globals.netifs_lock);
+        
+        ip_globals.net_phone = net_phone;
         ip_globals.packet_counter = 0;
         ip_globals.gateway.address.s_addr = 0;
@@ -264 +257 @@
         ip_globals.gateway.gateway.s_addr = 0;
         ip_globals.gateway.netif = NULL;
-        ip_globals.client_connection = client_connection;
-        
-        rc = ip_netifs_initialize(&ip_globals.netifs);
+        
+        int rc = ip_netifs_initialize(&ip_globals.netifs);
         if (rc != EOK)
                 goto out;
@@ -275 +267 @@
         if (rc != EOK)
                 goto out;
-        rc = add_module(NULL, &ip_globals.modules, ARP_NAME, ARP_FILENAME,
-            SERVICE_ARP, 0, arp_connect_module);
+        rc = add_module(NULL, &ip_globals.modules, (uint8_t *) ARP_NAME,
+            (uint8_t *) ARP_FILENAME, SERVICE_ARP, 0, arp_connect_module);
 
 out:
@@ -312 +304 @@
         measured_string_t names[] = {
                 {
-                        (char *) "IPV",
+                        (uint8_t *) "IPV",
                         3
                 },
                 {
-                        (char *) "IP_CONFIG",
+                        (uint8_t *) "IP_CONFIG",
                         9
                 },
                 {
-                        (char *) "IP_ADDR",
+                        (uint8_t *) "IP_ADDR",
                         7
                 },
                 {
-                        (char *) "IP_NETMASK",
+                        (uint8_t *) "IP_NETMASK",
                         10
                 },
                 {
-                        (char *) "IP_GATEWAY",
+                        (uint8_t *) "IP_GATEWAY",
                         10
                 },
                 {
-                        (char *) "IP_BROADCAST",
+                        (uint8_t *) "IP_BROADCAST",
                         12
                 },
                 {
-                        (char *) "ARP",
+                        (uint8_t *) "ARP",
                         3
                 },
                 {
-                        (char *) "IP_ROUTING",
+                        (uint8_t *) "IP_ROUTING",
                         10
                 }
@@ -346 +338 @@
         measured_string_t *configuration;
         size_t count = sizeof(names) / sizeof(measured_string_t);
-        char *data;
+        uint8_t *data;
         measured_string_t address;
         ip_route_t *route;
@@ -368 +360 @@
         if (configuration) {
                 if (configuration[0].value)
-                        ip_netif->ipv = strtol(configuration[0].value, NULL, 0);
-
-                ip_netif->dhcp = !str_lcmp(configuration[1].value, "dhcp",
+                        ip_netif->ipv = strtol((char *) configuration[0].value, NULL, 0);
+                
+                ip_netif->dhcp = !str_lcmp((char *) configuration[1].value, "dhcp",
                     configuration[1].length);
                 
@@ -394 +386 @@
                         }
                         
-                        if ((inet_pton(AF_INET, configuration[2].value,
+                        if ((inet_pton(AF_INET, (char *) configuration[2].value,
                             (uint8_t *) &route->address.s_addr) != EOK) ||
-                            (inet_pton(AF_INET, configuration[3].value,
+                            (inet_pton(AF_INET, (char *) configuration[3].value,
                             (uint8_t *) &route->netmask.s_addr) != EOK) ||
-                            (inet_pton(AF_INET, configuration[4].value,
+                            (inet_pton(AF_INET, (char *) configuration[4].value,
                             (uint8_t *) &gateway.s_addr) == EINVAL) ||
-                            (inet_pton(AF_INET, configuration[5].value,
+                            (inet_pton(AF_INET, (char *) configuration[5].value,
                             (uint8_t *) &ip_netif->broadcast.s_addr) == EINVAL))
                             {
@@ -431 +423 @@
         ip_netif->phone = nil_bind_service(ip_netif->service,
             (sysarg_t) ip_netif->device_id, SERVICE_IP,
-            ip_globals.client_connection);
+            ip_receiver);
         if (ip_netif->phone < 0) {
                 printf("Failed to contact the nil service %d\n",
@@ -441 +433 @@
         if (ip_netif->arp) {
                 if (route) {
-                        address.value = (char *) &route->address.s_addr;
+                        address.value = (uint8_t *) &route->address.s_addr;
                         address.length = sizeof(in_addr_t);
                         
@@ -477 +469 @@
                 ip_globals.gateway.gateway.s_addr = gateway.s_addr;
                 ip_globals.gateway.netif = ip_netif;
+                
+                char defgateway[INET_ADDRSTRLEN];
+                inet_ntop(AF_INET, (uint8_t *) &gateway.s_addr,
+                    defgateway, INET_ADDRSTRLEN);
+                printf("%s: Default gateway (%s)\n", NAME, defgateway);
         }
 
@@ -482 +479 @@
 }
 
-/** 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.
- * @return              EOK on success.
- * @return              ENOENT if device is not found.
- */
-static int ip_mtu_changed_message(device_id_t device_id, size_t mtu)
-{
+static int ip_device_req_local(int il_phone, device_id_t device_id,
+    services_t netif)
+{
+        ip_netif_t *ip_netif;
+        ip_route_t *route;
+        int index;
+        int rc;
+
+        ip_netif = (ip_netif_t *) malloc(sizeof(ip_netif_t));
+        if (!ip_netif)
+                return ENOMEM;
+
+        rc = ip_routes_initialize(&ip_netif->routes);
+        if (rc != EOK) {
+                free(ip_netif);
+                return rc;
+        }
+
+        ip_netif->device_id = device_id;
+        ip_netif->service = netif;
+        ip_netif->state = NETIF_STOPPED;
+
+        fibril_rwlock_write_lock(&ip_globals.netifs_lock);
+
+        rc = ip_netif_initialize(ip_netif);
+        if (rc != EOK) {
+                fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
+                ip_routes_destroy(&ip_netif->routes);
+                free(ip_netif);
+                return rc;
+        }
+        if (ip_netif->arp)
+                ip_netif->arp->usage++;
+
+        // print the settings
+        printf("%s: Device registered (id: %d, phone: %d, ipv: %d, conf: %s)\n",
+            NAME, ip_netif->device_id, ip_netif->phone, ip_netif->ipv,
+            ip_netif->dhcp ? "dhcp" : "static");
+        
+        // TODO ipv6 addresses
+        
+        char address[INET_ADDRSTRLEN];
+        char netmask[INET_ADDRSTRLEN];
+        char gateway[INET_ADDRSTRLEN];
+        
+        for (index = 0; index < ip_routes_count(&ip_netif->routes); index++) {
+                route = ip_routes_get_index(&ip_netif->routes, index);
+                if (route) {
+                        inet_ntop(AF_INET, (uint8_t *) &route->address.s_addr,
+                            address, INET_ADDRSTRLEN);
+                        inet_ntop(AF_INET, (uint8_t *) &route->netmask.s_addr,
+                            netmask, INET_ADDRSTRLEN);
+                        inet_ntop(AF_INET, (uint8_t *) &route->gateway.s_addr,
+                            gateway, INET_ADDRSTRLEN);
+                        printf("%s: Route %d (address: %s, netmask: %s, "
+                            "gateway: %s)\n", NAME, index, address, netmask,
+                            gateway);
+                }
+        }
+        
+        inet_ntop(AF_INET, (uint8_t *) &ip_netif->broadcast.s_addr, address,
+            INET_ADDRSTRLEN);
+        fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
+
+        printf("%s: Broadcast (%s)\n", NAME, address);
+
+        return EOK;
+}
+
+/** Searches the network interfaces if there is a suitable route.
+ *
+ * @param[in] netif     The network interface to be searched for routes. May be
+ *                      NULL.
+ * @param[in] destination The destination address.
+ * @return              The found route.
+ * @return              NULL if no route was found.
+ */
+static ip_route_t *ip_netif_find_route(ip_netif_t *netif,
+    in_addr_t destination)
+{
+        int index;
+        ip_route_t *route;
+        
+        if (!netif)
+                return NULL;
+        
+        /* Start with the first one (the direct route) */
+        for (index = 0; index < ip_routes_count(&netif->routes); index++) {
+                route = ip_routes_get_index(&netif->routes, index);
+                if ((route) &&
+                    ((route->address.s_addr & route->netmask.s_addr) ==
+                    (destination.s_addr & route->netmask.s_addr)))
+                        return route;
+        }
+
+        return NULL;
+}
+
+/** Searches all network interfaces if there is a suitable route.
+ *
+ * @param[in] destination The destination address.
+ * @return              The found route.
+ * @return              NULL if no route was found.
+ */
+static ip_route_t *ip_find_route(in_addr_t destination) {
+        int index;
+        ip_route_t *route;
         ip_netif_t *netif;
 
-        fibril_rwlock_write_lock(&ip_globals.netifs_lock);
-        netif = ip_netifs_find(&ip_globals.netifs, device_id);
-        if (!netif) {
-                fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
-                return ENOENT;
-        }
-        netif->packet_dimension.content = mtu;
-        fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
-
-        printf("%s: Device %d changed MTU to %zu\n", NAME, device_id, mtu);
-
-        return EOK;
-}
-
-/** Updates the device state.
- *
- * @param[in] device_id The device identifier.
- * @param[in] state     The new state value.
- * @return              EOK on success.
- * @return              ENOENT if device is not found.
- */
-static int ip_device_state_message(device_id_t device_id, device_state_t state)
-{
-        ip_netif_t *netif;
-
-        fibril_rwlock_write_lock(&ip_globals.netifs_lock);
-        // find the device
-        netif = ip_netifs_find(&ip_globals.netifs, device_id);
-        if (!netif) {
-                fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
-                return ENOENT;
-        }
-        netif->state = state;
-        fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
-
-        printf("%s: Device %d changed state to %d\n", NAME, device_id, state);
-
-        return EOK;
-}
-
-
-/** Prefixes a middle fragment header based on the last fragment header to the
- * packet.
- *
- * @param[in] packet    The packet to be prefixed.
- * @param[in] last      The last header to be copied.
- * @return              The prefixed middle header.
- * @return              NULL on error.
- */
-static ip_header_t *
-ip_create_middle_header(packet_t *packet, ip_header_t *last)
-{
-        ip_header_t *middle;
-
-        middle = (ip_header_t *) packet_suffix(packet, IP_HEADER_LENGTH(last));
-        if (!middle)
-                return NULL;
-        memcpy(middle, last, IP_HEADER_LENGTH(last));
-        middle->flags |= IPFLAG_MORE_FRAGMENTS;
-        return middle;
+        // start with the last netif - the newest one
+        index = ip_netifs_count(&ip_globals.netifs) - 1;
+        while (index >= 0) {
+                netif = ip_netifs_get_index(&ip_globals.netifs, index);
+                if (netif && (netif->state == NETIF_ACTIVE)) {
+                        route = ip_netif_find_route(netif, destination);
+                        if (route)
+                                return route;
+                }
+                index--;
+        }
+
+        return &ip_globals.gateway;
+}
+
+/** Returns the network interface's IP address.
+ *
+ * @param[in] netif     The network interface.
+ * @return              The IP address.
+ * @return              NULL if no IP address was found.
+ */
+static in_addr_t *ip_netif_address(ip_netif_t *netif)
+{
+        ip_route_t *route;
+
+        route = ip_routes_get_index(&netif->routes, 0);
+        return route ? &route->address : NULL;
 }
 
@@ -621 +683 @@
  *                      function.
  */
-static int
-ip_prepare_packet(in_addr_t *source, in_addr_t dest, packet_t *packet,
-    measured_string_t *destination)
+static int ip_prepare_packet(in_addr_t *source, in_addr_t dest,
+    packet_t *packet, measured_string_t *destination)
 {
         size_t length;
@@ -752 +813 @@
  *                      function.
  */
-static int
-ip_fragment_packet_data(packet_t *packet, packet_t *new_packet,
+static int ip_fragment_packet_data(packet_t *packet, packet_t *new_packet,
     ip_header_t *header, ip_header_t *new_header, size_t length,
     const struct sockaddr *src, const struct sockaddr *dest, socklen_t addrlen)
@@ -787 +847 @@
 
         return pq_insert_after(packet, new_packet);
+}
+
+/** Prefixes a middle fragment header based on the last fragment header to the
+ * packet.
+ *
+ * @param[in] packet    The packet to be prefixed.
+ * @param[in] last      The last header to be copied.
+ * @return              The prefixed middle header.
+ * @return              NULL on error.
+ */
+static ip_header_t *ip_create_middle_header(packet_t *packet,
+    ip_header_t *last)
+{
+        ip_header_t *middle;
+
+        middle = (ip_header_t *) packet_suffix(packet, IP_HEADER_LENGTH(last));
+        if (!middle)
+                return NULL;
+        memcpy(middle, last, IP_HEADER_LENGTH(last));
+        middle->flags |= IPFLAG_MORE_FRAGMENTS;
+        return middle;
 }
 
@@ -991 +1072 @@
  *                      function.
  */
-static int
-ip_send_route(packet_t *packet, ip_netif_t *netif, ip_route_t *route,
-    in_addr_t *src, in_addr_t dest, services_t error)
+static int ip_send_route(packet_t *packet, ip_netif_t *netif,
+    ip_route_t *route, in_addr_t *src, in_addr_t dest, services_t error)
 {
         measured_string_t destination;
         measured_string_t *translation;
-        char *data;
+        uint8_t *data;
         int phone;
         int rc;
@@ -1004 +1084 @@
         if (netif->arp && (route->address.s_addr != dest.s_addr)) {
                 destination.value = route->gateway.s_addr ?
-                    (char *) &route->gateway.s_addr : (char *) &dest.s_addr;
+                    (uint8_t *) &route->gateway.s_addr : (uint8_t *) &dest.s_addr;
                 destination.length = sizeof(dest.s_addr);
 
@@ -1056 +1136 @@
 }
 
-/** Searches the network interfaces if there is a suitable route.
- *
- * @param[in] netif     The network interface to be searched for routes. May be
- *                      NULL.
- * @param[in] destination The destination address.
- * @return              The found route.
- * @return              NULL if no route was found.
- */
-static ip_route_t *
-ip_netif_find_route(ip_netif_t *netif, in_addr_t destination)
-{
-        int index;
-        ip_route_t *route;
-
-        if (!netif)
-                return NULL;
-
-        // start with the first one - the direct route
-        for (index = 0; index < ip_routes_count(&netif->routes); index++) {
-                route = ip_routes_get_index(&netif->routes, index);
-                if (route &&
-                    ((route->address.s_addr & route->netmask.s_addr) ==
-                    (destination.s_addr & route->netmask.s_addr))) {
-                        return route;
-                }
-        }
-
-        return NULL;
-}
-
-/** Searches all network interfaces if there is a suitable route.
- *
- * @param[in] destination The destination address.
- * @return              The found route.
- * @return              NULL if no route was found.
- */
-static ip_route_t *ip_find_route(in_addr_t destination) {
-        int index;
-        ip_route_t *route;
-        ip_netif_t *netif;
-
-        // start with the last netif - the newest one
-        index = ip_netifs_count(&ip_globals.netifs) - 1;
-        while (index >= 0) {
-                netif = ip_netifs_get_index(&ip_globals.netifs, index);
-                if (netif && (netif->state == NETIF_ACTIVE)) {
-                        route = ip_netif_find_route(netif, destination);
-                        if (route)
-                                return route;
-                }
-                index--;
-        }
-
-        return &ip_globals.gateway;
-}
-
-/** Returns the network interface's IP address.
- *
- * @param[in] netif     The network interface.
- * @return              The IP address.
- * @return              NULL if no IP address was found.
- */
-static in_addr_t *ip_netif_address(ip_netif_t *netif)
-{
-        ip_route_t *route;
-
-        route = ip_routes_get_index(&netif->routes, 0);
-        return route ? &route->address : NULL;
-}
-
-/** Registers the transport layer protocol.
- *
- * The traffic of this protocol will be supplied using either the receive
- * function or IPC message.
- *
- * @param[in] protocol  The transport layer module protocol.
- * @param[in] service   The transport layer module service.
- * @param[in] phone     The transport layer module phone.
- * @param[in] received_msg The receiving function.
- * @return              EOK on success.
- * @return              EINVAL if the protocol parameter and/or the service
- *                      parameter is zero.
- * @return              EINVAL if the phone parameter is not a positive number
- *                      and the tl_receive_msg is NULL.
- * @return              ENOMEM if there is not enough memory left.
- */
-static int
-ip_register(int protocol, services_t service, int phone,
-    tl_received_msg_t received_msg)
-{
-        ip_proto_t *proto;
-        int index;
-
-        if (!protocol || !service || ((phone < 0) && !received_msg))
-                return EINVAL;
-
-        proto = (ip_proto_t *) malloc(sizeof(ip_protos_t));
-        if (!proto)
-                return ENOMEM;
-
-        proto->protocol = protocol;
-        proto->service = service;
-        proto->phone = phone;
-        proto->received_msg = received_msg;
-
-        fibril_rwlock_write_lock(&ip_globals.protos_lock);
-        index = ip_protos_add(&ip_globals.protos, proto->protocol, proto);
-        if (index < 0) {
-                fibril_rwlock_write_unlock(&ip_globals.protos_lock);
-                free(proto);
-                return index;
-        }
-        fibril_rwlock_write_unlock(&ip_globals.protos_lock);
-
-        printf("%s: Protocol registered (protocol: %d, phone: %d)\n",
-            NAME, proto->protocol, proto->phone);
-
-        return EOK;
-}
-
-static int
-ip_device_req_local(int il_phone, device_id_t device_id, services_t netif)
-{
-        ip_netif_t *ip_netif;
-        ip_route_t *route;
-        int index;
-        int rc;
-
-        ip_netif = (ip_netif_t *) malloc(sizeof(ip_netif_t));
-        if (!ip_netif)
-                return ENOMEM;
-
-        rc = ip_routes_initialize(&ip_netif->routes);
-        if (rc != EOK) {
-                free(ip_netif);
-                return rc;
-        }
-
-        ip_netif->device_id = device_id;
-        ip_netif->service = netif;
-        ip_netif->state = NETIF_STOPPED;
-
-        fibril_rwlock_write_lock(&ip_globals.netifs_lock);
-
-        rc = ip_netif_initialize(ip_netif);
-        if (rc != EOK) {
-                fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
-                ip_routes_destroy(&ip_netif->routes);
-                free(ip_netif);
-                return rc;
-        }
-        if (ip_netif->arp)
-                ip_netif->arp->usage++;
-
-        // print the settings
-        printf("%s: Device registered (id: %d, phone: %d, ipv: %d, conf: %s)\n",
-            NAME, ip_netif->device_id, ip_netif->phone, ip_netif->ipv,
-            ip_netif->dhcp ? "dhcp" : "static");
-        
-        // TODO ipv6 addresses
-        
-        char address[INET_ADDRSTRLEN];
-        char netmask[INET_ADDRSTRLEN];
-        char gateway[INET_ADDRSTRLEN];
-        
-        for (index = 0; index < ip_routes_count(&ip_netif->routes); index++) {
-                route = ip_routes_get_index(&ip_netif->routes, index);
-                if (route) {
-                        inet_ntop(AF_INET, (uint8_t *) &route->address.s_addr,
-                            address, INET_ADDRSTRLEN);
-                        inet_ntop(AF_INET, (uint8_t *) &route->netmask.s_addr,
-                            netmask, INET_ADDRSTRLEN);
-                        inet_ntop(AF_INET, (uint8_t *) &route->gateway.s_addr,
-                            gateway, INET_ADDRSTRLEN);
-                        printf("%s: Route %d (address: %s, netmask: %s, "
-                            "gateway: %s)\n", NAME, index, address, netmask,
-                            gateway);
-                }
-        }
-        
-        inet_ntop(AF_INET, (uint8_t *) &ip_netif->broadcast.s_addr, address,
-            INET_ADDRSTRLEN);
-        fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
-
-        printf("%s: Broadcast (%s)\n", NAME, address);
-
-        return EOK;
-}
-
-static int
-ip_send_msg_local(int il_phone, device_id_t device_id, packet_t *packet,
-    services_t sender, services_t error)
+static int ip_send_msg_local(int il_phone, device_id_t device_id,
+    packet_t *packet, services_t sender, services_t error)
 {
         int addrlen;
@@ -1288 +1178 @@
         if (device_id > 0) {
                 netif = ip_netifs_find(&ip_globals.netifs, device_id);
-                route = ip_netif_find_route(netif, * dest);
+                route = ip_netif_find_route(netif, *dest);
                 if (netif && !route && (ip_globals.gateway.netif == netif))
                         route = &ip_globals.gateway;
@@ -1318 +1208 @@
                 }
         }
-
+        
         // if the local host is the destination
         if ((route->address.s_addr == dest->s_addr) &&
@@ -1351 +1241 @@
 }
 
+/** Updates the device state.
+ *
+ * @param[in] device_id The device identifier.
+ * @param[in] state     The new state value.
+ * @return              EOK on success.
+ * @return              ENOENT if device is not found.
+ */
+static int ip_device_state_message(device_id_t device_id, device_state_t state)
+{
+        ip_netif_t *netif;
+
+        fibril_rwlock_write_lock(&ip_globals.netifs_lock);
+        // find the device
+        netif = ip_netifs_find(&ip_globals.netifs, device_id);
+        if (!netif) {
+                fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
+                return ENOENT;
+        }
+        netif->state = state;
+        fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
+
+        printf("%s: Device %d changed state to %d\n", NAME, device_id, state);
+
+        return EOK;
+}
+
+/** Returns the packet destination address from the IP header.
+ *
+ * @param[in] header    The packet IP header to be read.
+ * @return              The packet destination address.
+ */
+static in_addr_t ip_get_destination(ip_header_t *header)
+{
+        in_addr_t destination;
+
+        // TODO search set ipopt route?
+        destination.s_addr = header->destination_address;
+        return destination;
+}
+
+/** Delivers the packet to the local host.
+ *
+ * The packet is either passed to another module or released on error.
+ * The ICMP_PROT_UNREACH error notification may be sent if the protocol is not
+ * found.
+ *
+ * @param[in] device_id The source device identifier.
+ * @param[in] packet    The packet to be delivered.
+ * @param[in] header    The first packet IP header. May be NULL.
+ * @param[in] error     The packet error service.
+ * @return              EOK on success.
+ * @return              ENOTSUP if the packet is a fragment.
+ * @return              EAFNOSUPPORT if the address family is not supported.
+ * @return              ENOENT if the target protocol is not found.
+ * @return              Other error codes as defined for the packet_set_addr()
+ *                      function.
+ * @return              Other error codes as defined for the packet_trim()
+ *                      function.
+ * @return              Other error codes as defined for the protocol specific
+ *                      tl_received_msg() function.
+ */
+static int ip_deliver_local(device_id_t device_id, packet_t *packet,
+    ip_header_t *header, services_t error)
+{
+        ip_proto_t *proto;
+        int phone;
+        services_t service;
+        tl_received_msg_t received_msg;
+        struct sockaddr *src;
+        struct sockaddr *dest;
+        struct sockaddr_in src_in;
+        struct sockaddr_in dest_in;
+        socklen_t addrlen;
+        int rc;
+
+        if ((header->flags & IPFLAG_MORE_FRAGMENTS) ||
+            IP_FRAGMENT_OFFSET(header)) {
+                // TODO fragmented
+                return ENOTSUP;
+        }
+        
+        switch (header->version) {
+        case IPVERSION:
+                addrlen = sizeof(src_in);
+                bzero(&src_in, addrlen);
+                src_in.sin_family = AF_INET;
+                memcpy(&dest_in, &src_in, addrlen);
+                memcpy(&src_in.sin_addr.s_addr, &header->source_address,
+                    sizeof(header->source_address));
+                memcpy(&dest_in.sin_addr.s_addr, &header->destination_address,
+                    sizeof(header->destination_address));
+                src = (struct sockaddr *) &src_in;
+                dest = (struct sockaddr *) &dest_in;
+                break;
+
+        default:
+                return ip_release_and_return(packet, EAFNOSUPPORT);
+        }
+
+        rc = packet_set_addr(packet, (uint8_t *) src, (uint8_t *) dest,
+            addrlen);
+        if (rc != EOK)
+                return ip_release_and_return(packet, rc);
+
+        // trim padding if present
+        if (!error &&
+            (IP_TOTAL_LENGTH(header) < packet_get_data_length(packet))) {
+                rc = packet_trim(packet, 0,
+                    packet_get_data_length(packet) - IP_TOTAL_LENGTH(header));
+                if (rc != EOK)
+                        return ip_release_and_return(packet, rc);
+        }
+
+        fibril_rwlock_read_lock(&ip_globals.protos_lock);
+
+        proto = ip_protos_find(&ip_globals.protos, header->protocol);
+        if (!proto) {
+                fibril_rwlock_read_unlock(&ip_globals.protos_lock);
+                phone = ip_prepare_icmp_and_get_phone(error, packet, header);
+                if (phone >= 0) {
+                        // unreachable ICMP
+                        icmp_destination_unreachable_msg(phone,
+                            ICMP_PROT_UNREACH, 0, packet);
+                }
+                return ENOENT;
+        }
+
+        if (proto->received_msg) {
+                service = proto->service;
+                received_msg = proto->received_msg;
+                fibril_rwlock_read_unlock(&ip_globals.protos_lock);
+                rc = received_msg(device_id, packet, service, error);
+        } else {
+                rc = tl_received_msg(proto->phone, device_id, packet,
+                    proto->service, error);
+                fibril_rwlock_read_unlock(&ip_globals.protos_lock);
+        }
+
+        return rc;
+}
+
+/** Processes the received packet.
+ *
+ * The packet is either passed to another module or released on error.
+ *
+ * The ICMP_PARAM_POINTER error notification may be sent if the checksum is
+ * invalid.
+ * The ICMP_EXC_TTL error notification may be sent if the TTL is less than two.
+ * The ICMP_HOST_UNREACH error notification may be sent if no route was found.
+ * The ICMP_HOST_UNREACH error notification may be sent if the packet is for
+ * another host and the routing is disabled.
+ *
+ * @param[in] device_id The source device identifier.
+ * @param[in] packet    The received packet to be processed.
+ * @return              EOK on success.
+ * @return              EINVAL if the TTL is less than two.
+ * @return              EINVAL if the checksum is invalid.
+ * @return              EAFNOSUPPORT if the address family is not supported.
+ * @return              ENOENT if no route was found.
+ * @return              ENOENT if the packet is for another host and the routing
+ *                      is disabled.
+ */
+static int ip_process_packet(device_id_t device_id, packet_t *packet)
+{
+        ip_header_t *header;
+        in_addr_t dest;
+        ip_route_t *route;
+        int phone;
+        struct sockaddr *addr;
+        struct sockaddr_in addr_in;
+        socklen_t addrlen;
+        int rc;
+        
+        header = (ip_header_t *) packet_get_data(packet);
+        if (!header)
+                return ip_release_and_return(packet, ENOMEM);
+
+        // checksum
+        if ((header->header_checksum) &&
+            (IP_HEADER_CHECKSUM(header) != IP_CHECKSUM_ZERO)) {
+                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
+                if (phone >= 0) {
+                        // checksum error ICMP
+                        icmp_parameter_problem_msg(phone, ICMP_PARAM_POINTER,
+                            ((size_t) ((void *) &header->header_checksum)) -
+                            ((size_t) ((void *) header)), packet);
+                }
+                return EINVAL;
+        }
+
+        if (header->ttl <= 1) {
+                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
+                if (phone >= 0) {
+                        // ttl exceeded ICMP
+                        icmp_time_exceeded_msg(phone, ICMP_EXC_TTL, packet);
+                }
+                return EINVAL;
+        }
+        
+        // process ipopt and get destination
+        dest = ip_get_destination(header);
+
+        // set the addrination address
+        switch (header->version) {
+        case IPVERSION:
+                addrlen = sizeof(addr_in);
+                bzero(&addr_in, addrlen);
+                addr_in.sin_family = AF_INET;
+                memcpy(&addr_in.sin_addr.s_addr, &dest, sizeof(dest));
+                addr = (struct sockaddr *) &addr_in;
+                break;
+
+        default:
+                return ip_release_and_return(packet, EAFNOSUPPORT);
+        }
+
+        rc = packet_set_addr(packet, NULL, (uint8_t *) &addr, addrlen);
+        if (rc != EOK)
+                return rc;
+        
+        route = ip_find_route(dest);
+        if (!route) {
+                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
+                if (phone >= 0) {
+                        // unreachable ICMP
+                        icmp_destination_unreachable_msg(phone,
+                            ICMP_HOST_UNREACH, 0, packet);
+                }
+                return ENOENT;
+        }
+
+        if (route->address.s_addr == dest.s_addr) {
+                // local delivery
+                return ip_deliver_local(device_id, packet, header, 0);
+        }
+
+        if (route->netif->routing) {
+                header->ttl--;
+                return ip_send_route(packet, route->netif, route, NULL, dest,
+                    0);
+        }
+
+        phone = ip_prepare_icmp_and_get_phone(0, packet, header);
+        if (phone >= 0) {
+                // unreachable ICMP if no routing
+                icmp_destination_unreachable_msg(phone, ICMP_HOST_UNREACH, 0,
+                    packet);
+        }
+        
+        return ENOENT;
+}
+
 /** Returns the device packet dimensions for sending.
  *
@@ -1362 +1504 @@
  * @return              EOK on success.
  */
-static int
-ip_packet_size_message(device_id_t device_id, size_t *addr_len, size_t *prefix,
-    size_t *content, size_t *suffix)
+static int ip_packet_size_message(device_id_t device_id, size_t *addr_len,
+    size_t *prefix, size_t *content, size_t *suffix)
 {
         ip_netif_t *netif;
@@ -1414 +1555 @@
 }
 
-/** Returns the packet destination address from the IP header.
- *
- * @param[in] header    The packet IP header to be read.
- * @return              The packet destination address.
- */
-static in_addr_t ip_get_destination(ip_header_t *header)
-{
-        in_addr_t destination;
-
-        // TODO search set ipopt route?
-        destination.s_addr = header->destination_address;
-        return destination;
-}
-
-/** Delivers the packet to the local host.
- *
- * The packet is either passed to another module or released on error.
- * The ICMP_PROT_UNREACH error notification may be sent if the protocol is not
- * found.
- *
- * @param[in] device_id The source device identifier.
- * @param[in] packet    The packet to be delivered.
- * @param[in] header    The first packet IP header. May be NULL.
- * @param[in] error     The packet error service.
+/** 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.
  * @return              EOK on success.
- * @return              ENOTSUP if the packet is a fragment.
- * @return              EAFNOSUPPORT if the address family is not supported.
- * @return              ENOENT if the target protocol is not found.
- * @return              Other error codes as defined for the packet_set_addr()
- *                      function.
- * @return              Other error codes as defined for the packet_trim()
- *                      function.
- * @return              Other error codes as defined for the protocol specific
- *                      tl_received_msg() function.
+ * @return              ENOENT if device is not found.
+ */
+static int ip_mtu_changed_message(device_id_t device_id, size_t mtu)
+{
+        ip_netif_t *netif;
+
+        fibril_rwlock_write_lock(&ip_globals.netifs_lock);
+        netif = ip_netifs_find(&ip_globals.netifs, device_id);
+        if (!netif) {
+                fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
+                return ENOENT;
+        }
+        netif->packet_dimension.content = mtu;
+        fibril_rwlock_write_unlock(&ip_globals.netifs_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 ip_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:
+                        rc = ip_device_state_message(IPC_GET_DEVICE(*icall),
+                            IPC_GET_STATE(*icall));
+                        ipc_answer_0(iid, (sysarg_t) rc);
+                        break;
+                
+                case NET_IL_RECEIVED:
+                        rc = packet_translate_remote(ip_globals.net_phone, &packet,
+                            IPC_GET_PACKET(*icall));
+                        if (rc == EOK) {
+                                do {
+                                        packet_t *next = pq_detach(packet);
+                                        ip_process_packet(IPC_GET_DEVICE(*icall), packet);
+                                        packet = next;
+                                } while (packet);
+                        }
+                        
+                        ipc_answer_0(iid, (sysarg_t) rc);
+                        break;
+                
+                case NET_IL_MTU_CHANGED:
+                        rc = ip_mtu_changed_message(IPC_GET_DEVICE(*icall),
+                            IPC_GET_MTU(*icall));
+                        ipc_answer_0(iid, (sysarg_t) rc);
+                        break;
+                
+                default:
+                        ipc_answer_0(iid, (sysarg_t) ENOTSUP);
+                }
+                
+                iid = async_get_call(icall);
+        }
+}
+
+/** Registers the transport layer protocol.
+ *
+ * The traffic of this protocol will be supplied using either the receive
+ * function or IPC message.
+ *
+ * @param[in] protocol  The transport layer module protocol.
+ * @param[in] service   The transport layer module service.
+ * @param[in] phone     The transport layer module phone.
+ * @param[in] received_msg The receiving function.
+ * @return              EOK on success.
+ * @return              EINVAL if the protocol parameter and/or the service
+ *                      parameter is zero.
+ * @return              EINVAL if the phone parameter is not a positive number
+ *                      and the tl_receive_msg is NULL.
+ * @return              ENOMEM if there is not enough memory left.
  */
 static int
-ip_deliver_local(device_id_t device_id, packet_t *packet, ip_header_t *header,
-    services_t error)
+ip_register(int protocol, services_t service, int phone,
+    tl_received_msg_t received_msg)
 {
         ip_proto_t *proto;
-        int phone;
-        services_t service;
-        tl_received_msg_t received_msg;
-        struct sockaddr *src;
-        struct sockaddr *dest;
-        struct sockaddr_in src_in;
-        struct sockaddr_in dest_in;
-        socklen_t addrlen;
-        int rc;
-
-        if ((header->flags & IPFLAG_MORE_FRAGMENTS) ||
-            IP_FRAGMENT_OFFSET(header)) {
-                // TODO fragmented
-                return ENOTSUP;
-        }
-        
-        switch (header->version) {
-        case IPVERSION:
-                addrlen = sizeof(src_in);
-                bzero(&src_in, addrlen);
-                src_in.sin_family = AF_INET;
-                memcpy(&dest_in, &src_in, addrlen);
-                memcpy(&src_in.sin_addr.s_addr, &header->source_address,
-                    sizeof(header->source_address));
-                memcpy(&dest_in.sin_addr.s_addr, &header->destination_address,
-                    sizeof(header->destination_address));
-                src = (struct sockaddr *) &src_in;
-                dest = (struct sockaddr *) &dest_in;
-                break;
-
-        default:
-                return ip_release_and_return(packet, EAFNOSUPPORT);
-        }
-
-        rc = packet_set_addr(packet, (uint8_t *) src, (uint8_t *) dest,
-            addrlen);
-        if (rc != EOK)
-                return ip_release_and_return(packet, rc);
-
-        // trim padding if present
-        if (!error &&
-            (IP_TOTAL_LENGTH(header) < packet_get_data_length(packet))) {
-                rc = packet_trim(packet, 0,
-                    packet_get_data_length(packet) - IP_TOTAL_LENGTH(header));
-                if (rc != EOK)
-                        return ip_release_and_return(packet, rc);
-        }
-
-        fibril_rwlock_read_lock(&ip_globals.protos_lock);
-
-        proto = ip_protos_find(&ip_globals.protos, header->protocol);
-        if (!proto) {
-                fibril_rwlock_read_unlock(&ip_globals.protos_lock);
-                phone = ip_prepare_icmp_and_get_phone(error, packet, header);
-                if (phone >= 0) {
-                        // unreachable ICMP
-                        icmp_destination_unreachable_msg(phone,
-                            ICMP_PROT_UNREACH, 0, packet);
-                }
-                return ENOENT;
-        }
-
-        if (proto->received_msg) {
-                service = proto->service;
-                received_msg = proto->received_msg;
-                fibril_rwlock_read_unlock(&ip_globals.protos_lock);
-                rc = received_msg(device_id, packet, service, error);
-        } else {
-                rc = tl_received_msg(proto->phone, device_id, packet,
-                    proto->service, error);
-                fibril_rwlock_read_unlock(&ip_globals.protos_lock);
-        }
-
-        return rc;
-}
-
-/** Processes the received packet.
- *
- * The packet is either passed to another module or released on error.
- *
- * The ICMP_PARAM_POINTER error notification may be sent if the checksum is
- * invalid.
- * The ICMP_EXC_TTL error notification may be sent if the TTL is less than two.
- * The ICMP_HOST_UNREACH error notification may be sent if no route was found.
- * The ICMP_HOST_UNREACH error notification may be sent if the packet is for
- * another host and the routing is disabled.
- *
- * @param[in] device_id The source device identifier.
- * @param[in] packet    The received packet to be processed.
- * @return              EOK on success.
- * @return              EINVAL if the TTL is less than two.
- * @return              EINVAL if the checksum is invalid.
- * @return              EAFNOSUPPORT if the address family is not supported.
- * @return              ENOENT if no route was found.
- * @return              ENOENT if the packet is for another host and the routing
- *                      is disabled.
- */
-static int
-ip_process_packet(device_id_t device_id, packet_t *packet)
-{
-        ip_header_t *header;
-        in_addr_t dest;
-        ip_route_t *route;
-        int phone;
-        struct sockaddr *addr;
-        struct sockaddr_in addr_in;
-        socklen_t addrlen;
-        int rc;
-
-        header = (ip_header_t *) packet_get_data(packet);
-        if (!header)
-                return ip_release_and_return(packet, ENOMEM);
-
-        // checksum
-        if ((header->header_checksum) &&
-            (IP_HEADER_CHECKSUM(header) != IP_CHECKSUM_ZERO)) {
-                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
-                if (phone >= 0) {
-                        // checksum error ICMP
-                        icmp_parameter_problem_msg(phone, ICMP_PARAM_POINTER,
-                            ((size_t) ((void *) &header->header_checksum)) -
-                            ((size_t) ((void *) header)), packet);
-                }
+        int index;
+
+        if (!protocol || !service || ((phone < 0) && !received_msg))
                 return EINVAL;
-        }
-
-        if (header->ttl <= 1) {
-                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
-                if (phone >= 0) {
-                        // ttl exceeded ICMP
-                        icmp_time_exceeded_msg(phone, ICMP_EXC_TTL, packet);
-                }
-                return EINVAL;
-        }
-
-        // process ipopt and get destination
-        dest = ip_get_destination(header);
-
-        // set the addrination address
-        switch (header->version) {
-        case IPVERSION:
-                addrlen = sizeof(addr_in);
-                bzero(&addr_in, addrlen);
-                addr_in.sin_family = AF_INET;
-                memcpy(&addr_in.sin_addr.s_addr, &dest, sizeof(dest));
-                addr = (struct sockaddr *) &addr_in;
-                break;
-
-        default:
-                return ip_release_and_return(packet, EAFNOSUPPORT);
-        }
-
-        rc = packet_set_addr(packet, NULL, (uint8_t *) &addr, addrlen);
-        if (rc != EOK)
-                return rc;
-
-        route = ip_find_route(dest);
-        if (!route) {
-                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
-                if (phone >= 0) {
-                        // unreachable ICMP
-                        icmp_destination_unreachable_msg(phone,
-                            ICMP_HOST_UNREACH, 0, packet);
-                }
-                return ENOENT;
-        }
-
-        if (route->address.s_addr == dest.s_addr) {
-                // local delivery
-                return ip_deliver_local(device_id, packet, header, 0);
-        }
-
-        if (route->netif->routing) {
-                header->ttl--;
-                return ip_send_route(packet, route->netif, route, NULL, dest,
-                    0);
-        }
-
-        phone = ip_prepare_icmp_and_get_phone(0, packet, header);
-        if (phone >= 0) {
-                // unreachable ICMP if no routing
-                icmp_destination_unreachable_msg(phone, ICMP_HOST_UNREACH, 0,
-                    packet);
-        }
-        
-        return ENOENT;
-}
+
+        proto = (ip_proto_t *) malloc(sizeof(ip_protos_t));
+        if (!proto)
+                return ENOMEM;
+
+        proto->protocol = protocol;
+        proto->service = service;
+        proto->phone = phone;
+        proto->received_msg = received_msg;
+
+        fibril_rwlock_write_lock(&ip_globals.protos_lock);
+        index = ip_protos_add(&ip_globals.protos, proto->protocol, proto);
+        if (index < 0) {
+                fibril_rwlock_write_unlock(&ip_globals.protos_lock);
+                free(proto);
+                return index;
+        }
+        fibril_rwlock_write_unlock(&ip_globals.protos_lock);
+
+        printf("%s: Protocol registered (protocol: %d, phone: %d)\n",
+            NAME, proto->protocol, proto->phone);
+
+        return EOK;
+}
+
 
 static int
@@ -1756 +1792 @@
                     (header->destination_address & route->netmask.s_addr))) {
                         // clear the ARP mapping if any
-                        address.value = (char *) &header->destination_address;
+                        address.value = (uint8_t *) &header->destination_address;
                         address.length = sizeof(header->destination_address);
                         arp_clear_address_req(netif->arp->phone,
@@ -1841 +1877 @@
 }
 
-/** Processes the received IP packet or the packet queue one by one.
- *
- * The packet is either passed to another module or released on error.
- *
- * @param[in] device_id The source device identifier.
- * @param[in,out] packet The received packet.
- * @return              EOK on success and the packet is no longer needed.
- * @return              EINVAL if the packet is too small to carry the IP
- *                      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 ip_receive_message(device_id_t device_id, packet_t *packet)
-{
-        packet_t *next;
-
-        do {
-                next = pq_detach(packet);
-                ip_process_packet(device_id, packet);
-                packet = next;
-        } while (packet);
-
-        return EOK;
-}
-
 /** Processes the IP message.
  *
@@ -1881 +1888 @@
  *
  * @see ip_interface.h
- * @see il_interface.h
+ * @see il_remote.h
  * @see IS_NET_IP_MESSAGE()
  */
-int
-ip_message_standalone(ipc_callid_t callid, ipc_call_t *call, ipc_call_t *answer,
-    int *answer_count)
+int il_module_message(ipc_callid_t callid, ipc_call_t *call, ipc_call_t *answer,
+    size_t *answer_count)
 {
         packet_t *packet;
         struct sockaddr *addr;
+        void *header;
+        size_t headerlen;
         size_t addrlen;
         size_t prefix;
         size_t suffix;
         size_t content;
-        void *header;
-        size_t headerlen;
         device_id_t device_id;
         int rc;
@@ -1905 +1911 @@
         
         case IPC_M_CONNECT_TO_ME:
-                return ip_register(IL_GET_PROTO(call), IL_GET_SERVICE(call),
-                    IPC_GET_PHONE(call), NULL);
-        
-        case NET_IL_DEVICE:
-                return ip_device_req_local(0, IPC_GET_DEVICE(call),
-                    IPC_GET_SERVICE(call));
-        
-        case NET_IL_SEND:
+                return ip_register(IL_GET_PROTO(*call), IL_GET_SERVICE(*call),
+                    IPC_GET_PHONE(*call), NULL);
+        
+        case NET_IP_DEVICE:
+                return ip_device_req_local(0, IPC_GET_DEVICE(*call),
+                    IPC_GET_SERVICE(*call));
+        
+        case NET_IP_RECEIVED_ERROR:
                 rc = packet_translate_remote(ip_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
+                    IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
-                return ip_send_msg_local(0, IPC_GET_DEVICE(call), packet, 0,
-                    IPC_GET_ERROR(call));
-        
-        case NET_IL_DEVICE_STATE:
-                return ip_device_state_message(IPC_GET_DEVICE(call),
-                    IPC_GET_STATE(call));
-        
-        case NET_IL_RECEIVED:
-                rc = packet_translate_remote(ip_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
-                if (rc != EOK)
-                        return rc;
-                return ip_receive_message(IPC_GET_DEVICE(call), packet);
-        
-        case NET_IP_RECEIVED_ERROR:
-                rc = packet_translate_remote(ip_globals.net_phone, &packet,
-                    IPC_GET_PACKET(call));
-                if (rc != EOK)
-                        return rc;
-                return ip_received_error_msg_local(0, IPC_GET_DEVICE(call),
-                    packet, IPC_GET_TARGET(call), IPC_GET_ERROR(call));
+                return ip_received_error_msg_local(0, IPC_GET_DEVICE(*call),
+                    packet, IPC_GET_TARGET(*call), IPC_GET_ERROR(*call));
         
         case NET_IP_ADD_ROUTE:
-                return ip_add_route_req_local(0, IPC_GET_DEVICE(call),
-                    IP_GET_ADDRESS(call), IP_GET_NETMASK(call),
-                    IP_GET_GATEWAY(call));
+                return ip_add_route_req_local(0, IPC_GET_DEVICE(*call),
+                    IP_GET_ADDRESS(*call), IP_GET_NETMASK(*call),
+                    IP_GET_GATEWAY(*call));
 
         case NET_IP_SET_GATEWAY:
-                return ip_set_gateway_req_local(0, IPC_GET_DEVICE(call),
-                    IP_GET_GATEWAY(call));
+                return ip_set_gateway_req_local(0, IPC_GET_DEVICE(*call),
+                    IP_GET_GATEWAY(*call));
 
         case NET_IP_GET_ROUTE:
@@ -1954 +1941 @@
                         return rc;
                 
-                rc = ip_get_route_req_local(0, IP_GET_PROTOCOL(call), addr,
+                rc = ip_get_route_req_local(0, IP_GET_PROTOCOL(*call), addr,
                     (socklen_t) addrlen, &device_id, &header, &headerlen);
                 if (rc != EOK)
                         return rc;
                 
-                IPC_SET_DEVICE(answer, device_id);
-                IP_SET_HEADERLEN(answer, headerlen);
+                IPC_SET_DEVICE(*answer, device_id);
+                IP_SET_HEADERLEN(*answer, headerlen);
                 
                 *answer_count = 2;
@@ -1971 +1958 @@
                 return rc;
         
-        case NET_IL_PACKET_SPACE:
-                rc = ip_packet_size_message(IPC_GET_DEVICE(call), &addrlen,
+        case NET_IP_PACKET_SPACE:
+                rc = ip_packet_size_message(IPC_GET_DEVICE(*call), &addrlen,
                     &prefix, &content, &suffix);
                 if (rc != EOK)
                         return rc;
                 
-                IPC_SET_ADDR(answer, addrlen);
-                IPC_SET_PREFIX(answer, prefix);
-                IPC_SET_CONTENT(answer, content);
-                IPC_SET_SUFFIX(answer, suffix);
+                IPC_SET_ADDR(*answer, addrlen);
+                IPC_SET_PREFIX(*answer, prefix);
+                IPC_SET_CONTENT(*answer, content);
+                IPC_SET_SUFFIX(*answer, suffix);
                 *answer_count = 4;
                 return EOK;
         
-        case NET_IL_MTU_CHANGED:
-                return ip_mtu_changed_message(IPC_GET_DEVICE(call),
-                    IPC_GET_MTU(call));
+        case NET_IP_SEND:
+                rc = packet_translate_remote(ip_globals.net_phone, &packet,
+                    IPC_GET_PACKET(*call));
+                if (rc != EOK)
+                        return rc;
+                
+                return ip_send_msg_local(0, IPC_GET_DEVICE(*call), packet, 0,
+                    IPC_GET_ERROR(*call));
         }
         
@@ -1992 +1984 @@
 }
 
-/** 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.
-         */
-        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 told to either by the message or the processing
-                 * result.
-                 */
-                if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
-                    (res == EHANGUP)) {
-                        return;
-                }
-                
-                /* Answer the message */
-                answer_call(callid, res, &answer, answer_count);
-        }
-}
-
-/** Starts the module.
- *
- * @return EOK on success.
- * @return Other error codes as defined for each specific module start function.
- */
 int main(int argc, char *argv[])
 {
-        int rc;
-        
         /* Start the module */
-        rc = il_module_start_standalone(il_client_connection);
-        return rc;
+        return il_module_start(SERVICE_IP);
 }
 

uspace/srv/net/il/ip/ip.h

@@ -138 +138 @@
 /** IP global data. */
 struct ip_globals {
-        /** Default client connection function for support modules. */
-        async_client_conn_t client_connection;
         /** Default gateway. */
         ip_route_t gateway;