Changeset 6b82009 in mainline for uspace/srv

Timestamp:

2011-06-22T20:41:41Z (14 years ago)

Author:

Martin Decky <martin@…>

Branches:

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

Children:

ef09a7a

Parents:

55091847

Message:

networking stack: convert to the new async framework

Location:

uspace/srv

Files:

• hw/netif/ne2000/ne2000.c (modified) (9 diffs)
• net/il/arp/arp.c (modified) (18 diffs)
• net/il/arp/arp.h (modified) (3 diffs)
• net/il/ip/ip.c (modified) (48 diffs)
• net/il/ip/ip.h (modified) (4 diffs)
• net/net/net.c (modified) (10 diffs)
• net/netif/lo/lo.c (modified) (3 diffs)
• net/nil/eth/eth.c (modified) (22 diffs)
• net/nil/eth/eth.h (modified) (4 diffs)
• net/nil/nildummy/nildummy.c (modified) (16 diffs)
• net/nil/nildummy/nildummy.h (modified) (3 diffs)
• net/tl/icmp/icmp.c (modified) (15 diffs)
• net/tl/tcp/tcp.c (modified) (55 diffs)
• net/tl/tcp/tcp.h (modified) (2 diffs)
• net/tl/udp/udp.c (modified) (26 diffs)
• net/tl/udp/udp.h (modified) (2 diffs)

uspace/srv/hw/netif/ne2000/ne2000.c

@@ -38 +38 @@
 #include <assert.h>
 #include <async.h>
-#include <async_obsolete.h>
 #include <ddi.h>
 #include <errno.h>
@@ -44 +43 @@
 #include <malloc.h>
 #include <sysinfo.h>
+#include <ns.h>
 #include <ipc/services.h>
-#include <ns.h>
-#include <ns_obsolete.h>
 #include <ipc/irc.h>
 #include <net/modules.h>
@@ -78 +76 @@
 
 static bool irc_service = false;
-static int irc_phone = -1;
+static async_sess_t *irc_sess = NULL;
 
 /** NE2000 kernel interrupt command sequence.
@@ -154 +152 @@
         device_id_t device_id = IRQ_GET_DEVICE(*call);
         netif_device_t *device;
-        int nil_phone;
+        async_sess_t *nil_sess;
         ne2k_t *ne2k;
         
         fibril_rwlock_read_lock(&netif_globals.lock);
         
-        if (find_device(device_id, &device) == EOK) {
-                nil_phone = device->nil_phone;
+        nil_sess = netif_globals.nil_sess;
+        
+        if (find_device(device_id, &device) == EOK)
                 ne2k = (ne2k_t *) device->specific;
-        } else
+        else
                 ne2k = NULL;
         
@@ -177 +176 @@
                                 
                                 list_remove(&frame->link);
-                                nil_received_msg(nil_phone, device_id,
-                                    frame->packet, SERVICE_NONE);
+                                nil_received_msg(nil_sess, device_id, frame->packet,
+                                    SERVICE_NONE);
                                 free(frame);
                         }
@@ -278 +277 @@
         
         device->device_id = device_id;
-        device->nil_phone = -1;
         device->specific = (void *) ne2k;
         device->state = NETIF_STOPPED;
@@ -331 +329 @@
                 change_state(device, NETIF_ACTIVE);
                 
-                if (irc_service)
-                        async_obsolete_msg_1(irc_phone, IRC_ENABLE_INTERRUPT, ne2k->irq);
+                if (irc_service) {
+                        async_exch_t *exch = async_exchange_begin(irc_sess);
+                        async_msg_1(exch, IRC_ENABLE_INTERRUPT, ne2k->irq);
+                        async_exchange_end(exch);
+                }
         }
         
@@ -390 +391 @@
         
         if (irc_service) {
-                while (irc_phone < 0)
-                        irc_phone = service_obsolete_connect_blocking(SERVICE_IRC, 0, 0);
+                while (!irc_sess)
+                        irc_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
+                            SERVICE_IRC, 0, 0);
         }
         
@@ -402 +404 @@
 {
         /* Start the module */
-        return netif_module_start();
+        return netif_module_start(SERVICE_ETHERNET);
 }
 

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

@@ -164 +164 @@
 }
 
-static int arp_clean_cache_req(int arp_phone)
+static int arp_clean_cache_req(void)
 {
         int count;
@@ -190 +190 @@
 }
 
-static int arp_clear_address_req(int arp_phone, device_id_t device_id,
-    services_t protocol, measured_string_t *address)
+static int arp_clear_address_req(device_id_t device_id, services_t protocol,
+    measured_string_t *address)
 {
         fibril_mutex_lock(&arp_globals.lock);
@@ -218 +218 @@
 }
 
