Changeset 6b82009 in mainline for uspace/lib/c

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/lib/c

Files:

• generic/adt/measured_strings.c (modified) (12 diffs)
• generic/net/icmp_api.c (modified) (4 diffs)
• generic/net/icmp_common.c (modified) (1 diff)
• generic/net/modules.c (modified) (5 diffs)
• generic/net/socket_client.c (modified) (31 diffs)
• include/adt/measured_strings.h (modified) (2 diffs)
• include/ipc/net.h (modified) (1 diff)
• include/net/icmp_api.h (modified) (2 diffs)
• include/net/icmp_common.h (modified) (1 diff)
• include/net/modules.h (modified) (1 diff)

uspace/lib/c/generic/adt/measured_strings.c

@@ -42 +42 @@
 #include <errno.h>
 #include <async.h>
-#include <async_obsolete.h>
 
 /** Creates a new measured string bundled with a copy of the given string
@@ -298 +297 @@
  * size has to be negotiated in advance.
  *
- * @param[in] phone     The other module phone.
+ * @param[in] exch      Exchange.
  * @param[out] strings  The returned measured strings array.
  * @param[out] data     The measured strings data. This memory block stores the
@@ -305 +304 @@
  * @return              EOK on success.
  * @return              EINVAL if the strings or data parameter is NULL.
- * @return              EINVAL if the phone or count parameter is not positive.
+ * @return              EINVAL if the exch or count parameter is invalid.
  * @return              EINVAL if the sent array differs in size.
  * @return              ENOMEM if there is not enough memory left.
@@ -311 +310 @@
  *                      async_data_read_start() function.
  */
