Changes in uspace/srv/net/tl/tcp/tcp.c [472020fc:28a3e74] 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>
@@ -65 +63 @@
 #include <ip_interface.h>
 #include <icmp_client.h>
-#include <icmp_interface.h>
+#include <icmp_remote.h>
 #include <net_interface.h>
 #include <socket_core.h>
 #include <tl_common.h>
-#include <tl_local.h>
-#include <tl_interface.h>
+#include <tl_remote.h>
+#include <tl_skel.h>
 
 #include "tcp.h"
 #include "tcp_header.h"
-#include "tcp_module.h"
 
 /** TCP module name. */
-#define NAME    "TCP protocol"
+#define NAME  "tcp"
 
 /** The TCP window default value. */
@@ -110 +107 @@
 
 /** 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) \
@@ -126 +124 @@
  */
 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.
@@ -144 +137 @@
 
         /** Local sockets. */
-        socket_cores_ref local_sockets;
+        socket_cores_t *local_sockets;
 
         /** Socket identifier. */
@@ -159 +152 @@
 
         /** Port map key. */
-        char *key;
+        uint8_t *key;
 
         /** Port map key length. */
@@ -165 +158 @@
 };
 
-/** 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);
+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);
 
 /** TCP global data. */
 tcp_globals_t tcp_globals;
 
-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;
+int tcp_received_msg(device_id_t device_id, packet_t *packet,
+    services_t receiver, services_t error)
+{
+        int rc;
 
         if (receiver != SERVICE_TCP)
@@ -286 +228 @@
 
         fibril_rwlock_write_lock(&tcp_globals.lock);
-        if (ERROR_OCCURRED(tcp_process_packet(device_id, packet, error)))
+        rc = tcp_process_packet(device_id, packet, error);
+        if (rc != EOK)
                 fibril_rwlock_write_unlock(&tcp_globals.lock);
 
-        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;
-
+        printf("receive %d \n", rc);
+
+        return rc;
+}
+
+int tcp_process_packet(device_id_t device_id, packet_t *packet, services_t error)
+{
         size_t length;
         size_t offset;
         int result;
-        tcp_header_ref header;
-        socket_core_ref socket;
-        tcp_socket_data_ref socket_data;
-        packet_t next_packet;
+        tcp_header_t *header;
+        socket_core_t *socket;
+        tcp_socket_data_t *socket_data;
+        packet_t *next_packet;
         size_t total_length;
         uint32_t checksum;
@@ -313 +254 @@
         struct sockaddr *dest;
         size_t addrlen;
-
-        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?
+        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? */
         result = ip_client_process_packet(packet, NULL, NULL, NULL, NULL, NULL);
         if (result < 0)
@@ -349 +289 @@
                 return tcp_release_and_return(packet, NO_DATA);
 
-        // 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);
+        /* 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);
         if (!header)
                 return tcp_release_and_return(packet, NO_DATA);
 
-//      printf("header len %d, port %d \n", TCP_HEADER_LENGTH(header),
-//          ntohs(header->destination_port));
-
+#if 0
+        printf("header len %d, port %d \n", TCP_HEADER_LENGTH(header),
+            ntohs(header->destination_port));
+#endif
         result = packet_get_addr(packet, (uint8_t **) &src, (uint8_t **) &dest);
         if (result <= 0)
@@ -367 +309 @@
         addrlen = (size_t) result;
 
-        if (ERROR_OCCURRED(tl_set_address_port(src, addrlen,
-            ntohs(header->source_port)))) 
-                return tcp_release_and_return(packet, ERROR_CODE);
+        rc = tl_set_address_port(src, addrlen, ntohs(header->source_port));
+        if (rc != EOK)
+                return tcp_release_and_return(packet, rc);
         
-        // find the destination socket
+        /* Find the destination socket */
         socket = socket_port_find(&tcp_globals.sockets,
-            ntohs(header->destination_port), (const char *) src, addrlen);
+            ntohs(header->destination_port), (uint8_t *) 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), 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),
+                    (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;
+        }
+
         printf("socket id %d\n", socket->socket_id);
