Changeset 80cd7cd for uspace/srv/net – HelenOS

uspace/srv/net/cfg/ne2k

-              reaef141
+              r80cd7cd
 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

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

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

-              reaef141
+              r80cd7cd
  * @see arp.h
  */
-#include "arp.h"
-#include "arp_header.h"
-#include "arp_oc.h"
-#include "arp_module.h"
 #include <async.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. */
 …
 /** Number of microseconds to wait for an ARP reply. */
+#define ARP_TRANS_WAIT  1000000
+#define ARP_TRANS_WAIT  1000000
+/** @name ARP operation codes definitions */
+/*@{*/
+/** REQUEST operation code. */
+#define ARPOP_REQUEST  1
+/** REPLY operation code. */
+#define ARPOP_REPLY  2
+/*@}*/
+/** Type definition of an ARP protocol header.
+ * @see arp_header
+ */
+typedef struct arp_header arp_header_t;
+/** ARP protocol header. */
+struct arp_header {
+        /**
+         * Hardware type identifier.
+         * @see hardware.h
+         */
+        uint16_t hardware;
+        /** Protocol identifier. */
+        uint16_t protocol;
+        /** Hardware address length in bytes. */
+        uint8_t hardware_length;
+        /** Protocol address length in bytes. */
+        uint8_t protocol_length;
+        /**
+         * ARP packet type.
+         * @see arp_oc.h
+         */
+        uint16_t operation;
+} __attribute__ ((packed));
 /** ARP global data. */
 …
                 trans->hw_addr = NULL;
+        }
         fibril_condvar_broadcast(&trans->cv);
+}
 …
+{
         int count;
+        arp_trans_t *trans;
         for (count = arp_addr_count(addresses) - 1; count >= 0; count--) {
+                trans = arp_addr_items_get_index(&addresses->values, count);
+                arp_trans_t *trans = arp_addr_items_get_index(&addresses->values,
+                    count);
                 if (trans)
                         arp_clear_trans(trans);
 …
+}
+/** Clears the device specific data.
+ *
+ * @param[in] device    The device specific data.
+/** Clear the device specific data.
+ *
+ * @param[in] device Device specific data.
  */
 static void arp_clear_device(arp_device_t *device)
+{
         int count;
+        arp_proto_t *proto;
         for (count = arp_protos_count(&device->protos) - 1; count >= 0;
             count--) {
+                proto = arp_protos_get_index(&device->protos, count);
+                arp_proto_t *proto = arp_protos_get_index(&device->protos,
+                    count);
                 if (proto) {
                         if (proto->addr)
                                 free(proto->addr);
                         if (proto->addr_data)
                                 free(proto->addr_data);
                         arp_clear_addr(&proto->addresses);
                         arp_addr_destroy(&proto->addresses);
+                }
+        }
         arp_protos_clear(&device->protos);
+}
 …
+{
         int count;
+        arp_device_t *device;
         fibril_mutex_lock(&arp_globals.lock);
         for (count = arp_cache_count(&arp_globals.cache) - 1; count >= 0;
             count--) {
+                device = arp_cache_get_index(&arp_globals.cache, count);
+                arp_device_t *device = arp_cache_get_index(&arp_globals.cache,
+                    count);
                 if (device) {
                         arp_clear_device(device);
                         if (device->addr_data)
                                 free(device->addr_data);
                         if (device->broadcast_data)
                                 free(device->broadcast_data);
+                }
+        }
         arp_cache_clear(&arp_globals.cache);
         fibril_mutex_unlock(&arp_globals.lock);
         printf("Cache cleaned\n");
         return EOK;
+}
 …
     services_t protocol, measured_string_t *address)
+{
-        arp_device_t *device;
-        arp_proto_t *proto;
-        arp_trans_t *trans;
         fibril_mutex_lock(&arp_globals.lock);
+        device = arp_cache_find(&arp_globals.cache, device_id);
+        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
         if (!device) {
                 fibril_mutex_unlock(&arp_globals.lock);
                 return ENOENT;
+        }
+        proto = arp_protos_find(&device->protos, protocol);
+        arp_proto_t *proto = arp_protos_find(&device->protos, protocol);
         if (!proto) {
                 fibril_mutex_unlock(&arp_globals.lock);
                 return ENOENT;
+        }
+        trans = arp_addr_find(&proto->addresses, address->value, address->length);
+        arp_trans_t *trans = arp_addr_find(&proto->addresses, address->value,
+            address->length);
         if (trans)
                 arp_clear_trans(trans);
         arp_addr_exclude(&proto->addresses, address->value, address->length);
         fibril_mutex_unlock(&arp_globals.lock);
         return EOK;
+}
 static int arp_clear_device_req(int arp_phone, device_id_t device_id)
+{
-        arp_device_t *device;
         fibril_mutex_lock(&arp_globals.lock);
+        device = arp_cache_find(&arp_globals.cache, device_id);
+        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
         if (!device) {
                 fibril_mutex_unlock(&arp_globals.lock);
                 return ENOENT;
+        }
         arp_clear_device(device);
         printf("Device %d cleared\n", device_id);
         fibril_mutex_unlock(&arp_globals.lock);
         return EOK;
+}
+/** Creates new protocol specific data.
+ *
+ * Allocates and returns the needed memory block as the proto parameter.
+ *
+ * @param[out] proto    The allocated protocol specific data.
+ * @param[in] service   The protocol module service.
+ * @param[in] address   The actual protocol device address.
+ * @return              EOK on success.
+ * @return              ENOMEM if there is not enough memory left.
+/** Create new protocol specific data.
+ *
+ * Allocate and return the needed memory block as the proto parameter.
+ *
+ * @param[out] proto   Allocated protocol specific data.
+ * @param[in]  service Protocol module service.
+ * @param[in]  address Actual protocol device address.
+ *
+ * @return EOK on success.
+ * @return ENOMEM if there is not enough memory left.
+ *
  */
 static int arp_proto_create(arp_proto_t **proto, services_t service,
     measured_string_t *address)