-static int arp_clear_device_req(int arp_phone, device_id_t device_id)
+static int arp_clear_device_req(device_id_t device_id)
 {
         fibril_mutex_lock(&arp_globals.lock);
@@ -375 +375 @@
                                 return rc;
                         
-                        nil_send_msg(device->phone, device_id, packet,
+                        nil_send_msg(device->sess, device_id, packet,
                             SERVICE_ARP);
                         return 1;
@@ -416 +416 @@
  * @param[in]     iid   Message identifier.
  * @param[in,out] icall Message parameters.
- * @param[in]     arg   Local argument.
+ * @param[in]     arg   Local argument.
+ *
  */
 static void arp_receiver(ipc_callid_t iid, ipc_call_t *icall, void *arg)
@@ -431 +432 @@
                 
                 case NET_IL_RECEIVED:
-                        rc = packet_translate_remote(arp_globals.net_phone, &packet,
+                        rc = packet_translate_remote(arp_globals.net_sess, &packet,
                             IPC_GET_PACKET(*icall));
                         if (rc == EOK) {
@@ -439 +440 @@
                                         rc = arp_receive_message(IPC_GET_DEVICE(*icall), packet);
                                         if (rc != 1) {
-                                                pq_release_remote(arp_globals.net_phone,
+                                                pq_release_remote(arp_globals.net_sess,
                                                     packet_get_id(packet));
                                         }
@@ -564 +565 @@
                 
                 /* Bind */
-                device->phone = nil_bind_service(device->service,
+                device->sess = nil_bind_service(device->service,
                     (sysarg_t) device->device_id, SERVICE_ARP,
                     arp_receiver);
-                if (device->phone < 0) {
+                if (device->sess == NULL) {
                         fibril_mutex_unlock(&arp_globals.lock);
                         arp_protos_destroy(&device->protos, free);
@@ -575 +576 @@
                 
                 /* Get packet dimensions */
-                rc = nil_packet_size_req(device->phone, device_id,
+                rc = nil_packet_size_req(device->sess, device_id,
                     &device->packet_dimension);
                 if (rc != EOK) {
@@ -585 +586 @@
                 
                 /* Get hardware address */
-                rc = nil_get_addr_req(device->phone, device_id, &device->addr,
+                rc = nil_get_addr_req(device->sess, device_id, &device->addr,
                     &device->addr_data);
                 if (rc != EOK) {
@@ -595 +596 @@
                 
                 /* Get broadcast address */
-                rc = nil_get_broadcast_addr_req(device->phone, device_id,
+                rc = nil_get_broadcast_addr_req(device->sess, device_id,
                     &device->broadcast_addr, &device->broadcast_data);
                 if (rc != EOK) {
@@ -627 +628 @@
 }
 
-int il_initialize(int net_phone)
+int il_initialize(async_sess_t *net_sess)
 {
         fibril_mutex_initialize(&arp_globals.lock);
         
         fibril_mutex_lock(&arp_globals.lock);
-        arp_globals.net_phone = net_phone;
+        arp_globals.net_sess = net_sess;
         int rc = arp_cache_initialize(&arp_globals.cache);
         fibril_mutex_unlock(&arp_globals.lock);
@@ -647 +648 @@
                 return ELIMIT;
         
-        packet_t *packet = packet_get_4_remote(arp_globals.net_phone,
+        packet_t *packet = packet_get_4_remote(arp_globals.net_sess,
             device->packet_dimension.addr_len, device->packet_dimension.prefix,
             length, device->packet_dimension.suffix);
@@ -655 +656 @@
         arp_header_t *header = (arp_header_t *) packet_suffix(packet, length);
         if (!header) {
-                pq_release_remote(arp_globals.net_phone, packet_get_id(packet));
+                pq_release_remote(arp_globals.net_sess, packet_get_id(packet));
                 return ENOMEM;
         }
@@ -680 +681 @@
             (uint8_t *) device->broadcast_addr->value, device->addr->length);
         if (rc != EOK) {
-                pq_release_remote(arp_globals.net_phone, packet_get_id(packet));
+                pq_release_remote(arp_globals.net_sess, packet_get_id(packet));
                 return rc;
         }
         
-        nil_send_msg(device->phone, device_id, packet, SERVICE_ARP);
+        nil_send_msg(device->sess, device_id, packet, SERVICE_ARP);
         return EOK;
 }
@@ -890 +891 @@
         
         case NET_ARP_CLEAR_DEVICE:
-                return arp_clear_device_req(0, IPC_GET_DEVICE(*call));
+                return arp_clear_device_req(IPC_GET_DEVICE(*call));
         
         case NET_ARP_CLEAR_ADDRESS:
@@ -897 +898 @@
                         return rc;
                 
-                arp_clear_address_req(0, IPC_GET_DEVICE(*call),
+                arp_clear_address_req(IPC_GET_DEVICE(*call),
                     IPC_GET_SERVICE(*call), address);
                 free(address);
@@ -904 +905 @@
         
         case NET_ARP_CLEAN_CACHE:
-                return arp_clean_cache_req(0);
+                return arp_clean_cache_req();
         }
         

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

@@ -38 +38 @@
 #define NET_ARP_H_
 
+#include <async.h>
 #include <fibril_synch.h>
 #include <ipc/services.h>
@@ -104 +105 @@
         /** Packet dimension. */
         packet_dimension_t packet_dimension;
-        /** Device module phone. */
-        int phone;
+        /** Device module session. */
+        async_sess_t *sess;
         
         /**
@@ -122 +123 @@
         arp_cache_t cache;
         
-        /** Networking module phone. */
-        int net_phone;
+        /** Networking module session. */
+        async_sess_t *net_sess;
+        
         /** Safety lock. */
         fibril_mutex_t lock;

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

@@ -77 +77 @@
 #include <il_skel.h>
 
-// FIXME: remove this header
-#include <kernel/ipc/ipc_methods.h>
-
 /** IP module name. */
 #define NAME                    "ip"
@@ -125 +122 @@
 static void ip_receiver(ipc_callid_t, ipc_call_t *, void *);
 
-/** 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.
+/** 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;
 }
 
@@ -182 +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) {
@@ -221 +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);
@@ -253 +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;
@@ -355 +356 @@
 
         /* 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)
@@ -423 +424 @@
 
         /* 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;
         }
 
@@ -438 +439 @@
                         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);
@@ -449 +450 @@
 
         /* 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)
@@ -481 +482 @@
 }
 
-static int ip_device_req_local(int il_phone, device_id_t device_id,
-    services_t netif)
+static int ip_device_req_local(device_id_t device_id, services_t netif)
 {
         ip_netif_t *ip_netif;
@@ -516 +516 @@
 
         /* 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");
         
@@ -932 +932 @@
 
         /* 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)
@@ -969 +969 @@
         /* 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));
@@ -994 +994 @@
 }
 
-/** 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;
@@ -1016 +1017 @@
         packet_t *new_packet;
         int result;
-        int phone;
-
+        async_sess_t *sess;
+        
         next = packet;
         /* Check all packets */
@@ -1039 +1040 @@
                         /* 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));
                         }
@@ -1061 +1061 @@
 }
 
-/** 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,
@@ -1084 +1084 @@
         measured_string_t *translation;
         uint8_t *data;
-        int phone;
+        async_sess_t *sess;
         int rc;
 
@@ -1093 +1093 @@
                 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;
@@ -1106 +1106 @@
                                 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);
                         }
@@ -1122 +1122 @@
         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,
@@ -1129 +1129 @@
                     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);
                 }
@@ -1142 +1142 @@
 }
 
-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(device_id_t device_id, packet_t *packet,
+    services_t sender, services_t error)
 {
         int addrlen;
@@ -1152 +1152 @@
         in_addr_t *dest;
         in_addr_t *src;
-        int phone;
+        async_sess_t *sess;
         int rc;
 
@@ -1197 +1197 @@
         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);
                 }
@@ -1228 +1228 @@
                 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);
                         }
@@ -1316 +1316 @@
 {
         ip_proto_t *proto;
-        int phone;
+        async_sess_t *sess;
         services_t service;
         tl_received_msg_t received_msg;
@@ -1369 +1369 @@
         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);
                 }
@@ -1384 +1384 @@
                 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);
@@ -1418 +1418 @@
         in_addr_t dest;
         ip_route_t *route;
-        int phone;
+        async_sess_t *sess;
         struct sockaddr *addr;
         struct sockaddr_in addr_in;
@@ -1431 +1431 @@
         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);
@@ -1442 +1442 @@
 
         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;
@@ -1473 +1473 @@
         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);
                 }
@@ -1493 +1493 @@
         }
 
-        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);
         }
@@ -1503 +1503 @@
 }
 
-/** 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.
+/** 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(device_id_t device_id, size_t *addr_len,
@@ -1595 +1595 @@
  * @param[in,out] icall Message parameters.
  * @param[in]     arg   Local argument.
+ *
  */
 static void ip_receiver(ipc_callid_t iid, ipc_call_t *icall, void *arg)
@@ -1610 +1611 @@
                 
                 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) {
@@ -1637 +1638 @@
 }
 
-/** 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)
 {
@@ -1660 +1662 @@
         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)
@@ -1669 +1671 @@
         proto->protocol = protocol;
         proto->service = service;
-        proto->phone = phone;
+        proto->sess = sess;
         proto->received_msg = received_msg;
 
@@ -1681 +1683 @@
         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(device_id_t device_id, in_addr_t address,
     in_addr_t netmask, in_addr_t gateway)
 {
@@ -1723 +1723 @@
 }
 
-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(device_id_t device_id, in_addr_t gateway)
 {
         ip_netif_t *netif;
@@ -1748 +1747 @@
 /** 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(device_id_t device_id,
     packet_t *packet, services_t target, services_t error)
 {
@@ -1804 +1802 @@
                         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);
                 }
@@ -1818 +1816 @@
 }
 
-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)
@@ -1920 +1917 @@
                 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_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));
 
@@ -1952 +1951 @@
                         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)
@@ -1983 +1982 @@
         
         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));
         }

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

@@ -38 +38 @@
 #define NET_IP_H_
 
+#include <async.h>
 #include <fibril_synch.h>
 #include <ipc/services.h>
@@ -98 +99 @@
         /** Packet dimension. */
         packet_dimension_t packet_dimension;
-        /** Netif module phone. */
-        int phone;
+        /** Netif module session. */
+        async_sess_t *sess;
         /** Routing table. */
         ip_routes_t routes;
@@ -112 +113 @@
 /** IP protocol specific data. */
 struct ip_proto {
-        /** Protocol module phone. */
-        int phone;
+        /** Protocol module session. */
+        async_sess_t *sess;
         /** Protocol number. */
         int protocol;
@@ -142 +143 @@
         /** Known support modules. */
         modules_t modules;
-        /** Networking module phone. */
-        int net_phone;
+        /** Networking module session. */
+        async_sess_t *net_sess;
         /** Registered network interfaces. */
         ip_netifs_t netifs;

uspace/srv/net/net/net.c

@@ -36 +36 @@
  */
 
-#include "net.h"
-
 #include <async.h>
 #include <ctype.h>
 #include <ddi.h>
-#include <ns.h>
 #include <errno.h>
 #include <malloc.h>
@@ -47 +44 @@
 #include <str.h>
 #include <str_error.h>
-
+#include <ns.h>
 #include <ipc/services.h>
 #include <ipc/net.h>
@@ -53 +50 @@
 #include <ipc/il.h>
 #include <ipc/nil.h>
-
 #include <net/modules.h>
 #include <net/packet.h>
 #include <net/device.h>
-
 #include <adt/char_map.h>
 #include <adt/generic_char_map.h>
 #include <adt/measured_strings.h>
 #include <adt/module_map.h>
-
 #include <netif_remote.h>
 #include <nil_remote.h>
 #include <net_interface.h>
 #include <ip_interface.h>
+#include "net.h"
 
 /** Networking module name. */
@@ -394 +389 @@
 }
 
-int net_get_conf_req(int net_phone, measured_string_t **configuration,
+static int net_get_conf_req_local(measured_string_t **configuration,
     size_t count, uint8_t **data)
 {
@@ -403 +398 @@
 }
 
-int net_get_device_conf_req(int net_phone, device_id_t device_id,
+static int net_get_device_conf_req_local(device_id_t device_id,
     measured_string_t **configuration, size_t count, uint8_t **data)
 {
@@ -479 +474 @@
         uintptr_t io = setting ? strtol((char *) setting->value, NULL, 16) : 0;
         
-        rc = netif_probe_req(netif->driver->phone, netif->id, irq, (void *) io);
+        rc = netif_probe_req(netif->driver->sess, netif->id, irq, (void *) io);
         if (rc != EOK)
                 return rc;
         
         /* Network interface layer startup */
-        services_t internet_service;
         if (netif->nil) {
                 setting = measured_strings_find(&netif->configuration, (uint8_t *) CONF_MTU, 0);
@@ -493 +487 @@
                 int mtu = setting ? strtol((char *) setting->value, NULL, 10) : 0;
                 
-                rc = nil_device_req(netif->nil->phone, netif->id, mtu,
-                    netif->driver->service);
+                rc = nil_device_req(netif->nil->sess, netif->id, mtu);
                 if (rc != EOK)
                         return rc;
-                
-                internet_service = netif->nil->service;
-        } else
-                internet_service = netif->driver->service;
+        }
         
         /* Inter-network layer startup */
-        switch (netif->il->service) {
-        case SERVICE_IP:
-                rc = ip_device_req(netif->il->phone, netif->id,
-                    internet_service);
-                if (rc != EOK)
-                        return rc;
-                break;
-        default:
-                return ENOENT;
-        }
-        
-        return netif_start_req(netif->driver->phone, netif->id);
+        rc = ip_device_req(netif->il->sess, netif->id);
+        if (rc != EOK)
+                return rc;
+        
+        return netif_start_req(netif->driver->sess, netif->id);
 }
 
@@ -649 +632 @@
                 if (rc != EOK)
                         return rc;
-                net_get_device_conf_req(0, IPC_GET_DEVICE(*call), &strings,
+                net_get_device_conf_req_local(IPC_GET_DEVICE(*call), &strings,
                     IPC_GET_COUNT(*call), NULL);
                 
@@ -663 +646 @@
                 if (rc != EOK)
                         return rc;
-                net_get_conf_req(0, &strings, IPC_GET_COUNT(*call), NULL);
+                net_get_conf_req_local(&strings, IPC_GET_COUNT(*call), NULL);
                 
                 /* Strings should not contain received data anymore */
@@ -683 +666 @@
  * @param[in] icall The initial message call structure.
  * @param[in] arg   Local argument.
+ *
  */
 static void net_client_connection(ipc_callid_t iid, ipc_call_t *icall,

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

@@ -148 +148 @@
         null_device_stats((device_stats_t *) (*device)->specific);
         (*device)->device_id = device_id;
-        (*device)->nil_phone = -1;
         (*device)->state = NETIF_STOPPED;
         int index = netif_device_map_add(&netif_globals.device_map,
@@ -202 +201 @@
         } while (next);
         
-        int phone = device->nil_phone;
+        async_sess_t *nil_sess = netif_globals.nil_sess;
         fibril_rwlock_write_unlock(&netif_globals.lock);
         
-        nil_received_msg(phone, device_id, packet, sender);
+        nil_received_msg(nil_sess, device_id, packet, sender);
         
         fibril_rwlock_write_lock(&netif_globals.lock);
@@ -226 +225 @@
 {
         /* Start the module */
-        return netif_module_start();
+        return netif_module_start(SERVICE_NILDUMMY);
 }
 

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

@@ -59 +59 @@
 #include <packet_remote.h>
 #include <nil_skel.h>
-
-// FIXME: remove this header
-#include <kernel/ipc/ipc_methods.h>
-
 #include "eth.h"
 
@@ -171 +167 @@
 INT_MAP_IMPLEMENT(eth_protos, eth_proto_t);
 
-int nil_device_state_msg_local(int nil_phone, device_id_t device_id, int state)
+int nil_device_state_msg_local(device_id_t device_id, sysarg_t state)
 {
         int index;
@@ -180 +176 @@
             index--) {
                 proto = eth_protos_get_index(&eth_globals.protos, index);
-                if (proto && proto->phone) {
-                        il_device_state_msg(proto->phone, device_id, state,
+                if ((proto) && (proto->sess)) {
+                        il_device_state_msg(proto->sess, device_id, state,
                             proto->service);
                 }
@@ -190 +186 @@
 }
 
-int nil_initialize(int net_phone)
+int nil_initialize(async_sess_t *sess)
 {
         int rc;
@@ -199 +195 @@
         fibril_rwlock_write_lock(&eth_globals.devices_lock);
         fibril_rwlock_write_lock(&eth_globals.protos_lock);
-        eth_globals.net_phone = net_phone;
+        eth_globals.net_sess = sess;
 
         eth_globals.broadcast_addr =
@@ -226 +222 @@
 }
 
-/** Processes IPC messages from the registered device driver modules in an
+/** Process IPC messages from the registered device driver modules in an
  * infinite loop.
  *
- * @param[in] iid       The message identifier.
- * @param[in,out] icall The message parameters.
- * @param[in] arg       Local argument.
+ * @param[in]     iid   Message identifier.
+ * @param[in,out] icall Message parameters.
+ * @param[in]     arg   Local argument.
+ *
  */
 static void eth_receiver(ipc_callid_t iid, ipc_call_t *icall, void *arg)
@@ -241 +238 @@
                 switch (IPC_GET_IMETHOD(*icall)) {
                 case NET_NIL_DEVICE_STATE:
-                        nil_device_state_msg_local(0, IPC_GET_DEVICE(*icall),
+                        nil_device_state_msg_local(IPC_GET_DEVICE(*icall),
                             IPC_GET_STATE(*icall));
                         async_answer_0(iid, EOK);
                         break;
                 case NET_NIL_RECEIVED:
-                        rc = packet_translate_remote(eth_globals.net_phone,
+                        rc = packet_translate_remote(eth_globals.net_sess,
                             &packet, IPC_GET_PACKET(*icall));
                         if (rc == EOK)
-                                rc = nil_received_msg_local(0,
-                                    IPC_GET_DEVICE(*icall), packet, 0);
+                                rc = nil_received_msg_local(IPC_GET_DEVICE(*icall),
+                                    packet, 0);
                         
                         async_answer_0(iid, (sysarg_t) rc);
@@ -326 +323 @@
                         proto = eth_protos_get_index(&eth_globals.protos,
                             index);
-                        if (proto->phone) {
-                                il_mtu_changed_msg(proto->phone,
+                        if (proto->sess) {
+                                il_mtu_changed_msg(proto->sess,
                                     device->device_id, device->mtu,
                                     proto->service);
@@ -351 +348 @@
 
         configuration = &names[0];
-        rc = net_get_device_conf_req(eth_globals.net_phone, device->device_id,
+        rc = net_get_device_conf_req(eth_globals.net_sess, device->device_id,
             &configuration, count, &data);
         if (rc != EOK) {
@@ -380 +377 @@
         
         /* Bind the device driver */
-        device->phone = netif_bind_service(device->service, device->device_id,
+        device->sess = netif_bind_service(device->service, device->device_id,
             SERVICE_ETHERNET, eth_receiver);
-        if (device->phone < 0) {
+        if (device->sess == NULL) {
                 fibril_rwlock_write_unlock(&eth_globals.devices_lock);
                 free(device);
-                return device->phone;
+                return ENOENT;
         }
         
         /* Get hardware address */
-        rc = netif_get_addr_req(device->phone, device->device_id, &device->addr,
+        rc = netif_get_addr_req(device->sess, device->device_id, &device->addr,
             &device->addr_data);
         if (rc != EOK) {
@@ -509 +506 @@
 }
 
-int nil_received_msg_local(int nil_phone, device_id_t device_id,
-    packet_t *packet, services_t target)
+int nil_received_msg_local(device_id_t device_id, packet_t *packet,
+    services_t target)
 {
         eth_proto_t *proto;
@@ -532 +529 @@
                 proto = eth_process_packet(flags, packet);
                 if (proto) {
-                        il_received_msg(proto->phone, device_id, packet,
+                        il_received_msg(proto->sess, device_id, packet,
                             proto->service);
                 } else {
                         /* Drop invalid/unknown */
-                        pq_release_remote(eth_globals.net_phone,
+                        pq_release_remote(eth_globals.net_sess,
                             packet_get_id(packet));
                 }
@@ -615 +612 @@
 }
 
-/** Registers receiving module service.
- *
- * Passes received packets for this service.
- *
- * @param[in] service   The module service.
- * @param[in] phone     The service phone.
- * @return              EOK on success.
- * @return              ENOENT if the service is not known.
- * @return              ENOMEM if there is not enough memory left.
- */
-static int eth_register_message(services_t service, int phone)
+/** Register receiving module service.
+ *
+ * Pass received packets for this service.
+ *
+ * @param[in] service Module service.
+ * @param[in] sess    Service session.
+ *
+ * @return EOK on success.
+ * @return ENOENT if the service is not known.
+ * @return ENOMEM if there is not enough memory left.
+ *
+ */
+static int eth_register_message(services_t service, async_sess_t *sess)
 {
         eth_proto_t *proto;
@@ -638 +637 @@
         proto = eth_protos_find(&eth_globals.protos, protocol);
         if (proto) {
-                proto->phone = phone;
+                proto->sess = sess;
                 fibril_rwlock_write_unlock(&eth_globals.protos_lock);
                 return EOK;
@@ -650 +649 @@
                 proto->service = service;
                 proto->protocol = protocol;
-                proto->phone = phone;
+                proto->sess = sess;
 
                 index = eth_protos_add(&eth_globals.protos, protocol, proto);
@@ -660 +659 @@
         }
         
-        printf("%s: Protocol registered (protocol: %d, service: %d, phone: "
-            "%d)\n", NAME, proto->protocol, proto->service, proto->phone);
+        printf("%s: Protocol registered (protocol: %d, service: %d)\n",
+            NAME, proto->protocol, proto->service);
         
         fibril_rwlock_write_unlock(&eth_globals.protos_lock);
@@ -799 +798 @@
         ethertype = htons(protocol_map(SERVICE_ETHERNET, sender));
         if (!ethertype) {
-                pq_release_remote(eth_globals.net_phone, packet_get_id(packet));
+                pq_release_remote(eth_globals.net_sess, packet_get_id(packet));
                 return EINVAL;
         }
@@ -820 +819 @@
                         if (next == packet)
                                 packet = tmp;
-                        pq_release_remote(eth_globals.net_phone,
+                        pq_release_remote(eth_globals.net_sess,
                             packet_get_id(next));
                         next = tmp;
@@ -830 +829 @@
         /* Send packet queue */
         if (packet) {
-                netif_send_msg(device->phone, device_id, packet,
+                netif_send_msg(device->sess, device_id, packet,
                     SERVICE_ETHERNET);
         }
@@ -854 +853 @@
                 return EOK;
         
+        async_sess_t *callback =
+            async_callback_receive_start(EXCHANGE_SERIALIZE, call);
+        if (callback)
+                return eth_register_message(NIL_GET_PROTO(*call), callback);
+        
         switch (IPC_GET_IMETHOD(*call)) {
         case NET_NIL_DEVICE:
@@ -859 +863 @@
                     IPC_GET_SERVICE(*call), IPC_GET_MTU(*call));
         case NET_NIL_SEND:
-                rc = packet_translate_remote(eth_globals.net_phone, &packet,
+                rc = packet_translate_remote(eth_globals.net_sess, &packet,
                     IPC_GET_PACKET(*call));
                 if (rc != EOK)
@@ -888 +892 @@
                         return EOK;
                 return measured_strings_reply(address, 1);
-        case IPC_M_CONNECT_TO_ME:
-                return eth_register_message(NIL_GET_PROTO(*call),
-                    IPC_GET_PHONE(*call));
         }
         

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

@@ -38 +38 @@
 #define NET_ETH_H_
 
+#include <async.h>
 #include <fibril_synch.h>
 #include <ipc/services.h>
-
 #include <net/device.h>
 #include <adt/measured_strings.h>
@@ -223 +223 @@
         /** Device driver service. */
         services_t service;
-        /** Driver phone. */
-        int phone;
+        /** Driver session. */
+        async_sess_t *sess;
         /** Maximal transmission unit. */
         size_t mtu;
@@ -248 +248 @@
         /** Protocol identifier. */
         int protocol;
-        /** Protocol module phone. */
-        int phone;
+        /** Protocol module session. */
+        async_sess_t *sess;
 };
 
 /** Ethernet global data. */
 struct eth_globals {
-        /** Networking module phone. */
-        int net_phone;
+        /** Networking module session. */
+        async_sess_t *net_sess;
         /** Safety lock for devices. */
         fibril_rwlock_t devices_lock;
@@ -265 +265 @@
         /**
          * Protocol map.
-         * Service phone map for each protocol.
+         * Service map for each protocol.
          */
         eth_protos_t protos;

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

@@ -44 +44 @@
 #include <ipc/net.h>
 #include <ipc/services.h>
-
 #include <net/modules.h>
 #include <net/device.h>
@@ -53 +52 @@
 #include <netif_remote.h>
 #include <nil_skel.h>
-
-// FIXME: remove this header
-#include <kernel/ipc/ipc_methods.h>
-
 #include "nildummy.h"
 
@@ -70 +65 @@
 DEVICE_MAP_IMPLEMENT(nildummy_devices, nildummy_device_t);
 
-int nil_device_state_msg_local(int nil_phone, device_id_t device_id, int state)
+int nil_device_state_msg_local(device_id_t device_id, sysarg_t state)
 {
         fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
-        if (nildummy_globals.proto.phone)
-                il_device_state_msg(nildummy_globals.proto.phone, device_id,
+        if (nildummy_globals.proto.sess)
+                il_device_state_msg(nildummy_globals.proto.sess, device_id,
                     state, nildummy_globals.proto.service);
         fibril_rwlock_read_unlock(&nildummy_globals.protos_lock);
@@ -81 +76 @@
 }
 
-int nil_initialize(int net_phone)
+int nil_initialize(async_sess_t *sess)
 {
         fibril_rwlock_initialize(&nildummy_globals.devices_lock);
@@ -88 +83 @@
         fibril_rwlock_write_lock(&nildummy_globals.protos_lock);
         
-        nildummy_globals.net_phone = net_phone;
-        nildummy_globals.proto.phone = 0;
+        nildummy_globals.net_sess = sess;
+        nildummy_globals.proto.sess = NULL;
         int rc = nildummy_devices_initialize(&nildummy_globals.devices);
         
@@ -102 +97 @@
  * @param[in]     iid   Message identifier.
  * @param[in,out] icall Message parameters.
- * @param[in]     arg   Local argument.
+ * @param[in]     arg    Local argument.
+ *
  */
 static void nildummy_receiver(ipc_callid_t iid, ipc_call_t *icall, void *arg)
@@ -112 +108 @@
                 switch (IPC_GET_IMETHOD(*icall)) {
                 case NET_NIL_DEVICE_STATE:
-                        rc = nil_device_state_msg_local(0,
-                            IPC_GET_DEVICE(*icall), IPC_GET_STATE(*icall));
+                        rc = nil_device_state_msg_local(IPC_GET_DEVICE(*icall),
+                            IPC_GET_STATE(*icall));
                         async_answer_0(iid, (sysarg_t) rc);
                         break;
                 
                 case NET_NIL_RECEIVED:
-                        rc = packet_translate_remote(nildummy_globals.net_phone,
+                        rc = packet_translate_remote(nildummy_globals.net_sess,
                             &packet, IPC_GET_PACKET(*icall));
                         if (rc == EOK)
-                                rc = nil_received_msg_local(0,
-                                    IPC_GET_DEVICE(*icall), packet, 0);
+                                rc = nil_received_msg_local(IPC_GET_DEVICE(*icall),
+                                    packet, 0);
                         
                         async_answer_0(iid, (sysarg_t) rc);
@@ -180 +176 @@
                 /* Notify the upper layer module */
                 fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
-                if (nildummy_globals.proto.phone) {
-                        il_mtu_changed_msg(nildummy_globals.proto.phone,
+                if (nildummy_globals.proto.sess) {
+                        il_mtu_changed_msg(nildummy_globals.proto.sess,
                             device->device_id, device->mtu,
                             nildummy_globals.proto.service);
@@ -203 +199 @@
 
         /* Bind the device driver */
-        device->phone = netif_bind_service(device->service, device->device_id,
+        device->sess = netif_bind_service(device->service, device->device_id,
             SERVICE_ETHERNET, nildummy_receiver);
-        if (device->phone < 0) {
+        if (device->sess == NULL) {
                 fibril_rwlock_write_unlock(&nildummy_globals.devices_lock);
                 free(device);
-                return device->phone;
+                return ENOENT;
         }
         
         /* Get hardware address */
-        int rc = netif_get_addr_req(device->phone, device->device_id,
+        int rc = netif_get_addr_req(device->sess, device->device_id,
             &device->addr, &device->addr_data);
         if (rc != EOK) {
@@ -307 +303 @@
 }
 
-int nil_received_msg_local(int nil_phone, device_id_t device_id,
-    packet_t *packet, services_t target)
+int nil_received_msg_local(device_id_t device_id, packet_t *packet,
+    services_t target)
 {
         fibril_rwlock_read_lock(&nildummy_globals.protos_lock);
         
-        if (nildummy_globals.proto.phone) {
+        if (nildummy_globals.proto.sess) {
                 do {
                         packet_t *next = pq_detach(packet);
-                        il_received_msg(nildummy_globals.proto.phone, device_id,
+                        il_received_msg(nildummy_globals.proto.sess, device_id,
                             packet, nildummy_globals.proto.service);
                         packet = next;
@@ -331 +327 @@
  *
  * @param[in] service Module service.
- * @param[in] phone   Service phone.
+ * @param[in] sess    Service session.
  *
  * @return EOK on success.
@@ -338 +334 @@
  *
  */
-static int nildummy_register_message(services_t service, int phone)
+static int nildummy_register_message(services_t service, async_sess_t *sess)
 {
         fibril_rwlock_write_lock(&nildummy_globals.protos_lock);
         nildummy_globals.proto.service = service;
-        nildummy_globals.proto.phone = phone;
-        
-        printf("%s: Protocol registered (service: %d, phone: %d)\n",
-            NAME, nildummy_globals.proto.service, nildummy_globals.proto.phone);
+        nildummy_globals.proto.sess = sess;
+        
+        printf("%s: Protocol registered (service: %d)\n",
+            NAME, nildummy_globals.proto.service);
         
         fibril_rwlock_write_unlock(&nildummy_globals.protos_lock);
@@ -376 +372 @@
         /* Send packet queue */
         if (packet)
-                netif_send_msg(device->phone, device_id, packet,
+                netif_send_msg(device->sess, device_id, packet,
                     SERVICE_NILDUMMY);
         
@@ -400 +396 @@
                 return EOK;
         
+        async_sess_t *callback =
+            async_callback_receive_start(EXCHANGE_SERIALIZE, call);
+        if (callback)
+                return nildummy_register_message(NIL_GET_PROTO(*call), callback);
+        
         switch (IPC_GET_IMETHOD(*call)) {
         case NET_NIL_DEVICE:
@@ -406 +407 @@
         
         case NET_NIL_SEND:
-                rc = packet_translate_remote(nildummy_globals.net_phone,
+                rc = packet_translate_remote(nildummy_globals.net_sess,
                     &packet, IPC_GET_PACKET(*call));
                 if (rc != EOK)
@@ -436 +437 @@
                         return rc;
                 return measured_strings_reply(address, 1);
-        
-        case IPC_M_CONNECT_TO_ME:
-                return nildummy_register_message(NIL_GET_PROTO(*call),
-                    IPC_GET_PHONE(*call));
         }
         

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

@@ -38 +38 @@
 #define NET_NILDUMMY_H_
 
+#include <async.h>
 #include <fibril_synch.h>
 #include <ipc/services.h>
-
 #include <net/device.h>
 #include <adt/measured_strings.h>
@@ -81 +81 @@
         services_t service;
         
-        /** Driver phone. */
-        int phone;
+        /** Driver session. */
+        async_sess_t *sess;
         
         /** Maximal transmission unit. */
@@ -99 +99 @@
         services_t service;
         
-        /** Protocol module phone. */
-        int phone;
+        /** Protocol module session. */
+        async_sess_t *sess;
 };
 
 /** Dummy nil global data. */
 struct nildummy_globals {
-        /** Networking module phone. */
-        int net_phone;
+        /** Networking module session. */
+        async_sess_t *net_sess;
         
         /** Lock for devices. */

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

@@ -118 +118 @@
 
 /** Global data */
-static int phone_net = -1;
-static int phone_ip = -1;
+static async_sess_t *net_sess = NULL;
+static async_sess_t *ip_sess = NULL;
 static bool error_reporting = true;
 static bool echo_replying = true;
@@ -173 +173 @@
 static void icmp_release(packet_t *packet)
 {
-        pq_release_remote(phone_net, packet_get_id(packet));
+        pq_release_remote(net_sess, packet_get_id(packet));
 }
 
@@ -225 +225 @@
         }
         
-        return ip_send_msg(phone_ip, -1, packet, SERVICE_ICMP, error);
+        return ip_send_msg(ip_sess, -1, packet, SERVICE_ICMP, error);
 }
 
@@ -297 +297 @@
         size_t length = (size_t) addrlen;
         
-        packet_t *packet = packet_get_4_remote(phone_net, size,
+        packet_t *packet = packet_get_4_remote(net_sess, size,
             icmp_dimension.addr_len, ICMP_HEADER_SIZE + icmp_dimension.prefix,
             icmp_dimension.suffix);
@@ -595 +595 @@
         case ICMP_SKIP:
         case ICMP_PHOTURIS:
-                ip_received_error_msg(phone_ip, -1, packet,
+                ip_received_error_msg(ip_sess, -1, packet,
                     SERVICE_IP, SERVICE_ICMP);
                 return EOK;
@@ -609 +609 @@
  * @param[in,out] icall Message parameters.
  * @param[in]     arg   Local argument.
+ *
  */
 static void icmp_receiver(ipc_callid_t iid, ipc_call_t *icall, void *arg)
@@ -621 +622 @@
                 switch (IPC_GET_IMETHOD(*icall)) {
                 case NET_TL_RECEIVED:
-                        rc = packet_translate_remote(phone_net, &packet,
+                        rc = packet_translate_remote(net_sess, &packet,
                             IPC_GET_PACKET(*icall));
                         if (rc == EOK) {
@@ -641 +642 @@
 /** Initialize the ICMP module.
  *
- * @param[in] net_phone Network module phone.
+ * @param[in] sess Network module session.
  *
  * @return EOK on success.
@@ -647 +648 @@
  *
  */
-int tl_initialize(int net_phone)
+int tl_initialize(async_sess_t *sess)
 {
         measured_string_t names[] = {
@@ -669 +670 @@
         atomic_set(&icmp_client, 0);
         
-        phone_net = net_phone;
-        phone_ip = ip_bind_service(SERVICE_IP, IPPROTO_ICMP, SERVICE_ICMP,
+        net_sess = sess;
+        ip_sess = ip_bind_service(SERVICE_IP, IPPROTO_ICMP, SERVICE_ICMP,
             icmp_receiver);
-        if (phone_ip < 0)
-                return phone_ip;
-        
-        int rc = ip_packet_size_req(phone_ip, -1, &icmp_dimension);
+        if (ip_sess == NULL)
+                return ENOENT;
+        
+        int rc = ip_packet_size_req(ip_sess, -1, &icmp_dimension);
         if (rc != EOK)
                 return rc;
@@ -684 +685 @@
         /* Get configuration */
         configuration = &names[0];
-        rc = net_get_conf_req(phone_net, &configuration, count, &data);
+        rc = net_get_conf_req(net_sess, &configuration, count, &data);
         if (rc != EOK)
                 return rc;
@@ -762 +763 @@
         
         case NET_ICMP_DEST_UNREACH:
-                rc = packet_translate_remote(phone_net, &packet,
+                rc = packet_translate_remote(net_sess, &packet,
                     IPC_GET_PACKET(*call));
                 if (rc != EOK)
@@ -771 +772 @@
         
         case NET_ICMP_SOURCE_QUENCH:
-                rc = packet_translate_remote(phone_net, &packet,
+                rc = packet_translate_remote(net_sess, &packet,
                     IPC_GET_PACKET(*call));
                 if (rc != EOK)
@@ -779 +780 @@
         
         case NET_ICMP_TIME_EXCEEDED:
-                rc = packet_translate_remote(phone_net, &packet,
+                rc = packet_translate_remote(net_sess, &packet,
                     IPC_GET_PACKET(*call));
                 if (rc != EOK)
@@ -787 +788 @@
         
         case NET_ICMP_PARAMETERPROB:
-                rc = packet_translate_remote(phone_net, &packet,
+                rc = packet_translate_remote(net_sess, &packet,
                     IPC_GET_PACKET(*call));
                 if (rc != EOK)

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

@@ -38 +38 @@
 #include <assert.h>
 #include <async.h>
-#include <async_obsolete.h>
 #include <fibril_synch.h>
 #include <malloc.h>
@@ -74 +73 @@
 #include "tcp_header.h"
 
-// FIXME: remove this header
-#include <kernel/ipc/ipc_methods.h>
-
 /** TCP module name. */
 #define NAME  "tcp"
@@ -210 +206 @@
 
 static int tcp_received_msg(device_id_t, packet_t *, services_t, services_t);
-static int tcp_process_client_messages(ipc_callid_t, ipc_call_t);
+static int tcp_process_client_messages(async_sess_t *, ipc_callid_t,
+    ipc_call_t);
 
 static int tcp_listen_message(socket_cores_t *, int, int);
@@ -328 +325 @@
 
         if (!socket) {
-                if (tl_prepare_icmp_packet(tcp_globals.net_phone,
-                    tcp_globals.icmp_phone, packet, error) == EOK) {
-                        icmp_destination_unreachable_msg(tcp_globals.icmp_phone,
+                if (tl_prepare_icmp_packet(tcp_globals.net_sess,
+                    tcp_globals.icmp_sess, packet, error) == EOK) {
+                        icmp_destination_unreachable_msg(tcp_globals.icmp_sess,
                             ICMP_PORT_UNREACH, 0, packet);
                 }
@@ -401 +398 @@
                 fibril_rwlock_write_unlock(socket_data->local_lock);
 
-                rc = tl_prepare_icmp_packet(tcp_globals.net_phone,
-                    tcp_globals.icmp_phone, packet, error);
+                rc = tl_prepare_icmp_packet(tcp_globals.net_sess,
+                    tcp_globals.icmp_sess, packet, error);
                 if (rc == EOK) {
                         /* Checksum error ICMP */
-                        icmp_parameter_problem_msg(tcp_globals.icmp_phone,
+                        icmp_parameter_problem_msg(tcp_globals.icmp_sess,
                             ICMP_PARAM_POINTER,
                             ((size_t) ((void *) &header->checksum)) -
@@ -443 +440 @@
                 break;
         default:
-                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
+                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
         }
 
@@ -506 +503 @@
                         /* Release the acknowledged packets */
                         next_packet = pq_next(packet);
-                        pq_release_remote(tcp_globals.net_phone,
+                        pq_release_remote(tcp_globals.net_sess,
                             packet_get_id(packet));
                         packet = next_packet;
@@ -565 +562 @@
                         next_packet = pq_next(next_packet);
                         pq_insert_after(tmp_packet, next_packet);
-                        pq_release_remote(tcp_globals.net_phone,
+                        pq_release_remote(tcp_globals.net_sess,
                             packet_get_id(tmp_packet));
                 }
@@ -602 +599 @@
                                 if (packet == socket_data->incoming)
                                         socket_data->incoming = next_packet;
-                                pq_release_remote(tcp_globals.net_phone,
+                                pq_release_remote(tcp_globals.net_sess,
                                     packet_get_id(packet));
                                 packet = next_packet;
@@ -625 +622 @@
                                 if (length <= 0) {
                                         /* Remove the empty packet */
-                                        pq_release_remote(tcp_globals.net_phone,
+                                        pq_release_remote(tcp_globals.net_sess,
                                             packet_get_id(packet));
                                         packet = next_packet;
@@ -672 +669 @@
                                 }
                                 /* Remove the duplicit or corrupted packet */
-                                pq_release_remote(tcp_globals.net_phone,
+                                pq_release_remote(tcp_globals.net_sess,
                                     packet_get_id(packet));
                                 packet = next_packet;
@@ -699 +696 @@
                 if (rc != EOK) {
                         /* Remove the corrupted packets */
-                        pq_release_remote(tcp_globals.net_phone,
+                        pq_release_remote(tcp_globals.net_sess,
                             packet_get_id(packet));
-                        pq_release_remote(tcp_globals.net_phone,
+                        pq_release_remote(tcp_globals.net_sess,
                             packet_get_id(next_packet));
                 } else {
@@ -712 +709 @@
                                     new_sequence_number, length);
                                 if (rc != EOK) {
-                                        pq_release_remote(tcp_globals.net_phone,
+                                        pq_release_remote(tcp_globals.net_sess,
                                             packet_get_id(next_packet));
                                 }
                                 rc = pq_insert_after(packet, next_packet);
                                 if (rc != EOK) {
-                                        pq_release_remote(tcp_globals.net_phone,
+                                        pq_release_remote(tcp_globals.net_sess,
                                             packet_get_id(next_packet));
                                 }
@@ -726 +723 @@
                 printf("unexpected\n");
                 /* Release duplicite or restricted */
-                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
+                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
                 forced_ack = true;
         }
@@ -794 +791 @@
         if (rc != EOK)
                 return tcp_release_and_return(packet, rc);
-        rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
+        rc = tl_get_ip_packet_dimension(tcp_globals.ip_sess,
             &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
         if (rc != EOK)
@@ -803 +800 @@
 
         /* Notify the destination socket */
-        async_obsolete_msg_5(socket->phone, NET_SOCKET_RECEIVED,
-            (sysarg_t) socket->socket_id,
+        async_exch_t *exch = async_exchange_begin(socket->sess);
+        async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t) socket->socket_id,
             ((packet_dimension->content < socket_data->data_fragment_size) ?
             packet_dimension->content : socket_data->data_fragment_size), 0, 0,
             (sysarg_t) fragments);
+        async_exchange_end(exch);
 
         return EOK;
@@ -824 +822 @@
 
         /* Notify the destination socket */
-        async_obsolete_msg_5(socket->phone, NET_SOCKET_RECEIVED,
-            (sysarg_t) socket->socket_id,
-            0, 0, 0,
-            (sysarg_t) 0 /* 0 fragments == no more data */);
+        async_exch_t *exch = async_exchange_begin(socket->sess);
+        async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t) socket->socket_id,
+            0, 0, 0, (sysarg_t) 0 /* 0 fragments == no more data */);
+        async_exchange_end(exch);
 }
 
@@ -853 +851 @@
         next_packet = pq_detach(packet);
         if (next_packet) {
-                pq_release_remote(tcp_globals.net_phone,
+                pq_release_remote(tcp_globals.net_sess,
                     packet_get_id(next_packet));
         }
@@ -940 +938 @@
         /* Create a socket */
         socket_id = -1;
-        rc = socket_create(socket_data->local_sockets, listening_socket->phone,
+        rc = socket_create(socket_data->local_sockets, listening_socket->sess,
             socket_data, &socket_id);
         if (rc != EOK) {
@@ -993 +991 @@
         fibril_rwlock_write_unlock(&tcp_globals.lock);
         if (rc != EOK) {
-                socket_destroy(tcp_globals.net_phone, socket->socket_id,
+                socket_destroy(tcp_globals.net_sess, socket->socket_id,
                     socket_data->local_sockets, &tcp_globals.sockets,
                     tcp_free_socket_data);
@@ -1005 +1003 @@
         next_packet = pq_detach(packet);
         if (next_packet) {
-                pq_release_remote(tcp_globals.net_phone,
+                pq_release_remote(tcp_globals.net_sess,
                     packet_get_id(next_packet));
         }
@@ -1014 +1012 @@
                     packet_get_data_length(packet) - sizeof(*header));
                 if (rc != EOK) {
-                        socket_destroy(tcp_globals.net_phone, socket->socket_id,
+                        socket_destroy(tcp_globals.net_sess, socket->socket_id,
                             socket_data->local_sockets, &tcp_globals.sockets,
                             tcp_free_socket_data);
@@ -1025 +1023 @@
         rc = tcp_queue_packet(socket, socket_data, packet, 1);
         if (rc != EOK) {
-                socket_destroy(tcp_globals.net_phone, socket->socket_id,
+                socket_destroy(tcp_globals.net_sess, socket->socket_id,
                     socket_data->local_sockets, &tcp_globals.sockets,
                     tcp_free_socket_data);
@@ -1033 +1031 @@
         packet = tcp_get_packets_to_send(socket, socket_data);
         if (!packet) {
-                socket_destroy(tcp_globals.net_phone, socket->socket_id,
+                socket_destroy(tcp_globals.net_sess, socket->socket_id,
                     socket_data->local_sockets, &tcp_globals.sockets,
                     tcp_free_socket_data);
@@ -1068 +1066 @@
 
         socket_data->next_incoming = ntohl(header->sequence_number); /* + 1; */
-        pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
+        pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
         socket_data->state = TCP_SOCKET_ESTABLISHED;
         listening_socket = socket_cores_find(socket_data->local_sockets,
@@ -1082 +1080 @@
                 if (rc == EOK) {
                         /* Notify the destination socket */
-                        async_obsolete_msg_5(socket->phone, NET_SOCKET_ACCEPTED,
+                        async_exch_t *exch = async_exchange_begin(socket->sess);
+                        async_msg_5(exch, NET_SOCKET_ACCEPTED,
                             (sysarg_t) listening_socket->socket_id,
                             socket_data->data_fragment_size, TCP_HEADER_SIZE,
                             0, (sysarg_t) socket->socket_id);
+                        async_exchange_end(exch);
 
                         fibril_rwlock_write_unlock(socket_data->local_lock);
@@ -1181 +1181 @@
                                 /* Add to acknowledged or release */
                                 if (pq_add(&acknowledged, packet, 0, 0) != EOK)
-                                        pq_release_remote(tcp_globals.net_phone,
+                                        pq_release_remote(tcp_globals.net_sess,
                                             packet_get_id(packet));
                                 packet = next;
@@ -1190 +1190 @@
                 /* Release acknowledged */
                 if (acknowledged) {
-                        pq_release_remote(tcp_globals.net_phone,
+                        pq_release_remote(tcp_globals.net_sess,
                             packet_get_id(acknowledged));
                 }
@@ -1234 +1234 @@
         assert(answer);
         assert(answer_count);
-
+        
         *answer_count = 0;
-        switch (IPC_GET_IMETHOD(*call)) {
-        case IPC_M_CONNECT_TO_ME:
-                return tcp_process_client_messages(callid, *call);
-        }
-
+        
+        async_sess_t *callback =
+            async_callback_receive_start(EXCHANGE_SERIALIZE, call);
+        if (callback)
+                return tcp_process_client_messages(callback, callid, *call);
+        
         return ENOTSUP;
 }
@@ -1270 +1271 @@
 }
 
-int tcp_process_client_messages(ipc_callid_t callid, ipc_call_t call)
+int tcp_process_client_messages(async_sess_t *sess, ipc_callid_t callid,
+    ipc_call_t call)
 {
         int res;
         socket_cores_t local_sockets;
-        int app_phone = IPC_GET_PHONE(call);
         struct sockaddr *addr;
         int socket_id;
@@ -1325 +1326 @@
                         fibril_rwlock_write_lock(&lock);
                         socket_id = SOCKET_GET_SOCKET_ID(call);
-                        res = socket_create(&local_sockets, app_phone,
+                        res = socket_create(&local_sockets, sess,
                             socket_data, &socket_id);
                         SOCKET_SET_SOCKET_ID(answer, socket_id);
@@ -1333 +1334 @@
                                 break;
                         }
-                        if (tl_get_ip_packet_dimension(tcp_globals.ip_phone,
+                        if (tl_get_ip_packet_dimension(tcp_globals.ip_sess,
                             &tcp_globals.dimensions, DEVICE_INVALID_ID,
                             &packet_dimension) == EOK) {
@@ -1508 +1509 @@
         }
 
-        /* Release the application phone */
-        async_obsolete_hangup(app_phone);
+        /* Release the application session */
+        async_hangup(sess);
 
         printf("release\n");
         /* Release all local sockets */
-        socket_cores_release(tcp_globals.net_phone, &local_sockets,
+        socket_cores_release(tcp_globals.net_sess, &local_sockets,
             &tcp_globals.sockets, tcp_free_socket_data);
 
@@ -1621 +1622 @@
                         local_lock = socket_data->local_lock;
                         fibril_rwlock_write_lock(local_lock);
-                        socket_destroy(tcp_globals.net_phone,
+                        socket_destroy(tcp_globals.net_sess,
                             timeout->socket_id, timeout->local_sockets,
                             &tcp_globals.sockets, tcp_free_socket_data);
@@ -1754 +1755 @@
         }
 
-        rc = ip_get_route_req(tcp_globals.ip_phone, IPPROTO_TCP,
+        rc = ip_get_route_req(tcp_globals.ip_sess, IPPROTO_TCP,
             addr, addrlen, &socket_data->device_id,
             &socket_data->pseudo_header, &socket_data->headerlen);
@@ -1902 +1903 @@
                         rc = pq_insert_after(previous, copy);
                         if (rc != EOK) {
-                                pq_release_remote(tcp_globals.net_phone,
+                                pq_release_remote(tcp_globals.net_sess,
                                     packet_get_id(copy));
                                 return sending;
@@ -1939 +1940 @@
             socket_data->headerlen, packet_get_data_length(packet));
         if (rc != EOK) {
-                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
+                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
                 return NULL;
         }
@@ -1946 +1947 @@
         header = (tcp_header_t *) packet_get_data(packet);
         if (!header) {
-                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
+                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
                 return NULL;
         }
@@ -1971 +1972 @@
         rc = ip_client_prepare_packet(packet, IPPROTO_TCP, 0, 0, 0, 0);
         if (rc != EOK) {
-                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
+                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
                 return NULL;
         }
@@ -1978 +1979 @@
             sequence_number, socket_data->state, socket_data->timeout, true);
         if (rc != EOK) {
-                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
+                pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
                 return NULL;
         }
@@ -1995 +1996 @@
 
         /* Make a copy of the packet */
-        copy = packet_get_copy(tcp_globals.net_phone, packet);
+        copy = packet_get_copy(tcp_globals.net_sess, packet);
         if (!copy)
                 return NULL;
@@ -2009 +2010 @@
         while (packet) {
                 next = pq_detach(packet);
-                ip_send_msg(tcp_globals.ip_phone, device_id, packet,
+                ip_send_msg(tcp_globals.ip_sess, device_id, packet,
                     SERVICE_TCP, 0);
                 packet = next;
@@ -2122 +2123 @@
                 return NO_DATA;
 
-        rc = packet_translate_remote(tcp_globals.net_phone, &packet, packet_id);
+        rc = packet_translate_remote(tcp_globals.net_sess, &packet, packet_id);
         if (rc != EOK)
                 return rc;
@@ -2133 +2134 @@
         /* Release the packet */
         dyn_fifo_pop(&socket->received);
-        pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
+        pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
 
         /* Return the total length */
@@ -2171 +2172 @@
                 return ENOTCONN;
 
-        rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
+        rc = tl_get_ip_packet_dimension(tcp_globals.ip_sess,
             &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
         if (rc != EOK)
@@ -2182 +2183 @@
         for (index = 0; index < fragments; index++) {
                 /* Read the data fragment */
-                result = tl_socket_read_packet_data(tcp_globals.net_phone,
+                result = tl_socket_read_packet_data(tcp_globals.net_sess,
                     &packet, TCP_HEADER_SIZE, packet_dimension,
                     socket_data->addr, socket_data->addrlen);
@@ -2245 +2246 @@
         default:
                 /* Just destroy */
-                rc = socket_destroy(tcp_globals.net_phone, socket_id,
+                rc = socket_destroy(tcp_globals.net_sess, socket_id,
                     local_sockets, &tcp_globals.sockets,
                     tcp_free_socket_data);
@@ -2293 +2294 @@
 
         /* Get the device packet dimension */
-        rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
+        rc = tl_get_ip_packet_dimension(tcp_globals.ip_sess,
             &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
         if (rc != EOK)
@@ -2299 +2300 @@
 
         /* Get a new packet */
-        *packet = packet_get_4_remote(tcp_globals.net_phone, TCP_HEADER_SIZE,
+        *packet = packet_get_4_remote(tcp_globals.net_sess, TCP_HEADER_SIZE,
             packet_dimension->addr_len, packet_dimension->prefix,
             packet_dimension->suffix);
@@ -2362 +2363 @@
                         if (rc != EOK)
                                 return rc;
-                        rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
+                        rc = tl_get_ip_packet_dimension(tcp_globals.ip_sess,
                             &tcp_globals.dimensions, socket_data->device_id,
                             &packet_dimension);
@@ -2434 +2435 @@
 int tcp_release_and_return(packet_t *packet, int result)
 {
-        pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
+        pq_release_remote(tcp_globals.net_sess, packet_get_id(packet));
         return result;
 }
@@ -2443 +2444 @@
  * @param[in,out] icall Message parameters.
  * @param[in]     arg   Local argument.
+ *
  */
 static void tcp_receiver(ipc_callid_t iid, ipc_call_t *icall, void *arg)
@@ -2452 +2454 @@
                 switch (IPC_GET_IMETHOD(*icall)) {
                 case NET_TL_RECEIVED:
-                        rc = packet_translate_remote(tcp_globals.net_phone, &packet,
+                        rc = packet_translate_remote(tcp_globals.net_sess, &packet,
                             IPC_GET_PACKET(*icall));
                         if (rc == EOK)
@@ -2470 +2472 @@
 /** Initialize the TCP module.
  *
- * @param[in] net_phone Network module phone.
+ * @param[in] sess Network module session.
  *
  * @return EOK on success.
@@ -2476 +2478 @@
  *
  */
-int tl_initialize(int net_phone)
+int tl_initialize(async_sess_t *sess)
 {
         fibril_rwlock_initialize(&tcp_globals.lock);
         fibril_rwlock_write_lock(&tcp_globals.lock);
         
-        tcp_globals.net_phone = net_phone;
+        tcp_globals.net_sess = sess;
         
-        tcp_globals.icmp_phone = icmp_connect_module();
-        tcp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_TCP,
+        tcp_globals.icmp_sess = icmp_connect_module();
+        tcp_globals.ip_sess = ip_bind_service(SERVICE_IP, IPPROTO_TCP,
             SERVICE_TCP, tcp_receiver);
-        if (tcp_globals.ip_phone < 0) {
+        if (tcp_globals.ip_sess == NULL) {
                 fibril_rwlock_write_unlock(&tcp_globals.lock);
-                return tcp_globals.ip_phone;
+                return ENOENT;
         }
         

uspace/srv/net/tl/tcp/tcp.h

@@ -38 +38 @@
 #define NET_TCP_H_
 
+#include <async.h>
 #include <fibril_synch.h>
-
 #include <net/packet.h>
 #include <net/device.h>
@@ -284 +284 @@
 /** TCP global data. */
 struct tcp_globals {
-        /** Networking module phone. */
-        int net_phone;
-        /** IP module phone. */
-        int ip_phone;
-        /** ICMP module phone. */
-        int icmp_phone;
+        /** Networking module session. */
+        async_sess_t *net_sess;
+        /** IP module session. */
+        async_sess_t *ip_sess;
+        /** ICMP module session. */
+        async_sess_t *icmp_sess;
         /** Last used free port. */
         int last_used_port;

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

@@ -37 +37 @@
 
 #include <async.h>
-#include <async_obsolete.h>
 #include <fibril_synch.h>
 #include <malloc.h>
@@ -71 +70 @@
 #include "udp_header.h"
 
-// FIXME: remove this header
-#include <kernel/ipc/ipc_methods.h>
-
 /** UDP module name. */
 #define NAME  "udp"
@@ -103 +99 @@
 static int udp_release_and_return(packet_t *packet, int result)
 {
-        pq_release_remote(udp_globals.net_phone, packet_get_id(packet));
+        pq_release_remote(udp_globals.net_sess, packet_get_id(packet));
         return result;
 }
@@ -196 +192 @@
             ntohs(header->destination_port), (uint8_t *) SOCKET_MAP_KEY_LISTENING, 0);
         if (!socket) {
-                if (tl_prepare_icmp_packet(udp_globals.net_phone,
-                    udp_globals.icmp_phone, packet, error) == EOK) {
-                        icmp_destination_unreachable_msg(udp_globals.icmp_phone,
+                if (tl_prepare_icmp_packet(udp_globals.net_sess,
+                    udp_globals.icmp_sess, packet, error) == EOK) {
+                        icmp_destination_unreachable_msg(udp_globals.icmp_sess,
                             ICMP_PORT_UNREACH, 0, packet);
                 }
@@ -255 +251 @@
                         while (tmp_packet) {
                                 next_packet = pq_detach(tmp_packet);
-                                pq_release_remote(udp_globals.net_phone,
+                                pq_release_remote(udp_globals.net_sess,
                                     packet_get_id(tmp_packet));
                                 tmp_packet = next_packet;
@@ -278 +274 @@
                 if (flip_checksum(compact_checksum(checksum)) !=
                     IP_CHECKSUM_ZERO) {
-                        if (tl_prepare_icmp_packet(udp_globals.net_phone,
-                            udp_globals.icmp_phone, packet, error) == EOK) {
+                        if (tl_prepare_icmp_packet(udp_globals.net_sess,
+                            udp_globals.icmp_sess, packet, error) == EOK) {
                                 /* Checksum error ICMP */
                                 icmp_parameter_problem_msg(
-                                    udp_globals.icmp_phone, ICMP_PARAM_POINTER,
+                                    udp_globals.icmp_sess, ICMP_PARAM_POINTER,
                                     ((size_t) ((void *) &header->checksum)) -
                                     ((size_t) ((void *) header)), packet);
@@ -296 +292 @@
                 return udp_release_and_return(packet, rc);
                 
-        rc = tl_get_ip_packet_dimension(udp_globals.ip_phone,
+        rc = tl_get_ip_packet_dimension(udp_globals.ip_sess,
             &udp_globals.dimensions, device_id, &packet_dimension);
         if (rc != EOK)
@@ -303 +299 @@
         /* Notify the destination socket */
         fibril_rwlock_write_unlock(&udp_globals.lock);
-        async_obsolete_msg_5(socket->phone, NET_SOCKET_RECEIVED,
-            (sysarg_t) socket->socket_id, packet_dimension->content, 0, 0,
-            (sysarg_t) fragments);
+        
+        async_exch_t *exch = async_exchange_begin(socket->sess);
+        async_msg_5(exch, NET_SOCKET_RECEIVED, (sysarg_t) socket->socket_id,
+            packet_dimension->content, 0, 0, (sysarg_t) fragments);
+        async_exchange_end(exch);
 
         return EOK;
@@ -342 +340 @@
  * @param[in,out] icall Message parameters.
  * @param[in]     arg   Local argument.
+ *
  */
 static void udp_receiver(ipc_callid_t iid, ipc_call_t *icall, void *arg)
@@ -351 +350 @@
                 switch (IPC_GET_IMETHOD(*icall)) {
                 case NET_TL_RECEIVED:
-                        rc = packet_translate_remote(udp_globals.net_phone, &packet,
+                        rc = packet_translate_remote(udp_globals.net_sess, &packet,
                             IPC_GET_PACKET(*icall));
                         if (rc == EOK)
@@ -369 +368 @@
 /** Initialize the UDP module.
  *
- * @param[in] net_phone Network module phone.
+ * @param[in] sess Network module session.
  *
  * @return EOK on success.
@@ -375 +374 @@
  *
  */
-int tl_initialize(int net_phone)
+int tl_initialize(async_sess_t *sess)
 {
         measured_string_t names[] = {
@@ -394 +393 @@
         fibril_rwlock_write_lock(&udp_globals.lock);
         
-        udp_globals.net_phone = net_phone;
-        
-        udp_globals.icmp_phone = icmp_connect_module();
-        
-        udp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_UDP,
-            SERVICE_UDP, udp_receiver);
-        if (udp_globals.ip_phone < 0) {
-                fibril_rwlock_write_unlock(&udp_globals.lock);
-                return udp_globals.ip_phone;
+        udp_globals.net_sess = sess;
+        udp_globals.icmp_sess = icmp_connect_module();
+        
+        udp_globals.ip_sess = ip_bind_service(SERVICE_IP, IPPROTO_UDP,
+             SERVICE_UDP, udp_receiver);
+        if (udp_globals.ip_sess == NULL) {
+            fibril_rwlock_write_unlock(&udp_globals.lock);
+            return ENOENT;
         }
         
         /* Read default packet dimensions */
-        int rc = ip_packet_size_req(udp_globals.ip_phone, -1,
+        int rc = ip_packet_size_req(udp_globals.ip_sess, -1,
             &udp_globals.packet_dimension);
         if (rc != EOK) {
@@ -435 +433 @@
         /* Get configuration */
         configuration = &names[0];
-        rc = net_get_conf_req(udp_globals.net_phone, &configuration, count,
+        rc = net_get_conf_req(udp_globals.net_sess, &configuration, count,
             &data);
         if (rc != EOK) {
@@ -529 +527 @@
 
         if (udp_globals.checksum_computing) {
-                rc = ip_get_route_req(udp_globals.ip_phone, IPPROTO_UDP, addr,
+                rc = ip_get_route_req(udp_globals.ip_sess, IPPROTO_UDP, addr,
                     addrlen, &device_id, &ip_header, &headerlen);
                 if (rc != EOK)
                         return rc;
                 /* Get the device packet dimension */
-//              rc = tl_get_ip_packet_dimension(udp_globals.ip_phone,
+//              rc = tl_get_ip_packet_dimension(udp_globals.ip_sess,
 //                  &udp_globals.dimensions, device_id, &packet_dimension);
 //              if (rc != EOK)
@@ -541 +539 @@
 //      } else {
                 /* Do not ask all the time */
-                rc = ip_packet_size_req(udp_globals.ip_phone, -1,
+                rc = ip_packet_size_req(udp_globals.ip_sess, -1,
                     &udp_globals.packet_dimension);
                 if (rc != EOK)
@@ -559 +557 @@
 
         /* Read the first packet fragment */
-        result = tl_socket_read_packet_data(udp_globals.net_phone, &packet,
+        result = tl_socket_read_packet_data(udp_globals.net_sess, &packet,
             UDP_HEADER_SIZE, packet_dimension, addr, addrlen);
         if (result < 0)
@@ -580 +578 @@
         /* Read the rest of the packet fragments */
         for (index = 1; index < fragments; index++) {
-                result = tl_socket_read_packet_data(udp_globals.net_phone,
+                result = tl_socket_read_packet_data(udp_globals.net_sess,
                     &next_packet, 0, packet_dimension, addr, addrlen);
                 if (result < 0)
@@ -632 +630 @@
 
         /* Send the packet */
-        ip_send_msg(udp_globals.ip_phone, device_id, packet, SERVICE_UDP, 0);
+        ip_send_msg(udp_globals.ip_sess, device_id, packet, SERVICE_UDP, 0);
 
         return EOK;
@@ -679 +677 @@
                 return NO_DATA;
         
-        rc = packet_translate_remote(udp_globals.net_phone, &packet, packet_id);
+        rc = packet_translate_remote(udp_globals.net_sess, &packet, packet_id);
         if (rc != EOK) {
                 (void) dyn_fifo_pop(&socket->received);
@@ -739 +737 @@
 }
 
-/** Processes the socket client messages.
- *
- * Runs until the client module disconnects.
- *
- * @param[in] callid    The message identifier.
- * @param[in] call      The message parameters.
- * @return              EOK on success.
- *
- * @see socket.h
- */
-static int udp_process_client_messages(ipc_callid_t callid, ipc_call_t call)
+/** Process the socket client messages.
+ *
+ * Run until the client module disconnects.
+ *
+ * @see socket.h
+ *
+ * @param[in] sess   Callback session.
+ * @param[in] callid Message identifier.
+ * @param[in] call   Message parameters.
+ *
+ * @return EOK on success.
+ *
+ */
+static int udp_process_client_messages(async_sess_t *sess, ipc_callid_t callid,
+    ipc_call_t call)
 {
         int res;
         socket_cores_t local_sockets;
-        int app_phone = IPC_GET_PHONE(call);
         struct sockaddr *addr;
         int socket_id;
@@ -786 +787 @@
                 /* Get the next call */
                 callid = async_get_call(&call);
-                
+
+                /* Process the call */
                 if (!IPC_GET_IMETHOD(call)) {
                         res = EHANGUP;
                         break;
                 }
-
-                /* Process the call */
+                
                 switch (IPC_GET_IMETHOD(call)) {
                 case NET_SOCKET:
                         socket_id = SOCKET_GET_SOCKET_ID(call);
-                        res = socket_create(&local_sockets, app_phone, NULL,
+                        res = socket_create(&local_sockets, sess, NULL,
                             &socket_id);
                         SOCKET_SET_SOCKET_ID(answer, socket_id);
@@ -804 +805 @@
                         
                         size = MAX_UDP_FRAGMENT_SIZE;
-                        if (tl_get_ip_packet_dimension(udp_globals.ip_phone,
+                        if (tl_get_ip_packet_dimension(udp_globals.ip_sess,
                             &udp_globals.dimensions, DEVICE_INVALID_ID,
                             &packet_dimension) == EOK) {
@@ -868 +869 @@
                 case NET_SOCKET_CLOSE:
                         fibril_rwlock_write_lock(&udp_globals.lock);
-                        res = socket_destroy(udp_globals.net_phone,
+                        res = socket_destroy(udp_globals.net_sess,
                             SOCKET_GET_SOCKET_ID(call), &local_sockets,
                             &udp_globals.sockets, NULL);
@@ -882 +883 @@
         }
 
-        /* Release the application phone */
-        async_obsolete_hangup(app_phone);
+        /* Release the application session */
+        async_hangup(sess);
 
         /* Release all local sockets */
-        socket_cores_release(udp_globals.net_phone, &local_sockets,
+        socket_cores_release(udp_globals.net_sess, &local_sockets,
             &udp_globals.sockets, NULL);
 
@@ -916 +917 @@
 {
         *answer_count = 0;
-
-        switch (IPC_GET_IMETHOD(*call)) {
-        case IPC_M_CONNECT_TO_ME:
-                return udp_process_client_messages(callid, *call);
-        }
-
+        
+        async_sess_t *callback =
+            async_callback_receive_start(EXCHANGE_SERIALIZE, call);
+        if (callback)
+                return udp_process_client_messages(callback, callid, *call);
+        
         return ENOTSUP;
 }

uspace/srv/net/tl/udp/udp.h

@@ -38 +38 @@
 #define NET_UDP_H_
 
+#include <async.h>
 #include <fibril_synch.h>
 #include <socket_core.h>
@@ -49 +50 @@
 /** UDP global data. */
 struct udp_globals {
-        /** Networking module phone. */
-        int net_phone;
-        /** IP module phone. */
-        int ip_phone;
-        /** ICMP module phone. */
-        int icmp_phone;
+        /** Networking module session. */
+        async_sess_t *net_sess;
+        /** IP module session. */
+        async_sess_t *ip_sess;
+        /** ICMP module session. */
+        async_sess_t *icmp_sess;
         /** Packet dimension. */
         packet_dimension_t packet_dimension;