Changes in uspace/srv/net/tl/tcp/tcp.c [28a3e74:472020fc] in mainline

File:

• uspace/srv/net/tl/tcp/tcp.c (modified) (127 diffs)

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

@@ -28 +28 @@
 
 /** @addtogroup tcp
- * @{
+ *  @{
  */
 
 /** @file
- * TCP module implementation.
- * @see tcp.h
+ *  TCP module implementation.
+ *  @see tcp.h
  */
 
@@ -40 +40 @@
 #include <fibril_synch.h>
 #include <malloc.h>
-/* TODO remove stdio */
+//TODO remove stdio
 #include <stdio.h>
 #include <errno.h>
-
+#include <err.h>
+
+#include <ipc/ipc.h>
 #include <ipc/services.h>
 #include <ipc/net.h>
@@ -63 +65 @@
 #include <ip_interface.h>
 #include <icmp_client.h>
-#include <icmp_remote.h>
+#include <icmp_interface.h>
 #include <net_interface.h>
 #include <socket_core.h>
 #include <tl_common.h>
-#include <tl_remote.h>
-#include <tl_skel.h>
+#include <tl_local.h>
+#include <tl_interface.h>
 
 #include "tcp.h"
 #include "tcp_header.h"
+#include "tcp_module.h"
 
 /** TCP module name. */
-#define NAME  "tcp"
+#define NAME    "TCP protocol"
 
 /** The TCP window default value. */
@@ -107 +110 @@
 
 /** Returns a value indicating whether the value is in the interval respecting
- * the possible overflow.
+ *  the possible overflow.
  *
- * The high end and/or the value may overflow, be lower than the low value.
- *
- * @param[in] lower     The last value before the interval.
- * @param[in] value     The value to be checked.
- * @param[in] higher_equal The last value in the interval.
+ *  The high end and/or the value may overflow, be lower than the low value.
+ *  @param[in] lower The last value before the interval.
+ *  @param[in] value The value to be checked.
+ *  @param[in] higher_equal The last value in the interval.
  */
 #define IS_IN_INTERVAL_OVERFLOW(lower, value, higher_equal) \
@@ -124 +126 @@
  */
 typedef struct tcp_timeout tcp_timeout_t;
+
+/** Type definition of the TCP timeout pointer.
+ *  @see tcp_timeout
+ */
+typedef tcp_timeout_t *tcp_timeout_ref;
 
 /** TCP reply timeout data.
@@ -137 +144 @@
 
         /** Local sockets. */
-        socket_cores_t *local_sockets;
+        socket_cores_ref local_sockets;
 
         /** Socket identifier. */
@@ -152 +159 @@
 
         /** Port map key. */
-        uint8_t *key;
+        char *key;
 
         /** Port map key length. */
@@ -158 +165 @@
 };
 
-static int tcp_release_and_return(packet_t *, int);
-static void tcp_prepare_operation_header(socket_core_t *, tcp_socket_data_t *,
-    tcp_header_t *, int synchronize, int);
-static int tcp_prepare_timeout(int (*)(void *), socket_core_t *,
-    tcp_socket_data_t *, size_t, tcp_socket_state_t, suseconds_t, int);
-static void tcp_free_socket_data(socket_core_t *);
-
-static int tcp_timeout(void *);
-
-static int tcp_release_after_timeout(void *);
-
-static int tcp_process_packet(device_id_t, packet_t *, services_t);
-static int tcp_connect_core(socket_core_t *, socket_cores_t *,
-    struct sockaddr *, socklen_t);
-static int tcp_queue_prepare_packet(socket_core_t *, tcp_socket_data_t *,
-    packet_t *, size_t);
-static int tcp_queue_packet(socket_core_t *, tcp_socket_data_t *, packet_t *,
-    size_t);
-static packet_t *tcp_get_packets_to_send(socket_core_t *, tcp_socket_data_t *);
-static void tcp_send_packets(device_id_t, packet_t *);
-
-static void tcp_process_acknowledgement(socket_core_t *, tcp_socket_data_t *,
-    tcp_header_t *);
-static packet_t *tcp_send_prepare_packet(socket_core_t *, tcp_socket_data_t *,
-    packet_t *, size_t, size_t);
-static packet_t *tcp_prepare_copy(socket_core_t *, tcp_socket_data_t *,
-    packet_t *, size_t, size_t);
-/* static */ void tcp_retransmit_packet(socket_core_t *, tcp_socket_data_t *,
-    size_t);
-static int tcp_create_notification_packet(packet_t **, socket_core_t *,
-    tcp_socket_data_t *, int, int);
-static void tcp_refresh_socket_data(tcp_socket_data_t *);
-
-static void tcp_initialize_socket_data(tcp_socket_data_t *);
-
-static int tcp_process_listen(socket_core_t *, tcp_socket_data_t *,
-    tcp_header_t *, packet_t *, struct sockaddr *, struct sockaddr *, size_t);
-static int tcp_process_syn_sent(socket_core_t *, tcp_socket_data_t *,
-    tcp_header_t *, packet_t *);
-static int tcp_process_syn_received(socket_core_t *, tcp_socket_data_t *,
-    tcp_header_t *, packet_t *);
-static int tcp_process_established(socket_core_t *, tcp_socket_data_t *,
-    tcp_header_t *, packet_t *, int, size_t);
-static int tcp_queue_received_packet(socket_core_t *, tcp_socket_data_t *,
-    packet_t *, int, size_t);
-static void tcp_queue_received_end_of_data(socket_core_t *socket);
-
-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_listen_message(socket_cores_t *, int, int);
-static int tcp_connect_message(socket_cores_t *, int, struct sockaddr *,
-    socklen_t);
-static int tcp_recvfrom_message(socket_cores_t *, int, int, size_t *);
-static int tcp_send_message(socket_cores_t *, int, int, size_t *, int);
-static int tcp_accept_message(socket_cores_t *, int, int, size_t *, size_t *);
-static int tcp_close_message(socket_cores_t *, int);
+/** 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.
+ */
+int tcp_release_and_return(packet_t packet, int result);
+
+void tcp_prepare_operation_header(socket_core_ref socket,
+    tcp_socket_data_ref socket_data, tcp_header_ref header, int synchronize,
+    int finalize);
+int tcp_prepare_timeout(int (*timeout_function)(void *tcp_timeout_t),
+    socket_core_ref socket, tcp_socket_data_ref socket_data,
+    size_t sequence_number, tcp_socket_state_t state, suseconds_t timeout,
+    int globals_read_only);
+void tcp_free_socket_data(socket_core_ref socket);
+
+int tcp_timeout(void *data);
+
+int tcp_release_after_timeout(void *data);
+
+int tcp_process_packet(device_id_t device_id, packet_t packet,
+    services_t error);
+int tcp_connect_core(socket_core_ref socket, socket_cores_ref local_sockets,
+    struct sockaddr *addr, socklen_t addrlen);
+int tcp_queue_prepare_packet(socket_core_ref socket,
+    tcp_socket_data_ref socket_data, packet_t packet, size_t data_length);
+int tcp_queue_packet(socket_core_ref socket, tcp_socket_data_ref socket_data,
+    packet_t packet, size_t data_length);
+packet_t tcp_get_packets_to_send(socket_core_ref socket,
+    tcp_socket_data_ref socket_data);
+void tcp_send_packets(device_id_t device_id, packet_t packet);
+
+void tcp_process_acknowledgement(socket_core_ref socket,
+    tcp_socket_data_ref socket_data, tcp_header_ref header);
+packet_t tcp_send_prepare_packet(socket_core_ref socket,
+    tcp_socket_data_ref socket_data, packet_t packet, size_t data_length,
+    size_t sequence_number);
+packet_t tcp_prepare_copy(socket_core_ref socket,
+    tcp_socket_data_ref socket_data, packet_t packet, size_t data_length,
+    size_t sequence_number);
+void tcp_retransmit_packet(socket_core_ref socket,
+    tcp_socket_data_ref socket_data, size_t sequence_number);
+int tcp_create_notification_packet(packet_t * packet, socket_core_ref socket,
+    tcp_socket_data_ref socket_data, int synchronize, int finalize);
+void tcp_refresh_socket_data(tcp_socket_data_ref socket_data);
+
+void tcp_initialize_socket_data(tcp_socket_data_ref socket_data);
+
+int tcp_process_listen(socket_core_ref listening_socket,
+    tcp_socket_data_ref listening_socket_data, tcp_header_ref header,
+    packet_t packet, struct sockaddr *src, struct sockaddr *dest,
+    size_t addrlen);
+int tcp_process_syn_sent(socket_core_ref socket,
+    tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet);
+int tcp_process_syn_received(socket_core_ref socket,
+    tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet);
+int tcp_process_established(socket_core_ref socket,
+    tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet,
+    int fragments, size_t total_length);
+int tcp_queue_received_packet(socket_core_ref socket,
+    tcp_socket_data_ref socket_data, packet_t packet, int fragments,
+    size_t total_length);
+
+int tcp_received_msg(device_id_t device_id, packet_t packet,
+    services_t receiver, services_t error);
+int tcp_process_client_messages(ipc_callid_t callid, ipc_call_t call);
+
+int tcp_listen_message(socket_cores_ref local_sockets, int socket_id,
+    int backlog);
+int tcp_connect_message(socket_cores_ref local_sockets, int socket_id,
+    struct sockaddr *addr, socklen_t addrlen);
+int tcp_recvfrom_message(socket_cores_ref local_sockets, int socket_id,
+    int flags, size_t * addrlen);
+int tcp_send_message(socket_cores_ref local_sockets, int socket_id,
+    int fragments, size_t * data_fragment_size, int flags);
+int tcp_accept_message(socket_cores_ref local_sockets, int socket_id,
+    int new_socket_id, size_t * data_fragment_size, size_t * addrlen);
+int tcp_close_message(socket_cores_ref local_sockets, int socket_id);
 
 /** TCP global data. */
 tcp_globals_t tcp_globals;
 