+{
-        int rc;
         *proto = (arp_proto_t *) malloc(sizeof(arp_proto_t));
         if (!*proto)
 …
         (*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_mutex_lock(&arp_globals.lock);
+        /* An existing device? */
+        device = arp_cache_find(&arp_globals.cache, device_id);
+        if (device) {
+                if (device->service != service) {
+                        printf("Device %d already exists\n", device->device_id);
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        return EEXIST;
+                }
+                proto = arp_protos_find(&device->protos, protocol);
+                if (proto) {
+                        free(proto->addr);
+                        free(proto->addr_data);
+                        proto->addr = address;
+                        proto->addr_data = address->value;
+                } else {
+                        rc = arp_proto_create(&proto, protocol, address);
+                        if (rc != EOK) {
+                                fibril_mutex_unlock(&arp_globals.lock);
+                                return rc;
+                        }
+                        index = arp_protos_add(&device->protos, proto->service,
+                            proto);
+                        if (index < 0) {
+                                fibril_mutex_unlock(&arp_globals.lock);
+                                free(proto);
+                                return index;
+                        }
+                        printf("New protocol added:\n\tdevice id\t= "
+                            "%d\n\tproto\t= %d", device_id, protocol);
+                }
+        } else {
+                hardware = hardware_map(service);
+                if (!hardware)
+                        return ENOENT;
+                /* Create a new device */
+                device = (arp_device_t *) malloc(sizeof(arp_device_t));
+                if (!device) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        return ENOMEM;
+                }
+                device->hardware = hardware;
+                device->device_id = device_id;
+                rc = arp_protos_initialize(&device->protos);
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        free(device);
+                        return rc;
+                }
+                rc = arp_proto_create(&proto, protocol, address);
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        free(device);
+                        return rc;
+                }
+                index = arp_protos_add(&device->protos, proto->service, proto);
+                if (index < 0) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        arp_protos_destroy(&device->protos);
+                        free(device);
+                        return index;
+                }
+                device->service = service;
+                /* Bind the new one */
+                device->phone = nil_bind_service(device->service,
+                    (sysarg_t) device->device_id, SERVICE_ARP,
+                    arp_globals.client_connection);
+                if (device->phone < 0) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        arp_protos_destroy(&device->protos);
+                        free(device);
+                        return EREFUSED;
+                }
+                /* Get packet dimensions */
+                rc = nil_packet_size_req(device->phone, device_id,
+                    &device->packet_dimension);
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        arp_protos_destroy(&device->protos);
+                        free(device);
+                        return rc;
+                }
+                /* Get hardware address */
+                rc = nil_get_addr_req(device->phone, device_id, &device->addr,
+                    &device->addr_data);
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        arp_protos_destroy(&device->protos);
+                        free(device);
+                        return rc;
+                }
+                /* Get broadcast address */
+                rc = nil_get_broadcast_addr_req(device->phone, device_id,
+                    &device->broadcast_addr, &device->broadcast_data);
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        free(device->addr);
+                        free(device->addr_data);
+                        arp_protos_destroy(&device->protos);
+                        free(device);
+                        return rc;
+                }
+                rc = arp_cache_add(&arp_globals.cache, device->device_id,
+                    device);
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        free(device->addr);
+                        free(device->addr_data);
+                        free(device->broadcast_addr);
+                        free(device->broadcast_data);
+                        arp_protos_destroy(&device->protos);
+                        free(device);
+                        return rc;
+                }
+                printf("%s: Device registered (id: %d, type: 0x%x, service: %d,"
+                    " proto: %d)\n", NAME, device->device_id, device->hardware,
+                    device->service, protocol);
+        }
+        fibril_mutex_unlock(&arp_globals.lock);
+        return EOK;
+}
+/** Initializes the ARP module.
+ *
+ *  @param[in] client_connection The client connection processing function.
+ *                      The module skeleton propagates its own one.
+ *  @return             EOK on success.
+ *  @return             ENOMEM if there is not enough memory left.
+ */
+int arp_initialize(async_client_conn_t client_connection)
+{
+        int rc;
+        fibril_mutex_initialize(&arp_globals.lock);
+        fibril_mutex_lock(&arp_globals.lock);
+        arp_globals.client_connection = client_connection;
+        rc = arp_cache_initialize(&arp_globals.cache);
+        fibril_mutex_unlock(&arp_globals.lock);
+        return rc;
+}
+/** Updates the device content length according to the new MTU value.
+ *
+ * @param[in] device_id The device identifier.
+ * @param[in] mtu       The new mtu value.
+ * @return              ENOENT if device is not found.
+ * @return              EOK on success.
+ */
+static int arp_mtu_changed_message(device_id_t device_id, size_t mtu)
+{
+        arp_device_t *device;
+        fibril_mutex_lock(&arp_globals.lock);
+        device = arp_cache_find(&arp_globals.cache, device_id);
+        if (!device) {
+                fibril_mutex_unlock(&arp_globals.lock);
+                return ENOENT;
+        }
+        device->packet_dimension.content = mtu;
+        fibril_mutex_unlock(&arp_globals.lock);
+        printf("arp - device %d changed mtu to %zu\n\n", device_id, mtu);
+        return EOK;
+}
+/** Processes the received ARP packet.
+ *
+ * Updates the source hardware address if the source entry exists or the packet
+ * is targeted to my protocol address.
+ * Responses to the ARP request if the packet is the ARP request and is
+ * targeted to my address.
+ *
+ * @param[in] device_id The source device identifier.
+ * @param[in,out] packet The received packet.
+ * @return              EOK on success and the packet is no longer needed.
+ * @return              One on success and the packet has been reused.
+ * @return              EINVAL if the packet is too small to carry an ARP
+ *                      packet.
+ * @return              EINVAL if the received address lengths differs from
+ *                      the registered values.
+ * @return              ENOENT if the device is not found in the cache.
+ * @return              ENOENT if the protocol for the device is not found in
+ *                      the cache.
+ * @return              ENOMEM if there is not enough memory left.
+ */
+static int arp_receive_message(device_id_t device_id, packet_t *packet)
+{
+        size_t length;
+        arp_header_t *header;
+        arp_device_t *device;
+        arp_proto_t *proto;
+        arp_trans_t *trans;
+        uint8_t *src_hw;
+        uint8_t *src_proto;
+        uint8_t *des_hw;
+        uint8_t *des_proto;
+        int rc;
+        length = packet_get_data_length(packet);
+        size_t length = packet_get_data_length(packet);
         if (length <= sizeof(arp_header_t))
                 return EINVAL;
         device = arp_cache_find(&arp_globals.cache, device_id);
+        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
         if (!device)
                 return ENOENT;
         header = (arp_header_t *) packet_get_data(packet);
+        arp_header_t *header = (arp_header_t *) packet_get_data(packet);
         if ((ntohs(header->hardware) != device->hardware) ||
             (length < sizeof(arp_header_t) + header->hardware_length * 2U +
 …
                 return EINVAL;
+        }
         proto = arp_protos_find(&device->protos,
+        arp_proto_t *proto = arp_protos_find(&device->protos,
             protocol_unmap(device->service, ntohs(header->protocol)));
         if (!proto)
                 return ENOENT;
+        src_hw = ((uint8_t *) header) + sizeof(arp_header_t);
+        src_proto = src_hw + header->hardware_length;
+        des_hw = src_proto + header->protocol_length;
+        des_proto = des_hw + header->hardware_length;
+        trans = arp_addr_find(&proto->addresses, (char *) src_proto,
+        uint8_t *src_hw = ((uint8_t *) header) + sizeof(arp_header_t);
+        uint8_t *src_proto = src_hw + header->hardware_length;
+        uint8_t *des_hw = src_proto + header->protocol_length;
+        uint8_t *des_proto = des_hw + header->hardware_length;
+        arp_trans_t *trans = arp_addr_find(&proto->addresses, src_proto,
             header->protocol_length);
+        /* Exists? */
+        if (trans && trans->hw_addr) {
+        if ((trans) && (trans->hw_addr)) {
+                /* Translation exists */
                 if (trans->hw_addr->length != header->hardware_length)
                         return EINVAL;
                 memcpy(trans->hw_addr->value, src_hw, trans->hw_addr->length);
+        }
         /* Is my protocol address? */
         if (proto->addr->length != header->protocol_length)
                 return EINVAL;
+        if (!str_lcmp(proto->addr->value, (char *) des_proto,
+            proto->addr->length)) {
+                /* Not already updated? */
+        if (!bcmp(proto->addr->value, des_proto, proto->addr->length)) {
                 if (!trans) {
+                        /* Update the translation */
                         trans = (arp_trans_t *) malloc(sizeof(arp_trans_t));
                         if (!trans)
                                 return ENOMEM;
                         trans->hw_addr = NULL;
                         fibril_condvar_initialize(&trans->cv);
                         rc = arp_addr_add(&proto->addresses, (char *) src_proto,
+                        rc = arp_addr_add(&proto->addresses, src_proto,
                             header->protocol_length, trans);
                         if (rc != EOK) {
 …
+                        }
+                }
                 if (!trans->hw_addr) {
                         trans->hw_addr = measured_string_create_bulk(
                             (char *) src_hw, header->hardware_length);
+                        trans->hw_addr = measured_string_create_bulk(src_hw,
+                            header->hardware_length);
                         if (!trans->hw_addr)
                                 return ENOMEM;
                         /* Notify the fibrils that wait for the translation. */
                         fibril_condvar_broadcast(&trans->cv);
+                }
                 if (ntohs(header->operation) == ARPOP_REQUEST) {
                         header->operation = htons(ARPOP_REPLY);
 …
+                }
+        }
         return EOK;
+}
+/** Returns the hardware address for the given protocol address.
+ *
+ * Sends the ARP request packet if the hardware address is not found in the
+ * cache.
+ *
+ * @param[in] device_id The device identifier.
+ * @param[in] protocol  The protocol service.
+ * @param[in] target    The target protocol address.
+ * @param[out] translation Where the hardware address of the target is stored.
+ * @return              EOK on success.
+ * @return              EAGAIN if the caller should try again.
+ * @return              Other error codes in case of error.
+ */
+static int
+arp_translate_message(device_id_t device_id, services_t protocol,
+    measured_string_t *target, measured_string_t **translation)
+{
+        arp_device_t *device;
+        arp_proto_t *proto;
+        arp_trans_t *trans;
+        size_t length;
+/** Update the device content length according to the new MTU value.
+ *
+ * @param[in] device_id Device identifier.
+ * @param[in] mtu       New MTU value.
+ *
+ * @return ENOENT if device is not found.
+ * @return EOK on success.
+ *
+ */
+static int arp_mtu_changed_message(device_id_t device_id, size_t mtu)
+{
+        fibril_mutex_lock(&arp_globals.lock);
+        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
+        if (!device) {
+                fibril_mutex_unlock(&arp_globals.lock);
+                return ENOENT;
+        }
+        device->packet_dimension.content = mtu;
+        fibril_mutex_unlock(&arp_globals.lock);
+        printf("%s: Device %d changed MTU to %zu\n", NAME, device_id, mtu);
+        return EOK;
+}
+/** Process IPC messages from the registered device driver modules
+ *
+ * @param[in]     iid   Message identifier.
+ * @param[in,out] icall Message parameters.
+ *
+ */
+static void arp_receiver(ipc_callid_t iid, ipc_call_t *icall)
+{
         packet_t *packet;
-        arp_header_t *header;
-        bool retry = false;
         int rc;
+restart:
+        if (!target || !translation)
+                return EBADMEM;
+        device = arp_cache_find(&arp_globals.cache, device_id);
+        if (!device)
+                return ENOENT;
+        proto = arp_protos_find(&device->protos, protocol);
+        if (!proto || (proto->addr->length != target->length))
+                return ENOENT;
+        trans = arp_addr_find(&proto->addresses, target->value, target->length);
+        if (trans) {
+                if (trans->hw_addr) {
+                        *translation = trans->hw_addr;
+                        return EOK;
+                }
+                if (retry)
+                        return EAGAIN;
+                rc = fibril_condvar_wait_timeout(&trans->cv, &arp_globals.lock,
+                    ARP_TRANS_WAIT);
+                if (rc == ETIMEOUT)
+        while (true) {
+                switch (IPC_GET_IMETHOD(*icall)) {
+                case NET_IL_DEVICE_STATE:
+                        /* Do nothing - keep the cache */
+                        ipc_answer_0(iid, (sysarg_t) EOK);
+                        break;
+                case NET_IL_RECEIVED:
+                        rc = packet_translate_remote(arp_globals.net_phone, &packet,
+                            IPC_GET_PACKET(*icall));
+                        if (rc == EOK) {
+                                fibril_mutex_lock(&arp_globals.lock);
+                                do {
+                                        packet_t *next = pq_detach(packet);
+                                        rc = arp_receive_message(IPC_GET_DEVICE(*icall), packet);
+                                        if (rc != 1) {
+                                                pq_release_remote(arp_globals.net_phone,
+                                                    packet_get_id(packet));
+                                        }
+                                        packet = next;
+                                } while (packet);
+                                fibril_mutex_unlock(&arp_globals.lock);
+                        }
+                        ipc_answer_0(iid, (sysarg_t) rc);
+                        break;
+                case NET_IL_MTU_CHANGED:
+                        rc = arp_mtu_changed_message(IPC_GET_DEVICE(*icall),
+                            IPC_GET_MTU(*icall));
+                        ipc_answer_0(iid, (sysarg_t) rc);
+                        break;
+                default:
+                        ipc_answer_0(iid, (sysarg_t) ENOTSUP);
+                }
+                iid = async_get_call(icall);
+        }
+}
+/** Register the device.
+ *
+ * Create new device entry in the cache or update the protocol address if the
+ * device with the device identifier and the driver service exists.
+ *
+ * @param[in] device_id Device identifier.
+ * @param[in] service   Device driver service.
+ * @param[in] protocol  Protocol service.
+ * @param[in] address   Actual device protocol address.
+ *
+ * @return EOK on success.
+ * @return EEXIST if another device with the same device identifier
+ *         and different driver service exists.
+ * @return ENOMEM if there is not enough memory left.
+ * @return Other error codes as defined for the
+ *         measured_strings_return() function.
+ *
+ */
+static int arp_device_message(device_id_t device_id, services_t service,
+    services_t protocol, measured_string_t *address)
+{
+        int index;
+        int rc;
+        fibril_mutex_lock(&arp_globals.lock);
+        /* An existing device? */
+        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
+        if (device) {
+                if (device->service != service) {
+                        printf("%s: Device %d already exists\n", NAME,
+                            device->device_id);
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        return EEXIST;
+                }
+                arp_proto_t *proto = arp_protos_find(&device->protos, protocol);
+                if (proto) {
+                        free(proto->addr);
+                        free(proto->addr_data);
+                        proto->addr = address;
+                        proto->addr_data = address->value;
+                } else {
+                        rc = arp_proto_create(&proto, protocol, address);
+                        if (rc != EOK) {
+                                fibril_mutex_unlock(&arp_globals.lock);
+                                return rc;
+                        }
+                        index = arp_protos_add(&device->protos, proto->service,
+                            proto);
+                        if (index < 0) {
+                                fibril_mutex_unlock(&arp_globals.lock);
+                                free(proto);
+                                return index;
+                        }
+                        printf("%s: New protocol added (id: %d, proto: %d)\n", NAME,
+                            device_id, protocol);
+                }
+        } else {
+                hw_type_t hardware = hardware_map(service);
+                if (!hardware)
                         return ENOENT;
+                retry = true;
+                goto restart;
+        }
+        if (retry)
+                return EAGAIN;
+                /* Create new device */
+                device = (arp_device_t *) malloc(sizeof(arp_device_t));
+                if (!device) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        return ENOMEM;
+                }
+                device->hardware = hardware;
+                device->device_id = device_id;
+                rc = arp_protos_initialize(&device->protos);
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        free(device);
+                        return rc;
+                }
+                arp_proto_t *proto;
+                rc = arp_proto_create(&proto, protocol, address);
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        free(device);
+                        return rc;
+                }
+                index = arp_protos_add(&device->protos, proto->service, proto);
+                if (index < 0) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        arp_protos_destroy(&device->protos);
+                        free(device);
+                        return index;
+                }
+                device->service = service;
+                /* Bind */
+                device->phone = nil_bind_service(device->service,
+                    (sysarg_t) device->device_id, SERVICE_ARP,
+                    arp_receiver);
+                if (device->phone < 0) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        arp_protos_destroy(&device->protos);
+                        free(device);
+                        return EREFUSED;
+                }
+                /* Get packet dimensions */
+                rc = nil_packet_size_req(device->phone, device_id,
+                    &device->packet_dimension);
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        arp_protos_destroy(&device->protos);
+                        free(device);
+                        return rc;
+                }
+                /* Get hardware address */
+                rc = nil_get_addr_req(device->phone, device_id, &device->addr,
+                    &device->addr_data);
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        arp_protos_destroy(&device->protos);
+                        free(device);
+                        return rc;
+                }
+                /* Get broadcast address */
+                rc = nil_get_broadcast_addr_req(device->phone, device_id,
+                    &device->broadcast_addr, &device->broadcast_data);
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        free(device->addr);
+                        free(device->addr_data);
+                        arp_protos_destroy(&device->protos);
+                        free(device);
+                        return rc;
+                }
+                rc = arp_cache_add(&arp_globals.cache, device->device_id,
+                    device);
+                if (rc != EOK) {
+                        fibril_mutex_unlock(&arp_globals.lock);
+                        free(device->addr);
+                        free(device->addr_data);
+                        free(device->broadcast_addr);
+                        free(device->broadcast_data);
+                        arp_protos_destroy(&device->protos);
+                        free(device);
+                        return rc;
+                }
+                printf("%s: Device registered (id: %d, type: 0x%x, service: %d,"
+                    " proto: %d)\n", NAME, device->device_id, device->hardware,
+                    device->service, protocol);
+        }
+        fibril_mutex_unlock(&arp_globals.lock);
+        return EOK;
+}
+int il_initialize(int net_phone)
+{
+        fibril_mutex_initialize(&arp_globals.lock);
+        fibril_mutex_lock(&arp_globals.lock);
+        arp_globals.net_phone = net_phone;
+        int rc = arp_cache_initialize(&arp_globals.cache);
+        fibril_mutex_unlock(&arp_globals.lock);
+        return rc;
+}
+static int arp_send_request(device_id_t device_id, services_t protocol,
+    measured_string_t *target, arp_device_t *device, arp_proto_t *proto)
+{
         /* ARP packet content size = header + (address + translation) * 2 */
         length = 8 + 2 * (proto->addr->length + device->addr->length);
+        size_t length = 8 + 2 * (proto->addr->length + device->addr->length);
         if (length > device->packet_dimension.content)
                 return ELIMIT;
         packet = packet_get_4_remote(arp_globals.net_phone,
+        packet_t *packet = packet_get_4_remote(arp_globals.net_phone,
             device->packet_dimension.addr_len, device->packet_dimension.prefix,
             length, device->packet_dimension.suffix);
         if (!packet)
                 return ENOMEM;
         header = (arp_header_t *) packet_suffix(packet, length);
+        arp_header_t *header = (arp_header_t *) packet_suffix(packet, length);
         if (!header) {
                 pq_release_remote(arp_globals.net_phone, packet_get_id(packet));
                 return ENOMEM;
+        }
         header->hardware = htons(device->hardware);
         header->hardware_length = (uint8_t) device->addr->length;
 …
         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);
         rc = packet_set_addr(packet, (uint8_t *) device->addr->value,
+        int rc = packet_set_addr(packet, (uint8_t *) device->addr->value,
             (uint8_t *) device->broadcast_addr->value, device->addr->length);
         if (rc != EOK) {
 …
                 return rc;
+        }
         nil_send_msg(device->phone, device_id, packet, SERVICE_ARP);
+        return EOK;
+}
+/** Return the hardware address for the given protocol address.
+ *
+ * Send the ARP request packet if the hardware address is not found in the
+ * cache.
+ *
+ * @param[in]  device_id   Device identifier.
+ * @param[in]  protocol    Protocol service.
+ * @param[in]  target      Target protocol address.
+ * @param[out] translation Where the hardware address of the target is stored.
+ *
+ * @return EOK on success.
+ * @return EAGAIN if the caller should try again.
+ * @return Other error codes in case of error.
+ *
+ */
+static int arp_translate_message(device_id_t device_id, services_t protocol,
+    measured_string_t *target, measured_string_t **translation)
+{
+        bool retry = false;
+        int rc;
+restart:
+        if ((!target) || (!translation))
+                return EBADMEM;
+        arp_device_t *device = arp_cache_find(&arp_globals.cache, device_id);
+        if (!device)
+                return ENOENT;
+        arp_proto_t *proto = arp_protos_find(&device->protos, protocol);
+        if ((!proto) || (proto->addr->length != target->length))
+                return ENOENT;
+        arp_trans_t *trans = arp_addr_find(&proto->addresses, target->value,
+            target->length);
+        if (trans) {
+                if (trans->hw_addr) {
+                        *translation = trans->hw_addr;
+                        return EOK;
+                }
+                if (retry) {
+                        /* Remove the translation from the map */
+                        arp_clear_trans(trans);
+                        arp_addr_exclude(&proto->addresses, target->value,
+                            target->length);
+                        return EAGAIN;
+                }
+                rc = fibril_condvar_wait_timeout(&trans->cv, &arp_globals.lock,
+                    ARP_TRANS_WAIT);
+                if (rc == ETIMEOUT)
+                        return ENOENT;
+                retry = true;
+                goto restart;
+        }
+        if (retry)
+                return EAGAIN;
         trans = (arp_trans_t *) malloc(sizeof(arp_trans_t));
         if (!trans)
                 return ENOMEM;
         trans->hw_addr = NULL;
         fibril_condvar_initialize(&trans->cv);
         rc = arp_addr_add(&proto->addresses, target->value, target->length,
             trans);
 …
+        }
+        rc = arp_send_request(device_id, protocol, target, device, proto);
+        if (rc != EOK)
+                return rc;
         rc = fibril_condvar_wait_timeout(&trans->cv, &arp_globals.lock,
             ARP_TRANS_WAIT);
         if (rc == ETIMEOUT)
                 return ENOENT;
         retry = true;
         goto restart;
+}
+/** Processes the ARP message.
+ *
+ * @param[in] callid    The message identifier.
+ * @param[in] call      The message parameters.
+ * @param[out] answer   The message answer parameters.
+ * @param[out] answer_count The last parameter for the actual answer in the
+ *                      answer parameter.
+ * @return              EOK on success.
+ * @return              ENOTSUP if the message is not known.
+/** Process the ARP message.
+ *
+ * @param[in]  callid Message identifier.
+ * @param[in]  call   Message parameters.
+ * @param[out] answer Answer.
+ * @param[out] count  Number of arguments of the answer.
+ *
+ * @return EOK on success.
+ * @return ENOTSUP if the message is not known.
+ *
  * @see arp_interface.h
  * @see IS_NET_ARP_MESSAGE()
  */
