Changeset 357b5f5 for uspace/srv/net – HelenOS

uspace/srv/net/cfg/ne2k

-              rcead2aa
+              r357b5f5
 NAME=ne2k
 NETIF=dp8390
+NETIF=ne2000
 NIL=eth
 IL=ip
 IRQ=9
+IRQ=5
 IO=300
 …
 IP_ADDR=10.0.2.15
 IP_ROUTING=yes
 IP_NETMASK=255.255.255.240
+IP_NETMASK=255.255.255.0
 IP_BROADCAST=10.0.2.255
 IP_GATEWAY=10.0.2.2
 ARP=arp
 MTU=1492
+MTU=1500

uspace/srv/net/il/arp/Makefile

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

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

-              rcead2aa
+              r357b5f5
  */
-#include "arp.h"
-#include "arp_header.h"
-#include "arp_oc.h"
-#include "arp_module.h"
 #include <async.h>
 #include <malloc.h>
 #include <mem.h>
 #include <fibril_synch.h>
+#include <assert.h>
 #include <stdio.h>
 #include <str.h>
 …
 #include <ipc/arp.h>
 #include <ipc/il.h>
+#include <ipc/nil.h>
 #include <byteorder.h>
 #include <errno.h>
 #include <net/modules.h>
 #include <net/device.h>
 #include <net/packet.h>
+#include <nil_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. */
 #define NAME  "arp"
+/** Number of microseconds to wait for an ARP reply. */
+#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. */
 arp_globals_t arp_globals;
 …
 DEVICE_MAP_IMPLEMENT(arp_cache, arp_device_t);
 INT_MAP_IMPLEMENT(arp_protos, arp_proto_t);
+GENERIC_CHAR_MAP_IMPLEMENT(arp_addr, measured_string_t);
+/** Clears the device specific data.
+ *
+ * @param[in] device    The device specific data.
+GENERIC_CHAR_MAP_IMPLEMENT(arp_addr, arp_trans_t);
+static void arp_clear_trans(arp_trans_t *trans)
+{
+        if (trans->hw_addr) {
+                free(trans->hw_addr);
+                trans->hw_addr = NULL;
+        }
+        fibril_condvar_broadcast(&trans->cv);
+}
+static void arp_clear_addr(arp_addr_t *addresses)
+{
+        int count;
+        for (count = arp_addr_count(addresses) - 1; count >= 0; count--) {
+                arp_trans_t *trans = arp_addr_items_get_index(&addresses->values,
+                    count);
+                if (trans)
+                        arp_clear_trans(trans);
+        }
+}
+/** Clear the device specific data.
+ *
+ * @param[in] device Device specific data.
  */
 static void arp_clear_device(arp_device_t *device)
+{
         int count;
+        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);
+}
 …
+{
         int count;
+        arp_device_t *device;
+        fibril_rwlock_write_lock(&arp_globals.lock);
+        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_rwlock_write_unlock(&arp_globals.lock);
         printf("Cache cleaned\n");
+        fibril_mutex_unlock(&arp_globals.lock);
         return EOK;
+}
 …
     services_t protocol, measured_string_t *address)
+{
+        arp_device_t *device;
+        arp_proto_t *proto;
+        fibril_rwlock_write_lock(&arp_globals.lock);
+        device = arp_cache_find(&arp_globals.cache, device_id);
+        fibril_mutex_lock(&arp_globals.lock);
+        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
         if (!device) {
                 fibril_rwlock_write_unlock(&arp_globals.lock);
+                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_rwlock_write_unlock(&arp_globals.lock);
+                fibril_mutex_unlock(&arp_globals.lock);
                 return ENOENT;
+        }
+        arp_trans_t *trans = arp_addr_find(&proto->addresses, address->value,
+            address->length);
+        if (trans)
+                arp_clear_trans(trans);
         arp_addr_exclude(&proto->addresses, address->value, address->length);
+        fibril_rwlock_write_unlock(&arp_globals.lock);
+        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_rwlock_write_lock(&arp_globals.lock);
+        device = arp_cache_find(&arp_globals.cache, device_id);
+        fibril_mutex_lock(&arp_globals.lock);
+        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
         if (!device) {
                 fibril_rwlock_write_unlock(&arp_globals.lock);
+                fibril_mutex_unlock(&arp_globals.lock);
                 return ENOENT;
+        }
         arp_clear_device(device);
         printf("Device %d cleared\n", device_id);
         fibril_rwlock_write_unlock(&arp_globals.lock);
+        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)
 …
         (*proto)->addr_data = address->value;
         rc = arp_addr_initialize(&(*proto)->addresses);
+        int rc = arp_addr_initialize(&(*proto)->addresses);
         if (rc != EOK) {
                 free(*proto);
 …
+}
+/** 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_rwlock_write_lock(&arp_globals.lock);
+        /* An existing device? */
+        device = arp_cache_find(&arp_globals.cache, device_id);
+        if (device) {
+                if (device->service != service) {
+                        printf("Device %d already exists\n", device->device_id);
+                        fibril_rwlock_write_unlock(&arp_globals.lock);
+                        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_rwlock_write_unlock(&arp_globals.lock);
+                                return rc;
+                        }
+                        index = arp_protos_add(&device->protos, proto->service,
+                            proto);
+                        if (index < 0) {
+                                fibril_rwlock_write_unlock(&arp_globals.lock);
+                                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_rwlock_write_unlock(&arp_globals.lock);
+                        return ENOMEM;
+                }
+                device->hardware = hardware;
+                device->device_id = device_id;
+                rc = arp_protos_initialize(&device->protos);
+                if (rc != EOK) {
+                        fibril_rwlock_write_unlock(&arp_globals.lock);
+                        free(device);
+                        return rc;
+                }
+                rc = arp_proto_create(&proto, protocol, address);
+                if (rc != EOK) {
+                        fibril_rwlock_write_unlock(&arp_globals.lock);
+                        free(device);
+                        return rc;
+                }
+                index = arp_protos_add(&device->protos, proto->service, proto);
+                if (index < 0) {
+                        fibril_rwlock_write_unlock(&arp_globals.lock);
+                        arp_protos_destroy(&device->protos);
+                        free(device);
+                        return index;
+                }
+                device->service = service;
+                /* Bind the new one */
+                device->phone = nil_bind_service(device->service,
+                    (ipcarg_t) device->device_id, SERVICE_ARP,
+                    arp_globals.client_connection);
+                if (device->phone < 0) {
+                        fibril_rwlock_write_unlock(&arp_globals.lock);
+                        arp_protos_destroy(&device->protos);
+                        free(device);
+                        return EREFUSED;
+                }
+                /* Get packet dimensions */
+                rc = nil_packet_size_req(device->phone, device_id,
+                    &device->packet_dimension);
+                if (rc != EOK) {
+                        fibril_rwlock_write_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_rwlock_write_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_rwlock_write_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_rwlock_write_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_rwlock_write_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_rwlock_initialize(&arp_globals.lock);
+        fibril_rwlock_write_lock(&arp_globals.lock);
+        arp_globals.client_connection = client_connection;
+        rc = arp_cache_initialize(&arp_globals.cache);
+        fibril_rwlock_write_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_rwlock_write_lock(&arp_globals.lock);
+        device = arp_cache_find(&arp_globals.cache, device_id);
+        if (!device) {
+                fibril_rwlock_write_unlock(&arp_globals.lock);
+                return ENOENT;
+        }
+        device->packet_dimension.content = mtu;
+        fibril_rwlock_write_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;
+        measured_string_t *hw_source;
+        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 +
 …
                 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;
+        hw_source = arp_addr_find(&proto->addresses, (char *) src_proto,
+            CONVERT_SIZE(uint8_t, char, header->protocol_length));
+        /* Exists? */
+        if (hw_source) {
+                if (hw_source->length != CONVERT_SIZE(uint8_t, char,
+                    header->hardware_length)) {
+        uint8_t *src_hw = ((uint8_t *) header) + sizeof(arp_header_t);
+        uint8_t *src_proto = src_hw + header->hardware_length;
+        uint8_t *des_hw = src_proto + header->protocol_length;
+        uint8_t *des_proto = des_hw + header->hardware_length;
+        arp_trans_t *trans = arp_addr_find(&proto->addresses, src_proto,
+            header->protocol_length);
+        if ((trans) && (trans->hw_addr)) {
+                /* Translation exists */
+                if (trans->hw_addr->length != header->hardware_length)
                         return EINVAL;
+                }
+                memcpy(hw_source->value, src_hw, hw_source->length);
+        }
+                memcpy(trans->hw_addr->value, src_hw, trans->hw_addr->length);
+        }
         /* Is my protocol address? */
+        if (proto->addr->length != CONVERT_SIZE(uint8_t, char,
+            header->protocol_length)) {
+        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 (!hw_source) {
+                        hw_source = measured_string_create_bulk((char *) src_hw,
+                            CONVERT_SIZE(uint8_t, char,
+                            header->hardware_length));
+                        if (!hw_source)
+        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;
+                        rc = arp_addr_add(&proto->addresses, (char *) src_proto,
+                            CONVERT_SIZE(uint8_t, char,
+                            header->protocol_length), hw_source);
+                        if (rc != EOK)
+                        trans->hw_addr = NULL;
+                        fibril_condvar_initialize(&trans->cv);
+                        rc = arp_addr_add(&proto->addresses, src_proto,
+                            header->protocol_length, trans);
+                        if (rc != EOK) {
+                                /* The generic char map has already freed trans! */
                                 return rc;
+                }
+                        }
+                }
+                if (!trans->hw_addr) {
+                        trans->hw_addr = measured_string_create_bulk(src_hw,
+                            header->hardware_length);
+                        if (!trans->hw_addr)
+                                return ENOMEM;
+                        /* Notify the fibrils that wait for the translation. */
+                        fibril_condvar_broadcast(&trans->cv);
+                }
                 if (ntohs(header->operation) == ARPOP_REQUEST) {
                         header->operation = htons(ARPOP_REPLY);
 …
                         memcpy(src_hw, device->addr->value,
                             device->packet_dimension.addr_len);
                         memcpy(des_hw, hw_source->value,
+                        memcpy(des_hw, trans->hw_addr->value,
                             header->hardware_length);
 …
+                }
+        }
         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.
+ * @return              The hardware address of the target.
+ * @return              NULL if the target parameter is NULL.
+ * @return              NULL if the device is not found.
+ * @return              NULL if the device packet is too small to send a
+ *                      request.
+ * @return              NULL if the hardware address is not found in the cache.
+ */
+static measured_string_t *
+arp_translate_message(device_id_t device_id, services_t protocol,
+    measured_string_t *target)
+{
+        arp_device_t *device;
+        arp_proto_t *proto;
+        measured_string_t *addr;
+        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;
+        if (!target)
+                return NULL;
+        device = arp_cache_find(&arp_globals.cache, device_id);
+        if (!device)
+                return NULL;
+        proto = arp_protos_find(&device->protos, protocol);
+        if (!proto || (proto->addr->length != target->length))
+                return NULL;
+        addr = arp_addr_find(&proto->addresses, target->value, target->length);
+        if (addr)
+                return addr;
+        int rc;
+        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;
+                /* 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 * (CONVERT_SIZE(char, uint8_t, proto->addr->length) +
+            CONVERT_SIZE(char, uint8_t, device->addr->length));
+        size_t length = 8 + 2 * (proto->addr->length + device->addr->length);
         if (length > device->packet_dimension.content)
                 return NULL;
         packet = packet_get_4_remote(arp_globals.net_phone,
+                return ELIMIT;
+        packet_t *packet = packet_get_4_remote(arp_globals.net_phone,
             device->packet_dimension.addr_len, device->packet_dimension.prefix,
             length, device->packet_dimension.suffix);
         if (!packet)
                 return NULL;
         header = (arp_header_t *) packet_suffix(packet, length);
+                return ENOMEM;
+        arp_header_t *header = (arp_header_t *) packet_suffix(packet, length);
         if (!header) {
                 pq_release_remote(arp_globals.net_phone, packet_get_id(packet));
                 return NULL;
+        }
+                return ENOMEM;
+        }
         header->hardware = htons(device->hardware);
         header->hardware_length = (uint8_t) device->addr->length;
 …
         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);
 …
         length += device->addr->length;
         memcpy(((uint8_t *) header) + length, target->value, target->length);
         if (packet_set_addr(packet, (uint8_t *) device->addr->value,
             (uint8_t *) device->broadcast_addr->value,
             CONVERT_SIZE(char, uint8_t, device->addr->length)) != EOK) {
+        int rc = packet_set_addr(packet, (uint8_t *) device->addr->value,
+            (uint8_t *) device->broadcast_addr->value, device->addr->length);
+        if (rc != EOK) {
                 pq_release_remote(arp_globals.net_phone, packet_get_id(packet));
                 return NULL;
+        }
+                return rc;
+        }
         nil_send_msg(device->phone, device_id, packet, SERVICE_ARP);
+        return NULL;
+}
+/** 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.
+        return EOK;
+}
+/** Return the hardware address for the given protocol address.
+ *
+ * Send the ARP request packet if the hardware address is not found in the
+ * cache.
+ *
+ * @param[in]  device_id   Device identifier.
+ * @param[in]  protocol    Protocol service.
+ * @param[in]  target      Target protocol address.
+ * @param[out] translation Where the hardware address of the target is stored.
+ *
+ * @return EOK on success.
+ * @return EAGAIN if the caller should try again.
+ * @return Other error codes in case of error.
+ *
+ */
+static int arp_translate_message(device_id_t device_id, services_t protocol,
+    measured_string_t *target, measured_string_t **translation)
+{
+        bool retry = false;
+        int rc;
+        assert(fibril_mutex_is_locked(&arp_globals.lock));
+restart:
+        if ((!target) || (!translation))
+                return EBADMEM;
+        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
+        if (!device)
+                return ENOENT;
+        arp_proto_t *proto = arp_protos_find(&device->protos, protocol);
+        if ((!proto) || (proto->addr->length != target->length))
+                return ENOENT;
+        arp_trans_t *trans = arp_addr_find(&proto->addresses, target->value,
+            target->length);
+        if (trans) {
+                if (trans->hw_addr) {
+                        /* The translation is in place. */
+                        *translation = trans->hw_addr;
+                        return EOK;
+                }
+                if (retry) {
+                        /*
+                         * We may get here as a result of being signalled for
+                         * some reason while waiting for the translation (e.g.
+                         * translation becoming available, record being removed
+                         * from the table) and then losing the race for
+                         * the arp_globals.lock with someone else who modified
+                         * the table.
+                         *
+                         * Remove the incomplete record so that it is possible
+                         * to make new ARP requests.
+                         */
+                        arp_clear_trans(trans);
+                        arp_addr_exclude(&proto->addresses, target->value,
+                            target->length);
+                        return EAGAIN;
+                }
+                /*
+                 * We are a random passer-by who merely joins an already waiting
+                 * fibril in waiting for the translation.
+                 */
+                rc = fibril_condvar_wait_timeout(&trans->cv, &arp_globals.lock,
+                    ARP_TRANS_WAIT);
+                if (rc == ETIMEOUT)
+                        return ENOENT;
+                /*
+                 * Need to recheck because we did not hold the lock while
+                 * sleeping on the condition variable.
+                 */
+                retry = true;
+                goto restart;
+        }
+        if (retry)
+                return EAGAIN;
+        /*
+         * We are under the protection of arp_globals.lock, so we can afford to
+         * first send the ARP request and then insert an incomplete ARP record.
+         * The incomplete record is used to tell any other potential waiter
+         * that this fibril has already sent the request and that it is waiting
+         * for the answer. Lastly, any fibril which sees the incomplete request
+         * can perform a timed wait on its condition variable to wait for the
+         * ARP reply to arrive.
+         */
+        rc = arp_send_request(device_id, protocol, target, device, proto);
+        if (rc != EOK)
+                return rc;
+        trans = (arp_trans_t *) malloc(sizeof(arp_trans_t));
+        if (!trans)
+                return ENOMEM;
+        trans->hw_addr = NULL;
+        fibril_condvar_initialize(&trans->cv);
+        rc = arp_addr_add(&proto->addresses, target->value, target->length,
+            trans);
+        if (rc != EOK) {
+                /* The generic char map has already freed trans! */
+                return rc;
+        }
+        rc = fibril_condvar_wait_timeout(&trans->cv, &arp_globals.lock,
+            ARP_TRANS_WAIT);
+        if (rc == ETIMEOUT) {
+                /*
+                 * Remove the incomplete record so that it is possible to make
+                 * new ARP requests.
+                 */
+                arp_clear_trans(trans);
+                arp_addr_exclude(&proto->addresses, target->value,
+                    target->length);
+                return ENOENT;
+        }
+        /*
+         * We need to recheck that the translation has indeed become available,
+         * because we dropped the arp_globals.lock while sleeping on the
+         * condition variable and someone else might have e.g. removed the
+         * translation before we managed to lock arp_globals.lock again.
+         */
+        retry = true;
+        goto restart;
+}
+/** Process the ARP message.
+ *
+ * @param[in]  callid Message identifier.
+ * @param[in]  call   Message parameters.
+ * @param[out] answer Answer.
+ * @param[out] count  Number of arguments of the answer.
+ *
+ * @return EOK on success.
+ * @return ENOTSUP if the message is not known.
+ *
  * @see arp_interface.h
  * @see IS_NET_ARP_MESSAGE()
  */
+int
 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;
         switch (IPC_GET_METHOD(*call)) {
+        *count = 0;
+        switch (IPC_GET_IMETHOD(*call)) {
         case IPC_M_PHONE_HUNGUP:
                 return EOK;
 …
                         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;
 …
                         return rc;
                 fibril_rwlock_read_lock(&arp_globals.lock);
                 translation = arp_translate_message(IPC_GET_DEVICE(call),
                     IPC_GET_SERVICE(call), address);
+                fibril_mutex_lock(&arp_globals.lock);
+                rc = arp_translate_message(IPC_GET_DEVICE(*call),
+                    IPC_GET_SERVICE(*call), address, &translation);
                 free(address);
                 free(data);
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        return rc;
+                }
                 if (!translation) {
                         fibril_rwlock_read_unlock(&arp_globals.lock);
+                        fibril_mutex_unlock(&arp_globals.lock);
                         return ENOENT;
+                }
                 rc = measured_strings_reply(translation, 1);
                 fibril_rwlock_read_unlock(&arp_globals.lock);
+                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);
 …
                         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);
 …
         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_rwlock_read_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_rwlock_read_unlock(&arp_globals.lock);
-                return EOK;
-        case NET_IL_MTU_CHANGED:
-                return arp_mtu_changed_message(IPC_GET_DEVICE(call),
-                    IPC_GET_MTU(call));
+        }
 …
+}
-/** 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_METHOD(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

-              rcead2aa
+              r357b5f5
 typedef struct arp_proto arp_proto_t;
+/** Type definition of the ARP address translation record.
+ * @see arp_trans
+ */
+typedef struct arp_trans arp_trans_t;
 /** ARP address map.
+ *
 …
  * @see generic_char_map.h
  */
 GENERIC_CHAR_MAP_DECLARE(arp_addr, measured_string_t);