-int
-measured_strings_return(int phone, measured_string_t **strings, uint8_t **data,
-    size_t count)
+int measured_strings_return(async_exch_t *exch, measured_string_t **strings,
+    uint8_t **data, size_t count)
 {
         size_t *lengths;
@@ -320 +318 @@
         int rc;
 
-        if ((phone < 0) || (!strings) || (!data) || (count <= 0))
+        if ((exch == NULL) || (!strings) || (!data) || (count <= 0))
                 return EINVAL;
 
@@ -327 +325 @@
                 return ENOMEM;
 
-        rc = async_obsolete_data_read_start(phone, lengths,
+        rc = async_data_read_start(exch, lengths,
             sizeof(size_t) * (count + 1));
         if (rc != EOK) {
@@ -352 +350 @@
                 (*strings)[index].length = lengths[index];
                 if (lengths[index] > 0) {
-                        rc = async_obsolete_data_read_start(phone, next, lengths[index]);
+                        rc = async_data_read_start(exch, next, lengths[index]);
                         if (rc != EOK) {
                                 free(lengths);
@@ -376 +374 @@
  * size has to be negotiated in advance.
  *
- * @param[in] phone     The other module phone.
+ * @param[in] exch      Exchange.
  * @param[in] strings   The measured strings array to be transferred.
  * @param[in] count     The measured strings array size.
  * @return              EOK on success.
  * @return              EINVAL if the strings parameter is NULL.
- * @return              EINVAL if the phone or count parameter is not positive.
+ * @return              EINVAL if the exch or count parameter is invalid.
  * @return              Other error codes as defined for the
  *                      async_data_write_start() function.
  */
-int
-measured_strings_send(int phone, const measured_string_t *strings,
+int measured_strings_send(async_exch_t *exch, const measured_string_t *strings,
     size_t count)
 {
@@ -393 +390 @@
         int rc;
 
-        if ((phone < 0) || (!strings) || (count <= 0))
+        if ((exch == NULL) || (!strings) || (count <= 0))
                 return EINVAL;
 
@@ -400 +397 @@
                 return ENOMEM;
 
-        rc = async_obsolete_data_write_start(phone, lengths,
+        rc = async_data_write_start(exch, lengths,
             sizeof(size_t) * (count + 1));
         if (rc != EOK) {
@@ -411 +408 @@
         for (index = 0; index < count; index++) {
                 if (strings[index].length > 0) {
-                        rc = async_obsolete_data_write_start(phone, strings[index].value,
+                        rc = async_data_write_start(exch, strings[index].value,
                             strings[index].length);
                         if (rc != EOK)
@@ -423 +420 @@
 /** @}
  */
-

uspace/lib/c/generic/net/icmp_api.c

@@ -42 +42 @@
 #include <net/ip_codes.h>
 #include <async.h>
-#include <async_obsolete.h>
 #include <sys/types.h>
 #include <sys/time.h>
@@ -55 +54 @@
  * timeout occurs.
  *
- * @param[in] icmp_phone The ICMP module phone used for (semi)remote calls.
+ * @param[in] sess The ICMP session.
  * @param[in] size      The message data length in bytes.
  * @param[in] timeout   The timeout in milliseconds.
@@ -74 +73 @@
  */
 int
-icmp_echo_msg(int icmp_phone, size_t size, mseconds_t timeout, ip_ttl_t ttl,
+icmp_echo_msg(async_sess_t *sess, size_t size, mseconds_t timeout, ip_ttl_t ttl,
     ip_tos_t tos, int dont_fragment, const struct sockaddr *addr,
     socklen_t addrlen)
@@ -83 +82 @@
         if (addrlen <= 0)
                 return EINVAL;
-
-        message_id = async_obsolete_send_5(icmp_phone, NET_ICMP_ECHO, size, timeout, ttl,
+        
+        async_exch_t *exch = async_exchange_begin(sess);
+        
+        message_id = async_send_5(exch, NET_ICMP_ECHO, size, timeout, ttl,
             tos, (sysarg_t) dont_fragment, NULL);
-
+        
         /* Send the address */
-        async_obsolete_data_write_start(icmp_phone, addr, (size_t) addrlen);
+        async_data_write_start(exch, addr, (size_t) addrlen);
+        
+        async_exchange_end(exch);
 
         async_wait_for(message_id, &result);

uspace/lib/c/generic/net/icmp_common.c

@@ -45 +45 @@
 /** Connect to the ICMP module.
  *
- * @return ICMP module phone on success.
+ * @return ICMP module session.
  *
  */
-int icmp_connect_module(void)
+async_sess_t *icmp_connect_module(void)
 {
         return connect_to_service(SERVICE_ICMP);

uspace/lib/c/generic/net/modules.c

@@ -40 +40 @@
 
 #include <async.h>
-#include <async_obsolete.h>
 #include <malloc.h>
 #include <errno.h>
@@ -47 +46 @@
 #include <net/modules.h>
 #include <ns.h>
-#include <ns_obsolete.h>
-
-/** The time between connect requests in microseconds. */
-#define MODULE_WAIT_TIME  (10 * 1000)
 
 /** Answer a call.
@@ -98 +93 @@
 }
 
-/** Create bidirectional connection with the needed module service and registers
+/** Create bidirectional connection with the needed module service and register
  * the message receiver.
  *
- * @param[in] need      The needed module service.
- * @param[in] arg1      The first parameter.
- * @param[in] arg2      The second parameter.
- * @param[in] arg3      The third parameter.
- * @param[in] client_receiver The message receiver.
- *
- * @return              The phone of the needed service.
- * @return              Other error codes as defined for the ipc_connect_to_me()
- *                      function.
- */
-int bind_service(services_t need, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
-    async_client_conn_t client_receiver)
+ * @param[in] need            Needed module service.
+ * @param[in] arg1            First parameter.
+ * @param[in] arg2            Second parameter.
+ * @param[in] arg3            Third parameter.
+ * @param[in] client_receiver Message receiver.
+ *
+ * @return Session to the needed service.
+ * @return Other error codes as defined for the async_connect_to_me()
+ *         function.
+ *
+ */
+async_sess_t *bind_service(services_t need, sysarg_t arg1, sysarg_t arg2,
+    sysarg_t arg3, async_client_conn_t client_receiver)
 {
         /* Connect to the needed service */
-        int phone = connect_to_service(need);
-        if (phone >= 0) {
+        async_sess_t *sess = connect_to_service(need);
+        if (sess != NULL) {
                 /* Request the bidirectional connection */
-                int rc = async_obsolete_connect_to_me(phone, arg1, arg2, arg3,
+                async_exch_t *exch = async_exchange_begin(sess);
+                int rc = async_connect_to_me(exch, arg1, arg2, arg3,
                     client_receiver, NULL);
+                async_exchange_end(exch);
+                
                 if (rc != EOK) {
-                        async_obsolete_hangup(phone);
-                        return rc;
+                        async_hangup(sess);
+                        errno = rc;
+                        return NULL;
                 }
         }
         
-        return phone;
-}
-
-/** Connects to the needed module.
- *
- * @param[in] need      The needed module service.
- * @return              The phone of the needed service.
- */
-int connect_to_service(services_t need)
-{
-        return service_obsolete_connect_blocking(need, 0, 0);
-}
-
-/** Replies the data to the other party.
- *
- * @param[in] data      The data buffer to be sent.
+        return sess;
+}
+
+/** Connect to the needed module.
+ *
+ * @param[in] need Needed module service.
+ *
+ * @return Session to the needed service.
+ * @return NULL if the connection timeouted.
+ *
+ */
+async_sess_t *connect_to_service(services_t need)
+{
+        return service_connect_blocking(EXCHANGE_SERIALIZE, need, 0, 0);
+}
+
+/** Reply the data to the other party.
+ *
+ * @param[in] data        The data buffer to be sent.
  * @param[in] data_length The buffer length.
- * @return              EOK on success.
- * @return              EINVAL if the client does not expect the data.
- * @return              EOVERFLOW if the client does not expect all the data.
- *                      Only partial data are transfered.
- * @return              Other error codes as defined for the
- *                      async_data_read_finalize() function.
+ *
+ * @return EOK on success.
+ * @return EINVAL if the client does not expect the data.
+ * @return EOVERFLOW if the client does not expect all the data.
+ *         Only partial data are transfered.
+ * @return Other error codes as defined for the
+ *         async_data_read_finalize() function.
+ *
  */
 int data_reply(void *data, size_t data_length)
@@ -154 +159 @@
         size_t length;
         ipc_callid_t callid;
-
+        
         /* Fetch the request */
         if (!async_data_read_receive(&callid, &length))
                 return EINVAL;
-
+        
         /* Check the requested data size */
         if (length < data_length) {
@@ -164 +169 @@
                 return EOVERFLOW;
         }
-
+        
         /* Send the data */
         return async_data_read_finalize(callid, data, data_length);

uspace/lib/c/generic/net/socket_client.c

@@ -39 +39 @@
 #include <assert.h>
 #include <async.h>
-#include <async_obsolete.h>
 #include <fibril_synch.h>
 #include <stdint.h>
@@ -84 +83 @@
         /** Socket identifier. */
         int socket_id;
-        /** Parent module phone. */
-        int phone;
+        /** Parent module session. */
+        async_sess_t *sess;
         /** Parent module service. */
         services_t service;
@@ -144 +143 @@
 /** Socket client library global data. */
 static struct socket_client_globals {
-        /** TCP module phone. */
-        int tcp_phone;
-        /** UDP module phone. */
-        int udp_phone;
-
-//      /** The last socket identifier.
-//       */
-//      int last_id;
+        /** TCP module session. */
+        async_sess_t *tcp_sess;
+        /** UDP module session. */
+        async_sess_t *udp_sess;
 
         /** Active sockets. */
@@ -164 +159 @@
         fibril_rwlock_t lock;
 } socket_globals = {
-        .tcp_phone = -1,
-        .udp_phone = -1,
-//      .last_id = 0,
+        .tcp_sess = NULL,
+        .udp_sess = NULL,
         .sockets = NULL,
         .lock = FIBRIL_RWLOCK_INITIALIZER(socket_globals.lock)
@@ -280 +274 @@
 }
 
-/** Returns the TCP module phone.
- *
- * Connects to the TCP module if necessary.
- *
- * @return              The TCP module phone.
- * @return              Other error codes as defined for the
- *                      bind_service() function.
- */
-static int socket_get_tcp_phone(void)
-{
-        if (socket_globals.tcp_phone < 0) {
-                socket_globals.tcp_phone = bind_service(SERVICE_TCP,
+/** Return the TCP module session.
+ *
+ * Connect to the TCP module if necessary.
+ *
+ * @return The TCP module session.
+ *
+ */
+static async_sess_t *socket_get_tcp_sess(void)
+{
+        if (socket_globals.tcp_sess == NULL) {
+                socket_globals.tcp_sess = bind_service(SERVICE_TCP,
                     0, 0, SERVICE_TCP, socket_connection);
         }
 
-        return socket_globals.tcp_phone;
-}
-
-/** Returns the UDP module phone.
- *
- * Connects to the UDP module if necessary.
- *
- * @return              The UDP module phone.
- * @return              Other error codes as defined for the
- *                      bind_service() function.
- */
-static int socket_get_udp_phone(void)
-{
-        if (socket_globals.udp_phone < 0) {
-                socket_globals.udp_phone = bind_service(SERVICE_UDP,
+        return socket_globals.tcp_sess;
+}
+
+/** Return the UDP module session.
+ *
+ * Connect to the UDP module if necessary.
+ *
+ * @return The UDP module session.
+ *
+ */
+static async_sess_t *socket_get_udp_sess(void)
+{
+        if (socket_globals.udp_sess == NULL) {
+                socket_globals.udp_sess = bind_service(SERVICE_UDP,
                     0, 0, SERVICE_UDP, socket_connection);
         }
 
-        return socket_globals.udp_phone;
+        return socket_globals.udp_sess;
 }
 
@@ -329 +321 @@
         sockets = socket_get_sockets();
         count = 0;
-//      socket_id = socket_globals.last_id;
 
         do {
@@ -342 +333 @@
                         if (socket_id < INT_MAX) {
                                 ++socket_id;
-/*                      } else if(socket_globals.last_id) {
- *                              socket_globals.last_id = 0;
- *                              socket_id = 1;
- */                     } else {
+                        } else {
                                 return ELIMIT;
                         }
                 }
         } while (sockets_find(sockets, socket_id));
-
-//      last_id = socket_id
+        
         return socket_id;
 }
@@ -358 +345 @@
  *
  * @param[in,out] socket The socket to be initialized.
- * @param[in] socket_id The new socket identifier.
- * @param[in] phone     The parent module phone.
- * @param[in] service   The parent module service.
- */
-static void
-socket_initialize(socket_t *socket, int socket_id, int phone,
-    services_t service)
+ * @param[in] socket_id  The new socket identifier.
+ * @param[in] sess       The parent module session.
+ * @param[in] service    The parent module service.
+ */
+static void socket_initialize(socket_t *socket, int socket_id,
+    async_sess_t *sess, services_t service)
 {
         socket->socket_id = socket_id;
-        socket->phone = phone;
+        socket->sess = sess;
         socket->service = service;
         dyn_fifo_initialize(&socket->received, SOCKET_INITIAL_RECEIVED_SIZE);
@@ -397 +383 @@
 {
         socket_t *socket;
-        int phone;
+        async_sess_t *sess;
         int socket_id;
         services_t service;
@@ -414 +400 @@
                         switch (protocol) {
                         case IPPROTO_TCP:
-                                phone = socket_get_tcp_phone();
+                                sess = socket_get_tcp_sess();
                                 service = SERVICE_TCP;
                                 break;
@@ -429 +415 @@
                         switch (protocol) {
                         case IPPROTO_UDP:
-                                phone = socket_get_udp_phone();
+                                sess = socket_get_udp_sess();
                                 service = SERVICE_UDP;
                                 break;
@@ -450 +436 @@
         }
 
-        if (phone < 0)
-                return phone;
+        if (sess == NULL)
+                return ENOENT;
 
         /* Create a new socket structure */
@@ -468 +454 @@
                 return socket_id;
         }
-
-        rc = (int) async_obsolete_req_3_3(phone, NET_SOCKET, socket_id, 0, service, NULL,
+        
+        async_exch_t *exch = async_exchange_begin(sess);
+        rc = (int) async_req_3_3(exch, NET_SOCKET, socket_id, 0, service, NULL,
             &fragment_size, &header_size);
+        async_exchange_end(exch);
+        
         if (rc != EOK) {
                 fibril_rwlock_write_unlock(&socket_globals.lock);
@@ -481 +470 @@
 
         /* Finish the new socket initialization */
-        socket_initialize(socket, socket_id, phone, service);
+        socket_initialize(socket, socket_id, sess, service);
         /* Store the new socket */
         rc = sockets_add(socket_get_sockets(), socket_id, socket);
@@ -490 +479 @@
                 dyn_fifo_destroy(&socket->accepted);
                 free(socket);
-                async_obsolete_msg_3(phone, NET_SOCKET_CLOSE, (sysarg_t) socket_id, 0,
+                
+                exch = async_exchange_begin(sess);
+                async_msg_3(exch, NET_SOCKET_CLOSE, (sysarg_t) socket_id, 0,
                     service);
+                async_exchange_end(exch);
+                
                 return rc;
         }
@@ -535 +528 @@
 
         /* Request the message */
-        message_id = async_obsolete_send_3(socket->phone, message,
+        async_exch_t *exch = async_exchange_begin(socket->sess);
+        message_id = async_send_3(exch, message,
             (sysarg_t) socket->socket_id, arg2, socket->service, NULL);
         /* Send the address */
-        async_obsolete_data_write_start(socket->phone, data, datalength);
+        async_data_write_start(exch, data, datalength);
+        async_exchange_end(exch);
 
         fibril_rwlock_read_unlock(&socket_globals.lock);
@@ -595 +590 @@
 
         /* Request listen backlog change */
-        result = (int) async_obsolete_req_3_0(socket->phone, NET_SOCKET_LISTEN,
+        async_exch_t *exch = async_exchange_begin(socket->sess);
+        result = (int) async_req_3_0(exch, NET_SOCKET_LISTEN,
             (sysarg_t) socket->socket_id, (sysarg_t) backlog, socket->service);
+        async_exchange_end(exch);
 
         fibril_rwlock_read_unlock(&socket_globals.lock);
@@ -666 +663 @@
                 return socket_id;
         }
-        socket_initialize(new_socket, socket_id, socket->phone,
+        socket_initialize(new_socket, socket_id, socket->sess,
             socket->service);
         result = sockets_add(socket_get_sockets(), new_socket->socket_id,
@@ -678 +675 @@
 
         /* Request accept */
-        message_id = async_obsolete_send_5(socket->phone, NET_SOCKET_ACCEPT,
+        async_exch_t *exch = async_exchange_begin(socket->sess);
+        message_id = async_send_5(exch, NET_SOCKET_ACCEPT,
             (sysarg_t) socket->socket_id, 0, socket->service, 0,
             new_socket->socket_id, &answer);
 
         /* Read address */
-        async_obsolete_data_read_start(socket->phone, cliaddr, *addrlen);
+        async_data_read_start(exch, cliaddr, *addrlen);
+        async_exchange_end(exch);
+        
         fibril_rwlock_write_unlock(&socket_globals.lock);
         async_wait_for(message_id, &ipc_result);
@@ -777 +777 @@
 
         /* Request close */
-        rc = (int) async_obsolete_req_3_0(socket->phone, NET_SOCKET_CLOSE,
+        async_exch_t *exch = async_exchange_begin(socket->sess);
+        rc = (int) async_req_3_0(exch, NET_SOCKET_CLOSE,
             (sysarg_t) socket->socket_id, 0, socket->service);
+        async_exchange_end(exch);
+        
         if (rc != EOK) {
                 fibril_rwlock_write_unlock(&socket_globals.lock);
@@ -850 +853 @@
 
         /* Request send */
-        message_id = async_obsolete_send_5(socket->phone, message,
+        async_exch_t *exch = async_exchange_begin(socket->sess);
+        
+        message_id = async_send_5(exch, message,
             (sysarg_t) socket->socket_id,
             (fragments == 1 ? datalength : socket->data_fragment_size),
@@ -857 +862 @@
         /* Send the address if given */
         if (!toaddr ||
-            (async_obsolete_data_write_start(socket->phone, toaddr, addrlen) == EOK)) {
+            (async_data_write_start(exch, toaddr, addrlen) == EOK)) {
                 if (fragments == 1) {
                         /* Send all if only one fragment */
-                        async_obsolete_data_write_start(socket->phone, data, datalength);
+                        async_data_write_start(exch, data, datalength);
                 } else {
                         /* Send the first fragment */
-                        async_obsolete_data_write_start(socket->phone, data,
+                        async_data_write_start(exch, data,
                             socket->data_fragment_size - socket->header_size);
                         data = ((const uint8_t *) data) +
@@ -870 +875 @@
                         /* Send the middle fragments */
                         while (--fragments > 1) {
-                                async_obsolete_data_write_start(socket->phone, data,
+                                async_data_write_start(exch, data,
                                     socket->data_fragment_size);
                                 data = ((const uint8_t *) data) +
@@ -877 +882 @@
 
                         /* Send the last fragment */
-                        async_obsolete_data_write_start(socket->phone, data,
+                        async_data_write_start(exch, data,
                             (datalength + socket->header_size) %
                             socket->data_fragment_size);
                 }
         }
+        
+        async_exchange_end(exch);
 
         async_wait_for(message_id, &result);
@@ -1023 +1030 @@
                 return 0;
         }
+        
+        async_exch_t *exch = async_exchange_begin(socket->sess);
 
         /* Prepare lengths if more fragments */
@@ -1035 +1044 @@
 
                 /* Request packet data */
-                message_id = async_obsolete_send_4(socket->phone, message,
+                message_id = async_send_4(exch, message,
                     (sysarg_t) socket->socket_id, 0, socket->service,
                     (sysarg_t) flags, &answer);
@@ -1041 +1050 @@
                 /* Read the address if desired */
                 if(!fromaddr ||
-                    (async_obsolete_data_read_start(socket->phone, fromaddr,
+                    (async_data_read_start(exch, fromaddr,
                     *addrlen) == EOK)) {
                         /* Read the fragment lengths */
-                        if (async_obsolete_data_read_start(socket->phone, lengths,
+                        if (async_data_read_start(exch, lengths,
                             sizeof(int) * (fragments + 1)) == EOK) {
                                 if (lengths[fragments] <= datalength) {
@@ -1051 +1060 @@
                                         for (index = 0; index < fragments;
                                             ++index) {
-                                                async_obsolete_data_read_start(
-                                                    socket->phone, data,
+                                                async_data_read_start(exch, data,
                                                     lengths[index]);
                                                 data = ((uint8_t *) data) +
@@ -1064 +1072 @@
         } else { /* fragments == 1 */
                 /* Request packet data */
-                message_id = async_obsolete_send_4(socket->phone, message,
+                message_id = async_send_4(exch, message,
                     (sysarg_t) socket->socket_id, 0, socket->service,
                     (sysarg_t) flags, &answer);
@@ -1070 +1078 @@
                 /* Read the address if desired */
                 if (!fromaddr ||
-                    (async_obsolete_data_read_start(socket->phone, fromaddr,
-                        *addrlen) == EOK)) {
+                    (async_data_read_start(exch, fromaddr, *addrlen) == EOK)) {
                         /* Read all if only one fragment */
-                        async_obsolete_data_read_start(socket->phone, data, datalength);
+                        async_data_read_start(exch, data, datalength);
                 }
         }
+        
+        async_exchange_end(exch);
 
         async_wait_for(message_id, &ipc_result);
@@ -1187 +1196 @@
 
         /* Request option value */
-        message_id = async_obsolete_send_3(socket->phone, NET_SOCKET_GETSOCKOPT,
+        async_exch_t *exch = async_exchange_begin(socket->sess);
+        
+        message_id = async_send_3(exch, NET_SOCKET_GETSOCKOPT,
             (sysarg_t) socket->socket_id, (sysarg_t) optname, socket->service,
             NULL);
 
         /* Read the length */
-        if (async_obsolete_data_read_start(socket->phone, optlen,
+        if (async_data_read_start(exch, optlen,
             sizeof(*optlen)) == EOK) {
                 /* Read the value */
-                async_obsolete_data_read_start(socket->phone, value, *optlen);
-        }
+                async_data_read_start(exch, value, *optlen);
+        }
+        
+        async_exchange_end(exch);
 
         fibril_rwlock_read_unlock(&socket_globals.lock);

uspace/lib/c/include/adt/measured_strings.h

@@ -41 +41 @@
 
 #include <sys/types.h>
+#include <async.h>
 
 /** Type definition of the character string with measured length.
@@ -64 +65 @@
 extern int measured_strings_receive(measured_string_t **, uint8_t **, size_t);
 extern int measured_strings_reply(const measured_string_t *, size_t);
-extern int measured_strings_return(int, measured_string_t **, uint8_t **, size_t);
-extern int measured_strings_send(int, const measured_string_t *, size_t);
+
+extern int measured_strings_return(async_exch_t *, measured_string_t **,
+    uint8_t **, size_t);
+extern int measured_strings_send(async_exch_t *, const measured_string_t *,
+    size_t);
 
 #endif

uspace/lib/c/include/ipc/net.h

@@ -335 +335 @@
 #define IPC_GET_ERROR(call)  ((services_t) IPC_GET_ARG4(call))
 
-/** Return the phone message argument.
- *
- * @param[in] call Message call structure.
- *
- */
-#define IPC_GET_PHONE(call)  ((int) IPC_GET_ARG5(call))
-
 /** Set the device identifier in the message answer.
  *

uspace/lib/c/include/net/icmp_api.h

@@ -42 +42 @@
 #include <sys/types.h>
 #include <sys/time.h>
-
 #include <adt/measured_strings.h>
 #include <net/ip_codes.h>
 #include <net/icmp_codes.h>
 #include <net/icmp_common.h>
+#include <async.h>
 
 /** @name ICMP module application interface
@@ -53 +53 @@
 /*@{*/
 
-extern int icmp_echo_msg(int, size_t, mseconds_t, ip_ttl_t, ip_tos_t, int,
-    const struct sockaddr *, socklen_t);
+extern int icmp_echo_msg(async_sess_t *, size_t, mseconds_t, ip_ttl_t, ip_tos_t,
+    int, const struct sockaddr *, socklen_t);
 
 /*@}*/

uspace/lib/c/include/net/icmp_common.h

@@ -40 +40 @@
 #include <ipc/services.h>
 #include <sys/time.h>
+#include <async.h>
 
-extern int icmp_connect_module(void);
+extern async_sess_t *icmp_connect_module(void);
 
 #endif

uspace/lib/c/include/net/modules.h

@@ -46 +46 @@
 #include <sys/time.h>
 
-/** Connect to the needed module function type definition.
+/** Connect to module function type definition.
  *
- * @param[in] need The needed module service.
- *
- * @return The phone of the needed service.
+ * @return Session to the service.
  *
  */
-typedef int connect_module_t(services_t need);
+typedef async_sess_t *connect_module_t(services_t);
 
 extern void answer_call(ipc_callid_t, int, ipc_call_t *, size_t);
-extern int bind_service(services_t, sysarg_t, sysarg_t, sysarg_t,
+extern async_sess_t *bind_service(services_t, sysarg_t, sysarg_t, sysarg_t,
     async_client_conn_t);
-extern int connect_to_service(services_t);
+extern async_sess_t *connect_to_service(services_t);
 extern int data_reply(void *, size_t);
 extern void refresh_answer(ipc_call_t *, size_t *);