-        socket_data = (tcp_socket_data_ref) socket->specific_data;
+        socket_data = (tcp_socket_data_t *) 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;
@@ -402 +345 @@
         total_length = 0;
         do {
-                ++fragments;
+                fragments++;
                 length = packet_get_data_length(next_packet);
                 if (length <= 0)
@@ -409 +352 @@
                 total_length += length;
 
-                // add partial checksum if set
+                /* Add partial checksum if set */
                 if (!error) {
                         checksum = compute_checksum(checksum,
@@ -421 +364 @@
 
         if (error)
-                goto error;
+                goto has_error_service;
         
         if (socket_data->state == TCP_SOCKET_LISTEN) {
-
                 if (socket_data->pseudo_header) {
                         free(socket_data->pseudo_header);
@@ -431 +373 @@
                 }
 
-                if (ERROR_OCCURRED(ip_client_get_pseudo_header(IPPROTO_TCP, src,
-                    addrlen, dest, addrlen, total_length,
-                    &socket_data->pseudo_header, &socket_data->headerlen))) {
+                rc = ip_client_get_pseudo_header(IPPROTO_TCP, src, addrlen,
+                    dest, addrlen, total_length, &socket_data->pseudo_header,
+                    &socket_data->headerlen);
+                if (rc != EOK) {
                         fibril_rwlock_write_unlock(socket_data->local_lock);
-                        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);
+                        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);
+                }
         }
         
@@ -452 +397 @@
                 fibril_rwlock_write_unlock(socket_data->local_lock);
 
-                if (ERROR_NONE(tl_prepare_icmp_packet(tcp_globals.net_phone,
-                    tcp_globals.icmp_phone, packet, error))) {
-                        // checksum error ICMP
+                rc = tl_prepare_icmp_packet(tcp_globals.net_phone,
+                    tcp_globals.icmp_phone, packet, error);
+                if (rc == EOK) {
+                        /* Checksum error ICMP */
                         icmp_parameter_problem_msg(tcp_globals.icmp_phone,
                             ICMP_PARAM_POINTER,
@@ -464 +410 @@
         }
 
-error:
-        fibril_rwlock_read_unlock(&tcp_globals.lock);
-
-        // TODO error reporting/handling
+has_error_service:
+        fibril_rwlock_write_unlock(&tcp_globals.lock);
+
+        /* TODO error reporting/handling */
         switch (socket_data->state) {
         case TCP_SOCKET_LISTEN:
-                ERROR_CODE = tcp_process_listen(socket, socket_data, header,
-                    packet, src, dest, addrlen);
+                rc = tcp_process_listen(socket, socket_data, header, packet,
+                    src, dest, addrlen);
                 break;
         case TCP_SOCKET_SYN_RECEIVED:
-                ERROR_CODE = tcp_process_syn_received(socket, socket_data,
-                    header, packet);
+                rc = 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);
+                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:
-                ERROR_CODE = tcp_process_established(socket, socket_data,
-                    header, packet, fragments, total_length);
+                rc = tcp_process_established(socket, socket_data, header,
+                    packet, fragments, total_length);
                 break;
         default:
@@ -497 +442 @@
         }
 
-        if (ERROR_CODE != EOK) {
-                printf("process %d\n", ERROR_CODE);
+        if (rc != EOK) {
                 fibril_rwlock_write_unlock(socket_data->local_lock);
+                printf("process %d\n", rc);
         }
 
@@ -505 +450 @@
 }
 
-int
-tcp_process_established(socket_core_ref socket, tcp_socket_data_ref socket_data,
-    tcp_header_ref header, packet_t packet, int fragments,
+int tcp_process_established(socket_core_t *socket, tcp_socket_data_t *
+    socket_data, tcp_header_t *header, packet_t *packet, int fragments,
     size_t total_length)
 {
-        ERROR_DECLARE;
-
-        packet_t next_packet;
-        packet_t tmp_packet;
+        packet_t *next_packet;
+        packet_t *tmp_packet;
         uint32_t old_incoming;
         size_t order;
@@ -520 +462 @@
         size_t offset;
         uint32_t new_sequence_number;
+        bool forced_ack;
+        int rc;
 
         assert(socket);
@@ -527 +471 @@
         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;
-
-        // trim begining if containing expected data
+        if (header->finalize) {
+                socket_data->fin_incoming = new_sequence_number +
+                    total_length - TCP_HEADER_LENGTH(header);
+        }
+
+        /* 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 -
@@ -549 +497 @@
                 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,
@@ -560 +509 @@
                 }
 
-                if ((offset > 0) && (ERROR_OCCURRED(packet_trim(packet,
-                    offset, 0))))
-                        return tcp_release_and_return(packet, ERROR_CODE);
+                if (offset > 0) {
+                        rc = packet_trim(packet, offset, 0);
+                        if (rc != EOK)
+                                return tcp_release_and_return(packet, rc);
+                }
 
                 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 +
@@ -594 +545 @@
                         if (length <= offset)
                                 next_packet = pq_next(next_packet);
-                        else if (ERROR_OCCURRED(packet_trim(next_packet, 0,
-                            length - offset)))
-                                return tcp_release_and_return(packet,
-                                    ERROR_CODE);
+                        else {
+                                rc = packet_trim(next_packet, 0,
+                                    length - offset));
+                                if (rc != EOK)
+                                        return tcp_release_and_return(packet,
+                                            rc);
+                        }
                         offset -= length;
                         total_length -= length - offset;
@@ -614 +568 @@
         }
 */
-        // 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);
-                if (ERROR_OCCURRED(packet_trim(packet,
-                    TCP_HEADER_LENGTH(header), 0)))
-                        return tcp_release_and_return(packet, ERROR_CODE);
+                rc = packet_trim(packet, TCP_HEADER_LENGTH(header), 0);
+                if (rc != EOK)
+                        return tcp_release_and_return(packet, rc);
 
                 if (total_length) {
-                        ERROR_PROPAGATE(tcp_queue_received_packet(socket,
-                            socket_data, packet, fragments, total_length));
+                        rc = tcp_queue_received_packet(socket, socket_data,
+                            packet, fragments, total_length);
+                        if (rc != EOK)
+                                return rc;
                 } else {
                         total_length = 1;
@@ -636 +592 @@
                 packet = socket_data->incoming;
                 while (packet) {
-
-                        if (ERROR_OCCURRED(pq_get_order(socket_data->incoming,
-                            &order, NULL))) {
-                                // remove the corrupted packet
+                        rc = pq_get_order(socket_data->incoming, &order, NULL);
+                        if (rc != EOK) {
+                                /* Remove the corrupted packet */
                                 next_packet = pq_detach(packet);
                                 if (packet == socket_data->incoming)
@@ -652 +607 @@
                         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));
@@ -671 +626 @@
                                         continue;
                                 }
-                                // exactly following
+                                /* Exactly following */
                                 if (sequence_number ==
                                     socket_data->next_incoming) {
-                                        // queue received data
-                                        ERROR_PROPAGATE(
-                                            tcp_queue_received_packet(socket,
+                                        /* Queue received data */
+                                        rc = tcp_queue_received_packet(socket,
                                             socket_data, packet, 1,
-                                            packet_get_data_length(packet)));
+                                            packet_get_data_length(packet));
+                                        if (rc != EOK)
+                                                return rc;
                                         socket_data->next_incoming =
                                             new_sequence_number;
                                         packet = next_packet;
                                         continue;
-                                        // at least partly following data?
-                                } else if (IS_IN_INTERVAL_OVERFLOW(
-                                    sequence_number, socket_data->next_incoming,
-                                    new_sequence_number)) {
+                                        /* At least partly following data? */
+                                }
+                                if (IS_IN_INTERVAL_OVERFLOW(sequence_number,
+                                    socket_data->next_incoming, new_sequence_number)) {
                                         if (socket_data->next_incoming <
                                             new_sequence_number) {
@@ -696 +652 @@
                                                     new_sequence_number;
                                         }
-                                        if (ERROR_NONE(packet_trim(packet,
-                                            length, 0))) {
-                                                // queue received data
-                                                ERROR_PROPAGATE(
-                                                    tcp_queue_received_packet(
+                                        rc = packet_trim(packet,length, 0);
+                                        if (rc == EOK) {
+                                                /* Queue received data */
+                                                rc = tcp_queue_received_packet(
                                                     socket, socket_data, packet,
                                                     1, packet_get_data_length(
-                                                    packet)));
+                                                    packet));
+                                                if (rc != EOK)
+                                                        return rc;
                                                 socket_data->next_incoming =
                                                     new_sequence_number;
@@ -710 +667 @@
                                         }
                                 }
-                                // remove the duplicit or corrupted packet
+                                /* Remove the duplicit or corrupted packet */
                                 pq_release_remote(tcp_globals.net_phone,
                                     packet_get_id(packet));
@@ -723 +680 @@
             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);
-                if (ERROR_OCCURRED(packet_trim(packet,
-                    TCP_HEADER_LENGTH(header), 0)))
-                        return tcp_release_and_return(packet, ERROR_CODE);
+                rc = packet_trim(packet, TCP_HEADER_LENGTH(header), 0);
+                if (rc != EOK)
+                        return tcp_release_and_return(packet, rc);
 
                 next_packet = pq_detach(packet);
                 length = packet_get_data_length(packet);
-                if (ERROR_OCCURRED(pq_add(&socket_data->incoming, packet,
-                    new_sequence_number, length))) {
-                        // remove the corrupted packets
+                rc = pq_add(&socket_data->incoming, packet, new_sequence_number,
+                    length);
+                if (rc != EOK) {
+                        /* Remove the corrupted packets */
                         pq_release_remote(tcp_globals.net_phone,
                             packet_get_id(packet));
@@ -746 +704 @@
                                 tmp_packet = pq_detach(next_packet);
                                 length = packet_get_data_length(next_packet);
-                                if (ERROR_OCCURRED(pq_set_order(next_packet,
-                                    new_sequence_number, length)) ||
-                                    ERROR_OCCURRED(pq_insert_after(packet,
-                                    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) {
                                         pq_release_remote(tcp_globals.net_phone,
                                             packet_get_id(next_packet));
@@ -758 +721 @@
         } else {
                 printf("unexpected\n");
-                // release duplicite or restricted
+                /* Release duplicite or restricted */
                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
-        }
-
-        // change state according to the acknowledging incoming fin
-        if (IS_IN_INTERVAL_OVERFLOW(old_incoming, socket_data->fin_incoming,
-            socket_data->next_incoming)) {
+                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 */
                 switch (socket_data->state) {
                 case TCP_SOCKET_FIN_WAIT_1:
@@ -771 +738 @@
                         socket_data->state = TCP_SOCKET_CLOSING;
                         break;
-                        //case TCP_ESTABLISHED:
+                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;
                 default:
                         socket_data->state = TCP_SOCKET_CLOSE_WAIT;
@@ -779 +750 @@
 
         packet = tcp_get_packets_to_send(socket, socket_data);
-        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));
+        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;
                 packet = tcp_send_prepare_packet(socket, socket_data, packet, 1,
                     socket_data->last_outgoing + 1);
@@ -791 +765 @@
         fibril_rwlock_write_unlock(socket_data->local_lock);
 
-        // send the packet
+        /* Send the packet */
         tcp_send_packets(socket_data->device_id, packet);
 
@@ -797 +771 @@
 }
 
-int
-tcp_queue_received_packet(socket_core_ref socket,
-    tcp_socket_data_ref socket_data, packet_t packet, int fragments,
+int tcp_queue_received_packet(socket_core_t *socket,
+    tcp_socket_data_t *socket_data, packet_t *packet, int fragments,
     size_t total_length)
 {
-        ERROR_DECLARE;
-
-        packet_dimension_ref packet_dimension;
+        packet_dimension_t *packet_dimension;
+        int rc;
 
         assert(socket);
@@ -813 +785 @@
         assert(socket_data->window > total_length);
 
-        // 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
+        /* 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 */
         socket_data->window -= total_length;
 
-        // notify the destination socket
+        /* Notify the destination socket */
         async_msg_5(socket->phone, NET_SOCKET_RECEIVED,
-            (ipcarg_t) socket->socket_id,
+            (sysarg_t) socket->socket_id,
             ((packet_dimension->content < socket_data->data_fragment_size) ?
             packet_dimension->content : socket_data->data_fragment_size), 0, 0,
-            (ipcarg_t) fragments);
+            (sysarg_t) fragments);
 
         return EOK;
 }
 
-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;
+/** 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;
 
         assert(socket);
@@ -852 +841 @@
                 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) {
@@ -862 +852 @@
                     packet_get_id(next_packet));
         }
-        // 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);
-        }
+
+        /* 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);
+        }
+
         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;
@@ -877 +871 @@
                 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);
@@ -885 +879 @@
                 }
         }
+
         fibril_mutex_unlock(&socket_data->operation.mutex);
         return tcp_release_and_return(packet, EINVAL);
 }
 
-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,
+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,
     size_t addrlen)
 {
-        ERROR_DECLARE;
-
-        packet_t next_packet;
-        socket_core_ref socket;
-        tcp_socket_data_ref socket_data;
+        packet_t *next_packet;
+        socket_core_t *socket;
+        tcp_socket_data_t *socket_data;
         int socket_id;
         int listening_socket_id = listening_socket->socket_id;
         int listening_port = listening_socket->port;
+        int rc;
 
         assert(listening_socket);
@@ -913 +906 @@
                 return tcp_release_and_return(packet, EINVAL);
 
-        socket_data = (tcp_socket_data_ref) malloc(sizeof(*socket_data));
+        socket_data = (tcp_socket_data_t *) malloc(sizeof(*socket_data));
         if (!socket_data)
                 return tcp_release_and_return(packet, ENOMEM);
@@ -930 +923 @@
                 return tcp_release_and_return(packet, ENOMEM);
         }
+
         memcpy(socket_data->addr, src, socket_data->addrlen);
         socket_data->dest_port = ntohs(header->source_port);
-        if (ERROR_OCCURRED(tl_set_address_port(socket_data->addr,
-            socket_data->addrlen, socket_data->dest_port))) {
+        rc = tl_set_address_port(socket_data->addr, socket_data->addrlen,
+            socket_data->dest_port);
+        if (rc != EOK) {
                 free(socket_data->addr);
                 free(socket_data);
-                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
-                return ERROR_CODE;
-        }
-
-        // create a socket
+                return tcp_release_and_return(packet, rc);
+        }
+
+        /* Create a socket */
         socket_id = -1;
-        if (ERROR_OCCURRED(socket_create(socket_data->local_sockets,
-            listening_socket->phone, socket_data, &socket_id))) {
+        rc = socket_create(socket_data->local_sockets, listening_socket->phone,
+            socket_data, &socket_id);
+        if (rc != EOK) {
                 free(socket_data->addr);
                 free(socket_data);
-                return tcp_release_and_return(packet, ERROR_CODE);
+                return tcp_release_and_return(packet, rc);
         }
 
@@ -958 +953 @@
         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, SOCKET_MAP_KEY_LISTENING, 0);
-        if ((!listening_socket) ||
+            listening_port, (uint8_t *) 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_ref) listening_socket->specific_data;
+            (tcp_socket_data_t *) listening_socket->specific_data;
         assert(listening_socket_data);
 
@@ -976 +971 @@
             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_ref) socket->specific_data;
+        socket_data = (tcp_socket_data_t *) socket->specific_data;
         assert(socket_data);
 
-        ERROR_CODE = socket_port_add(&tcp_globals.sockets, listening_port,
-            socket, (const char *) socket_data->addr, socket_data->addrlen);
+        rc = socket_port_add(&tcp_globals.sockets, listening_port, socket,
+            (uint8_t *) socket_data->addr, socket_data->addrlen);
         assert(socket == socket_port_find(&tcp_globals.sockets, listening_port,
-            (const char *) socket_data->addr, socket_data->addrlen));
-
-//      ERROR_CODE = socket_bind_free_port(&tcp_globals.sockets, socket,
+            (uint8_t *) socket_data->addr, socket_data->addrlen));
+
+//      rc = 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 (ERROR_CODE != EOK) {
+        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, ERROR_CODE);
+                return tcp_release_and_return(packet, rc);
         }
 
@@ -1003 +998 @@
         socket_data->next_incoming = ntohl(header->sequence_number) + 1;
 
-        // release additional packets
+        /* Release additional packets */
         next_packet = pq_detach(packet);
         if (next_packet) {
@@ -1010 +1005 @@
         }
 
-        // 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)))) {
+        /* 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) {
                 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, 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;
+                return rc;
         }
 
@@ -1040 +1038 @@
         fibril_rwlock_write_unlock(socket_data->local_lock);
 
-        // send the packet
+        /* Send the packet */
         tcp_send_packets(socket_data->device_id, packet);
 
@@ -1046 +1044 @@
 }
 
-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;
+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;
 
         assert(socket);
@@ -1064 +1060 @@
                 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;
@@ -1074 +1070 @@
         if (listening_socket) {
                 listening_socket_data =
-                    (tcp_socket_data_ref) listening_socket->specific_data;
+                    (tcp_socket_data_t *) listening_socket->specific_data;
                 assert(listening_socket_data);
 
-                // 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
+                /* 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 */
                         async_msg_5(socket->phone, NET_SOCKET_ACCEPTED,
-                            (ipcarg_t) listening_socket->socket_id,
+                            (sysarg_t) listening_socket->socket_id,
                             socket_data->data_fragment_size, TCP_HEADER_SIZE,
-                            0, (ipcarg_t) socket->socket_id);
+                            0, (sysarg_t) socket->socket_id);
 
                         fibril_rwlock_write_unlock(socket_data->local_lock);
@@ -1092 +1087 @@
                 }
         }
-        // send FIN
+        /* Send FIN */
         socket_data->state = TCP_SOCKET_FIN_WAIT_1;
 
-        // 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
+        /* 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 */
         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);
         }
@@ -1113 +1111 @@
 }
 
-void
-tcp_process_acknowledgement(socket_core_ref socket,
-    tcp_socket_data_ref socket_data, tcp_header_ref header)
+void tcp_process_acknowledgement(socket_core_t *socket,
+    tcp_socket_data_t *socket_data, tcp_header_t *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;
 
@@ -1133 +1130 @@
 
         number = ntohl(header->acknowledgement_number);
-        // if more data acknowledged
+
+        /* If more data acknowledged */
         if (number != socket_data->expected) {
                 old = socket_data->expected;
@@ -1144 +1142 @@
                         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) {
@@ -1161 +1162 @@
                             socket_data->expected;
                 }
-                // set new expected sequence number
+
+                /* Set new expected sequence number */
                 socket_data->expected = number;
                 socket_data->expected_count = 1;
@@ -1173 +1175 @@
                                         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,
@@ -1181 +1183 @@
                                 break;
                 }
-                // release acknowledged
+
+                /* Release acknowledged */
                 if (acknowledged) {
                         pq_release_remote(tcp_globals.net_phone,
@@ -1187 +1190 @@
                 }
                 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);
                 }
@@ -1200 +1204 @@
 }
 
-int tcp_message_standalone(ipc_callid_t callid, ipc_call_t * call,
-    ipc_call_t * answer, int *answer_count)
-{
-        ERROR_DECLARE;
-
-        packet_t packet;
-
+/** 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)
+{
         assert(call);
         assert(answer);
@@ -1212 +1232 @@
 
         *answer_count = 0;
-        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;
-
+        switch (IPC_GET_IMETHOD(*call)) {
         case IPC_M_CONNECT_TO_ME:
                 return tcp_process_client_messages(callid, *call);
@@ -1230 +1240 @@
 }
 
-void tcp_refresh_socket_data(tcp_socket_data_ref socket_data)
+void tcp_refresh_socket_data(tcp_socket_data_t *socket_data)
 {
         assert(socket_data);
@@ -1246 +1256 @@
 }
 
-void tcp_initialize_socket_data(tcp_socket_data_ref socket_data)
+void tcp_initialize_socket_data(tcp_socket_data_t *socket_data)
 {
         assert(socket_data);
@@ -1261 +1271 @@
         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;
@@ -1268 +1278 @@
         fibril_rwlock_t lock;
         ipc_call_t answer;
-        int answer_count;
-        tcp_socket_data_ref socket_data;
-        socket_core_ref socket;
-        packet_dimension_ref packet_dimension;
+        size_t answer_count;
+        tcp_socket_data_t *socket_data;
+        socket_core_t *socket;
+        packet_dimension_t *packet_dimension;
 
         /*
@@ -1285 +1295 @@
         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_METHOD(call)) {
+                /* Process the call */
+                switch (IPC_GET_IMETHOD(call)) {
                 case IPC_M_PHONE_HUNGUP:
                         keep_on_going = false;
@@ -1301 +1311 @@
                 case NET_SOCKET:
                         socket_data =
-                            (tcp_socket_data_ref) malloc(sizeof(*socket_data));
+                            (tcp_socket_data_t *) malloc(sizeof(*socket_data));
                         if (!socket_data) {
                                 res = ENOMEM;
@@ -1335 +1345 @@
 
                 case NET_SOCKET_BIND:
-                        res = data_receive((void **) &addr, &addrlen);
+                        res = async_data_write_accept((void **) &addr, false,
+                            0, 0, 0, &addrlen);
                         if (res != EOK)
                                 break;
@@ -1348 +1359 @@
                                     SOCKET_GET_SOCKET_ID(call));
                                 if (socket) {
-                                        socket_data = (tcp_socket_data_ref)
+                                        socket_data = (tcp_socket_data_t *)
                                             socket->specific_data;
                                         assert(socket_data);
@@ -1372 +1383 @@
 
                 case NET_SOCKET_CONNECT:
-                        res = data_receive((void **) &addr, &addrlen);
+                        res = async_data_write_accept((void **) &addr, false,
+                            0, 0, 0, &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);
@@ -1421 +1435 @@
 
                 case NET_SOCKET_SENDTO:
-                        res = data_receive((void **) &addr, &addrlen);
+                        res = async_data_write_accept((void **) &addr, false,
+                            0, 0, 0, &addrlen);
                         if (res != EOK)
                                 break;
@@ -1490 +1505 @@
         }
 
-        // release the application phone
-        ipc_hangup(app_phone);
+        /* Release the application phone */
+        async_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);
@@ -1503 +1518 @@
 int tcp_timeout(void *data)
 {
-        tcp_timeout_ref timeout = data;
+        tcp_timeout_t *timeout = data;
         int keep_write_lock = false;
-        socket_core_ref socket;
-        tcp_socket_data_ref socket_data;
+        socket_core_t *socket;
+        tcp_socket_data_t *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);
@@ -1518 +1533 @@
                 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_ref) socket->specific_data;
+        socket_data = (tcp_socket_data_t *) socket->specific_data;
         assert(socket_data);
         if (socket_data->local_sockets != timeout->local_sockets)
@@ -1531 +1546 @@
         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);
@@ -1545 +1560 @@
         } 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 unlocki
-                        // order does not matter...
+                        /*
+                         * Operation is ok, do nothing.
+                         * Unlocking from now on, so the unlocking
+                         * order does not matter.
+                         */
                         fibril_rwlock_write_unlock(socket_data->local_lock);
                 }
@@ -1563 +1581 @@
 
 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;
@@ -1577 +1595 @@
 int tcp_release_after_timeout(void *data)
 {
-        tcp_timeout_ref timeout = data;
-        socket_core_ref socket;
-        tcp_socket_data_ref socket_data;
+        tcp_timeout_t *timeout = data;
+        socket_core_t *socket;
+        tcp_socket_data_t *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_ref) socket->specific_data;
+                socket_data = (tcp_socket_data_t *) socket->specific_data;
                 assert(socket_data);
                 if (socket_data->local_sockets == timeout->local_sockets) {
@@ -1603 +1624 @@
                 }
         }
-        // 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_ref socket, tcp_socket_data_ref socket_data,
-    size_t sequence_number)
-{
-        packet_t packet;
-        packet_t copy;
+void tcp_retransmit_packet(socket_core_t *socket, tcp_socket_data_t *
+    socket_data, size_t sequence_number)
+{
+        packet_t *packet;
+        packet_t *copy;
         size_t data_length;
 
@@ -1622 +1645 @@
         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));
@@ -1638 +1661 @@
 }
 
-int
-tcp_listen_message(socket_cores_ref local_sockets, int socket_id, int backlog)
-{
-        socket_core_ref socket;
-        tcp_socket_data_ref socket_data;
+int tcp_listen_message(socket_cores_t *local_sockets, int socket_id,
+    int backlog)
+{
+        socket_core_t *socket;
+        tcp_socket_data_t *socket_data;
 
         assert(local_sockets);
@@ -1649 +1672 @@
                 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_ref) socket->specific_data;
+        /* Get the socket specific data */
+        socket_data = (tcp_socket_data_t *) socket->specific_data;
         assert(socket_data);
-        // set the backlog
+
+        /* Set the backlog */
         socket_data->backlog = backlog;
 
@@ -1663 +1687 @@
 }
 
-int
-tcp_connect_message(socket_cores_ref local_sockets, int socket_id,
+int tcp_connect_message(socket_cores_t *local_sockets, int socket_id,
     struct sockaddr *addr, socklen_t addrlen)
 {
-        ERROR_DECLARE;
-
-        socket_core_ref socket;
+        socket_core_t *socket;
+        int rc;
 
         assert(local_sockets);
@@ -1675 +1697 @@
         assert(addrlen > 0);
 
-        // find the socket
+        /* Find the socket */
         socket = socket_cores_find(local_sockets, socket_id);
         if (!socket)
                 return ENOTSOCK;
         
-        if (ERROR_OCCURRED(tcp_connect_core(socket, local_sockets, addr,
-            addrlen))) {
+        rc = tcp_connect_core(socket, local_sockets, addr, addrlen);
+        if (rc != EOK) {
                 tcp_free_socket_data(socket);
-                // unbind if bound
+                /* Unbind if bound */
                 if (socket->port > 0) {
                         socket_ports_exclude(&tcp_globals.sockets,
-                            socket->port);
+                            socket->port, free);
                         socket->port = 0;
                 }
         }
-        return ERROR_CODE;
-}
-
-int
-tcp_connect_core(socket_core_ref socket, socket_cores_ref local_sockets,
+        return rc;
+}
+
+int tcp_connect_core(socket_core_t *socket, socket_cores_t *local_sockets,
     struct sockaddr *addr, socklen_t addrlen)
 {
-        ERROR_DECLARE;
-
-        tcp_socket_data_ref socket_data;
-        packet_t packet;
+        tcp_socket_data_t *socket_data;
+        packet_t *packet;
+        int rc;
 
         assert(socket);
@@ -1706 +1726 @@
         assert(addrlen > 0);
 
-        // get the socket specific data
-        socket_data = (tcp_socket_data_ref) socket->specific_data;
+        /* Get the socket specific data */
+        socket_data = (tcp_socket_data_t *) socket->specific_data;
         assert(socket_data);
         assert(socket->specific_data == socket_data);
@@ -1715 +1735 @@
                 return EINVAL;
 
-        // get the destination port
-        ERROR_PROPAGATE(tl_get_address_port(addr, addrlen,
-            &socket_data->dest_port));
+        /* Get the destination port */
+        rc = tl_get_address_port(addr, addrlen, &socket_data->dest_port);
+        if (rc != EOK)
+                return rc;
+        
         if (socket->port <= 0) {
-                // 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
+                /* 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 */
                 tcp_globals.last_used_port = socket->port;
         }
 
-        ERROR_PROPAGATE(ip_get_route_req(tcp_globals.ip_phone, IPPROTO_TCP,
+        rc = ip_get_route_req(tcp_globals.ip_phone, IPPROTO_TCP,
             addr, addrlen, &socket_data->device_id,
-            &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
+            &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 */
         fibril_rwlock_write_unlock(&tcp_globals.lock);
 
         socket_data->addr = addr;
         socket_data->addrlen = addrlen;
-        // 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))) {
-
+
+        /* 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)) {
                 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);
-                        // send the packet
+
+                        socket_data->state = TCP_SOCKET_SYN_SENT;
+
+                        /* 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);
-                        ERROR_CODE = socket_data->operation.result;
-                        if (ERROR_CODE != EOK) {
+                        rc = socket_data->operation.result;
+                        if (rc != EOK) {
                                 socket_data->addr = NULL;
                                 socket_data->addrlen = 0;
@@ -1770 +1800 @@
                         socket_data->addr = NULL;
                         socket_data->addrlen = 0;
-                        ERROR_CODE = EINTR;
+                        rc = EINTR;
                 }
         }
 
         fibril_mutex_unlock(&socket_data->operation.mutex);
-
-        // 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;
+        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;
 
         assert(socket);
@@ -1792 +1818 @@
         assert(socket->specific_data == socket_data);
 
-        // get tcp header
-        header = (tcp_header_ref) packet_get_data(packet);
+        /* Get TCP header */
+        header = (tcp_header_t *) packet_get_data(packet);
         if (!header)
                 return NO_DATA;
@@ -1801 +1827 @@
         header->sequence_number = htonl(socket_data->next_outgoing);
 
-        if (ERROR_OCCURRED(packet_set_addr(packet, NULL,
-            (uint8_t *) socket_data->addr, socket_data->addrlen)))
+        rc = packet_set_addr(packet, NULL, (uint8_t *) socket_data->addr,
+            socket_data->addrlen);
+        if (rc != EOK)
                 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;
@@ -1812 +1839 @@
 }
 
-int
-tcp_queue_packet(socket_core_ref socket, tcp_socket_data_ref socket_data,
-    packet_t packet, size_t data_length)
-{
-        ERROR_DECLARE;
+int tcp_queue_packet(socket_core_t *socket, tcp_socket_data_t *socket_data,
+    packet_t *packet, size_t data_length)
+{
+        int rc;
 
         assert(socket);
@@ -1822 +1848 @@
         assert(socket->specific_data == socket_data);
 
-        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);
+        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);
 
         socket_data->next_outgoing += data_length;
@@ -1833 +1861 @@
 }
 
-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;
+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;
         size_t data_length;
+        int rc;
 
         assert(socket);
@@ -1852 +1879 @@
                 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,
@@ -1867 +1896 @@
                 if (!sending) {
                         sending = copy;
-                } else if (ERROR_OCCURRED(pq_insert_after(previous, copy))) {
-                        pq_release_remote(tcp_globals.net_phone,
-                            packet_get_id(copy));
-                        return sending;
+                } else {
+                        rc = pq_insert_after(previous, copy);
+                        if (rc != EOK) {
+                                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;
                 }
@@ -1888 +1921 @@
 }
 
-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;
+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;
         uint32_t checksum;
+        int rc;
 
         assert(socket);
@@ -1901 +1932 @@
         assert(socket->specific_data == socket_data);
 
-        // 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)))) {
+        /* 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) {
                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
                 return NULL;
         }
 
-        // get the header
-        header = (tcp_header_ref) packet_get_data(packet);
+        /* Get the header */
+        header = (tcp_header_t *) packet_get_data(packet);
         if (!header) {
                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
@@ -1917 +1948 @@
         assert(ntohl(header->sequence_number) == sequence_number);
 
-        // adjust the header
+        /* Adjust the header */
         if (socket_data->next_incoming) {
                 header->acknowledgement_number =
@@ -1925 +1956 @@
         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
-        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))) {
+        /* Prepare the packet */
+        rc = ip_client_prepare_packet(packet, IPPROTO_TCP, 0, 0, 0, 0);
+        if (rc != EOK) {
                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
                 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_ref socket, tcp_socket_data_ref socket_data,
-    packet_t packet, size_t data_length, size_t sequence_number)
-{
-        packet_t copy;
+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;
 
         assert(socket);
@@ -1955 +1991 @@
         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)
@@ -1964 +2000 @@
 }
 
-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) {
@@ -1976 +2012 @@
 }
 
-void
-tcp_prepare_operation_header(socket_core_ref socket,
-    tcp_socket_data_ref socket_data, tcp_header_ref header, int synchronize,
+void tcp_prepare_operation_header(socket_core_t *socket,
+    tcp_socket_data_t *socket_data, tcp_header_t *header, int synchronize,
     int finalize)
 {
@@ -1994 +2029 @@
 }
 
-int
-tcp_prepare_timeout(int (*timeout_function)(void *tcp_timeout_t),
-    socket_core_ref socket, tcp_socket_data_ref socket_data,
+int tcp_prepare_timeout(int (*timeout_function)(void *tcp_timeout_t),
+    socket_core_t *socket, tcp_socket_data_t *socket_data,
     size_t sequence_number, tcp_socket_state_t state, suseconds_t timeout,
     int globals_read_only)
 {
-        tcp_timeout_ref operation_timeout;
+        tcp_timeout_t *operation_timeout;
         fid_t fibril;
 
@@ -2007 +2041 @@
         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);
@@ -2022 +2056 @@
         operation_timeout->state = state;
 
-        // copy the key
-        operation_timeout->key = ((char *) operation_timeout) +
+        /* Copy the key */
+        operation_timeout->key = ((uint8_t *) operation_timeout) +
             sizeof(*operation_timeout);
         operation_timeout->key_length = socket->key_length;
@@ -2029 +2063 @@
         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 EPARTY;  /* FIXME: use another EC */
-        }
+                return ENOMEM;
+        }
+
 //      fibril_mutex_lock(&socket_data->operation.mutex);
-        // start the timeouting fibril
+        /* Start the timeout fibril */
         fibril_add_ready(fibril);
         //socket_data->state = state;
@@ -2042 +2077 @@
 }
 
-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 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 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_ref) socket->specific_data;
-
-        // check state
+        socket_data = (tcp_socket_data_t *) 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) {
-                ERROR_PROPAGATE(data_reply(socket_data->addr,
-                    socket_data->addrlen));
+                rc = data_reply(socket_data->addr, socket_data->addrlen);
+                if (rc != EOK)
+                        return rc;
                 *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;
 
-        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
+        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 */
         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_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;
+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;
         size_t total_length;
-        tcp_header_ref header;
+        tcp_header_t *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_ref) socket->specific_data;
-
-        // check state
+        socket_data = (tcp_socket_data_t *) socket->specific_data;
+
+        /* Check state */
         if ((socket_data->state != TCP_SOCKET_ESTABLISHED) &&
             (socket_data->state != TCP_SOCKET_CLOSE_WAIT))
                 return ENOTCONN;
 
-        ERROR_PROPAGATE(tl_get_ip_packet_dimension(tcp_globals.ip_phone,
-           &tcp_globals.dimensions, socket_data->device_id, &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;
 
         *data_fragment_size =
@@ -2138 +2176 @@
             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,
@@ -2147 +2185 @@
 
                 total_length = (size_t) result;
-                // prefix the tcp header
+
+                /* Prefix the TCP header */
                 header = PACKET_PREFIX(packet, tcp_header_t);
                 if (!header)
@@ -2153 +2192 @@
 
                 tcp_prepare_operation_header(socket, socket_data, header, 0, 0);
-                ERROR_PROPAGATE(tcp_queue_packet(socket, socket_data, packet,
-                    0));
-        }
-
-        // flush packets
+                rc = tcp_queue_packet(socket, socket_data, packet, total_length);
+                if (rc != EOK)
+                        return rc;
+        }
+
+        /* Flush packets */
         packet = tcp_get_packets_to_send(socket, socket_data);
         fibril_rwlock_write_unlock(socket_data->local_lock);
@@ -2163 +2203 @@
 
         if (packet) {
-                // send the packet
+                /* Send the packet */
                 tcp_send_packets(socket_data->device_id, packet);
         }
@@ -2171 +2211 @@
 
 int
-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
+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 */
         socket = socket_cores_find(local_sockets, socket_id);
         if (!socket)
                 return ENOTSOCK;
 
-        // get the socket specific data
-        socket_data = (tcp_socket_data_ref) socket->specific_data;
+        /* Get the socket specific data */
+        socket_data = (tcp_socket_data_t *) socket->specific_data;
         assert(socket_data);
 
-        // check state
+        /* Check state */
         switch (socket_data->state) {
         case TCP_SOCKET_ESTABLISHED:
@@ -2201 +2240 @@
 
         default:
-                // just destroy
-                if (ERROR_NONE(socket_destroy(tcp_globals.net_phone, socket_id,
+                /* Just destroy */
+                rc = socket_destroy(tcp_globals.net_phone, socket_id,
                     local_sockets, &tcp_globals.sockets,
-                    tcp_free_socket_data))) {
+                    tcp_free_socket_data);
+                if (rc == EOK) {
                         fibril_rwlock_write_unlock(socket_data->local_lock);
                         fibril_rwlock_write_unlock(&tcp_globals.lock);
                 }
-                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
+                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 */
         packet = tcp_get_packets_to_send(socket, socket_data);
         fibril_rwlock_write_unlock(socket_data->local_lock);
@@ -2227 +2272 @@
 
         if (packet) {
-                // send the packet
+                /* Send the packet */
                 tcp_send_packets(socket_data->device_id, packet);
         }
@@ -2234 +2279 @@
 }
 
-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;
+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;
 
         assert(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
+        /* 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 */
         *packet = packet_get_4_remote(tcp_globals.net_phone, TCP_HEADER_SIZE,
             packet_dimension->addr_len, packet_dimension->prefix,
@@ -2258 +2302 @@
                 return ENOMEM;
 
-        // allocate space in the packet
+        /* Allocate space in the packet */
         header = PACKET_SUFFIX(*packet, tcp_header_t);
         if (!header)
@@ -2269 +2313 @@
 }
 
-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;
+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;
 
         assert(local_sockets);
@@ -2284 +2326 @@
         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_ref) socket->specific_data;
+        /* Get the socket specific data */
+        socket_data = (tcp_socket_data_t *) socket->specific_data;
         assert(socket_data);
 
-        // check state
+        /* Check state */
         if (socket_data->state != TCP_SOCKET_LISTEN)
                 return EINVAL;
@@ -2307 +2349 @@
                         return ENOTSOCK;
 
-                // get the socket specific data
-                socket_data = (tcp_socket_data_ref) accepted->specific_data;
+                /* Get the socket specific data */
+                socket_data = (tcp_socket_data_t *) 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) {
-                        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));
+                        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;
                         *addrlen = socket_data->addrlen;
 
@@ -2326 +2372 @@
         
                         if (new_socket_id > 0) {
-                                ERROR_PROPAGATE(socket_cores_update(
-                                    local_sockets, accepted->socket_id,
-                                    new_socket_id));
+                                rc = socket_cores_update(local_sockets,
+                                    accepted->socket_id, new_socket_id);
+                                if (rc != EOK)
+                                        return rc;
                                 accepted->socket_id = new_socket_id;
                         }
@@ -2339 +2386 @@
 }
 
-void
-tcp_free_socket_data(socket_core_ref socket)
-{
-        tcp_socket_data_ref socket_data;
+void tcp_free_socket_data(socket_core_t *socket)
+{
+        tcp_socket_data_t *socket_data;
 
         assert(socket);
@@ -2348 +2394 @@
         printf("destroy_socket %d\n", socket->socket_id);
 
-        // get the socket specific data
-        socket_data = (tcp_socket_data_ref) socket->specific_data;
+        /* Get the socket specific data */
+        socket_data = (tcp_socket_data_t *) socket->specific_data;
         assert(socket_data);
-        //free the pseudo header
+
+        /* Free the pseudo header */
         if (socket_data->pseudo_header) {
                 if (socket_data->headerlen) {
@@ -2360 +2407 @@
                 socket_data->pseudo_header = NULL;
         }
+
         socket_data->headerlen = 0;
-        // free the address
+
+        /* Free the address */
         if (socket_data->addr) {
                 if (socket_data->addrlen) {
@@ -2373 +2422 @@
 }
 
-int tcp_release_and_return(packet_t packet, int result)
+/** 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)
 {
         pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
@@ -2379 +2434 @@
 }
 
-/** Default thread for new connections.
+/** Process IPC messages from the IP module
  *
- *  @param[in] iid The initial message identifier.
- *  @param[in] icall The initial message call structure.
+ * @param[in]     iid   Message identifier.
+ * @param[in,out] icall Message parameters.
  *
  */
-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);
-
+static void tcp_receiver(ipc_callid_t iid, ipc_call_t *icall)
+{
+        packet_t *packet;
+        int rc;
+        
         while (true) {
-                ipc_call_t answer;
-                int answer_count;
-
-                /*
-                   Clear the answer structure 
-                 */
-                refresh_answer(&answer, &answer_count);
-
-                /*
-                   Fetch the next message 
-                 */
-                ipc_call_t call;
-                ipc_callid_t callid = async_get_call(&call);
-
-                /*
-                   Process the message 
-                 */
-                int res = 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.
+                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.
  *
- *  @param argc The count of the command line arguments. Ignored parameter.
- *  @param argv The command line parameters. Ignored parameter.
+ * @param[in] net_phone Network module phone.
  *
- *  @returns EOK on success.
- *  @returns Other error codes as defined for each specific module start function.
+ * @return EOK on success.
+ * @return ENOMEM if there is not enough memory left.
  *
  */
-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;
+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);
 }