+GENERIC_CHAR_MAP_DECLARE(arp_addr, arp_trans_t);
 /** ARP address cache.
 …
 struct arp_device {
         /** Actual device hardware address. */
         measured_string_t * addr;
+        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;
+        measured_string_t *broadcast_addr;
         /** Broadcast device hardware address data. */
         char *broadcast_data;
+        uint8_t *broadcast_data;
         /** Device identifier. */
         device_id_t device_id;
 …
         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;
         /** Safety lock. */
         fibril_rwlock_t lock;
+        fibril_mutex_t lock;
 };
 …
         measured_string_t *addr;
         /** Actual device protocol address data. */
         char *addr_data;
+        uint8_t *addr_data;
         /** Address map. */
         arp_addr_t addresses;
 …
 };
+/** ARP address translation record. */
+struct arp_trans {
+        /**
+         * 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. */
+        fibril_condvar_t cv;
+};
 #endif
 /** @}
  */

uspace/srv/net/il/ip/Makefile

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

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

-              rcead2aa
+              r357b5f5
  * @see arp.h
  */
-#include "ip.h"
-#include "ip_module.h"
 #include <async.h>
 …
 #include <sys/types.h>
 #include <byteorder.h>
+#include "ip.h"
 #include <adt/measured_strings.h>
 …
 #include <net_checksum.h>
 #include <icmp_client.h>
+#include <icmp_interface.h>
+#include <il_interface.h>
+#include <icmp_remote.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. */
 …
 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.
 …
+}
+/** 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;
 …
         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;
 …
         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:
 …
         measured_string_t names[] = {
+                {
                         (char *) "IPV",
+                        (uint8_t *) "IPV",
                 },
+                {
                         (char *) "IP_CONFIG",
+                        (uint8_t *) "IP_CONFIG",
                 },
+                {
                         (char *) "IP_ADDR",
+                        (uint8_t *) "IP_ADDR",
                 },
+                {
                         (char *) "IP_NETMASK",
+                        (uint8_t *) "IP_NETMASK",
                 },
+                {
                         (char *) "IP_GATEWAY",
+                        (uint8_t *) "IP_GATEWAY",
                 },
+                {
                         (char *) "IP_BROADCAST",
+                        (uint8_t *) "IP_BROADCAST",
                 },
+                {
                         (char *) "ARP",
+                        (uint8_t *) "ARP",
                 },
+                {
                         (char *) "IP_ROUTING",
+                        (uint8_t *) "IP_ROUTING",
+                }
 …
         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;
 …
         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);
 …
+                        }
                         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))
+                            {
 …
         // binds the netif service which also initializes the device
         ip_netif->phone = nil_bind_service(ip_netif->service,
             (ipcarg_t) ip_netif->device_id, SERVICE_IP,
             ip_globals.client_connection);
+            (sysarg_t) ip_netif->device_id, SERVICE_IP,
+            ip_receiver);
         if (ip_netif->phone < 0) {
                 printf("Failed to contact the nil service %d\n",
 …
         if (ip_netif->arp) {
                 if (route) {
                         address.value = (char *) &route->address.s_addr;
                         address.length = CONVERT_SIZE(in_addr_t, char, 1);
+                        address.value = (uint8_t *) &route->address.s_addr;
+                        address.length = sizeof(in_addr_t);
                         rc = arp_device_req(ip_netif->arp->phone,
 …
                 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);
+        }
 …
+}
+/** 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;
+}
 …
  *                      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;
 …
         if (destination) {
                 rc = packet_set_addr(packet, NULL, (uint8_t *) destination->value,
                     CONVERT_SIZE(char, uint8_t, destination->length));
+                    destination->length);
         } else {
                 rc = packet_set_addr(packet, NULL, NULL, 0);
 …
                                 rc = packet_set_addr(next, NULL,
                                     (uint8_t *) destination->value,
+                                    CONVERT_SIZE(char, uint8_t,
+                                    destination->length));
+                                    destination->length);
                                 if (rc != EOK) {
                                         free(last_header);
 …
                         rc = packet_set_addr(next, NULL,
                             (uint8_t *) destination->value,
                             CONVERT_SIZE(char, uint8_t, destination->length));
+                            destination->length);
                         if (rc != EOK) {
                                 free(last_header);
 …
  *                      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)
 …
         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;
+}
 …
  *                      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;
 …
         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;
                 destination.length = CONVERT_SIZE(dest.s_addr, char, 1);
+                    (uint8_t *) &route->gateway.s_addr : (uint8_t *) &dest.s_addr;
+                destination.length = sizeof(dest.s_addr);
                 rc = arp_translate_req(netif->arp->phone, netif->device_id,
 …
+}
+/** 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;
 …
         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;
 …
+                }
+        }
         // if the local host is the destination
         if ((route->address.s_addr == dest->s_addr) &&
 …
+}
+/** 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,
+);
+        }
+        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.
+ *
 …
  * @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;
 …
+}
+/** 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,
+);
+        }
+        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
 …
                     (header->destination_address & route->netmask.s_addr))) {
                         // clear the ARP mapping if any
+                        address.value = (char *) &header->destination_address;
+                        address.length = CONVERT_SIZE(uint8_t, char,
+                            sizeof(header->destination_address));
+                        address.value = (uint8_t *) &header->destination_address;
+                        address.length = sizeof(header->destination_address);
                         arp_clear_address_req(netif->arp->phone,
                             netif->device_id, SERVICE_IP, &address);
 …
+}
-/** 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.
+ *
 …
+ *
  * @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;
         *answer_count = 0;
         switch (IPC_GET_METHOD(*call)) {
+        switch (IPC_GET_IMETHOD(*call)) {
         case IPC_M_PHONE_HUNGUP:
                 return EOK;
         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:
+                rc = data_receive((void **) &addr, &addrlen);
+                rc = async_data_write_accept((void **) &addr, false, 0, 0, 0,
+                    &addrlen);
                 if (rc != EOK)
                         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;
 …
                 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));
+        }
 …
+}
-/** 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_METHOD(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

rcead2aa	r357b5f5
138	138	/** IP global data. */
139	139	struct ip_globals {
140		~~/** Default client connection function for support modules. */~~
141		~~async_client_conn_t client_connection;~~
142	140	/** Default gateway. */
143	141	ip_route_t gateway;

uspace/srv/net/net/net.c

-              rcead2aa
+              r357b5f5
 #include <stdio.h>
 #include <str.h>
+#include <str_error.h>
 #include <ipc/ipc.h>
 …
 #include <ipc/net_net.h>
 #include <ipc/il.h>
+#include <ipc/nil.h>
 #include <net/modules.h>
 …
 #include <netif_remote.h>
 #include <nil_interface.h>
+#include <nil_remote.h>
 #include <net_interface.h>
 #include <ip_interface.h>
 …
+ *
  */
 int add_configuration(measured_strings_t *configuration, const char *name,
     const char *value)
+int add_configuration(measured_strings_t *configuration, const uint8_t *name,
+    const uint8_t *value)
+{
         int rc;
 …
+}
 static int parse_line(measured_strings_t *configuration, char *line)
+static int parse_line(measured_strings_t *configuration, uint8_t *line)
+{
         int rc;
         /* From the beginning */
         char *name = line;
+        uint8_t *name = line;
         /* Skip comments and blank lines */
 …
         /* Remember the name start */
         char *value = name;
+        uint8_t *value = name;
         /* Skip the name */
 …
         /* Construct the full filename */
         char line[BUFFER_SIZE];
         if (snprintf(line, BUFFER_SIZE, "%s/%s", directory, filename) > BUFFER_SIZE)
+        char fname[BUFFER_SIZE];
+        if (snprintf(fname, BUFFER_SIZE, "%s/%s", directory, filename) > BUFFER_SIZE)
                 return EOVERFLOW;
         /* Open the file */
         FILE *cfg = fopen(line, "r");
+        FILE *cfg = fopen(fname, "r");
         if (!cfg)
                 return ENOENT;
 …
         unsigned int line_number = 0;
         size_t index = 0;
+        uint8_t line[BUFFER_SIZE];
         while (!ferror(cfg) && !feof(cfg)) {
                 int read = fgetc(cfg);
 …
                                 line[BUFFER_SIZE - 1] = '\0';
                                 fprintf(stderr, "%s: Configuration line %u too "
                                     "long: %s\n", NAME, line_number, line);
+                                    "long: %s\n", NAME, line_number, (char *) line);
                                 /* No space left in the line buffer */
 …
+                        }
                         /* Append the character */
                         line[index] = (char) read;
+                        line[index] = (uint8_t) read;
                         index++;
                 } else {
 …
                         if (parse_line(configuration, line) != EOK) {
                                 fprintf(stderr, "%s: Configuration error on "
                                     "line %u: %s\n", NAME, line_number, line);
+                                    "line %u: %s\n", NAME, line_number, (char *) line);
+                        }
 …
                 return rc;
         rc = add_module(NULL, &net_globals.modules, LO_NAME, LO_FILENAME,
             SERVICE_LO, 0, connect_to_service);
         if (rc != EOK)
                 return rc;
         rc = add_module(NULL, &net_globals.modules, DP8390_NAME,
             DP8390_FILENAME, SERVICE_DP8390, 0, connect_to_service);
         if (rc != EOK)
                 return rc;
         rc = add_module(NULL, &net_globals.modules, ETHERNET_NAME,
             ETHERNET_FILENAME, SERVICE_ETHERNET, 0, connect_to_service);
         if (rc != EOK)
                 return rc;
         rc = add_module(NULL, &net_globals.modules, NILDUMMY_NAME,
             NILDUMMY_FILENAME, SERVICE_NILDUMMY, 0, connect_to_service);
+        rc = add_module(NULL, &net_globals.modules, (uint8_t *) LO_NAME,
+            (uint8_t *) LO_FILENAME, SERVICE_LO, 0, connect_to_service);
+        if (rc != EOK)
+                return rc;
+        rc = add_module(NULL, &net_globals.modules, (uint8_t *) NE2000_NAME,
+            (uint8_t *) NE2000_FILENAME, SERVICE_NE2000, 0, connect_to_service);
+        if (rc != EOK)
+                return rc;
+        rc = add_module(NULL, &net_globals.modules, (uint8_t *) ETHERNET_NAME,
+            (uint8_t *) ETHERNET_FILENAME, SERVICE_ETHERNET, 0, connect_to_service);
+        if (rc != EOK)
+                return rc;
+        rc = add_module(NULL, &net_globals.modules, (uint8_t *) NILDUMMY_NAME,
+            (uint8_t *) NILDUMMY_FILENAME, SERVICE_NILDUMMY, 0, connect_to_service);
         if (rc != EOK)
                 return rc;
 …
 static int net_module_start(async_client_conn_t client_connection)
+{
         ipcarg_t phonehash;
+        sysarg_t phonehash;
         int rc;
 …
                 return rc;
         rc = net_initialize(client_connection);
         if (rc != EOK)
                 goto out;
         rc = REGISTER_ME(SERVICE_NETWORKING, &phonehash);
+        rc = ipc_connect_to_me(PHONE_NS, SERVICE_NETWORKING, 0, 0, &phonehash);
         if (rc != EOK)
                 goto out;
 …
  */
 static int net_get_conf(measured_strings_t *netif_conf,
     measured_string_t *configuration, size_t count, char **data)
+    measured_string_t *configuration, size_t count, uint8_t **data)
+{
         if (data)
 …
 int net_get_conf_req(int net_phone, measured_string_t **configuration,
     size_t count, char **data)
+    size_t count, uint8_t **data)
+{
         if (!configuration || (count <= 0))
 …
 int net_get_device_conf_req(int net_phone, device_id_t device_id,
     measured_string_t **configuration, size_t count, char **data)
+    measured_string_t **configuration, size_t count, uint8_t **data)
+{
         if ((!configuration) || (count == 0))
 …
+}
 void net_free_settings(measured_string_t *settings, char *data)
+void net_free_settings(measured_string_t *settings, uint8_t *data)
+{
+}
 …
         /* Mandatory netif */
         measured_string_t *setting =
             measured_strings_find(&netif->configuration, CONF_NETIF, 0);
+            measured_strings_find(&netif->configuration, (uint8_t *) CONF_NETIF, 0);
         netif->driver = get_running_module(&net_globals.modules, setting->value);
 …
         /* Optional network interface layer */
         setting = measured_strings_find(&netif->configuration, CONF_NIL, 0);
+        setting = measured_strings_find(&netif->configuration, (uint8_t *) CONF_NIL, 0);
         if (setting) {
                 netif->nil = get_running_module(&net_globals.modules, setting->value);
 …
         /* Mandatory internet layer */
         setting = measured_strings_find(&netif->configuration, CONF_IL, 0);
+        setting = measured_strings_find(&netif->configuration, (uint8_t *) CONF_IL, 0);
         netif->il = get_running_module(&net_globals.modules, setting->value);
         if (!netif->il) {
 …
         /* Hardware configuration */
         setting = measured_strings_find(&netif->configuration, CONF_IRQ, 0);
         int irq = setting ? strtol(setting->value, NULL, 10) : 0;
         setting = measured_strings_find(&netif->configuration, CONF_IO, 0);
         int io = setting ? strtol(setting->value, NULL, 16) : 0;
         rc = netif_probe_req_remote(netif->driver->phone, netif->id, irq, io);
+        setting = measured_strings_find(&netif->configuration, (uint8_t *) CONF_IRQ, 0);
+        int irq = setting ? strtol((char *) setting->value, NULL, 10) : 0;
+        setting = measured_strings_find(&netif->configuration, (uint8_t *) CONF_IO, 0);
+        uintptr_t io = setting ? strtol((char *) setting->value, NULL, 16) : 0;
+        rc = netif_probe_req(netif->driver->phone, netif->id, irq, (void *) io);
         if (rc != EOK)
                 return rc;
 …
         services_t internet_service;
         if (netif->nil) {
                 setting = measured_strings_find(&netif->configuration, CONF_MTU, 0);
+                setting = measured_strings_find(&netif->configuration, (uint8_t *) CONF_MTU, 0);
                 if (!setting)
                         setting = measured_strings_find(&net_globals.configuration,
                             CONF_MTU, 0);
                 int mtu = setting ? strtol(setting->value, NULL, 10) : 0;
+                            (uint8_t *) CONF_MTU, 0);
+                int mtu = setting ? strtol((char *) setting->value, NULL, 10) : 0;
                 rc = nil_device_req(netif->nil->phone, netif->id, mtu,
 …
+        }
         return netif_start_req_remote(netif->driver->phone, netif->id);
+        return netif_start_req(netif->driver->phone, netif->id);
+}
 …
                 /* Mandatory name */
                 measured_string_t *setting =
                     measured_strings_find(&netif->configuration, CONF_NAME, 0);
+                    measured_strings_find(&netif->configuration, (uint8_t *) CONF_NAME, 0);
                 if (!setting) {
                         fprintf(stderr, "%s: Network interface name is missing\n", NAME);
 …
                 rc = start_device(netif);
                 if (rc != EOK) {
+                        printf("%s: Error starting interface %s (%s)\n", NAME,
+                            netif->name, str_error(rc));
                         measured_strings_destroy(&netif->configuration);
                         netifs_exclude_index(&net_globals.netifs, index);
                         return rc;
+                }
 …
                 printf("%s: Network interface started (name: %s, id: %d, driver: %s, "
                     "nil: %s, il: %s)\n", NAME, netif->name, netif->id,
                     netif->driver->name,  netif->nil ? netif->nil->name : "[none]",
+                    netif->driver->name, netif->nil ? (char *) netif->nil->name : "[none]",
                     netif->il->name);
+        }
 …
 /** Process the networking message.
+ *
  * @param[in] callid        The message identifier.
  * @param[in] call          The message parameters.
+ * @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
 …
  */
 int net_message(ipc_callid_t callid, ipc_call_t *call, ipc_call_t *answer,
     int *answer_count)
+    size_t *answer_count)
+{
         measured_string_t *strings;
         char *data;
+        uint8_t *data;
         int rc;
         *answer_count = 0;
         switch (IPC_GET_METHOD(*call)) {
+        switch (IPC_GET_IMETHOD(*call)) {
         case IPC_M_PHONE_HUNGUP:
                 return EOK;
         case NET_NET_GET_DEVICE_CONF:
                 rc = measured_strings_receive(&strings, &data,
                     IPC_GET_COUNT(call));
+                    IPC_GET_COUNT(*call));
                 if (rc != EOK)
                         return rc;
                 net_get_device_conf_req(0, IPC_GET_DEVICE(call), &strings,
                     IPC_GET_COUNT(call), NULL);
+                net_get_device_conf_req(0, IPC_GET_DEVICE(*call), &strings,
+                    IPC_GET_COUNT(*call), NULL);
                 /* Strings should not contain received data anymore */
                 free(data);
                 rc = measured_strings_reply(strings, IPC_GET_COUNT(call));
+                rc = measured_strings_reply(strings, IPC_GET_COUNT(*call));
                 free(strings);
                 return rc;
         case NET_NET_GET_CONF:
                 rc = measured_strings_receive(&strings, &data,
                     IPC_GET_COUNT(call));
+                    IPC_GET_COUNT(*call));
                 if (rc != EOK)
                         return rc;
                 net_get_conf_req(0, &strings, IPC_GET_COUNT(call), NULL);
+                net_get_conf_req(0, &strings, IPC_GET_COUNT(*call), NULL);
                 /* Strings should not contain received data anymore */
                 free(data);
                 rc = measured_strings_reply(strings, IPC_GET_COUNT(call));
+                rc = measured_strings_reply(strings, IPC_GET_COUNT(*call));
                 free(strings);
                 return rc;
 …
                 /* Clear the answer structure */
                 ipc_call_t answer;
                 int answer_count;
+                size_t answer_count;
                 refresh_answer(&answer, &answer_count);
 …
                 /* End if told to either by the message or the processing result */
                 if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) || (res == EHANGUP))
+                if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) || (res == EHANGUP))
                         return;
 …
 int main(int argc, char *argv[])
+{
+        int rc;
+        rc = net_module_start(net_client_connection);
+        if (rc != EOK) {
+                fprintf(stderr, "%s: net_module_start error %i\n", NAME, rc);
+                return rc;
+        }
+        return EOK;
+        return net_module_start(net_client_connection);
+}

uspace/srv/net/net/net.h

-              rcead2aa
+              r357b5f5
  */
 #define DP8390_FILENAME  "/srv/dp8390"
 #define DP8390_NAME      "dp8390"
+#define NE2000_FILENAME  "/srv/ne2000"
+#define NE2000_NAME      "ne2000"
 #define ETHERNET_FILENAME  "/srv/eth"
 …
         module_t *driver;
         device_id_t id; /**< System-unique network interface identifier. */
         module_t *il;   /**< Serving internet layer module index. */
         char *name;     /**< System-unique network interface name. */
         module_t *nil;  /**< Serving link layer module index. */