+int
 arp_message_standalone(ipc_callid_t callid, ipc_call_t *call,
     ipc_call_t *answer, int *answer_count)
+ *
+ */
+int il_module_message(ipc_callid_t callid, ipc_call_t *call, ipc_call_t *answer,
+    size_t *count)
+{
         measured_string_t *address;
         measured_string_t *translation;
+        char *data;
+        packet_t *packet;
+        packet_t *next;
+        uint8_t *data;
         int rc;
         *answer_count = 0;
+        *count = 0;
         switch (IPC_GET_IMETHOD(*call)) {
         case IPC_M_PHONE_HUNGUP:
 …
                         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;
 …
                 fibril_mutex_lock(&arp_globals.lock);
                 rc = arp_translate_message(IPC_GET_DEVICE(call),
                     IPC_GET_SERVICE(call), address, &translation);
+                rc = arp_translate_message(IPC_GET_DEVICE(*call),
+                    IPC_GET_SERVICE(*call), address, &translation);
                 free(address);
                 free(data);
                 if (rc != EOK) {
                         fibril_mutex_unlock(&arp_globals.lock);
                         return rc;
+                }
                 if (!translation) {
                         fibril_mutex_unlock(&arp_globals.lock);
                         return ENOENT;
+                }
                 rc = measured_strings_reply(translation, 1);
                 fibril_mutex_unlock(&arp_globals.lock);
                 return rc;
         case NET_ARP_CLEAR_DEVICE:
                 return arp_clear_device_req(0, IPC_GET_DEVICE(call));
+                return arp_clear_device_req(0, IPC_GET_DEVICE(*call));
         case NET_ARP_CLEAR_ADDRESS:
                 rc = measured_strings_receive(&address, &data, 1);
 …
                         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_mutex_lock(&arp_globals.lock);
-                do {
-                        next = pq_detach(packet);
-                        rc = arp_receive_message(IPC_GET_DEVICE(call), packet);
-                        if (rc != 1) {
-                                pq_release_remote(arp_globals.net_phone,
-                                    packet_get_id(packet));
+                        }
-                        packet = next;
-                } while (packet);
-                fibril_mutex_unlock(&arp_globals.lock);
-                return EOK;
-        case NET_IL_MTU_CHANGED:
-                return arp_mtu_changed_message(IPC_GET_DEVICE(call),
-                    IPC_GET_MTU(call));
+        }
 …
+}
-/** Default thread for new connections.
+ *
- * @param[in] iid       The initial message identifier.
- * @param[in] icall     The initial message call structure.
- */
-static void il_client_connection(ipc_callid_t iid, ipc_call_t *icall)
+{
-        /*
-         * Accept the connection
-         *  - Answer the first IPC_M_CONNECT_ME_TO call.
-         */
-        ipc_answer_0(iid, EOK);
-        while (true) {
-                ipc_call_t answer;
-                int answer_count;
-                /* Clear the answer structure */
-                refresh_answer(&answer, &answer_count);
-                /* Fetch the next message */
-                ipc_call_t call;
-                ipc_callid_t callid = async_get_call(&call);
-                /* Process the message */
-                int res = il_module_message_standalone(callid, &call, &answer,
-                    &answer_count);
-                /*
-                 * End if told to either by the message or the processing
-                 * result.
-                 */
-                if ((IPC_GET_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
-                    (res == EHANGUP))
-                        return;
-                /* Answer the message */
-                answer_call(callid, res, &answer, answer_count);
+        }
+}
-/** Starts the module.
+ *
- * @return              EOK on success.
- * @return              Other error codes as defined for each specific module
- *                      start function.
- */
 int main(int argc, char *argv[])
+{
-        int rc;
         /* Start the module */
+        rc = il_module_start_standalone(il_client_connection);
+        return rc;
+        return il_module_start(SERVICE_ARP);
+}
 /** @}
  */

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

-              reaef141
+              r80cd7cd
         measured_string_t *addr;
         /** Actual device hardware address data. */
         char *addr_data;
+        uint8_t *addr_data;
         /** Broadcast device hardware address. */
         measured_string_t *broadcast_addr;
         /** Broadcast device hardware address data. */
         char *broadcast_data;
+        uint8_t *broadcast_data;
         /** Device identifier. */
         device_id_t device_id;
 …
         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;
 …
         measured_string_t *addr;
         /** Actual device protocol address data. */
         char *addr_data;
+        uint8_t *addr_data;
         /** Address map. */
         arp_addr_t addresses;
 …
          * Hardware address for the translation. NULL denotes an incomplete
          * record with possible waiters.
          */
+         */
         measured_string_t *hw_addr;
         /** Condition variable used for waiting for completion of the record. */

uspace/srv/net/il/ip/Makefile

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

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

-              reaef141
+              r80cd7cd
  * @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 <icmp_client.h>
 #include <icmp_interface.h>
-#include <il_interface.h>
 #include <ip_client.h>
 #include <ip_interface.h>
 #include <ip_header.h>
 #include <net_interface.h>
 #include <nil_interface.h>
 #include <tl_interface.h>
+#include <nil_remote.h>
+#include <tl_remote.h>
 #include <packet_remote.h>
+#include <il_local.h>
+#include <il_remote.h>
+#include <il_skel.h>
 /** IP module name. */
 …
 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))
+                            {
 …
         ip_netif->phone = nil_bind_service(ip_netif->service,
             (sysarg_t) ip_netif->device_id, SERVICE_IP,
             ip_globals.client_connection);
+            ip_receiver);
         if (ip_netif->phone < 0) {
                 printf("Failed to contact the nil service %d\n",
 …
         if (ip_netif->arp) {
                 if (route) {
                         address.value = (char *) &route->address.s_addr;
+                        address.value = (uint8_t *) &route->address.s_addr;
                         address.length = sizeof(in_addr_t);
 …
                 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;
 …
  *                      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;
+                    (uint8_t *) &route->gateway.s_addr : (uint8_t *) &dest.s_addr;
                 destination.length = sizeof(dest.s_addr);
 …
+}
+/** 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.value = (uint8_t *) &header->destination_address;
                         address.length = sizeof(header->destination_address);
                         arp_clear_address_req(netif->arp->phone,
 …
+}
-/** 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;
 …
         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:
 …
                         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_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
-                    (res == EHANGUP)) {
-                        return;
+                }
-                /* Answer the message */
-                answer_call(callid, res, &answer, answer_count);
+        }
+}
-/** Starts the module.
+ *
- * @return EOK on success.
- * @return Other error codes as defined for each specific module start function.
- */
 int main(int argc, char *argv[])
+{
-        int rc;
         /* Start the module */
+        rc = il_module_start_standalone(il_client_connection);
+        return rc;
+        return il_module_start(SERVICE_IP);
+}

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

reaef141	r80cd7cd
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

-              reaef141
+              r80cd7cd
 #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;
 …
                 return rc;
         rc = net_initialize(client_connection);
         if (rc != EOK)
 …
  */
 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;
 …
         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);
 …
 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

-              reaef141
+              r80cd7cd
  */
 #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

-              reaef141
+              r80cd7cd
         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/lo.c

-              reaef141
+              r80cd7cd
 #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);
 …
+{
         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, uintptr_t io)
+{
+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_IMETHOD(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

-              reaef141
+              r80cd7cd
 SOURCES = \
+        eth.c \
+        eth_module.c
+        eth.c
 include $(USPACE_PREFIX)/Makefile.common

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

-              reaef141
+              r80cd7cd
 #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", ETH_ADDR);
+            measured_string_create_bulk((uint8_t *) "\xFF\xFF\xFF\xFF\xFF\xFF", ETH_ADDR);
         if (!eth_globals.broadcast_addr) {
                 rc = ENOMEM;
 …
                 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_GET_DEVICE(*icall), packet, 0);
                         ipc_answer_0(iid, (sysarg_t) rc);
                         break;
 …
         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;
 …
         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_IMETHOD(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

-              reaef141
+              r80cd7cd
 #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

-              reaef141
+              r80cd7cd
 SOURCES = \
+        nildummy.c \
+        nildummy_module.c
+        nildummy.c
 include $(USPACE_PREFIX)/Makefile.common

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

-              reaef141
+              r80cd7cd
 #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_IMETHOD(*icall)) {
                 case NET_NIL_DEVICE_STATE:
                         rc = nil_device_state_msg_local(0,
                             IPC_GET_DEVICE(icall), IPC_GET_STATE(icall));
+                            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_GET_DEVICE(*icall), packet, 0);
                         ipc_answer_0(iid, (sysarg_t) rc);
                         break;
 …
  * 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;
 …
         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_IMETHOD(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

-              reaef141
+              r80cd7cd
 /** 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

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

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

-              reaef141
+              r80cd7cd
  * @see icmp.h
  */
-#include "icmp.h"
-#include "icmp_module.h"
 #include <async.h>
 …
 #include <icmp_client.h>
 #include <icmp_interface.h>
 #include <il_interface.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>
+#include "icmp.h"
 /** ICMP module name. */
 #define NAME    "ICMP protocol"
+#define NAME  "icmp"
 /** Default ICMP error reporting. */
 …
+}
-/** 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.
+ *
 …
         icmp_code_t code;
         int rc;
         switch (error) {
         case SERVICE_NONE:
 …
+}
+/** 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)
+{
+        packet_t *packet;
+        int rc;
+        while (true) {
+                switch (IPC_GET_IMETHOD(*icall)) {
+                case NET_TL_RECEIVED:
+                        rc = packet_translate_remote(icmp_globals.net_phone, &packet,
+                            IPC_GET_PACKET(*icall));
+                        if (rc == EOK)
+                                rc = icmp_received_msg_local(IPC_GET_DEVICE(*icall), packet,
+                                    SERVICE_ICMP, 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 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;
+        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.net_phone = net_phone;
+        icmp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_ICMP,
+            SERVICE_ICMP, icmp_receiver);
+        if (icmp_globals.ip_phone < 0) {
+                fibril_rwlock_write_unlock(&icmp_globals.lock);
+                return icmp_globals.ip_phone;
+        }
+        int 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;
+}
 /** Processes the generic client messages.
+ *
 …
         case NET_ICMP_DEST_UNREACH:
                 rc = packet_translate_remote(icmp_globals.net_phone, &packet,
                     IPC_GET_PACKET(call));
+                    IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
                 return icmp_destination_unreachable_msg_local(0,
                     ICMP_GET_CODE(call), ICMP_GET_MTU(call), packet);
+                    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));
+                    IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
 …
         case NET_ICMP_TIME_EXCEEDED:
                 rc = packet_translate_remote(icmp_globals.net_phone, &packet,
                     IPC_GET_PACKET(call));
+                    IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
                 return icmp_time_exceeded_msg_local(0, ICMP_GET_CODE(call),
+                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));
+                    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);
+                return icmp_parameter_problem_msg_local(0, ICMP_GET_CODE(*call),
+                    ICMP_GET_POINTER(*call), packet);
         default:
                 return ENOTSUP;
 …
         bool keep_on_going = true;
         ipc_call_t answer;
         int answer_count;
+        size_t answer_count;
         size_t length;
         struct sockaddr *addr;
 …
  * @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;
+int tl_module_message   (ipc_callid_t callid, ipc_call_t *call,
+    ipc_call_t *answer, size_t *answer_count)
+{
         *answer_count = 0;
         switch (IPC_GET_IMETHOD(*call)) {
-        case NET_TL_RECEIVED:
-                rc = packet_translate_remote(icmp_globals.net_phone, &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);
+                return icmp_process_client_messages(callid, *call);
         default:
                 return icmp_process_message(call);
+        }
         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_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
-                    (res == EHANGUP))
-                        return;
-                /* Answer the message */
-                answer_call(callid, res, &answer, answer_count);
+        }
+}
-/** Starts the module.
+ *
- * @return              EOK on success.
- * @return              Other error codes as defined for each specific module
- *                      start function.
- */
 int main(int argc, char *argv[])
+{
-        int rc;
         /* Start the module */
+        rc = tl_module_start_standalone(tl_client_connection);
+        return rc;
+        return tl_module_start(SERVICE_ICMP);
+}
 /** @}
  */

uspace/srv/net/tl/tcp/Makefile

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

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

-              reaef141
+              r80cd7cd
  */
-#include "tcp.h"
-#include "tcp_header.h"
-#include "tcp_module.h"
 #include <assert.h>
 #include <async.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. */
 …
 /** 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);
+        }
 …
         /* 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,
 …
  * @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_module_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_IMETHOD(*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;
         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;
 …
         /* 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;
 …
+}
 /** 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_IMETHOD(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(SERVICE_ICMP,
+            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

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

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

-              reaef141
+              r80cd7cd
  * @see udp.h
  */
-#include "udp.h"
-#include "udp_header.h"
-#include "udp_module.h"
 #include <async.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,
 …
+}
+/** 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(SERVICE_ICMP,
+            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;
+}
 /** Sends data from the socket to the remote address.
+ *
 …
         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;
 …
  * @see IS_NET_UDP_MESSAGE()
  */
 int udp_message_standalone(ipc_callid_t callid, ipc_call_t *call,
     ipc_call_t *answer, int *answer_count)
+int tl_module_message(ipc_callid_t callid, ipc_call_t *call,
+    ipc_call_t *answer, size_t *answer_count)
+{
-        packet_t *packet;
-        int rc;
         *answer_count = 0;
         switch (IPC_GET_IMETHOD(*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));
         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_IMETHOD(call) == IPC_M_PHONE_HUNGUP) ||
-                    (res == EHANGUP))
-                        return;
-                /* Answer the message */
-                answer_call(callid, res, &answer, answer_count);
+        }
+}
-/** Starts the module.
+ *
- * @return              EOK on success.
- * @return              Other error codes as defined for each specific module
- *                      start function.
- */
 int main(int argc, char *argv[])
+{
-        int rc;
         /* Start the module */
+        rc = tl_module_start_standalone(tl_client_connection);
+        return rc;
+        return tl_module_start(SERVICE_UDP);
+}

Context Navigation

Changeset 80cd7cd 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/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: