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

File:

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

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

@@ -120 +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.
- *
- * @param[in] packet    The packet queue to be released.
- * @param[in] result    The result to be returned.
- * @return              The result parameter.
+static void ip_receiver(ipc_callid_t, ipc_call_t *, void *);
+
+/** Release the packet and returns the result.
+ *
+ * @param[in] packet Packet queue to be released.
+ * @param[in] result Result to be returned.
+ *
+ * @return Result parameter.
+ *
  */
 static int ip_release_and_return(packet_t *packet, int result)
 {
-        pq_release_remote(ip_globals.net_phone, packet_get_id(packet));
+        pq_release_remote(ip_globals.net_sess, packet_get_id(packet));
         return result;
 }
 
-/** Returns the ICMP phone.
- *
- * Searches the registered protocols.
- *
- * @return              The found ICMP phone.
- * @return              ENOENT if the ICMP is not registered.
- */
-static int ip_get_icmp_phone(void)
-{
-        ip_proto_t *proto;
-        int phone;
-
+/** Return the ICMP session.
+ *
+ * Search the registered protocols.
+ *
+ * @return Found ICMP session.
+ * @return NULL if the ICMP is not registered.
+ *
+ */
+static async_sess_t *ip_get_icmp_session(void)
+{
         fibril_rwlock_read_lock(&ip_globals.protos_lock);
-        proto = ip_protos_find(&ip_globals.protos, IPPROTO_ICMP);
-        phone = proto ? proto->phone : ENOENT;
+        ip_proto_t *proto = ip_protos_find(&ip_globals.protos, IPPROTO_ICMP);
+        async_sess_t *sess = proto ? proto->sess : NULL;
         fibril_rwlock_read_unlock(&ip_globals.protos_lock);
-        return phone;
+        
+        return sess;
 }
 
@@ -179 +180 @@
         next = pq_detach(packet);
         if (next)
-                pq_release_remote(ip_globals.net_phone, packet_get_id(next));
+                pq_release_remote(ip_globals.net_sess, packet_get_id(next));
 
         if (!header) {
@@ -201 +202 @@
 
         /* Set the destination address */
-        switch (header->version) {
+        switch (GET_IP_HEADER_VERSION(header)) {
         case IPVERSION:
                 addrlen = sizeof(dest_in);
@@ -218 +219 @@
 }
 
-/** Prepares the ICMP notification packet.
- *
- * Releases additional packets and keeps only the first one.
+/** Prepare the ICMP notification packet.
+ *
+ * Release additional packets and keep only the first one.
  * All packets are released on error.
  *
- * @param[in] error     The packet error service.
- * @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.
- * @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_t *header)
-{
-        int phone;
-
-        phone = ip_get_icmp_phone();
-        if (error || (phone < 0) || ip_prepare_icmp(packet, header))
-                return ip_release_and_return(packet, EINVAL);
-        return phone;
-}
-
-int il_initialize(int net_phone)
+ * @param[in] error  Packet error service.
+ * @param[in] packet Packet or the packet queue to be reported as faulty.
+ * @param[in] header First packet IP header. May be NULL.
+ *
+ * @return Found ICMP session.
+ * @return NULL if the error parameter is set.
+ * @return NULL if the ICMP session is not found.
+ * @return NULL if the ip_prepare_icmp() fails.
+ *
+ */
+static async_sess_t *ip_prepare_icmp_and_get_session(services_t error,
+    packet_t *packet, ip_header_t *header)
+{
+        async_sess_t *sess = ip_get_icmp_session();
+        
+        if ((error) || (!sess) || (ip_prepare_icmp(packet, header))) {
+                pq_release_remote(ip_globals.net_sess, packet_get_id(packet));
+                return NULL;
+        }
+        
+        return sess;
+}
+
+int il_initialize(async_sess_t *net_sess)
 {
         fibril_rwlock_initialize(&ip_globals.lock);
@@ -250 +254 @@
         fibril_rwlock_initialize(&ip_globals.netifs_lock);
         
-        ip_globals.net_phone = net_phone;
+        ip_globals.net_sess = net_sess;
         ip_globals.packet_counter = 0;
         ip_globals.gateway.address.s_addr = 0;
@@ -350 +354 @@
         ip_netif->routing = NET_DEFAULT_IP_ROUTING;
         configuration = &names[0];
-
+        
         /* Get configuration */
-        rc = net_get_device_conf_req(ip_globals.net_phone, ip_netif->device_id,
+        rc = net_get_device_conf_req(ip_globals.net_sess, ip_netif->device_id,
             &configuration, count, &data);
         if (rc != EOK)
@@ -402 +406 @@
                         return ENOTSUP;
                 }
-
+                
                 if (configuration[6].value) {
                         ip_netif->arp = get_running_module(&ip_globals.modules,
@@ -413 +417 @@
                         }
                 }
+                
                 if (configuration[7].value)
                         ip_netif->routing = (configuration[7].value[0] == 'y');
-
+                
                 net_free_settings(configuration, data);
         }
-
+        
         /* Bind netif service which also initializes the device */
-        ip_netif->phone = nil_bind_service(ip_netif->service,
+        ip_netif->sess = nil_bind_service(ip_netif->service,
             (sysarg_t) ip_netif->device_id, SERVICE_IP,
             ip_receiver);
-        if (ip_netif->phone < 0) {
+        if (ip_netif->sess == NULL) {
                 printf("Failed to contact the nil service %d\n",
                     ip_netif->service);
-                return ip_netif->phone;
-        }
-
+                return ENOENT;
+        }
+        
         /* Has to be after the device netif module initialization */
         if (ip_netif->arp) {
@@ -435 +440 @@
                         address.length = sizeof(in_addr_t);
                         
-                        rc = arp_device_req(ip_netif->arp->phone,
+                        rc = arp_device_req(ip_netif->arp->sess,
                             ip_netif->device_id, SERVICE_IP, ip_netif->service,
                             &address);
@@ -444 +449 @@
                 }
         }
-
+        
         /* Get packet dimensions */
-        rc = nil_packet_size_req(ip_netif->phone, ip_netif->device_id,
+        rc = nil_packet_size_req(ip_netif->sess, ip_netif->device_id,
             &ip_netif->packet_dimension);
         if (rc != EOK)
@@ -457 +462 @@
                 ip_netif->packet_dimension.content = IP_MIN_CONTENT;
         }
-
+        
         index = ip_netifs_add(&ip_globals.netifs, ip_netif->device_id, ip_netif);
         if (index < 0)
@@ -474 +479 @@
                 printf("%s: Default gateway (%s)\n", NAME, defgateway);
         }
-
+        
         return EOK;
 }
 
-static int ip_device_req_local(int il_phone, device_id_t device_id,
-    services_t netif)
+static int ip_device_req_local(nic_device_id_t device_id, services_t netif)
 {
         ip_netif_t *ip_netif;
@@ -495 +499 @@
                 return rc;
         }
-
+        
         ip_netif->device_id = device_id;
         ip_netif->service = netif;
-        ip_netif->state = NETIF_STOPPED;
-
+        ip_netif->state = NIC_STATE_STOPPED;
+        
         fibril_rwlock_write_lock(&ip_globals.netifs_lock);
 
@@ -513 +517 @@
 
         /* 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,
+        printf("%s: Device registered (id: %d, ipv: %d, conf: %s)\n",
+            NAME, ip_netif->device_id, ip_netif->ipv,
             ip_netif->dhcp ? "dhcp" : "static");
         
@@ -591 +595 @@
         while (index >= 0) {
                 netif = ip_netifs_get_index(&ip_globals.netifs, index);
-                if (netif && (netif->state == NETIF_ACTIVE)) {
+                if (netif && (netif->state == NIC_STATE_ACTIVE)) {
                         route = ip_netif_find_route(netif, destination);
                         if (route)
@@ -635 +639 @@
 
         /* Process all IP options */
-        while (next < first->header_length) {
+        while (next < GET_IP_HEADER_LENGTH(first)) {
                 option = (ip_option_t *) (((uint8_t *) first) + next);
                 /* Skip end or noop */
@@ -656 +660 @@
         if (length % 4) {
                 bzero(((uint8_t *) last) + length, 4 - (length % 4));
-                last->header_length = length / 4 + 1;
+                SET_IP_HEADER_LENGTH(last, (length / 4 + 1));
         } else {
-                last->header_length = length / 4;
+                SET_IP_HEADER_LENGTH(last, (length / 4));
         }
 
@@ -706 +710 @@
                 return rc;
         
-        header->version = IPV4;
-        header->fragment_offset_high = 0;
+        SET_IP_HEADER_VERSION(header, IPV4);
+        SET_IP_HEADER_FRAGMENT_OFFSET_HIGH(header, 0);
         header->fragment_offset_low = 0;
         header->header_checksum = 0;
@@ -735 +739 @@
                         memcpy(middle_header, last_header,
                             IP_HEADER_LENGTH(last_header));
-                        header->flags |= IPFLAG_MORE_FRAGMENTS;
+                        SET_IP_HEADER_FLAGS(header,
+                            (GET_IP_HEADER_FLAGS(header) | IPFLAG_MORE_FRAGMENTS));
                         middle_header->total_length =
                             htons(packet_get_data_length(next));
-                        middle_header->fragment_offset_high =
-                            IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length);
+                        SET_IP_HEADER_FRAGMENT_OFFSET_HIGH(middle_header,
+                            IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length));
                         middle_header->fragment_offset_low =
                             IP_COMPUTE_FRAGMENT_OFFSET_LOW(length);
@@ -768 +773 @@
                 middle_header->total_length =
                     htons(packet_get_data_length(next));
-                middle_header->fragment_offset_high =
-                    IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length);
+                SET_IP_HEADER_FRAGMENT_OFFSET_HIGH(middle_header,
+                    IP_COMPUTE_FRAGMENT_OFFSET_HIGH(length));
                 middle_header->fragment_offset_low =
                     IP_COMPUTE_FRAGMENT_OFFSET_LOW(length);
@@ -785 +790 @@
                 length += packet_get_data_length(next);
                 free(last_header);
-                header->flags |= IPFLAG_MORE_FRAGMENTS;
+                SET_IP_HEADER_FLAGS(header,
+                    (GET_IP_HEADER_FLAGS(header) | IPFLAG_MORE_FRAGMENTS));
         }
 
@@ -834 +840 @@
         new_header->total_length = htons(IP_HEADER_LENGTH(new_header) + length);
         offset = IP_FRAGMENT_OFFSET(header) + IP_HEADER_DATA_LENGTH(header);
-        new_header->fragment_offset_high =
-            IP_COMPUTE_FRAGMENT_OFFSET_HIGH(offset);
+        SET_IP_HEADER_FRAGMENT_OFFSET_HIGH(new_header,
+            IP_COMPUTE_FRAGMENT_OFFSET_HIGH(offset));
         new_header->fragment_offset_low =
             IP_COMPUTE_FRAGMENT_OFFSET_LOW(offset);
@@ -865 +871 @@
                 return NULL;
         memcpy(middle, last, IP_HEADER_LENGTH(last));
-        middle->flags |= IPFLAG_MORE_FRAGMENTS;
+        SET_IP_HEADER_FLAGS(middle,
+            (GET_IP_HEADER_FLAGS(middle) | IPFLAG_MORE_FRAGMENTS));
         return middle;
 }
@@ -922 +929 @@
 
         /* Fragmentation forbidden? */
-        if(header->flags & IPFLAG_DONT_FRAGMENT)
+        if(GET_IP_HEADER_FLAGS(header) & IPFLAG_DONT_FRAGMENT)
                 return EPERM;
 
         /* Create the last fragment */
-        new_packet = packet_get_4_remote(ip_globals.net_phone, prefix, length,
+        new_packet = packet_get_4_remote(ip_globals.net_sess, prefix, length,
             suffix, ((addrlen > addr_len) ? addrlen : addr_len));
         if (!new_packet)
@@ -958 +965 @@
 
         /* Mark the first as fragmented */
-        header->flags |= IPFLAG_MORE_FRAGMENTS;
+        SET_IP_HEADER_FLAGS(header,
+            (GET_IP_HEADER_FLAGS(header) | IPFLAG_MORE_FRAGMENTS));
 
         /* Create middle fragments */
         while (IP_TOTAL_LENGTH(header) > length) {
-                new_packet = packet_get_4_remote(ip_globals.net_phone, prefix,
+                new_packet = packet_get_4_remote(ip_globals.net_sess, prefix,
                     length, suffix,
                     ((addrlen >= addr_len) ? addrlen : addr_len));
@@ -987 +995 @@
 }
 
-/** Checks the packet queue lengths and fragments the packets if needed.
+/** Check the packet queue lengths and fragments the packets if needed.
  *
  * The ICMP_FRAG_NEEDED error notification may be sent if the packet needs to
  * be fragmented and the fragmentation is not allowed.
  *
- * @param[in,out] packet The packet or the packet queue to be checked.
- * @param[in] prefix    The minimum prefix size.
- * @param[in] content   The maximum content size.
- * @param[in] suffix    The minimum suffix size.
- * @param[in] addr_len  The minimum address length.
- * @param[in] error     The error module service.
- * @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)
+ * @param[in,out] packet   Packet or the packet queue to be checked.
+ * @param[in]     prefix   Minimum prefix size.
+ * @param[in]     content  Maximum content size.
+ * @param[in]     suffix   Minimum suffix size.
+ * @param[in]     addr_len Minimum address length.
+ * @param[in]     error    Error module service.
+ *
+ * @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;
@@ -1009 +1018 @@
         packet_t *new_packet;
         int result;
-        int phone;
-
+        async_sess_t *sess;
+        
         next = packet;
         /* Check all packets */
@@ -1032 +1041 @@
                         /* Fragmentation needed? */
                         if (result == EPERM) {
-                                phone = ip_prepare_icmp_and_get_phone(
-                                    error, next, NULL);
-                                if (phone >= 0) {
+                                sess = ip_prepare_icmp_and_get_session(error, next, NULL);
+                                if (sess) {
                                         /* Fragmentation necessary ICMP */
-                                        icmp_destination_unreachable_msg(phone,
+                                        icmp_destination_unreachable_msg(sess,
                                             ICMP_FRAG_NEEDED, content, next);
                                 }
                         } else {
-                                pq_release_remote(ip_globals.net_phone,
+                                pq_release_remote(ip_globals.net_sess,
                                     packet_get_id(next));
                         }
@@ -1054 +1062 @@
 }
 
-/** Sends the packet or the packet queue via the specified route.
+/** Send the packet or the packet queue via the specified route.
  *
  * The ICMP_HOST_UNREACH error notification may be sent if route hardware
  * destination address is found.
  *
- * @param[in,out] packet The packet to be sent.
- * @param[in] netif     The target network interface.
- * @param[in] route     The target route.
- * @param[in] src       The source address.
- * @param[in] dest      The destination address.
- * @param[in] error     The error module service.
- * @return              EOK on success.
- * @return              Other error codes as defined for the arp_translate_req()
- *                      function.
- * @return              Other error codes as defined for the ip_prepare_packet()
- *                      function.
+ * @param[in,out] packet Packet to be sent.
+ * @param[in]     netif  Target network interface.
+ * @param[in]     route  Target route.
+ * @param[in]     src    Source address.
+ * @param[in]     dest   Destination address.
+ * @param[in]     error  Error module service.
+ *
+ * @return EOK on success.
+ * @return Other error codes as defined for arp_translate_req().
+ * @return Other error codes as defined for ip_prepare_packet().
+ *
  */
 static int ip_send_route(packet_t *packet, ip_netif_t *netif,
@@ -1077 +1085 @@
         measured_string_t *translation;
         uint8_t *data;
-        int phone;
+        async_sess_t *sess;
         int rc;
 
@@ -1086 +1094 @@
                 destination.length = sizeof(dest.s_addr);
 
-                rc = arp_translate_req(netif->arp->phone, netif->device_id,
+                rc = arp_translate_req(netif->arp->sess, netif->device_id,
                     SERVICE_IP, &destination, &translation, &data);
                 if (rc != EOK) {
-                        pq_release_remote(ip_globals.net_phone,
+                        pq_release_remote(ip_globals.net_sess,
                             packet_get_id(packet));
                         return rc;
@@ -1099 +1107 @@
                                 free(data);
                         }
-                        phone = ip_prepare_icmp_and_get_phone(error, packet,
+                        sess = ip_prepare_icmp_and_get_session(error, packet,
                             NULL);
-                        if (phone >= 0) {
+                        if (sess) {
                                 /* Unreachable ICMP if no routing */
-                                icmp_destination_unreachable_msg(phone,
+                                icmp_destination_unreachable_msg(sess,
                                     ICMP_HOST_UNREACH, 0, packet);
                         }
@@ -1115 +1123 @@
         rc = ip_prepare_packet(src, dest, packet, translation);
         if (rc != EOK) {
-                pq_release_remote(ip_globals.net_phone, packet_get_id(packet));
+                pq_release_remote(ip_globals.net_sess, packet_get_id(packet));
         } else {
                 packet = ip_split_packet(packet, netif->packet_dimension.prefix,
@@ -1122 +1130 @@
                     netif->packet_dimension.addr_len, error);
                 if (packet) {
-                        nil_send_msg(netif->phone, netif->device_id, packet,
+                        nil_send_msg(netif->sess, netif->device_id, packet,
                             SERVICE_IP);
                 }
@@ -1135 +1143 @@
 }
 
-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(nic_device_id_t device_id, packet_t *packet,
+    services_t sender, services_t error)
 {
         int addrlen;
@@ -1145 +1153 @@
         in_addr_t *dest;
         in_addr_t *src;
-        int phone;
+        async_sess_t *sess;
         int rc;
 
@@ -1190 +1198 @@
         if (!netif || !route) {
                 fibril_rwlock_read_unlock(&ip_globals.netifs_lock);
-                phone = ip_prepare_icmp_and_get_phone(error, packet, NULL);
-                if (phone >= 0) {
+                sess = ip_prepare_icmp_and_get_session(error, packet, NULL);
+                if (sess) {
                         /* Unreachable ICMP if no routing */
-                        icmp_destination_unreachable_msg(phone,
+                        icmp_destination_unreachable_msg(sess,
                             ICMP_NET_UNREACH, 0, packet);
                 }
@@ -1221 +1229 @@
                 if (!netif || !route) {
                         fibril_rwlock_read_unlock(&ip_globals.netifs_lock);
-                        phone = ip_prepare_icmp_and_get_phone(error, packet,
+                        sess = ip_prepare_icmp_and_get_session(error, packet,
                             NULL);
-                        if (phone >= 0) {
+                        if (sess) {
                                 /* Unreachable ICMP if no routing */
-                                icmp_destination_unreachable_msg(phone,
+                                icmp_destination_unreachable_msg(sess,
                                     ICMP_HOST_UNREACH, 0, packet);
                         }
@@ -1251 +1259 @@
  * @return              ENOENT if device is not found.
  */
-static int ip_device_state_message(device_id_t device_id, device_state_t state)
+static int ip_device_state_message(nic_device_id_t device_id,
+    nic_device_state_t state)
 {
         ip_netif_t *netif;
@@ -1265 +1274 @@
         fibril_rwlock_write_unlock(&ip_globals.netifs_lock);
 
-        printf("%s: Device %d changed state to %d\n", NAME, device_id, state);
+        printf("%s: Device %d changed state to '%s'\n", NAME, device_id,
+            nic_device_state_to_string(state));
 
         return EOK;
@@ -1305 +1315 @@
  *                      tl_received_msg() function.
  */
-static int ip_deliver_local(device_id_t device_id, packet_t *packet,
+static int ip_deliver_local(nic_device_id_t device_id, packet_t *packet,
     ip_header_t *header, services_t error)
 {
         ip_proto_t *proto;
-        int phone;
+        async_sess_t *sess;
         services_t service;
         tl_received_msg_t received_msg;
@@ -1319 +1329 @@
         int rc;
 
-        if ((header->flags & IPFLAG_MORE_FRAGMENTS) ||
+        if ((GET_IP_HEADER_FLAGS(header) & IPFLAG_MORE_FRAGMENTS) ||
             IP_FRAGMENT_OFFSET(header)) {
                 // TODO fragmented
@@ -1325 +1335 @@
         }
         
-        switch (header->version) {
+        switch (GET_IP_HEADER_VERSION(header)) {
         case IPVERSION:
                 addrlen = sizeof(src_in);
@@ -1362 +1372 @@
         if (!proto) {
                 fibril_rwlock_read_unlock(&ip_globals.protos_lock);
-                phone = ip_prepare_icmp_and_get_phone(error, packet, header);
-                if (phone >= 0) {
+                sess = ip_prepare_icmp_and_get_session(error, packet, header);
+                if (sess) {
                         /* Unreachable ICMP */
-                        icmp_destination_unreachable_msg(phone,
+                        icmp_destination_unreachable_msg(sess,
                             ICMP_PROT_UNREACH, 0, packet);
                 }
@@ -1377 +1387 @@
                 rc = received_msg(device_id, packet, service, error);
         } else {
-                rc = tl_received_msg(proto->phone, device_id, packet,
+                rc = tl_received_msg(proto->sess, device_id, packet,
                     proto->service, error);
                 fibril_rwlock_read_unlock(&ip_globals.protos_lock);
@@ -1406 +1416 @@
  *                      is disabled.
  */
-static int ip_process_packet(device_id_t device_id, packet_t *packet)
+static int ip_process_packet(nic_device_id_t device_id, packet_t *packet)
 {
         ip_header_t *header;
         in_addr_t dest;
         ip_route_t *route;
-        int phone;
+        async_sess_t *sess;
         struct sockaddr *addr;
         struct sockaddr_in addr_in;
@@ -1424 +1434 @@
         if ((header->header_checksum) &&
             (IP_HEADER_CHECKSUM(header) != IP_CHECKSUM_ZERO)) {
-                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
-                if (phone >= 0) {
+                sess = ip_prepare_icmp_and_get_session(0, packet, header);
+                if (sess) {
                         /* Checksum error ICMP */
-                        icmp_parameter_problem_msg(phone, ICMP_PARAM_POINTER,
+                        icmp_parameter_problem_msg(sess, ICMP_PARAM_POINTER,
                             ((size_t) ((void *) &header->header_checksum)) -
                             ((size_t) ((void *) header)), packet);
@@ -1435 +1445 @@
 
         if (header->ttl <= 1) {
-                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
-                if (phone >= 0) {
+                sess = ip_prepare_icmp_and_get_session(0, packet, header);
+                if (sess) {
                         /* TTL exceeded ICMP */
-                        icmp_time_exceeded_msg(phone, ICMP_EXC_TTL, packet);
+                        icmp_time_exceeded_msg(sess, ICMP_EXC_TTL, packet);
                 }
                 return EINVAL;
@@ -1447 +1457 @@
 
         /* Set the destination address */
-        switch (header->version) {
+        switch (GET_IP_HEADER_VERSION(header)) {
         case IPVERSION:
                 addrlen = sizeof(addr_in);
@@ -1466 +1476 @@
         route = ip_find_route(dest);
         if (!route) {
-                phone = ip_prepare_icmp_and_get_phone(0, packet, header);
-                if (phone >= 0) {
+                sess = ip_prepare_icmp_and_get_session(0, packet, header);
+                if (sess) {
                         /* Unreachable ICMP */
-                        icmp_destination_unreachable_msg(phone,
+                        icmp_destination_unreachable_msg(sess,
                             ICMP_HOST_UNREACH, 0, packet);
                 }
@@ -1486 +1496 @@
         }
 
-        phone = ip_prepare_icmp_and_get_phone(0, packet, header);
-        if (phone >= 0) {
+        sess = ip_prepare_icmp_and_get_session(0, packet, header);
+        if (sess) {
                 /* Unreachable ICMP if no routing */
-                icmp_destination_unreachable_msg(phone, ICMP_HOST_UNREACH, 0,
+                icmp_destination_unreachable_msg(sess, ICMP_HOST_UNREACH, 0,
                     packet);
         }
@@ -1496 +1506 @@
 }
 
-/** Returns the device packet dimensions for sending.
- *
- * @param[in] phone     The service module phone.
- * @param[in] message   The service specific message.
- * @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.
- */
-static int ip_packet_size_message(device_id_t device_id, size_t *addr_len,
+/** Return the device packet dimensions for sending.
+ *
+ * @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.
+ *
+ */
+static int ip_packet_size_message(nic_device_id_t device_id, size_t *addr_len,
     size_t *prefix, size_t *content, size_t *suffix)
 {
@@ -1565 +1575 @@
  * @return              ENOENT if device is not found.
  */
-static int ip_mtu_changed_message(device_id_t device_id, size_t mtu)
+static int ip_mtu_changed_message(nic_device_id_t device_id, size_t mtu)
 {
         ip_netif_t *netif;
@@ -1587 +1597 @@
  * @param[in]     iid   Message identifier.
  * @param[in,out] icall Message parameters.
- *
- */
-static void ip_receiver(ipc_callid_t iid, ipc_call_t *icall)
+ * @param[in]     arg   Local argument.
+ *
+ */
+static void ip_receiver(ipc_callid_t iid, ipc_call_t *icall, void *arg)
 {
         packet_t *packet;
@@ -1603 +1614 @@
                 
                 case NET_IL_RECEIVED:
-                        rc = packet_translate_remote(ip_globals.net_phone, &packet,
+                        rc = packet_translate_remote(ip_globals.net_sess, &packet,
                             IPC_GET_PACKET(*icall));
                         if (rc == EOK) {
@@ -1621 +1632 @@
                         async_answer_0(iid, (sysarg_t) rc);
                         break;
-                
+                case NET_IL_ADDR_CHANGED:
+                        async_answer_0(iid, (sysarg_t) EOK);
+                        break;
+
                 default:
                         async_answer_0(iid, (sysarg_t) ENOTSUP);
@@ -1630 +1644 @@
 }
 
-/** Registers the transport layer protocol.
+/** Register 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,
+ * @param[in] protocol     Transport layer module protocol.
+ * @param[in] service      Transport layer module service.
+ * @param[in] sess         Transport layer module session.
+ * @param[in] received_msg 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, async_sess_t *sess,
     tl_received_msg_t received_msg)
 {
@@ -1653 +1668 @@
         int index;
 
-        if (!protocol || !service || ((phone < 0) && !received_msg))
+        if ((!protocol) || (!service) || ((!sess) && (!received_msg)))
                 return EINVAL;
-
+        
         proto = (ip_proto_t *) malloc(sizeof(ip_protos_t));
         if (!proto)
@@ -1662 +1677 @@
         proto->protocol = protocol;
         proto->service = service;
-        proto->phone = phone;
+        proto->sess = sess;
         proto->received_msg = received_msg;
 
@@ -1674 +1689 @@
         fibril_rwlock_write_unlock(&ip_globals.protos_lock);
 
-        printf("%s: Protocol registered (protocol: %d, phone: %d)\n",
-            NAME, proto->protocol, proto->phone);
+        printf("%s: Protocol registered (protocol: %d)\n",
+            NAME, proto->protocol);
 
         return EOK;
 }
 
-
-static int
-ip_add_route_req_local(int ip_phone, device_id_t device_id, in_addr_t address,
+static int ip_add_route_req_local(nic_device_id_t device_id, in_addr_t address,
     in_addr_t netmask, in_addr_t gateway)
 {
@@ -1716 +1729 @@
 }
 
-static int
-ip_set_gateway_req_local(int ip_phone, device_id_t device_id, in_addr_t gateway)
+static int ip_set_gateway_req_local(nic_device_id_t device_id,
+    in_addr_t gateway)
 {
         ip_netif_t *netif;
@@ -1741 +1754 @@
 /** Notify the IP module about the received error notification packet.
  *
- * @param[in] ip_phone  The IP module phone used for (semi)remote calls.
- * @param[in] device_id The device identifier.
- * @param[in] packet    The received packet or the received packet queue.
- * @param[in] target    The target internetwork module service to be
- *                      delivered to.
- * @param[in] error     The packet error reporting service. Prefixes the
- *                      received packet.
- * @return              EOK on success.
- *
- */
-static int
-ip_received_error_msg_local(int ip_phone, device_id_t device_id,
+ * @param[in] device_id Device identifier.
+ * @param[in] packet    Received packet or the received packet queue.
+ * @param[in] target    Target internetwork module service to be
+ *                      delivered to.
+ * @param[in] error     Packet error reporting service. Prefixes the
+ *                      received packet.
+ *
+ * @return EOK on success.
+ *
+ */
+static int ip_received_error_msg_local(nic_device_id_t device_id,
     packet_t *packet, services_t target, services_t error)
 {
@@ -1797 +1809 @@
                         address.value = (uint8_t *) &header->destination_address;
                         address.length = sizeof(header->destination_address);
-                        arp_clear_address_req(netif->arp->phone,
+                        arp_clear_address_req(netif->arp->sess,
                             netif->device_id, SERVICE_IP, &address);
                 }
@@ -1811 +1823 @@
 }
 
-static int
-ip_get_route_req_local(int ip_phone, ip_protocol_t protocol,
+static int ip_get_route_req_local(ip_protocol_t protocol,
     const struct sockaddr *destination, socklen_t addrlen,
-    device_id_t *device_id, void **header, size_t *headerlen)
+    nic_device_id_t *device_id, void **header, size_t *headerlen)
 {
         struct sockaddr_in *address_in;
@@ -1905 +1916 @@
         size_t suffix;
         size_t content;
-        device_id_t device_id;
+        nic_device_id_t device_id;
         int rc;
         
         *answer_count = 0;
+        
+        if (!IPC_GET_IMETHOD(*call))
+                return EOK;
+        
+        async_sess_t *callback =
+            async_callback_receive_start(EXCHANGE_SERIALIZE, call);
+        if (callback)
+                return ip_register(IL_GET_PROTO(*call), IL_GET_SERVICE(*call),
+                    callback, NULL);
+        
         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_IP_DEVICE:
-                return ip_device_req_local(0, IPC_GET_DEVICE(*call),
+                return ip_device_req_local(IPC_GET_DEVICE(*call),
                     IPC_GET_SERVICE(*call));
         
         case NET_IP_RECEIVED_ERROR:
-                rc = packet_translate_remote(ip_globals.net_phone, &packet,
+                rc = packet_translate_remote(ip_globals.net_sess, &packet,
                     IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
-                return ip_received_error_msg_local(0, IPC_GET_DEVICE(*call),
+                return ip_received_error_msg_local(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),
+                return ip_add_route_req_local(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),
+                return ip_set_gateway_req_local(IPC_GET_DEVICE(*call),
                     IP_GET_GATEWAY(*call));
 
@@ -1944 +1958 @@
                         return rc;
                 
-                rc = ip_get_route_req_local(0, IP_GET_PROTOCOL(*call), addr,
+                rc = ip_get_route_req_local(IP_GET_PROTOCOL(*call), addr,
                     (socklen_t) addrlen, &device_id, &header, &headerlen);
                 if (rc != EOK)
@@ -1975 +1989 @@
         
         case NET_IP_SEND:
-                rc = packet_translate_remote(ip_globals.net_phone, &packet,
+                rc = packet_translate_remote(ip_globals.net_sess, &packet,
                     IPC_GET_PACKET(*call));
                 if (rc != EOK)
                         return rc;
                 
-                return ip_send_msg_local(0, IPC_GET_DEVICE(*call), packet, 0,
+                return ip_send_msg_local(IPC_GET_DEVICE(*call), packet, 0,
                     IPC_GET_ERROR(*call));
         }