+        device_id_t id;  /**< System-unique network interface identifier. */
+        module_t *il;    /**< Serving internet layer module index. */
+        uint8_t *name;   /**< System-unique network interface name. */
+        module_t *nil;   /**< Serving link layer module index. */
 } netif_t;
 …
 } net_globals_t;
+extern int add_configuration(measured_strings_t *, const char *, const char *);
+extern int net_module_message(ipc_callid_t, ipc_call_t *, ipc_call_t *, int *);
+extern int add_configuration(measured_strings_t *, const uint8_t *,
+    const uint8_t *);
+extern int net_module_message(ipc_callid_t, ipc_call_t *, ipc_call_t *, size_t *);
 extern int net_initialize_build(async_client_conn_t);
 extern int net_message(ipc_callid_t, ipc_call_t *, ipc_call_t *, int *);
+extern int net_message(ipc_callid_t, ipc_call_t *, ipc_call_t *, size_t *);
 #endif

uspace/srv/net/net/net_standalone.c

-              rcead2aa
+              r357b5f5
         int rc;
         task_id_t task_id = spawn("/srv/ip");
+        task_id_t task_id = net_spawn((uint8_t *) "/srv/ip");
         if (!task_id)
                 return EINVAL;
         rc = add_module(NULL, &net_globals.modules, IP_NAME,
             IP_FILENAME, SERVICE_IP, task_id, ip_connect_module);
+        rc = add_module(NULL, &net_globals.modules, (uint8_t *) IP_NAME,
+            (uint8_t *) IP_FILENAME, SERVICE_IP, task_id, ip_connect_module);
         if (rc != EOK)
                 return rc;
         if (!spawn("/srv/icmp"))
+        if (!net_spawn((uint8_t *) "/srv/icmp"))
                 return EINVAL;
         if (!spawn("/srv/udp"))
+        if (!net_spawn((uint8_t *) "/srv/udp"))
                 return EINVAL;
         if (!spawn("/srv/tcp"))
+        if (!net_spawn((uint8_t *) "/srv/tcp"))
                 return EINVAL;
 …
  */
 int net_module_message(ipc_callid_t callid, ipc_call_t *call,
     ipc_call_t *answer, int *answer_count)
+    ipc_call_t *answer, size_t *count)
+{
         if (IS_NET_PACKET_MESSAGE(call))
                 return packet_server_message(callid, call, answer, answer_count);
+        if (IS_NET_PACKET_MESSAGE(*call))
+                return packet_server_message(callid, call, answer, count);
         return net_message(callid, call, answer, answer_count);
+        return net_message(callid, call, answer, count);
+}

uspace/srv/net/netif/lo/Makefile

-              rcead2aa
+              r357b5f5
 -include $(CONFIG_MAKEFILE)
-ifeq ($(CONFIG_NETIF_NIL_BUNDLE),y)
-        LIBS += $(USPACE_PREFIX)/srv/net/nil/nildummy/libnildummy.a
-endif
 BINARY = lo

uspace/srv/net/netif/lo/lo.c

-              rcead2aa
+              r357b5f5
 #include <packet_client.h>
 #include <net/device.h>
+#include <nil_interface.h>
+#include <netif_interface.h>
+#include <netif_local.h>
+/** Default hardware address. */
+#define DEFAULT_ADDR            "\0\0\0\0\0\0"
+#include <netif_skel.h>
+#include <nil_remote.h>
 /** Default address length. */
 #define DEFAULT_ADDR_LEN        (sizeof(DEFAULT_ADDR) / sizeof(char))
+#define DEFAULT_ADDR_LEN  6
 /** Loopback module name. */
 #define NAME  "lo"
+/** Network interface global data. */
 netif_globals_t netif_globals;
+static uint8_t default_addr[DEFAULT_ADDR_LEN] =
+    {0, 0, 0, 0, 0, 0};
 int netif_specific_message(ipc_callid_t callid, ipc_call_t *call,
     ipc_call_t *answer, int *answer_count)
+    ipc_call_t *answer, size_t *count)
+{
         return ENOTSUP;
 …
         if (!address)
                 return EBADMEM;
         address->value = str_dup(DEFAULT_ADDR);
+        address->value = default_addr;
         address->length = DEFAULT_ADDR_LEN;
         return EOK;
+}
 …
 int netif_get_device_stats(device_id_t device_id, device_stats_t *stats)
+{
-        netif_device_t *device;
-        int rc;
         if (!stats)
                 return EBADMEM;
+        rc = find_device(device_id, &device);
+        netif_device_t *device;
+        int rc = find_device(device_id, &device);
         if (rc != EOK)
                 return rc;
         memcpy(stats, (device_stats_t *) device->specific,
             sizeof(device_stats_t));
+        return EOK;
+}
+/** Changes the loopback state.
+ *
+ * @param[in] device    The device structure.
+ * @param[in] state     The new device state.
+ * @return              The new state if changed.
+ * @return              EOK otherwise.
+ */
+static int change_state_message(netif_device_t *device, device_state_t state)
+        return EOK;
+}
+/** Change the loopback state.
+ *
+ * @param[in] device The device structure.
+ * @param[in] state  The new device state.
+ *
+ * @return New state if changed.
+ * @return EOK otherwise.
+ *
+ */
+static void change_state_message(netif_device_t *device, device_state_t state)
+{
         if (device->state != state) {
                 device->state = state;
+                printf("%s: State changed to %s\n", NAME,
+                    (state == NETIF_ACTIVE) ? "active" : "stopped");
+                const char *desc;
+                switch (state) {
+                case NETIF_ACTIVE:
+                        desc = "active";
+                        break;
+                case NETIF_STOPPED:
+                        desc = "stopped";
+                        break;
+                default:
+                        desc = "unknown";
+                }
+                return state;
+        }
+        return EOK;
+}
+/** Creates and returns the loopback network interface structure.
+ *
+ * @param[in] device_id The new devce identifier.
+ * @param[out] device   The device structure.
+ * @return              EOK on success.
+ * @return              EXDEV if one loopback network interface already exists.
+ * @return              ENOMEM if there is not enough memory left.
+ */
+static int create(device_id_t device_id, netif_device_t **device)
+{
+        int index;
+                printf("%s: State changed to %s\n", NAME, desc);
+        }
+}
+/** Create and return the loopback network interface structure.
+ *
+ * @param[in]  device_id New devce identifier.
+ * @param[out] device    Device structure.
+ *
+ * @return EOK on success.
+ * @return EXDEV if one loopback network interface already exists.
+ * @return ENOMEM if there is not enough memory left.
+ *
+ */
+static int lo_create(device_id_t device_id, netif_device_t **device)
+{
         if (netif_device_map_count(&netif_globals.device_map) > 0)
                 return EXDEV;
         *device = (netif_device_t *) malloc(sizeof(netif_device_t));
         if (!*device)
                 return ENOMEM;
         (*device)->specific = (device_stats_t *) malloc(sizeof(device_stats_t));
         if (!(*device)->specific) {
 …
                 return ENOMEM;
+        }
         null_device_stats((device_stats_t *) (*device)->specific);
         (*device)->device_id = device_id;
         (*device)->nil_phone = -1;
         (*device)->state = NETIF_STOPPED;
         index = netif_device_map_add(&netif_globals.device_map,
+        int index = netif_device_map_add(&netif_globals.device_map,
             (*device)->device_id, *device);
         if (index < 0) {
                 free(*device);
 …
 int netif_initialize(void)
+{
         ipcarg_t phonehash;
+        return REGISTER_ME(SERVICE_LO, &phonehash);
+}
+int netif_probe_message(device_id_t device_id, int irq, uintptr_t io)
+{
+        sysarg_t phonehash;
+        return ipc_connect_to_me(PHONE_NS, SERVICE_LO, 0, 0, &phonehash);
+}
+int netif_probe_message(device_id_t device_id, int irq, void *io)
+{
+        /* Create a new device */
         netif_device_t *device;
+        int rc;
+        /* Create a new device */
+        rc = create(device_id, &device);
+        int rc = lo_create(device_id, &device);
         if (rc != EOK)
                 return rc;
+        /* Print the settings */
         printf("%s: Device created (id: %d)\n", NAME, device->device_id);
         return EOK;
+}
 …
+{
         netif_device_t *device;
+        size_t length;
+        packet_t *next;
+        int phone;
+        int rc;
+        rc = find_device(device_id, &device);
+        int rc = find_device(device_id, &device);
         if (rc != EOK)
                 return EOK;
         if (device->state != NETIF_ACTIVE) {
                 netif_pq_release(packet_get_id(packet));
                 return EFORWARD;
+        }
         next = packet;
+        packet_t *next = packet;
         do {
                 ((device_stats_t *) device->specific)->send_packets++;
                 ((device_stats_t *) device->specific)->receive_packets++;
                 length = packet_get_data_length(next);
+                size_t length = packet_get_data_length(next);
                 ((device_stats_t *) device->specific)->send_bytes += length;
                 ((device_stats_t *) device->specific)->receive_bytes += length;
                 next = pq_next(next);
         } while(next);
         phone = device->nil_phone;
+        } while (next);
+        int phone = device->nil_phone;
         fibril_rwlock_write_unlock(&netif_globals.lock);
         nil_received_msg(phone, device_id, packet, sender);
         fibril_rwlock_write_lock(&netif_globals.lock);
         return EOK;
+}
 …
 int netif_start_message(netif_device_t *device)
+{
+        return change_state_message(device, NETIF_ACTIVE);
+        change_state_message(device, NETIF_ACTIVE);
+        return device->state;
+}
 int netif_stop_message(netif_device_t *device)
+{
+        return change_state_message(device, NETIF_STOPPED);
+}
+/** Default thread for new connections.
+ *
+ * @param[in] iid       The initial message identifier.
+ * @param[in] icall     The initial message call structure.
+ */
+static void netif_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 = netif_module_message(NAME, callid, &call, &answer,
+                    &answer_count);
+                /*
+                 * End if told to either by the message or the processing
+                 * result.
+                 */
+                if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
+                    (res == EHANGUP))
+                        return;
+                /* Answer the message */
+                answer_call(callid, res, &answer, answer_count);
+        }
+        change_state_message(device, NETIF_STOPPED);
+        return device->state;
+}
 int main(int argc, char *argv[])
+{
-        int rc;
         /* Start the module */
+        rc = netif_module_start(netif_client_connection);
+        return rc;
+        return netif_module_start();
+}

uspace/srv/net/nil/eth/Makefile

-              rcead2aa
+              r357b5f5
 -include $(CONFIG_MAKEFILE)
+ifeq ($(CONFIG_NETIF_NIL_BUNDLE),y)
+        LIBRARY = libeth
+else
+        BINARY = eth
+endif
+BINARY = eth
 SOURCES = \
+        eth.c \
+        eth_module.c
+        eth.c
 include $(USPACE_PREFIX)/Makefile.common

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

-              rcead2aa
+              r357b5f5
 #include <ipc/ipc.h>
+#include <ipc/nil.h>
 #include <ipc/net.h>
 #include <ipc/services.h>
 …
 #include <protocol_map.h>
 #include <net/device.h>
 #include <netif_interface.h>
+#include <netif_remote.h>
 #include <net_interface.h>
+#include <nil_interface.h>
+#include <il_interface.h>
+#include <il_remote.h>
 #include <adt/measured_strings.h>
 #include <packet_client.h>
 #include <packet_remote.h>
 #include <nil_local.h>
+#include <nil_skel.h>
 #include "eth.h"
-#include "eth_header.h"
 /** The module name. */
 …
 #define ETH_PREFIX \
         (sizeof(eth_header_t) + sizeof(eth_header_lsap_t) + \
         sizeof(eth_header_snap_t))
+            sizeof(eth_header_snap_t))
 /** Reserved packet suffix length. */
+#define ETH_SUFFIX \
+        sizeof(eth_fcs_t)
+#define ETH_SUFFIX  (sizeof(eth_fcs_t))
 /** Maximum packet content length. */
 #define ETH_MAX_CONTENT 1500u
+#define ETH_MAX_CONTENT  1500u
 /** Minimum packet content length. */
 #define ETH_MIN_CONTENT 46u
+#define ETH_MIN_CONTENT  46u
 /** Maximum tagged packet content length. */
 #define ETH_MAX_TAGGED_CONTENT(flags) \
         (ETH_MAX_CONTENT - \
         ((IS_8023_2_LSAP(flags) || IS_8023_2_SNAP(flags)) ? \
         sizeof(eth_header_lsap_t) : 0) - \
         (IS_8023_2_SNAP(flags) ? sizeof(eth_header_snap_t) : 0))
+            ((IS_8023_2_LSAP(flags) || IS_8023_2_SNAP(flags)) ? \
+            sizeof(eth_header_lsap_t) : 0) - \
+            (IS_8023_2_SNAP(flags) ? sizeof(eth_header_snap_t) : 0))
 /** Minimum tagged packet content length. */
 #define ETH_MIN_TAGGED_CONTENT(flags) \
         (ETH_MIN_CONTENT - \
         ((IS_8023_2_LSAP(flags) || IS_8023_2_SNAP(flags)) ? \
         sizeof(eth_header_lsap_t) : 0) - \
         (IS_8023_2_SNAP(flags) ? sizeof(eth_header_snap_t) : 0))
+            ((IS_8023_2_LSAP(flags) || IS_8023_2_SNAP(flags)) ? \
+            sizeof(eth_header_lsap_t) : 0) - \
+            (IS_8023_2_SNAP(flags) ? sizeof(eth_header_snap_t) : 0))
 /** Dummy flag shift value. */
 #define ETH_DUMMY_SHIFT 0
+#define ETH_DUMMY_SHIFT  0
 /** Mode flag shift value. */
 #define ETH_MODE_SHIFT  1
+#define ETH_MODE_SHIFT  1
 /** Dummy device flag.
  * Preamble and FCS are mandatory part of the packets.
  */
 #define ETH_DUMMY               (1 << ETH_DUMMY_SHIFT)
+#define ETH_DUMMY  (1 << ETH_DUMMY_SHIFT)
 /** Returns the dummy flag.
  * @see ETH_DUMMY
  */
 #define IS_DUMMY(flags)         ((flags) & ETH_DUMMY)
+#define IS_DUMMY(flags)  ((flags) & ETH_DUMMY)
 /** Device mode flags.
 …
  * @see ETH_8023_2_SNAP
  */
 #define ETH_MODE_MASK           (3 << ETH_MODE_SHIFT)
+#define ETH_MODE_MASK  (3 << ETH_MODE_SHIFT)
 /** DIX Ethernet mode flag. */
 #define ETH_DIX                 (1 << ETH_MODE_SHIFT)
 /** Returns whether the DIX Ethernet mode flag is set.
+ *
  * @param[in] flags     The ethernet flags.
+#define ETH_DIX  (1 << ETH_MODE_SHIFT)
+/** Return whether the DIX Ethernet mode flag is set.
+ *
+ * @param[in] flags Ethernet flags.
  * @see ETH_DIX
+ */
+#define IS_DIX(flags)           (((flags) & ETH_MODE_MASK) == ETH_DIX)
+ *
+ */
+#define IS_DIX(flags)  (((flags) & ETH_MODE_MASK) == ETH_DIX)
 /** 802.3 + 802.2 + LSAP mode flag. */
 #define ETH_8023_2_LSAP         (2 << ETH_MODE_SHIFT)
 /** Returns whether the 802.3 + 802.2 + LSAP mode flag is set.
+ *
  * @param[in] flags     The ethernet flags.
+#define ETH_8023_2_LSAP  (2 << ETH_MODE_SHIFT)
+/** Return whether the 802.3 + 802.2 + LSAP mode flag is set.
+ *
+ * @param[in] flags Ethernet flags.
  * @see ETH_8023_2_LSAP
+ */
+#define IS_8023_2_LSAP(flags)   (((flags) & ETH_MODE_MASK) == ETH_8023_2_LSAP)
+ *
+ */
+#define IS_8023_2_LSAP(flags)  (((flags) & ETH_MODE_MASK) == ETH_8023_2_LSAP)
 /** 802.3 + 802.2 + LSAP + SNAP mode flag. */
 #define ETH_8023_2_SNAP         (3 << ETH_MODE_SHIFT)
 /** Returns whether the 802.3 + 802.2 + LSAP + SNAP mode flag is set.
+ *
  * @param[in] flags     The ethernet flags.
+#define ETH_8023_2_SNAP  (3 << ETH_MODE_SHIFT)
+/** Return whether the 802.3 + 802.2 + LSAP + SNAP mode flag is set.
+ *
+ * @param[in] flags Ethernet flags.
  * @see ETH_8023_2_SNAP
+ */
+#define IS_8023_2_SNAP(flags)   (((flags) & ETH_MODE_MASK) == ETH_8023_2_SNAP)
+ *
+ */
+#define IS_8023_2_SNAP(flags)  (((flags) & ETH_MODE_MASK) == ETH_8023_2_SNAP)
 /** Type definition of the ethernet address type.
 …
         eth_globals.broadcast_addr =
+            measured_string_create_bulk("\xFF\xFF\xFF\xFF\xFF\xFF",
+            CONVERT_SIZE(uint8_t, char, ETH_ADDR));
+            measured_string_create_bulk((uint8_t *) "\xFF\xFF\xFF\xFF\xFF\xFF", ETH_ADDR);
         if (!eth_globals.broadcast_addr) {
                 rc = ENOMEM;
 …
         while (true) {
                 switch (IPC_GET_METHOD(*icall)) {
+                switch (IPC_GET_IMETHOD(*icall)) {
                 case NET_NIL_DEVICE_STATE:
                         nil_device_state_msg_local(0, IPC_GET_DEVICE(icall),
                             IPC_GET_STATE(icall));
+                        nil_device_state_msg_local(0, IPC_GET_DEVICE(*icall),
+                            IPC_GET_STATE(*icall));
                         ipc_answer_0(iid, EOK);
                         break;
                 case NET_NIL_RECEIVED:
                         rc = packet_translate_remote(eth_globals.net_phone,
                             &packet, IPC_GET_PACKET(icall));
                         if (rc == EOK) {
+                            &packet, IPC_GET_PACKET(*icall));
+                        if (rc == EOK)
                                 rc = nil_received_msg_local(0,
                                     IPC_GET_DEVICE(icall), packet, 0);
+                        }
                         ipc_answer_0(iid, (ipcarg_t) rc);
+                                    IPC_GET_DEVICE(*icall), packet, 0);
+                        ipc_answer_0(iid, (sysarg_t) rc);
                         break;
                 default:
                         ipc_answer_0(iid, (ipcarg_t) ENOTSUP);
+                        ipc_answer_0(iid, (sysarg_t) ENOTSUP);
+                }
 …
         measured_string_t names[2] = {
+                {
                         (char *) "ETH_MODE",
+                        (uint8_t *) "ETH_MODE",
                 },
+                {
                         (char *) "ETH_DUMMY",
+                        (uint8_t *) "ETH_DUMMY",
+                }
 …
         measured_string_t *configuration;
         size_t count = sizeof(names) / sizeof(measured_string_t);
         char *data;
+        uint8_t *data;
         eth_proto_t *proto;
         int rc;
 …
         if (configuration) {
                 if (!str_lcmp(configuration[0].value, "DIX",
+                if (!str_lcmp((char *) configuration[0].value, "DIX",
                     configuration[0].length)) {
                         device->flags |= ETH_DIX;
                 } else if(!str_lcmp(configuration[0].value, "8023_2_LSAP",
+                } else if(!str_lcmp((char *) configuration[0].value, "8023_2_LSAP",
                     configuration[0].length)) {
                         device->flags |= ETH_8023_2_LSAP;
 …
         printf("%s: Device registered (id: %d, service: %d: mtu: %zu, "
             "mac: %x:%x:%x:%x:%x:%x, flags: 0x%x)\n",
+            "mac: %02x:%02x:%02x:%02x:%02x:%02x, flags: 0x%x)\n",
             NAME, device->device_id, device->service, device->mtu,
             device->addr_data[0], device->addr_data[1],
 …
+}
 int nil_message_standalone(const char *name, ipc_callid_t callid,
     ipc_call_t *call, ipc_call_t *answer, int *answer_count)
+int nil_module_message(ipc_callid_t callid, ipc_call_t *call,
+    ipc_call_t *answer, size_t *answer_count)
+{
         measured_string_t *address;
 …
         *answer_count = 0;
         switch (IPC_GET_METHOD(*call)) {
+        switch (IPC_GET_IMETHOD(*call)) {
         case IPC_M_PHONE_HUNGUP:
                 return EOK;
         case NET_NIL_DEVICE:
                 return eth_device_message(IPC_GET_DEVICE(call),
                     IPC_GET_SERVICE(call), IPC_GET_MTU(call));
+                return eth_device_message(IPC_GET_DEVICE(*call),
+                    IPC_GET_SERVICE(*call), IPC_GET_MTU(*call));
         case NET_NIL_SEND:
                 rc = packet_translate_remote(eth_globals.net_phone, &packet,
                     IPC_GET_PACKET(call));
+                    IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
                 return eth_send_message(IPC_GET_DEVICE(call), packet,
                     IPC_GET_SERVICE(call));
+                return eth_send_message(IPC_GET_DEVICE(*call), packet,
+                    IPC_GET_SERVICE(*call));
         case NET_NIL_PACKET_SPACE:
                 rc = eth_packet_space_message(IPC_GET_DEVICE(call), &addrlen,
+                rc = eth_packet_space_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_NIL_ADDR:
                 rc = eth_addr_message(IPC_GET_DEVICE(call), ETH_LOCAL_ADDR,
+                rc = eth_addr_message(IPC_GET_DEVICE(*call), ETH_LOCAL_ADDR,
                     &address);
                 if (rc != EOK)
 …
                 return measured_strings_reply(address, 1);
         case NET_NIL_BROADCAST_ADDR:
                 rc = eth_addr_message(IPC_GET_DEVICE(call), ETH_BROADCAST_ADDR,
+                rc = eth_addr_message(IPC_GET_DEVICE(*call), ETH_BROADCAST_ADDR,
                     &address);
                 if (rc != EOK)
 …
                 return measured_strings_reply(address, 1);
         case IPC_M_CONNECT_TO_ME:
                 return eth_register_message(NIL_GET_PROTO(call),
                     IPC_GET_PHONE(call));
+                return eth_register_message(NIL_GET_PROTO(*call),
+                    IPC_GET_PHONE(*call));
+        }
 …
+}
-/** Default thread for new connections.
+ *
- * @param[in] iid       The initial message identifier.
- * @param[in] icall     The initial message call structure.
- */
-static void nil_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 = nil_module_message_standalone(NAME, callid, &call,
-                    &answer, &answer_count);
-                /*
-                 * End if told to either by the message or the processing
-                 * result.
-                 */
-                if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
-                    (res == EHANGUP))
-                        return;
-                /* Answer the message */
-                answer_call(callid, res, &answer, answer_count);
+        }
+}
 int main(int argc, char *argv[])
