Changes in uspace/srv/net/il/ip/ip.c [fd8e8e1:ccca251] in mainline

File:

• uspace/srv/net/il/ip/ip.c (modified) (67 diffs)

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

@@ -36 +36 @@
  */
 
-#include "ip.h"
-#include "ip_module.h"
-
 #include <async.h>
 #include <errno.h>
-#include <err.h>
 #include <fibril_synch.h>
 #include <stdio.h>
 #include <str.h>
-#include <ipc/ipc.h>
 #include <ipc/services.h>
 #include <ipc/net.h>
@@ -53 +48 @@
 #include <sys/types.h>
 #include <byteorder.h>
+#include "ip.h"
 
 #include <adt/measured_strings.h>
@@ -70 +66 @@
 #include <net_checksum.h>
 #include <icmp_client.h>
-#include <icmp_interface.h>
-#include <il_interface.h>
+#include <icmp_remote.h>
 #include <ip_client.h>
 #include <ip_interface.h>
 #include <ip_header.h>
 #include <net_interface.h>
-#include <nil_interface.h>
-#include <tl_interface.h>
+#include <nil_remote.h>
+#include <tl_remote.h>
 #include <packet_remote.h>
-#include <il_local.h>
+#include <il_remote.h>
+#include <il_skel.h>
 
 /** IP module name. */
@@ -124 +120 @@
 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.
  *
@@ -130 +128 @@
  * @return              The result parameter.
  */
-static int ip_release_and_return(packet_t packet, int result)
+static int ip_release_and_return(packet_t *packet, int result)
 {
         pq_release_remote(ip_globals.net_phone, packet_get_id(packet));
@@ -140 +138 @@
  * Searches the registered protocols.
  *
- * @returns             The found ICMP phone.
- * @returns             ENOENT if the ICMP is not registered.
+ * @return              The found ICMP phone.
+ * @return              ENOENT if the ICMP is not registered.
  */
 static int ip_get_icmp_phone(void)
 {
-        ip_proto_ref proto;
+        ip_proto_t *proto;
         int phone;
 
@@ -161 +159 @@
  * @param[in] packet    The packet or the packet queue to be reported as faulty.
  * @param[in] header    The first packet IP header. May be NULL.
- * @returns             EOK on success.
- * @returns             EINVAL if there are no data in the packet.
- * @returns             EINVAL if the packet is a fragment.
- * @returns             ENOMEM if the packet is too short to contain the IP
+ * @return              EOK on success.
+ * @return              EINVAL if there are no data in the packet.
+ * @return              EINVAL if the packet is a fragment.
+ * @return              ENOMEM if the packet is too short to contain the IP
  *                      header.
- * @returns             EAFNOSUPPORT if the address family is not supported.
- * @returns             EPERM if the protocol is not allowed to send ICMP
+ * @return              EAFNOSUPPORT if the address family is not supported.
+ * @return              EPERM if the protocol is not allowed to send ICMP
  *                      notifications. The ICMP protocol itself.
- * @returns             Other error codes as defined for the packet_set_addr().
- */
-static int ip_prepare_icmp(packet_t packet, ip_header_ref header)
-{
-        packet_t next;
+ * @return              Other error codes as defined for the packet_set_addr().
+ */
+static int ip_prepare_icmp(packet_t *packet, ip_header_t *header)
+{
+        packet_t *next;
         struct sockaddr *dest;
         struct sockaddr_in dest_in;
         socklen_t addrlen;
 
-        // detach the first packet and release the others
+        /* Detach the first packet and release the others */
         next = pq_detach(packet);
         if (next)
@@ -187 +185 @@
                         return ENOMEM;
 
-                // get header
-                header = (ip_header_ref) packet_get_data(packet);
+                /* Get header */
+                header = (ip_header_t *) packet_get_data(packet);
                 if (!header)
                         return EINVAL;
@@ -194 +192 @@
         }
 
-        // only for the first fragment
+        /* Only for the first fragment */
         if (IP_FRAGMENT_OFFSET(header))
                 return EINVAL;
 
-        // not for the ICMP protocol
+        /* Not for the ICMP protocol */
         if (header->protocol == IPPROTO_ICMP)
                 return EPERM;
 
-        // set the destination address
+        /* Set the destination address */
         switch (header->version) {
         case IPVERSION:
@@ -228 +226 @@
  * @param[in] packet    The packet or the packet queue to be reported as faulty.
  * @param[in] header    The first packet IP header. May be NULL.
- * @returns             The found ICMP phone.
- * @returns             EINVAL if the error parameter is set.
- * @returns             EINVAL if the ICMP phone is not found.
- * @returns             EINVAL if the ip_prepare_icmp() fails.
+ * @return              The found ICMP phone.
+ * @return              EINVAL if the error parameter is set.
+ * @return              EINVAL if the ICMP phone is not found.
+ * @return              EINVAL if the ip_prepare_icmp() fails.
  */
 static int
-ip_prepare_icmp_and_get_phone(services_t error, packet_t packet,
-    ip_header_ref header)
+ip_prepare_icmp_and_get_phone(services_t error, packet_t *packet,
+    ip_header_t *header)
 {
         int phone;
@@ -245 +243 @@
 }
 
-/** Initializes the IP module.
- *
- * @param[in] client_connection The client connection processing function. The
- *                      module skeleton propagates its own one.
- * @returns             EOK on success.
- * @returns             ENOMEM if there is not enough memory left.
- */
-int ip_initialize(async_client_conn_t client_connection)
-{
-        ERROR_DECLARE;
-
+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;
@@ -265 +256 @@
         ip_globals.gateway.gateway.s_addr = 0;
         ip_globals.gateway.netif = NULL;
-        ERROR_PROPAGATE(ip_netifs_initialize(&ip_globals.netifs));
-        ERROR_PROPAGATE(ip_protos_initialize(&ip_globals.protos));
-        ip_globals.client_connection = client_connection;
-        ERROR_PROPAGATE(modules_initialize(&ip_globals.modules));
-        ERROR_PROPAGATE(add_module(NULL, &ip_globals.modules, ARP_NAME,
-            ARP_FILENAME, SERVICE_ARP, 0, arp_connect_module));
+        
+        int rc = ip_netifs_initialize(&ip_globals.netifs);
+        if (rc != EOK)
+                goto out;
+        rc = ip_protos_initialize(&ip_globals.protos);
+        if (rc != EOK)
+                goto out;
+        rc = modules_initialize(&ip_globals.modules);
+        if (rc != EOK)
+                goto out;
+        rc = add_module(NULL, &ip_globals.modules, (uint8_t *) ARP_NAME,
+            (uint8_t *) ARP_FILENAME, SERVICE_ARP, 0, arp_connect_module);
+
+out:
         fibril_rwlock_write_unlock(&ip_globals.lock);
 
-        return EOK;
+        return rc;
 }
 
@@ -285 +284 @@
  *
  * @param[in,out] ip_netif Network interface specific data.
- * @returns             EOK on success.
- * @returns             ENOTSUP if DHCP is configured.
- * @returns             ENOTSUP if IPv6 is configured.
- * @returns             EINVAL if any of the addresses is invalid.
- * @returns             EINVAL if the used ARP module is not known.
- * @returns             ENOMEM if there is not enough memory left.
- * @returns             Other error codes as defined for the
+ * @return              EOK on success.
+ * @return              ENOTSUP if DHCP is configured.
+ * @return              ENOTSUP if IPv6 is configured.
+ * @return              EINVAL if any of the addresses is invalid.
+ * @return              EINVAL if the used ARP module is not known.
+ * @return              ENOMEM if there is not enough memory left.
+ * @return              Other error codes as defined for the
  *                      net_get_device_conf_req() function.
- * @returns             Other error codes as defined for the bind_service()
+ * @return              Other error codes as defined for the bind_service()
  *                      function.
- * @returns             Other error codes as defined for the specific
+ * @return              Other error codes as defined for the specific
  *                      arp_device_req() function.
- * @returns             Other error codes as defined for the
+ * @return              Other error codes as defined for the
  *                      nil_packet_size_req() function.
  */
-static int ip_netif_initialize(ip_netif_ref ip_netif)
-{
-        ERROR_DECLARE;
-
+static int ip_netif_initialize(ip_netif_t *ip_netif)
+{
         measured_string_t names[] = {
                 {
-                        (char *) "IPV",
+                        (uint8_t *) "IPV",
                         3
                 },
                 {
-                        (char *) "IP_CONFIG",
+                        (uint8_t *) "IP_CONFIG",
                         9
                 },
                 {
-                        (char *) "IP_ADDR",
+                        (uint8_t *) "IP_ADDR",
                         7
                 },
                 {
-                        (char *) "IP_NETMASK",
+                        (uint8_t *) "IP_NETMASK",
                         10
                 },
                 {
-                        (char *) "IP_GATEWAY",
+                        (uint8_t *) "IP_GATEWAY",
                         10
                 },
                 {
-                        (char *) "IP_BROADCAST",
+                        (uint8_t *) "IP_BROADCAST",
                         12
                 },
                 {
-                        (char *) "ARP",
+                        (uint8_t *) "ARP",
                         3
                 },
                 {
-                        (char *) "IP_ROUTING",
+                        (uint8_t *) "IP_ROUTING",
                         10
                 }
         };
-        measured_string_ref configuration;
+        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;
+        in_addr_t gateway;
         int index;
-        ip_route_ref route;
-        in_addr_t gateway;
+        int rc;
 
         ip_netif->arp = NULL;
@@ -353 +351 @@
         configuration = &names[0];
 
-        // get configuration
-        ERROR_PROPAGATE(net_get_device_conf_req(ip_globals.net_phone,
-            ip_netif->device_id, &configuration, count, &data));
+        /* Get configuration */
+        rc = net_get_device_conf_req(ip_globals.net_phone, ip_netif->device_id,
+            &configuration, count, &data);
+        if (rc != EOK)
+                return rc;
+        
         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);
                 
@@ -368 +369 @@
                         return ENOTSUP;
                 } else if (ip_netif->ipv == IPV4) {
-                        route = (ip_route_ref) malloc(sizeof(ip_route_t));
+                        route = (ip_route_t *) malloc(sizeof(ip_route_t));
                         if (!route) {
                                 net_free_settings(configuration, data);
@@ -383 +384 @@
                                 return index;
                         }
-                        if (ERROR_OCCURRED(inet_pton(AF_INET,
-                            configuration[2].value,
-                            (uint8_t *) &route->address.s_addr)) ||
-                            ERROR_OCCURRED(inet_pton(AF_INET,
-                            configuration[3].value,
-                            (uint8_t *) &route->netmask.s_addr)) ||
-                            (inet_pton(AF_INET, configuration[4].value,
+                        
+                        if ((inet_pton(AF_INET, (char *) configuration[2].value,
+                            (uint8_t *) &route->address.s_addr) != EOK) ||
+                            (inet_pton(AF_INET, (char *) configuration[3].value,
+                            (uint8_t *) &route->netmask.s_addr) != EOK) ||
+                            (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))
                             {
@@ -419 +419 @@
         }
 
-        // binds the netif service which also initializes the device
+        /* Bind netif service which also initializes the device */
         ip_netif->phone = nil_bind_service(ip_netif->service,
-            (ipcarg_t) ip_netif->device_id, SERVICE_IP,
-            ip_globals.client_connection);
+            (sysarg_t) ip_netif->device_id, SERVICE_IP,
+            ip_receiver);
         if (ip_netif->phone < 0) {
                 printf("Failed to contact the nil service %d\n",
@@ -429 +429 @@
         }
 
-        // has to be after the device netif module initialization
+        /* Has to be after the device netif module initialization */
         if (ip_netif->arp) {
                 if (route) {
-                        address.value = (char *) &route->address.s_addr;
-                        address.length = CONVERT_SIZE(in_addr_t, char, 1);
-                        ERROR_PROPAGATE(arp_device_req(ip_netif->arp->phone,
+                        address.value = (uint8_t *) &route->address.s_addr;
+                        address.length = sizeof(in_addr_t);
+                        
+                        rc = arp_device_req(ip_netif->arp->phone,
                             ip_netif->device_id, SERVICE_IP, ip_netif->service,
-                            &address));
+                            &address);
+                        if (rc != EOK)
+                                return rc;
                 } else {
                         ip_netif->arp = 0;
@@ -442 +445 @@
         }
 
-        // get packet dimensions
-        ERROR_PROPAGATE(nil_packet_size_req(ip_netif->phone,
-            ip_netif->device_id, &ip_netif->packet_dimension));
+        /* Get packet dimensions */
+        rc = nil_packet_size_req(ip_netif->phone, ip_netif->device_id,
+            &ip_netif->packet_dimension);
+        if (rc != EOK)
+                return rc;
+        
         if (ip_netif->packet_dimension.content < IP_MIN_CONTENT) {
-                printf("Maximum transmission unit %d bytes is too small, at "
+                printf("Maximum transmission unit %zu bytes is too small, at "
                     "least %d bytes are needed\n",
                     ip_netif->packet_dimension.content, IP_MIN_CONTENT);
@@ -457 +463 @@
         
         if (gateway.s_addr) {
-                // the default gateway
+                /* The default gateway */
                 ip_globals.gateway.address.s_addr = 0;
                 ip_globals.gateway.netmask.s_addr = 0;
                 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);
         }
 
@@ -467 +478 @@
 }
 
-/** Updates the device content length according to the new MTU value.
- *
- * @param[in] device_id The device identifier.
- * @param[in] mtu       The new mtu value.
- * @returns             EOK on success.
- * @returns             ENOENT if device is not found.
- */
-static int ip_mtu_changed_message(device_id_t device_id, size_t mtu)
-{
-        ip_netif_ref netif;
+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);
-        netif = ip_netifs_find(&ip_globals.netifs, device_id);
-        if (!netif) {
+
+        rc = ip_netif_initialize(ip_netif);
+        if (rc != EOK) {
                 fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
-                return ENOENT;
-        }
-        netif->packet_dimension.content = mtu;
+                ip_routes_destroy(&ip_netif->routes, free);
+                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: Device %d changed MTU to %d\n", NAME, device_id, mtu);
+        printf("%s: Broadcast (%s)\n", NAME, address);
 
         return EOK;
 }
 
-/** Updates the device state.
- *
- * @param[in] device_id The device identifier.
- * @param[in] state     The new state value.
- * @returns             EOK on success.
- * @returns             ENOENT if device is not found.
- */
-static int ip_device_state_message(device_id_t device_id, device_state_t state)
-{
-        ip_netif_ref 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.
- * @returns             The prefixed middle header.
- * @returns             NULL on error.
- */
-static ip_header_ref
-ip_create_middle_header(packet_t packet, ip_header_ref last)
-{
-        ip_header_ref middle;
-
-        middle = (ip_header_ref) packet_suffix(packet, IP_HEADER_LENGTH(last));
-        if (!middle)
+/** 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;
-        memcpy(middle, last, IP_HEADER_LENGTH(last));
-        middle->flags |= IPFLAG_MORE_FRAGMENTS;
-        return middle;
+        
+        /* 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;
 }
 
@@ -547 +623 @@
  * @param[in] first     The original header to be copied.
  */
-static void ip_create_last_header(ip_header_ref last, ip_header_ref first)
-{
-        ip_option_ref option;
+static void ip_create_last_header(ip_header_t *last, ip_header_t *first)
+{
+        ip_option_t *option;
         size_t next;
         size_t length;
 
-        // copy first itself
+        /* Copy first itself */
         memcpy(last, first, sizeof(ip_header_t));
         length = sizeof(ip_header_t);
         next = sizeof(ip_header_t);
 
-        // process all ip options
+        /* Process all IP options */
         while (next < first->header_length) {
-                option = (ip_option_ref) (((uint8_t *) first) + next);
-                // skip end or noop
+                option = (ip_option_t *) (((uint8_t *) first) + next);
+                /* Skip end or noop */
                 if ((option->type == IPOPT_END) ||
                     (option->type == IPOPT_NOOP)) {
                         next++;
                 } else {
-                        // copy if told so or skip
+                        /* Copy if told so or skip */
                         if (IPOPT_COPIED(option->type)) {
                                 memcpy(((uint8_t *) last) + length,
@@ -572 +648 @@
                                 length += option->length;
                         }
-                        // next option
+                        /* Next option */
                         next += option->length;
                 }
         }
 
-        // align 4 byte boundary
+        /* Align 4 byte boundary */
         if (length % 4) {
                 bzero(((uint8_t *) last) + length, 4 - (length % 4));
@@ -598 +674 @@
  * @param[in,out] packet The packet to be sent.
  * @param[in] destination The destination hardware address.
- * @returns             EOK on success.
- * @returns             EINVAL if the packet is too small to contain the IP
+ * @return              EOK on success.
+ * @return              EINVAL if the packet is too small to contain the IP
  *                      header.
- * @returns             EINVAL if the packet is too long than the IP allows.
- * @returns             ENOMEM if there is not enough memory left.
- * @returns             Other error codes as defined for the packet_set_addr()
+ * @return              EINVAL if the packet is too long than the IP allows.
+ * @return              ENOMEM if there is not enough memory left.
+ * @return              Other error codes as defined for the packet_set_addr()
  *                      function.
  */
-static int
-ip_prepare_packet(in_addr_t *source, in_addr_t dest, packet_t packet,
-    measured_string_ref destination)
-{
-        ERROR_DECLARE;
-
+static int ip_prepare_packet(in_addr_t *source, in_addr_t dest,
+    packet_t *packet, measured_string_t *destination)
+{
         size_t length;
-        ip_header_ref header;
-        ip_header_ref last_header;
-        ip_header_ref middle_header;
-        packet_t next;
+        ip_header_t *header;
+        ip_header_t *last_header;
+        ip_header_t *middle_header;
+        packet_t *next;
+        int rc;
 
         length = packet_get_data_length(packet);
@@ -622 +696 @@
                 return EINVAL;
 
-        header = (ip_header_ref) packet_get_data(packet);
+        header = (ip_header_t *) packet_get_data(packet);
         if (destination) {
-                ERROR_PROPAGATE(packet_set_addr(packet, NULL,
-                    (uint8_t *) destination->value,
-                    CONVERT_SIZE(char, uint8_t, destination->length)));
+                rc = packet_set_addr(packet, NULL, (uint8_t *) destination->value,
+                    destination->length);
         } else {
-                ERROR_PROPAGATE(packet_set_addr(packet, NULL, NULL, 0));
-        }
+                rc = packet_set_addr(packet, NULL, NULL, 0);
+        }
+        if (rc != EOK)
+                return rc;
+        
         header->version = IPV4;
         header->fragment_offset_high = 0;
@@ -644 +720 @@
 
         if (pq_next(packet)) {
-                last_header = (ip_header_ref) malloc(IP_HEADER_LENGTH(header));
+                last_header = (ip_header_t *) malloc(IP_HEADER_LENGTH(header));
                 if (!last_header)
                         return ENOMEM;
@@ -650 +726 @@
                 next = pq_next(packet);
                 while (pq_next(next)) {
-                        middle_header = (ip_header_ref) packet_prefix(next,
+                        middle_header = (ip_header_t *) packet_prefix(next,
                             IP_HEADER_LENGTH(last_header));
                         if (!middle_header) {
@@ -669 +745 @@
                             IP_HEADER_CHECKSUM(middle_header);
                         if (destination) {
-                                if (ERROR_OCCURRED(packet_set_addr(next, NULL,
+                                rc = packet_set_addr(next, NULL,
                                     (uint8_t *) destination->value,
-                                    CONVERT_SIZE(char, uint8_t,
-                                    destination->length)))) {
+                                    destination->length);
+                                if (rc != EOK) {
                                         free(last_header);
-                                        return ERROR_CODE;
+                                        return rc;
                                 }
                         }
@@ -681 +757 @@
                 }
 
-                middle_header = (ip_header_ref) packet_prefix(next,
+                middle_header = (ip_header_t *) packet_prefix(next,
                     IP_HEADER_LENGTH(last_header));
                 if (!middle_header) {
@@ -699 +775 @@
                     IP_HEADER_CHECKSUM(middle_header);
                 if (destination) {
-                        if (ERROR_OCCURRED(packet_set_addr(next, NULL,
+                        rc = packet_set_addr(next, NULL,
                             (uint8_t *) destination->value,
-                            CONVERT_SIZE(char, uint8_t,
-                            destination->length)))) {
+                            destination->length);
+                        if (rc != EOK) {
                                 free(last_header);
-                                return ERROR_CODE;
-                            }
+                                return rc;
+                        }
                 }
                 length += packet_get_data_length(next);
@@ -713 +789 @@
 
         header->total_length = htons(length);
-        // unnecessary for all protocols
+        /* Unnecessary for all protocols */
         header->header_checksum = IP_HEADER_CHECKSUM(header);
 
@@ -729 +805 @@
  * @param[in] dest      The destiantion address.
  * @param[in] addrlen   The address length.
- * @returns             EOK on success.
- * @returns             ENOMEM if the target packet is too small.
- * @returns             Other error codes as defined for the packet_set_addr()
+ * @return              EOK on success.
+ * @return              ENOMEM if the target packet is too small.
+ * @return              Other error codes as defined for the packet_set_addr()
  *                      function.
- * @returns             Other error codes as defined for the pq_insert_after()
+ * @return              Other error codes as defined for the pq_insert_after()
  *                      function.
  */
-static int
-ip_fragment_packet_data(packet_t packet, packet_t new_packet,
-    ip_header_ref header, ip_header_ref new_header, size_t length,
+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)
 {
-        ERROR_DECLARE;
-
         void *data;
         size_t offset;
+        int rc;
 
         data = packet_suffix(new_packet, length);
@@ -752 +826 @@
         memcpy(data, ((void *) header) + IP_TOTAL_LENGTH(header) - length,
             length);
-        ERROR_PROPAGATE(packet_trim(packet, 0, length));
+        
+        rc = packet_trim(packet, 0, length);
+        if (rc != EOK)
+                return rc;
+        
         header->total_length = htons(IP_TOTAL_LENGTH(header) - length);
         new_header->total_length = htons(IP_HEADER_LENGTH(new_header) + length);
@@ -761 +839 @@
             IP_COMPUTE_FRAGMENT_OFFSET_LOW(offset);
         new_header->header_checksum = IP_HEADER_CHECKSUM(new_header);
-        ERROR_PROPAGATE(packet_set_addr(new_packet, (const uint8_t *) src,
-            (const uint8_t *) dest, addrlen));
+        
+        rc = packet_set_addr(new_packet, (const uint8_t *) src,
+            (const uint8_t *) dest, addrlen);
+        if (rc != EOK)
+                return rc;
 
         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;
 }
 
@@ -776 +878 @@
  * @param[in] suffix    The minimum suffix size.
  * @param[in] addr_len  The minimum address length.
- * @returns             EOK on success.
- * @returns             EINVAL if the packet_get_addr() function fails.
- * @returns             EINVAL if the packet does not contain the IP header.
- * @returns             EPERM if the packet needs to be fragmented and the
+ * @return              EOK on success.
+ * @return              EINVAL if the packet_get_addr() function fails.
+ * @return              EINVAL if the packet does not contain the IP header.
+ * @return              EPERM if the packet needs to be fragmented and the
  *                      fragmentation is not allowed.
- * @returns             ENOMEM if there is not enough memory left.
- * @returns             ENOMEM if there is no packet available.
- * @returns             ENOMEM if the packet is too small to contain the IP
+ * @return              ENOMEM if there is not enough memory left.
+ * @return              ENOMEM if there is no packet available.
+ * @return              ENOMEM if the packet is too small to contain the IP
  *                      header.
- * @returns             Other error codes as defined for the packet_trim()
+ * @return              Other error codes as defined for the packet_trim()
  *                      function.
- * @returns             Other error codes as defined for the
+ * @return              Other error codes as defined for the
  *                      ip_create_middle_header() function.
- * @returns             Other error codes as defined for the
+ * @return              Other error codes as defined for the
  *                      ip_fragment_packet_data() function.
  */
 static int
-ip_fragment_packet(packet_t packet, size_t length, size_t prefix, size_t suffix,
+ip_fragment_packet(packet_t *packet, size_t length, size_t prefix, size_t suffix,
     socklen_t addr_len)
 {
-        ERROR_DECLARE;
-
-        packet_t new_packet;
-        ip_header_ref header;
-        ip_header_ref middle_header;
-        ip_header_ref last_header;
+        packet_t *new_packet;
+        ip_header_t *header;
+        ip_header_t *middle_header;
+        ip_header_t *last_header;
         struct sockaddr *src;
         struct sockaddr *dest;
         socklen_t addrlen;
         int result;
+        int rc;
 
         result = packet_get_addr(packet, (uint8_t **) &src, (uint8_t **) &dest);
@@ -815 +916 @@
                 return ENOMEM;
 
-        // get header
-        header = (ip_header_ref) packet_get_data(packet);
+        /* Get header */
+        header = (ip_header_t *) packet_get_data(packet);
         if (!header)
                 return EINVAL;
 
-        // fragmentation forbidden?
+        /* Fragmentation forbidden? */
         if(header->flags & IPFLAG_DONT_FRAGMENT)
                 return EPERM;
 
-        // create the last fragment
+        /* Create the last fragment */
         new_packet = packet_get_4_remote(ip_globals.net_phone, prefix, length,
             suffix, ((addrlen > addr_len) ? addrlen : addr_len));
@@ -830 +931 @@
                 return ENOMEM;
 
-        // allocate as much as originally
-        last_header = (ip_header_ref) packet_suffix(new_packet,
+        /* Allocate as much as originally */
+        last_header = (ip_header_t *) packet_suffix(new_packet,
             IP_HEADER_LENGTH(header));
         if (!last_header)
@@ -838 +939 @@
         ip_create_last_header(last_header, header);
 
-        // trim the unused space
-        if (ERROR_OCCURRED(packet_trim(new_packet, 0,
-            IP_HEADER_LENGTH(header) - IP_HEADER_LENGTH(last_header)))) {
-                return ip_release_and_return(packet, ERROR_CODE);
-        }
-
-        // biggest multiple of 8 lower than content
+        /* Trim the unused space */
+        rc = packet_trim(new_packet, 0,
+            IP_HEADER_LENGTH(header) - IP_HEADER_LENGTH(last_header));
+        if (rc != EOK)
+                return ip_release_and_return(packet, rc);
+
+        /* Greatest multiple of 8 lower than content */
         // TODO even fragmentation?
         length = length & ~0x7;
-        if (ERROR_OCCURRED(ip_fragment_packet_data(packet, new_packet, header,
-            last_header,
+        
+        rc = ip_fragment_packet_data(packet, new_packet, header, last_header,
             ((IP_HEADER_DATA_LENGTH(header) -
             ((length - IP_HEADER_LENGTH(header)) & ~0x7)) %
-            ((length - IP_HEADER_LENGTH(last_header)) & ~0x7)), src, dest,
-            addrlen))) {
-                return ip_release_and_return(packet, ERROR_CODE);
-        }
-
-        // mark the first as fragmented
+            ((length - IP_HEADER_LENGTH(last_header)) & ~0x7)),
+            src, dest, addrlen);
+        if (rc != EOK)
+                return ip_release_and_return(packet, rc);
+
+        /* Mark the first as fragmented */
         header->flags |= IPFLAG_MORE_FRAGMENTS;
 
-        // create middle framgents
+        /* Create middle fragments */
         while (IP_TOTAL_LENGTH(header) > length) {
                 new_packet = packet_get_4_remote(ip_globals.net_phone, prefix,
@@ -872 +973 @@
                         return ip_release_and_return(packet, ENOMEM);
 
-                if (ERROR_OCCURRED(ip_fragment_packet_data(packet, new_packet,
-                    header, middle_header,
-                    (length - IP_HEADER_LENGTH(middle_header)) & ~0x7, src,
-                    dest, addrlen))) {
-                        return ip_release_and_return(packet, ERROR_CODE);
-                }
-        }
-
-        // finish the first fragment
+                rc = ip_fragment_packet_data(packet, new_packet, header,
+                    middle_header,
+                    (length - IP_HEADER_LENGTH(middle_header)) & ~0x7,
+                    src, dest, addrlen);
+                if (rc != EOK)
+                        return ip_release_and_return(packet, rc);
+        }
+
+        /* Finish the first fragment */
         header->header_checksum = IP_HEADER_CHECKSUM(header);
 
@@ -897 +998 @@
  * @param[in] addr_len  The minimum address length.
  * @param[in] error     The error module service.
- * @returns             The packet or the packet queue of the allowed length.
- * @returns             NULL if there are no packets left.
- */
-static packet_t
-ip_split_packet(packet_t packet, size_t prefix, size_t content, size_t suffix,
+ * @return              The packet or the packet queue of the allowed length.
+ * @return              NULL if there are no packets left.
+ */
+static packet_t *
+ip_split_packet(packet_t *packet, size_t prefix, size_t content, size_t suffix,
     socklen_t addr_len, services_t error)
 {
         size_t length;
-        packet_t next;
-        packet_t new_packet;
+        packet_t *next;
+        packet_t *new_packet;
         int result;
         int phone;
 
         next = packet;
-        // check all packets
+        /* Check all packets */
         while (next) {
                 length = packet_get_data_length(next);
@@ -920 +1021 @@
                 }
 
-                // too long
+                /* Too long */
                 result = ip_fragment_packet(next, content, prefix,
                     suffix, addr_len);
@@ -926 +1027 @@
                         new_packet = pq_detach(next);
                         if (next == packet) {
-                                // the new first packet of the queue
+                                /* The new first packet of the queue */
                                 packet = new_packet;
                         }
-                        // fragmentation needed?
+                        /* Fragmentation needed? */
                         if (result == EPERM) {
                                 phone = ip_prepare_icmp_and_get_phone(
                                     error, next, NULL);
                                 if (phone >= 0) {
-                                        // fragmentation necessary ICMP
+                                        /* Fragmentation necessary ICMP */
                                         icmp_destination_unreachable_msg(phone,
                                             ICMP_FRAG_NEEDED, content, next);
@@ -964 +1065 @@
  * @param[in] dest      The destination address.
  * @param[in] error     The error module service.
- * @returns             EOK on success.
- * @returns             Other error codes as defined for the arp_translate_req()
+ * @return              EOK on success.
+ * @return              Other error codes as defined for the arp_translate_req()
  *                      function.
- * @returns             Other error codes as defined for the ip_prepare_packet()
+ * @return              Other error codes as defined for the ip_prepare_packet()
  *                      function.
  */
-static int
-ip_send_route(packet_t packet, ip_netif_ref netif, ip_route_ref route,
-    in_addr_t *src, in_addr_t dest, services_t error)
-{
-        ERROR_DECLARE;
-
+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_ref translation;
-        char *data;
+        measured_string_t *translation;
+        uint8_t *data;
         int phone;
-
-        // get destination hardware address
+        int rc;
+
+        /* Get destination hardware address */
         if (netif->arp && (route->address.s_addr != dest.s_addr)) {
                 destination.value = route->gateway.s_addr ?
-                    (char *) &route->gateway.s_addr : (char *) &dest.s_addr;
-                destination.length = CONVERT_SIZE(dest.s_addr, char, 1);
-
-                if (ERROR_OCCURRED(arp_translate_req(netif->arp->phone,
-                    netif->device_id, SERVICE_IP, &destination, &translation,
-                    &data))) {
+                    (uint8_t *) &route->gateway.s_addr : (uint8_t *) &dest.s_addr;
+                destination.length = sizeof(dest.s_addr);
+
+                rc = arp_translate_req(netif->arp->phone, netif->device_id,
+                    SERVICE_IP, &destination, &translation, &data);
+                if (rc != EOK) {
                         pq_release_remote(ip_globals.net_phone,
                             packet_get_id(packet));
-                        return ERROR_CODE;
+                        return rc;
                 }
 
@@ -1003 +1102 @@
                             NULL);
                         if (phone >= 0) {
-                                // unreachable ICMP if no routing
+                                /* Unreachable ICMP if no routing */
                                 icmp_destination_unreachable_msg(phone,
                                     ICMP_HOST_UNREACH, 0, packet);
@@ -1014 +1113 @@
         }
 
-        if (ERROR_OCCURRED(ip_prepare_packet(src, dest, packet, translation))) {
+        rc = ip_prepare_packet(src, dest, packet, translation);
+        if (rc != EOK) {
                 pq_release_remote(ip_globals.net_phone, packet_get_id(packet));
         } else {
@@ -1032 +1132 @@
         }
 
-        return ERROR_CODE;
-}
-
-/** 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.
- * @returns             The found route.
- * @returns             NULL if no route was found.
- */
-static ip_route_ref
-ip_netif_find_route(ip_netif_ref netif, in_addr_t destination)
-{
-        int index;
-        ip_route_ref 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.
- * @returns             The found route.
- * @returns             NULL if no route was found.
- */
-static ip_route_ref ip_find_route(in_addr_t destination) {
-        int index;
-        ip_route_ref route;
-        ip_netif_ref 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.
- * @returns             The IP address.
- * @returns             NULL if no IP address was found.
- */
-static in_addr_t *ip_netif_address(ip_netif_ref netif)
-{
-        ip_route_ref 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.
- * @returns             EOK on success.
- * @returns             EINVAL if the protocol parameter and/or the service
- *                      parameter is zero.
- * @returns             EINVAL if the phone parameter is not a positive number
- *                      and the tl_receive_msg is NULL.
- * @returns             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_ref proto;
-        int index;
-
-        if (!protocol || !service || ((phone < 0) && !received_msg))
-                return EINVAL;
-
-        proto = (ip_proto_ref) 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)
-{
-        ERROR_DECLARE;
-
-        ip_netif_ref ip_netif;
-        ip_route_ref route;
-        int index;
-
-        ip_netif = (ip_netif_ref) malloc(sizeof(ip_netif_t));
-        if (!ip_netif)
-                return ENOMEM;
-
-        if (ERROR_OCCURRED(ip_routes_initialize(&ip_netif->routes))) {
-                free(ip_netif);
-                return ERROR_CODE;
-        }
-
-        ip_netif->device_id = device_id;
-        ip_netif->service = netif;
-        ip_netif->state = NETIF_STOPPED;
-
-        fibril_rwlock_write_lock(&ip_globals.netifs_lock);
-        if (ERROR_OCCURRED(ip_netif_initialize(ip_netif))) {
-                fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
-                ip_routes_destroy(&ip_netif->routes);
-                free(ip_netif);
-                return ERROR_CODE;
-        }
-        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)
-{
-        ERROR_DECLARE;
-
+        return rc;
+}
+
+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;
-        ip_netif_ref netif;
-        ip_route_ref route;
+        ip_netif_t *netif;
+        ip_route_t *route;
         struct sockaddr *addr;
         struct sockaddr_in *address_in;
@@ -1236 +1146 @@
         in_addr_t *src;
         int phone;
-
-        // addresses in the host byte order
-        // should be the next hop address or the target destination address
+        int rc;
+
+        /*
+         * Addresses in the host byte order
+         * Should be the next hop address or the target destination address
+         */
         addrlen = packet_get_addr(packet, NULL, (uint8_t **) &addr);
         if (addrlen < 0)
@@ -1263 +1176 @@
         fibril_rwlock_read_lock(&ip_globals.netifs_lock);
 
-        // device specified?
+        /* Device specified? */
         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;
@@ -1279 +1192 @@
                 phone = ip_prepare_icmp_and_get_phone(error, packet, NULL);
                 if (phone >= 0) {
-                        // unreachable ICMP if no routing
+                        /* Unreachable ICMP if no routing */
                         icmp_destination_unreachable_msg(phone,
                             ICMP_NET_UNREACH, 0, packet);
@@ -1287 +1200 @@
 
         if (error) {
-                // do not send for broadcast, anycast packets or network
-                // broadcast
+                /*
+                 * Do not send for broadcast, anycast packets or network
+                 * broadcast.
+                 */
                 if (!dest->s_addr || !(~dest->s_addr) ||
                     !(~((dest->s_addr & ~route->netmask.s_addr) |
@@ -1296 +1211 @@
                 }
         }
-
-        // if the local host is the destination
+        
+        /* If the local host is the destination */
         if ((route->address.s_addr == dest->s_addr) &&
             (dest->s_addr != IPV4_LOCALHOST_ADDRESS)) {
-                // find the loopback device to deliver
+                /* Find the loopback device to deliver */
                 dest->s_addr = IPV4_LOCALHOST_ADDRESS;
                 route = ip_find_route(*dest);
@@ -1309 +1224 @@
                             NULL);
                         if (phone >= 0) {
-                                // unreachable ICMP if no routing
+                                /* Unreachable ICMP if no routing */
                                 icmp_destination_unreachable_msg(phone,
                                     ICMP_HOST_UNREACH, 0, packet);
@@ -1323 +1238 @@
         }
 
-        ERROR_CODE = ip_send_route(packet, netif, route, src, *dest, error);
+        rc = ip_send_route(packet, netif, route, src, *dest, error);
         fibril_rwlock_read_unlock(&ip_globals.netifs_lock);
 
-        return ERROR_CODE;
+        return rc;
+}
+
+/** 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 destination address */
+        switch (header->version) {
+        case IPVERSION:
+                addrlen = sizeof(addr_in);
+                bzero(&addr_in, addrlen);
+                addr_in.sin_family = AF_INET;
+                memcpy(&addr_in.sin_addr.s_addr, &dest, sizeof(dest));
+                addr = (struct sockaddr *) &addr_in;
+                break;
+
+        default:
+                return ip_release_and_return(packet, EAFNOSUPPORT);
+        }
+
+        rc = packet_set_addr(packet, NULL, (uint8_t *) &addr, addrlen);
+        if (rc != EOK)
+                return rc;
+        
+        route = ip_find_route(dest);
+        if (!route) {
+                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
+                if (phone >= 0) {
+                        /* Unreachable ICMP */
+                        icmp_destination_unreachable_msg(phone,
+                            ICMP_HOST_UNREACH, 0, packet);
+                }
+                return ENOENT;
+        }
+
+        if (route->address.s_addr == dest.s_addr) {
+                /* Local delivery */
+                return ip_deliver_local(device_id, packet, header, 0);
+        }
+
+        if (route->netif->routing) {
+                header->ttl--;
+                return ip_send_route(packet, route->netif, route, NULL, dest,
+                    0);
+        }
+
+        phone = ip_prepare_icmp_and_get_phone(0, packet, header);
+        if (phone >= 0) {
+                /* Unreachable ICMP if no routing */
+                icmp_destination_unreachable_msg(phone, ICMP_HOST_UNREACH, 0,
+                    packet);
+        }
+        
+        return ENOENT;
 }
 
@@ -1338 +1505 @@
  * @param[out] content  The maximum content size.
  * @param[out] suffix   The minimum reserved suffix size.
- * @returns             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)
-{
-        ip_netif_ref netif;
+ * @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)
+{
+        ip_netif_t *netif;
         int index;
 
@@ -1392 +1558 @@
 }
 
-/** Returns the packet destination address from the IP header.
- *
- * @param[in] header    The packet IP header to be read.
- * @returns             The packet destination address.
- */
-static in_addr_t ip_get_destination(ip_header_ref 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.
- * @returns             EOK on success.
- * @returns             ENOTSUP if the packet is a fragment.
- * @returns             EAFNOSUPPORT if the address family is not supported.
- * @returns             ENOENT if the target protocol is not found.
- * @returns             Other error codes as defined for the packet_set_addr()
- *                      function.
- * @returns             Other error codes as defined for the packet_trim()
- *                      function.
- * @returns             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_ref header,
-    services_t error)
-{
-        ERROR_DECLARE;
-
-        ip_proto_ref 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;
-
-        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);
-        }
-
-        if (ERROR_OCCURRED(packet_set_addr(packet, (uint8_t *) src,
-            (uint8_t *) dest, addrlen))) {
-                return ip_release_and_return(packet, ERROR_CODE);
-        }
-
-        // trim padding if present
-        if (!error &&
-            (IP_TOTAL_LENGTH(header) < packet_get_data_length(packet))) {
-                if (ERROR_OCCURRED(packet_trim(packet, 0,
-                    packet_get_data_length(packet) - IP_TOTAL_LENGTH(header))))
-                        return ip_release_and_return(packet, ERROR_CODE);
-        }
-
-        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);
-                ERROR_CODE = received_msg(device_id, packet, service, error);
-        } else {
-                ERROR_CODE = tl_received_msg(proto->phone, device_id, packet,
-                    proto->service, error);
-                fibril_rwlock_read_unlock(&ip_globals.protos_lock);
-        }
-
-        return ERROR_CODE;
-}
-
-/** 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.
- * @returns             EOK on success.
- * @returns             EINVAL if the TTL is less than two.
- * @returns             EINVAL if the checksum is invalid.
- * @returns             EAFNOSUPPORT if the address family is not supported.
- * @returns             ENOENT if no route was found.
- * @returns             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)
-{
-        ERROR_DECLARE;
-
-        ip_header_ref header;
-        in_addr_t dest;
-        ip_route_ref route;
-        int phone;
-        struct sockaddr *addr;
-        struct sockaddr_in addr_in;
-        socklen_t addrlen;
-
-        header = (ip_header_ref) 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);
-        }
-
-        ERROR_PROPAGATE(packet_set_addr(packet, NULL, (uint8_t *) &addr,
-            addrlen));
-
-        route = ip_find_route(dest);
-        if (!route) {
-                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
-                if (phone >= 0) {
-                        // unreachable ICMP
-                        icmp_destination_unreachable_msg(phone,
-                            ICMP_HOST_UNREACH, 0, packet);
-                }
-                return ENOENT;
-        }
-
-        if (route->address.s_addr == dest.s_addr) {
-                // local delivery
-                return ip_deliver_local(device_id, packet, header, 0);
-        }
-
-        if (route->netif->routing) {
-                header->ttl--;
-                return ip_send_route(packet, route->netif, route, NULL, dest,
-                    0);
-        }
-
-        phone = ip_prepare_icmp_and_get_phone(0, packet, header);
-        if (phone >= 0) {
-                // unreachable ICMP if no routing
-                icmp_destination_unreachable_msg(phone, ICMP_HOST_UNREACH, 0,
-                    packet);
-        }
-        
-        return ENOENT;
-}
-
-static int
-ip_add_route_req_local(int ip_phone, device_id_t device_id, in_addr_t address,
-    in_addr_t netmask, in_addr_t gateway)
-{
-        ip_route_ref route;
-        ip_netif_ref netif;
-        int index;
+/** 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)
+{
+        ip_netif_t *netif;
 
         fibril_rwlock_write_lock(&ip_globals.netifs_lock);
-
         netif = ip_netifs_find(&ip_globals.netifs, device_id);
         if (!netif) {
@@ -1635 +1575 @@
                 return ENOENT;
         }
-
-        route = (ip_route_ref) malloc(sizeof(ip_route_t));
+        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));
+                        async_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);
+                        }
+                        
+                        async_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));
+                        async_answer_0(iid, (sysarg_t) rc);
+                        break;
+                
+                default:
+                        async_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_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_add_route_req_local(int ip_phone, device_id_t device_id, in_addr_t address,
+    in_addr_t netmask, in_addr_t gateway)
+{
+        ip_route_t *route;
+        ip_netif_t *netif;
+        int index;
+
+        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;
+        }
+
+        route = (ip_route_t *) malloc(sizeof(ip_route_t));
         if (!route) {
                 fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
@@ -1658 +1719 @@
 ip_set_gateway_req_local(int ip_phone, device_id_t device_id, in_addr_t gateway)
 {
-        ip_netif_ref netif;
+        ip_netif_t *netif;
 
         fibril_rwlock_write_lock(&ip_globals.netifs_lock);
@@ -1692 +1753 @@
 static int
 ip_received_error_msg_local(int ip_phone, device_id_t device_id,
-    packet_t packet, services_t target, services_t error)
+    packet_t *packet, services_t target, services_t error)
 {
         uint8_t *data;
@@ -1698 +1759 @@
         icmp_type_t type;
         icmp_code_t code;
-        ip_netif_ref netif;
+        ip_netif_t *netif;
         measured_string_t address;
-        ip_route_ref route;
-        ip_header_ref header;
+        ip_route_t *route;
+        ip_header_t *header;
 
         switch (error) {
@@ -1711 +1772 @@
 
                 data = packet_get_data(packet);
-                header = (ip_header_ref)(data + offset);
-
-                // destination host unreachable?
+                header = (ip_header_t *)(data + offset);
+
+                /* Destination host unreachable? */
                 if ((type != ICMP_DEST_UNREACH) ||
                     (code != ICMP_HOST_UNREACH)) {
-                        // no, something else
+                        /* No, something else */
                         break;
                 }
@@ -1730 +1791 @@
                 route = ip_routes_get_index(&netif->routes, 0);
 
-                // from the same network?
+                /* From the same network? */
                 if (route && ((route->address.s_addr & route->netmask.s_addr) ==
                     (header->destination_address & route->netmask.s_addr))) {
-                        // clear the ARP mapping if any
-                        address.value = (char *) &header->destination_address;
-                        address.length = CONVERT_SIZE(uint8_t, char,
-                            sizeof(header->destination_address));
+                        /* Clear the ARP mapping if any */
+                        address.value = (uint8_t *) &header->destination_address;
+                        address.length = sizeof(header->destination_address);
                         arp_clear_address_req(netif->arp->phone,
                             netif->device_id, SERVICE_IP, &address);
@@ -1759 +1819 @@
         in_addr_t *dest;
         in_addr_t *src;
-        ip_route_ref route;
-        ipv4_pseudo_header_ref header_in;
+        ip_route_t *route;
+        ipv4_pseudo_header_t *header_in;
 
         if (!destination || (addrlen <= 0))
@@ -1788 +1848 @@
         fibril_rwlock_read_lock(&ip_globals.lock);
         route = ip_find_route(*dest);
-        // if the local host is the destination
+        /* If the local host is the destination */
         if (route && (route->address.s_addr == dest->s_addr) &&
             (dest->s_addr != IPV4_LOCALHOST_ADDRESS)) {
-                // find the loopback device to deliver
+                /* Find the loopback device to deliver */
                 dest->s_addr = IPV4_LOCALHOST_ADDRESS;
                 route = ip_find_route(*dest);
@@ -1806 +1866 @@
 
         *headerlen = sizeof(*header_in);
-        header_in = (ipv4_pseudo_header_ref) malloc(*headerlen);
+        header_in = (ipv4_pseudo_header_t *) malloc(*headerlen);
         if (!header_in)
                 return ENOMEM;
@@ -1820 +1880 @@
 }
 
-/** 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.
- * @returns             EOK on success and the packet is no longer needed.
- * @returns             EINVAL if the packet is too small to carry the IP
- *                      packet.
- * @returns             EINVAL if the received address lengths differs from the
- *                      registered values.
- * @returns             ENOENT if the device is not found in the cache.
- * @returns             ENOENT if the protocol for the device is not found in
- *                      the cache.
- * @returns             ENOMEM if there is not enough memory left.
- */
-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.
  *
@@ -1856 +1887 @@
  * @param[out] answer_count The last parameter for the actual answer in the
  *                      answer parameter.
- * @returns             EOK on success.
- * @returns             ENOTSUP if the message is not known.
+ * @return              EOK on success.
+ * @return              ENOTSUP if the message is not known.
  *
  * @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)
-{
-        ERROR_DECLARE;
-        
-        packet_t packet;
+int il_module_message(ipc_callid_t callid, ipc_call_t *call, ipc_call_t *answer,
+    size_t *answer_count)
+{
+        packet_t *packet;
         struct sockaddr *addr;
+        void *header;
+        size_t headerlen;
         size_t addrlen;
         size_t prefix;
         size_t suffix;
         size_t content;
-        void *header;
-        size_t headerlen;
         device_id_t device_id;
+        int rc;
         
         *answer_count = 0;
-        switch (IPC_GET_METHOD(*call)) {
+        switch (IPC_GET_IMETHOD(*call)) {
         case IPC_M_PHONE_HUNGUP:
                 return EOK;
         
         case IPC_M_CONNECT_TO_ME:
-                return ip_register(IL_GET_PROTO(call), IL_GET_SERVICE(call),
-                    IPC_GET_PHONE(call), NULL);
-        
-        case NET_IL_DEVICE:
-                return ip_device_req_local(0, IPC_GET_DEVICE(call),
-                    IPC_GET_SERVICE(call));
-        
-        case NET_IL_SEND:
-                ERROR_PROPAGATE(packet_translate_remote(ip_globals.net_phone,
-                    &packet, IPC_GET_PACKET(call)));
-                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:
-                ERROR_PROPAGATE(packet_translate_remote(ip_globals.net_phone,
-                    &packet, IPC_GET_PACKET(call)));
-                return ip_receive_message(IPC_GET_DEVICE(call), packet);
+                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:
-                ERROR_PROPAGATE(packet_translate_remote(ip_globals.net_phone,
-                    &packet, IPC_GET_PACKET(call)));
-                return ip_received_error_msg_local(0, IPC_GET_DEVICE(call),
-                    packet, IPC_GET_TARGET(call), IPC_GET_ERROR(call));
+                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));
         
         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:
-                ERROR_PROPAGATE(data_receive((void **) &addr, &addrlen));
-                ERROR_PROPAGATE(ip_get_route_req_local(0, IP_GET_PROTOCOL(call),
-                    addr, (socklen_t) addrlen, &device_id, &header,
-                    &headerlen));
-                IPC_SET_DEVICE(answer, device_id);
-                IP_SET_HEADERLEN(answer, headerlen);
+                rc = async_data_write_accept((void **) &addr, false, 0, 0, 0,
+                    &addrlen);
+                if (rc != EOK)
+                        return rc;
+                
+                rc = ip_get_route_req_local(0, IP_GET_PROTOCOL(*call), addr,
+                    (socklen_t) addrlen, &device_id, &header, &headerlen);
+                if (rc != EOK)
+                        return rc;
+                
+                IPC_SET_DEVICE(*answer, device_id);
+                IP_SET_HEADERLEN(*answer, headerlen);
                 
                 *answer_count = 2;
-                        
-                if (ERROR_NONE(data_reply(&headerlen, sizeof(headerlen))))
-                        ERROR_CODE = data_reply(header, headerlen);
+                
+                rc = data_reply(&headerlen, sizeof(headerlen));
+                if (rc == EOK)
+                        rc = data_reply(header, headerlen);
                         
                 free(header);
-                return ERROR_CODE;
-        
-        case NET_IL_PACKET_SPACE:
-                ERROR_PROPAGATE(ip_packet_size_message(IPC_GET_DEVICE(call),
-                    &addrlen, &prefix, &content, &suffix));
-                IPC_SET_ADDR(answer, addrlen);
-                IPC_SET_PREFIX(answer, prefix);
-                IPC_SET_CONTENT(answer, content);
-                IPC_SET_SUFFIX(answer, suffix);
+                return rc;
+        
+        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);
                 *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));
         }
         
@@ -1956 +1987 @@
 }
 
-/** Default thread for new connections.
- *
- * @param[in] iid       The initial message identifier.
- * @param[in] icall     The initial message call structure.
- */
-static void il_client_connection(ipc_callid_t iid, ipc_call_t *icall)
-{
-        /*
-         * Accept the connection
-         *  - Answer the first IPC_M_CONNECT_ME_TO call.
-         */
-        ipc_answer_0(iid, EOK);
-        
-        while (true) {
-                ipc_call_t answer;
-                int answer_count;
-                
-                /* Clear the answer structure */
-                refresh_answer(&answer, &answer_count);
-                
-                /* Fetch the next message */
-                ipc_call_t call;
-                ipc_callid_t callid = async_get_call(&call);
-                
-                /* Process the message */
-                int res = il_module_message_standalone(callid, &call, &answer,
-                    &answer_count);
-                
-                /*
-                 * End if told to either by the message or the processing
-                 * result.
-                 */
-                if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
-                    (res == EHANGUP)) {
-                        return;
-                }
-                
-                /* Answer the message */
-                answer_call(callid, res, &answer, answer_count);
-        }
-}
-
-/** Starts the module.
- *
- * @returns EOK on success.
- * @returns Other error codes as defined for each specific module start function.
- */
 int main(int argc, char *argv[])
 {
-        ERROR_DECLARE;
-        
         /* Start the module */
-        ERROR_PROPAGATE(il_module_start_standalone(il_client_connection));
-        return EOK;
+        return il_module_start(SERVICE_IP);
 }