-int tcp_received_msg(device_id_t device_id, packet_t *packet,
-    services_t receiver, services_t error)
-{
-        int rc;
+int tcp_initialize(async_client_conn_t client_connection)
+{
+        ERROR_DECLARE;
+
+        assert(client_connection);
+
+        fibril_rwlock_initialize(&tcp_globals.lock);
+        fibril_rwlock_write_lock(&tcp_globals.lock);
+
+        tcp_globals.icmp_phone = icmp_connect_module(SERVICE_ICMP,
+            ICMP_CONNECT_TIMEOUT);
+        tcp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_TCP,
+            SERVICE_TCP, client_connection);
+        if (tcp_globals.ip_phone < 0)
+                return tcp_globals.ip_phone;
+        
+        ERROR_PROPAGATE(socket_ports_initialize(&tcp_globals.sockets));
+        if (ERROR_OCCURRED(packet_dimensions_initialize(
+            &tcp_globals.dimensions))) {
+                socket_ports_destroy(&tcp_globals.sockets);
+                return ERROR_CODE;
+        }
+
+        tcp_globals.last_used_port = TCP_FREE_PORTS_START - 1;
+        fibril_rwlock_write_unlock(&tcp_globals.lock);
+
+        return EOK;
+}
+
+int
+tcp_received_msg(device_id_t device_id, packet_t packet, services_t receiver,
+    services_t error)
+{
+        ERROR_DECLARE;
 
         if (receiver != SERVICE_TCP)
@@ -228 +286 @@
 
         fibril_rwlock_write_lock(&tcp_globals.lock);
-        rc = tcp_process_packet(device_id, packet, error);
-        if (rc != EOK)
+        if (ERROR_OCCURRED(tcp_process_packet(device_id, packet, error)))
                 fibril_rwlock_write_unlock(&tcp_globals.lock);
 
-        printf("receive %d \n", rc);
-
-        return rc;
-}
-
-int tcp_process_packet(device_id_t device_id, packet_t *packet, services_t error)
-{
+        printf("receive %d \n", ERROR_CODE);
+
+        return ERROR_CODE;
+}
+
+int tcp_process_packet(device_id_t device_id, packet_t packet, services_t error)
+{
+        ERROR_DECLARE;
+
         size_t length;
         size_t offset;
         int result;
-        tcp_header_t *header;
-        socket_core_t *socket;
-        tcp_socket_data_t *socket_data;
-        packet_t *next_packet;
+        tcp_header_ref header;
+        socket_core_ref socket;
+        tcp_socket_data_ref socket_data;
+        packet_t next_packet;
         size_t total_length;
         uint32_t checksum;
@@ -254 +313 @@
         struct sockaddr *dest;
         size_t addrlen;
-        int rc;
-
-        switch (error) {
-        case SERVICE_NONE:
-                break;
-        case SERVICE_ICMP:
-                /* Process error */
-                result = icmp_client_process_packet(packet, &type, &code, NULL,
-                    NULL);
-                if (result < 0)
-                        return tcp_release_and_return(packet, result);
-
-                length = (size_t) result;
-                rc = packet_trim(packet, length, 0);
-                if (rc != EOK)
-                        return tcp_release_and_return(packet, rc);
-                break;
-        default:
-                return tcp_release_and_return(packet, ENOTSUP);
-        }
-
-        /* TODO process received ipopts? */
+
+        if (error) {
+                switch (error) {
+                case SERVICE_ICMP:
+                        // process error
+                        result = icmp_client_process_packet(packet, &type,
+                            &code, NULL, NULL);
+                        if (result < 0)
+                                return tcp_release_and_return(packet, result);
+
+                        length = (size_t) result;
+                        if (ERROR_OCCURRED(packet_trim(packet, length, 0))) {
+                                return tcp_release_and_return(packet,
+                                    ERROR_CODE);
+                        }
+                        break;
+
+                default:
+                        return tcp_release_and_return(packet, ENOTSUP);
+                }
+        }
+
+        // TODO process received ipopts?
         result = ip_client_process_packet(packet, NULL, NULL, NULL, NULL, NULL);
         if (result < 0)
@@ -289 +349 @@
                 return tcp_release_and_return(packet, NO_DATA);
 
-        /* Trim all but TCP header */
-        rc = packet_trim(packet, offset, 0);
-        if (rc != EOK)
-                return tcp_release_and_return(packet, rc);
-
-        /* Get tcp header */
-        header = (tcp_header_t *) packet_get_data(packet);
+        // trim all but TCP header
+        if (ERROR_OCCURRED(packet_trim(packet, offset, 0)))
+                return tcp_release_and_return(packet, ERROR_CODE);
+
+        // get tcp header
+        header = (tcp_header_ref) packet_get_data(packet);
         if (!header)
                 return tcp_release_and_return(packet, NO_DATA);
 
-#if 0
-        printf("header len %d, port %d \n", TCP_HEADER_LENGTH(header),
-            ntohs(header->destination_port));
-#endif
+//      printf("header len %d, port %d \n", TCP_HEADER_LENGTH(header),
+//          ntohs(header->destination_port));
+
         result = packet_get_addr(packet, (uint8_t **) &src, (uint8_t **) &dest);
         if (result <= 0)
@@ -309 +367 @@
         addrlen = (size_t) result;
 
-        rc = tl_set_address_port(src, addrlen, ntohs(header->source_port));
-        if (rc != EOK)
-                return tcp_release_and_return(packet, rc);
+        if (ERROR_OCCURRED(tl_set_address_port(src, addrlen,
+            ntohs(header->source_port)))) 
+                return tcp_release_and_return(packet, ERROR_CODE);
         
-        /* Find the destination socket */
+        // find the destination socket
         socket = socket_port_find(&tcp_globals.sockets,
-            ntohs(header->destination_port), (uint8_t *) src, addrlen);
+            ntohs(header->destination_port), (const char *) src, addrlen);
         if (!socket) {
-                /* Find the listening destination socket */
+                // find the listening destination socket
                 socket = socket_port_find(&tcp_globals.sockets,
-                    ntohs(header->destination_port),
-                    (uint8_t *) SOCKET_MAP_KEY_LISTENING, 0);
-        }
-
-        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,
-                            ICMP_PORT_UNREACH, 0, packet);
-                }
-                return EADDRNOTAVAIL;
-        }
-
+                    ntohs(header->destination_port), SOCKET_MAP_KEY_LISTENING,
+                    0);
+                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, ICMP_PORT_UNREACH,
+                                    0, packet);
+                        }
+                        return EADDRNOTAVAIL;
+                }
+        }
         printf("socket id %d\n", socket->socket_id);
-        socket_data = (tcp_socket_data_t *) socket->specific_data;
+        socket_data = (tcp_socket_data_ref) socket->specific_data;
         assert(socket_data);
 
-        /* Some data received, clear the timeout counter */
+        // some data received, clear the timeout counter
         socket_data->timeout_count = 0;
 
-        /* Count the received packet fragments */
+        // count the received packet fragments
         next_packet = packet;
         fragments = 0;
@@ -345 +402 @@
         total_length = 0;
         do {
-                fragments++;
+                ++fragments;
                 length = packet_get_data_length(next_packet);
                 if (length <= 0)
@@ -352 +409 @@
                 total_length += length;
 
-                /* Add partial checksum if set */
+                // add partial checksum if set
                 if (!error) {
                         checksum = compute_checksum(checksum,
@@ -364 +421 @@
 
         if (error)
-                goto has_error_service;
+                goto error;
         
         if (socket_data->state == TCP_SOCKET_LISTEN) {
+
                 if (socket_data->pseudo_header) {
                         free(socket_data->pseudo_header);
@@ -373 +431 @@
                 }
 
-                rc = ip_client_get_pseudo_header(IPPROTO_TCP, src, addrlen,
-                    dest, addrlen, total_length, &socket_data->pseudo_header,
-                    &socket_data->headerlen);
-                if (rc != EOK) {
+                if (ERROR_OCCURRED(ip_client_get_pseudo_header(IPPROTO_TCP, src,
+                    addrlen, dest, addrlen, total_length,
+                    &socket_data->pseudo_header, &socket_data->headerlen))) {
                         fibril_rwlock_write_unlock(socket_data->local_lock);
-                        return tcp_release_and_return(packet, rc);
-                }
-        } else {
-                rc = ip_client_set_pseudo_header_data_length(
-                    socket_data->pseudo_header, socket_data->headerlen,
-                    total_length);
-                if (rc != EOK) {
-                        fibril_rwlock_write_unlock(socket_data->local_lock);
-                        return tcp_release_and_return(packet, rc);
-                }
+                        return tcp_release_and_return(packet, ERROR_CODE);
+                }
+
+        } else if (ERROR_OCCURRED(ip_client_set_pseudo_header_data_length(
+            socket_data->pseudo_header, socket_data->headerlen,
+            total_length))) {
+                fibril_rwlock_write_unlock(socket_data->local_lock);
+                return tcp_release_and_return(packet, ERROR_CODE);
         }
         
@@ -397 +452 @@
                 fibril_rwlock_write_unlock(socket_data->local_lock);
 
-                rc = tl_prepare_icmp_packet(tcp_globals.net_phone,
-                    tcp_globals.icmp_phone, packet, error);
-                if (rc == EOK) {
-                        /* Checksum error ICMP */
+                if (ERROR_NONE(tl_prepare_icmp_packet(tcp_globals.net_phone,
+                    tcp_globals.icmp_phone, packet, error))) {
+                        // checksum error ICMP
                         icmp_parameter_problem_msg(tcp_globals.icmp_phone,
                             ICMP_PARAM_POINTER,
@@ -410 +464 @@
         }
 
-has_error_service:
-        fibril_rwlock_write_unlock(&tcp_globals.lock);
-
-        /* TODO error reporting/handling */
+error:
+        fibril_rwlock_read_unlock(&tcp_globals.lock);
+
+        // TODO error reporting/handling
         switch (socket_data->state) {
         case TCP_SOCKET_LISTEN:
-                rc = tcp_process_listen(socket, socket_data, header, packet,
-                    src, dest, addrlen);
+                ERROR_CODE = tcp_process_listen(socket, socket_data, header,
+                    packet, src, dest, addrlen);
                 break;
         case TCP_SOCKET_SYN_RECEIVED:
-                rc = tcp_process_syn_received(socket, socket_data, header,
+                ERROR_CODE = tcp_process_syn_received(socket, socket_data,
+                    header, packet);
+                break;
+        case TCP_SOCKET_SYN_SENT:
+                ERROR_CODE = tcp_process_syn_sent(socket, socket_data, header,
                     packet);
                 break;
-        case TCP_SOCKET_SYN_SENT:
-                rc = tcp_process_syn_sent(socket, socket_data, header, packet);
-                break;
         case TCP_SOCKET_FIN_WAIT_1:
-                /* ack changing the state to FIN_WAIT_2 gets processed later */
+                // ack changing the state to FIN_WAIT_2 gets processed later
         case TCP_SOCKET_FIN_WAIT_2:
-                /* fin changing state to LAST_ACK gets processed later */
+                // fin changing state to LAST_ACK gets processed later
         case TCP_SOCKET_LAST_ACK:
-                /* ack releasing the socket get processed later */
+                // ack releasing the socket get processed later
         case TCP_SOCKET_CLOSING:
-                /* ack releasing the socket gets processed later */
+                // ack releasing the socket gets processed later
         case TCP_SOCKET_ESTABLISHED:
-                rc = tcp_process_established(socket, socket_data, header,
-                    packet, fragments, total_length);
+                ERROR_CODE = tcp_process_established(socket, socket_data,
+                    header, packet, fragments, total_length);
                 break;
         default:
@@ -442 +497 @@
         }
 
-        if (rc != EOK) {
+        if (ERROR_CODE != EOK) {
+                printf("process %d\n", ERROR_CODE);
                 fibril_rwlock_write_unlock(socket_data->local_lock);
-                printf("process %d\n", rc);
         }
 
@@ -450 +505 @@
 }
 
-int tcp_process_established(socket_core_t *socket, tcp_socket_data_t *
-    socket_data, tcp_header_t *header, packet_t *packet, int fragments,
+int
+tcp_process_established(socket_core_ref socket, tcp_socket_data_ref socket_data,
+    tcp_header_ref header, packet_t packet, int fragments,
     size_t total_length)
 {
-        packet_t *next_packet;
-        packet_t *tmp_packet;
+        ERROR_DECLARE;
+
+        packet_t next_packet;
+        packet_t tmp_packet;
         uint32_t old_incoming;
         size_t order;
@@ -462 +520 @@
         size_t offset;
         uint32_t new_sequence_number;
-        bool forced_ack;
-        int rc;
 
         assert(socket);
@@ -471 +527 @@
         assert(packet);
 
-        forced_ack = false;
-
         new_sequence_number = ntohl(header->sequence_number);
         old_incoming = socket_data->next_incoming;
 
-        if (header->finalize) {
-                socket_data->fin_incoming = new_sequence_number +
-                    total_length - TCP_HEADER_LENGTH(header);
-        }
-
-        /* Trim begining if containing expected data */
+        if (header->finalize)
+                socket_data->fin_incoming = new_sequence_number;
+
+        // trim begining if containing expected data
         if (IS_IN_INTERVAL_OVERFLOW(new_sequence_number,
             socket_data->next_incoming, new_sequence_number + total_length)) {
 
-                /* Get the acknowledged offset */
+                // get the acknowledged offset
                 if (socket_data->next_incoming < new_sequence_number) {
                         offset = new_sequence_number -
@@ -497 +549 @@
                 total_length -= offset;
                 length = packet_get_data_length(packet);
-
-                /* Trim the acknowledged data */
+                // trim the acknowledged data
                 while (length <= offset) {
-                        /* Release the acknowledged packets */
+                        // release the acknowledged packets
                         next_packet = pq_next(packet);
                         pq_release_remote(tcp_globals.net_phone,
@@ -509 +560 @@
                 }
 
-                if (offset > 0) {
-                        rc = packet_trim(packet, offset, 0);
-                        if (rc != EOK)
-                                return tcp_release_and_return(packet, rc);
-                }
+                if ((offset > 0) && (ERROR_OCCURRED(packet_trim(packet,
+                    offset, 0))))
+                        return tcp_release_and_return(packet, ERROR_CODE);
 
                 assert(new_sequence_number == socket_data->next_incoming);
         }
 
-        /* Release if overflowing the window */
+        // release if overflowing the window
 /*
         if (IS_IN_INTERVAL_OVERFLOW(socket_data->next_incoming +
@@ -545 +594 @@
                         if (length <= offset)
                                 next_packet = pq_next(next_packet);
-                        else {
-                                rc = packet_trim(next_packet, 0,
-                                    length - offset));
-                                if (rc != EOK)
-                                        return tcp_release_and_return(packet,
-                                            rc);
-                        }
+                        else if (ERROR_OCCURRED(packet_trim(next_packet, 0,
+                            length - offset)))
+                                return tcp_release_and_return(packet,
+                                    ERROR_CODE);
                         offset -= length;
                         total_length -= length - offset;
@@ -568 +614 @@
         }
 */
-        /* The expected one arrived? */
+        // the expected one arrived?
         if (new_sequence_number == socket_data->next_incoming) {
                 printf("expected\n");
-                /* Process acknowledgement */
+                // process acknowledgement
                 tcp_process_acknowledgement(socket, socket_data, header);
 
-                /* Remove the header */
+                // remove the header
                 total_length -= TCP_HEADER_LENGTH(header);
-                rc = packet_trim(packet, TCP_HEADER_LENGTH(header), 0);
-                if (rc != EOK)
-                        return tcp_release_and_return(packet, rc);
+                if (ERROR_OCCURRED(packet_trim(packet,
+                    TCP_HEADER_LENGTH(header), 0)))
+                        return tcp_release_and_return(packet, ERROR_CODE);
 
                 if (total_length) {
-                        rc = tcp_queue_received_packet(socket, socket_data,
-                            packet, fragments, total_length);
-                        if (rc != EOK)
-                                return rc;
+                        ERROR_PROPAGATE(tcp_queue_received_packet(socket,
+                            socket_data, packet, fragments, total_length));
                 } else {
                         total_length = 1;
@@ -592 +636 @@
                 packet = socket_data->incoming;
                 while (packet) {
-                        rc = pq_get_order(socket_data->incoming, &order, NULL);
-                        if (rc != EOK) {
-                                /* Remove the corrupted packet */
+
+                        if (ERROR_OCCURRED(pq_get_order(socket_data->incoming,
+                            &order, NULL))) {
+                                // remove the corrupted packet
                                 next_packet = pq_detach(packet);
                                 if (packet == socket_data->incoming)
@@ -607 +652 @@
                         if (IS_IN_INTERVAL_OVERFLOW(sequence_number,
                             old_incoming, socket_data->next_incoming)) {
-                                /* Move to the next */
+                                // move to the next
                                 packet = pq_next(packet);
-                                /* Coninual data? */
+                                // coninual data?
                         } else if (IS_IN_INTERVAL_OVERFLOW(old_incoming,
                             sequence_number, socket_data->next_incoming)) {
-                                /* Detach the packet */
+                                // detach the packet
                                 next_packet = pq_detach(packet);
                                 if (packet == socket_data->incoming)
                                         socket_data->incoming = next_packet;
-                                /* Get data length */
+                                // get data length
                                 length = packet_get_data_length(packet);
                                 new_sequence_number = sequence_number + length;
                                 if (length <= 0) {
-                                        /* Remove the empty packet */
+                                        // remove the empty packet
                                         pq_release_remote(tcp_globals.net_phone,
                                             packet_get_id(packet));
@@ -626 +671 @@
                                         continue;
                                 }
-                                /* Exactly following */
+                                // exactly following
                                 if (sequence_number ==
                                     socket_data->next_incoming) {
-                                        /* Queue received data */
-                                        rc = tcp_queue_received_packet(socket,
+                                        // queue received data
+                                        ERROR_PROPAGATE(
+                                            tcp_queue_received_packet(socket,
                                             socket_data, packet, 1,
-                                            packet_get_data_length(packet));
-                                        if (rc != EOK)
-                                                return rc;
+                                            packet_get_data_length(packet)));
                                         socket_data->next_incoming =
                                             new_sequence_number;
                                         packet = next_packet;
                                         continue;
-                                        /* At least partly following data? */
-                                }
-                                if (IS_IN_INTERVAL_OVERFLOW(sequence_number,
-                                    socket_data->next_incoming, new_sequence_number)) {
+                                        // at least partly following data?
+                                } else if (IS_IN_INTERVAL_OVERFLOW(
+                                    sequence_number, socket_data->next_incoming,
+                                    new_sequence_number)) {
                                         if (socket_data->next_incoming <
                                             new_sequence_number) {
@@ -652 +696 @@
                                                     new_sequence_number;
                                         }
-                                        rc = packet_trim(packet,length, 0);
-                                        if (rc == EOK) {
-                                                /* Queue received data */
-                                                rc = tcp_queue_received_packet(
+                                        if (ERROR_NONE(packet_trim(packet,
+                                            length, 0))) {
+                                                // queue received data
+                                                ERROR_PROPAGATE(
+                                                    tcp_queue_received_packet(
                                                     socket, socket_data, packet,
                                                     1, packet_get_data_length(
-                                                    packet));
-                                                if (rc != EOK)
-                                                        return rc;
+                                                    packet)));
                                                 socket_data->next_incoming =
                                                     new_sequence_number;
@@ -667 +710 @@
                                         }
                                 }
-                                /* Remove the duplicit or corrupted packet */
+                                // remove the duplicit or corrupted packet
                                 pq_release_remote(tcp_globals.net_phone,
                                     packet_get_id(packet));
@@ -680 +723 @@
             socket_data->next_incoming + socket_data->window)) {
                 printf("in window\n");
-                /* Process acknowledgement */
+                // process acknowledgement
                 tcp_process_acknowledgement(socket, socket_data, header);
 
-                /* Remove the header */
+                // remove the header
                 total_length -= TCP_HEADER_LENGTH(header);
-                rc = packet_trim(packet, TCP_HEADER_LENGTH(header), 0);
-                if (rc != EOK)
-                        return tcp_release_and_return(packet, rc);
+                if (ERROR_OCCURRED(packet_trim(packet,
+                    TCP_HEADER_LENGTH(header), 0)))
+                        return tcp_release_and_return(packet, ERROR_CODE);
 
                 next_packet = pq_detach(packet);
                 length = packet_get_data_length(packet);
-                rc = pq_add(&socket_data->incoming, packet, new_sequence_number,
-                    length);
-                if (rc != EOK) {
-                        /* Remove the corrupted packets */
+                if (ERROR_OCCURRED(pq_add(&socket_data->incoming, packet,
+                    new_sequence_number, length))) {
+                        // remove the corrupted packets
                         pq_release_remote(tcp_globals.net_phone,
                             packet_get_id(packet));
@@ -704 +746 @@
                                 tmp_packet = pq_detach(next_packet);
                                 length = packet_get_data_length(next_packet);
-
-                                rc = pq_set_order(next_packet,
-                                    new_sequence_number, length);
-                                if (rc != EOK) {
-                                        pq_release_remote(tcp_globals.net_phone,
-                                            packet_get_id(next_packet));
-                                }
-                                rc = pq_insert_after(packet, next_packet);
-                                if (rc != EOK) {
+                                if (ERROR_OCCURRED(pq_set_order(next_packet,
+                                    new_sequence_number, length)) ||
+                                    ERROR_OCCURRED(pq_insert_after(packet,
+                                    next_packet))) {
                                         pq_release_remote(tcp_globals.net_phone,
                                             packet_get_id(next_packet));
@@ -721 +758 @@
         } else {
                 printf("unexpected\n");
-                /* Release duplicite or restricted */
+                // release duplicite or restricted
                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
-                forced_ack = true;
-        }
-
-        /* If next in sequence is an incoming FIN */
-        if (socket_data->next_incoming == socket_data->fin_incoming) {
-                /* Advance sequence number */
-                socket_data->next_incoming += 1;
-
-                /* Handle FIN */
+        }
+
+        // change state according to the acknowledging incoming fin
+        if (IS_IN_INTERVAL_OVERFLOW(old_incoming, socket_data->fin_incoming,
+            socket_data->next_incoming)) {
                 switch (socket_data->state) {
                 case TCP_SOCKET_FIN_WAIT_1:
@@ -738 +771 @@
                         socket_data->state = TCP_SOCKET_CLOSING;
                         break;
-                case TCP_SOCKET_ESTABLISHED:
-                        /* Queue end-of-data marker on the socket. */
-                        tcp_queue_received_end_of_data(socket);
-                        socket_data->state = TCP_SOCKET_CLOSE_WAIT;
-                        break;
+                        //case TCP_ESTABLISHED:
                 default:
                         socket_data->state = TCP_SOCKET_CLOSE_WAIT;
@@ -750 +779 @@
 
         packet = tcp_get_packets_to_send(socket, socket_data);
-        if (!packet && (socket_data->next_incoming != old_incoming || forced_ack)) {
-                /* Create the notification packet */
-                rc = tcp_create_notification_packet(&packet, socket,
-                    socket_data, 0, 0);
-                if (rc != EOK)
-                        return rc;
-                rc = tcp_queue_prepare_packet(socket, socket_data, packet, 1);
-                if (rc != EOK)
-                        return rc;
+        if (!packet) {
+                // create the notification packet
+                ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket,
+                    socket_data, 0, 0));
+                ERROR_PROPAGATE(tcp_queue_prepare_packet(socket, socket_data,
+                    packet, 1));
                 packet = tcp_send_prepare_packet(socket, socket_data, packet, 1,
                     socket_data->last_outgoing + 1);
@@ -765 +791 @@
         fibril_rwlock_write_unlock(socket_data->local_lock);
 
-        /* Send the packet */
+        // send the packet
         tcp_send_packets(socket_data->device_id, packet);
 
@@ -771 +797 @@
 }
 
-int tcp_queue_received_packet(socket_core_t *socket,
-    tcp_socket_data_t *socket_data, packet_t *packet, int fragments,
+int
+tcp_queue_received_packet(socket_core_ref socket,
+    tcp_socket_data_ref socket_data, packet_t packet, int fragments,
     size_t total_length)
 {
-        packet_dimension_t *packet_dimension;
-        int rc;
+        ERROR_DECLARE;
+
+        packet_dimension_ref packet_dimension;
 
         assert(socket);
@@ -785 +813 @@
         assert(socket_data->window > total_length);
 
-        /* Queue the received packet */
-        rc = dyn_fifo_push(&socket->received, packet_get_id(packet),
-            SOCKET_MAX_RECEIVED_SIZE);
-        if (rc != EOK)
-                return tcp_release_and_return(packet, rc);
-        rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
-            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
-        if (rc != EOK)
-                return tcp_release_and_return(packet, rc);
-
-        /* Decrease the window size */
+        // queue the received packet
+        if (ERROR_OCCURRED(dyn_fifo_push(&socket->received,
+            packet_get_id(packet), SOCKET_MAX_RECEIVED_SIZE)) ||
+            ERROR_OCCURRED(tl_get_ip_packet_dimension(tcp_globals.ip_phone,
+            &tcp_globals.dimensions, socket_data->device_id,
+            &packet_dimension))) {
+                return tcp_release_and_return(packet, ERROR_CODE);
+        }
+
+        // decrease the window size
         socket_data->window -= total_length;
 
-        /* Notify the destination socket */
+        // notify the destination socket
         async_msg_5(socket->phone, NET_SOCKET_RECEIVED,
-            (sysarg_t) socket->socket_id,
+            (ipcarg_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);
+            (ipcarg_t) fragments);
 
         return EOK;
 }
 
-/** Queue end-of-data marker on the socket.
- *
- * Next element in the sequence space is FIN. Queue end-of-data marker
- * on the socket.
- *
- * @param socket        Socket
- */
-static void tcp_queue_received_end_of_data(socket_core_t *socket)
-{
-        assert(socket != NULL);
-
-        /* Notify the destination socket */
-        async_msg_5(socket->phone, NET_SOCKET_RECEIVED,
-            (sysarg_t) socket->socket_id,
-            0, 0, 0,
-            (sysarg_t) 0 /* 0 fragments == no more data */);
-}
-
-int tcp_process_syn_sent(socket_core_t *socket, tcp_socket_data_t *
-    socket_data, tcp_header_t *header, packet_t *packet)
-{
-        packet_t *next_packet;
-        int rc;
+int
+tcp_process_syn_sent(socket_core_ref socket, tcp_socket_data_ref socket_data,
+    tcp_header_ref header, packet_t packet)
+{
+        ERROR_DECLARE;
+
+        packet_t next_packet;
 
         assert(socket);
@@ -841 +852 @@
                 return tcp_release_and_return(packet, EINVAL);
         
-        /* Process acknowledgement */
+        // process acknowledgement
         tcp_process_acknowledgement(socket, socket_data, header);
 
         socket_data->next_incoming = ntohl(header->sequence_number) + 1;
-
-        /* Release additional packets */
+        // release additional packets
         next_packet = pq_detach(packet);
         if (next_packet) {
@@ -852 +862 @@
                     packet_get_id(next_packet));
         }
-
-        /* Trim if longer than the header */
-        if (packet_get_data_length(packet) > sizeof(*header)) {
-                rc = packet_trim(packet, 0,
-                    packet_get_data_length(packet) - sizeof(*header));
-                if (rc != EOK)
-                        return tcp_release_and_return(packet, rc);
-        }
-
+        // trim if longer than the header
+        if ((packet_get_data_length(packet) > sizeof(*header)) &&
+            ERROR_OCCURRED(packet_trim(packet, 0,
+            packet_get_data_length(packet) - sizeof(*header)))) {
+                return tcp_release_and_return(packet, ERROR_CODE);
+        }
         tcp_prepare_operation_header(socket, socket_data, header, 0, 0);
         fibril_mutex_lock(&socket_data->operation.mutex);
         socket_data->operation.result = tcp_queue_packet(socket, socket_data,
             packet, 1);
-
         if (socket_data->operation.result == EOK) {
                 socket_data->state = TCP_SOCKET_ESTABLISHED;
@@ -871 +877 @@
                 if (packet) {
                         fibril_rwlock_write_unlock( socket_data->local_lock);
-                        /* Send the packet */
+                        // send the packet
                         tcp_send_packets(socket_data->device_id, packet);
-                        /* Signal the result */
+                        // signal the result
                         fibril_condvar_signal( &socket_data->operation.condvar);
                         fibril_mutex_unlock( &socket_data->operation.mutex);
@@ -879 +885 @@
                 }
         }
-
         fibril_mutex_unlock(&socket_data->operation.mutex);
         return tcp_release_and_return(packet, EINVAL);
 }
 
-int tcp_process_listen(socket_core_t *listening_socket,
-    tcp_socket_data_t *listening_socket_data, tcp_header_t *header,
-    packet_t *packet, struct sockaddr *src, struct sockaddr *dest,
+int
+tcp_process_listen(socket_core_ref listening_socket,
+    tcp_socket_data_ref listening_socket_data, tcp_header_ref header,
+    packet_t packet, struct sockaddr *src, struct sockaddr *dest,
     size_t addrlen)
 {
-        packet_t *next_packet;
-        socket_core_t *socket;
-        tcp_socket_data_t *socket_data;
+        ERROR_DECLARE;
+
+        packet_t next_packet;
+        socket_core_ref socket;
+        tcp_socket_data_ref socket_data;
         int socket_id;
         int listening_socket_id = listening_socket->socket_id;
         int listening_port = listening_socket->port;
-        int rc;
 
         assert(listening_socket);
@@ -906 +913 @@
                 return tcp_release_and_return(packet, EINVAL);
 
-        socket_data = (tcp_socket_data_t *) malloc(sizeof(*socket_data));
+        socket_data = (tcp_socket_data_ref) malloc(sizeof(*socket_data));
         if (!socket_data)
                 return tcp_release_and_return(packet, ENOMEM);
@@ -923 +930 @@
                 return tcp_release_and_return(packet, ENOMEM);
         }
-
         memcpy(socket_data->addr, src, socket_data->addrlen);
         socket_data->dest_port = ntohs(header->source_port);
-        rc = tl_set_address_port(socket_data->addr, socket_data->addrlen,
-            socket_data->dest_port);
-        if (rc != EOK) {
+        if (ERROR_OCCURRED(tl_set_address_port(socket_data->addr,
+            socket_data->addrlen, socket_data->dest_port))) {
                 free(socket_data->addr);
                 free(socket_data);
-                return tcp_release_and_return(packet, rc);
-        }
-
-        /* Create a socket */
+                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
+                return ERROR_CODE;
+        }
+
+        // create a socket
         socket_id = -1;
-        rc = socket_create(socket_data->local_sockets, listening_socket->phone,
-            socket_data, &socket_id);
-        if (rc != EOK) {
+        if (ERROR_OCCURRED(socket_create(socket_data->local_sockets,
+            listening_socket->phone, socket_data, &socket_id))) {
                 free(socket_data->addr);
                 free(socket_data);
-                return tcp_release_and_return(packet, rc);
+                return tcp_release_and_return(packet, ERROR_CODE);
         }
 
@@ -953 +958 @@
         fibril_rwlock_write_lock(&tcp_globals.lock);
 
-        /* Find the destination socket */
+        // find the destination socket
         listening_socket = socket_port_find(&tcp_globals.sockets,
-            listening_port, (uint8_t *) SOCKET_MAP_KEY_LISTENING, 0);
-        if (!listening_socket ||
+            listening_port, SOCKET_MAP_KEY_LISTENING, 0);
+        if ((!listening_socket) ||
             (listening_socket->socket_id != listening_socket_id)) {
                 fibril_rwlock_write_unlock(&tcp_globals.lock);
-                /* A shadow may remain until app hangs up */
+                // a shadow may remain until app hangs up
                 return tcp_release_and_return(packet, EOK /*ENOTSOCK*/);
         }
         listening_socket_data =
-            (tcp_socket_data_t *) listening_socket->specific_data;
+            (tcp_socket_data_ref) listening_socket->specific_data;
         assert(listening_socket_data);
 
@@ -971 +976 @@
             socket_id);
         if (!socket) {
-                /* Where is the socket?!? */
+                // where is the socket?!?
                 fibril_rwlock_write_unlock(&tcp_globals.lock);
                 return ENOTSOCK;
         }
-        socket_data = (tcp_socket_data_t *) socket->specific_data;
+        socket_data = (tcp_socket_data_ref) socket->specific_data;
         assert(socket_data);
 
-        rc = socket_port_add(&tcp_globals.sockets, listening_port, socket,
-            (uint8_t *) socket_data->addr, socket_data->addrlen);
+        ERROR_CODE = socket_port_add(&tcp_globals.sockets, listening_port,
+            socket, (const char *) socket_data->addr, socket_data->addrlen);
         assert(socket == socket_port_find(&tcp_globals.sockets, listening_port,
-            (uint8_t *) socket_data->addr, socket_data->addrlen));
-
-//      rc = socket_bind_free_port(&tcp_globals.sockets, socket,
+            (const char *) socket_data->addr, socket_data->addrlen));
+
+//      ERROR_CODE = socket_bind_free_port(&tcp_globals.sockets, socket,
 //          TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
 //          tcp_globals.last_used_port);
 //      tcp_globals.last_used_port = socket->port;
         fibril_rwlock_write_unlock(&tcp_globals.lock);
-        if (rc != EOK) {
+        if (ERROR_CODE != EOK) {
                 socket_destroy(tcp_globals.net_phone, socket->socket_id,
                     socket_data->local_sockets, &tcp_globals.sockets,
                     tcp_free_socket_data);
-                return tcp_release_and_return(packet, rc);
+                return tcp_release_and_return(packet, ERROR_CODE);
         }
 
@@ -998 +1003 @@
         socket_data->next_incoming = ntohl(header->sequence_number) + 1;
 
-        /* Release additional packets */
+        // release additional packets
         next_packet = pq_detach(packet);
         if (next_packet) {
@@ -1005 +1010 @@
         }
 
-        /* Trim if longer than the header */
-        if (packet_get_data_length(packet) > sizeof(*header)) {
-                rc = packet_trim(packet, 0,
-                    packet_get_data_length(packet) - sizeof(*header));
-                if (rc != EOK) {
-                        socket_destroy(tcp_globals.net_phone, socket->socket_id,
-                            socket_data->local_sockets, &tcp_globals.sockets,
-                            tcp_free_socket_data);
-                        return tcp_release_and_return(packet, rc);
-                }
-        }
-
-        tcp_prepare_operation_header(socket, socket_data, header, 1, 0);
-
-        rc = tcp_queue_packet(socket, socket_data, packet, 1);
-        if (rc != EOK) {
+        // trim if longer than the header
+        if ((packet_get_data_length(packet) > sizeof(*header)) &&
+            ERROR_OCCURRED(packet_trim(packet, 0,
+            packet_get_data_length(packet) - sizeof(*header)))) {
                 socket_destroy(tcp_globals.net_phone, socket->socket_id,
                     socket_data->local_sockets, &tcp_globals.sockets,
                     tcp_free_socket_data);
-                return rc;
+                return tcp_release_and_return(packet, ERROR_CODE);
+        }
+
+        tcp_prepare_operation_header(socket, socket_data, header, 1, 0);
+
+        if (ERROR_OCCURRED(tcp_queue_packet(socket, socket_data, packet, 1))) {
+                socket_destroy(tcp_globals.net_phone, socket->socket_id,
+                    socket_data->local_sockets, &tcp_globals.sockets,
+                    tcp_free_socket_data);
+                return ERROR_CODE;
         }
 
@@ -1038 +1040 @@
         fibril_rwlock_write_unlock(socket_data->local_lock);
 
-        /* Send the packet */
+        // send the packet
         tcp_send_packets(socket_data->device_id, packet);
 
@@ -1044 +1046 @@
 }
 
-int tcp_process_syn_received(socket_core_t *socket,
-    tcp_socket_data_t *socket_data, tcp_header_t *header, packet_t *packet)
-{
-        socket_core_t *listening_socket;
-        tcp_socket_data_t *listening_socket_data;
-        int rc;
+int
+tcp_process_syn_received(socket_core_ref socket,
+    tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet)
+{
+        ERROR_DECLARE;
+
+        socket_core_ref listening_socket;
+        tcp_socket_data_ref listening_socket_data;
 
         assert(socket);
@@ -1060 +1064 @@
                 return tcp_release_and_return(packet, EINVAL);
 
-        /* Process acknowledgement */
+        // process acknowledgement
         tcp_process_acknowledgement(socket, socket_data, header);
 
-        socket_data->next_incoming = ntohl(header->sequence_number); /* + 1; */
+        socket_data->next_incoming = ntohl(header->sequence_number);    // + 1;
         pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
         socket_data->state = TCP_SOCKET_ESTABLISHED;
@@ -1070 +1074 @@
         if (listening_socket) {
                 listening_socket_data =
-                    (tcp_socket_data_t *) listening_socket->specific_data;
+                    (tcp_socket_data_ref) listening_socket->specific_data;
                 assert(listening_socket_data);
 
-                /* Queue the received packet */
-                rc = dyn_fifo_push(&listening_socket->accepted,
-                    (-1 * socket->socket_id), listening_socket_data->backlog);
-                if (rc == EOK) {
-                        /* Notify the destination socket */
+                // queue the received packet
+                if (ERROR_NONE(dyn_fifo_push(&listening_socket->accepted,
+                    (-1 * socket->socket_id),
+                    listening_socket_data->backlog))) {
+
+                        // notify the destination socket
                         async_msg_5(socket->phone, NET_SOCKET_ACCEPTED,
-                            (sysarg_t) listening_socket->socket_id,
+                            (ipcarg_t) listening_socket->socket_id,
                             socket_data->data_fragment_size, TCP_HEADER_SIZE,
-                            0, (sysarg_t) socket->socket_id);
+                            0, (ipcarg_t) socket->socket_id);
 
                         fibril_rwlock_write_unlock(socket_data->local_lock);
@@ -1087 +1092 @@
                 }
         }
-        /* Send FIN */
+        // send FIN
         socket_data->state = TCP_SOCKET_FIN_WAIT_1;
 
-        /* Create the notification packet */
-        rc = tcp_create_notification_packet(&packet, socket, socket_data, 0, 1);
-        if (rc != EOK)
-                return rc;
-
-        /* Send the packet */
-        rc = tcp_queue_packet(socket, socket_data, packet, 1);
-        if (rc != EOK)
-                return rc;
-
-        /* Flush packets */
+        // create the notification packet
+        ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket,
+            socket_data, 0, 1));
+
+        // send the packet
+        ERROR_PROPAGATE(tcp_queue_packet(socket, socket_data, packet, 1));
+
+        // flush packets
         packet = tcp_get_packets_to_send(socket, socket_data);
         fibril_rwlock_write_unlock(socket_data->local_lock);
         if (packet) {
-                /* Send the packet */
+                // send the packet
                 tcp_send_packets(socket_data->device_id, packet);
         }
@@ -1111 +1113 @@
 }
 
-void tcp_process_acknowledgement(socket_core_t *socket,
-    tcp_socket_data_t *socket_data, tcp_header_t *header)
+void
+tcp_process_acknowledgement(socket_core_ref socket,
+    tcp_socket_data_ref socket_data, tcp_header_ref header)
 {
         size_t number;
         size_t length;
-        packet_t *packet;
-        packet_t *next;
-        packet_t *acknowledged = NULL;
+        packet_t packet;
+        packet_t next;
+        packet_t acknowledged = NULL;
         uint32_t old;
 
@@ -1130 +1133 @@
 
         number = ntohl(header->acknowledgement_number);
-
-        /* If more data acknowledged */
+        // if more data acknowledged
         if (number != socket_data->expected) {
                 old = socket_data->expected;
@@ -1142 +1144 @@
                         case TCP_SOCKET_LAST_ACK:
                         case TCP_SOCKET_CLOSING:
-                                /*
-                                 * FIN acknowledged - release the socket in
-                                 * another fibril.
-                                 */
+                                // fin acknowledged - release the socket in
+                                // another fibril
                                 tcp_prepare_timeout(tcp_release_after_timeout,
                                     socket, socket_data, 0,
@@ -1155 +1155 @@
                         }
                 }
-
-                /* Update the treshold if higher than set */
+                // update the treshold if higher than set
                 if (number + ntohs(header->window) >
                     socket_data->expected + socket_data->treshold) {
@@ -1162 +1161 @@
                             socket_data->expected;
                 }
-
-                /* Set new expected sequence number */
+                // set new expected sequence number
                 socket_data->expected = number;
                 socket_data->expected_count = 1;
@@ -1175 +1173 @@
                                         socket_data->outgoing = next;
 
-                                /* Add to acknowledged or release */
+                                // add to acknowledged or release
                                 if (pq_add(&acknowledged, packet, 0, 0) != EOK)
                                         pq_release_remote(tcp_globals.net_phone,
@@ -1183 +1181 @@
                                 break;
                 }
-
-                /* Release acknowledged */
+                // release acknowledged
                 if (acknowledged) {
                         pq_release_remote(tcp_globals.net_phone,
@@ -1190 +1187 @@
                 }
                 return;
-                /* If the same as the previous time */
-        }
-
+                // if the same as the previous time
+        }
         if (number == socket_data->expected) {
-                /* Increase the counter */
-                socket_data->expected_count++;
+                // increase the counter
+                ++socket_data->expected_count;
                 if (socket_data->expected_count == TCP_FAST_RETRANSMIT_COUNT) {
                         socket_data->expected_count = 1;
-                        /* TODO retransmit lock */
+                        // TODO retransmit lock
                         //tcp_retransmit_packet(socket, socket_data, number);
                 }
@@ -1204 +1200 @@
 }
 
-/** Per-connection initialization
- *
- */
-void tl_connection(void)
-{
-}
-
-/** Processes the TCP message.
- *
- * @param[in] callid    The message identifier.
- * @param[in] call      The message parameters.
- * @param[out] answer   The message answer parameters.
- * @param[out] answer_count The last parameter for the actual answer in the
- *                      answer parameter.
- * @return              EOK on success.
- * @return              ENOTSUP if the message is not known.
- *
- * @see tcp_interface.h
- * @see IS_NET_TCP_MESSAGE()
- */
-int tl_message(ipc_callid_t callid, ipc_call_t *call,
-    ipc_call_t *answer, size_t *answer_count)
-{
+int tcp_message_standalone(ipc_callid_t callid, ipc_call_t * call,
+    ipc_call_t * answer, int *answer_count)
+{
+        ERROR_DECLARE;
+
+        packet_t packet;
+
         assert(call);
         assert(answer);
@@ -1232 +1212 @@
 
         *answer_count = 0;
-        switch (IPC_GET_IMETHOD(*call)) {
+        switch (IPC_GET_METHOD(*call)) {
+        case NET_TL_RECEIVED:
+                //fibril_rwlock_read_lock(&tcp_globals.lock);
+                if (ERROR_NONE(packet_translate_remote(tcp_globals.net_phone,
+                    &packet, IPC_GET_PACKET(call)))) {
+                        ERROR_CODE = tcp_received_msg(IPC_GET_DEVICE(call),
+                            packet, SERVICE_TCP, IPC_GET_ERROR(call));
+                }
+                //fibril_rwlock_read_unlock(&tcp_globals.lock);
+                return ERROR_CODE;
+
         case IPC_M_CONNECT_TO_ME:
                 return tcp_process_client_messages(callid, *call);
@@ -1240 +1230 @@
 }
 
-void tcp_refresh_socket_data(tcp_socket_data_t *socket_data)
+void tcp_refresh_socket_data(tcp_socket_data_ref socket_data)
 {
         assert(socket_data);
@@ -1256 +1246 @@
 }
 
-void tcp_initialize_socket_data(tcp_socket_data_t *socket_data)
+void tcp_initialize_socket_data(tcp_socket_data_ref socket_data)
 {
         assert(socket_data);
@@ -1271 +1261 @@
         bool keep_on_going = true;
         socket_cores_t local_sockets;
-        int app_phone = IPC_GET_PHONE(call);
+        int app_phone = IPC_GET_PHONE(&call);
         struct sockaddr *addr;
         int socket_id;
@@ -1278 +1268 @@
         fibril_rwlock_t lock;
         ipc_call_t answer;
-        size_t answer_count;
-        tcp_socket_data_t *socket_data;
-        socket_core_t *socket;
-        packet_dimension_t *packet_dimension;
+        int answer_count;
+        tcp_socket_data_ref socket_data;
+        socket_core_ref socket;
+        packet_dimension_ref packet_dimension;
 
         /*
@@ -1295 +1285 @@
         while (keep_on_going) {
 
-                /* Answer the call */
+                // answer the call
                 answer_call(callid, res, &answer, answer_count);
-                /* Refresh data */
+                // refresh data
                 refresh_answer(&answer, &answer_count);
-                /* Get the next call */
+                // get the next call
                 callid = async_get_call(&call);
 
-                /* Process the call */
-                switch (IPC_GET_IMETHOD(call)) {
+                // process the call
+                switch (IPC_GET_METHOD(call)) {
                 case IPC_M_PHONE_HUNGUP:
                         keep_on_going = false;
@@ -1311 +1301 @@
                 case NET_SOCKET:
                         socket_data =
-                            (tcp_socket_data_t *) malloc(sizeof(*socket_data));
+                            (tcp_socket_data_ref) malloc(sizeof(*socket_data));
                         if (!socket_data) {
                                 res = ENOMEM;
@@ -1345 +1335 @@
 
                 case NET_SOCKET_BIND:
-                        res = async_data_write_accept((void **) &addr, false,
-                            0, 0, 0, &addrlen);
+                        res = data_receive((void **) &addr, &addrlen);
                         if (res != EOK)
                                 break;
@@ -1359 +1348 @@
                                     SOCKET_GET_SOCKET_ID(call));
                                 if (socket) {
-                                        socket_data = (tcp_socket_data_t *)
+                                        socket_data = (tcp_socket_data_ref)
                                             socket->specific_data;
                                         assert(socket_data);
@@ -1383 +1372 @@
 
                 case NET_SOCKET_CONNECT:
-                        res = async_data_write_accept((void **) &addr, false,
-                            0, 0, 0, &addrlen);
+                        res = data_receive((void **) &addr, &addrlen);
                         if (res != EOK)
                                 break;
-                        /*
-                         * The global lock may be released in the
-                         * tcp_connect_message() function.
-                         */
+                        // the global lock may be released in the
+                        // tcp_connect_message() function
                         fibril_rwlock_write_lock(&tcp_globals.lock);
                         fibril_rwlock_write_lock(&lock);
@@ -1435 +1421 @@
 
                 case NET_SOCKET_SENDTO:
-                        res = async_data_write_accept((void **) &addr, false,
-                            0, 0, 0, &addrlen);
+                        res = data_receive((void **) &addr, &addrlen);
                         if (res != EOK)
                                 break;
@@ -1505 +1490 @@
         }
 
-        /* Release the application phone */
-        async_hangup(app_phone);
+        // release the application phone
+        ipc_hangup(app_phone);
 
         printf("release\n");
-        /* Release all local sockets */
+        // release all local sockets
         socket_cores_release(tcp_globals.net_phone, &local_sockets,
             &tcp_globals.sockets, tcp_free_socket_data);
@@ -1518 +1503 @@
 int tcp_timeout(void *data)
 {
-        tcp_timeout_t *timeout = data;
+        tcp_timeout_ref timeout = data;
         int keep_write_lock = false;
-        socket_core_t *socket;
-        tcp_socket_data_t *socket_data;
+        socket_core_ref socket;
+        tcp_socket_data_ref socket_data;
 
         assert(timeout);
 
-        /* Sleep the given timeout */
+        // sleep the given timeout
         async_usleep(timeout->timeout);
-        /* Lock the globals */
+        // lock the globals
         if (timeout->globals_read_only) 
                 fibril_rwlock_read_lock(&tcp_globals.lock);
@@ -1533 +1518 @@
                 fibril_rwlock_write_lock(&tcp_globals.lock);
 
-        /* Find the pending operation socket */
+        // find the pending operation socket
         socket = socket_port_find(&tcp_globals.sockets, timeout->port,
             timeout->key, timeout->key_length);
-        if (!socket || (socket->socket_id != timeout->socket_id))
+        if (!(socket && (socket->socket_id == timeout->socket_id)))
                 goto out;
         
-        socket_data = (tcp_socket_data_t *) socket->specific_data;
+        socket_data = (tcp_socket_data_ref) socket->specific_data;
         assert(socket_data);
         if (socket_data->local_sockets != timeout->local_sockets)
@@ -1546 +1531 @@
         fibril_rwlock_write_lock(socket_data->local_lock);
         if (timeout->sequence_number) {
-                /* Increase the timeout counter */
-                socket_data->timeout_count++;
+                // increase the timeout counter;
+                ++socket_data->timeout_count;
                 if (socket_data->timeout_count == TCP_MAX_TIMEOUTS) {
-                        /* TODO release as connection lost */
+                        // TODO release as connection lost
                         //tcp_refresh_socket_data(socket_data);
                         fibril_rwlock_write_unlock(socket_data->local_lock);
                 } else {
-                        /* Retransmit */
+                        // retransmit
 //                      tcp_retransmit_packet(socket,
 //                          socket_data, timeout->sequence_number);
@@ -1560 +1545 @@
         } else {
                 fibril_mutex_lock(&socket_data->operation.mutex);
-                /* Set the timeout operation result if state not changed */
+                // set the timeout operation result if state not
+                // changed
                 if (socket_data->state == timeout->state) {
                         socket_data->operation.result = ETIMEOUT;
-
-                        /* Notify the main fibril */
+                        // notify the main fibril
                         fibril_condvar_signal(&socket_data->operation.condvar);
-
-                        /* Keep the global write lock */
+                        // keep the global write lock
                         keep_write_lock = true;
                 } else {
-                        /*
-                         * Operation is ok, do nothing.
-                         * Unlocking from now on, so the unlocking
-                         * order does not matter.
-                         */
+                        // operation is ok, do nothing
+                        // unlocking from now on, so the unlocki
+                        // order does not matter...
                         fibril_rwlock_write_unlock(socket_data->local_lock);
                 }
@@ -1581 +1563 @@
 
 out:
-        /* Unlock only if no socket */
+        // unlock only if no socket
         if (timeout->globals_read_only)
                 fibril_rwlock_read_unlock(&tcp_globals.lock);
         else if (!keep_write_lock)
-                /* Release if not desired */
+                // release if not desired
                 fibril_rwlock_write_unlock(&tcp_globals.lock);
         
-        /* Release the timeout structure */
+        // release the timeout structure
         free(timeout);
         return EOK;
@@ -1595 +1577 @@
 int tcp_release_after_timeout(void *data)
 {
-        tcp_timeout_t *timeout = data;
-        socket_core_t *socket;
-        tcp_socket_data_t *socket_data;
+        tcp_timeout_ref timeout = data;
+        socket_core_ref socket;
+        tcp_socket_data_ref socket_data;
         fibril_rwlock_t *local_lock;
 
         assert(timeout);
 
-        /* Sleep the given timeout */
+        // sleep the given timeout
         async_usleep(timeout->timeout);
-
-        /* Lock the globals */
+        // lock the globals
         fibril_rwlock_write_lock(&tcp_globals.lock);
-
-        /* Find the pending operation socket */
+        // find the pending operation socket
         socket = socket_port_find(&tcp_globals.sockets, timeout->port,
             timeout->key, timeout->key_length);
-
         if (socket && (socket->socket_id == timeout->socket_id)) {
-                socket_data = (tcp_socket_data_t *) socket->specific_data;
+                socket_data = (tcp_socket_data_ref) socket->specific_data;
                 assert(socket_data);
                 if (socket_data->local_sockets == timeout->local_sockets) {
@@ -1624 +1603 @@
                 }
         }
-
-        /* Unlock the globals */
+        // unlock the globals
         fibril_rwlock_write_unlock(&tcp_globals.lock);
-
-        /* Release the timeout structure */
+        // release the timeout structure
         free(timeout);
-
         return EOK;
 }
 
-void tcp_retransmit_packet(socket_core_t *socket, tcp_socket_data_t *
-    socket_data, size_t sequence_number)
-{
-        packet_t *packet;
-        packet_t *copy;
+void
+tcp_retransmit_packet(socket_core_ref socket, tcp_socket_data_ref socket_data,
+    size_t sequence_number)
+{
+        packet_t packet;
+        packet_t copy;
         size_t data_length;
 
@@ -1645 +1622 @@
         assert(socket->specific_data == socket_data);
 
-        /* Sent packet? */
+        // sent packet?
         packet = pq_find(socket_data->outgoing, sequence_number);
         printf("retransmit %d\n", packet_get_id(packet));
@@ -1661 +1638 @@
 }
 
-int tcp_listen_message(socket_cores_t *local_sockets, int socket_id,
-    int backlog)
-{
-        socket_core_t *socket;
-        tcp_socket_data_t *socket_data;
+int
+tcp_listen_message(socket_cores_ref local_sockets, int socket_id, int backlog)
+{
+        socket_core_ref socket;
+        tcp_socket_data_ref socket_data;
 
         assert(local_sockets);
@@ -1672 +1649 @@
                 return EINVAL;
 
-        /* Find the socket */
+        // find the socket
         socket = socket_cores_find(local_sockets, socket_id);
         if (!socket) 
                 return ENOTSOCK;
         
-        /* Get the socket specific data */
-        socket_data = (tcp_socket_data_t *) socket->specific_data;
+        // get the socket specific data
+        socket_data = (tcp_socket_data_ref) socket->specific_data;
         assert(socket_data);
-
-        /* Set the backlog */
+        // set the backlog
         socket_data->backlog = backlog;
 
@@ -1687 +1663 @@
 }
 
-int tcp_connect_message(socket_cores_t *local_sockets, int socket_id,
+int
+tcp_connect_message(socket_cores_ref local_sockets, int socket_id,
     struct sockaddr *addr, socklen_t addrlen)
 {
-        socket_core_t *socket;
-        int rc;
+        ERROR_DECLARE;
+
+        socket_core_ref socket;
 
         assert(local_sockets);
@@ -1697 +1675 @@
         assert(addrlen > 0);
 
-        /* Find the socket */
+        // find the socket
         socket = socket_cores_find(local_sockets, socket_id);
         if (!socket)
                 return ENOTSOCK;
         
-        rc = tcp_connect_core(socket, local_sockets, addr, addrlen);
-        if (rc != EOK) {
+        if (ERROR_OCCURRED(tcp_connect_core(socket, local_sockets, addr,
+            addrlen))) {
                 tcp_free_socket_data(socket);
-                /* Unbind if bound */
+                // unbind if bound
                 if (socket->port > 0) {
                         socket_ports_exclude(&tcp_globals.sockets,
-                            socket->port, free);
+                            socket->port);
                         socket->port = 0;
                 }
         }
-        return rc;
-}
-
-int tcp_connect_core(socket_core_t *socket, socket_cores_t *local_sockets,
+        return ERROR_CODE;
+}
+
+int
+tcp_connect_core(socket_core_ref socket, socket_cores_ref local_sockets,
     struct sockaddr *addr, socklen_t addrlen)
 {
-        tcp_socket_data_t *socket_data;
-        packet_t *packet;
-        int rc;
+        ERROR_DECLARE;
+
+        tcp_socket_data_ref socket_data;
+        packet_t packet;
 
         assert(socket);
@@ -1726 +1706 @@
         assert(addrlen > 0);
 
-        /* Get the socket specific data */
-        socket_data = (tcp_socket_data_t *) socket->specific_data;
+        // get the socket specific data
+        socket_data = (tcp_socket_data_ref) socket->specific_data;
         assert(socket_data);
         assert(socket->specific_data == socket_data);
@@ -1735 +1715 @@
                 return EINVAL;
 
-        /* Get the destination port */
-        rc = tl_get_address_port(addr, addrlen, &socket_data->dest_port);
-        if (rc != EOK)
-                return rc;
-        
+        // get the destination port
+        ERROR_PROPAGATE(tl_get_address_port(addr, addrlen,
+            &socket_data->dest_port));
         if (socket->port <= 0) {
-                /* Try to find a free port */
-                rc = socket_bind_free_port(&tcp_globals.sockets, socket,
-                    TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
-                    tcp_globals.last_used_port);
-                if (rc != EOK)
-                        return rc;
-                /* Set the next port as the search starting port number */
+                // try to find a free port
+                ERROR_PROPAGATE(socket_bind_free_port(&tcp_globals.sockets,
+                    socket, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
+                    tcp_globals.last_used_port));
+                // set the next port as the search starting port number
                 tcp_globals.last_used_port = socket->port;
         }
 
-        rc = ip_get_route_req(tcp_globals.ip_phone, IPPROTO_TCP,
+        ERROR_PROPAGATE(ip_get_route_req(tcp_globals.ip_phone, IPPROTO_TCP,
             addr, addrlen, &socket_data->device_id,
-            &socket_data->pseudo_header, &socket_data->headerlen);
-        if (rc != EOK)
-                return rc;
-
-        /* Create the notification packet */
-        rc = tcp_create_notification_packet(&packet, socket, socket_data, 1, 0);
-        if (rc != EOK)
-                return rc;
-
-        /* Unlock the globals and wait for an operation */
+            &socket_data->pseudo_header, &socket_data->headerlen));
+
+        // create the notification packet
+        ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket,
+            socket_data, 1, 0));
+
+        // unlock the globals and wait for an operation
         fibril_rwlock_write_unlock(&tcp_globals.lock);
 
         socket_data->addr = addr;
         socket_data->addrlen = addrlen;
-
-        /* Send the packet */
-
-        if (((rc = tcp_queue_packet(socket, socket_data, packet, 1)) != EOK) ||
-            ((rc = tcp_prepare_timeout(tcp_timeout, socket, socket_data, 0,
-            TCP_SOCKET_INITIAL, NET_DEFAULT_TCP_INITIAL_TIMEOUT, false)) !=
-            EOK)) {
+        // send the packet
+        if (ERROR_OCCURRED(tcp_queue_packet(socket, socket_data, packet, 1)) ||
+            ERROR_OCCURRED(tcp_prepare_timeout(tcp_timeout, socket, socket_data,
+            0, TCP_SOCKET_INITIAL, NET_DEFAULT_TCP_INITIAL_TIMEOUT, false))) {
+
                 socket_data->addr = NULL;
                 socket_data->addrlen = 0;
                 fibril_rwlock_write_lock(&tcp_globals.lock);
+
         } else {
+
                 packet = tcp_get_packets_to_send(socket, socket_data);
                 if (packet) {
                         fibril_mutex_lock(&socket_data->operation.mutex);
                         fibril_rwlock_write_unlock(socket_data->local_lock);
-
-                        socket_data->state = TCP_SOCKET_SYN_SENT;
-
-                        /* Send the packet */
+                        // send the packet
                         printf("connecting %d\n", packet_get_id(packet));
                         tcp_send_packets(socket_data->device_id, packet);
 
-                        /* Wait for a reply */
+                        // wait for a reply
                         fibril_condvar_wait(&socket_data->operation.condvar,
                             &socket_data->operation.mutex);
-                        rc = socket_data->operation.result;
-                        if (rc != EOK) {
+                        ERROR_CODE = socket_data->operation.result;
+                        if (ERROR_CODE != EOK) {
                                 socket_data->addr = NULL;
                                 socket_data->addrlen = 0;
@@ -1800 +1770 @@
                         socket_data->addr = NULL;
                         socket_data->addrlen = 0;
-                        rc = EINTR;
+                        ERROR_CODE = EINTR;
                 }
         }
 
         fibril_mutex_unlock(&socket_data->operation.mutex);
-        return rc;
-}
-
-int tcp_queue_prepare_packet(socket_core_t *socket,
-    tcp_socket_data_t *socket_data, packet_t *packet, size_t data_length)
-{
-        tcp_header_t *header;
-        int rc;
+
+        // return the result
+        return ERROR_CODE;
+}
+
+int
+tcp_queue_prepare_packet(socket_core_ref socket,
+    tcp_socket_data_ref socket_data, packet_t packet, size_t data_length)
+{
+        ERROR_DECLARE;
+
+        tcp_header_ref header;
 
         assert(socket);
@@ -1818 +1792 @@
         assert(socket->specific_data == socket_data);
 
-        /* Get TCP header */
-        header = (tcp_header_t *) packet_get_data(packet);
+        // get tcp header
+        header = (tcp_header_ref) packet_get_data(packet);
         if (!header)
                 return NO_DATA;
@@ -1827 +1801 @@
         header->sequence_number = htonl(socket_data->next_outgoing);
 
-        rc = packet_set_addr(packet, NULL, (uint8_t *) socket_data->addr,
-            socket_data->addrlen);
-        if (rc != EOK)
+        if (ERROR_OCCURRED(packet_set_addr(packet, NULL,
+            (uint8_t *) socket_data->addr, socket_data->addrlen)))
                 return tcp_release_and_return(packet, EINVAL);
 
-        /* Remember the outgoing FIN */
+        // remember the outgoing FIN
         if (header->finalize) 
                 socket_data->fin_outgoing = socket_data->next_outgoing;
@@ -1839 +1812 @@
 }
 
-int tcp_queue_packet(socket_core_t *socket, tcp_socket_data_t *socket_data,
-    packet_t *packet, size_t data_length)
-{
-        int rc;
+int
+tcp_queue_packet(socket_core_ref socket, tcp_socket_data_ref socket_data,
+    packet_t packet, size_t data_length)
+{
+        ERROR_DECLARE;
 
         assert(socket);
@@ -1848 +1822 @@
         assert(socket->specific_data == socket_data);
 
-        rc = tcp_queue_prepare_packet(socket, socket_data, packet, data_length);
-        if (rc != EOK)
-                return rc;
-
-        rc = pq_add(&socket_data->outgoing, packet, socket_data->next_outgoing,
-            data_length);
-        if (rc != EOK)
-                return tcp_release_and_return(packet, rc);
+        ERROR_PROPAGATE(tcp_queue_prepare_packet(socket, socket_data, packet,
+            data_length));
+
+        if (ERROR_OCCURRED(pq_add(&socket_data->outgoing, packet,
+            socket_data->next_outgoing, data_length)))
+                return tcp_release_and_return(packet, ERROR_CODE);
 
         socket_data->next_outgoing += data_length;
@@ -1861 +1833 @@
 }
 
-packet_t *tcp_get_packets_to_send(socket_core_t *socket, tcp_socket_data_t *
-    socket_data)
-{
-        packet_t *packet;
-        packet_t *copy;
-        packet_t *sending = NULL;
-        packet_t *previous = NULL;
+packet_t
+tcp_get_packets_to_send(socket_core_ref socket, tcp_socket_data_ref socket_data)
+{
+        ERROR_DECLARE;
+
+        packet_t packet;
+        packet_t copy;
+        packet_t sending = NULL;
+        packet_t previous = NULL;
         size_t data_length;
-        int rc;
 
         assert(socket);
@@ -1879 +1852 @@
                 pq_get_order(packet, NULL, &data_length);
 
-                /*
-                 * Send only if fits into the window, respecting the possible
-                 * overflow.
-                 */
+                // send only if fits into the window
+                // respecting the possible overflow
                 if (!IS_IN_INTERVAL_OVERFLOW(
                     (uint32_t) socket_data->last_outgoing,
@@ -1896 +1867 @@
                 if (!sending) {
                         sending = copy;
-                } else {
-                        rc = pq_insert_after(previous, copy);
-                        if (rc != EOK) {
-                                pq_release_remote(tcp_globals.net_phone,
-                                    packet_get_id(copy));
-                                return sending;
-                        }
+                } else if (ERROR_OCCURRED(pq_insert_after(previous, copy))) {
+                        pq_release_remote(tcp_globals.net_phone,
+                            packet_get_id(copy));
+                        return sending;
                 }
 
                 previous = copy;
                 packet = pq_next(packet);
-
-                /* Overflow occurred? */
-                if (!packet &&
+                // overflow occurred ?
+                if ((!packet) &&
                     (socket_data->last_outgoing > socket_data->next_outgoing)) {
                         printf("gpts overflow\n");
-                        /* Continue from the beginning */
+                        // continue from the beginning
                         packet = socket_data->outgoing;
                 }
@@ -1921 +1888 @@
 }
 
-packet_t *tcp_send_prepare_packet(socket_core_t *socket, tcp_socket_data_t *
-    socket_data, packet_t *packet, size_t data_length, size_t sequence_number)
-{
-        tcp_header_t *header;
+packet_t
+tcp_send_prepare_packet(socket_core_ref socket, tcp_socket_data_ref socket_data,
+    packet_t packet, size_t data_length, size_t sequence_number)
+{
+        ERROR_DECLARE;
+
+        tcp_header_ref header;
         uint32_t checksum;
-        int rc;
 
         assert(socket);
@@ -1932 +1901 @@
         assert(socket->specific_data == socket_data);
 
-        /* Adjust the pseudo header */
-        rc = ip_client_set_pseudo_header_data_length(socket_data->pseudo_header,
-            socket_data->headerlen, packet_get_data_length(packet));
-        if (rc != EOK) {
+        // adjust the pseudo header
+        if (ERROR_OCCURRED(ip_client_set_pseudo_header_data_length(
+            socket_data->pseudo_header, socket_data->headerlen,
+            packet_get_data_length(packet)))) {
                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
                 return NULL;
         }
 
-        /* Get the header */
-        header = (tcp_header_t *) packet_get_data(packet);
+        // get the header
+        header = (tcp_header_ref) packet_get_data(packet);
         if (!header) {
                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
@@ -1948 +1917 @@
         assert(ntohl(header->sequence_number) == sequence_number);
 
-        /* Adjust the header */
+        // adjust the header
         if (socket_data->next_incoming) {
                 header->acknowledgement_number =
@@ -1956 +1925 @@
         header->window = htons(socket_data->window);
 
-        /* Checksum */
+        // checksum
         header->checksum = 0;
         checksum = compute_checksum(0, socket_data->pseudo_header,
             socket_data->headerlen);
-        checksum = compute_checksum(checksum,
-            (uint8_t *) packet_get_data(packet),
+        checksum = compute_checksum(checksum, (uint8_t *) packet_get_data(packet),
             packet_get_data_length(packet));
         header->checksum = htons(flip_checksum(compact_checksum(checksum)));
 
-        /* Prepare the packet */
-        rc = ip_client_prepare_packet(packet, IPPROTO_TCP, 0, 0, 0, 0);
-        if (rc != EOK) {
+        // prepare the packet
+        if (ERROR_OCCURRED(ip_client_prepare_packet(packet, IPPROTO_TCP, 0, 0,
+            0, 0)) || ERROR_OCCURRED(tcp_prepare_timeout(tcp_timeout, socket,
+            socket_data, sequence_number, socket_data->state,
+            socket_data->timeout, true))) {
                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
                 return NULL;
         }
 
-        rc = tcp_prepare_timeout(tcp_timeout, socket, socket_data,
-            sequence_number, socket_data->state, socket_data->timeout, true);
-        if (rc != EOK) {
-                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
-                return NULL;
-        }
-
         return packet;
 }
 
-packet_t *tcp_prepare_copy(socket_core_t *socket, tcp_socket_data_t *
-    socket_data, packet_t *packet, size_t data_length, size_t sequence_number)
-{
-        packet_t *copy;
+packet_t
+tcp_prepare_copy(socket_core_ref socket, tcp_socket_data_ref socket_data,
+    packet_t packet, size_t data_length, size_t sequence_number)
+{
+        packet_t copy;
 
         assert(socket);
@@ -1991 +1955 @@
         assert(socket->specific_data == socket_data);
 
-        /* Make a copy of the packet */
+        // make a copy of the packet
         copy = packet_get_copy(tcp_globals.net_phone, packet);
         if (!copy)
@@ -2000 +1964 @@
 }
 
-void tcp_send_packets(device_id_t device_id, packet_t *packet)
-{
-        packet_t *next;
+void tcp_send_packets(device_id_t device_id, packet_t packet)
+{
+        packet_t next;
 
         while (packet) {
@@ -2012 +1976 @@
 }
 
-void tcp_prepare_operation_header(socket_core_t *socket,
-    tcp_socket_data_t *socket_data, tcp_header_t *header, int synchronize,
+void
+tcp_prepare_operation_header(socket_core_ref socket,
+    tcp_socket_data_ref socket_data, tcp_header_ref header, int synchronize,
     int finalize)
 {
@@ -2029 +1994 @@
 }
 
-int tcp_prepare_timeout(int (*timeout_function)(void *tcp_timeout_t),
-    socket_core_t *socket, tcp_socket_data_t *socket_data,
+int
+tcp_prepare_timeout(int (*timeout_function)(void *tcp_timeout_t),
+    socket_core_ref socket, tcp_socket_data_ref socket_data,
     size_t sequence_number, tcp_socket_state_t state, suseconds_t timeout,
     int globals_read_only)
 {
-        tcp_timeout_t *operation_timeout;
+        tcp_timeout_ref operation_timeout;
         fid_t fibril;
 
@@ -2041 +2007 @@
         assert(socket->specific_data == socket_data);
 
-        /* Prepare the timeout with key bundle structure */
+        // prepare the timeout with key bundle structure
         operation_timeout = malloc(sizeof(*operation_timeout) +
             socket->key_length + 1);
@@ -2056 +2022 @@
         operation_timeout->state = state;
 
-        /* Copy the key */
-        operation_timeout->key = ((uint8_t *) operation_timeout) +
+        // copy the key
+        operation_timeout->key = ((char *) operation_timeout) +
             sizeof(*operation_timeout);
         operation_timeout->key_length = socket->key_length;
@@ -2063 +2029 @@
         operation_timeout->key[operation_timeout->key_length] = '\0';
 
-        /* Prepare the timeouting thread */
+        // prepare the timeouting thread
         fibril = fibril_create(timeout_function, operation_timeout);
         if (!fibril) {
                 free(operation_timeout);
-                return ENOMEM;
-        }
-
+                return EPARTY;  /* FIXME: use another EC */
+        }
 //      fibril_mutex_lock(&socket_data->operation.mutex);
-        /* Start the timeout fibril */
+        // start the timeouting fibril
         fibril_add_ready(fibril);
         //socket_data->state = state;
@@ -2077 +2042 @@
 }
 
-int tcp_recvfrom_message(socket_cores_t *local_sockets, int socket_id,
-    int flags, size_t *addrlen)
-{
-        socket_core_t *socket;
-        tcp_socket_data_t *socket_data;
+int
+tcp_recvfrom_message(socket_cores_ref local_sockets, int socket_id, int flags,
+    size_t * addrlen)
+{
+        ERROR_DECLARE;
+
+        socket_core_ref socket;
+        tcp_socket_data_ref socket_data;
         int packet_id;
-        packet_t *packet;
+        packet_t packet;
         size_t length;
-        int rc;
 
         assert(local_sockets);
 
-        /* Find the socket */
+        // find the socket
         socket = socket_cores_find(local_sockets, socket_id);
         if (!socket)
                 return ENOTSOCK;
 
-        /* Get the socket specific data */
+        // get the socket specific data
         if (!socket->specific_data)
                 return NO_DATA;
 
-        socket_data = (tcp_socket_data_t *) socket->specific_data;
-
-        /* Check state */
+        socket_data = (tcp_socket_data_ref) socket->specific_data;
+
+        // check state
         if ((socket_data->state != TCP_SOCKET_ESTABLISHED) &&
             (socket_data->state != TCP_SOCKET_CLOSE_WAIT))
                 return ENOTCONN;
 
-        /* Send the source address if desired */
+        // send the source address if desired
         if (addrlen) {
-                rc = data_reply(socket_data->addr, socket_data->addrlen);
-                if (rc != EOK)
-                        return rc;
+                ERROR_PROPAGATE(data_reply(socket_data->addr,
+                    socket_data->addrlen));
                 *addrlen = socket_data->addrlen;
         }
 
-        /* Get the next received packet */
+        // get the next received packet
         packet_id = dyn_fifo_value(&socket->received);
         if (packet_id < 0)
                 return NO_DATA;
 
-        rc = packet_translate_remote(tcp_globals.net_phone, &packet, packet_id);
-        if (rc != EOK)
-                return rc;
-
-        /* Reply the packets */
-        rc = socket_reply_packets(packet, &length);
-        if (rc != EOK)
-                return rc;
-
-        /* Release the packet */
+        ERROR_PROPAGATE(packet_translate_remote(tcp_globals.net_phone, &packet,
+            packet_id));
+
+        // reply the packets
+        ERROR_PROPAGATE(socket_reply_packets(packet, &length));
+
+        // release the packet
         dyn_fifo_pop(&socket->received);
         pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
-
-        /* Return the total length */
+        // return the total length
         return (int) length;
 }
 
-int tcp_send_message(socket_cores_t *local_sockets, int socket_id,
-    int fragments, size_t *data_fragment_size, int flags)
-{
-        socket_core_t *socket;
-        tcp_socket_data_t *socket_data;
-        packet_dimension_t *packet_dimension;
-        packet_t *packet;
+int
+tcp_send_message(socket_cores_ref local_sockets, int socket_id, int fragments,
+    size_t * data_fragment_size, int flags)
+{
+        ERROR_DECLARE;
+
+        socket_core_ref socket;
+        tcp_socket_data_ref socket_data;
+        packet_dimension_ref packet_dimension;
+        packet_t packet;
         size_t total_length;
-        tcp_header_t *header;
+        tcp_header_ref header;
         int index;
         int result;
-        int rc;
 
         assert(local_sockets);
         assert(data_fragment_size);
 
-        /* Find the socket */
+        // find the socket
         socket = socket_cores_find(local_sockets, socket_id);
         if (!socket)
                 return ENOTSOCK;
 
-        /* Get the socket specific data */
+        // get the socket specific data
         if (!socket->specific_data)
                 return NO_DATA;
 
-        socket_data = (tcp_socket_data_t *) socket->specific_data;
-
-        /* Check state */
+        socket_data = (tcp_socket_data_ref) socket->specific_data;
+
+        // check state
         if ((socket_data->state != TCP_SOCKET_ESTABLISHED) &&
             (socket_data->state != TCP_SOCKET_CLOSE_WAIT))
                 return ENOTCONN;
 
-        rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
-            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
-        if (rc != EOK)
-                return rc;
+        ERROR_PROPAGATE(tl_get_ip_packet_dimension(tcp_globals.ip_phone,
+           &tcp_globals.dimensions, socket_data->device_id, &packet_dimension));
 
         *data_fragment_size =
@@ -2176 +2138 @@
             packet_dimension->content : socket_data->data_fragment_size);
 
-        for (index = 0; index < fragments; index++) {
-                /* Read the data fragment */
+        for (index = 0; index < fragments; ++index) {
+                // read the data fragment
                 result = tl_socket_read_packet_data(tcp_globals.net_phone,
                     &packet, TCP_HEADER_SIZE, packet_dimension,
@@ -2185 +2147 @@
 
                 total_length = (size_t) result;
-
-                /* Prefix the TCP header */
+                // prefix the tcp header
                 header = PACKET_PREFIX(packet, tcp_header_t);
                 if (!header)
@@ -2192 +2153 @@
 
                 tcp_prepare_operation_header(socket, socket_data, header, 0, 0);
-                rc = tcp_queue_packet(socket, socket_data, packet, total_length);
-                if (rc != EOK)
-                        return rc;
-        }
-
-        /* Flush packets */
+                ERROR_PROPAGATE(tcp_queue_packet(socket, socket_data, packet,
+                    0));
+        }
+
+        // flush packets
         packet = tcp_get_packets_to_send(socket, socket_data);
         fibril_rwlock_write_unlock(socket_data->local_lock);
@@ -2203 +2163 @@
 
         if (packet) {
-                /* Send the packet */
+                // send the packet
                 tcp_send_packets(socket_data->device_id, packet);
         }
@@ -2211 +2171 @@
 
 int
-tcp_close_message(socket_cores_t *local_sockets, int socket_id)
-{
-        socket_core_t *socket;
-        tcp_socket_data_t *socket_data;
-        packet_t *packet;
-        int rc;
-
-        /* Find the socket */
+tcp_close_message(socket_cores_ref local_sockets, int socket_id)
+{
+        ERROR_DECLARE;
+
+        socket_core_ref socket;
+        tcp_socket_data_ref socket_data;
+        packet_t packet;
+
+        // find the socket
         socket = socket_cores_find(local_sockets, socket_id);
         if (!socket)
                 return ENOTSOCK;
 
-        /* Get the socket specific data */
-        socket_data = (tcp_socket_data_t *) socket->specific_data;
+        // get the socket specific data
+        socket_data = (tcp_socket_data_ref) socket->specific_data;
         assert(socket_data);
 
-        /* Check state */
+        // check state
         switch (socket_data->state) {
         case TCP_SOCKET_ESTABLISHED:
@@ -2240 +2201 @@
 
         default:
-                /* Just destroy */
-                rc = socket_destroy(tcp_globals.net_phone, socket_id,
+                // just destroy
+                if (ERROR_NONE(socket_destroy(tcp_globals.net_phone, socket_id,
                     local_sockets, &tcp_globals.sockets,
-                    tcp_free_socket_data);
-                if (rc == EOK) {
+                    tcp_free_socket_data))) {
                         fibril_rwlock_write_unlock(socket_data->local_lock);
                         fibril_rwlock_write_unlock(&tcp_globals.lock);
                 }
-                return rc;
-        }
-
-        /*
-         * Send FIN.
-         * TODO should I wait to complete?
-         */
-
-        /* Create the notification packet */
-        rc = tcp_create_notification_packet(&packet, socket, socket_data, 0, 1);
-        if (rc != EOK)
-                return rc;
-
-        /* Send the packet */
-        rc = tcp_queue_packet(socket, socket_data, packet, 1);
-        if (rc != EOK)
-                return rc;
-
-        /* Flush packets */
+                return ERROR_CODE;
+        }
+
+        // send FIN
+        // TODO should I wait to complete?
+
+        // create the notification packet
+        ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket,
+            socket_data, 0, 1));
+
+        // send the packet
+        ERROR_PROPAGATE(tcp_queue_packet(socket, socket_data, packet, 1));
+
+        // flush packets
         packet = tcp_get_packets_to_send(socket, socket_data);
         fibril_rwlock_write_unlock(socket_data->local_lock);
@@ -2272 +2227 @@
 
         if (packet) {
-                /* Send the packet */
+                // send the packet
                 tcp_send_packets(socket_data->device_id, packet);
         }
@@ -2279 +2234 @@
 }
 
-int tcp_create_notification_packet(packet_t **packet, socket_core_t *socket,
-    tcp_socket_data_t *socket_data, int synchronize, int finalize)
-{
-        packet_dimension_t *packet_dimension;
-        tcp_header_t *header;
-        int rc;
+int
+tcp_create_notification_packet(packet_t * packet, socket_core_ref socket,
+    tcp_socket_data_ref socket_data, int synchronize, int finalize)
+{
+        ERROR_DECLARE;
+
+        packet_dimension_ref packet_dimension;
+        tcp_header_ref header;
 
         assert(packet);
 
-        /* Get the device packet dimension */
-        rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
-            &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
-        if (rc != EOK)
-                return rc;
-
-        /* Get a new packet */
+        // get the device packet dimension
+        ERROR_PROPAGATE(tl_get_ip_packet_dimension(tcp_globals.ip_phone,
+            &tcp_globals.dimensions, socket_data->device_id,
+            &packet_dimension));
+
+        // get a new packet
         *packet = packet_get_4_remote(tcp_globals.net_phone, TCP_HEADER_SIZE,
             packet_dimension->addr_len, packet_dimension->prefix,
@@ -2302 +2258 @@
                 return ENOMEM;
 
-        /* Allocate space in the packet */
+        // allocate space in the packet
         header = PACKET_SUFFIX(*packet, tcp_header_t);
         if (!header)
@@ -2313 +2269 @@
 }
 
-int tcp_accept_message(socket_cores_t *local_sockets, int socket_id,
-    int new_socket_id, size_t *data_fragment_size, size_t *addrlen)
-{
-        socket_core_t *accepted;
-        socket_core_t *socket;
-        tcp_socket_data_t *socket_data;
-        packet_dimension_t *packet_dimension;
-        int rc;
+int
+tcp_accept_message(socket_cores_ref local_sockets, int socket_id,
+    int new_socket_id, size_t * data_fragment_size, size_t * addrlen)
+{
+        ERROR_DECLARE;
+
+        socket_core_ref accepted;
+        socket_core_ref socket;
+        tcp_socket_data_ref socket_data;
+        packet_dimension_ref packet_dimension;
 
         assert(local_sockets);
@@ -2326 +2284 @@
         assert(addrlen);
 
-        /* Find the socket */
+        // find the socket
         socket = socket_cores_find(local_sockets, socket_id);
         if (!socket)
                 return ENOTSOCK;
 
-        /* Get the socket specific data */
-        socket_data = (tcp_socket_data_t *) socket->specific_data;
+        // get the socket specific data
+        socket_data = (tcp_socket_data_ref) socket->specific_data;
         assert(socket_data);
 
-        /* Check state */
+        // check state
         if (socket_data->state != TCP_SOCKET_LISTEN)
                 return EINVAL;
@@ -2349 +2307 @@
                         return ENOTSOCK;
 
-                /* Get the socket specific data */
-                socket_data = (tcp_socket_data_t *) accepted->specific_data;
+                // get the socket specific data
+                socket_data = (tcp_socket_data_ref) accepted->specific_data;
                 assert(socket_data);
-                /* TODO can it be in another state? */
+                // TODO can it be in another state?
                 if (socket_data->state == TCP_SOCKET_ESTABLISHED) {
-                        rc = data_reply(socket_data->addr,
-                            socket_data->addrlen);
-                        if (rc != EOK)
-                                return rc;
-                        rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
-                            &tcp_globals.dimensions, socket_data->device_id,
-                            &packet_dimension);
-                        if (rc != EOK)
-                                return rc;
+                        ERROR_PROPAGATE(data_reply(socket_data->addr,
+                            socket_data->addrlen));
+                        ERROR_PROPAGATE(tl_get_ip_packet_dimension(
+                            tcp_globals.ip_phone, &tcp_globals.dimensions,
+                            socket_data->device_id, &packet_dimension));
                         *addrlen = socket_data->addrlen;
 
@@ -2372 +2326 @@
         
                         if (new_socket_id > 0) {
-                                rc = socket_cores_update(local_sockets,
-                                    accepted->socket_id, new_socket_id);
-                                if (rc != EOK)
-                                        return rc;
+                                ERROR_PROPAGATE(socket_cores_update(
+                                    local_sockets, accepted->socket_id,
+                                    new_socket_id));
                                 accepted->socket_id = new_socket_id;
                         }
@@ -2386 +2339 @@
 }
 
-void tcp_free_socket_data(socket_core_t *socket)
-{
-        tcp_socket_data_t *socket_data;
+void
+tcp_free_socket_data(socket_core_ref socket)
+{
+        tcp_socket_data_ref socket_data;
 
         assert(socket);
@@ -2394 +2348 @@
         printf("destroy_socket %d\n", socket->socket_id);
 
-        /* Get the socket specific data */
-        socket_data = (tcp_socket_data_t *) socket->specific_data;
+        // get the socket specific data
+        socket_data = (tcp_socket_data_ref) socket->specific_data;
         assert(socket_data);
-
-        /* Free the pseudo header */
+        //free the pseudo header
         if (socket_data->pseudo_header) {
                 if (socket_data->headerlen) {
@@ -2407 +2360 @@
                 socket_data->pseudo_header = NULL;
         }
-
         socket_data->headerlen = 0;
-
-        /* Free the address */
+        // free the address
         if (socket_data->addr) {
                 if (socket_data->addrlen) {
@@ -2422 +2373 @@
 }
 
-/** 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.
- */
-int tcp_release_and_return(packet_t *packet, int result)
+int tcp_release_and_return(packet_t packet, int result)
 {
         pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
@@ -2434 +2379 @@
 }
 
-/** Process IPC messages from the IP module
+/** Default thread for new connections.
  *
- * @param[in]     iid   Message identifier.
- * @param[in,out] icall Message parameters.
+ *  @param[in] iid The initial message identifier.
+ *  @param[in] icall The initial message call structure.
  *
  */
-static void tcp_receiver(ipc_callid_t iid, ipc_call_t *icall)
-{
-        packet_t *packet;
-        int rc;
-        
+static void tl_client_connection(ipc_callid_t iid, ipc_call_t * icall)
+{
+        /*
+         * Accept the connection
+         *  - Answer the first IPC_M_CONNECT_ME_TO call.
+         */
+        ipc_answer_0(iid, EOK);
+
         while (true) {
-                switch (IPC_GET_IMETHOD(*icall)) {
-                case NET_TL_RECEIVED:
-                        rc = packet_translate_remote(tcp_globals.net_phone, &packet,
-                            IPC_GET_PACKET(*icall));
-                        if (rc == EOK)
-                                rc = tcp_received_msg(IPC_GET_DEVICE(*icall), packet,
-                                    SERVICE_TCP, IPC_GET_ERROR(*icall));
-                        
-                        async_answer_0(iid, (sysarg_t) rc);
-                        break;
-                default:
-                        async_answer_0(iid, (sysarg_t) ENOTSUP);
-                }
-                
-                iid = async_get_call(icall);
-        }
-}
-
-/** Initialize the TCP module.
+                ipc_call_t answer;
+                int answer_count;
+
+                /*
+                   Clear the answer structure 
+                 */
+                refresh_answer(&answer, &answer_count);
+
+                /*
+                   Fetch the next message 
+                 */
+                ipc_call_t call;
+                ipc_callid_t callid = async_get_call(&call);
+
+                /*
+                   Process the message 
+                 */
+                int res = tl_module_message_standalone(callid, &call, &answer,
+                    &answer_count);
+
+                /*
+                   End if said to either by the message or the processing result 
+                 */
+                if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
+                    (res == EHANGUP))
+                        return;
+
+                /*
+                   Answer the message 
+                 */
+                answer_call(callid, res, &answer, answer_count);
+        }
+}
+
+/** Starts the module.
  *
- * @param[in] net_phone Network module phone.
+ *  @param argc The count of the command line arguments. Ignored parameter.
+ *  @param argv The command line parameters. Ignored parameter.
  *
- * @return EOK on success.
- * @return ENOMEM if there is not enough memory left.
+ *  @returns EOK on success.
+ *  @returns Other error codes as defined for each specific module start function.
  *
  */
-int tl_initialize(int net_phone)
-{
-        fibril_rwlock_initialize(&tcp_globals.lock);
-        fibril_rwlock_write_lock(&tcp_globals.lock);
-        
-        tcp_globals.net_phone = net_phone;
-        
-        tcp_globals.icmp_phone = icmp_connect_module(ICMP_CONNECT_TIMEOUT);
-        tcp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_TCP,
-            SERVICE_TCP, tcp_receiver);
-        if (tcp_globals.ip_phone < 0) {
-                fibril_rwlock_write_unlock(&tcp_globals.lock);
-                return tcp_globals.ip_phone;
-        }
-        
-        int rc = socket_ports_initialize(&tcp_globals.sockets);
-        if (rc != EOK)
-                goto out;
-
-        rc = packet_dimensions_initialize(&tcp_globals.dimensions);
-        if (rc != EOK) {
-                socket_ports_destroy(&tcp_globals.sockets, free);
-                goto out;
-        }
-
-        tcp_globals.last_used_port = TCP_FREE_PORTS_START - 1;
-
-out:
-        fibril_rwlock_write_unlock(&tcp_globals.lock);
-        return rc;
-}
-
-int main(int argc, char *argv[])
-{
-        return tl_module_start(SERVICE_TCP);
+int
+main(int argc, char *argv[])
+{
+        ERROR_DECLARE;
+
+        /*
+           Start the module 
+         */
+        if (ERROR_OCCURRED(tl_module_start_standalone(tl_client_connection)))
+                return ERROR_CODE;
+
+        return EOK;
 }