+{
-        int rc;
         /* Start the module */
+        rc = nil_module_start_standalone(nil_client_connection);
+        return rc;
+        return nil_module_start(SERVICE_ETHERNET);
+}

uspace/srv/net/nil/eth/eth.h

-              rcead2aa
+              r357b5f5
 #include <adt/measured_strings.h>
+/** Ethernet address length. */
+#define ETH_ADDR  6
+/** Ethernet header preamble value. */
+#define ETH_PREAMBLE  0x55
+/** Ethernet header start of frame value. */
+#define ETH_SFD  0xD5
+/** IEEE 802.2 unordered information control field. */
+#define IEEE_8023_2_UI  0x03
+/** Type definition of the Ethernet header IEEE 802.3 + 802.2 + SNAP extensions.
+ * @see eth_header_snap
+ */
+typedef struct eth_header_snap eth_header_snap_t;
+/** Type definition of the Ethernet header IEEE 802.3 + 802.2 + SNAP extensions.
+ * @see eth_header_lsap
+ */
+typedef struct eth_header_lsap eth_header_lsap_t;
+/** Type definition of the Ethernet header LSAP extension.
+ * @see eth_ieee_lsap
+ */
+typedef struct eth_ieee_lsap eth_ieee_lsap_t;
+/** Type definition of the Ethernet header SNAP extension.
+ * @see eth_snap
+ */
+typedef struct eth_snap eth_snap_t;
+/** Type definition of the Ethernet header preamble.
+ * @see preamble
+ */
+typedef struct eth_preamble eth_preamble_t;
+/** Type definition of the Ethernet header.
+ * @see eth_header
+ */
+typedef struct eth_header eth_header_t;
+/** Ethernet header Link Service Access Point extension. */
+struct eth_ieee_lsap {
+        /**
+         * Destination Service Access Point identifier.
+         * The possible values are assigned by an IEEE committee.
+         */
+        uint8_t dsap;
+        /**
+         * Source Service Access Point identifier.
+         * The possible values are assigned by an IEEE committee.
+         */
+        uint8_t ssap;
+        /**
+         * Control parameter.
+         * The possible values are assigned by an IEEE committee.
+         */
+        uint8_t ctrl;
+} __attribute__ ((packed));
+/** Ethernet header SNAP extension. */
+struct eth_snap {
+        /** Protocol identifier or organization code. */
+        uint8_t protocol[3];
+        /**
+         * Ethernet protocol identifier in the network byte order (big endian).
+         * @see ethernet_protocols.h
+         */
+        uint16_t ethertype;
+} __attribute__ ((packed));
+/** Ethernet header preamble.
+ *
+ * Used for dummy devices.
+ */
+struct eth_preamble {
+        /**
+         * Controlling preamble used for the frame transmission synchronization.
+         * All should be set to ETH_PREAMBLE.
+         */
+        uint8_t preamble[7];
+        /**
+         * Start of Frame Delimiter used for the frame transmission
+         * synchronization.
+         * Should be set to ETH_SFD.
+         */
+        uint8_t sfd;
+} __attribute__ ((packed));
+/** Ethernet header. */
+struct eth_header {
+        /** Destination host Ethernet address (MAC address). */
+        uint8_t destination_address[ETH_ADDR];
+        /** Source host Ethernet address (MAC address). */
+        uint8_t source_address[ETH_ADDR];
+        /**
+         * Ethernet protocol identifier in the network byte order (big endian).
+         * @see ethernet_protocols.h
+         */
+        uint16_t ethertype;
+} __attribute__ ((packed));
+/** Ethernet header IEEE 802.3 + 802.2 extension. */
+struct eth_header_lsap {
+        /** Ethernet header. */
+        eth_header_t header;
+        /**
+         * LSAP extension.
+         * If DSAP and SSAP are set to ETH_LSAP_SNAP the SNAP extension is being
+         * used.
+         * If DSAP and SSAP fields are equal to ETH_RAW the raw Ethernet packet
+         * without any extensions is being used and the frame content starts
+         * rigth after the two fields.
+         */
+        eth_ieee_lsap_t lsap;
+} __attribute__ ((packed));
+/** Ethernet header IEEE 802.3 + 802.2 + SNAP extensions. */
+struct eth_header_snap {
+        /** Ethernet header. */
+        eth_header_t header;
+        /**
+         * LSAP extension.
+         * If DSAP and SSAP are set to ETH_LSAP_SNAP the SNAP extension is being
+         * used.
+         * If DSAP and SSAP fields are equal to ETH_RAW the raw Ethernet packet
+         * without any extensions is being used and the frame content starts
+         * rigth after the two fields.
+         */
+        eth_ieee_lsap_t lsap;
+        /** SNAP extension. */
+        eth_snap_t snap;
+} __attribute__ ((packed));
+/** Ethernet Frame Check Sequence. */
+typedef uint32_t eth_fcs_t;
 /** Type definition of the Ethernet global data.
  * @see eth_globals
 …
         /** Actual device hardware address. */
         measured_string_t *addr;
         /** Actual device hardware address data. */
         char *addr_data;
+        uint8_t *addr_data;
 };

uspace/srv/net/nil/nildummy/Makefile

-              rcead2aa
+              r357b5f5
 -include $(CONFIG_MAKEFILE)
+ifeq ($(CONFIG_NETIF_NIL_BUNDLE),y)
+        LIBRARY = libnildummy
+else
+        BINARY = nildummy
+endif
+BINARY = nildummy
 SOURCES = \
+        nildummy.c \
+        nildummy_module.c
+        nildummy.c
 include $(USPACE_PREFIX)/Makefile.common

uspace/srv/net/nil/nildummy/nildummy.c

-              rcead2aa
+              r357b5f5
 #include <str.h>
 #include <ipc/ipc.h>
+#include <ipc/nil.h>
 #include <ipc/net.h>
 #include <ipc/services.h>
 …
 #include <net/modules.h>
 #include <net/device.h>
+#include <netif_interface.h>
+#include <nil_interface.h>
+#include <il_interface.h>
+#include <il_remote.h>
 #include <adt/measured_strings.h>
 #include <net/packet.h>
 #include <packet_remote.h>
+#include <nil_local.h>
+#include <netif_remote.h>
+#include <nil_skel.h>
 #include "nildummy.h"
 …
 int nil_initialize(int net_phone)
+{
-        int rc;
         fibril_rwlock_initialize(&nildummy_globals.devices_lock);
         fibril_rwlock_initialize(&nildummy_globals.protos_lock);
 …
         nildummy_globals.net_phone = net_phone;
         nildummy_globals.proto.phone = 0;
         rc = nildummy_devices_initialize(&nildummy_globals.devices);
+        int rc = nildummy_devices_initialize(&nildummy_globals.devices);
         fibril_rwlock_write_unlock(&nildummy_globals.protos_lock);
 …
+}
 /** Process IPC messages from the registered device driver modules in an
  * infinite loop.
+ *
  * @param[in] iid       The message identifier.
  * @param[in,out]       icall The message parameters.
+/** Process IPC messages from the registered device driver modules
+ *
+ * @param[in]     iid   Message identifier.
+ * @param[in,out] icall Message parameters.
+ *
  */
 static void nildummy_receiver(ipc_callid_t iid, ipc_call_t *icall)
 …
         packet_t *packet;
         int rc;
         while (true) {
                 switch (IPC_GET_METHOD(*icall)) {
+                switch (IPC_GET_IMETHOD(*icall)) {
                 case NET_NIL_DEVICE_STATE:
                         rc = nil_device_state_msg_local(0,
                             IPC_GET_DEVICE(icall), IPC_GET_STATE(icall));
                         ipc_answer_0(iid, (ipcarg_t) rc);
+                            IPC_GET_DEVICE(*icall), IPC_GET_STATE(*icall));
+                        ipc_answer_0(iid, (sysarg_t) rc);
                         break;
                 case NET_NIL_RECEIVED:
                         rc = packet_translate_remote(nildummy_globals.net_phone,
                             &packet, IPC_GET_PACKET(icall));
                         if (rc == EOK) {
+                            &packet, IPC_GET_PACKET(*icall));
+                        if (rc == EOK)
                                 rc = nil_received_msg_local(0,
                                     IPC_GET_DEVICE(icall), packet, 0);
+                        }
                         ipc_answer_0(iid, (ipcarg_t) rc);
+                                    IPC_GET_DEVICE(*icall), packet, 0);
+                        ipc_answer_0(iid, (sysarg_t) rc);
                         break;
                 default:
                         ipc_answer_0(iid, (ipcarg_t) ENOTSUP);
+                        ipc_answer_0(iid, (sysarg_t) ENOTSUP);
+                }
 …
  * Determine the device local hardware address.
+ *
+ * @param[in] device_id The new device identifier.
+ * @param[in] service   The device driver service.
+ * @param[in] mtu       The device maximum transmission unit.
+ * @return              EOK on success.
+ * @return              EEXIST if the device with the different service exists.
+ * @return              ENOMEM if there is not enough memory left.
+ * @return              Other error codes as defined for the
+ *                      netif_bind_service() function.
+ * @return              Other error codes as defined for the
+ *                      netif_get_addr_req() function.
+ * @param[in] device_id New device identifier.
+ * @param[in] service   Device driver service.
+ * @param[in] mtu       Device maximum transmission unit.
+ *
+ * @return EOK on success.
+ * @return EEXIST if the device with the different service exists.
+ * @return ENOMEM if there is not enough memory left.
+ * @return Other error codes as defined for the
+ *         netif_bind_service() function.
+ * @return Other error codes as defined for the
+ *         netif_get_addr_req() function.
+ *
  */
 static int nildummy_device_message(device_id_t device_id, services_t service,
     size_t mtu)
