Changeset fb04cba8 in mainline for uspace/srv/net/tl

Timestamp:

2010-11-14T14:07:05Z (15 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

9e2e715

Parents:

c9ebbe71

Message:

Fix style of function headers and comments.

Location:

uspace/srv/net/tl

Files:

• icmp/icmp.c (modified) (28 diffs)
• icmp/icmp_module.c (modified) (1 diff)
• tcp/tcp.c (modified) (128 diffs)
• tcp/tcp_module.c (modified) (1 diff)
• udp/udp.c (modified) (40 diffs)
• udp/udp_module.c (modified) (1 diff)

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

@@ -155 +155 @@
  * @returns             EPERM if the error message is not allowed.
  */
-static int
-icmp_send_packet(icmp_type_t type, icmp_code_t code, packet_t packet,
+static int icmp_send_packet(icmp_type_t type, icmp_code_t code, packet_t packet,
     icmp_header_ref header, services_t error, ip_ttl_t ttl, ip_tos_t tos,
     int dont_fragment)
@@ -162 +161 @@
         int rc;
 
-        // do not send an error if disabled
+        /* Do not send an error if disabled */
         if (error && !icmp_globals.error_reporting)
                 return icmp_release_and_return(packet, EPERM);
@@ -204 +203 @@
                 return NULL;
 
-        // truncate if longer than 64 bits (without the IP header)
+        /* Truncate if longer than 64 bits (without the IP header) */
         if ((total_length > header_length + ICMP_KEEP_LENGTH) &&
             (packet_trim(packet, 0,
@@ -244 +243 @@
  * @returns             EPARTY if there was an internal error.
  */
-static int
-icmp_echo(icmp_param_t id, icmp_param_t sequence, size_t size,
+static int icmp_echo(icmp_param_t id, icmp_param_t sequence, size_t size,
     mseconds_t timeout, ip_ttl_t ttl, ip_tos_t tos, int dont_fragment,
     const struct sockaddr * addr, socklen_t addrlen)
@@ -262 +260 @@
 
         length = (size_t) addrlen;
-        // TODO do not ask all the time
+        /* TODO do not ask all the time */
         rc = ip_packet_size_req(icmp_globals.ip_phone, -1,
             &icmp_globals.packet_dimension);
@@ -275 +273 @@
                 return ENOMEM;
 
-        // prepare the requesting packet
-        // set the destination address
+        /* Prepare the requesting packet, set the destination address. */
         rc = packet_set_addr(packet, NULL, (const uint8_t *) addr, length);
         if (rc != EOK)
                 return icmp_release_and_return(packet, rc);
 
-        // allocate space in the packet
+        /* Allocate space in the packet */
         data = (uint8_t *) packet_suffix(packet, size);
         if (!data)
                 return icmp_release_and_return(packet, ENOMEM);
 
-        // fill the data
+        /* Fill the data */
         length = 0;
         while (size > length + sizeof(ICMP_ECHO_TEXT)) {
@@ -294 +291 @@
         memcpy(data + length, ICMP_ECHO_TEXT, size - length);
 
-        // prefix the header
+        /* Prefix the header */
         header = PACKET_PREFIX(packet, icmp_header_t);
         if (!header)
@@ -303 +300 @@
         header->un.echo.sequence_number = sequence;
 
-        // prepare the reply structure
+        /* Prepare the reply structure */
         reply = malloc(sizeof(*reply));
         if (!reply)
@@ -319 +316 @@
         }
 
-        // unlock the globals so that we can wait for the reply
+        /* Unlock the globals so that we can wait for the reply */
         fibril_rwlock_write_unlock(&icmp_globals.lock);
 
-        // send the request
+        /* Send the request */
         icmp_send_packet(ICMP_ECHO, 0, packet, header, 0, ttl, tos,
             dont_fragment);
 
-        // wait for the reply
-        // timeout in microseconds
+        /* Wait for the reply. Timeout in microseconds. */
         rc = fibril_condvar_wait_timeout(&reply->condvar, &reply->mutex,
             timeout * 1000);
@@ -333 +329 @@
                 rc = reply->result;
 
-        // drop the reply mutex before locking the globals again
+        /* Drop the reply mutex before locking the globals again */
         fibril_mutex_unlock(&reply->mutex);
         fibril_rwlock_write_lock(&icmp_globals.lock);
 
-        // destroy the reply structure
+        /* Destroy the reply structure */
         icmp_replies_exclude_index(&icmp_globals.replies, index);
 
@@ -343 +339 @@
 }
 
-static int
-icmp_destination_unreachable_msg_local(int icmp_phone, icmp_code_t code,
-    icmp_param_t mtu, packet_t packet)
+static int icmp_destination_unreachable_msg_local(int icmp_phone,
+    icmp_code_t code, icmp_param_t mtu, packet_t packet)
 {
         icmp_header_ref header;
@@ -372 +367 @@
 }
 
-static int
-icmp_time_exceeded_msg_local(int icmp_phone, icmp_code_t code, packet_t packet)
+static int icmp_time_exceeded_msg_local(int icmp_phone, icmp_code_t code,
+    packet_t packet)
 {
         icmp_header_ref header;
@@ -385 +380 @@
 }
 
-static int
-icmp_parameter_problem_msg_local(int icmp_phone, icmp_code_t code,
+static int icmp_parameter_problem_msg_local(int icmp_phone, icmp_code_t code,
     icmp_param_t pointer, packet_t packet)
 {
@@ -449 +443 @@
         icmp_globals.echo_replying = NET_DEFAULT_ICMP_ECHO_REPLYING;
 
-        // get configuration
+        /* Get configuration */
         configuration = &names[0];
         rc = net_get_conf_req(icmp_globals.net_phone, &configuration, count,
@@ -485 +479 @@
  * @param[in] code      The received reply message code.
  */
-static void 
-icmp_process_echo_reply(packet_t packet, icmp_header_ref header,
+static void  icmp_process_echo_reply(packet_t packet, icmp_header_ref header,
     icmp_type_t type, icmp_code_t code)
 {
@@ -492 +485 @@
         icmp_reply_ref reply;
 
-        // compute the reply key
+        /* Compute the reply key */
         reply_key = ICMP_GET_REPLY_KEY(header->un.echo.identifier,
             header->un.echo.sequence_number);
         pq_release_remote(icmp_globals.net_phone, packet_get_id(packet));
 
+        /* Find the pending reply */
         fibril_rwlock_write_lock(&icmp_globals.lock);
-        // find the pending reply
         reply = icmp_replies_find(&icmp_globals.replies, reply_key);
         if (reply) {
@@ -541 +534 @@
                 break;
         case SERVICE_ICMP:
-                // process error
+                /* Process error */
                 result = icmp_client_process_packet(packet, &type, &code, NULL,
                     NULL);
@@ -547 +540 @@
                         return result;
                 length = (size_t) result;
-                // remove the error header
+                /* Remove the error header */
                 rc = packet_trim(packet, length, 0);
                 if (rc != EOK)
@@ -556 +549 @@
         }
 
-        // get rid of the ip header
+        /* Get rid of the IP header */
         length = ip_client_header_length(packet);
         rc = packet_trim(packet, length, 0);
@@ -573 +566 @@
                 return EINVAL;
 
-        // get icmp header
+        /* Get ICMP header */
         header = (icmp_header_ref) data;
 
         if (header->checksum) {
                 while (ICMP_CHECKSUM(header, length) != IP_CHECKSUM_ZERO) {
-                        // set the original message type on error notification
-                        // type swap observed in Qemu
+                        /*
+                         * Set the original message type on error notification.
+                         * Type swap observed in Qemu.
+                         */
                         if (error) {
                                 switch (header->type) {
@@ -606 +601 @@
                 }
                 
-                // do not send a reply if disabled
+                /* Do not send a reply if disabled */
                 if (icmp_globals.echo_replying) {
                         addrlen = packet_get_addr(packet, &src, NULL);
 
-                        // set both addresses to the source one (avoids the
-                        // source address deletion before setting the
-                        // destination one)
+                        /*
+                         * Set both addresses to the source one (avoids the
+                         * source address deletion before setting the
+                         * destination one).
+                         */
                         if ((addrlen > 0) && (packet_set_addr(packet, src, src,
                             (size_t) addrlen) == EOK)) {
-                                // send the reply
+                                /* Send the reply */
                                 icmp_send_packet(ICMP_ECHOREPLY, 0, packet,
                                     header, 0, 0, 0, 0);
@@ -661 +658 @@
  *                      icmp_process_packet() function.
  */
-static int
-icmp_received_msg_local(device_id_t device_id, packet_t packet,
+static int icmp_received_msg_local(device_id_t device_id, packet_t packet,
     services_t receiver, services_t error)
 {
@@ -746 +742 @@
                 return EBADMEM;
 
-        // from the last used one
+        /* From the last used one */
         index = icmp_globals.last_used_id;
         do {
                 index++;
-                // til the range end
+                /* til the range end */
                 if (index >= ICMP_FREE_IDS_END) {
-                        // start from the range beginning
+                        /* start from the range beginning */
                         index = ICMP_FREE_IDS_START - 1;
                         do {
                                 index++;
-                                // til the last used one
+                                /* til the last used one */
                                 if (index >= icmp_globals.last_used_id) {
-                                        // none found
+                                        /* none found */
                                         return ENOTCONN;
                                 }
@@ -764 +760 @@
                             index) != NULL);
 
-                        // found, break immediately
+                        /* Found, break immediately */
                         break;
                 }
@@ -808 +804 @@
                 return ENOMEM;
 
-        // assign a new identifier
+        /* Assign a new identifier */
         fibril_rwlock_write_lock(&icmp_globals.lock);
         rc = icmp_bind_free_id(echo_data);
@@ -818 +814 @@
 
         while (keep_on_going) {
-                // answer the call
+                /* Answer the call */
                 answer_call(callid, rc, &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
+                /* Process the call */
                 switch (IPC_GET_METHOD(call)) {
                 case IPC_M_PHONE_HUNGUP:
@@ -876 +872 @@
         }
 
-        // release the identifier
+        /* Release the identifier */
         fibril_rwlock_write_lock(&icmp_globals.lock);
         icmp_echo_data_exclude(&icmp_globals.echo_data, echo_data->identifier);
@@ -897 +893 @@
  * @see IS_NET_ICMP_MESSAGE()
  */
-int
-icmp_message_standalone(ipc_callid_t callid, ipc_call_t *call,
+int icmp_message_standalone(ipc_callid_t callid, ipc_call_t *call,
     ipc_call_t *answer, int *answer_count)
 {

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

@@ -85 +85 @@
 }
 
-int
-tl_module_message_standalone(ipc_callid_t callid, ipc_call_t *call,
+int tl_module_message_standalone(ipc_callid_t callid, ipc_call_t *call,
     ipc_call_t *answer, int *answer_count)
 {

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

@@ -44 +44 @@
 #include <fibril_synch.h>
 #include <malloc.h>
-//TODO remove stdio
+/* TODO remove stdio */
 #include <stdio.h>
 #include <errno.h>
@@ -267 +267 @@
 }
 
-int
-tcp_received_msg(device_id_t device_id, packet_t packet, services_t receiver,
-    services_t error)
+int tcp_received_msg(device_id_t device_id, packet_t packet,
+    services_t receiver, services_t error)
 {
         int rc;
@@ -309 +308 @@
                 break;
         case SERVICE_ICMP:
-                // process error
+                /* Process error */
                 result = icmp_client_process_packet(packet, &type, &code, NULL,
                     NULL);
@@ -324 +323 @@
         }
 
-        // TODO process received ipopts?
+        /* TODO process received ipopts? */
         result = ip_client_process_packet(packet, NULL, NULL, NULL, NULL, NULL);
         if (result < 0)
@@ -338 +337 @@
                 return tcp_release_and_return(packet, NO_DATA);
 
-        // trim all but TCP header
+        /* Trim all but TCP header */
         rc = packet_trim(packet, offset, 0);
         if (rc != EOK)
                 return tcp_release_and_return(packet, rc);
 
-        // get tcp header
+        /* Get tcp header */
         header = (tcp_header_ref) packet_get_data(packet);
         if (!header)
@@ -361 +360 @@
                 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);
         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,
@@ -383 +383 @@
         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;
@@ -399 +399 @@
                 total_length += length;
 
-                // add partial checksum if set
+                /* Add partial checksum if set */
                 if (!error) {
                         checksum = compute_checksum(checksum,
@@ -447 +447 @@
                     tcp_globals.icmp_phone, packet, error);
                 if (rc == EOK) {
-                        // checksum error ICMP
+                        /* Checksum error ICMP */
                         icmp_parameter_problem_msg(tcp_globals.icmp_phone,
                             ICMP_PARAM_POINTER,
@@ -460 +460 @@
         fibril_rwlock_read_unlock(&tcp_globals.lock);
 
-        // TODO error reporting/handling
+        /* TODO error reporting/handling */
         switch (socket_data->state) {
         case TCP_SOCKET_LISTEN:
@@ -474 +474 @@
                 break;
         case TCP_SOCKET_FIN_WAIT_1:
-                // ack changing the state to FIN_WAIT_2 gets processed later
+                /* ack changing the state to FIN_WAIT_2 gets processed later */
         case TCP_SOCKET_FIN_WAIT_2:
-                // fin changing state to LAST_ACK gets processed later
+                /* fin changing state to LAST_ACK gets processed later */
         case TCP_SOCKET_LAST_ACK:
-                // ack releasing the socket get processed later
+                /* ack releasing the socket get processed later */
         case TCP_SOCKET_CLOSING:
-                // ack releasing the socket gets processed later
+                /* ack releasing the socket gets processed later */
         case TCP_SOCKET_ESTABLISHED:
                 rc = tcp_process_established(socket, socket_data, header,
@@ -497 +497 @@
 }
 
-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_process_established(socket_core_ref socket, tcp_socket_data_ref
+    socket_data, tcp_header_ref header, packet_t packet, int fragments,
+    size_t total_length)
 {
         packet_t next_packet;
@@ -523 +523 @@
                 socket_data->fin_incoming = new_sequence_number;
 
-        // trim begining if containing expected data
+        /* 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 -
@@ -539 +539 @@
                 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,
@@ -559 +560 @@
         }
 
-        // release if overflowing the window
+        /* Release if overflowing the window */
 /*
         if (IS_IN_INTERVAL_OVERFLOW(socket_data->next_incoming +
@@ -609 +610 @@
         }
 */
-        // the expected one arrived?
+        /* The expected one arrived? */
         if (new_sequence_number == socket_data->next_incoming) {
                 printf("expected\n");
-                // process acknowledgement
+                /* Process acknowledgement */
                 tcp_process_acknowledgement(socket, socket_data, header);
 
-                // remove the header
+                /* Remove the header */
                 total_length -= TCP_HEADER_LENGTH(header);
                 rc = packet_trim(packet, TCP_HEADER_LENGTH(header), 0);
@@ -635 +636 @@
                         rc = pq_get_order(socket_data->incoming, &order, NULL);
                         if (rc != EOK) {
-                                // remove the corrupted packet
+                                /* Remove the corrupted packet */
                                 next_packet = pq_detach(packet);
                                 if (packet == socket_data->incoming)
@@ -648 +649 @@
                         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));
@@ -667 +668 @@
                                         continue;
                                 }
-                                // exactly following
+                                /* Exactly following */
                                 if (sequence_number ==
                                     socket_data->next_incoming) {
-                                        // queue received data
+                                        /* Queue received data */
                                         rc = tcp_queue_received_packet(socket,
                                             socket_data, packet, 1,
@@ -680 +681 @@
                                         packet = next_packet;
                                         continue;
-                                        // at least partly following data?
+                                        /* At least partly following data? */
                                 }
                                 if (IS_IN_INTERVAL_OVERFLOW(sequence_number,
@@ -695 +696 @@
                                         rc = packet_trim(packet,length, 0);
                                         if (rc == EOK) {
-                                                // queue received data
+                                                /* Queue received data */
                                                 rc = tcp_queue_received_packet(
                                                     socket, socket_data, packet,
@@ -708 +709 @@
                                         }
                                 }
-                                // remove the duplicit or corrupted packet
+                                /* Remove the duplicit or corrupted packet */
                                 pq_release_remote(tcp_globals.net_phone,
                                     packet_get_id(packet));
@@ -721 +722 @@
             socket_data->next_incoming + socket_data->window)) {
                 printf("in window\n");
-                // process acknowledgement
+                /* Process acknowledgement */
                 tcp_process_acknowledgement(socket, socket_data, header);
 
-                // remove the header
+                /* Remove the header */
                 total_length -= TCP_HEADER_LENGTH(header);
                 rc = packet_trim(packet, TCP_HEADER_LENGTH(header), 0);
@@ -735 +736 @@
                     length);
                 if (rc != EOK) {
-                        // remove the corrupted packets
+                        /* Remove the corrupted packets */
                         pq_release_remote(tcp_globals.net_phone,
                             packet_get_id(packet));
@@ -762 +763 @@
         } 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
+        /* Change state according to the acknowledging incoming fin */
         if (IS_IN_INTERVAL_OVERFLOW(old_incoming, socket_data->fin_incoming,
             socket_data->next_incoming)) {
@@ -775 +776 @@
                         socket_data->state = TCP_SOCKET_CLOSING;
                         break;
-                        //case TCP_ESTABLISHED:
+                /*case TCP_ESTABLISHED:*/
                 default:
                         socket_data->state = TCP_SOCKET_CLOSE_WAIT;
@@ -784 +785 @@
         packet = tcp_get_packets_to_send(socket, socket_data);
         if (!packet) {
-                // create the notification packet
+                /* Create the notification packet */
                 rc = tcp_create_notification_packet(&packet, socket,
                     socket_data, 0, 0);
@@ -798 +799 @@
         fibril_rwlock_write_unlock(socket_data->local_lock);
 
-        // send the packet
+        /* Send the packet */
         tcp_send_packets(socket_data->device_id, packet);
 
@@ -804 +805 @@
 }
 
-int
-tcp_queue_received_packet(socket_core_ref socket,
+int tcp_queue_received_packet(socket_core_ref socket,
     tcp_socket_data_ref socket_data, packet_t packet, int fragments,
     size_t total_length)
@@ -819 +819 @@
         assert(socket_data->window > total_length);
 
-        // queue the received packet
+        /* Queue the received packet */
         rc = dyn_fifo_push(&socket->received, packet_get_id(packet),
             SOCKET_MAX_RECEIVED_SIZE);
@@ -829 +829 @@
                 return tcp_release_and_return(packet, rc);
 
-        // decrease the window size
+        /* 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,
@@ -842 +842 @@
 }
 
-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_sent(socket_core_ref socket, tcp_socket_data_ref
+    socket_data, tcp_header_ref header, packet_t packet)
 {
         packet_t next_packet;
@@ -858 +857 @@
                 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) {
@@ -868 +868 @@
                     packet_get_id(next_packet));
         }
-        // trim if longer than the header
+
+        /* Trim if longer than the header */
         if (packet_get_data_length(packet) > sizeof(*header)) {
                 rc = packet_trim(packet, 0,
@@ -875 +876 @@
                         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;
@@ -884 +887 @@
                 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);
@@ -892 +895 @@
                 }
         }
+
         fibril_mutex_unlock(&socket_data->operation.mutex);
         return tcp_release_and_return(packet, EINVAL);
 }
 
-int
-tcp_process_listen(socket_core_ref listening_socket,
+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,
@@ -936 +939 @@
                 return tcp_release_and_return(packet, ENOMEM);
         }
+
         memcpy(socket_data->addr, src, socket_data->addrlen);
         socket_data->dest_port = ntohs(header->source_port);
@@ -946 +950 @@
         }
 
-        // create a socket
+        /* Create a socket */
         socket_id = -1;
         rc = socket_create(socket_data->local_sockets, listening_socket->phone,
@@ -965 +969 @@
         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);
@@ -971 +975 @@
             (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*/);
         }
@@ -983 +987 @@
             socket_id);
         if (!socket) {
-                // where is the socket?!?
+                /* Where is the socket?!? */
                 fibril_rwlock_write_unlock(&tcp_globals.lock);
                 return ENOTSOCK;
@@ -1010 +1014 @@
         socket_data->next_incoming = ntohl(header->sequence_number) + 1;
 
-        // release additional packets
+        /* Release additional packets */
         next_packet = pq_detach(packet);
         if (next_packet) {
@@ -1017 +1021 @@
         }
 
-        // trim if longer than the header
+        /* Trim if longer than the header */
         if (packet_get_data_length(packet) > sizeof(*header)) {
                 rc = packet_trim(packet, 0,
@@ -1050 +1054 @@
         fibril_rwlock_write_unlock(socket_data->local_lock);
 
-        // send the packet
+        /* Send the packet */
         tcp_send_packets(socket_data->device_id, packet);
 
@@ -1056 +1060 @@
 }
 
-int
-tcp_process_syn_received(socket_core_ref socket,
+int tcp_process_syn_received(socket_core_ref socket,
     tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet)
 {
@@ -1073 +1076 @@
                 return tcp_release_and_return(packet, EINVAL);
 
-        // process acknowledgement
+        /* Process acknowledgement */
         tcp_process_acknowledgement(socket, socket_data, header);
 
@@ -1086 +1089 @@
                 assert(listening_socket_data);
 
-                // queue the received packet
+                /* 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
+                        /* Notify the destination socket */
                         async_msg_5(socket->phone, NET_SOCKET_ACCEPTED,
                             (ipcarg_t) listening_socket->socket_id,
@@ -1100 +1103 @@
                 }
         }
-        // send FIN
+        /* Send FIN */
         socket_data->state = TCP_SOCKET_FIN_WAIT_1;
 
-        // create the notification packet
+        /* Create the notification packet */
         rc = tcp_create_notification_packet(&packet, socket, socket_data, 0, 1);
         if (rc != EOK)
                 return rc;
 
-        // send the packet
+        /* Send the packet */
         rc = tcp_queue_packet(socket, socket_data, packet, 1);
         if (rc != EOK)
                 return rc;
 
-        // flush packets
+        /* 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);
         }
@@ -1124 +1127 @@
 }
 
-void
-tcp_process_acknowledgement(socket_core_ref socket,
+void tcp_process_acknowledgement(socket_core_ref socket,
     tcp_socket_data_ref socket_data, tcp_header_ref header)
 {
@@ -1144 +1146 @@
 
         number = ntohl(header->acknowledgement_number);
-        // if more data acknowledged
+
+        /* If more data acknowledged */
         if (number != socket_data->expected) {
                 old = socket_data->expected;
@@ -1155 +1158 @@
                         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,
@@ -1166 +1171 @@
                         }
                 }
-                // 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) {
@@ -1172 +1178 @@
                             socket_data->expected;
                 }
-                // set new expected sequence number
+
+                /* Set new expected sequence number */
                 socket_data->expected = number;
                 socket_data->expected_count = 1;
@@ -1184 +1191 @@
                                         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,
@@ -1192 +1199 @@
                                 break;
                 }
-                // release acknowledged
+
+                /* Release acknowledged */
                 if (acknowledged) {
                         pq_release_remote(tcp_globals.net_phone,
@@ -1198 +1206 @@
                 }
                 return;
-                // if the same as the previous time
-        }
+                /* If the same as the previous time */
+        }
+
         if (number == socket_data->expected) {
-                // increase the counter
+                /* 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);
                 }
@@ -1311 +1320 @@
         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
+                /* Process the call */
                 switch (IPC_GET_METHOD(call)) {
                 case IPC_M_PHONE_HUNGUP:
@@ -1401 +1410 @@
                         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);
@@ -1516 +1527 @@
         }
 
-        // release the application phone
+        /* Release the application phone */
         ipc_hangup(app_phone);
 
         printf("release\n");
-        // release all local sockets
+        /* Release all local sockets */
         socket_cores_release(tcp_globals.net_phone, &local_sockets,
             &tcp_globals.sockets, tcp_free_socket_data);
@@ -1536 +1547 @@
         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);
@@ -1544 +1555 @@
                 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);
@@ -1557 +1568 @@
         fibril_rwlock_write_lock(socket_data->local_lock);
         if (timeout->sequence_number) {
-                // increase the timeout counter;
+                /* 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);
@@ -1571 +1582 @@
         } 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);
                 }
@@ -1589 +1603 @@
 
 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;
@@ -1610 +1624 @@
         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;
@@ -1629 +1646 @@
                 }
         }
-        // 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)
+void tcp_retransmit_packet(socket_core_ref socket, tcp_socket_data_ref
+    socket_data, size_t sequence_number)
 {
         packet_t packet;
@@ -1648 +1667 @@
         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));
@@ -1664 +1683 @@
 }
 
-int
-tcp_listen_message(socket_cores_ref local_sockets, int socket_id, int backlog)
+int tcp_listen_message(socket_cores_ref local_sockets, int socket_id,
+    int backlog)
 {
         socket_core_ref socket;
@@ -1675 +1694 @@
                 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
+        /* Get the socket specific data */
         socket_data = (tcp_socket_data_ref) socket->specific_data;
         assert(socket_data);
-        // set the backlog
+
+        /* Set the backlog */
         socket_data->backlog = backlog;
 
@@ -1689 +1709 @@
 }
 
-int
-tcp_connect_message(socket_cores_ref local_sockets, int socket_id,
+int tcp_connect_message(socket_cores_ref local_sockets, int socket_id,
     struct sockaddr *addr, socklen_t addrlen)
 {
@@ -1700 +1719 @@
         assert(addrlen > 0);
 
-        // find the socket
+        /* Find the socket */
         socket = socket_cores_find(local_sockets, socket_id);
         if (!socket)
@@ -1708 +1727 @@
         if (rc != EOK) {
                 tcp_free_socket_data(socket);
-                // unbind if bound
+                /* Unbind if bound */
                 if (socket->port > 0) {
                         socket_ports_exclude(&tcp_globals.sockets,
@@ -1718 +1737 @@
 }
 
-int
-tcp_connect_core(socket_core_ref socket, socket_cores_ref local_sockets,
+int tcp_connect_core(socket_core_ref socket, socket_cores_ref local_sockets,
     struct sockaddr *addr, socklen_t addrlen)
 {
@@ -1730 +1748 @@
         assert(addrlen > 0);
 
-        // get the socket specific data
+        /* Get the socket specific data */
         socket_data = (tcp_socket_data_ref) socket->specific_data;
         assert(socket_data);
@@ -1739 +1757 @@
                 return EINVAL;
 
-        // get the destination port
+        /* Get the destination port */
         rc = tl_get_address_port(addr, addrlen, &socket_data->dest_port);
         if (rc != EOK)
@@ -1745 +1763 @@
         
         if (socket->port <= 0) {
-                // try to find a free port
+                /* Try to find a free port */
                 rc = socket_bind_free_port(&tcp_globals.sockets, socket,
                     TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
@@ -1751 +1769 @@
                 if (rc != EOK)
                         return rc;
-                // set the next port as the search starting port number
+                /* Set the next port as the search starting port number */
                 tcp_globals.last_used_port = socket->port;
         }
@@ -1761 +1779 @@
                 return rc;
 
-        // create the notification packet
+        /* 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
+        /* 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
+
+        /* Send the packet */
 
         if (((rc = tcp_queue_packet(socket, socket_data, packet, 1)) != EOK) ||
@@ -1785 +1804 @@
                         fibril_mutex_lock(&socket_data->operation.mutex);
                         fibril_rwlock_write_unlock(socket_data->local_lock);
-                        // send the packet
+
+                        /* Send the packet */
                         printf("connecting %d\n", packet_get_id(packet));
                         tcp_send_packets(socket_data->device_id, packet);
 
-                        // wait for a reply
+                        /* Wait for a reply */
                         fibril_condvar_wait(&socket_data->operation.condvar,
                             &socket_data->operation.mutex);
@@ -1805 +1825 @@
 
         fibril_mutex_unlock(&socket_data->operation.mutex);
-
-        // return the result
         return rc;
 }
 
-int
-tcp_queue_prepare_packet(socket_core_ref socket,
+int tcp_queue_prepare_packet(socket_core_ref socket,
     tcp_socket_data_ref socket_data, packet_t packet, size_t data_length)
 {
@@ -1821 +1838 @@
         assert(socket->specific_data == socket_data);
 
-        // get tcp header
+        /* Get TCP header */
         header = (tcp_header_ref) packet_get_data(packet);
         if (!header)
@@ -1835 +1852 @@
                 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;
@@ -1842 +1859 @@
 }
 
-int
-tcp_queue_packet(socket_core_ref socket, tcp_socket_data_ref socket_data,
+int tcp_queue_packet(socket_core_ref socket, tcp_socket_data_ref socket_data,
     packet_t packet, size_t data_length)
 {
@@ -1865 +1881 @@
 }
 
-packet_t
-tcp_get_packets_to_send(socket_core_ref socket, tcp_socket_data_ref socket_data)
+packet_t tcp_get_packets_to_send(socket_core_ref socket, tcp_socket_data_ref
+    socket_data)
 {
         packet_t packet;
@@ -1883 +1899 @@
                 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,
@@ -1909 +1927 @@
                 previous = copy;
                 packet = pq_next(packet);
-                // overflow occurred ?
+
+                /* 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;
                 }
@@ -1922 +1941 @@
 }
 
-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_send_prepare_packet(socket_core_ref socket, tcp_socket_data_ref
+    socket_data, packet_t packet, size_t data_length, size_t sequence_number)
 {
         tcp_header_ref header;
@@ -1934 +1952 @@
         assert(socket->specific_data == socket_data);
 
-        // adjust the pseudo header
+        /* Adjust the pseudo header */
         rc = ip_client_set_pseudo_header_data_length(socket_data->pseudo_header,
             socket_data->headerlen, packet_get_data_length(packet));
@@ -1942 +1960 @@
         }
 
-        // get the header
+        /* Get the header */
         header = (tcp_header_ref) packet_get_data(packet);
         if (!header) {
@@ -1950 +1968 @@
         assert(ntohl(header->sequence_number) == sequence_number);
 
-        // adjust the header
+        /* Adjust the header */
         if (socket_data->next_incoming) {
                 header->acknowledgement_number =
@@ -1958 +1976 @@
         header->window = htons(socket_data->window);
 
-        // checksum
+        /* Checksum */
         header->checksum = 0;
         checksum = compute_checksum(0, socket_data->pseudo_header,
@@ -1967 +1985 @@
         header->checksum = htons(flip_checksum(compact_checksum(checksum)));
 
-        // prepare the packet
+        /* Prepare the packet */
         rc = ip_client_prepare_packet(packet, IPPROTO_TCP, 0, 0, 0, 0);
         if (rc != EOK) {
@@ -1973 +1991 @@
                 return NULL;
         }
+
         rc = tcp_prepare_timeout(tcp_timeout, socket, socket_data,
             sequence_number, socket_data->state, socket_data->timeout, true);
@@ -1983 +2002 @@
 }
 
-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 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;
@@ -1993 +2011 @@
         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)
@@ -2014 +2032 @@
 }
 
-void
-tcp_prepare_operation_header(socket_core_ref socket,
+void tcp_prepare_operation_header(socket_core_ref socket,
     tcp_socket_data_ref socket_data, tcp_header_ref header, int synchronize,
     int finalize)
@@ -2032 +2049 @@
 }
 
-int
-tcp_prepare_timeout(int (*timeout_function)(void *tcp_timeout_t),
+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,
@@ -2045 +2061 @@
         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);
@@ -2060 +2076 @@
         operation_timeout->state = state;
 
-        // copy the key
+        /* Copy the key */
         operation_timeout->key = ((char *) operation_timeout) +
             sizeof(*operation_timeout);
@@ -2067 +2083 @@
         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) {
@@ -2074 +2090 @@
         }
 //      fibril_mutex_lock(&socket_data->operation.mutex);
-        // start the timeouting fibril
+        /* Start the timeout fibril */
         fibril_add_ready(fibril);
         //socket_data->state = state;
@@ -2080 +2096 @@
 }
 
-int
-tcp_recvfrom_message(socket_cores_ref local_sockets, int socket_id, int flags,
-    size_t *addrlen)
+int tcp_recvfrom_message(socket_cores_ref local_sockets, int socket_id,
+    int flags, size_t *addrlen)
 {
         socket_core_ref socket;
@@ -2093 +2108 @@
         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;
@@ -2104 +2119 @@
         socket_data = (tcp_socket_data_ref) socket->specific_data;
 
-        // check state
+        /* Check state */
         if ((socket_data->state != TCP_SOCKET_ESTABLISHED) &&
             (socket_data->state != TCP_SOCKET_CLOSE_WAIT))
                 return ENOTCONN;
 
-        // send the source address if desired
+        /* Send the source address if desired */
         if (addrlen) {
                 rc = data_reply(socket_data->addr, socket_data->addrlen);
@@ -2117 +2132 @@
         }
 
-        // get the next received packet
+        /* Get the next received packet */
         packet_id = dyn_fifo_value(&socket->received);
         if (packet_id < 0)
@@ -2126 +2141 @@
                 return rc;
 
-        // reply the packets
+        /* Reply the packets */
         rc = socket_reply_packets(packet, &length);
         if (rc != EOK)
                 return rc;
 
-        // release the packet
+        /* 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)
+int tcp_send_message(socket_cores_ref local_sockets, int socket_id,
+    int fragments, size_t *data_fragment_size, int flags)
 {
         socket_core_ref socket;
@@ -2155 +2170 @@
         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;
@@ -2166 +2181 @@
         socket_data = (tcp_socket_data_ref) socket->specific_data;
 
-        // check state
+        /* Check state */
         if ((socket_data->state != TCP_SOCKET_ESTABLISHED) &&
             (socket_data->state != TCP_SOCKET_CLOSE_WAIT))
@@ -2181 +2196 @@
 
         for (index = 0; index < fragments; index++) {
-                // read the data fragment
+                /* Read the data fragment */
                 result = tl_socket_read_packet_data(tcp_globals.net_phone,
                     &packet, TCP_HEADER_SIZE, packet_dimension,
@@ -2189 +2204 @@
 
                 total_length = (size_t) result;
-                // prefix the tcp header
+
+                /* Prefix the TCP header */
                 header = PACKET_PREFIX(packet, tcp_header_t);
                 if (!header)
@@ -2200 +2216 @@
         }
 
-        // flush packets
+        /* Flush packets */
         packet = tcp_get_packets_to_send(socket, socket_data);
         fibril_rwlock_write_unlock(socket_data->local_lock);
@@ -2206 +2222 @@
 
         if (packet) {
-                // send the packet
+                /* Send the packet */
                 tcp_send_packets(socket_data->device_id, packet);
         }
@@ -2221 +2237 @@
         int rc;
 
-        // 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 */
         socket_data = (tcp_socket_data_ref) socket->specific_data;
         assert(socket_data);
 
-        // check state
+        /* Check state */
         switch (socket_data->state) {
         case TCP_SOCKET_ESTABLISHED:
@@ -2243 +2259 @@
 
         default:
-                // just destroy
+                /* Just destroy */
                 rc = socket_destroy(tcp_globals.net_phone, socket_id,
                     local_sockets, &tcp_globals.sockets,
@@ -2254 +2270 @@
         }
 
-        // send FIN
-        // TODO should I wait to complete?
-
-        // create the notification packet
+        /*
+         * 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
+        /* Send the packet */
         rc = tcp_queue_packet(socket, socket_data, packet, 1);
         if (rc != EOK)
                 return rc;
 
-        // flush packets
+        /* Flush packets */
         packet = tcp_get_packets_to_send(socket, socket_data);
         fibril_rwlock_write_unlock(socket_data->local_lock);
@@ -2273 +2291 @@
 
         if (packet) {
-                // send the packet
+                /* Send the packet */
                 tcp_send_packets(socket_data->device_id, packet);
         }
@@ -2280 +2298 @@
 }
 
-int
-tcp_create_notification_packet(packet_t *packet, socket_core_ref socket,
+int tcp_create_notification_packet(packet_t *packet, socket_core_ref socket,
     tcp_socket_data_ref socket_data, int synchronize, int finalize)
 {
@@ -2290 +2307 @@
         assert(packet);
 
-        // get the device packet dimension
+        /* Get the device packet dimension */
         rc = tl_get_ip_packet_dimension(tcp_globals.ip_phone,
             &tcp_globals.dimensions, socket_data->device_id, &packet_dimension);
@@ -2296 +2313 @@
                 return rc;
 
-        // get a new packet
+        /* Get a new packet */
         *packet = packet_get_4_remote(tcp_globals.net_phone, TCP_HEADER_SIZE,
             packet_dimension->addr_len, packet_dimension->prefix,
@@ -2304 +2321 @@
                 return ENOMEM;
 
-        // allocate space in the packet
+        /* Allocate space in the packet */
         header = PACKET_SUFFIX(*packet, tcp_header_t);
         if (!header)
@@ -2315 +2332 @@
 }
 
-int
-tcp_accept_message(socket_cores_ref local_sockets, int socket_id,
+int tcp_accept_message(socket_cores_ref local_sockets, int socket_id,
     int new_socket_id, size_t *data_fragment_size, size_t *addrlen)
 {
@@ -2329 +2345 @@
         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
+        /* Get the socket specific data */
         socket_data = (tcp_socket_data_ref) socket->specific_data;
         assert(socket_data);
 
-        // check state
+        /* Check state */
         if (socket_data->state != TCP_SOCKET_LISTEN)
                 return EINVAL;
@@ -2352 +2368 @@
                         return ENOTSOCK;
 
-                // get the socket specific data
+                /* Get the socket specific data */
                 socket_data = (tcp_socket_data_ref) accepted->specific_data;
                 assert(socket_data);
-                // TODO can it be in another state?
+                /* TODO can it be in another state? */
                 if (socket_data->state == TCP_SOCKET_ESTABLISHED) {
                         rc = data_reply(socket_data->addr,
@@ -2389 +2405 @@
 }
 
-void
-tcp_free_socket_data(socket_core_ref socket)
+void tcp_free_socket_data(socket_core_ref socket)
 {
         tcp_socket_data_ref socket_data;
@@ -2398 +2413 @@
         printf("destroy_socket %d\n", socket->socket_id);
 
-        // get the socket specific data
+        /* Get the socket specific data */
         socket_data = (tcp_socket_data_ref) socket->specific_data;
         assert(socket_data);
-        //free the pseudo header
+
+        /* Free the pseudo header */
         if (socket_data->pseudo_header) {
                 if (socket_data->headerlen) {
@@ -2410 +2426 @@
                 socket_data->pseudo_header = NULL;
         }
+
         socket_data->headerlen = 0;
-        // free the address
+
+        /* Free the address */
         if (socket_data->addr) {
                 if (socket_data->addrlen) {
@@ -2473 +2491 @@
 
                 /*
-                   Answer the message 
+                 * Answer the message 
                  */
                 answer_call(callid, res, &answer, answer_count);

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

@@ -86 +86 @@
 }
 
-int
-tl_module_message_standalone(ipc_callid_t callid, ipc_call_t *call,
+int tl_module_message_standalone(ipc_callid_t callid, ipc_call_t *call,
     ipc_call_t *answer, int *answer_count)
 {

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

@@ -130 +130 @@
         }
 
-        // read default packet dimensions
+        /* Read default packet dimensions */
         rc = ip_packet_size_req(udp_globals.ip_phone, -1,
             &udp_globals.packet_dimension);
@@ -158 +158 @@
         udp_globals.autobinding = NET_DEFAULT_UDP_AUTOBINDING;
 
-        // get configuration
+        /* Get configuration */
         configuration = &names[0];
         rc = net_get_conf_req(udp_globals.net_phone, &configuration, count,
@@ -217 +217 @@
  *                      ip_client_process_packet() function.
  */
-static int
-udp_process_packet(device_id_t device_id, packet_t packet, services_t error)
+static int udp_process_packet(device_id_t device_id, packet_t packet,
+    services_t error)
 {
         size_t length;
@@ -242 +242 @@
                 break;
         case SERVICE_ICMP:
-                // ignore error
+                /* Ignore error */
                 // length = icmp_client_header_length(packet);
-                // process error
+
+                /* Process error */
                 result = icmp_client_process_packet(packet, &type,
                     &code, NULL, NULL);
@@ -258 +259 @@
         }
 
-        // TODO process received ipopts?
+        /* TODO process received ipopts? */
         result = ip_client_process_packet(packet, NULL, NULL, NULL, NULL, NULL);
         if (result < 0)
@@ -270 +271 @@
                 return udp_release_and_return(packet, NO_DATA);
 
-        // trim all but UDP header
+        /* Trim all but UDP header */
         rc = packet_trim(packet, offset, 0);
         if (rc != EOK)
                 return udp_release_and_return(packet, rc);
 
-        // get udp header
+        /* Get UDP header */
         header = (udp_header_ref) packet_get_data(packet);
         if (!header)
                 return udp_release_and_return(packet, NO_DATA);
 
-        // find the destination socket
+        /* Find the destination socket */
         socket = socket_port_find(&udp_globals.sockets,
         ntohs(header->destination_port), SOCKET_MAP_KEY_LISTENING, 0);
@@ -292 +293 @@
         }
 
-        // count the received packet fragments
+        /* Count the received packet fragments */
         next_packet = packet;
         fragments = 0;
         total_length = ntohs(header->total_length);
 
-        // compute header checksum if set
+        /* Compute header checksum if set */
         if (header->checksum && !error) {
                 result = packet_get_addr(packet, (uint8_t **) &src,
@@ -310 +311 @@
                 } else {
                         checksum = compute_checksum(0, ip_header, length);
-                        // the udp header checksum will be added with the first
-                        // fragment later
+                        /*
+                         * The udp header checksum will be added with the first
+                         * fragment later.
+                         */
                         free(ip_header);
                 }
@@ -330 +333 @@
                                 return udp_release_and_return(packet, rc);
 
-                        // add partial checksum if set
+                        /* Add partial checksum if set */
                         if (header->checksum) {
                                 checksum = compute_checksum(checksum,
@@ -337 +340 @@
                         }
 
-                        // relese the rest of the packet fragments
+                        /* Relese the rest of the packet fragments */
                         tmp_packet = pq_next(next_packet);
                         while (tmp_packet) {
@@ -346 +349 @@
                         }
 
-                        // exit the loop
+                        /* Exit the loop */
                         break;
                 }
                 total_length -= length;
 
-                // add partial checksum if set
+                /* Add partial checksum if set */
                 if (header->checksum) {
                         checksum = compute_checksum(checksum,
@@ -360 +363 @@
         } while ((next_packet = pq_next(next_packet)) && (total_length > 0));
 
-        // check checksum
+        /* Verify checksum */
         if (header->checksum) {
                 if (flip_checksum(compact_checksum(checksum)) !=
@@ -366 +369 @@
                         if (tl_prepare_icmp_packet(udp_globals.net_phone,
                             udp_globals.icmp_phone, packet, error) == EOK) {
-                                // checksum error ICMP
+                                /* Checksum error ICMP */
                                 icmp_parameter_problem_msg(
                                     udp_globals.icmp_phone, ICMP_PARAM_POINTER,
@@ -376 +379 @@
         }
 
-        // queue the received packet
+        /* Queue the received packet */
         rc = dyn_fifo_push(&socket->received, packet_get_id(packet),
             SOCKET_MAX_RECEIVED_SIZE);
@@ -387 +390 @@
                 return udp_release_and_return(packet, rc);
 
-        // notify the destination socket
+        /* Notify the destination socket */
         fibril_rwlock_write_unlock(&udp_globals.lock);
         async_msg_5(socket->phone, NET_SOCKET_RECEIVED,
@@ -410 +413 @@
  *                      udp_process_packet() function.
  */
-static int
-udp_received_msg(device_id_t device_id, packet_t packet, services_t receiver,
-    services_t error)
+static int udp_received_msg(device_id_t device_id, packet_t packet,
+    services_t receiver, services_t error)
 {
         int result;
@@ -451 +453 @@
  *                      function.
  */
-static int
-udp_sendto_message(socket_cores_ref local_sockets, int socket_id,
+static int udp_sendto_message(socket_cores_ref local_sockets, int socket_id,
     const struct sockaddr *addr, socklen_t addrlen, int fragments,
     size_t *data_fragment_size, int flags)
@@ -480 +481 @@
 
         if ((socket->port <= 0) && udp_globals.autobinding) {
-                // bind the socket to a random free port if not bound
+                /* Bind the socket to a random free port if not bound */
                 rc = socket_bind_free_port(&udp_globals.sockets, socket,
                     UDP_FREE_PORTS_START, UDP_FREE_PORTS_END,
@@ -486 +487 @@
                 if (rc != EOK)
                         return rc;
-                // set the next port as the search starting port number
+                /* Set the next port as the search starting port number */
                 udp_globals.last_used_port = socket->port;
         }
@@ -495 +496 @@
                 if (rc != EOK)
                         return rc;
-                // get the device packet dimension
+                /* Get the device packet dimension */
 //              rc = tl_get_ip_packet_dimension(udp_globals.ip_phone,
 //                  &udp_globals.dimensions, device_id, &packet_dimension);
@@ -502 +503 @@
         }
 //      } else {
-                // do not ask all the time
+                /* Do not ask all the time */
                 rc = ip_packet_size_req(udp_globals.ip_phone, -1,
                     &udp_globals.packet_dimension);
@@ -510 +511 @@
 //      }
 
-        // read the first packet fragment
+        /* Read the first packet fragment */
         result = tl_socket_read_packet_data(udp_globals.net_phone, &packet,
             UDP_HEADER_SIZE, packet_dimension, addr, addrlen);
@@ -523 +524 @@
                 checksum = 0;
 
-        // prefix the udp header
+        /* Prefix the UDP header */
         header = PACKET_PREFIX(packet, udp_header_t);
         if (!header)
@@ -529 +530 @@
 
         bzero(header, sizeof(*header));
-        // read the rest of the packet fragments
+
+        /* Read the rest of the packet fragments */
         for (index = 1; index < fragments; index++) {
                 result = tl_socket_read_packet_data(udp_globals.net_phone,
@@ -548 +550 @@
         }
 
-        // set the udp header
+        /* Set the UDP header */
         header->source_port = htons((socket->port > 0) ? socket->port : 0);
         header->destination_port = htons(dest_port);
         header->total_length = htons(total_length + sizeof(*header));
         header->checksum = 0;
+
         if (udp_globals.checksum_computing) {
-                // update the pseudo header
+                /* Update the pseudo header */
                 rc = ip_client_set_pseudo_header_data_length(ip_header,
                     headerlen, total_length + UDP_HEADER_SIZE);
@@ -562 +565 @@
                 }
 
-                // finish the checksum computation
+                /* Finish the checksum computation */
                 checksum = compute_checksum(checksum, ip_header, headerlen);
                 checksum = compute_checksum(checksum, (uint8_t *) header,
@@ -573 +576 @@
         }
 
-        // prepare the first packet fragment
+        /* Prepare the first packet fragment */
         rc = ip_client_prepare_packet(packet, IPPROTO_UDP, 0, 0, 0, 0);
         if (rc != EOK)
@@ -581 +584 @@
         fibril_rwlock_write_unlock(&udp_globals.lock);
 
-        // send the packet
+        /* Send the packet */
         ip_send_msg(udp_globals.ip_phone, device_id, packet, SERVICE_UDP, 0);
 
@@ -606 +609 @@
  *                      function.
  */
-static int
-udp_recvfrom_message(socket_cores_ref local_sockets, int socket_id, int flags,
-    size_t *addrlen)
+static int udp_recvfrom_message(socket_cores_ref local_sockets, int socket_id,
+    int flags, size_t *addrlen)
 {
         socket_core_ref socket;
@@ -620 +622 @@
         int rc;
 
-        // find the socket
+        /* Find the socket */
         socket = socket_cores_find(local_sockets, socket_id);
         if (!socket)
                 return ENOTSOCK;
 
-        // get the next received packet
+        /* Get the next received packet */
         packet_id = dyn_fifo_value(&socket->received);
         if (packet_id < 0)
@@ -636 +638 @@
         }
 
-        // get udp header
+        /* Get UDP header */
         data = packet_get_data(packet);
         if (!data) {
@@ -644 +646 @@
         header = (udp_header_ref) data;
 
-        // set the source address port
+        /* Set the source address port */
         result = packet_get_addr(packet, (uint8_t **) &addr, NULL);
         rc = tl_set_address_port(addr, result, ntohs(header->source_port));
@@ -653 +655 @@
         *addrlen = (size_t) result;
 
-        // send the source address
+        /* Send the source address */
         rc = data_reply(addr, *addrlen);
         switch (rc) {
@@ -665 +667 @@
         }
 
-        // trim the header
+        /* Trim the header */
         rc = packet_trim(packet, UDP_HEADER_SIZE, 0);
         if (rc != EOK) {
@@ -672 +674 @@
         }
 
-        // reply the packets
+        /* Reply the packets */
         rc = socket_reply_packets(packet, &length);
         switch (rc) {
@@ -686 +688 @@
         (void) dyn_fifo_pop(&socket->received);
 
-        // release the packet and return the total length
+        /* Release the packet and return the total length */
         return udp_release_and_return(packet, (int) length);
 }
@@ -721 +723 @@
         answer_count = 0;
 
-        // The client connection is only in one fibril and therefore no
-        // additional locks are needed.
+        /*
+         * The client connection is only in one fibril and therefore no
+         * additional locks are needed.
+         */
 
         socket_cores_initialize(&local_sockets);
@@ -728 +732 @@
         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
+                /* Process the call */
                 switch (IPC_GET_METHOD(call)) {
                 case IPC_M_PHONE_HUNGUP:
@@ -831 +835 @@
         }
 
-        // release the application phone
+        /* Release the application phone */
         ipc_hangup(app_phone);
 
-        // release all local sockets
+        /* Release all local sockets */
         socket_cores_release(udp_globals.net_phone, &local_sockets,
             &udp_globals.sockets, NULL);
@@ -854 +858 @@
  * @see IS_NET_UDP_MESSAGE()
  */
-int
-udp_message_standalone(ipc_callid_t callid, ipc_call_t *call,
+int udp_message_standalone(ipc_callid_t callid, ipc_call_t *call,
     ipc_call_t *answer, int *answer_count)
 {

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

@@ -86 +86 @@
 }
 
-int
-tl_module_message_standalone(ipc_callid_t callid, ipc_call_t *call,
+int tl_module_message_standalone(ipc_callid_t callid, ipc_call_t *call,
     ipc_call_t *answer, int *answer_count)
 {