+{
-        nildummy_device_t *device;
-        int index;
-        int rc;
         fibril_rwlock_write_lock(&nildummy_globals.devices_lock);
         /* An existing device? */
+        device = nildummy_devices_find(&nildummy_globals.devices, device_id);
+        nildummy_device_t *device =
+            nildummy_devices_find(&nildummy_globals.devices, device_id);
         if (device) {
                 if (device->service != service) {
 …
         /* Get hardware address */
         rc = netif_get_addr_req(device->phone, device->device_id, &device->addr,
             &device->addr_data);
+        int rc = netif_get_addr_req(device->phone, device->device_id,
+            &device->addr, &device->addr_data);
         if (rc != EOK) {
                 fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
 …
         /* Add to the cache */
         index = nildummy_devices_add(&nildummy_globals.devices,
+        int index = nildummy_devices_add(&nildummy_globals.devices,
             device->device_id, device);
         if (index < 0) {
 …
 /** Return the device hardware address.
+ *
+ * @param[in] device_id The device identifier.
+ * @param[out] address  The device hardware address.
+ * @return               EOK on success.
+ * @return              EBADMEM if the address parameter is NULL.
+ * @return              ENOENT if there no such device.
+ * @param[in]  device_id Device identifier.
+ * @param[out] address   Device hardware address.
+ *
+ * @return EOK on success.
+ * @return EBADMEM if the address parameter is NULL.
+ * @return ENOENT if there no such device.
+ *
  */
 …
     measured_string_t **address)
+{
-        nildummy_device_t *device;
         if (!address)
                 return EBADMEM;
         fibril_rwlock_read_lock(&nildummy_globals.devices_lock);
+        device = nildummy_devices_find(&nildummy_globals.devices, device_id);
+        nildummy_device_t *device =
+            nildummy_devices_find(&nildummy_globals.devices, device_id);
         if (!device) {
                 fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
                 return ENOENT;
+        }
         *address = device->addr;
         fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
 …
 /** Return the device packet dimensions for sending.
+ *
+ * @param[in] device_id The device identifier.
+ * @param[out] addr_len The minimum reserved address length.
+ * @param[out] prefix   The minimum reserved prefix size.
+ * @param[out] content  The maximum content size.
+ * @param[out] suffix   The minimum reserved suffix size.
+ * @return              EOK on success.
+ * @return              EBADMEM if either one of the parameters is NULL.
+ * @return              ENOENT if there is no such device.
+ * @param[in]  device_id Device identifier.
+ * @param[out] addr_len  Minimum reserved address length.
+ * @param[out] prefix    Minimum reserved prefix size.
+ * @param[out] content   Maximum content size.
+ * @param[out] suffix    Minimum reserved suffix size.
+ *
+ * @return EOK on success.
+ * @return EBADMEM if either one of the parameters is NULL.
+ * @return ENOENT if there is no such device.
+ *
  */
 …
     size_t *prefix, size_t *content, size_t *suffix)
+{
+        nildummy_device_t *device;
+        if (!addr_len || !prefix || !content || !suffix)
+        if ((!addr_len) || (!prefix) || (!content) || (!suffix))
                 return EBADMEM;
         fibril_rwlock_read_lock(&nildummy_globals.devices_lock);
+        device = nildummy_devices_find(&nildummy_globals.devices, device_id);
+        nildummy_device_t *device =
+            nildummy_devices_find(&nildummy_globals.devices, device_id);
         if (!device) {
                 fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
                 return ENOENT;
+        }
         *content = device->mtu;
         fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
 …
     packet_t *packet, services_t target)
+{
-        packet_t *next;
         fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
         if (nildummy_globals.proto.phone) {
                 do {
                         next = pq_detach(packet);
+                        packet_t *next = pq_detach(packet);
                         il_received_msg(nildummy_globals.proto.phone, device_id,
                             packet, nildummy_globals.proto.service);
                         packet = next;
+                } while(packet);
+        }
+                } while (packet);
+        }
         fibril_rwlock_read_unlock(&nildummy_globals.protos_lock);
 …
  * Pass received packets for this service.
+ *
+ * @param[in] service   The module service.
+ * @param[in] phone     The service phone.
+ * @return              EOK on success.
+ * @return              ENOENT if the service is not known.
+ * @return              ENOMEM if there is not enough memory left.
+ * @param[in] service Module service.
+ * @param[in] phone   Service phone.
+ *
+ * @return EOK on success.
+ * @return ENOENT if the service is not known.
+ * @return ENOMEM if there is not enough memory left.
+ *
  */
 static int nildummy_register_message(services_t service, int phone)
 …
 /** Send the packet queue.
+ *
+ * @param[in] device_id The device identifier.
+ * @param[in] packet    The packet queue.
+ * @param[in] sender    The sending module service.
+ * @return              EOK on success.
+ * @return              ENOENT if there no such device.
+ * @return              EINVAL if the service parameter is not known.
+ * @param[in] device_id Device identifier.
+ * @param[in] packet    Packet queue.
+ * @param[in] sender    Sending module service.
+ *
+ * @return EOK on success.
+ * @return ENOENT if there no such device.
+ * @return EINVAL if the service parameter is not known.
+ *
  */
 static int nildummy_send_message(device_id_t device_id, packet_t *packet,
     services_t sender)
+{
-        nildummy_device_t *device;
         fibril_rwlock_read_lock(&nildummy_globals.devices_lock);
+        device = nildummy_devices_find(&nildummy_globals.devices, device_id);
+        nildummy_device_t *device =
+            nildummy_devices_find(&nildummy_globals.devices, device_id);
         if (!device) {
                 fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
                 return ENOENT;
+        }
         /* Send packet queue */
         if (packet)
                 netif_send_msg(device->phone, device_id, packet,
                     SERVICE_NILDUMMY);
         fibril_rwlock_read_unlock(&nildummy_globals.devices_lock);
+        return EOK;
+}
+int nil_message_standalone(const char *name, ipc_callid_t callid,
+    ipc_call_t *call, ipc_call_t *answer, int *answer_count)
+        return EOK;
+}
+int nil_module_message(ipc_callid_t callid, ipc_call_t *call,
+    ipc_call_t *answer, size_t *answer_count)
+{
         measured_string_t *address;
 …
         *answer_count = 0;
         switch (IPC_GET_METHOD(*call)) {
+        switch (IPC_GET_IMETHOD(*call)) {
         case IPC_M_PHONE_HUNGUP:
                 return EOK;
         case NET_NIL_DEVICE:
                 return nildummy_device_message(IPC_GET_DEVICE(call),
                     IPC_GET_SERVICE(call), IPC_GET_MTU(call));
+                return nildummy_device_message(IPC_GET_DEVICE(*call),
+                    IPC_GET_SERVICE(*call), IPC_GET_MTU(*call));
         case NET_NIL_SEND:
                 rc = packet_translate_remote(nildummy_globals.net_phone,
                     &packet, IPC_GET_PACKET(call));
+                    &packet, IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
                 return nildummy_send_message(IPC_GET_DEVICE(call), packet,
                     IPC_GET_SERVICE(call));
+                return nildummy_send_message(IPC_GET_DEVICE(*call), packet,
+                    IPC_GET_SERVICE(*call));
         case NET_NIL_PACKET_SPACE:
                 rc = nildummy_packet_space_message(IPC_GET_DEVICE(call),
+                rc = nildummy_packet_space_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_NIL_ADDR:
                 rc = nildummy_addr_message(IPC_GET_DEVICE(call), &address);
+                rc = nildummy_addr_message(IPC_GET_DEVICE(*call), &address);
                 if (rc != EOK)
                         return rc;
 …
         case NET_NIL_BROADCAST_ADDR:
                 rc = nildummy_addr_message(IPC_GET_DEVICE(call), &address);
+                rc = nildummy_addr_message(IPC_GET_DEVICE(*call), &address);
                 if (rc != EOK)
                         return rc;
 …
         case IPC_M_CONNECT_TO_ME:
                 return nildummy_register_message(NIL_GET_PROTO(call),
                     IPC_GET_PHONE(call));
+                return nildummy_register_message(NIL_GET_PROTO(*call),
+                    IPC_GET_PHONE(*call));
+        }
 …
+}
-/** Default thread for new connections.
+ *
- * @param[in] iid       The initial message identifier.
- * @param[in] icall     The initial message call structure.
- */
-static void nil_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 = nil_module_message_standalone(NAME, callid, &call,
-                    &answer, &answer_count);
-                /*
-                 * End if told to either by the message or the processing
-                 * result.
-                 */
-                if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
-                    (res == EHANGUP))
-                        return;
-                /* Answer the message */
-                answer_call(callid, res, &answer, answer_count);
+        }
+}
 int main(int argc, char *argv[])
+{
-        int rc;
         /* Start the module */
+        rc = nil_module_start_standalone(nil_client_connection);
+        return rc;
+        return nil_module_start(SERVICE_NILDUMMY);
+}

uspace/srv/net/nil/nildummy/nildummy.h

-              rcead2aa
+              r357b5f5
 /** Type definition of the dummy nil global data.
+ *
  * @see nildummy_globals
+ *
  */
 typedef struct nildummy_globals nildummy_globals_t;
 /** Type definition of the dummy nil device specific data.
+ *
  * @see nildummy_device
+ *
  */
 typedef struct nildummy_device nildummy_device_t;
 /** Type definition of the dummy nil protocol specific data.
+ *
  * @see nildummy_proto
+ *
  */
 typedef struct nildummy_proto nildummy_proto_t;
 /** Dummy nil device map.
+ * Maps devices to the dummy nil device specific data.
+ *
+ * Map devices to the dummy nil device specific data.
  * @see device.h
+ *
  */
 DEVICE_MAP_DECLARE(nildummy_devices, nildummy_device_t);
 …
         /** Device identifier. */
         device_id_t device_id;
         /** Device driver service. */
         services_t service;
         /** Driver phone. */
         int phone;
         /** Maximal transmission unit. */
         size_t mtu;
         /** Actual device hardware address. */
         measured_string_t *addr;
         /** Actual device hardware address data. */
         char *addr_data;
+        uint8_t *addr_data;
 };
 …
         /** Protocol service. */
         services_t service;
         /** Protocol module phone. */
         int phone;
 …
         /** Networking module phone. */
         int net_phone;
+        /** Safety lock for devices. */
+        /** Lock for devices. */
         fibril_rwlock_t devices_lock;
         /** All known Ethernet devices. */
         nildummy_devices_t devices;
         /** Safety lock for protocols. */
         fibril_rwlock_t protos_lock;
         /** Default protocol. */
         nildummy_proto_t proto;

uspace/srv/net/tl/icmp/Makefile

-              rcead2aa
+              r357b5f5
 SOURCES = \
+        icmp.c \
+        icmp_module.c
+        icmp.c
 include $(USPACE_PREFIX)/Makefile.common

uspace/srv/net/tl/icmp/icmp.c

-              rcead2aa
+              r357b5f5
 /** @file
  * ICMP module implementation.
+ * @see icmp.h
+ */
+#include "icmp.h"
+#include "icmp_module.h"
+ */
 #include <async.h>
 …
 #include <byteorder.h>
 #include <errno.h>
+#include <adt/hash_table.h>
 #include <net/socket_codes.h>
 …
 #include <net_checksum.h>
 #include <icmp_client.h>
 #include <icmp_interface.h>
 #include <il_interface.h>
+#include <icmp_remote.h>
+#include <il_remote.h>
 #include <ip_client.h>
 #include <ip_interface.h>
 #include <net_interface.h>
 #include <tl_interface.h>
 #include <tl_local.h>
+#include <tl_remote.h>
+#include <tl_skel.h>
 #include <icmp_header.h>
+/** ICMP module name. */
+#define NAME    "ICMP protocol"
+/** Default ICMP error reporting. */
+#define NET_DEFAULT_ICMP_ERROR_REPORTING        true
+/** Default ICMP echo replying. */
+#define NET_DEFAULT_ICMP_ECHO_REPLYING          true
+/** Original datagram length in bytes transfered to the error notification
+ * message.
+ */
+#define ICMP_KEEP_LENGTH        8
+/** Free identifier numbers pool start. */
+#define ICMP_FREE_IDS_START     1
+/** Free identifier numbers pool end. */
+#define ICMP_FREE_IDS_END       UINT16_MAX
+/** Computes the ICMP datagram checksum.
+ *
+ * @param[in,out] header The ICMP datagram header.
+ * @param[in] length    The total datagram length.
+ * @return              The computed checksum.
+/** ICMP module name */
+#define NAME  "icmp"
+/** Number of replies hash table keys */
+#define REPLY_KEYS  2
+/** Number of replies hash table buckets */
+#define REPLY_BUCKETS  1024
+/**
+ * Original datagram length in bytes transfered to the error
+ * notification message.
+ */
+#define ICMP_KEEP_LENGTH  8
+/** Compute the ICMP datagram checksum.
+ *
+ * @param[in,out] header ICMP datagram header.
+ * @param[in]     length Total datagram length.
+ *
+ * @return Computed checksum.
+ *
  */
 #define ICMP_CHECKSUM(header, length) \
 …
 /** An echo request datagrams pattern. */
+#define ICMP_ECHO_TEXT          "Hello from HelenOS."
+/** Computes an ICMP reply data key.
+ *
+ * @param[in] id        The message identifier.
+ * @param[in] sequence  The message sequence number.
+ * @return              The computed ICMP reply data key.
+ */
+#define ICMP_GET_REPLY_KEY(id, sequence) \
+        (((id) << 16) | (sequence & 0xFFFF))
+/** ICMP global data. */
+icmp_globals_t  icmp_globals;
+INT_MAP_IMPLEMENT(icmp_replies, icmp_reply_t);
+INT_MAP_IMPLEMENT(icmp_echo_data, icmp_echo_t);
+/** Releases the packet and returns the result.
+ *
+ * @param[in] packet    The packet queue to be released.
+ * @param[in] result    The result to be returned.
+ * @return              The result parameter.
+ */
+static int icmp_release_and_return(packet_t *packet, int result)
+{
+        pq_release_remote(icmp_globals.net_phone, packet_get_id(packet));
+        return result;
+}
+/** Sends the ICMP message.
+ *
+ * Sets the message type and code and computes the checksum.
+#define ICMP_ECHO_TEXT  "ICMP hello from HelenOS."
+/** ICMP reply data. */
+typedef struct {
+        /** Hash table link */
+        link_t link;
+        /** Reply identification and sequence */
+        icmp_param_t id;
+        icmp_param_t sequence;
+        /** Reply signaling */
+        fibril_condvar_t condvar;
+        /** Reply result */
+        int result;
+} icmp_reply_t;
+/** Global data */
+static int phone_net = -1;
+static int phone_ip = -1;
+static bool error_reporting = true;
+static bool echo_replying = true;
+static packet_dimension_t icmp_dimension;
+/** ICMP client identification counter */
+static atomic_t icmp_client;
+/** ICMP identifier and sequence number (client-specific) */
+static fibril_local icmp_param_t icmp_id;
+static fibril_local icmp_param_t icmp_seq;
+/** Reply hash table */
+static fibril_mutex_t reply_lock;
+static hash_table_t replies;
+static hash_index_t replies_hash(unsigned long key[])
+{
+        /*
+         * ICMP identifier and sequence numbers
+         * are 16-bit values.
+         */
+        hash_index_t index = ((key[0] & 0xffff) << 16) | (key[1] & 0xffff);
+        return (index % REPLY_BUCKETS);
+}
+static int replies_compare(unsigned long key[], hash_count_t keys, link_t *item)
+{
+        icmp_reply_t *reply =
+            hash_table_get_instance(item, icmp_reply_t, link);
+        if (keys == 1)
+                return (reply->id == key[0]);
+        else
+                return ((reply->id == key[0]) && (reply->sequence == key[1]));
+}
+static void replies_remove_callback(link_t *item)
+{
+}
+static hash_table_operations_t reply_ops = {
+        .hash = replies_hash,
+        .compare = replies_compare,
+        .remove_callback = replies_remove_callback
+};
+/** Release the packet and return the result.
+ *
+ * @param[in] packet Packet queue to be released.
+ *
+ */
+static void icmp_release(packet_t *packet)
+{
+        pq_release_remote(phone_net, packet_get_id(packet));
+}
+/** Send the ICMP message.
+ *
+ * Set the message type and code and compute the checksum.
  * Error messages are sent only if allowed in the configuration.
+ * Releases the packet on errors.
+ *
+ * @param[in] type      The message type.
+ * @param[in] code      The message code.
+ * @param[in] packet    The message packet to be sent.
+ * @param[in] header    The ICMP header.
+ * @param[in] error     The error service to be announced. Should be
+ *                      SERVICE_ICMP or zero.
+ * @param[in] ttl       The time to live.
+ * @param[in] tos       The type of service.
+ * @param[in] dont_fragment The value indicating whether the datagram must not
+ *                      be fragmented. Is used as a MTU discovery.
+ * @return              EOK on success.
+ * @return              EPERM if the error message is not allowed.
+ */
+static int icmp_send_packet(icmp_type_t type, icmp_code_t code, packet_t *packet,
+    icmp_header_t *header, services_t error, ip_ttl_t ttl, ip_tos_t tos,
+    int dont_fragment)
+{
+        int rc;
+ * Release the packet on errors.
+ *
+ * @param[in] type          Message type.
+ * @param[in] code          Message code.
+ * @param[in] packet        Message packet to be sent.
+ * @param[in] header        ICMP header.
+ * @param[in] error         Error service to be announced. Should be
+ *                          SERVICE_ICMP or zero.
+ * @param[in] ttl           Time to live.
+ * @param[in] tos           Type of service.
+ * @param[in] dont_fragment Disable fragmentation.
+ *
+ * @return EOK on success.
+ * @return EPERM if the error message is not allowed.
+ *
+ */
+static int icmp_send_packet(icmp_type_t type, icmp_code_t code,
+    packet_t *packet, icmp_header_t *header, services_t error, ip_ttl_t ttl,
+    ip_tos_t tos, bool dont_fragment)
+{
         /* Do not send an error if disabled */
+        if (error && !icmp_globals.error_reporting)
+                return icmp_release_and_return(packet, EPERM);
+        if ((error) && (!error_reporting)) {
+                icmp_release(packet);
+                return EPERM;
+        }
         header->type = type;
         header->code = code;
+        /*
+         * The checksum needs to be calculated
+         * with a virtual checksum field set to
+         * zero.
+         */
         header->checksum = 0;
         header->checksum = ICMP_CHECKSUM(header,
             packet_get_data_length(packet));
         rc = ip_client_prepare_packet(packet, IPPROTO_ICMP, ttl, tos,
+        int rc = ip_client_prepare_packet(packet, IPPROTO_ICMP, ttl, tos,
             dont_fragment, 0);
+        if (rc != EOK)
+                return icmp_release_and_return(packet, rc);
+        return ip_send_msg(icmp_globals.ip_phone, -1, packet, SERVICE_ICMP,
+            error);
+}
+/** Prepares the ICMP error packet.
+ *
+ * Truncates the original packet if longer than ICMP_KEEP_LENGTH bytes.
+ * Prefixes and returns the ICMP header.
+ *
+ * @param[in,out] packet The original packet.
+        if (rc != EOK) {
+                icmp_release(packet);
+                return rc;
+        }
+        return ip_send_msg(phone_ip, -1, packet, SERVICE_ICMP, error);
+}
+/** Prepare the ICMP error packet.
+ *
+ * Truncate the original packet if longer than ICMP_KEEP_LENGTH bytes.
+ * Prefix and return the ICMP header.
+ *
+ * @param[in,out] packet Original packet.
+ *
  * @return The prefixed ICMP header.
  * @return NULL on errors.
+ *
  */
 static icmp_header_t *icmp_prepare_packet(packet_t *packet)
+{
+        icmp_header_t *header;
+        size_t header_length;
+        size_t total_length;
+        total_length = packet_get_data_length(packet);
+        size_t total_length = packet_get_data_length(packet);
         if (total_length <= 0)
                 return NULL;
         header_length = ip_client_header_length(packet);
+        size_t header_length = ip_client_header_length(packet);
         if (header_length <= 0)
                 return NULL;
         /* Truncate if longer than 64 bits (without the IP header) */
         if ((total_length > header_length + ICMP_KEEP_LENGTH) &&
             (packet_trim(packet, 0,
             total_length - header_length - ICMP_KEEP_LENGTH) != EOK)) {
+            total_length - header_length - ICMP_KEEP_LENGTH) != EOK))
                 return NULL;
+        }
+        header = PACKET_PREFIX(packet, icmp_header_t);
+        icmp_header_t *header = PACKET_PREFIX(packet, icmp_header_t);
         if (!header)
                 return NULL;
         bzero(header, sizeof(*header));
         return header;
+}
 /** Requests an echo message.
+ *
  * Sends a packet with specified parameters to the target host and waits for
  * the reply upto the given timeout.
  * Blocks the caller until the reply or the timeout occurs.
+ *
  * @param[in] id        The message identifier.
  * @param[in] sequence  The message sequence parameter.
  * @param[in] size      The message data length in bytes.
  * @param[in] timeout   The timeout in miliseconds.
  * @param[in] ttl       The time to live.
  * @param[in] tos       The type of service.
  * @param[in] dont_fragment The value indicating whether the datagram must not
  *                      be fragmented. Is used as a MTU discovery.
  * @param[in] addr      The target host address.
  * @param[in] addrlen   The torget host address length.
  * @return              ICMP_ECHO on success.
  * @return              ETIMEOUT if the reply has not arrived before the
  *                      timeout.
  * @return              ICMP type of the received error notification.
  * @return              EINVAL if the addrlen parameter is less or equal to
  *                      zero.
  * @return              ENOMEM if there is not enough memory left.
  * @return              EPARTY if there was an internal error.
+/** Request an echo message.
+ *
+ * Send a packet with specified parameters to the target host
+ * and wait for the reply upto the given timeout.
+ * Block the caller until the reply or the timeout occurs.
+ *
+ * @param[in] id            Message identifier.
+ * @param[in] sequence      Message sequence parameter.
+ * @param[in] size          Message data length in bytes.
+ * @param[in] timeout       Timeout in miliseconds.
+ * @param[in] ttl           Time to live.
+ * @param[in] tos           Type of service.
+ * @param[in] dont_fragment Disable fragmentation.
+ * @param[in] addr          Target host address.
+ * @param[in] addrlen       Torget host address length.
+ *
+ * @return ICMP_ECHO on success.
+ * @return ETIMEOUT if the reply has not arrived before the
+ *         timeout.
+ * @return ICMP type of the received error notification.
+ * @return EINVAL if the addrlen parameter is less or equal to
+ *         zero.
+ * @return ENOMEM if there is not enough memory left.
+ *
  */
 static int icmp_echo(icmp_param_t id, icmp_param_t sequence, size_t size,
+    mseconds_t timeout, ip_ttl_t ttl, ip_tos_t tos, int dont_fragment,
+    const struct sockaddr * addr, socklen_t addrlen)
+{
+        icmp_header_t *header;
+        packet_t *packet;
+        size_t length;
+        uint8_t *data;
+        icmp_reply_t *reply;
+        int reply_key;
+        int index;
+        int rc;
+    mseconds_t timeout, ip_ttl_t ttl, ip_tos_t tos, bool dont_fragment,
+    const struct sockaddr *addr, socklen_t addrlen)
+{
         if (addrlen <= 0)
                 return EINVAL;
+        length = (size_t) addrlen;
+        /* TODO do not ask all the time */
+        rc = ip_packet_size_req(icmp_globals.ip_phone, -1,
+            &icmp_globals.packet_dimension);
+        if (rc != EOK)
+                return rc;
+        packet = packet_get_4_remote(icmp_globals.net_phone, size,
+            icmp_globals.packet_dimension.addr_len,
+            ICMP_HEADER_SIZE + icmp_globals.packet_dimension.prefix,
+            icmp_globals.packet_dimension.suffix);
+        size_t length = (size_t) addrlen;
+        packet_t *packet = packet_get_4_remote(phone_net, size,
+            icmp_dimension.addr_len, ICMP_HEADER_SIZE + icmp_dimension.prefix,
+            icmp_dimension.suffix);
         if (!packet)
                 return ENOMEM;
         /* Prepare the requesting packet, set the destination address. */
+        rc = packet_set_addr(packet, NULL, (const uint8_t *) addr, length);
+        if (rc != EOK)
+                return icmp_release_and_return(packet, rc);
+        int rc = packet_set_addr(packet, NULL, (const uint8_t *) addr, length);
+        if (rc != EOK) {
+                icmp_release(packet);
+                return rc;
+        }
         /* Allocate space in the packet */
+        data = (uint8_t *) packet_suffix(packet, size);
+        if (!data)
+                return icmp_release_and_return(packet, ENOMEM);
+        uint8_t *data = (uint8_t *) packet_suffix(packet, size);
+        if (!data) {
+                icmp_release(packet);
+                return ENOMEM;
+        }
         /* Fill the data */
         length = 0;
 …
+        }
         memcpy(data + length, ICMP_ECHO_TEXT, size - length);
         /* Prefix the header */
+        header = PACKET_PREFIX(packet, icmp_header_t);
+        if (!header)
+                return icmp_release_and_return(packet, ENOMEM);
+        bzero(header, sizeof(*header));
+        icmp_header_t *header = PACKET_PREFIX(packet, icmp_header_t);
+        if (!header) {
+                icmp_release(packet);
+                return ENOMEM;
+        }
+        bzero(header, sizeof(icmp_header_t));
         header->un.echo.identifier = id;
         header->un.echo.sequence_number = sequence;
         /* Prepare the reply structure */
+        reply = malloc(sizeof(*reply));
+        if (!reply)
+                return icmp_release_and_return(packet, ENOMEM);
+        fibril_mutex_initialize(&reply->mutex);
+        fibril_mutex_lock(&reply->mutex);
+        icmp_reply_t *reply = malloc(sizeof(icmp_reply_t));
+        if (!reply) {
+                icmp_release(packet);
+                return ENOMEM;
+        }
+        reply->id = id;
+        reply->sequence = sequence;
         fibril_condvar_initialize(&reply->condvar);
+        reply_key = ICMP_GET_REPLY_KEY(header->un.echo.identifier,
+            header->un.echo.sequence_number);
+        index = icmp_replies_add(&icmp_globals.replies, reply_key, reply);
+        if (index < 0) {
+                free(reply);
+                return icmp_release_and_return(packet, index);
+        }
+        /* Unlock the globals so that we can wait for the reply */
+        fibril_rwlock_write_unlock(&icmp_globals.lock);
+        /* Add the reply to the replies hash table */
+        fibril_mutex_lock(&reply_lock);
+        unsigned long key[REPLY_KEYS] = {id, sequence};
+        hash_table_insert(&replies, key, &reply->link);
         /* Send the request */
         icmp_send_packet(ICMP_ECHO, 0, packet, header, 0, ttl, tos,
             dont_fragment);
         /* Wait for the reply. Timeout in microseconds. */
         rc = fibril_condvar_wait_timeout(&reply->condvar, &reply->mutex,
+        rc = fibril_condvar_wait_timeout(&reply->condvar, &reply_lock,
             timeout * 1000);
         if (rc == EOK)
                 rc = reply->result;
         /* Drop the reply mutex before locking the globals again */
         fibril_mutex_unlock(&reply->mutex);
         fibril_rwlock_write_lock(&icmp_globals.lock);
         /* Destroy the reply structure */
         icmp_replies_exclude_index(&icmp_globals.replies, index);
+        /* Remove the reply from the replies hash table */
+        hash_table_remove(&replies, key, REPLY_KEYS);
+        fibril_mutex_unlock(&reply_lock);
+        free(reply);
         return rc;
+}
 static int icmp_destination_unreachable_msg_local(int icmp_phone,
     icmp_code_t code, icmp_param_t mtu, packet_t *packet)
+{
         icmp_header_t *header;
         header = icmp_prepare_packet(packet);
         if (!header)
                 return icmp_release_and_return(packet, ENOMEM);
+static int icmp_destination_unreachable(icmp_code_t code, icmp_param_t mtu,
+    packet_t *packet)
+{
+        icmp_header_t *header = icmp_prepare_packet(packet);
+        if (!header) {
+                icmp_release(packet);
+                return ENOMEM;
+        }
         if (mtu)
                 header->un.frag.mtu = mtu;
         return icmp_send_packet(ICMP_DEST_UNREACH, code, packet, header,
             SERVICE_ICMP, 0, 0, 0);
+}
 static int icmp_source_quench_msg_local(int icmp_phone, packet_t *packet)
+{
         icmp_header_t *header;
         header = icmp_prepare_packet(packet);
         if (!header)
                 return icmp_release_and_return(packet, ENOMEM);
+            SERVICE_ICMP, 0, 0, false);
+}
+static int icmp_source_quench(packet_t *packet)
+{
+        icmp_header_t *header = icmp_prepare_packet(packet);
+        if (!header) {
+                icmp_release(packet);
+                return ENOMEM;
+        }
         return icmp_send_packet(ICMP_SOURCE_QUENCH, 0, packet, header,
+            SERVICE_ICMP, 0, 0, 0);
+}
+static int icmp_time_exceeded_msg_local(int icmp_phone, icmp_code_t code,
+            SERVICE_ICMP, 0, 0, false);
+}
+static int icmp_time_exceeded(icmp_code_t code, packet_t *packet)
+{
+        icmp_header_t *header = icmp_prepare_packet(packet);
+        if (!header) {
+                icmp_release(packet);
+                return ENOMEM;
+        }
+        return icmp_send_packet(ICMP_TIME_EXCEEDED, code, packet, header,
+            SERVICE_ICMP, 0, 0, false);
+}
+static int icmp_parameter_problem(icmp_code_t code, icmp_param_t pointer,
     packet_t *packet)
+{
+        icmp_header_t *header;
+        header = icmp_prepare_packet(packet);
+        if (!header)
+                return icmp_release_and_return(packet, ENOMEM);
+        return icmp_send_packet(ICMP_TIME_EXCEEDED, code, packet, header,
+            SERVICE_ICMP, 0, 0, 0);
+}
+static int icmp_parameter_problem_msg_local(int icmp_phone, icmp_code_t code,
+    icmp_param_t pointer, packet_t *packet)
+{
+        icmp_header_t *header;
+        header = icmp_prepare_packet(packet);
+        if (!header)
+                return icmp_release_and_return(packet, ENOMEM);
+        icmp_header_t *header = icmp_prepare_packet(packet);
+        if (!header) {
+                icmp_release(packet);
+                return ENOMEM;
+        }
         header->un.param.pointer = pointer;
         return icmp_send_packet(ICMP_PARAMETERPROB, code, packet, header,
+            SERVICE_ICMP, 0, 0, 0);
+}
+/** Initializes the ICMP 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 icmp_initialize(async_client_conn_t client_connection)
+{
+        measured_string_t names[] = {
+                {
+                        (char *) "ICMP_ERROR_REPORTING",
+                },
+                {
+                        (char *) "ICMP_ECHO_REPLYING",
+                }
+        };
+        measured_string_t *configuration;
+        size_t count = sizeof(names) / sizeof(measured_string_t);
+        char *data;
+        int rc;
+        fibril_rwlock_initialize(&icmp_globals.lock);
+        fibril_rwlock_write_lock(&icmp_globals.lock);
+        icmp_replies_initialize(&icmp_globals.replies);
+        icmp_echo_data_initialize(&icmp_globals.echo_data);
+        icmp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_ICMP,
+            SERVICE_ICMP, client_connection);
+        if (icmp_globals.ip_phone < 0) {
+                fibril_rwlock_write_unlock(&icmp_globals.lock);
+                return icmp_globals.ip_phone;
+        }
+        rc = ip_packet_size_req(icmp_globals.ip_phone, -1,
+            &icmp_globals.packet_dimension);
+        if (rc != EOK) {
+                fibril_rwlock_write_unlock(&icmp_globals.lock);
+                return rc;
+        }
+        icmp_globals.packet_dimension.prefix += ICMP_HEADER_SIZE;
+        icmp_globals.packet_dimension.content -= ICMP_HEADER_SIZE;
+        icmp_globals.error_reporting = NET_DEFAULT_ICMP_ERROR_REPORTING;
+        icmp_globals.echo_replying = NET_DEFAULT_ICMP_ECHO_REPLYING;
+        /* Get configuration */
+        configuration = &names[0];
+        rc = net_get_conf_req(icmp_globals.net_phone, &configuration, count,
+            &data);
+        if (rc != EOK) {
+                fibril_rwlock_write_unlock(&icmp_globals.lock);
+                return rc;
+        }
+        if (configuration) {
+                if (configuration[0].value) {
+                        icmp_globals.error_reporting =
+                            (configuration[0].value[0] == 'y');
+                }
+                if (configuration[1].value) {
+                        icmp_globals.echo_replying =
+                            (configuration[1].value[0] == 'y');
+                }
+                net_free_settings(configuration, data);
+        }
+        fibril_rwlock_write_unlock(&icmp_globals.lock);
+        return EOK;
+}
+/** Tries to set the pending reply result as the received message type.
+            SERVICE_ICMP, 0, 0, false);
+}
+/** Try to set the pending reply result as the received message type.
+ *
  * If the reply data is not present, the reply timed out and the other fibril
  * is already awake.
  * Releases the packet.
+ *
  * @param[in] packet    The received reply message.
  * @param[in] header    The ICMP message header.
  * @param[in] type      The received reply message type.
  * @param[in] code      The received reply message code.
  */
 static void  icmp_process_echo_reply(packet_t *packet, icmp_header_t *header,
+ * is already awake. The packet is released.
+ *
+ * @param[in] packet The received reply message.
+ * @param[in] header The ICMP message header.
+ * @param[in] type   The received reply message type.
+ * @param[in] code   The received reply message code.
+ *
+ */
+static void icmp_process_echo_reply(packet_t *packet, icmp_header_t *header,
     icmp_type_t type, icmp_code_t code)
+{
+        int reply_key;
+        icmp_reply_t *reply;
+        /* Compute the reply key */
+        reply_key = ICMP_GET_REPLY_KEY(header->un.echo.identifier,
+            header->un.echo.sequence_number);
+        pq_release_remote(icmp_globals.net_phone, packet_get_id(packet));
+        unsigned long key[REPLY_KEYS] =
+            {header->un.echo.identifier, header->un.echo.sequence_number};
+        /* The packet is no longer needed */
+        icmp_release(packet);
         /* Find the pending reply */
+        fibril_rwlock_write_lock(&icmp_globals.lock);
+        reply = icmp_replies_find(&icmp_globals.replies, reply_key);
+        if (reply) {
+        fibril_mutex_lock(&reply_lock);
+        link_t *link = hash_table_find(&replies, key);
+        if (link != NULL) {
+                icmp_reply_t *reply =
+                   hash_table_get_instance(link, icmp_reply_t, link);
                 reply->result = type;
                 fibril_condvar_signal(&reply->condvar);
+        }
+        fibril_rwlock_write_unlock(&icmp_globals.lock);
+}
+/** Processes the received ICMP packet.
+ *
+ * Notifies the destination socket application.
+ *
+ * @param[in,out] packet The received packet.
+ * @param[in] error     The packet error reporting service. Prefixes the
+ *                      received packet.
+ * @return              EOK on success.
+ * @return              EINVAL if the packet is not valid.
+ * @return              EINVAL if the stored packet address is not the an_addr_t.
+ * @return              EINVAL if the packet does not contain any data.
+ * @return              NO_DATA if the packet content is shorter than the user
+ *                      datagram header.
+ * @return              ENOMEM if there is not enough memory left.
+ * @return              EADDRNOTAVAIL if the destination socket does not exist.
+ * @return              Other error codes as defined for the
+ *                      ip_client_process_packet() function.
+        fibril_mutex_unlock(&reply_lock);
+}
+/** Process the received ICMP packet.
+ *
+ * Notify the destination socket application.
+ *
+ * @param[in,out] packet Received packet.
+ * @param[in]     error  Packet error reporting service to prefix
+ *                       the received packet.
+ *
+ * @return EOK on success.
+ * @return EINVAL if the packet is not valid.
+ * @return EINVAL if the stored packet address is not the an_addr_t.
+ * @return EINVAL if the packet does not contain any data.
+ * @return NO_DATA if the packet content is shorter than the user
+ *         datagram header.
+ * @return ENOMEM if there is not enough memory left.
+ * @return EADDRNOTAVAIL if the destination socket does not exist.
+ * @return Other error codes as defined for the
+ *         ip_client_process_packet() function.
+ *
  */
 static int icmp_process_packet(packet_t *packet, services_t error)
+{
-        size_t length;
-        uint8_t *src;
-        int addrlen;
-        int result;
-        void *data;
-        icmp_header_t *header;
         icmp_type_t type;
         icmp_code_t code;
         int rc;
         switch (error) {
         case SERVICE_NONE:
 …
         case SERVICE_ICMP:
                 /* Process error */
+                result = icmp_client_process_packet(packet, &type, &code, NULL,
+                    NULL);
+                if (result < 0)
+                        return result;
+                length = (size_t) result;
+                rc = icmp_client_process_packet(packet, &type, &code, NULL, NULL);
+                if (rc < 0)
+                        return rc;
                 /* Remove the error header */
                 rc = packet_trim(packet, length, 0);
+                rc = packet_trim(packet, (size_t) rc, 0);
                 if (rc != EOK)
                         return rc;
                 break;
         default:
                 return ENOTSUP;
+        }
         /* Get rid of the IP header */
         length = ip_client_header_length(packet);
+        size_t length = ip_client_header_length(packet);
         rc = packet_trim(packet, length, 0);
         if (rc != EOK)
                 return rc;
         length = packet_get_data_length(packet);
         if (length <= 0)
                 return EINVAL;
         if (length < ICMP_HEADER_SIZE)
                 return EINVAL;
         data = packet_get_data(packet);
+        void *data = packet_get_data(packet);
         if (!data)
                 return EINVAL;
         /* Get ICMP header */
         header = (icmp_header_t *) data;
+        icmp_header_t *header = (icmp_header_t *) data;
         if (header->checksum) {
                 while (ICMP_CHECKSUM(header, length) != IP_CHECKSUM_ZERO) {
 …
+                                }
+                        }
                         return EINVAL;
+                }
+        }
         switch (header->type) {
         case ICMP_ECHOREPLY:
 …
                 else
                         icmp_process_echo_reply(packet, header, ICMP_ECHO, 0);
                 return EOK;
         case ICMP_ECHO:
                 if (error) {
 …
                 /* Do not send a reply if disabled */
+                if (icmp_globals.echo_replying) {
+                        addrlen = packet_get_addr(packet, &src, NULL);
+                if (echo_replying) {
+                        uint8_t *src;
+                        int addrlen = packet_get_addr(packet, &src, NULL);
                         /*
                          * Set both addresses to the source one (avoids the
+                         * Set both addresses to the source one (avoid the
                          * source address deletion before setting the
                          * destination one).
 …
                                 return EOK;
+                        }
                         return EINVAL;
+                }
                 return EPERM;
         case ICMP_DEST_UNREACH:
         case ICMP_SOURCE_QUENCH:
 …
         case ICMP_SKIP:
         case ICMP_PHOTURIS:
                 ip_received_error_msg(icmp_globals.ip_phone, -1, packet,
+                ip_received_error_msg(phone_ip, -1, packet,
                     SERVICE_IP, SERVICE_ICMP);
                 return EOK;
         default:
                 return ENOTSUP;
 …
+}
+/** Processes the received ICMP packet.
+ *
+ * Is used as an entry point from the underlying IP module.
+ * Releases the packet on error.
+ *
+ * @param device_id     The device identifier. Ignored parameter.
+ * @param[in,out] packet The received packet.
+ * @param receiver      The target service. Ignored parameter.
+ * @param[in] error     The packet error reporting service. Prefixes the
+ *                      received packet.
+ * @return              EOK on success.
+ * @return              Other error codes as defined for the
+ *                      icmp_process_packet() function.
+ */
+static int icmp_received_msg_local(device_id_t device_id, packet_t *packet,
+    services_t receiver, services_t error)
+{
+        int rc;
+        rc = icmp_process_packet(packet, error);
+        if (rc != EOK)
+                return icmp_release_and_return(packet, rc);
+        return EOK;
+}
+/** Processes the generic client messages.
+ *
+ * @param[in] call      The message parameters.
+ * @return              EOK on success.
+ * @return              ENOTSUP if the message is not known.
+ * @return              Other error codes as defined for the packet_translate()
+ *                      function.
+ * @return              Other error codes as defined for the
+ *                      icmp_destination_unreachable_msg_local() function.
+ * @return              Other error codes as defined for the
+ *                      icmp_source_quench_msg_local() function.
+ * @return              Other error codes as defined for the
+ *                      icmp_time_exceeded_msg_local() function.
+ * @return              Other error codes as defined for the
+ *                      icmp_parameter_problem_msg_local() function.
+ *
+ * @see icmp_interface.h
+ */
+static int icmp_process_message(ipc_call_t *call)
+{
+/** Process IPC messages from the IP module
+ *
+ * @param[in]     iid   Message identifier.
+ * @param[in,out] icall Message parameters.
+ *
+ */
+static void icmp_receiver(ipc_callid_t iid, ipc_call_t *icall)
+{
+        bool loop = true;
         packet_t *packet;
         int rc;
+        switch (IPC_GET_METHOD(*call)) {
+        case NET_ICMP_DEST_UNREACH:
+                rc = packet_translate_remote(icmp_globals.net_phone, &packet,
+                    IPC_GET_PACKET(call));
+        while (loop) {
+                switch (IPC_GET_IMETHOD(*icall)) {
+                case NET_TL_RECEIVED:
+                        rc = packet_translate_remote(phone_net, &packet,
+                            IPC_GET_PACKET(*icall));
+                        if (rc == EOK) {
+                                rc = icmp_process_packet(packet, IPC_GET_ERROR(*icall));
+                                if (rc != EOK)
+                                        icmp_release(packet);
+                        }
+                        ipc_answer_0(iid, (sysarg_t) rc);
+                        break;
+                case IPC_M_PHONE_HUNGUP:
+                        loop = false;
+                        continue;
+                default:
+                        ipc_answer_0(iid, (sysarg_t) ENOTSUP);
+                }
+                iid = async_get_call(icall);
+        }
+}
+/** Initialize the ICMP module.
+ *
+ * @param[in] net_phone Network module phone.
+ *
+ * @return EOK on success.
+ * @return ENOMEM if there is not enough memory left.
+ *
+ */
+int tl_initialize(int net_phone)
+{
+        measured_string_t names[] = {
+                {
+                        (uint8_t *) "ICMP_ERROR_REPORTING",
+                },
+                {
+                        (uint8_t *) "ICMP_ECHO_REPLYING",
+                }
+        };
+        measured_string_t *configuration;
+        size_t count = sizeof(names) / sizeof(measured_string_t);
+        uint8_t *data;
+        if (!hash_table_create(&replies, REPLY_BUCKETS, REPLY_KEYS, &reply_ops))
+                return ENOMEM;
+        fibril_mutex_initialize(&reply_lock);
+        atomic_set(&icmp_client, 0);
+        phone_net = net_phone;
+        phone_ip = ip_bind_service(SERVICE_IP, IPPROTO_ICMP, SERVICE_ICMP,
+            icmp_receiver);
+        if (phone_ip < 0)
+                return phone_ip;
+        int rc = ip_packet_size_req(phone_ip, -1, &icmp_dimension);
+        if (rc != EOK)
+                return rc;
+        icmp_dimension.prefix += ICMP_HEADER_SIZE;
+        icmp_dimension.content -= ICMP_HEADER_SIZE;
+        /* Get configuration */
+        configuration = &names[0];
+        rc = net_get_conf_req(phone_net, &configuration, count, &data);
+        if (rc != EOK)
+                return rc;
+        if (configuration) {
+                if (configuration[0].value)
+                        error_reporting = (configuration[0].value[0] == 'y');
+                if (configuration[1].value)
+                        echo_replying = (configuration[1].value[0] == 'y');
+                net_free_settings(configuration, data);
+        }
+        return EOK;
+}
+/** Per-connection initialization
+ *
+ * Initialize client-specific global variables.
+ *
+ */
+void tl_connection(void)
+{
+        icmp_id = (icmp_param_t) atomic_postinc(&icmp_client);
+        icmp_seq = 1;
+}
+/** Process the ICMP 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.
+ * @return Other error codes as defined for the packet_translate()
+ *         function.
+ * @return Other error codes as defined for the
+ *         icmp_destination_unreachable() function.
+ * @return Other error codes as defined for the
+ *         icmp_source_quench() function.
+ * @return Other error codes as defined for the
+ *         icmp_time_exceeded() function.
+ * @return Other error codes as defined for the
+ *         icmp_parameter_problem() function.
+ *
+ * @see icmp_remote.h
+ * @see IS_NET_ICMP_MESSAGE()
+ *
+ */
+int tl_message(ipc_callid_t callid, ipc_call_t *call,
+    ipc_call_t *answer, size_t *count)
+{
+        struct sockaddr *addr;
+        size_t size;
+        packet_t *packet;
+        int rc;
+        *count = 0;
+        switch (IPC_GET_IMETHOD(*call)) {
+        case NET_ICMP_ECHO:
+                rc = async_data_write_accept((void **) &addr, false, 0, 0, 0, &size);
                 if (rc != EOK)
                         return rc;
+                return icmp_destination_unreachable_msg_local(0,
+                    ICMP_GET_CODE(call), ICMP_GET_MTU(call), packet);
+        case NET_ICMP_SOURCE_QUENCH:
+                rc = packet_translate_remote(icmp_globals.net_phone, &packet,
+                    IPC_GET_PACKET(call));
+                rc = icmp_echo(icmp_id, icmp_seq, ICMP_GET_SIZE(*call),
+                    ICMP_GET_TIMEOUT(*call), ICMP_GET_TTL(*call),
+                    ICMP_GET_TOS(*call), ICMP_GET_DONT_FRAGMENT(*call),
+                    addr, (socklen_t) size);
+                free(addr);
+                icmp_seq++;
+                return rc;
+        case NET_ICMP_DEST_UNREACH:
+                rc = packet_translate_remote(phone_net, &packet,
+                    IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
+                return icmp_source_quench_msg_local(0, packet);
+        case NET_ICMP_TIME_EXCEEDED:
+                rc = packet_translate_remote(icmp_globals.net_phone, &packet,
+                    IPC_GET_PACKET(call));
+                return icmp_destination_unreachable(ICMP_GET_CODE(*call),
+                    ICMP_GET_MTU(*call), packet);
+        case NET_ICMP_SOURCE_QUENCH:
+                rc = packet_translate_remote(phone_net, &packet,
+                    IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
+                return icmp_time_exceeded_msg_local(0, ICMP_GET_CODE(call),
+                    packet);
+        case NET_ICMP_PARAMETERPROB:
+                rc = packet_translate_remote(icmp_globals.net_phone, &packet,
+                    IPC_GET_PACKET(call));
+                return icmp_source_quench(packet);
+        case NET_ICMP_TIME_EXCEEDED:
+                rc = packet_translate_remote(phone_net, &packet,
+                    IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
+                return icmp_parameter_problem_msg_local(0, ICMP_GET_CODE(call),
+                    ICMP_GET_POINTER(call), packet);
+        default:
+                return ENOTSUP;
+        }
+}
+/** Assigns a new identifier for the connection.
+ *
+ * Fills the echo data parameter with the assigned values.
+ *
+ * @param[in,out] echo_data The echo data to be bound.
+ * @return              Index of the inserted echo data.
+ * @return              EBADMEM if the echo_data parameter is NULL.
+ * @return              ENOTCONN if no free identifier have been found.
+ */
+static int icmp_bind_free_id(icmp_echo_t *echo_data)
+{
+        icmp_param_t index;
+        if (!echo_data)
+                return EBADMEM;
+        /* From the last used one */
+        index = icmp_globals.last_used_id;
+        do {
+                index++;
+                /* til the range end */
+                if (index >= ICMP_FREE_IDS_END) {
+                        /* start from the range beginning */
+                        index = ICMP_FREE_IDS_START - 1;
+                        do {
+                                index++;
+                                /* til the last used one */
+                                if (index >= icmp_globals.last_used_id) {
+                                        /* none found */
+                                        return ENOTCONN;
+                                }
+                        } while(icmp_echo_data_find(&icmp_globals.echo_data,
+                            index) != NULL);
+                        /* Found, break immediately */
+                        break;
+                }
+        } while (icmp_echo_data_find(&icmp_globals.echo_data, index) != NULL);
+        echo_data->identifier = index;
+        echo_data->sequence_number = 0;
+        return icmp_echo_data_add(&icmp_globals.echo_data, index, echo_data);
+}
+/** Processes the client messages.
+ *
+ * Remembers the assigned identifier and sequence numbers.
+ * Runs until the client module disconnects.
+ *
+ * @param[in] callid    The message identifier.
+ * @param[in] call      The message parameters.
+ * @return EOK.
+ *
+ * @see icmp_interface.h
+ * @see icmp_api.h
+ */
+static int icmp_process_client_messages(ipc_callid_t callid, ipc_call_t call)
+{
+        bool keep_on_going = true;
+        ipc_call_t answer;
+        int answer_count;
+        size_t length;
+        struct sockaddr *addr;
+        ipc_callid_t data_callid;
+        icmp_echo_t *echo_data;
+        int rc = EOK;
+        /*
+         * Accept the connection
+         *  - Answer the first NET_ICMP_INIT call.
+         */
+        answer_count = 0;
+        echo_data = (icmp_echo_t *) malloc(sizeof(*echo_data));
+        if (!echo_data)
+                return ENOMEM;
+        /* Assign a new identifier */
+        fibril_rwlock_write_lock(&icmp_globals.lock);
+        rc = icmp_bind_free_id(echo_data);
+        fibril_rwlock_write_unlock(&icmp_globals.lock);
+        if (rc < 0) {
+                free(echo_data);
+                return rc;
+        }
+        while (keep_on_going) {
+                /* Answer the call */
+                answer_call(callid, rc, &answer, answer_count);
+                /* Refresh data */
+                refresh_answer(&answer, &answer_count);
+                /* Get the next call */
+                callid = async_get_call(&call);
+                /* Process the call */
+                switch (IPC_GET_METHOD(call)) {
+                case IPC_M_PHONE_HUNGUP:
+                        keep_on_going = false;
+                        rc = EHANGUP;
+                        break;
+                case NET_ICMP_ECHO:
+                        if (!async_data_write_receive(&data_callid, &length)) {
+                                rc = EINVAL;
+                                break;
+                        }
+                        addr = malloc(length);
+                        if (!addr) {
+                                rc = ENOMEM;
+                                break;
+                        }
+                        rc = async_data_write_finalize(data_callid, addr,
+                            length);
+                        if (rc != EOK) {
+                                free(addr);
+                                break;
+                        }
+                        fibril_rwlock_write_lock(&icmp_globals.lock);
+                        rc = icmp_echo(echo_data->identifier,
+                            echo_data->sequence_number, ICMP_GET_SIZE(call),
+                            ICMP_GET_TIMEOUT(call), ICMP_GET_TTL(call),
+                            ICMP_GET_TOS(call), ICMP_GET_DONT_FRAGMENT(call),
+                            addr, (socklen_t) length);
+                        fibril_rwlock_write_unlock(&icmp_globals.lock);
+                        free(addr);
+                        if (echo_data->sequence_number < UINT16_MAX)
+                                echo_data->sequence_number++;
+                        else
+                                echo_data->sequence_number = 0;
+                        break;
+                default:
+                        rc = icmp_process_message(&call);
+                }
+        }
+        /* Release the identifier */
+        fibril_rwlock_write_lock(&icmp_globals.lock);
+        icmp_echo_data_exclude(&icmp_globals.echo_data, echo_data->identifier);
+        fibril_rwlock_write_unlock(&icmp_globals.lock);
+        return rc;
+}
+/** Processes the ICMP 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.
+ *
+ * @see icmp_interface.h
+ * @see IS_NET_ICMP_MESSAGE()
+ */
+int icmp_message_standalone(ipc_callid_t callid, ipc_call_t *call,
+    ipc_call_t *answer, int *answer_count)
+{
+        packet_t *packet;
+        int rc;
+        *answer_count = 0;
+        switch (IPC_GET_METHOD(*call)) {
+        case NET_TL_RECEIVED:
+                rc = packet_translate_remote(icmp_globals.net_phone, &packet,
+                    IPC_GET_PACKET(call));
+                return icmp_time_exceeded(ICMP_GET_CODE(*call), packet);
+        case NET_ICMP_PARAMETERPROB:
+                rc = packet_translate_remote(phone_net, &packet,
+                    IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
+                return icmp_received_msg_local(IPC_GET_DEVICE(call), packet,
+                    SERVICE_ICMP, IPC_GET_ERROR(call));
+        case NET_ICMP_INIT:
+                return icmp_process_client_messages(callid, * call);
+        default:
+                return icmp_process_message(call);
+        }
+                return icmp_parameter_problem(ICMP_GET_CODE(*call),
+                    ICMP_GET_POINTER(*call), packet);
+        }
         return ENOTSUP;
+}
-/** Default thread for new connections.
+ *
- * @param[in] iid The initial message identifier.
- * @param[in] icall The initial message call structure.
+ *
- */
-static void tl_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 = tl_module_message_standalone(callid, &call, &answer,
-                    &answer_count);
-                /*
-                 * End if told to either by the message or the processing
-                 * result.
-                 */
-                if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
-                    (res == EHANGUP))
-                        return;
-                /* Answer the message */
-                answer_call(callid, res, &answer, answer_count);
+        }
+}
-/** Starts the module.
+ *
- * @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 = tl_module_start_standalone(tl_client_connection);
+        return rc;
+        return tl_module_start(SERVICE_ICMP);
+}
 /** @}
  */

uspace/srv/net/tl/tcp/Makefile

-              rcead2aa
+              r357b5f5
 SOURCES = \
+        tcp.c \
+        tcp_module.c
+        tcp.c
 include $(USPACE_PREFIX)/Makefile.common

uspace/srv/net/tl/tcp/tcp.c

-              rcead2aa
+              r357b5f5
  */
-#include "tcp.h"
-#include "tcp_header.h"
-#include "tcp_module.h"
 #include <assert.h>
 #include <async.h>
 …
 #include <ip_interface.h>
 #include <icmp_client.h>
 #include <icmp_interface.h>
+#include <icmp_remote.h>
 #include <net_interface.h>
 #include <socket_core.h>
 #include <tl_common.h>
+#include <tl_local.h>
+#include <tl_interface.h>
+#include <tl_remote.h>
+#include <tl_skel.h>
+#include "tcp.h"
+#include "tcp_header.h"
 /** TCP module name. */
 #define NAME    "TCP protocol"
+#define NAME  "tcp"
 /** The TCP window default value. */
 …
         /** Port map key. */
         char *key;
+        uint8_t *key;
         /** Port map key length. */
 …
 static int tcp_queue_received_packet(socket_core_t *, tcp_socket_data_t *,
     packet_t *, int, size_t);
+static void tcp_queue_received_end_of_data(socket_core_t *socket);
 static int tcp_received_msg(device_id_t, packet_t *, services_t, services_t);
 …
 /** TCP global data. */
 tcp_globals_t tcp_globals;
-/** Initializes the TCP 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 tcp_initialize(async_client_conn_t client_connection)
+{
-        int rc;
-        assert(client_connection);
-        fibril_rwlock_initialize(&tcp_globals.lock);
-        fibril_rwlock_write_lock(&tcp_globals.lock);
-        tcp_globals.icmp_phone = icmp_connect_module(SERVICE_ICMP,
-            ICMP_CONNECT_TIMEOUT);
-        tcp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_TCP,
-            SERVICE_TCP, client_connection);
-        if (tcp_globals.ip_phone < 0) {
-                fibril_rwlock_write_unlock(&tcp_globals.lock);
-                return tcp_globals.ip_phone;
+        }
-        rc = socket_ports_initialize(&tcp_globals.sockets);
-        if (rc != EOK)
-                goto out;
-        rc = packet_dimensions_initialize(&tcp_globals.dimensions);
-        if (rc != EOK) {
-                socket_ports_destroy(&tcp_globals.sockets);
-                goto out;
+        }
-        tcp_globals.last_used_port = TCP_FREE_PORTS_START - 1;
-out:
-        fibril_rwlock_write_unlock(&tcp_globals.lock);
-        return rc;
+}
 int tcp_received_msg(device_id_t device_id, packet_t *packet,
 …
         /* Find the destination socket */
         socket = socket_port_find(&tcp_globals.sockets,
             ntohs(header->destination_port), (const char *) src, addrlen);
+            ntohs(header->destination_port), (uint8_t *) src, addrlen);
         if (!socket) {
                 /* Find the listening destination socket */
                 socket = socket_port_find(&tcp_globals.sockets,
                     ntohs(header->destination_port), SOCKET_MAP_KEY_LISTENING,
 );
+                    ntohs(header->destination_port),
+                    (uint8_t *) SOCKET_MAP_KEY_LISTENING, 0);
+        }
 …
 has_error_service:
         fibril_rwlock_read_unlock(&tcp_globals.lock);
+        fibril_rwlock_write_unlock(&tcp_globals.lock);
         /* TODO error reporting/handling */
 …
         size_t offset;
         uint32_t new_sequence_number;
+        bool forced_ack;
         int rc;
 …
         assert(packet);
+        forced_ack = false;
         new_sequence_number = ntohl(header->sequence_number);
         old_incoming = socket_data->next_incoming;
+        if (header->finalize)
+                socket_data->fin_incoming = new_sequence_number;
+        if (header->finalize) {
+                socket_data->fin_incoming = new_sequence_number +
+                    total_length - TCP_HEADER_LENGTH(header);
+        }
         /* Trim begining if containing expected data */
 …
                 /* Release duplicite or restricted */
                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
+        }
+        /* Change state according to the acknowledging incoming fin */
+        if (IS_IN_INTERVAL_OVERFLOW(old_incoming, socket_data->fin_incoming,
+            socket_data->next_incoming)) {
+                forced_ack = true;
+        }
+        /* If next in sequence is an incoming FIN */
+        if (socket_data->next_incoming == socket_data->fin_incoming) {
+                /* Advance sequence number */
+                socket_data->next_incoming += 1;
+                /* Handle FIN */
                 switch (socket_data->state) {
                 case TCP_SOCKET_FIN_WAIT_1:
 …
                         socket_data->state = TCP_SOCKET_CLOSING;
                         break;
+                /*case TCP_ESTABLISHED:*/
+                case TCP_SOCKET_ESTABLISHED:
+                        /* Queue end-of-data marker on the socket. */
+                        tcp_queue_received_end_of_data(socket);
+                        socket_data->state = TCP_SOCKET_CLOSE_WAIT;
+                        break;
                 default:
                         socket_data->state = TCP_SOCKET_CLOSE_WAIT;
 …
         packet = tcp_get_packets_to_send(socket, socket_data);
         if (!packet) {
+        if (!packet && (socket_data->next_incoming != old_incoming || forced_ack)) {
                 /* Create the notification packet */
                 rc = tcp_create_notification_packet(&packet, socket,
 …
         /* Notify the destination socket */
         async_msg_5(socket->phone, NET_SOCKET_RECEIVED,
             (ipcarg_t) socket->socket_id,
+            (sysarg_t) socket->socket_id,
             ((packet_dimension->content < socket_data->data_fragment_size) ?
             packet_dimension->content : socket_data->data_fragment_size), 0, 0,
             (ipcarg_t) fragments);
+            (sysarg_t) fragments);
         return EOK;
+}
+/** Queue end-of-data marker on the socket.
+ *
+ * Next element in the sequence space is FIN. Queue end-of-data marker
+ * on the socket.
+ *
+ * @param socket        Socket
+ */
+static void tcp_queue_received_end_of_data(socket_core_t *socket)
+{
+        assert(socket != NULL);
+        /* Notify the destination socket */
+        async_msg_5(socket->phone, NET_SOCKET_RECEIVED,
+            (sysarg_t) socket->socket_id,
+, 0, 0,
+            (sysarg_t) 0 /* 0 fragments == no more data */);
+}
 …
         /* Find the destination socket */
         listening_socket = socket_port_find(&tcp_globals.sockets,
             listening_port, SOCKET_MAP_KEY_LISTENING, 0);
+            listening_port, (uint8_t *) SOCKET_MAP_KEY_LISTENING, 0);
         if (!listening_socket ||
             (listening_socket->socket_id != listening_socket_id)) {
 …
         rc = socket_port_add(&tcp_globals.sockets, listening_port, socket,
             (const char *) socket_data->addr, socket_data->addrlen);
+            (uint8_t *) socket_data->addr, socket_data->addrlen);
         assert(socket == socket_port_find(&tcp_globals.sockets, listening_port,
             (const char *) socket_data->addr, socket_data->addrlen));
+            (uint8_t *) socket_data->addr, socket_data->addrlen));
 //      rc = socket_bind_free_port(&tcp_globals.sockets, socket,
 …
                         /* Notify the destination socket */
                         async_msg_5(socket->phone, NET_SOCKET_ACCEPTED,
                             (ipcarg_t) listening_socket->socket_id,
+                            (sysarg_t) listening_socket->socket_id,
                             socket_data->data_fragment_size, TCP_HEADER_SIZE,
 , (ipcarg_t) socket->socket_id);
+, (sysarg_t) socket->socket_id);
                         fibril_rwlock_write_unlock(socket_data->local_lock);
 …
+}
+/** Per-connection initialization
+ *
+ */
+void tl_connection(void)
+{
+}
 /** Processes the TCP message.
+ *
 …
  * @see IS_NET_TCP_MESSAGE()
  */
+int
+tcp_message_standalone(ipc_callid_t callid, ipc_call_t *call,
+    ipc_call_t *answer, int *answer_count)
+{
+        packet_t *packet;
+        int rc;
+int tl_message(ipc_callid_t callid, ipc_call_t *call,
+    ipc_call_t *answer, size_t *answer_count)
+{
         assert(call);
         assert(answer);
 …
         *answer_count = 0;
+        switch (IPC_GET_METHOD(*call)) {
+        case NET_TL_RECEIVED:
+//              fibril_rwlock_read_lock(&tcp_globals.lock);
+                rc = packet_translate_remote(tcp_globals.net_phone, &packet,
+                    IPC_GET_PACKET(call));
+                if (rc != EOK) {
+//                      fibril_rwlock_read_unlock(&tcp_globals.lock);
+                        return rc;
+                }
+                rc = tcp_received_msg(IPC_GET_DEVICE(call), packet, SERVICE_TCP,
+                    IPC_GET_ERROR(call));
+//              fibril_rwlock_read_unlock(&tcp_globals.lock);
+                return rc;
+        switch (IPC_GET_IMETHOD(*call)) {
         case IPC_M_CONNECT_TO_ME:
                 return tcp_process_client_messages(callid, *call);
 …
         bool keep_on_going = true;
         socket_cores_t local_sockets;
         int app_phone = IPC_GET_PHONE(&call);
+        int app_phone = IPC_GET_PHONE(call);
         struct sockaddr *addr;
         int socket_id;
 …
         fibril_rwlock_t lock;
         ipc_call_t answer;
         int answer_count;
+        size_t answer_count;
         tcp_socket_data_t *socket_data;
         socket_core_t *socket;
 …
                 /* Process the call */
                 switch (IPC_GET_METHOD(call)) {
+                switch (IPC_GET_IMETHOD(call)) {
                 case IPC_M_PHONE_HUNGUP:
                         keep_on_going = false;
 …
                 case NET_SOCKET_BIND:
+                        res = data_receive((void **) &addr, &addrlen);
+                        res = async_data_write_accept((void **) &addr, false,
+, 0, 0, &addrlen);
                         if (res != EOK)
                                 break;
 …
                 case NET_SOCKET_CONNECT:
+                        res = data_receive((void **) &addr, &addrlen);
+                        res = async_data_write_accept((void **) &addr, false,
+, 0, 0, &addrlen);
                         if (res != EOK)
                                 break;
 …
                 case NET_SOCKET_SENDTO:
+                        res = data_receive((void **) &addr, &addrlen);
+                        res = async_data_write_accept((void **) &addr, false,
+, 0, 0, &addrlen);
                         if (res != EOK)
                                 break;
 …
                         fibril_rwlock_write_unlock(socket_data->local_lock);
+                        socket_data->state = TCP_SOCKET_SYN_SENT;
                         /* Send the packet */
                         printf("connecting %d\n", packet_get_id(packet));
 …
         /* Copy the key */
         operation_timeout->key = ((char *) operation_timeout) +
+        operation_timeout->key = ((uint8_t *) operation_timeout) +
             sizeof(*operation_timeout);
         operation_timeout->key_length = socket->key_length;
 …
         if (!fibril) {
                 free(operation_timeout);
+                return EPARTY;  /* FIXME: use another EC */
+        }
+                return ENOMEM;
+        }
 //      fibril_mutex_lock(&socket_data->operation.mutex);
         /* Start the timeout fibril */
 …
                 tcp_prepare_operation_header(socket, socket_data, header, 0, 0);
                 rc = tcp_queue_packet(socket, socket_data, packet, 0);
+                rc = tcp_queue_packet(socket, socket_data, packet, total_length);
                 if (rc != EOK)
                         return rc;
 …
+}
 /** Default thread for new connections.
+/** Process IPC messages from the IP module
+ *
  * @param[in] iid       The initial message identifier.
  * @param[in] icall     The initial message call structure.
+ * @param[in]     iid   Message identifier.
+ * @param[in,out] icall Message parameters.
+ *
  */
+static void tl_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);
+static void tcp_receiver(ipc_callid_t iid, ipc_call_t *icall)
+{
+        packet_t *packet;
+        int rc;
         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 = tl_module_message_standalone(callid, &call, &answer,
+                    &answer_count);
+                /*
+                 * End if told to either by the message or the processing
+                 * result.
+                 */
+                if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
+                    (res == EHANGUP))
+                        return;
+                /*
+                 * Answer the message
+                 */
+                answer_call(callid, res, &answer, answer_count);
+        }
+}
+/** Starts the module.
+                switch (IPC_GET_IMETHOD(*icall)) {
+                case NET_TL_RECEIVED:
+                        rc = packet_translate_remote(tcp_globals.net_phone, &packet,
+                            IPC_GET_PACKET(*icall));
+                        if (rc == EOK)
+                                rc = tcp_received_msg(IPC_GET_DEVICE(*icall), packet,
+                                    SERVICE_TCP, IPC_GET_ERROR(*icall));
+                        ipc_answer_0(iid, (sysarg_t) rc);
+                        break;
+                default:
+                        ipc_answer_0(iid, (sysarg_t) ENOTSUP);
+                }
+                iid = async_get_call(icall);
+        }
+}
+/** Initialize the TCP module.
+ *
+ * @return              EOK on success.
+ * @return              Other error codes as defined for each specific module
+ *                      start function.
+ * @param[in] net_phone Network module phone.
+ *
+ * @return EOK on success.
+ * @return ENOMEM if there is not enough memory left.
+ *
  */
+int
+main(int argc, char *argv[])
+{
+        int rc;
+        rc = tl_module_start_standalone(tl_client_connection);
+int tl_initialize(int net_phone)
+{
+        fibril_rwlock_initialize(&tcp_globals.lock);
+        fibril_rwlock_write_lock(&tcp_globals.lock);
+        tcp_globals.net_phone = net_phone;
+        tcp_globals.icmp_phone = icmp_connect_module(ICMP_CONNECT_TIMEOUT);
+        tcp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_TCP,
+            SERVICE_TCP, tcp_receiver);
+        if (tcp_globals.ip_phone < 0) {
+                fibril_rwlock_write_unlock(&tcp_globals.lock);
+                return tcp_globals.ip_phone;
+        }
+        int rc = socket_ports_initialize(&tcp_globals.sockets);
+        if (rc != EOK)
+                goto out;
+        rc = packet_dimensions_initialize(&tcp_globals.dimensions);
+        if (rc != EOK) {
+                socket_ports_destroy(&tcp_globals.sockets);
+                goto out;
+        }
+        tcp_globals.last_used_port = TCP_FREE_PORTS_START - 1;
+out:
+        fibril_rwlock_write_unlock(&tcp_globals.lock);
         return rc;
+}
+int main(int argc, char *argv[])
+{
+        return tl_module_start(SERVICE_TCP);
+}

uspace/srv/net/tl/udp/Makefile

-              rcead2aa
+              r357b5f5
 SOURCES = \
+        udp.c \
+        udp_module.c
+        udp.c
 include $(USPACE_PREFIX)/Makefile.common

uspace/srv/net/tl/udp/udp.c

-              rcead2aa
+              r357b5f5
  * @see udp.h
  */
-#include "udp.h"
-#include "udp_header.h"
-#include "udp_module.h"
 #include <async.h>
 …
 #include <ip_interface.h>
 #include <icmp_client.h>
 #include <icmp_interface.h>
+#include <icmp_remote.h>
 #include <net_interface.h>
 #include <socket_core.h>
 #include <tl_common.h>
+#include <tl_local.h>
+#include <tl_interface.h>
+#include <tl_remote.h>
+#include <tl_skel.h>
+#include "udp.h"
+#include "udp_header.h"
 /** UDP module name. */
 #define NAME    "UDP protocol"
+#define NAME  "udp"
 /** Default UDP checksum computing. */
 …
 /** UDP global data.  */
 udp_globals_t udp_globals;
-/** Initializes the UDP 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 udp_initialize(async_client_conn_t client_connection)
+{
-        measured_string_t names[] = {
+                {
-                        (char *) "UDP_CHECKSUM_COMPUTING",
-                },
+                {
-                        (char *) "UDP_AUTOBINDING",
+                }
-        };
-        measured_string_t *configuration;
-        size_t count = sizeof(names) / sizeof(measured_string_t);
-        char *data;
-        int rc;
-        fibril_rwlock_initialize(&udp_globals.lock);
-        fibril_rwlock_write_lock(&udp_globals.lock);
-        udp_globals.icmp_phone = icmp_connect_module(SERVICE_ICMP,
-            ICMP_CONNECT_TIMEOUT);
-        udp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_UDP,
-            SERVICE_UDP, client_connection);
-        if (udp_globals.ip_phone < 0) {
-                fibril_rwlock_write_unlock(&udp_globals.lock);
-                return udp_globals.ip_phone;
+        }
-        /* Read default packet dimensions */
-        rc = ip_packet_size_req(udp_globals.ip_phone, -1,
-            &udp_globals.packet_dimension);
-        if (rc != EOK) {
-                fibril_rwlock_write_unlock(&udp_globals.lock);
-                return rc;
+        }
-        rc = socket_ports_initialize(&udp_globals.sockets);
-        if (rc != EOK) {
-                fibril_rwlock_write_unlock(&udp_globals.lock);
-                return rc;
+        }
-        rc = packet_dimensions_initialize(&udp_globals.dimensions);
-        if (rc != EOK) {
-                socket_ports_destroy(&udp_globals.sockets);
-                fibril_rwlock_write_unlock(&udp_globals.lock);
-                return rc;
+        }
-        udp_globals.packet_dimension.prefix += sizeof(udp_header_t);
-        udp_globals.packet_dimension.content -= sizeof(udp_header_t);
-        udp_globals.last_used_port = UDP_FREE_PORTS_START - 1;
-        udp_globals.checksum_computing = NET_DEFAULT_UDP_CHECKSUM_COMPUTING;
-        udp_globals.autobinding = NET_DEFAULT_UDP_AUTOBINDING;
-        /* Get configuration */
-        configuration = &names[0];
-        rc = net_get_conf_req(udp_globals.net_phone, &configuration, count,
-            &data);
-        if (rc != EOK) {
-                socket_ports_destroy(&udp_globals.sockets);
-                fibril_rwlock_write_unlock(&udp_globals.lock);
-                return rc;
+        }
-        if (configuration) {
-                if (configuration[0].value)
-                        udp_globals.checksum_computing =
-                            (configuration[0].value[0] == 'y');
-                if (configuration[1].value)
-                        udp_globals.autobinding =
-                            (configuration[1].value[0] == 'y');
-                net_free_settings(configuration, data);
+        }
-        fibril_rwlock_write_unlock(&udp_globals.lock);
-        return EOK;
+}
 /** Releases the packet and returns the result.
 …
         /* Find the destination socket */
         socket = socket_port_find(&udp_globals.sockets,
         ntohs(header->destination_port), SOCKET_MAP_KEY_LISTENING, 0);
+            ntohs(header->destination_port), (uint8_t *) SOCKET_MAP_KEY_LISTENING, 0);
         if (!socket) {
                 if (tl_prepare_icmp_packet(udp_globals.net_phone,
 …
         fibril_rwlock_write_unlock(&udp_globals.lock);
         async_msg_5(socket->phone, NET_SOCKET_RECEIVED,
             (ipcarg_t) socket->socket_id, packet_dimension->content, 0, 0,
             (ipcarg_t) fragments);
+            (sysarg_t) socket->socket_id, packet_dimension->content, 0, 0,
+            (sysarg_t) fragments);
         return EOK;
 …
         return result;
+}
+/** Process IPC messages from the IP module
+ *
+ * @param[in]     iid   Message identifier.
+ * @param[in,out] icall Message parameters.
+ *
+ */
+static void udp_receiver(ipc_callid_t iid, ipc_call_t *icall)
+{
+        packet_t *packet;
+        int rc;
+        while (true) {
+                switch (IPC_GET_IMETHOD(*icall)) {
+                case NET_TL_RECEIVED:
+                        rc = packet_translate_remote(udp_globals.net_phone, &packet,
+                            IPC_GET_PACKET(*icall));
+                        if (rc == EOK)
+                                rc = udp_received_msg(IPC_GET_DEVICE(*icall), packet,
+                                    SERVICE_UDP, IPC_GET_ERROR(*icall));
+                        ipc_answer_0(iid, (sysarg_t) rc);
+                        break;
+                default:
+                        ipc_answer_0(iid, (sysarg_t) ENOTSUP);
+                }
+                iid = async_get_call(icall);
+        }
+}
+/** Initialize the UDP module.
+ *
+ * @param[in] net_phone Network module phone.
+ *
+ * @return EOK on success.
+ * @return ENOMEM if there is not enough memory left.
+ *
+ */
+int tl_initialize(int net_phone)
+{
+        measured_string_t names[] = {
+                {
+                        (uint8_t *) "UDP_CHECKSUM_COMPUTING",
+                },
+                {
+                        (uint8_t *) "UDP_AUTOBINDING",
+                }
+        };
+        measured_string_t *configuration;
+        size_t count = sizeof(names) / sizeof(measured_string_t);
+        uint8_t *data;
+        fibril_rwlock_initialize(&udp_globals.lock);
+        fibril_rwlock_write_lock(&udp_globals.lock);
+        udp_globals.net_phone = net_phone;
+        udp_globals.icmp_phone = icmp_connect_module(ICMP_CONNECT_TIMEOUT);
+        udp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_UDP,
+            SERVICE_UDP, udp_receiver);
+        if (udp_globals.ip_phone < 0) {
+                fibril_rwlock_write_unlock(&udp_globals.lock);
+                return udp_globals.ip_phone;
+        }
+        /* Read default packet dimensions */
+        int rc = ip_packet_size_req(udp_globals.ip_phone, -1,
+            &udp_globals.packet_dimension);
+        if (rc != EOK) {
+                fibril_rwlock_write_unlock(&udp_globals.lock);
+                return rc;
+        }
+        rc = socket_ports_initialize(&udp_globals.sockets);
+        if (rc != EOK) {
+                fibril_rwlock_write_unlock(&udp_globals.lock);
+                return rc;
+        }
+        rc = packet_dimensions_initialize(&udp_globals.dimensions);
+        if (rc != EOK) {
+                socket_ports_destroy(&udp_globals.sockets);
+                fibril_rwlock_write_unlock(&udp_globals.lock);
+                return rc;
+        }
+        udp_globals.packet_dimension.prefix += sizeof(udp_header_t);
+        udp_globals.packet_dimension.content -= sizeof(udp_header_t);
+        udp_globals.last_used_port = UDP_FREE_PORTS_START - 1;
+        udp_globals.checksum_computing = NET_DEFAULT_UDP_CHECKSUM_COMPUTING;
+        udp_globals.autobinding = NET_DEFAULT_UDP_AUTOBINDING;
+        /* Get configuration */
+        configuration = &names[0];
+        rc = net_get_conf_req(udp_globals.net_phone, &configuration, count,
+            &data);
+        if (rc != EOK) {
+                socket_ports_destroy(&udp_globals.sockets);
+                fibril_rwlock_write_unlock(&udp_globals.lock);
+                return rc;
+        }
+        if (configuration) {
+                if (configuration[0].value)
+                        udp_globals.checksum_computing =
+                            (configuration[0].value[0] == 'y');
+                if (configuration[1].value)
+                        udp_globals.autobinding =
+                            (configuration[1].value[0] == 'y');
+                net_free_settings(configuration, data);
+        }
+        fibril_rwlock_write_unlock(&udp_globals.lock);
+        return EOK;
+}
 …
         bool keep_on_going = true;
         socket_cores_t local_sockets;
         int app_phone = IPC_GET_PHONE(&call);
+        int app_phone = IPC_GET_PHONE(call);
         struct sockaddr *addr;
         int socket_id;
 …
         size_t size;
         ipc_call_t answer;
         int answer_count;
+        size_t answer_count;
         packet_dimension_t *packet_dimension;
 …
                 /* Process the call */
                 switch (IPC_GET_METHOD(call)) {
+                switch (IPC_GET_IMETHOD(call)) {
                 case IPC_M_PHONE_HUNGUP:
                         keep_on_going = false;
 …
                 case NET_SOCKET_BIND:
+                        res = data_receive((void **) &addr, &addrlen);
+                        res = async_data_write_accept((void **) &addr, false,
+, 0, 0, &addrlen);
                         if (res != EOK)
                                 break;
 …
                 case NET_SOCKET_SENDTO:
+                        res = data_receive((void **) &addr, &addrlen);
+                        res = async_data_write_accept((void **) &addr, false,
+, 0, 0, &addrlen);
                         if (res != EOK)
                                 break;
 …
+}
+/** Per-connection initialization
+ *
+ */
+void tl_connection(void)
+{
+}
 /** Processes the UDP message.
+ *
 …
  * @see IS_NET_UDP_MESSAGE()
  */
+int udp_message_standalone(ipc_callid_t callid, ipc_call_t *call,
+    ipc_call_t *answer, int *answer_count)
+{
+        packet_t *packet;
+        int rc;
+int tl_message(ipc_callid_t callid, ipc_call_t *call,
+    ipc_call_t *answer, size_t *answer_count)
+{
         *answer_count = 0;
+        switch (IPC_GET_METHOD(*call)) {
+        case NET_TL_RECEIVED:
+                rc = packet_translate_remote(udp_globals.net_phone, &packet,
+                    IPC_GET_PACKET(call));
+                if (rc != EOK)
+                        return rc;
+                return udp_received_msg(IPC_GET_DEVICE(call), packet,
+                    SERVICE_UDP, IPC_GET_ERROR(call));
+        switch (IPC_GET_IMETHOD(*call)) {
         case IPC_M_CONNECT_TO_ME:
                 return udp_process_client_messages(callid, * call);
+                return udp_process_client_messages(callid, *call);
+        }
 …
+}
-/** Default thread for new connections.
+ *
- * @param[in] iid       The initial message identifier.
- * @param[in] icall     The initial message call structure.
- */
-static void tl_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 = tl_module_message_standalone(callid, &call, &answer,
-                    &answer_count);
-                /*
-                 * End if told to either by the message or the processing
-                 * result.
-                 */
-                if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
-                    (res == EHANGUP))
-                        return;
-                /* Answer the message */
-                answer_call(callid, res, &answer, answer_count);
+        }
+}
-/** Starts the module.
+ *
- * @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 = tl_module_start_standalone(tl_client_connection);
+        return rc;
+        return tl_module_start(SERVICE_UDP);
+}

Context Navigation

Changeset 357b5f5 in mainline for uspace/srv/net

Legend:

uspace/srv/net/cfg/ne2k

uspace/srv/net/il/arp/Makefile

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

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

uspace/srv/net/il/ip/Makefile

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

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

uspace/srv/net/net/net.c

uspace/srv/net/net/net.h

uspace/srv/net/net/net_standalone.c

uspace/srv/net/netif/lo/Makefile

uspace/srv/net/netif/lo/lo.c

uspace/srv/net/nil/eth/Makefile

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

uspace/srv/net/nil/eth/eth.h

uspace/srv/net/nil/nildummy/Makefile

uspace/srv/net/nil/nildummy/nildummy.c

uspace/srv/net/nil/nildummy/nildummy.h

uspace/srv/net/tl/icmp/Makefile

uspace/srv/net/tl/icmp/icmp.c

uspace/srv/net/tl/tcp/Makefile

uspace/srv/net/tl/tcp/tcp.c

uspace/srv/net/tl/udp/Makefile

uspace/srv/net/tl/udp/udp.c

Download in other formats: