Changeset 7c8267b in mainline


Ignore:
Timestamp:
2010-09-19T12:55:05Z (14 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
2fa0ad9, dc94cb2
Parents:
553f430
Message:

Coding style fixes.

This changeset converts the entire TCP code into HelenOS cstyle and improves
its general legibility by adding vertical spacing and removing unnecessary
clutter. It also attempts to suppress too deep nesting of blocks by
functional-equivalent code restructuralization.

This changeset brings no change in functionality (hopefully), but it should make
it easier to understand and eventually fix TCP code.

Location:
uspace
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/net/generic/packet_remote.c

    r553f430 r7c8267b  
    7070        aid_t message = async_send_1(phone, NET_PACKET_GET, packet_id, &answer);
    7171        *packet = (packet_t) as_get_mappable_page(size);
    72         if (ERROR_OCCURRED(async_share_in_start_0_0(phone, *packet, size))
    73             || ERROR_OCCURRED(pm_add(*packet))) {
     72        if (ERROR_OCCURRED(async_share_in_start_0_0(phone, *packet, size)) ||
     73            ERROR_OCCURRED(pm_add(*packet))) {
    7474                munmap(*packet, size);
    7575                async_wait_for(message, NULL);
  • uspace/lib/net/tl/tl_common.c

    r553f430 r7c8267b  
    157157}
    158158
    159 int tl_set_address_port(struct sockaddr * addr, int addrlen, uint16_t port){
     159int tl_set_address_port(struct sockaddr * addr, int addrlen, uint16_t port)
     160{
    160161        struct sockaddr_in * address_in;
    161162        struct sockaddr_in6 * address_in6;
    162163        size_t length;
    163164
    164         if(addrlen < 0){
    165                 return EINVAL;
    166         }
     165        if (addrlen < 0)
     166                return EINVAL;
     167       
    167168        length = (size_t) addrlen;
    168         if(length < sizeof(struct sockaddr)){
    169                 return EINVAL;
    170         }
    171         switch(addr->sa_family){
    172                 case AF_INET:
    173                         if(length != sizeof(struct sockaddr_in)){
     169        if (length < sizeof(struct sockaddr))
     170                return EINVAL;
     171
     172        switch (addr->sa_family) {
     173        case AF_INET:
     174                if (length != sizeof(struct sockaddr_in))
     175                        return EINVAL;
     176                address_in = (struct sockaddr_in *) addr;
     177                address_in->sin_port = htons(port);
     178                return EOK;
     179        case AF_INET6:
     180                if (length != sizeof(struct sockaddr_in6))
    174181                                return EINVAL;
    175                         }
    176                         address_in = (struct sockaddr_in *) addr;
    177                         address_in->sin_port = htons(port);
    178                         return EOK;
    179                 case AF_INET6:
    180                         if(length != sizeof(struct sockaddr_in6)){
    181                                 return EINVAL;
    182                         }
    183                         address_in6 = (struct sockaddr_in6 *) addr;
    184                         address_in6->sin6_port = htons(port);
    185                         return EOK;
    186                 default:
    187                         return EAFNOSUPPORT;
     182                address_in6 = (struct sockaddr_in6 *) addr;
     183                address_in6->sin6_port = htons(port);
     184                return EOK;
     185        default:
     186                return EAFNOSUPPORT;
    188187        }
    189188}
  • uspace/lib/socket/packet/packet_client.c

    r553f430 r7c8267b  
    122122}
    123123
    124 int packet_set_addr(packet_t packet, const uint8_t * src, const uint8_t * dest, size_t addr_len){
     124int
     125packet_set_addr(packet_t packet, const uint8_t * src, const uint8_t * dest,
     126    size_t addr_len)
     127{
    125128        size_t padding;
    126129        size_t allocated;
    127130
    128         if(! packet_is_valid(packet)){
     131        if (!packet_is_valid(packet))
    129132                return EINVAL;
    130         }
     133
    131134        allocated = PACKET_MAX_ADDRESS_LENGTH(packet);
    132         if(allocated < addr_len){
     135        if (allocated < addr_len)
    133136                return ENOMEM;
    134         }
     137
    135138        padding = allocated - addr_len;
    136139        packet->addr_len = addr_len;
    137         if(src){
     140
     141        if (src) {
    138142                memcpy((void *) packet + packet->src_addr, src, addr_len);
    139                 if(padding){
    140                         bzero((void *) packet + packet->src_addr + addr_len, padding);
    141                 }
    142         }else{
     143                if (padding)
     144                        bzero((void *) packet + packet->src_addr + addr_len,
     145                            padding);
     146        } else {
    143147                bzero((void *) packet + packet->src_addr, allocated);
    144148        }
    145         if(dest){
     149
     150        if (dest) {
    146151                memcpy((void *) packet + packet->dest_addr, dest, addr_len);
    147                 if(padding){
    148                         bzero((void *) packet + packet->dest_addr + addr_len, padding);
    149                 }
    150         }else{
     152                if (padding)
     153                        bzero((void *) packet + packet->dest_addr + addr_len,
     154                            padding);
     155        } else {
    151156                bzero((void *) packet + packet->dest_addr, allocated);
    152157        }
     158
    153159        return EOK;
    154160}
  • uspace/srv/net/tl/tcp/tcp.c

    r553f430 r7c8267b  
    7676#include "tcp_module.h"
    7777
    78 /** TCP module name.
    79  */
     78/** TCP module name. */
    8079#define NAME    "TCP protocol"
    8180
    82 /** The TCP window default value.
    83  */
    84 #define NET_DEFAULT_TCP_WINDOW  10240
    85 
    86 /** Initial timeout for new connections.
    87  */
     81/** The TCP window default value. */
     82#define NET_DEFAULT_TCP_WINDOW          10240
     83
     84/** Initial timeout for new connections. */
    8885#define NET_DEFAULT_TCP_INITIAL_TIMEOUT 3000000L
    8986
    90 /** Default timeout for closing.
    91  */
    92 #define NET_DEFAULT_TCP_TIME_WAIT_TIMEOUT       2000L
    93 
    94 /** The initial outgoing sequence number.
    95  */
    96 #define TCP_INITIAL_SEQUENCE_NUMBER             2999
    97 
    98 /** Maximum TCP fragment size.
    99  */
    100 #define MAX_TCP_FRAGMENT_SIZE   65535
    101 
    102 /** Free ports pool start.
    103  */
    104 #define TCP_FREE_PORTS_START    1025
    105 
    106 /** Free ports pool end.
    107  */
     87/** Default timeout for closing. */
     88#define NET_DEFAULT_TCP_TIME_WAIT_TIMEOUT 2000L
     89
     90/** The initial outgoing sequence number. */
     91#define TCP_INITIAL_SEQUENCE_NUMBER     2999
     92
     93/** Maximum TCP fragment size. */
     94#define MAX_TCP_FRAGMENT_SIZE           65535
     95
     96/** Free ports pool start. */
     97#define TCP_FREE_PORTS_START            1025
     98
     99/** Free ports pool end. */
    108100#define TCP_FREE_PORTS_END              65535
    109101
    110 /** Timeout for connection initialization, SYN sent.
    111  */
    112 #define TCP_SYN_SENT_TIMEOUT    1000000L
    113 
    114 /** The maximum number of timeouts in a row before singaling connection lost.
    115  */
     102/** Timeout for connection initialization, SYN sent. */
     103#define TCP_SYN_SENT_TIMEOUT            1000000L
     104
     105/** The maximum number of timeouts in a row before singaling connection lost. */
    116106#define TCP_MAX_TIMEOUTS                8
    117107
    118 /** The number of acknowledgements before retransmit.
    119  */
     108/** The number of acknowledgements before retransmit. */
    120109#define TCP_FAST_RETRANSMIT_COUNT       3
    121110
    122 /** Returns a value indicating whether the value is in the interval respecting the possible overflow.
     111/** Returns a value indicating whether the value is in the interval respecting
     112 *  the possible overflow.
     113 *
    123114 *  The high end and/or the value may overflow, be lower than the low value.
    124115 *  @param[in] lower The last value before the interval.
     
    126117 *  @param[in] higher_equal The last value in the interval.
    127118 */
    128 #define IS_IN_INTERVAL_OVERFLOW(lower, value, higher_equal)     ((((lower) < (value)) && (((value) <= (higher_equal)) || ((higher_equal) < (lower)))) || (((value) <= (higher_equal)) && ((higher_equal) < (lower))))
     119#define IS_IN_INTERVAL_OVERFLOW(lower, value, higher_equal) \
     120        ((((lower) < (value)) && (((value) <= (higher_equal)) || \
     121        ((higher_equal) < (lower)))) || (((value) <= (higher_equal)) && \
     122        ((higher_equal) < (lower))))
    129123
    130124/** Type definition of the TCP timeout.
    131125 *  @see tcp_timeout
    132126 */
    133 typedef struct tcp_timeout      tcp_timeout_t;
     127typedef struct tcp_timeout tcp_timeout_t;
    134128
    135129/** Type definition of the TCP timeout pointer.
    136130 *  @see tcp_timeout
    137131 */
    138 typedef tcp_timeout_t * tcp_timeout_ref;
     132typedef tcp_timeout_t *tcp_timeout_ref;
    139133
    140134/** TCP reply timeout data.
     
    142136 *  @see tcp_timeout()
    143137 */
    144 struct tcp_timeout{
    145         /** TCP global data are going to be read only.
    146          */
     138struct tcp_timeout {
     139        /** TCP global data are going to be read only. */
    147140        int globals_read_only;
    148         /** Socket port.
    149         */
     141
     142        /** Socket port. */
    150143        int port;
    151         /** Local sockets.
    152         */
     144
     145        /** Local sockets. */
    153146        socket_cores_ref local_sockets;
    154         /** Socket identifier.
    155         */
     147
     148        /** Socket identifier. */
    156149        int socket_id;
    157         /** Socket state.
    158         */
     150
     151        /** Socket state. */
    159152        tcp_socket_state_t state;
    160         /** Sent packet sequence number.
    161         */
     153
     154        /** Sent packet sequence number. */
    162155        int sequence_number;
    163         /** Timeout in microseconds.
    164         */
     156
     157        /** Timeout in microseconds. */
    165158        suseconds_t timeout;
    166         /** Port map key.
    167         */
    168         char * key;
    169         /** Port map key length.
    170         */
     159
     160        /** Port map key. */
     161        char *key;
     162
     163        /** Port map key length. */
    171164        size_t key_length;
    172165};
     
    179172int tcp_release_and_return(packet_t packet, int result);
    180173
    181 void tcp_prepare_operation_header(socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, int synchronize, int finalize);
    182 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);
     174void tcp_prepare_operation_header(socket_core_ref socket,
     175    tcp_socket_data_ref socket_data, tcp_header_ref header, int synchronize,
     176    int finalize);
     177int tcp_prepare_timeout(int (*timeout_function)(void *tcp_timeout_t),
     178    socket_core_ref socket, tcp_socket_data_ref socket_data,
     179    size_t sequence_number, tcp_socket_state_t state, suseconds_t timeout,
     180    int globals_read_only);
    183181void tcp_free_socket_data(socket_core_ref socket);
    184 int tcp_timeout(void * data);
    185 int tcp_release_after_timeout(void * data);
    186 int tcp_process_packet(device_id_t device_id, packet_t packet, services_t error);
    187 int tcp_connect_core(socket_core_ref socket, socket_cores_ref local_sockets, struct sockaddr * addr, socklen_t addrlen);
    188 int tcp_queue_prepare_packet(socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length);
    189 int tcp_queue_packet(socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length);
    190 packet_t tcp_get_packets_to_send(socket_core_ref socket, tcp_socket_data_ref socket_data);
     182
     183int tcp_timeout(void *data);
     184
     185int tcp_release_after_timeout(void *data);
     186
     187int tcp_process_packet(device_id_t device_id, packet_t packet,
     188    services_t error);
     189int tcp_connect_core(socket_core_ref socket, socket_cores_ref local_sockets,
     190    struct sockaddr *addr, socklen_t addrlen);
     191int tcp_queue_prepare_packet(socket_core_ref socket,
     192    tcp_socket_data_ref socket_data, packet_t packet, size_t data_length);
     193int tcp_queue_packet(socket_core_ref socket, tcp_socket_data_ref socket_data,
     194    packet_t packet, size_t data_length);
     195packet_t tcp_get_packets_to_send(socket_core_ref socket,
     196    tcp_socket_data_ref socket_data);
    191197void tcp_send_packets(device_id_t device_id, packet_t packet);
    192 void tcp_process_acknowledgement(socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header);
    193 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);
    194 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);
    195 void tcp_retransmit_packet(socket_core_ref socket, tcp_socket_data_ref socket_data, size_t sequence_number);
    196 int tcp_create_notification_packet(packet_t * packet, socket_core_ref socket, tcp_socket_data_ref socket_data, int synchronize, int finalize);
     198
     199void tcp_process_acknowledgement(socket_core_ref socket,
     200    tcp_socket_data_ref socket_data, tcp_header_ref header);
     201packet_t tcp_send_prepare_packet(socket_core_ref socket,
     202    tcp_socket_data_ref socket_data, packet_t packet, size_t data_length,
     203    size_t sequence_number);
     204packet_t tcp_prepare_copy(socket_core_ref socket,
     205    tcp_socket_data_ref socket_data, packet_t packet, size_t data_length,
     206    size_t sequence_number);
     207void tcp_retransmit_packet(socket_core_ref socket,
     208    tcp_socket_data_ref socket_data, size_t sequence_number);
     209int tcp_create_notification_packet(packet_t * packet, socket_core_ref socket,
     210    tcp_socket_data_ref socket_data, int synchronize, int finalize);
    197211void tcp_refresh_socket_data(tcp_socket_data_ref socket_data);
     212
    198213void tcp_initialize_socket_data(tcp_socket_data_ref socket_data);
    199 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);
    200 int tcp_process_syn_sent(socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet);
    201 int tcp_process_syn_received(socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet);
    202 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);
    203 int tcp_queue_received_packet(socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, int fragments, size_t total_length);
    204 
    205 int tcp_received_msg(device_id_t device_id, packet_t packet, services_t receiver, services_t error);
     214
     215int tcp_process_listen(socket_core_ref listening_socket,
     216    tcp_socket_data_ref listening_socket_data, tcp_header_ref header,
     217    packet_t packet, struct sockaddr *src, struct sockaddr *dest,
     218    size_t addrlen);
     219int tcp_process_syn_sent(socket_core_ref socket,
     220    tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet);
     221int tcp_process_syn_received(socket_core_ref socket,
     222    tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet);
     223int tcp_process_established(socket_core_ref socket,
     224    tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet,
     225    int fragments, size_t total_length);
     226int tcp_queue_received_packet(socket_core_ref socket,
     227    tcp_socket_data_ref socket_data, packet_t packet, int fragments,
     228    size_t total_length);
     229
     230int tcp_received_msg(device_id_t device_id, packet_t packet,
     231    services_t receiver, services_t error);
    206232int tcp_process_client_messages(ipc_callid_t callid, ipc_call_t call);
    207 int tcp_listen_message(socket_cores_ref local_sockets, int socket_id, int backlog);
    208 int tcp_connect_message(socket_cores_ref local_sockets, int socket_id, struct sockaddr * addr, socklen_t addrlen);
    209 int tcp_recvfrom_message(socket_cores_ref local_sockets, int socket_id, int flags, size_t * addrlen);
    210 int tcp_send_message(socket_cores_ref local_sockets, int socket_id, int fragments, size_t * data_fragment_size, int flags);
    211 int tcp_accept_message(socket_cores_ref local_sockets, int socket_id, int new_socket_id, size_t * data_fragment_size, size_t * addrlen);
     233
     234int tcp_listen_message(socket_cores_ref local_sockets, int socket_id,
     235    int backlog);
     236int tcp_connect_message(socket_cores_ref local_sockets, int socket_id,
     237    struct sockaddr *addr, socklen_t addrlen);
     238int tcp_recvfrom_message(socket_cores_ref local_sockets, int socket_id,
     239    int flags, size_t * addrlen);
     240int tcp_send_message(socket_cores_ref local_sockets, int socket_id,
     241    int fragments, size_t * data_fragment_size, int flags);
     242int tcp_accept_message(socket_cores_ref local_sockets, int socket_id,
     243    int new_socket_id, size_t * data_fragment_size, size_t * addrlen);
    212244int tcp_close_message(socket_cores_ref local_sockets, int socket_id);
    213245
    214 /** TCP global data.
    215  */
    216 tcp_globals_t   tcp_globals;
    217 
    218 int tcp_initialize(async_client_conn_t client_connection){
     246/** TCP global data. */
     247tcp_globals_t tcp_globals;
     248
     249int tcp_initialize(async_client_conn_t client_connection)
     250{
    219251        ERROR_DECLARE;
    220252
    221253        assert(client_connection);
     254
    222255        fibril_rwlock_initialize(&tcp_globals.lock);
    223256        fibril_rwlock_write_lock(&tcp_globals.lock);
    224         tcp_globals.icmp_phone = icmp_connect_module(SERVICE_ICMP, ICMP_CONNECT_TIMEOUT);
    225         tcp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_TCP, SERVICE_TCP, client_connection, tcp_received_msg);
    226         if(tcp_globals.ip_phone < 0){
     257
     258        tcp_globals.icmp_phone = icmp_connect_module(SERVICE_ICMP,
     259            ICMP_CONNECT_TIMEOUT);
     260        tcp_globals.ip_phone = ip_bind_service(SERVICE_IP, IPPROTO_TCP,
     261            SERVICE_TCP, client_connection, tcp_received_msg);
     262        if (tcp_globals.ip_phone < 0)
    227263                return tcp_globals.ip_phone;
    228         }
     264       
    229265        ERROR_PROPAGATE(socket_ports_initialize(&tcp_globals.sockets));
    230         if(ERROR_OCCURRED(packet_dimensions_initialize(&tcp_globals.dimensions))){
     266        if (ERROR_OCCURRED(packet_dimensions_initialize(
     267            &tcp_globals.dimensions))) {
    231268                socket_ports_destroy(&tcp_globals.sockets);
    232269                return ERROR_CODE;
    233270        }
     271
    234272        tcp_globals.last_used_port = TCP_FREE_PORTS_START - 1;
    235273        fibril_rwlock_write_unlock(&tcp_globals.lock);
     274
    236275        return EOK;
    237276}
    238277
    239 int tcp_received_msg(device_id_t device_id, packet_t packet, services_t receiver, services_t error){
     278int
     279tcp_received_msg(device_id_t device_id, packet_t packet, services_t receiver,
     280    services_t error)
     281{
    240282        ERROR_DECLARE;
    241283
    242         if(receiver != SERVICE_TCP){
     284        if (receiver != SERVICE_TCP)
    243285                return EREFUSED;
    244         }
     286
    245287        fibril_rwlock_write_lock(&tcp_globals.lock);
    246         if(ERROR_OCCURRED(tcp_process_packet(device_id, packet, error))){
     288        if (ERROR_OCCURRED(tcp_process_packet(device_id, packet, error)))
    247289                fibril_rwlock_write_unlock(&tcp_globals.lock);
    248         }
     290
    249291        printf("receive %d \n", ERROR_CODE);
    250292
     
    252294}
    253295
    254 int tcp_process_packet(device_id_t device_id, packet_t packet, services_t error){
     296int tcp_process_packet(device_id_t device_id, packet_t packet, services_t error)
     297{
    255298        ERROR_DECLARE;
    256299
     
    259302        int result;
    260303        tcp_header_ref header;
    261         socket_core_ref  socket;
     304        socket_core_ref socket;
    262305        tcp_socket_data_ref socket_data;
    263306        packet_t next_packet;
     
    267310        icmp_type_t type;
    268311        icmp_code_t code;
    269         struct sockaddr * src;
    270         struct sockaddr * dest;
     312        struct sockaddr *src;
     313        struct sockaddr *dest;
    271314        size_t addrlen;
    272315
    273         printf("p1 \n");
    274         if(error){
    275                 switch(error){
    276                         case SERVICE_ICMP:
    277                                 // process error
    278                                 result = icmp_client_process_packet(packet, &type, &code, NULL, NULL);
    279                                 if(result < 0){
    280                                         return tcp_release_and_return(packet, result);
    281                                 }
    282                                 length = (size_t) result;
    283                                 if(ERROR_OCCURRED(packet_trim(packet, length, 0))){
    284                                         return tcp_release_and_return(packet, ERROR_CODE);
    285                                 }
    286                                 break;
    287                         default:
    288                                 return tcp_release_and_return(packet, ENOTSUP);
     316        if (error) {
     317                switch (error) {
     318                case SERVICE_ICMP:
     319                        // process error
     320                        result = icmp_client_process_packet(packet, &type,
     321                            &code, NULL, NULL);
     322                        if (result < 0)
     323                                return tcp_release_and_return(packet, result);
     324
     325                        length = (size_t) result;
     326                        if (ERROR_OCCURRED(packet_trim(packet, length, 0))) {
     327                                return tcp_release_and_return(packet,
     328                                    ERROR_CODE);
     329                        }
     330                        break;
     331
     332                default:
     333                        return tcp_release_and_return(packet, ENOTSUP);
    289334                }
    290335        }
     
    292337        // TODO process received ipopts?
    293338        result = ip_client_process_packet(packet, NULL, NULL, NULL, NULL, NULL);
    294 //      printf("ip len %d\n", result);
    295         if(result < 0){
     339        if (result < 0)
    296340                return tcp_release_and_return(packet, result);
    297         }
     341
    298342        offset = (size_t) result;
    299343
    300344        length = packet_get_data_length(packet);
    301 //      printf("packet len %d\n", length);
    302         if(length <= 0){
     345        if (length <= 0)
    303346                return tcp_release_and_return(packet, EINVAL);
    304         }
    305         if(length < TCP_HEADER_SIZE + offset){
     347
     348        if (length < TCP_HEADER_SIZE + offset)
    306349                return tcp_release_and_return(packet, NO_DATA);
    307         }
    308350
    309351        // trim all but TCP header
    310         if(ERROR_OCCURRED(packet_trim(packet, offset, 0))){
     352        if (ERROR_OCCURRED(packet_trim(packet, offset, 0)))
    311353                return tcp_release_and_return(packet, ERROR_CODE);
    312         }
    313354
    314355        // get tcp header
    315356        header = (tcp_header_ref) packet_get_data(packet);
    316         if(! header){
     357        if (!header)
    317358                return tcp_release_and_return(packet, NO_DATA);
    318         }
    319 //      printf("header len %d, port %d \n", TCP_HEADER_LENGTH(header), ntohs(header->destination_port));
     359
     360//      printf("header len %d, port %d \n", TCP_HEADER_LENGTH(header),
     361//          ntohs(header->destination_port));
    320362
    321363        result = packet_get_addr(packet, (uint8_t **) &src, (uint8_t **) &dest);
    322         if(result <= 0){
     364        if (result <= 0)
    323365                return tcp_release_and_return(packet, result);
    324         }
     366
    325367        addrlen = (size_t) result;
    326368
    327         if(ERROR_OCCURRED(tl_set_address_port(src, addrlen, ntohs(header->source_port)))){
     369        if (ERROR_OCCURRED(tl_set_address_port(src, addrlen,
     370            ntohs(header->source_port))))
    328371                return tcp_release_and_return(packet, ERROR_CODE);
    329         }
    330 
     372       
    331373        // find the destination socket
    332         socket = socket_port_find(&tcp_globals.sockets, ntohs(header->destination_port), (const char *) src, addrlen);
    333         if(! socket){
    334 //              printf("listening?\n");
     374        socket = socket_port_find(&tcp_globals.sockets,
     375            ntohs(header->destination_port), (const char *) src, addrlen);
     376        if (!socket) {
    335377                // find the listening destination socket
    336                 socket = socket_port_find(&tcp_globals.sockets, ntohs(header->destination_port), SOCKET_MAP_KEY_LISTENING, 0);
    337                 if(! socket){
    338                         if(tl_prepare_icmp_packet(tcp_globals.net_phone, tcp_globals.icmp_phone, packet, error) == EOK){
    339                                 icmp_destination_unreachable_msg(tcp_globals.icmp_phone, ICMP_PORT_UNREACH, 0, packet);
     378                socket = socket_port_find(&tcp_globals.sockets,
     379                    ntohs(header->destination_port), SOCKET_MAP_KEY_LISTENING,
     380                    0);
     381                if (!socket) {
     382                        if (tl_prepare_icmp_packet(tcp_globals.net_phone,
     383                            tcp_globals.icmp_phone, packet, error) == EOK) {
     384                                icmp_destination_unreachable_msg(
     385                                    tcp_globals.icmp_phone, ICMP_PORT_UNREACH,
     386                                    0, packet);
    340387                        }
    341388                        return EADDRNOTAVAIL;
     
    354401        checksum = 0;
    355402        total_length = 0;
    356         do{
    357                 ++ fragments;
     403        do {
     404                ++fragments;
    358405                length = packet_get_data_length(next_packet);
    359                 if(length <= 0){
     406                if (length <= 0)
    360407                        return tcp_release_and_return(packet, NO_DATA);
    361                 }
     408
    362409                total_length += length;
     410
    363411                // add partial checksum if set
    364                 if(! error){
    365                         checksum = compute_checksum(checksum, packet_get_data(packet), packet_get_data_length(packet));
    366                 }
    367         }while((next_packet = pq_next(next_packet)));
    368 //      printf("fragments %d of %d bytes\n", fragments, total_length);
    369 
    370 //      printf("lock?\n");
     412                if (!error) {
     413                        checksum = compute_checksum(checksum,
     414                            packet_get_data(packet),
     415                            packet_get_data_length(packet));
     416                }
     417
     418        } while ((next_packet = pq_next(next_packet)));
     419
    371420        fibril_rwlock_write_lock(socket_data->local_lock);
    372 //      printf("locked\n");
    373         if(! error){
    374                 if(socket_data->state == TCP_SOCKET_LISTEN){
    375                         if(socket_data->pseudo_header){
    376                                 free(socket_data->pseudo_header);
    377                                 socket_data->pseudo_header = NULL;
    378                                 socket_data->headerlen = 0;
    379                         }
    380                         if(ERROR_OCCURRED(ip_client_get_pseudo_header(IPPROTO_TCP, src, addrlen, dest, addrlen, total_length, &socket_data->pseudo_header, &socket_data->headerlen))){
    381                                 fibril_rwlock_write_unlock(socket_data->local_lock);
    382                                 return tcp_release_and_return(packet, ERROR_CODE);
    383                         }
    384                 }else if(ERROR_OCCURRED(ip_client_set_pseudo_header_data_length(socket_data->pseudo_header, socket_data->headerlen, total_length))){
     421
     422        if (error)
     423                goto error;
     424       
     425        if (socket_data->state == TCP_SOCKET_LISTEN) {
     426
     427                if (socket_data->pseudo_header) {
     428                        free(socket_data->pseudo_header);
     429                        socket_data->pseudo_header = NULL;
     430                        socket_data->headerlen = 0;
     431                }
     432
     433                if (ERROR_OCCURRED(ip_client_get_pseudo_header(IPPROTO_TCP, src,
     434                    addrlen, dest, addrlen, total_length,
     435                    &socket_data->pseudo_header, &socket_data->headerlen))) {
    385436                        fibril_rwlock_write_unlock(socket_data->local_lock);
    386437                        return tcp_release_and_return(packet, ERROR_CODE);
    387438                }
    388                 checksum = compute_checksum(checksum, socket_data->pseudo_header, socket_data->headerlen);
    389                 if(flip_checksum(compact_checksum(checksum)) != IP_CHECKSUM_ZERO){
    390                         printf("checksum err %x -> %x\n", header->checksum, flip_checksum(compact_checksum(checksum)));
    391                         fibril_rwlock_write_unlock(socket_data->local_lock);
    392                         if(! ERROR_OCCURRED(tl_prepare_icmp_packet(tcp_globals.net_phone, tcp_globals.icmp_phone, packet, error))){
    393                                 // checksum error ICMP
    394                                 icmp_parameter_problem_msg(tcp_globals.icmp_phone, ICMP_PARAM_POINTER, ((size_t) ((void *) &header->checksum)) - ((size_t) ((void *) header)), packet);
    395                         }
    396                         return EINVAL;
    397                 }
    398         }
    399 
     439
     440        } else if (ERROR_OCCURRED(ip_client_set_pseudo_header_data_length(
     441            socket_data->pseudo_header, socket_data->headerlen,
     442            total_length))) {
     443                fibril_rwlock_write_unlock(socket_data->local_lock);
     444                return tcp_release_and_return(packet, ERROR_CODE);
     445        }
     446       
     447        checksum = compute_checksum(checksum, socket_data->pseudo_header,
     448            socket_data->headerlen);
     449        if (flip_checksum(compact_checksum(checksum)) != IP_CHECKSUM_ZERO) {
     450                printf("checksum err %x -> %x\n", header->checksum,
     451                    flip_checksum(compact_checksum(checksum)));
     452                fibril_rwlock_write_unlock(socket_data->local_lock);
     453
     454                if (ERROR_NONE(tl_prepare_icmp_packet(tcp_globals.net_phone,
     455                    tcp_globals.icmp_phone, packet, error))) {
     456                        // checksum error ICMP
     457                        icmp_parameter_problem_msg(tcp_globals.icmp_phone,
     458                            ICMP_PARAM_POINTER,
     459                            ((size_t) ((void *) &header->checksum)) -
     460                            ((size_t) ((void *) header)), packet);
     461                }
     462
     463                return EINVAL;
     464        }
     465
     466error:
    400467        fibril_rwlock_read_unlock(&tcp_globals.lock);
    401468
    402469        // TODO error reporting/handling
    403 //      printf("st %d\n", socket_data->state);
    404         switch(socket_data->state){
    405                 case TCP_SOCKET_LISTEN:
    406                         ERROR_CODE = tcp_process_listen(socket, socket_data, header, packet, src, dest, addrlen);
    407                         break;
    408                 case TCP_SOCKET_SYN_RECEIVED:
    409                         ERROR_CODE = tcp_process_syn_received(socket, socket_data, header, packet);
    410                         break;
    411                 case TCP_SOCKET_SYN_SENT:
    412                         ERROR_CODE = tcp_process_syn_sent(socket, socket_data, header, packet);
    413                         break;
    414                 case TCP_SOCKET_FIN_WAIT_1:
    415                         // ack changing the state to FIN_WAIT_2 gets processed later
    416                 case TCP_SOCKET_FIN_WAIT_2:
    417                         // fin changing state to LAST_ACK gets processed later
    418                 case TCP_SOCKET_LAST_ACK:
    419                         // ack releasing the socket get processed later
    420                 case TCP_SOCKET_CLOSING:
    421                         // ack releasing the socket gets processed later
    422                 case TCP_SOCKET_ESTABLISHED:
    423                         ERROR_CODE = tcp_process_established(socket, socket_data, header, packet, fragments, total_length);
    424                         break;
    425                 default:
    426                         pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    427         }
    428 
    429         if(ERROR_CODE != EOK){
     470        switch (socket_data->state) {
     471        case TCP_SOCKET_LISTEN:
     472                ERROR_CODE = tcp_process_listen(socket, socket_data, header,
     473                    packet, src, dest, addrlen);
     474                break;
     475        case TCP_SOCKET_SYN_RECEIVED:
     476                ERROR_CODE = tcp_process_syn_received(socket, socket_data,
     477                    header, packet);
     478                break;
     479        case TCP_SOCKET_SYN_SENT:
     480                ERROR_CODE = tcp_process_syn_sent(socket, socket_data, header,
     481                    packet);
     482                break;
     483        case TCP_SOCKET_FIN_WAIT_1:
     484                // ack changing the state to FIN_WAIT_2 gets processed later
     485        case TCP_SOCKET_FIN_WAIT_2:
     486                // fin changing state to LAST_ACK gets processed later
     487        case TCP_SOCKET_LAST_ACK:
     488                // ack releasing the socket get processed later
     489        case TCP_SOCKET_CLOSING:
     490                // ack releasing the socket gets processed later
     491        case TCP_SOCKET_ESTABLISHED:
     492                ERROR_CODE = tcp_process_established(socket, socket_data,
     493                    header, packet, fragments, total_length);
     494                break;
     495        default:
     496                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     497        }
     498
     499        if (ERROR_CODE != EOK) {
    430500                printf("process %d\n", ERROR_CODE);
    431501                fibril_rwlock_write_unlock(socket_data->local_lock);
    432502        }
     503
    433504        return EOK;
    434505}
    435506
    436 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){
     507int
     508tcp_process_established(socket_core_ref socket, tcp_socket_data_ref socket_data,
     509    tcp_header_ref header, packet_t packet, int fragments,
     510    size_t total_length)
     511{
    437512        ERROR_DECLARE;
    438513
     
    455530        old_incoming = socket_data->next_incoming;
    456531
    457         if(header->finalize){
     532        if (header->finalize)
    458533                socket_data->fin_incoming = new_sequence_number;
    459         }
    460 
    461 //      printf("pe %d < %d <= %d\n", new_sequence_number, socket_data->next_incoming, new_sequence_number + total_length);
     534
    462535        // trim begining if containing expected data
    463         if(IS_IN_INTERVAL_OVERFLOW(new_sequence_number, socket_data->next_incoming, new_sequence_number + total_length)){
     536        if (IS_IN_INTERVAL_OVERFLOW(new_sequence_number,
     537            socket_data->next_incoming, new_sequence_number + total_length)) {
     538
    464539                // get the acknowledged offset
    465                 if(socket_data->next_incoming < new_sequence_number){
    466                         offset = new_sequence_number - socket_data->next_incoming;
    467                 }else{
    468                         offset = socket_data->next_incoming - new_sequence_number;
    469                 }
    470 //              printf("offset %d\n", offset);
     540                if (socket_data->next_incoming < new_sequence_number) {
     541                        offset = new_sequence_number -
     542                            socket_data->next_incoming;
     543                } else {
     544                        offset = socket_data->next_incoming -
     545                            new_sequence_number;
     546                }
     547
    471548                new_sequence_number += offset;
    472549                total_length -= offset;
    473550                length = packet_get_data_length(packet);
    474551                // trim the acknowledged data
    475                 while(length <= offset){
     552                while (length <= offset) {
    476553                        // release the acknowledged packets
    477554                        next_packet = pq_next(packet);
    478                         pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     555                        pq_release_remote(tcp_globals.net_phone,
     556                            packet_get_id(packet));
    479557                        packet = next_packet;
    480558                        offset -= length;
    481559                        length = packet_get_data_length(packet);
    482560                }
    483                 if((offset > 0)
    484                         && (ERROR_OCCURRED(packet_trim(packet, offset, 0)))){
     561
     562                if ((offset > 0) && (ERROR_OCCURRED(packet_trim(packet,
     563                    offset, 0))))
    485564                        return tcp_release_and_return(packet, ERROR_CODE);
    486                 }
     565
    487566                assert(new_sequence_number == socket_data->next_incoming);
    488567        }
    489568
    490569        // release if overflowing the window
    491 //      if(IS_IN_INTERVAL_OVERFLOW(socket_data->next_incoming + socket_data->window, new_sequence_number, new_sequence_number + total_length)){
    492 //              return tcp_release_and_return(packet, EOVERFLOW);
    493 //      }
    494 
    495570/*
     571        if (IS_IN_INTERVAL_OVERFLOW(socket_data->next_incoming +
     572            socket_data->window, new_sequence_number, new_sequence_number +
     573            total_length)) {
     574                return tcp_release_and_return(packet, EOVERFLOW);
     575        }
     576
    496577        // trim end if overflowing the window
    497         if(IS_IN_INTERVAL_OVERFLOW(new_sequence_number, socket_data->next_incoming + socket_data->window, new_sequence_number + total_length)){
     578        if (IS_IN_INTERVAL_OVERFLOW(new_sequence_number,
     579            socket_data->next_incoming + socket_data->window,
     580            new_sequence_number + total_length)) {
    498581                // get the allowed data length
    499                 if(socket_data->next_incoming + socket_data->window < new_sequence_number){
    500                         offset = new_sequence_number - socket_data->next_incoming + socket_data->window;
    501                 }else{
    502                         offset = socket_data->next_incoming + socket_data->window - new_sequence_number;
     582                if (socket_data->next_incoming + socket_data->window <
     583                    new_sequence_number) {
     584                        offset = new_sequence_number -
     585                            socket_data->next_incoming + socket_data->window;
     586                } else {
     587                        offset = socket_data->next_incoming +
     588                            socket_data->window - new_sequence_number;
    503589                }
    504590                next_packet = packet;
    505591                // trim the overflowing data
    506                 while(next_packet && (offset > 0)){
     592                while (next_packet && (offset > 0)) {
    507593                        length = packet_get_data_length(packet);
    508                         if(length <= offset){
     594                        if (length <= offset)
    509595                                next_packet = pq_next(next_packet);
    510                         }else if(ERROR_OCCURRED(packet_trim(next_packet, 0, length - offset))){
    511                                 return tcp_release_and_return(packet, ERROR_CODE);
    512                         }
     596                        else if (ERROR_OCCURRED(packet_trim(next_packet, 0,
     597                            length - offset)))
     598                                return tcp_release_and_return(packet,
     599                                    ERROR_CODE);
    513600                        offset -= length;
    514601                        total_length -= length - offset;
     
    516603                // release the overflowing packets
    517604                next_packet = pq_next(next_packet);
    518                 if(next_packet){
     605                if (next_packet) {
    519606                        tmp_packet = next_packet;
    520607                        next_packet = pq_next(next_packet);
    521608                        pq_insert_after(tmp_packet, next_packet);
    522                         pq_release_remote(tcp_globals.net_phone, packet_get_id(tmp_packet));
    523                 }
    524                 assert(new_sequence_number + total_length == socket_data->next_incoming + socket_data->window);
     609                        pq_release_remote(tcp_globals.net_phone,
     610                            packet_get_id(tmp_packet));
     611                }
     612                assert(new_sequence_number + total_length ==
     613                    socket_data->next_incoming + socket_data->window);
    525614        }
    526615*/
    527616        // the expected one arrived?
    528         if(new_sequence_number == socket_data->next_incoming){
     617        if (new_sequence_number == socket_data->next_incoming) {
    529618                printf("expected\n");
    530619                // process acknowledgement
     
    533622                // remove the header
    534623                total_length -= TCP_HEADER_LENGTH(header);
    535                 if(ERROR_OCCURRED(packet_trim(packet, TCP_HEADER_LENGTH(header), 0))){
     624                if (ERROR_OCCURRED(packet_trim(packet,
     625                    TCP_HEADER_LENGTH(header), 0)))
    536626                        return tcp_release_and_return(packet, ERROR_CODE);
    537                 }
    538 
    539                 if(total_length){
    540                         ERROR_PROPAGATE(tcp_queue_received_packet(socket, socket_data, packet, fragments, total_length));
    541                 }else{
     627
     628                if (total_length) {
     629                        ERROR_PROPAGATE(tcp_queue_received_packet(socket,
     630                            socket_data, packet, fragments, total_length));
     631                } else {
    542632                        total_length = 1;
    543633                }
     634
    544635                socket_data->next_incoming = old_incoming + total_length;
    545636                packet = socket_data->incoming;
    546                 while(packet){
    547                         if(ERROR_OCCURRED(pq_get_order(socket_data->incoming, &order, NULL))){
     637                while (packet) {
     638
     639                        if (ERROR_OCCURRED(pq_get_order(socket_data->incoming,
     640                            &order, NULL))) {
    548641                                // remove the corrupted packet
    549642                                next_packet = pq_detach(packet);
    550                                 if(packet == socket_data->incoming){
     643                                if (packet == socket_data->incoming)
    551644                                        socket_data->incoming = next_packet;
    552                                 }
    553                                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     645                                pq_release_remote(tcp_globals.net_phone,
     646                                    packet_get_id(packet));
    554647                                packet = next_packet;
    555648                                continue;
    556649                        }
     650
    557651                        sequence_number = (uint32_t) order;
    558                         if(IS_IN_INTERVAL_OVERFLOW(sequence_number, old_incoming, socket_data->next_incoming)){
     652                        if (IS_IN_INTERVAL_OVERFLOW(sequence_number,
     653                            old_incoming, socket_data->next_incoming)) {
    559654                                // move to the next
    560655                                packet = pq_next(packet);
    561                         // coninual data?
    562                         }else if(IS_IN_INTERVAL_OVERFLOW(old_incoming, sequence_number, socket_data->next_incoming)){
     656                                // coninual data?
     657                        } else if (IS_IN_INTERVAL_OVERFLOW(old_incoming,
     658                            sequence_number, socket_data->next_incoming)) {
    563659                                // detach the packet
    564660                                next_packet = pq_detach(packet);
    565                                 if(packet == socket_data->incoming){
     661                                if (packet == socket_data->incoming)
    566662                                        socket_data->incoming = next_packet;
    567                                 }
    568663                                // get data length
    569664                                length = packet_get_data_length(packet);
    570665                                new_sequence_number = sequence_number + length;
    571                                 if(length <= 0){
     666                                if (length <= 0) {
    572667                                        // remove the empty packet
    573                                         pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     668                                        pq_release_remote(tcp_globals.net_phone,
     669                                            packet_get_id(packet));
    574670                                        packet = next_packet;
    575671                                        continue;
    576672                                }
    577673                                // exactly following
    578                                 if(sequence_number == socket_data->next_incoming){
     674                                if (sequence_number ==
     675                                    socket_data->next_incoming) {
    579676                                        // queue received data
    580                                         ERROR_PROPAGATE(tcp_queue_received_packet(socket, socket_data, packet, 1, packet_get_data_length(packet)));
    581                                         socket_data->next_incoming = new_sequence_number;
     677                                        ERROR_PROPAGATE(
     678                                            tcp_queue_received_packet(socket,
     679                                            socket_data, packet, 1,
     680                                            packet_get_data_length(packet)));
     681                                        socket_data->next_incoming =
     682                                            new_sequence_number;
    582683                                        packet = next_packet;
    583684                                        continue;
    584                                 // at least partly following data?
    585                                 }else if(IS_IN_INTERVAL_OVERFLOW(sequence_number, socket_data->next_incoming, new_sequence_number)){
    586                                         if(socket_data->next_incoming < new_sequence_number){
    587                                                 length = new_sequence_number - socket_data->next_incoming;
    588                                         }else{
    589                                                 length = socket_data->next_incoming - new_sequence_number;
     685                                        // at least partly following data?
     686                                } else if (IS_IN_INTERVAL_OVERFLOW(
     687                                    sequence_number, socket_data->next_incoming,
     688                                    new_sequence_number)) {
     689                                        if (socket_data->next_incoming <
     690                                            new_sequence_number) {
     691                                                length = new_sequence_number -
     692                                                    socket_data->next_incoming;
     693                                        } else {
     694                                                length =
     695                                                    socket_data->next_incoming -
     696                                                    new_sequence_number;
    590697                                        }
    591                                         if(! ERROR_OCCURRED(packet_trim(packet, length, 0))){
     698                                        if (ERROR_NONE(packet_trim(packet,
     699                                            length, 0))) {
    592700                                                // queue received data
    593                                                 ERROR_PROPAGATE(tcp_queue_received_packet(socket, socket_data, packet, 1, packet_get_data_length(packet)));
    594                                                 socket_data->next_incoming = new_sequence_number;
     701                                                ERROR_PROPAGATE(
     702                                                    tcp_queue_received_packet(
     703                                                    socket, socket_data, packet,
     704                                                    1, packet_get_data_length(
     705                                                    packet)));
     706                                                socket_data->next_incoming =
     707                                                    new_sequence_number;
    595708                                                packet = next_packet;
    596709                                                continue;
     
    598711                                }
    599712                                // remove the duplicit or corrupted packet
    600                                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     713                                pq_release_remote(tcp_globals.net_phone,
     714                                    packet_get_id(packet));
    601715                                packet = next_packet;
    602716                                continue;
    603                         }else{
     717                        } else {
    604718                                break;
    605719                        }
    606720                }
    607         }else if(IS_IN_INTERVAL(socket_data->next_incoming, new_sequence_number, socket_data->next_incoming + socket_data->window)){
     721        } else if (IS_IN_INTERVAL(socket_data->next_incoming,
     722            new_sequence_number,
     723            socket_data->next_incoming + socket_data->window)) {
    608724                printf("in window\n");
    609725                // process acknowledgement
     
    612728                // remove the header
    613729                total_length -= TCP_HEADER_LENGTH(header);
    614                 if(ERROR_OCCURRED(packet_trim(packet, TCP_HEADER_LENGTH(header), 0))){
     730                if (ERROR_OCCURRED(packet_trim(packet,
     731                    TCP_HEADER_LENGTH(header), 0)))
    615732                        return tcp_release_and_return(packet, ERROR_CODE);
    616                 }
    617733
    618734                next_packet = pq_detach(packet);
    619735                length = packet_get_data_length(packet);
    620                 if(ERROR_OCCURRED(pq_add(&socket_data->incoming, packet, new_sequence_number, length))){
     736                if (ERROR_OCCURRED(pq_add(&socket_data->incoming, packet,
     737                    new_sequence_number, length))) {
    621738                        // remove the corrupted packets
    622                         pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    623                         pq_release_remote(tcp_globals.net_phone, packet_get_id(next_packet));
    624                 }else{
    625                         while(next_packet){
     739                        pq_release_remote(tcp_globals.net_phone,
     740                            packet_get_id(packet));
     741                        pq_release_remote(tcp_globals.net_phone,
     742                            packet_get_id(next_packet));
     743                } else {
     744                        while (next_packet) {
    626745                                new_sequence_number += length;
    627746                                tmp_packet = pq_detach(next_packet);
    628747                                length = packet_get_data_length(next_packet);
    629                                 if(ERROR_OCCURRED(pq_set_order(next_packet, new_sequence_number, length))
    630                                         || ERROR_OCCURRED(pq_insert_after(packet, next_packet))){
    631                                         pq_release_remote(tcp_globals.net_phone, packet_get_id(next_packet));
     748                                if (ERROR_OCCURRED(pq_set_order(next_packet,
     749                                    new_sequence_number, length)) ||
     750                                    ERROR_OCCURRED(pq_insert_after(packet,
     751                                    next_packet))) {
     752                                        pq_release_remote(tcp_globals.net_phone,
     753                                            packet_get_id(next_packet));
    632754                                }
    633755                                next_packet = tmp_packet;
    634756                        }
    635757                }
    636         }else{
     758        } else {
    637759                printf("unexpected\n");
    638760                // release duplicite or restricted
     
    641763
    642764        // change state according to the acknowledging incoming fin
    643         if(IS_IN_INTERVAL_OVERFLOW(old_incoming, socket_data->fin_incoming, socket_data->next_incoming)){
    644                 switch(socket_data->state){
    645                         case TCP_SOCKET_FIN_WAIT_1:
    646                         case TCP_SOCKET_FIN_WAIT_2:
    647                         case TCP_SOCKET_CLOSING:
    648                                 socket_data->state = TCP_SOCKET_CLOSING;
    649                                 break;
     765        if (IS_IN_INTERVAL_OVERFLOW(old_incoming, socket_data->fin_incoming,
     766            socket_data->next_incoming)) {
     767                switch (socket_data->state) {
     768                case TCP_SOCKET_FIN_WAIT_1:
     769                case TCP_SOCKET_FIN_WAIT_2:
     770                case TCP_SOCKET_CLOSING:
     771                        socket_data->state = TCP_SOCKET_CLOSING;
     772                        break;
    650773                        //case TCP_ESTABLISHED:
    651                         default:
    652                                 socket_data->state = TCP_SOCKET_CLOSE_WAIT;
    653                                 break;
     774                default:
     775                        socket_data->state = TCP_SOCKET_CLOSE_WAIT;
     776                        break;
    654777                }
    655778        }
    656779
    657780        packet = tcp_get_packets_to_send(socket, socket_data);
    658         if(! packet){
     781        if (!packet) {
    659782                // create the notification packet
    660                 ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket, socket_data, 0, 0));
    661                 ERROR_PROPAGATE(tcp_queue_prepare_packet(socket, socket_data, packet, 1));
    662                 packet = tcp_send_prepare_packet(socket, socket_data, packet, 1, socket_data->last_outgoing + 1);
    663         }
     783                ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket,
     784                    socket_data, 0, 0));
     785                ERROR_PROPAGATE(tcp_queue_prepare_packet(socket, socket_data,
     786                    packet, 1));
     787                packet = tcp_send_prepare_packet(socket, socket_data, packet, 1,
     788                    socket_data->last_outgoing + 1);
     789        }
     790
    664791        fibril_rwlock_write_unlock(socket_data->local_lock);
     792
    665793        // send the packet
    666794        tcp_send_packets(socket_data->device_id, packet);
     795
    667796        return EOK;
    668797}
    669798
    670 int tcp_queue_received_packet(socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, int fragments, size_t total_length){
     799int
     800tcp_queue_received_packet(socket_core_ref socket,
     801    tcp_socket_data_ref socket_data, packet_t packet, int fragments,
     802    size_t total_length)
     803{
    671804        ERROR_DECLARE;
    672805
     
    681814
    682815        // queue the received packet
    683         if(ERROR_OCCURRED(dyn_fifo_push(&socket->received, packet_get_id(packet), SOCKET_MAX_RECEIVED_SIZE))
    684             || ERROR_OCCURRED(tl_get_ip_packet_dimension(tcp_globals.ip_phone, &tcp_globals.dimensions, socket_data->device_id, &packet_dimension))){
     816        if (ERROR_OCCURRED(dyn_fifo_push(&socket->received,
     817            packet_get_id(packet), SOCKET_MAX_RECEIVED_SIZE)) ||
     818            ERROR_OCCURRED(tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     819            &tcp_globals.dimensions, socket_data->device_id,
     820            &packet_dimension))) {
    685821                return tcp_release_and_return(packet, ERROR_CODE);
    686822        }
     
    690826
    691827        // notify the destination socket
    692         async_msg_5(socket->phone, NET_SOCKET_RECEIVED, (ipcarg_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);
     828        async_msg_5(socket->phone, NET_SOCKET_RECEIVED,
     829            (ipcarg_t) socket->socket_id,
     830            ((packet_dimension->content < socket_data->data_fragment_size) ?
     831            packet_dimension->content : socket_data->data_fragment_size), 0, 0,
     832            (ipcarg_t) fragments);
     833
    693834        return EOK;
    694835}
    695836
    696 int tcp_process_syn_sent(socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet){
     837int
     838tcp_process_syn_sent(socket_core_ref socket, tcp_socket_data_ref socket_data,
     839    tcp_header_ref header, packet_t packet)
     840{
    697841        ERROR_DECLARE;
    698842
     
    705849        assert(packet);
    706850
    707         if(header->synchronize){
    708                 // process acknowledgement
    709                 tcp_process_acknowledgement(socket, socket_data, header);
    710 
    711                 socket_data->next_incoming = ntohl(header->sequence_number) + 1;
    712                 // release additional packets
    713                 next_packet = pq_detach(packet);
    714                 if(next_packet){
    715                         pq_release_remote(tcp_globals.net_phone, packet_get_id(next_packet));
    716                 }
    717                 // trim if longer than the header
    718                 if((packet_get_data_length(packet) > sizeof(*header))
    719                         && ERROR_OCCURRED(packet_trim(packet, 0, packet_get_data_length(packet) - sizeof(*header)))){
    720                         return tcp_release_and_return(packet, ERROR_CODE);
    721                 }
    722                 tcp_prepare_operation_header(socket, socket_data, header, 0, 0);
    723                 fibril_mutex_lock(&socket_data->operation.mutex);
    724                 socket_data->operation.result = tcp_queue_packet(socket, socket_data, packet, 1);
    725                 if(socket_data->operation.result == EOK){
    726                         socket_data->state = TCP_SOCKET_ESTABLISHED;
    727                         packet = tcp_get_packets_to_send(socket, socket_data);
    728                         if(packet){
    729                                 fibril_rwlock_write_unlock(socket_data->local_lock);
    730                                 // send the packet
    731                                 tcp_send_packets(socket_data->device_id, packet);
    732                                 // signal the result
    733                                 fibril_condvar_signal(&socket_data->operation.condvar);
    734                                 fibril_mutex_unlock(&socket_data->operation.mutex);
    735                                 return EOK;
    736                         }
    737                 }
    738                 fibril_mutex_unlock(&socket_data->operation.mutex);
    739         }
     851        if (!header->synchronize)
     852                return tcp_release_and_return(packet, EINVAL);
     853       
     854        // process acknowledgement
     855        tcp_process_acknowledgement(socket, socket_data, header);
     856
     857        socket_data->next_incoming = ntohl(header->sequence_number) + 1;
     858        // release additional packets
     859        next_packet = pq_detach(packet);
     860        if (next_packet) {
     861                pq_release_remote(tcp_globals.net_phone,
     862                    packet_get_id(next_packet));
     863        }
     864        // trim if longer than the header
     865        if ((packet_get_data_length(packet) > sizeof(*header)) &&
     866            ERROR_OCCURRED(packet_trim(packet, 0,
     867            packet_get_data_length(packet) - sizeof(*header)))) {
     868                return tcp_release_and_return(packet, ERROR_CODE);
     869        }
     870        tcp_prepare_operation_header(socket, socket_data, header, 0, 0);
     871        fibril_mutex_lock(&socket_data->operation.mutex);
     872        socket_data->operation.result = tcp_queue_packet(socket, socket_data,
     873            packet, 1);
     874        if (socket_data->operation.result == EOK) {
     875                socket_data->state = TCP_SOCKET_ESTABLISHED;
     876                packet = tcp_get_packets_to_send(socket, socket_data);
     877                if (packet) {
     878                        fibril_rwlock_write_unlock( socket_data->local_lock);
     879                        // send the packet
     880                        tcp_send_packets(socket_data->device_id, packet);
     881                        // signal the result
     882                        fibril_condvar_signal( &socket_data->operation.condvar);
     883                        fibril_mutex_unlock( &socket_data->operation.mutex);
     884                        return EOK;
     885                }
     886        }
     887        fibril_mutex_unlock(&socket_data->operation.mutex);
    740888        return tcp_release_and_return(packet, EINVAL);
    741889}
    742890
    743 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){
     891int
     892tcp_process_listen(socket_core_ref listening_socket,
     893    tcp_socket_data_ref listening_socket_data, tcp_header_ref header,
     894    packet_t packet, struct sockaddr *src, struct sockaddr *dest,
     895    size_t addrlen)
     896{
    744897        ERROR_DECLARE;
    745898
     
    757910        assert(packet);
    758911
    759 //      printf("syn %d\n", header->synchronize);
    760         if(header->synchronize){
    761                 socket_data = (tcp_socket_data_ref) malloc(sizeof(*socket_data));
    762                 if(! socket_data){
    763                         return tcp_release_and_return(packet, ENOMEM);
    764                 }else{
    765                         tcp_initialize_socket_data(socket_data);
    766                         socket_data->local_lock = listening_socket_data->local_lock;
    767                         socket_data->local_sockets = listening_socket_data->local_sockets;
    768                         socket_data->listening_socket_id = listening_socket->socket_id;
    769 
    770                         socket_data->next_incoming = ntohl(header->sequence_number);
    771                         socket_data->treshold = socket_data->next_incoming + ntohs(header->window);
    772 
    773                         socket_data->addrlen = addrlen;
    774                         socket_data->addr = malloc(socket_data->addrlen);
    775                         if(! socket_data->addr){
    776                                 free(socket_data);
    777                                 return tcp_release_and_return(packet, ENOMEM);
    778                         }
    779                         memcpy(socket_data->addr, src, socket_data->addrlen);
    780 
    781                         socket_data->dest_port = ntohs(header->source_port);
    782                         if(ERROR_OCCURRED(tl_set_address_port(socket_data->addr, socket_data->addrlen, socket_data->dest_port))){
    783                                 free(socket_data->addr);
    784                                 free(socket_data);
    785                                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    786                                 return ERROR_CODE;
    787                         }
    788 
    789 //                      printf("addr %p\n", socket_data->addr, socket_data->addrlen);
    790                         // create a socket
    791                         socket_id = -1;
    792                         if(ERROR_OCCURRED(socket_create(socket_data->local_sockets, listening_socket->phone, socket_data, &socket_id))){
    793                                 free(socket_data->addr);
    794                                 free(socket_data);
    795                                 return tcp_release_and_return(packet, ERROR_CODE);
    796                         }
    797 
    798                         printf("new_sock %d\n", socket_id);
    799                         socket_data->pseudo_header = listening_socket_data->pseudo_header;
    800                         socket_data->headerlen = listening_socket_data->headerlen;
    801                         listening_socket_data->pseudo_header = NULL;
    802                         listening_socket_data->headerlen = 0;
    803 
    804                         fibril_rwlock_write_unlock(socket_data->local_lock);
    805 //                      printf("list lg\n");
    806                         fibril_rwlock_write_lock(&tcp_globals.lock);
    807 //                      printf("list locked\n");
    808                         // find the destination socket
    809                         listening_socket = socket_port_find(&tcp_globals.sockets, listening_port, SOCKET_MAP_KEY_LISTENING, 0);
    810                         if((! listening_socket) || (listening_socket->socket_id != listening_socket_id)){
    811                                 fibril_rwlock_write_unlock(&tcp_globals.lock);
    812                                 // a shadow may remain until app hangs up
    813                                 return tcp_release_and_return(packet, EOK/*ENOTSOCK*/);
    814                         }
    815 //                      printf("port %d\n", listening_socket->port);
    816                         listening_socket_data = (tcp_socket_data_ref) listening_socket->specific_data;
    817                         assert(listening_socket_data);
    818 
    819 //                      printf("list ll\n");
    820                         fibril_rwlock_write_lock(listening_socket_data->local_lock);
    821 //                      printf("list locked\n");
    822 
    823                         socket = socket_cores_find(listening_socket_data->local_sockets, socket_id);
    824                         if(! socket){
    825                                 // where is the socket?!?
    826                                 fibril_rwlock_write_unlock(&tcp_globals.lock);
    827                                 return ENOTSOCK;
    828                         }
    829                         socket_data = (tcp_socket_data_ref) socket->specific_data;
    830                         assert(socket_data);
    831 
    832 //                      uint8_t * data = socket_data->addr;
    833 //                      printf("addr %d of %x %x %x %x-%x %x %x %x-%x %x %x %x-%x %x %x %x\n", socket_data->addrlen, data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7], data[8], data[9], data[10], data[11], data[12], data[13], data[14], data[15]);
    834 
    835                         ERROR_CODE = socket_port_add(&tcp_globals.sockets, listening_port, socket, (const char *) socket_data->addr, socket_data->addrlen);
    836                         assert(socket == socket_port_find(&tcp_globals.sockets, listening_port, (const char *) socket_data->addr, socket_data->addrlen));
    837                         //ERROR_CODE = socket_bind_free_port(&tcp_globals.sockets, socket, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END, tcp_globals.last_used_port);
    838                         //tcp_globals.last_used_port = socket->port;
    839 //                      printf("bound %d\n", socket->port);
    840                         fibril_rwlock_write_unlock(&tcp_globals.lock);
    841                         if(ERROR_CODE != EOK){
    842                                 socket_destroy(tcp_globals.net_phone, socket->socket_id, socket_data->local_sockets, &tcp_globals.sockets, tcp_free_socket_data);
    843                                 return tcp_release_and_return(packet, ERROR_CODE);
    844                         }
    845 
    846                         socket_data->state = TCP_SOCKET_LISTEN;
    847                         socket_data->next_incoming = ntohl(header->sequence_number) + 1;
    848                         // release additional packets
    849                         next_packet = pq_detach(packet);
    850                         if(next_packet){
    851                                 pq_release_remote(tcp_globals.net_phone, packet_get_id(next_packet));
    852                         }
    853                         // trim if longer than the header
    854                         if((packet_get_data_length(packet) > sizeof(*header))
    855                                 && ERROR_OCCURRED(packet_trim(packet, 0, packet_get_data_length(packet) - sizeof(*header)))){
    856                                 socket_destroy(tcp_globals.net_phone, socket->socket_id, socket_data->local_sockets, &tcp_globals.sockets, tcp_free_socket_data);
    857                                 return tcp_release_and_return(packet, ERROR_CODE);
    858                         }
    859                         tcp_prepare_operation_header(socket, socket_data, header, 1, 0);
    860                         if(ERROR_OCCURRED(tcp_queue_packet(socket, socket_data, packet, 1))){
    861                                 socket_destroy(tcp_globals.net_phone, socket->socket_id, socket_data->local_sockets, &tcp_globals.sockets, tcp_free_socket_data);
    862                                 return ERROR_CODE;
    863                         }
    864                         packet = tcp_get_packets_to_send(socket, socket_data);
    865 //                      printf("send %d\n", packet_get_id(packet));
    866                         if(! packet){
    867                                 socket_destroy(tcp_globals.net_phone, socket->socket_id, socket_data->local_sockets, &tcp_globals.sockets, tcp_free_socket_data);
    868                                 return EINVAL;
    869                         }else{
    870                                 socket_data->state = TCP_SOCKET_SYN_RECEIVED;
    871 //                              printf("unlock\n");
    872                                 fibril_rwlock_write_unlock(socket_data->local_lock);
    873                                 // send the packet
    874                                 tcp_send_packets(socket_data->device_id, packet);
    875                                 return EOK;
    876                         }
    877                 }
    878         }
    879         return tcp_release_and_return(packet, EINVAL);
    880 }
    881 
    882 int tcp_process_syn_received(socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet){
     912        if (!header->synchronize)
     913                return tcp_release_and_return(packet, EINVAL);
     914
     915        socket_data = (tcp_socket_data_ref) malloc(sizeof(*socket_data));
     916        if (!socket_data)
     917                return tcp_release_and_return(packet, ENOMEM);
     918
     919        tcp_initialize_socket_data(socket_data);
     920        socket_data->local_lock = listening_socket_data->local_lock;
     921        socket_data->local_sockets = listening_socket_data->local_sockets;
     922        socket_data->listening_socket_id = listening_socket->socket_id;
     923        socket_data->next_incoming = ntohl(header->sequence_number);
     924        socket_data->treshold = socket_data->next_incoming +
     925            ntohs(header->window);
     926        socket_data->addrlen = addrlen;
     927        socket_data->addr = malloc(socket_data->addrlen);
     928        if (!socket_data->addr) {
     929                free(socket_data);
     930                return tcp_release_and_return(packet, ENOMEM);
     931        }
     932        memcpy(socket_data->addr, src, socket_data->addrlen);
     933        socket_data->dest_port = ntohs(header->source_port);
     934        if (ERROR_OCCURRED(tl_set_address_port(socket_data->addr,
     935            socket_data->addrlen, socket_data->dest_port))) {
     936                free(socket_data->addr);
     937                free(socket_data);
     938                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     939                return ERROR_CODE;
     940        }
     941
     942        // create a socket
     943        socket_id = -1;
     944        if (ERROR_OCCURRED(socket_create(socket_data->local_sockets,
     945            listening_socket->phone, socket_data, &socket_id))) {
     946                free(socket_data->addr);
     947                free(socket_data);
     948                return tcp_release_and_return(packet, ERROR_CODE);
     949        }
     950
     951        printf("new_sock %d\n", socket_id);
     952        socket_data->pseudo_header = listening_socket_data->pseudo_header;
     953        socket_data->headerlen = listening_socket_data->headerlen;
     954        listening_socket_data->pseudo_header = NULL;
     955        listening_socket_data->headerlen = 0;
     956
     957        fibril_rwlock_write_unlock(socket_data->local_lock);
     958        fibril_rwlock_write_lock(&tcp_globals.lock);
     959
     960        // find the destination socket
     961        listening_socket = socket_port_find(&tcp_globals.sockets,
     962            listening_port, SOCKET_MAP_KEY_LISTENING, 0);
     963        if ((!listening_socket) ||
     964            (listening_socket->socket_id != listening_socket_id)) {
     965                fibril_rwlock_write_unlock(&tcp_globals.lock);
     966                // a shadow may remain until app hangs up
     967                return tcp_release_and_return(packet, EOK /*ENOTSOCK*/);
     968        }
     969        listening_socket_data =
     970            (tcp_socket_data_ref) listening_socket->specific_data;
     971        assert(listening_socket_data);
     972
     973        fibril_rwlock_write_lock(listening_socket_data->local_lock);
     974
     975        socket = socket_cores_find(listening_socket_data->local_sockets,
     976            socket_id);
     977        if (!socket) {
     978                // where is the socket?!?
     979                fibril_rwlock_write_unlock(&tcp_globals.lock);
     980                return ENOTSOCK;
     981        }
     982        socket_data = (tcp_socket_data_ref) socket->specific_data;
     983        assert(socket_data);
     984
     985        ERROR_CODE = socket_port_add(&tcp_globals.sockets, listening_port,
     986            socket, (const char *) socket_data->addr, socket_data->addrlen);
     987        assert(socket == socket_port_find(&tcp_globals.sockets, listening_port,
     988            (const char *) socket_data->addr, socket_data->addrlen));
     989
     990//      ERROR_CODE = socket_bind_free_port(&tcp_globals.sockets, socket,
     991//          TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
     992//          tcp_globals.last_used_port);
     993//      tcp_globals.last_used_port = socket->port;
     994        fibril_rwlock_write_unlock(&tcp_globals.lock);
     995        if (ERROR_CODE != EOK) {
     996                socket_destroy(tcp_globals.net_phone, socket->socket_id,
     997                    socket_data->local_sockets, &tcp_globals.sockets,
     998                    tcp_free_socket_data);
     999                return tcp_release_and_return(packet, ERROR_CODE);
     1000        }
     1001
     1002        socket_data->state = TCP_SOCKET_LISTEN;
     1003        socket_data->next_incoming = ntohl(header->sequence_number) + 1;
     1004
     1005        // release additional packets
     1006        next_packet = pq_detach(packet);
     1007        if (next_packet) {
     1008                pq_release_remote(tcp_globals.net_phone,
     1009                    packet_get_id(next_packet));
     1010        }
     1011
     1012        // trim if longer than the header
     1013        if ((packet_get_data_length(packet) > sizeof(*header)) &&
     1014            ERROR_OCCURRED(packet_trim(packet, 0,
     1015            packet_get_data_length(packet) - sizeof(*header)))) {
     1016                socket_destroy(tcp_globals.net_phone, socket->socket_id,
     1017                    socket_data->local_sockets, &tcp_globals.sockets,
     1018                    tcp_free_socket_data);
     1019                return tcp_release_and_return(packet, ERROR_CODE);
     1020        }
     1021
     1022        tcp_prepare_operation_header(socket, socket_data, header, 1, 0);
     1023
     1024        if (ERROR_OCCURRED(tcp_queue_packet(socket, socket_data, packet, 1))) {
     1025                socket_destroy(tcp_globals.net_phone, socket->socket_id,
     1026                    socket_data->local_sockets, &tcp_globals.sockets,
     1027                    tcp_free_socket_data);
     1028                return ERROR_CODE;
     1029        }
     1030
     1031        packet = tcp_get_packets_to_send(socket, socket_data);
     1032        if (!packet) {
     1033                socket_destroy(tcp_globals.net_phone, socket->socket_id,
     1034                    socket_data->local_sockets, &tcp_globals.sockets,
     1035                    tcp_free_socket_data);
     1036                return EINVAL;
     1037        }
     1038
     1039        socket_data->state = TCP_SOCKET_SYN_RECEIVED;
     1040        fibril_rwlock_write_unlock(socket_data->local_lock);
     1041
     1042        // send the packet
     1043        tcp_send_packets(socket_data->device_id, packet);
     1044
     1045        return EOK;
     1046}
     1047
     1048int
     1049tcp_process_syn_received(socket_core_ref socket,
     1050    tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet)
     1051{
    8831052        ERROR_DECLARE;
    8841053
     
    8921061        assert(packet);
    8931062
    894         printf("syn_rec\n");
    895         if(header->acknowledge){
    896                 // process acknowledgement
    897                 tcp_process_acknowledgement(socket, socket_data, header);
    898 
    899                 socket_data->next_incoming = ntohl(header->sequence_number);// + 1;
    900                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    901                 socket_data->state = TCP_SOCKET_ESTABLISHED;
    902                 listening_socket = socket_cores_find(socket_data->local_sockets, socket_data->listening_socket_id);
    903                 if(listening_socket){
    904                         listening_socket_data = (tcp_socket_data_ref) listening_socket->specific_data;
    905                         assert(listening_socket_data);
    906 
    907                         // queue the received packet
    908                         if(! ERROR_OCCURRED(dyn_fifo_push(&listening_socket->accepted, (-1 * socket->socket_id), listening_socket_data->backlog))){
    909                                 // notify the destination socket
    910                                 async_msg_5(socket->phone, NET_SOCKET_ACCEPTED, (ipcarg_t) listening_socket->socket_id, socket_data->data_fragment_size, TCP_HEADER_SIZE, 0, (ipcarg_t) socket->socket_id);
    911                                 fibril_rwlock_write_unlock(socket_data->local_lock);
    912                                 return EOK;
    913                         }
    914                 }
    915                 // send FIN
    916                 socket_data->state = TCP_SOCKET_FIN_WAIT_1;
    917 
    918                 // create the notification packet
    919                 ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket, socket_data, 0, 1));
    920 
     1063        if (!header->acknowledge)
     1064                return tcp_release_and_return(packet, EINVAL);
     1065
     1066        // process acknowledgement
     1067        tcp_process_acknowledgement(socket, socket_data, header);
     1068
     1069        socket_data->next_incoming = ntohl(header->sequence_number);    // + 1;
     1070        pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
     1071        socket_data->state = TCP_SOCKET_ESTABLISHED;
     1072        listening_socket = socket_cores_find(socket_data->local_sockets,
     1073            socket_data->listening_socket_id);
     1074        if (listening_socket) {
     1075                listening_socket_data =
     1076                    (tcp_socket_data_ref) listening_socket->specific_data;
     1077                assert(listening_socket_data);
     1078
     1079                // queue the received packet
     1080                if (ERROR_NONE(dyn_fifo_push(&listening_socket->accepted,
     1081                    (-1 * socket->socket_id),
     1082                    listening_socket_data->backlog))) {
     1083
     1084                        // notify the destination socket
     1085                        async_msg_5(socket->phone, NET_SOCKET_ACCEPTED,
     1086                            (ipcarg_t) listening_socket->socket_id,
     1087                            socket_data->data_fragment_size, TCP_HEADER_SIZE,
     1088                            0, (ipcarg_t) socket->socket_id);
     1089
     1090                        fibril_rwlock_write_unlock(socket_data->local_lock);
     1091                        return EOK;
     1092                }
     1093        }
     1094        // send FIN
     1095        socket_data->state = TCP_SOCKET_FIN_WAIT_1;
     1096
     1097        // create the notification packet
     1098        ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket,
     1099            socket_data, 0, 1));
     1100
     1101        // send the packet
     1102        ERROR_PROPAGATE(tcp_queue_packet(socket, socket_data, packet, 1));
     1103
     1104        // flush packets
     1105        packet = tcp_get_packets_to_send(socket, socket_data);
     1106        fibril_rwlock_write_unlock(socket_data->local_lock);
     1107        if (packet) {
    9211108                // send the packet
    922                 ERROR_PROPAGATE(tcp_queue_packet(socket, socket_data, packet, 1));
    923 
    924                 // flush packets
    925                 packet = tcp_get_packets_to_send(socket, socket_data);
    926                 fibril_rwlock_write_unlock(socket_data->local_lock);
    927                 if(packet){
    928                         // send the packet
    929                         tcp_send_packets(socket_data->device_id, packet);
    930                 }
    931                 return EOK;
    932         }else{
    933                 return tcp_release_and_return(packet, EINVAL);
    934         }
    935         return EINVAL;
    936 }
    937 
    938 void tcp_process_acknowledgement(socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header){
     1109                tcp_send_packets(socket_data->device_id, packet);
     1110        }
     1111
     1112        return EOK;
     1113}
     1114
     1115void
     1116tcp_process_acknowledgement(socket_core_ref socket,
     1117    tcp_socket_data_ref socket_data, tcp_header_ref header)
     1118{
    9391119        size_t number;
    9401120        size_t length;
     
    9491129        assert(header);
    9501130
    951         if(header->acknowledge){
    952                 number = ntohl(header->acknowledgement_number);
    953                 // if more data acknowledged
    954                 if(number != socket_data->expected){
    955                         old = socket_data->expected;
    956                         if(IS_IN_INTERVAL_OVERFLOW(old, socket_data->fin_outgoing, number)){
    957                                 switch(socket_data->state){
    958                                         case TCP_SOCKET_FIN_WAIT_1:
    959                                                 socket_data->state = TCP_SOCKET_FIN_WAIT_2;
    960                                                 break;
    961                                         case TCP_SOCKET_LAST_ACK:
    962                                         case TCP_SOCKET_CLOSING:
    963                                                 // fin acknowledged - release the socket in another fibril
    964                                                 tcp_prepare_timeout(tcp_release_after_timeout, socket, socket_data, 0, TCP_SOCKET_TIME_WAIT, NET_DEFAULT_TCP_TIME_WAIT_TIMEOUT, true);
    965                                                 break;
    966                                         default:
    967                                                 break;
    968                                 }
     1131        if (!header->acknowledge)
     1132                return;
     1133
     1134        number = ntohl(header->acknowledgement_number);
     1135        // if more data acknowledged
     1136        if (number != socket_data->expected) {
     1137                old = socket_data->expected;
     1138                if (IS_IN_INTERVAL_OVERFLOW(old, socket_data->fin_outgoing,
     1139                    number)) {
     1140                        switch (socket_data->state) {
     1141                        case TCP_SOCKET_FIN_WAIT_1:
     1142                                socket_data->state = TCP_SOCKET_FIN_WAIT_2;
     1143                                break;
     1144                        case TCP_SOCKET_LAST_ACK:
     1145                        case TCP_SOCKET_CLOSING:
     1146                                // fin acknowledged - release the socket in
     1147                                // another fibril
     1148                                tcp_prepare_timeout(tcp_release_after_timeout,
     1149                                    socket, socket_data, 0,
     1150                                    TCP_SOCKET_TIME_WAIT,
     1151                                    NET_DEFAULT_TCP_TIME_WAIT_TIMEOUT, true);
     1152                                break;
     1153                        default:
     1154                                break;
    9691155                        }
    970                         // update the treshold if higher than set
    971                         if(number + ntohs(header->window) > socket_data->expected + socket_data->treshold){
    972                                 socket_data->treshold = number + ntohs(header->window) - socket_data->expected;
    973                         }
    974                         // set new expected sequence number
    975                         socket_data->expected = number;
     1156                }
     1157                // update the treshold if higher than set
     1158                if (number + ntohs(header->window) >
     1159                    socket_data->expected + socket_data->treshold) {
     1160                        socket_data->treshold = number + ntohs(header->window) -
     1161                            socket_data->expected;
     1162                }
     1163                // set new expected sequence number
     1164                socket_data->expected = number;
     1165                socket_data->expected_count = 1;
     1166                packet = socket_data->outgoing;
     1167                while (pq_get_order(packet, &number, &length) == EOK) {
     1168                        if (IS_IN_INTERVAL_OVERFLOW((uint32_t) old,
     1169                            (uint32_t) (number + length),
     1170                            (uint32_t) socket_data->expected)) {
     1171                                next = pq_detach(packet);
     1172                                if (packet == socket_data->outgoing)
     1173                                        socket_data->outgoing = next;
     1174
     1175                                // add to acknowledged or release
     1176                                if (pq_add(&acknowledged, packet, 0, 0) != EOK)
     1177                                        pq_release_remote(tcp_globals.net_phone,
     1178                                            packet_get_id(packet));
     1179                                packet = next;
     1180                        } else if (old < socket_data->expected)
     1181                                break;
     1182                }
     1183                // release acknowledged
     1184                if (acknowledged) {
     1185                        pq_release_remote(tcp_globals.net_phone,
     1186                            packet_get_id(acknowledged));
     1187                }
     1188                return;
     1189                // if the same as the previous time
     1190        }
     1191        if (number == socket_data->expected) {
     1192                // increase the counter
     1193                ++socket_data->expected_count;
     1194                if (socket_data->expected_count == TCP_FAST_RETRANSMIT_COUNT) {
    9761195                        socket_data->expected_count = 1;
    977                         packet = socket_data->outgoing;
    978                         while(pq_get_order(packet, &number, &length) == EOK){
    979                                 if(IS_IN_INTERVAL_OVERFLOW((uint32_t) old, (uint32_t)(number + length), (uint32_t) socket_data->expected)){
    980                                         next = pq_detach(packet);
    981                                         if(packet == socket_data->outgoing){
    982                                                 socket_data->outgoing = next;
    983                                         }
    984                                         // add to acknowledged or release
    985                                         if(pq_add(&acknowledged, packet, 0, 0) != EOK){
    986                                                 pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    987                                         }
    988                                         packet = next;
    989                                 }else if(old < socket_data->expected){
    990                                         break;
    991                                 }
    992                         }
    993                         // release acknowledged
    994                         if(acknowledged){
    995                                 pq_release_remote(tcp_globals.net_phone, packet_get_id(acknowledged));
    996                         }
    997                         return;
    998                 // if the same as the previous time
    999                 }else if(number == socket_data->expected){
    1000                         // increase the counter
    1001                         ++ socket_data->expected_count;
    1002                         if(socket_data->expected_count == TCP_FAST_RETRANSMIT_COUNT){
    1003                                 socket_data->expected_count = 1;
    1004                                 // TODO retransmit lock
    1005                                 //tcp_retransmit_packet(socket, socket_data, number);
    1006                         }
    1007                 }
    1008         }
    1009 }
    1010 
    1011 int tcp_message_standalone(ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count){
     1196                        // TODO retransmit lock
     1197                        //tcp_retransmit_packet(socket, socket_data, number);
     1198                }
     1199        }
     1200}
     1201
     1202int tcp_message_standalone(ipc_callid_t callid, ipc_call_t * call,
     1203    ipc_call_t * answer, int *answer_count)
     1204{
    10121205        ERROR_DECLARE;
    10131206
     
    10191212
    10201213        *answer_count = 0;
    1021         switch(IPC_GET_METHOD(*call)){
    1022                 case NET_TL_RECEIVED:
    1023                         //fibril_rwlock_read_lock(&tcp_globals.lock);
    1024                         if(! ERROR_OCCURRED(packet_translate_remote(tcp_globals.net_phone, &packet, IPC_GET_PACKET(call)))){
    1025                                 ERROR_CODE = tcp_received_msg(IPC_GET_DEVICE(call), packet, SERVICE_TCP, IPC_GET_ERROR(call));
    1026                         }
    1027                         //fibril_rwlock_read_unlock(&tcp_globals.lock);
    1028                         return ERROR_CODE;
    1029                 case IPC_M_CONNECT_TO_ME:
    1030                         return tcp_process_client_messages(callid, * call);
    1031         }
     1214        switch (IPC_GET_METHOD(*call)) {
     1215        case NET_TL_RECEIVED:
     1216                //fibril_rwlock_read_lock(&tcp_globals.lock);
     1217                if (ERROR_NONE(packet_translate_remote(tcp_globals.net_phone,
     1218                    &packet, IPC_GET_PACKET(call)))) {
     1219                        ERROR_CODE = tcp_received_msg(IPC_GET_DEVICE(call),
     1220                            packet, SERVICE_TCP, IPC_GET_ERROR(call));
     1221                }
     1222                //fibril_rwlock_read_unlock(&tcp_globals.lock);
     1223                return ERROR_CODE;
     1224
     1225        case IPC_M_CONNECT_TO_ME:
     1226                return tcp_process_client_messages(callid, *call);
     1227        }
     1228
    10321229        return ENOTSUP;
    10331230}
    10341231
    1035 void tcp_refresh_socket_data(tcp_socket_data_ref socket_data){
     1232void tcp_refresh_socket_data(tcp_socket_data_ref socket_data)
     1233{
    10361234        assert(socket_data);
    10371235
     
    10481246}
    10491247
    1050 void tcp_initialize_socket_data(tcp_socket_data_ref socket_data){
     1248void tcp_initialize_socket_data(tcp_socket_data_ref socket_data)
     1249{
    10511250        assert(socket_data);
    10521251
     
    10571256}
    10581257
    1059 int tcp_process_client_messages(ipc_callid_t callid, ipc_call_t call){
     1258int tcp_process_client_messages(ipc_callid_t callid, ipc_call_t call)
     1259{
    10601260        int res;
    10611261        bool keep_on_going = true;
    10621262        socket_cores_t local_sockets;
    10631263        int app_phone = IPC_GET_PHONE(&call);
    1064         struct sockaddr * addr;
     1264        struct sockaddr *addr;
    10651265        int socket_id;
    10661266        size_t addrlen;
     
    10831283        fibril_rwlock_initialize(&lock);
    10841284
    1085         while(keep_on_going){
     1285        while (keep_on_going) {
    10861286
    10871287                // answer the call
    10881288                answer_call(callid, res, &answer, answer_count);
    1089 
    10901289                // refresh data
    10911290                refresh_answer(&answer, &answer_count);
    1092 
    10931291                // get the next call
    10941292                callid = async_get_call(&call);
    10951293
    10961294                // process the call
    1097                 switch(IPC_GET_METHOD(call)){
    1098                         case IPC_M_PHONE_HUNGUP:
    1099                                 keep_on_going = false;
    1100                                 res = EHANGUP;
     1295                switch (IPC_GET_METHOD(call)) {
     1296                case IPC_M_PHONE_HUNGUP:
     1297                        keep_on_going = false;
     1298                        res = EHANGUP;
     1299                        break;
     1300
     1301                case NET_SOCKET:
     1302                        socket_data =
     1303                            (tcp_socket_data_ref) malloc(sizeof(*socket_data));
     1304                        if (!socket_data) {
     1305                                res = ENOMEM;
    11011306                                break;
    1102                         case NET_SOCKET:
    1103                                 socket_data = (tcp_socket_data_ref) malloc(sizeof(*socket_data));
    1104                                 if(! socket_data){
    1105                                         res = ENOMEM;
    1106                                 }else{
    1107                                         tcp_initialize_socket_data(socket_data);
    1108                                         socket_data->local_lock = &lock;
    1109                                         socket_data->local_sockets = &local_sockets;
    1110                                         fibril_rwlock_write_lock(&lock);
    1111                                         socket_id = SOCKET_GET_SOCKET_ID(call);
    1112                                         res = socket_create(&local_sockets, app_phone, socket_data, &socket_id);
    1113                                         SOCKET_SET_SOCKET_ID(answer, socket_id);
    1114                                         fibril_rwlock_write_unlock(&lock);
    1115                                         if(res == EOK){
    1116                                                 if (tl_get_ip_packet_dimension(tcp_globals.ip_phone, &tcp_globals.dimensions, DEVICE_INVALID_ID, &packet_dimension) == EOK){
    1117                                                         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, ((packet_dimension->content < socket_data->data_fragment_size) ? packet_dimension->content : socket_data->data_fragment_size));
    1118                                                 }
    1119 //                                              SOCKET_SET_DATA_FRAGMENT_SIZE(answer, MAX_TCP_FRAGMENT_SIZE);
    1120                                                 SOCKET_SET_HEADER_SIZE(answer, TCP_HEADER_SIZE);
    1121                                                 answer_count = 3;
    1122                                         }else{
    1123                                                 free(socket_data);
    1124                                         }
     1307                        }
     1308                       
     1309                        tcp_initialize_socket_data(socket_data);
     1310                        socket_data->local_lock = &lock;
     1311                        socket_data->local_sockets = &local_sockets;
     1312                        fibril_rwlock_write_lock(&lock);
     1313                        socket_id = SOCKET_GET_SOCKET_ID(call);
     1314                        res = socket_create(&local_sockets, app_phone,
     1315                            socket_data, &socket_id);
     1316                        SOCKET_SET_SOCKET_ID(answer, socket_id);
     1317                        fibril_rwlock_write_unlock(&lock);
     1318                        if (res != EOK) {
     1319                                free(socket_data);
     1320                                break;
     1321                        }
     1322                        if (tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     1323                            &tcp_globals.dimensions, DEVICE_INVALID_ID,
     1324                            &packet_dimension) == EOK) {
     1325                                SOCKET_SET_DATA_FRAGMENT_SIZE(answer,
     1326                                    ((packet_dimension->content <
     1327                                    socket_data->data_fragment_size) ?
     1328                                    packet_dimension->content :
     1329                                    socket_data->data_fragment_size));
     1330                        }
     1331//                      SOCKET_SET_DATA_FRAGMENT_SIZE(answer, MAX_TCP_FRAGMENT_SIZE);
     1332                        SOCKET_SET_HEADER_SIZE(answer, TCP_HEADER_SIZE);
     1333                        answer_count = 3;
     1334                        break;
     1335
     1336                case NET_SOCKET_BIND:
     1337                        res = data_receive((void **) &addr, &addrlen);
     1338                        if (res != EOK)
     1339                                break;
     1340                        fibril_rwlock_write_lock(&tcp_globals.lock);
     1341                        fibril_rwlock_write_lock(&lock);
     1342                        res = socket_bind(&local_sockets, &tcp_globals.sockets,
     1343                            SOCKET_GET_SOCKET_ID(call), addr, addrlen,
     1344                            TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
     1345                            tcp_globals.last_used_port);
     1346                        if (res == EOK) {
     1347                                socket = socket_cores_find(&local_sockets,
     1348                                    SOCKET_GET_SOCKET_ID(call));
     1349                                if (socket) {
     1350                                        socket_data = (tcp_socket_data_ref)
     1351                                            socket->specific_data;
     1352                                        assert(socket_data);
     1353                                        socket_data->state = TCP_SOCKET_LISTEN;
    11251354                                }
     1355                        }
     1356                        fibril_rwlock_write_unlock(&lock);
     1357                        fibril_rwlock_write_unlock(&tcp_globals.lock);
     1358                        free(addr);
     1359                        break;
     1360
     1361                case NET_SOCKET_LISTEN:
     1362                        fibril_rwlock_read_lock(&tcp_globals.lock);
     1363//                      fibril_rwlock_write_lock(&tcp_globals.lock);
     1364                        fibril_rwlock_write_lock(&lock);
     1365                        res = tcp_listen_message(&local_sockets,
     1366                            SOCKET_GET_SOCKET_ID(call),
     1367                            SOCKET_GET_BACKLOG(call));
     1368                        fibril_rwlock_write_unlock(&lock);
     1369//                      fibril_rwlock_write_unlock(&tcp_globals.lock);
     1370                        fibril_rwlock_read_unlock(&tcp_globals.lock);
     1371                        break;
     1372
     1373                case NET_SOCKET_CONNECT:
     1374                        res = data_receive((void **) &addr, &addrlen);
     1375                        if (res != EOK)
    11261376                                break;
    1127                         case NET_SOCKET_BIND:
    1128                                 res = data_receive((void **) &addr, &addrlen);
    1129                                 if(res == EOK){
    1130                                         fibril_rwlock_write_lock(&tcp_globals.lock);
    1131                                         fibril_rwlock_write_lock(&lock);
    1132                                         res = socket_bind(&local_sockets, &tcp_globals.sockets, SOCKET_GET_SOCKET_ID(call), addr, addrlen, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END, tcp_globals.last_used_port);
    1133                                         if(res == EOK){
    1134                                                 socket = socket_cores_find(&local_sockets, SOCKET_GET_SOCKET_ID(call));
    1135                                                 if(socket){
    1136                                                         socket_data = (tcp_socket_data_ref) socket->specific_data;
    1137                                                         assert(socket_data);
    1138                                                         socket_data->state = TCP_SOCKET_LISTEN;
    1139                                                 }
    1140                                         }
    1141                                         fibril_rwlock_write_unlock(&lock);
    1142                                         fibril_rwlock_write_unlock(&tcp_globals.lock);
    1143                                         free(addr);
    1144                                 }
    1145                                 break;
    1146                         case NET_SOCKET_LISTEN:
    1147                                 fibril_rwlock_read_lock(&tcp_globals.lock);
    1148 //                              fibril_rwlock_write_lock(&tcp_globals.lock);
    1149                                 fibril_rwlock_write_lock(&lock);
    1150                                 res = tcp_listen_message(&local_sockets, SOCKET_GET_SOCKET_ID(call), SOCKET_GET_BACKLOG(call));
     1377                        // the global lock may be released in the
     1378                        // tcp_connect_message() function
     1379                        fibril_rwlock_write_lock(&tcp_globals.lock);
     1380                        fibril_rwlock_write_lock(&lock);
     1381                        res = tcp_connect_message(&local_sockets,
     1382                            SOCKET_GET_SOCKET_ID(call), addr, addrlen);
     1383                        if (res != EOK) {
    11511384                                fibril_rwlock_write_unlock(&lock);
    1152 //                              fibril_rwlock_write_unlock(&tcp_globals.lock);
    1153                                 fibril_rwlock_read_unlock(&tcp_globals.lock);
    1154                                 break;
    1155                         case NET_SOCKET_CONNECT:
    1156                                 res = data_receive((void **) &addr, &addrlen);
    1157                                 if(res == EOK){
    1158                                         // the global lock may be released in the tcp_connect_message() function
    1159                                         fibril_rwlock_write_lock(&tcp_globals.lock);
    1160                                         fibril_rwlock_write_lock(&lock);
    1161                                         res = tcp_connect_message(&local_sockets, SOCKET_GET_SOCKET_ID(call), addr, addrlen);
    1162                                         if(res != EOK){
    1163                                                 fibril_rwlock_write_unlock(&lock);
    1164                                                 fibril_rwlock_write_unlock(&tcp_globals.lock);
    1165                                                 free(addr);
    1166                                         }
    1167                                 }
    1168                                 break;
    1169                         case NET_SOCKET_ACCEPT:
    1170                                 fibril_rwlock_read_lock(&tcp_globals.lock);
    1171                                 fibril_rwlock_write_lock(&lock);
    1172                                 res = tcp_accept_message(&local_sockets, SOCKET_GET_SOCKET_ID(call), SOCKET_GET_NEW_SOCKET_ID(call), &size, &addrlen);
    1173                                 SOCKET_SET_DATA_FRAGMENT_SIZE(answer, size);
     1385                                fibril_rwlock_write_unlock(&tcp_globals.lock);
     1386                                free(addr);
     1387                        }
     1388                        break;
     1389
     1390                case NET_SOCKET_ACCEPT:
     1391                        fibril_rwlock_read_lock(&tcp_globals.lock);
     1392                        fibril_rwlock_write_lock(&lock);
     1393                        res = tcp_accept_message(&local_sockets,
     1394                            SOCKET_GET_SOCKET_ID(call),
     1395                            SOCKET_GET_NEW_SOCKET_ID(call), &size, &addrlen);
     1396                        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, size);
     1397                        fibril_rwlock_write_unlock(&lock);
     1398                        fibril_rwlock_read_unlock(&tcp_globals.lock);
     1399                        if (res > 0) {
     1400                                SOCKET_SET_SOCKET_ID(answer, res);
     1401                                SOCKET_SET_ADDRESS_LENGTH(answer, addrlen);
     1402                                answer_count = 3;
     1403                        }
     1404                        break;
     1405
     1406                case NET_SOCKET_SEND:
     1407                        fibril_rwlock_read_lock(&tcp_globals.lock);
     1408                        fibril_rwlock_write_lock(&lock);
     1409                        res = tcp_send_message(&local_sockets,
     1410                            SOCKET_GET_SOCKET_ID(call),
     1411                            SOCKET_GET_DATA_FRAGMENTS(call), &size,
     1412                            SOCKET_GET_FLAGS(call));
     1413                        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, size);
     1414                        if (res != EOK) {
    11741415                                fibril_rwlock_write_unlock(&lock);
    11751416                                fibril_rwlock_read_unlock(&tcp_globals.lock);
    1176                                 if(res > 0){
    1177                                         SOCKET_SET_SOCKET_ID(answer, res);
    1178                                         SOCKET_SET_ADDRESS_LENGTH(answer, addrlen);
    1179                                         answer_count = 3;
    1180                                 }
     1417                        } else {
     1418                                answer_count = 2;
     1419                        }
     1420                        break;
     1421
     1422                case NET_SOCKET_SENDTO:
     1423                        res = data_receive((void **) &addr, &addrlen);
     1424                        if (res != EOK)
    11811425                                break;
    1182                         case NET_SOCKET_SEND:
    1183                                 fibril_rwlock_read_lock(&tcp_globals.lock);
    1184                                 fibril_rwlock_write_lock(&lock);
    1185                                 res = tcp_send_message(&local_sockets, SOCKET_GET_SOCKET_ID(call), SOCKET_GET_DATA_FRAGMENTS(call), &size, SOCKET_GET_FLAGS(call));
    1186                                 SOCKET_SET_DATA_FRAGMENT_SIZE(answer, size);
    1187                                 if(res != EOK){
    1188                                         fibril_rwlock_write_unlock(&lock);
    1189                                         fibril_rwlock_read_unlock(&tcp_globals.lock);
    1190                                 }else{
    1191                                         answer_count = 2;
    1192                                 }
    1193                                 break;
    1194                         case NET_SOCKET_SENDTO:
    1195                                 res = data_receive((void **) &addr, &addrlen);
    1196                                 if(res == EOK){
    1197                                         fibril_rwlock_read_lock(&tcp_globals.lock);
    1198                                         fibril_rwlock_write_lock(&lock);
    1199                                         res = tcp_send_message(&local_sockets, SOCKET_GET_SOCKET_ID(call), SOCKET_GET_DATA_FRAGMENTS(call), &size, SOCKET_GET_FLAGS(call));
    1200                                         SOCKET_SET_DATA_FRAGMENT_SIZE(answer, size);
    1201                                         if(res != EOK){
    1202                                                 fibril_rwlock_write_unlock(&lock);
    1203                                                 fibril_rwlock_read_unlock(&tcp_globals.lock);
    1204                                         }else{
    1205                                                 answer_count = 2;
    1206                                         }
    1207                                         free(addr);
    1208                                 }
    1209                                 break;
    1210                         case NET_SOCKET_RECV:
    1211                                 fibril_rwlock_read_lock(&tcp_globals.lock);
    1212                                 fibril_rwlock_write_lock(&lock);
    1213                                 res = tcp_recvfrom_message(&local_sockets, SOCKET_GET_SOCKET_ID(call), SOCKET_GET_FLAGS(call), NULL);
     1426                        fibril_rwlock_read_lock(&tcp_globals.lock);
     1427                        fibril_rwlock_write_lock(&lock);
     1428                        res = tcp_send_message(&local_sockets,
     1429                            SOCKET_GET_SOCKET_ID(call),
     1430                            SOCKET_GET_DATA_FRAGMENTS(call), &size,
     1431                            SOCKET_GET_FLAGS(call));
     1432                        SOCKET_SET_DATA_FRAGMENT_SIZE(answer, size);
     1433                        if (res != EOK) {
    12141434                                fibril_rwlock_write_unlock(&lock);
    12151435                                fibril_rwlock_read_unlock(&tcp_globals.lock);
    1216                                 if(res > 0){
    1217                                         SOCKET_SET_READ_DATA_LENGTH(answer, res);
    1218                                         answer_count = 1;
    1219                                         res = EOK;
    1220                                 }
    1221                                 break;
    1222                         case NET_SOCKET_RECVFROM:
    1223                                 fibril_rwlock_read_lock(&tcp_globals.lock);
    1224                                 fibril_rwlock_write_lock(&lock);
    1225                                 res = tcp_recvfrom_message(&local_sockets, SOCKET_GET_SOCKET_ID(call), SOCKET_GET_FLAGS(call), &addrlen);
     1436                        } else {
     1437                                answer_count = 2;
     1438                        }
     1439                        free(addr);
     1440                        break;
     1441
     1442                case NET_SOCKET_RECV:
     1443                        fibril_rwlock_read_lock(&tcp_globals.lock);
     1444                        fibril_rwlock_write_lock(&lock);
     1445                        res = tcp_recvfrom_message(&local_sockets,
     1446                            SOCKET_GET_SOCKET_ID(call), SOCKET_GET_FLAGS(call),
     1447                            NULL);
     1448                        fibril_rwlock_write_unlock(&lock);
     1449                        fibril_rwlock_read_unlock(&tcp_globals.lock);
     1450                        if (res > 0) {
     1451                                SOCKET_SET_READ_DATA_LENGTH(answer, res);
     1452                                answer_count = 1;
     1453                                res = EOK;
     1454                        }
     1455                        break;
     1456
     1457                case NET_SOCKET_RECVFROM:
     1458                        fibril_rwlock_read_lock(&tcp_globals.lock);
     1459                        fibril_rwlock_write_lock(&lock);
     1460                        res = tcp_recvfrom_message(&local_sockets,
     1461                            SOCKET_GET_SOCKET_ID(call), SOCKET_GET_FLAGS(call),
     1462                            &addrlen);
     1463                        fibril_rwlock_write_unlock(&lock);
     1464                        fibril_rwlock_read_unlock(&tcp_globals.lock);
     1465                        if (res > 0) {
     1466                                SOCKET_SET_READ_DATA_LENGTH(answer, res);
     1467                                SOCKET_SET_ADDRESS_LENGTH(answer, addrlen);
     1468                                answer_count = 3;
     1469                                res = EOK;
     1470                        }
     1471                        break;
     1472
     1473                case NET_SOCKET_CLOSE:
     1474                        fibril_rwlock_write_lock(&tcp_globals.lock);
     1475                        fibril_rwlock_write_lock(&lock);
     1476                        res = tcp_close_message(&local_sockets,
     1477                            SOCKET_GET_SOCKET_ID(call));
     1478                        if (res != EOK) {
    12261479                                fibril_rwlock_write_unlock(&lock);
    1227                                 fibril_rwlock_read_unlock(&tcp_globals.lock);
    1228                                 if(res > 0){
    1229                                         SOCKET_SET_READ_DATA_LENGTH(answer, res);
    1230                                         SOCKET_SET_ADDRESS_LENGTH(answer, addrlen);
    1231                                         answer_count = 3;
    1232                                         res = EOK;
    1233                                 }
    1234                                 break;
    1235                         case NET_SOCKET_CLOSE:
    1236                                 fibril_rwlock_write_lock(&tcp_globals.lock);
    1237                                 fibril_rwlock_write_lock(&lock);
    1238                                 res = tcp_close_message(&local_sockets, SOCKET_GET_SOCKET_ID(call));
    1239                                 if(res != EOK){
    1240                                         fibril_rwlock_write_unlock(&lock);
    1241                                         fibril_rwlock_write_unlock(&tcp_globals.lock);
    1242                                 }
    1243                                 break;
    1244                         case NET_SOCKET_GETSOCKOPT:
    1245                         case NET_SOCKET_SETSOCKOPT:
    1246                         default:
    1247                                 res = ENOTSUP;
    1248                                 break;
     1480                                fibril_rwlock_write_unlock(&tcp_globals.lock);
     1481                        }
     1482                        break;
     1483
     1484                case NET_SOCKET_GETSOCKOPT:
     1485                case NET_SOCKET_SETSOCKOPT:
     1486                default:
     1487                        res = ENOTSUP;
     1488                        break;
    12491489                }
    12501490        }
     
    12551495        printf("release\n");
    12561496        // release all local sockets
    1257         socket_cores_release(tcp_globals.net_phone, &local_sockets, &tcp_globals.sockets, tcp_free_socket_data);
     1497        socket_cores_release(tcp_globals.net_phone, &local_sockets,
     1498            &tcp_globals.sockets, tcp_free_socket_data);
    12581499
    12591500        return EOK;
    12601501}
    12611502
    1262 int tcp_timeout(void * data){
     1503int tcp_timeout(void *data)
     1504{
    12631505        tcp_timeout_ref timeout = data;
    12641506        int keep_write_lock = false;
     
    12711513        async_usleep(timeout->timeout);
    12721514        // lock the globals
    1273         if(timeout->globals_read_only){
     1515        if (timeout->globals_read_only)
    12741516                fibril_rwlock_read_lock(&tcp_globals.lock);
    1275         }else{
     1517        else
    12761518                fibril_rwlock_write_lock(&tcp_globals.lock);
    1277         }
     1519
    12781520        // find the pending operation socket
    1279         socket = socket_port_find(&tcp_globals.sockets, timeout->port, timeout->key, timeout->key_length);
    1280         if(socket && (socket->socket_id == timeout->socket_id)){
    1281                 socket_data = (tcp_socket_data_ref) socket->specific_data;
    1282                 assert(socket_data);
    1283                 if(socket_data->local_sockets == timeout->local_sockets){
    1284                         fibril_rwlock_write_lock(socket_data->local_lock);
    1285                         if(timeout->sequence_number){
    1286                                 // increase the timeout counter;
    1287                                 ++ socket_data->timeout_count;
    1288                                 if(socket_data->timeout_count == TCP_MAX_TIMEOUTS){
    1289                                         // TODO release as connection lost
    1290                                         //tcp_refresh_socket_data(socket_data);
    1291                                         fibril_rwlock_write_unlock(socket_data->local_lock);
    1292                                 }else{
    1293                                         // retransmit
    1294 //                                      tcp_retransmit_packet(socket, socket_data, timeout->sequence_number);
    1295                                         fibril_rwlock_write_unlock(socket_data->local_lock);
    1296                                 }
    1297                         }else{
    1298                                 fibril_mutex_lock(&socket_data->operation.mutex);
    1299                                 // set the timeout operation result if state not changed
    1300                                 if(socket_data->state == timeout->state){
    1301                                         socket_data->operation.result = ETIMEOUT;
    1302                                         // notify the main fibril
    1303                                         fibril_condvar_signal(&socket_data->operation.condvar);
    1304                                         // keep the global write lock
    1305                                         keep_write_lock = true;
    1306                                 }else{
    1307                                         // operation is ok, do nothing
    1308                                         // unlocking from now on, so the unlock order does not matter...
    1309                                         fibril_rwlock_write_unlock(socket_data->local_lock);
    1310                                 }
    1311                                 fibril_mutex_unlock(&socket_data->operation.mutex);
    1312                         }
    1313                 }
    1314         }
     1521        socket = socket_port_find(&tcp_globals.sockets, timeout->port,
     1522            timeout->key, timeout->key_length);
     1523        if (!(socket && (socket->socket_id == timeout->socket_id)))
     1524                goto out;
     1525       
     1526        socket_data = (tcp_socket_data_ref) socket->specific_data;
     1527        assert(socket_data);
     1528        if (socket_data->local_sockets != timeout->local_sockets)
     1529                goto out;
     1530       
     1531        fibril_rwlock_write_lock(socket_data->local_lock);
     1532        if (timeout->sequence_number) {
     1533                // increase the timeout counter;
     1534                ++socket_data->timeout_count;
     1535                if (socket_data->timeout_count == TCP_MAX_TIMEOUTS) {
     1536                        // TODO release as connection lost
     1537                        //tcp_refresh_socket_data(socket_data);
     1538                        fibril_rwlock_write_unlock(socket_data->local_lock);
     1539                } else {
     1540                        // retransmit
     1541//                      tcp_retransmit_packet(socket,
     1542//                          socket_data, timeout->sequence_number);
     1543                        fibril_rwlock_write_unlock(socket_data->local_lock);
     1544                }
     1545        } else {
     1546                fibril_mutex_lock(&socket_data->operation.mutex);
     1547                // set the timeout operation result if state not
     1548                // changed
     1549                if (socket_data->state == timeout->state) {
     1550                        socket_data->operation.result = ETIMEOUT;
     1551                        // notify the main fibril
     1552                        fibril_condvar_signal(&socket_data->operation.condvar);
     1553                        // keep the global write lock
     1554                        keep_write_lock = true;
     1555                } else {
     1556                        // operation is ok, do nothing
     1557                        // unlocking from now on, so the unlocki
     1558                        // order does not matter...
     1559                        fibril_rwlock_write_unlock(socket_data->local_lock);
     1560                }
     1561                fibril_mutex_unlock(&socket_data->operation.mutex);
     1562        }
     1563
     1564out:
    13151565        // unlock only if no socket
    1316         if(timeout->globals_read_only){
     1566        if (timeout->globals_read_only)
    13171567                fibril_rwlock_read_unlock(&tcp_globals.lock);
    1318         }else if(! keep_write_lock){
     1568        else if (!keep_write_lock)
    13191569                // release if not desired
    13201570                fibril_rwlock_write_unlock(&tcp_globals.lock);
    1321         }
     1571       
    13221572        // release the timeout structure
    13231573        free(timeout);
     
    13251575}
    13261576
    1327 int tcp_release_after_timeout(void * data){
     1577int tcp_release_after_timeout(void *data)
     1578{
    13281579        tcp_timeout_ref timeout = data;
    13291580        socket_core_ref socket;
    13301581        tcp_socket_data_ref socket_data;
    1331         fibril_rwlock_t * local_lock;
     1582        fibril_rwlock_t *local_lock;
    13321583
    13331584        assert(timeout);
     
    13381589        fibril_rwlock_write_lock(&tcp_globals.lock);
    13391590        // find the pending operation socket
    1340         socket = socket_port_find(&tcp_globals.sockets, timeout->port, timeout->key, timeout->key_length);
    1341         if(socket && (socket->socket_id == timeout->socket_id)){
     1591        socket = socket_port_find(&tcp_globals.sockets, timeout->port,
     1592            timeout->key, timeout->key_length);
     1593        if (socket && (socket->socket_id == timeout->socket_id)) {
    13421594                socket_data = (tcp_socket_data_ref) socket->specific_data;
    13431595                assert(socket_data);
    1344                 if(socket_data->local_sockets == timeout->local_sockets){
     1596                if (socket_data->local_sockets == timeout->local_sockets) {
    13451597                        local_lock = socket_data->local_lock;
    13461598                        fibril_rwlock_write_lock(local_lock);
    1347                         socket_destroy(tcp_globals.net_phone, timeout->socket_id, timeout->local_sockets, &tcp_globals.sockets, tcp_free_socket_data);
     1599                        socket_destroy(tcp_globals.net_phone,
     1600                            timeout->socket_id, timeout->local_sockets,
     1601                            &tcp_globals.sockets, tcp_free_socket_data);
    13481602                        fibril_rwlock_write_unlock(local_lock);
    13491603                }
     
    13561610}
    13571611
    1358 void tcp_retransmit_packet(socket_core_ref socket, tcp_socket_data_ref socket_data, size_t sequence_number){
     1612void
     1613tcp_retransmit_packet(socket_core_ref socket, tcp_socket_data_ref socket_data,
     1614    size_t sequence_number)
     1615{
    13591616        packet_t packet;
    13601617        packet_t copy;
     
    13681625        packet = pq_find(socket_data->outgoing, sequence_number);
    13691626        printf("retransmit %d\n", packet_get_id(packet));
    1370         if(packet){
     1627        if (packet) {
    13711628                pq_get_order(packet, NULL, &data_length);
    1372                 copy = tcp_prepare_copy(socket, socket_data, packet, data_length, sequence_number);
     1629                copy = tcp_prepare_copy(socket, socket_data, packet,
     1630                    data_length, sequence_number);
    13731631                fibril_rwlock_write_unlock(socket_data->local_lock);
    1374 //              printf("r send %d\n", packet_get_id(packet));
    1375                 if(copy){
     1632//              printf("r send %d\n", packet_get_id(packet));
     1633                if (copy)
    13761634                        tcp_send_packets(socket_data->device_id, copy);
    1377                 }
    1378         }else{
     1635        } else {
    13791636                fibril_rwlock_write_unlock(socket_data->local_lock);
    13801637        }
    13811638}
    13821639
    1383 int tcp_listen_message(socket_cores_ref local_sockets, int socket_id, int backlog){
     1640int
     1641tcp_listen_message(socket_cores_ref local_sockets, int socket_id, int backlog)
     1642{
    13841643        socket_core_ref socket;
    13851644        tcp_socket_data_ref socket_data;
     
    13871646        assert(local_sockets);
    13881647
    1389         if(backlog < 0){
     1648        if (backlog < 0)
    13901649                return EINVAL;
    1391         }
     1650
    13921651        // find the socket
    13931652        socket = socket_cores_find(local_sockets, socket_id);
    1394         if(! socket){
     1653        if (!socket)
    13951654                return ENOTSOCK;
    1396         }
     1655       
    13971656        // get the socket specific data
    13981657        socket_data = (tcp_socket_data_ref) socket->specific_data;
     
    14001659        // set the backlog
    14011660        socket_data->backlog = backlog;
     1661
    14021662        return EOK;
    14031663}
    14041664
    1405 int tcp_connect_message(socket_cores_ref local_sockets, int socket_id, struct sockaddr * addr, socklen_t addrlen){
     1665int
     1666tcp_connect_message(socket_cores_ref local_sockets, int socket_id,
     1667    struct sockaddr *addr, socklen_t addrlen)
     1668{
    14061669        ERROR_DECLARE;
    14071670
     
    14141677        // find the socket
    14151678        socket = socket_cores_find(local_sockets, socket_id);
    1416         if(! socket){
     1679        if (!socket)
    14171680                return ENOTSOCK;
    1418         }
    1419         if(ERROR_OCCURRED(tcp_connect_core(socket, local_sockets, addr, addrlen))){
     1681       
     1682        if (ERROR_OCCURRED(tcp_connect_core(socket, local_sockets, addr,
     1683            addrlen))) {
    14201684                tcp_free_socket_data(socket);
    14211685                // unbind if bound
    1422                 if(socket->port > 0){
    1423                         socket_ports_exclude(&tcp_globals.sockets, socket->port);
     1686                if (socket->port > 0) {
     1687                        socket_ports_exclude(&tcp_globals.sockets,
     1688                            socket->port);
    14241689                        socket->port = 0;
    14251690                }
     
    14281693}
    14291694
    1430 int tcp_connect_core(socket_core_ref socket, socket_cores_ref local_sockets, struct sockaddr * addr, socklen_t addrlen){
     1695int
     1696tcp_connect_core(socket_core_ref socket, socket_cores_ref local_sockets,
     1697    struct sockaddr *addr, socklen_t addrlen)
     1698{
    14311699        ERROR_DECLARE;
    14321700
     
    14421710        assert(socket_data);
    14431711        assert(socket->specific_data == socket_data);
    1444         if((socket_data->state != TCP_SOCKET_INITIAL)
    1445                 && ((socket_data->state != TCP_SOCKET_LISTEN) || (socket->port <= 0))){
     1712        if ((socket_data->state != TCP_SOCKET_INITIAL) &&
     1713            ((socket_data->state != TCP_SOCKET_LISTEN) ||
     1714            (socket->port <= 0)))
    14461715                return EINVAL;
    1447         }
     1716
    14481717        // get the destination port
    1449         ERROR_PROPAGATE(tl_get_address_port(addr, addrlen, &socket_data->dest_port));
    1450         if(socket->port <= 0){
     1718        ERROR_PROPAGATE(tl_get_address_port(addr, addrlen,
     1719            &socket_data->dest_port));
     1720        if (socket->port <= 0) {
    14511721                // try to find a free port
    1452                 ERROR_PROPAGATE(socket_bind_free_port(&tcp_globals.sockets, socket, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END, tcp_globals.last_used_port));
     1722                ERROR_PROPAGATE(socket_bind_free_port(&tcp_globals.sockets,
     1723                    socket, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END,
     1724                    tcp_globals.last_used_port));
    14531725                // set the next port as the search starting port number
    14541726                tcp_globals.last_used_port = socket->port;
    14551727        }
    1456         ERROR_PROPAGATE(ip_get_route_req(tcp_globals.ip_phone, IPPROTO_TCP, addr, addrlen, &socket_data->device_id, &socket_data->pseudo_header, &socket_data->headerlen));
     1728
     1729        ERROR_PROPAGATE(ip_get_route_req(tcp_globals.ip_phone, IPPROTO_TCP,
     1730            addr, addrlen, &socket_data->device_id,
     1731            &socket_data->pseudo_header, &socket_data->headerlen));
    14571732
    14581733        // create the notification packet
    1459         ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket, socket_data, 1, 0));
     1734        ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket,
     1735            socket_data, 1, 0));
    14601736
    14611737        // unlock the globals and wait for an operation
     
    14651741        socket_data->addrlen = addrlen;
    14661742        // send the packet
    1467         if(ERROR_OCCURRED(tcp_queue_packet(socket, socket_data, packet, 1))
    1468                 || ERROR_OCCURRED(tcp_prepare_timeout(tcp_timeout, socket, socket_data, 0, TCP_SOCKET_INITIAL, NET_DEFAULT_TCP_INITIAL_TIMEOUT, false))){
     1743        if (ERROR_OCCURRED(tcp_queue_packet(socket, socket_data, packet, 1)) ||
     1744            ERROR_OCCURRED(tcp_prepare_timeout(tcp_timeout, socket, socket_data,
     1745            0, TCP_SOCKET_INITIAL, NET_DEFAULT_TCP_INITIAL_TIMEOUT, false))) {
     1746
    14691747                socket_data->addr = NULL;
    14701748                socket_data->addrlen = 0;
    14711749                fibril_rwlock_write_lock(&tcp_globals.lock);
    1472         }else{
     1750
     1751        } else {
     1752
    14731753                packet = tcp_get_packets_to_send(socket, socket_data);
    1474                 if(packet){
     1754                if (packet) {
    14751755                        fibril_mutex_lock(&socket_data->operation.mutex);
    14761756                        fibril_rwlock_write_unlock(socket_data->local_lock);
     
    14781758                        printf("connecting %d\n", packet_get_id(packet));
    14791759                        tcp_send_packets(socket_data->device_id, packet);
     1760
    14801761                        // wait for a reply
    1481                         fibril_condvar_wait(&socket_data->operation.condvar, &socket_data->operation.mutex);
     1762                        fibril_condvar_wait(&socket_data->operation.condvar,
     1763                            &socket_data->operation.mutex);
    14821764                        ERROR_CODE = socket_data->operation.result;
    1483                         if(ERROR_CODE != EOK){
     1765                        if (ERROR_CODE != EOK) {
    14841766                                socket_data->addr = NULL;
    14851767                                socket_data->addrlen = 0;
    14861768                        }
    1487                 }else{
     1769                } else {
    14881770                        socket_data->addr = NULL;
    14891771                        socket_data->addrlen = 0;
     
    14981780}
    14991781
    1500 int tcp_queue_prepare_packet(socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length){
     1782int
     1783tcp_queue_prepare_packet(socket_core_ref socket,
     1784    tcp_socket_data_ref socket_data, packet_t packet, size_t data_length)
     1785{
    15011786        ERROR_DECLARE;
    15021787
     
    15091794        // get tcp header
    15101795        header = (tcp_header_ref) packet_get_data(packet);
    1511         if(! header){
     1796        if (!header)
    15121797                return NO_DATA;
    1513         }
     1798       
    15141799        header->destination_port = htons(socket_data->dest_port);
    15151800        header->source_port = htons(socket->port);
    15161801        header->sequence_number = htonl(socket_data->next_outgoing);
    1517         if(ERROR_OCCURRED(packet_set_addr(packet, NULL, (uint8_t *) socket_data->addr, socket_data->addrlen))){
     1802
     1803        if (ERROR_OCCURRED(packet_set_addr(packet, NULL,
     1804            (uint8_t *) socket_data->addr, socket_data->addrlen)))
    15181805                return tcp_release_and_return(packet, EINVAL);
    1519         }
     1806
    15201807        // remember the outgoing FIN
    1521         if(header->finalize){
     1808        if (header->finalize)
    15221809                socket_data->fin_outgoing = socket_data->next_outgoing;
    1523         }
     1810       
    15241811        return EOK;
    15251812}
    15261813
    1527 int tcp_queue_packet(socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length){
     1814int
     1815tcp_queue_packet(socket_core_ref socket, tcp_socket_data_ref socket_data,
     1816    packet_t packet, size_t data_length)
     1817{
    15281818        ERROR_DECLARE;
    15291819
     
    15321822        assert(socket->specific_data == socket_data);
    15331823
    1534         ERROR_PROPAGATE(tcp_queue_prepare_packet(socket, socket_data, packet, data_length));
    1535 
    1536         if(ERROR_OCCURRED(pq_add(&socket_data->outgoing, packet, socket_data->next_outgoing, data_length))){
     1824        ERROR_PROPAGATE(tcp_queue_prepare_packet(socket, socket_data, packet,
     1825            data_length));
     1826
     1827        if (ERROR_OCCURRED(pq_add(&socket_data->outgoing, packet,
     1828            socket_data->next_outgoing, data_length)))
    15371829                return tcp_release_and_return(packet, ERROR_CODE);
    1538         }
     1830
    15391831        socket_data->next_outgoing += data_length;
    15401832        return EOK;
    15411833}
    15421834
    1543 packet_t tcp_get_packets_to_send(socket_core_ref socket, tcp_socket_data_ref socket_data){
     1835packet_t
     1836tcp_get_packets_to_send(socket_core_ref socket, tcp_socket_data_ref socket_data)
     1837{
    15441838        ERROR_DECLARE;
    15451839
     
    15551849
    15561850        packet = pq_find(socket_data->outgoing, socket_data->last_outgoing + 1);
    1557         while(packet){
     1851        while (packet) {
    15581852                pq_get_order(packet, NULL, &data_length);
     1853
    15591854                // send only if fits into the window
    15601855                // respecting the possible overflow
    1561                 if(IS_IN_INTERVAL_OVERFLOW((uint32_t) socket_data->last_outgoing, (uint32_t)(socket_data->last_outgoing + data_length), (uint32_t)(socket_data->expected + socket_data->treshold))){
    1562                         copy = tcp_prepare_copy(socket, socket_data, packet, data_length, socket_data->last_outgoing + 1);
    1563                         if(! copy){
    1564                                 return sending;
    1565                         }
    1566                         if(! sending){
    1567                                 sending = copy;
    1568                         }else{
    1569                                 if(ERROR_OCCURRED(pq_insert_after(previous, copy))){
    1570                                         pq_release_remote(tcp_globals.net_phone, packet_get_id(copy));
    1571                                         return sending;
    1572                                 }
    1573                         }
    1574                         previous = copy;
    1575                         packet = pq_next(packet);
    1576                         // overflow occurred ?
    1577                         if((! packet) && (socket_data->last_outgoing > socket_data->next_outgoing)){
    1578                                 printf("gpts overflow\n");
    1579                                 // continue from the beginning
    1580                                 packet = socket_data->outgoing;
    1581                         }
    1582                         socket_data->last_outgoing += data_length;
    1583                 }else{
     1856                if (!IS_IN_INTERVAL_OVERFLOW(
     1857                    (uint32_t) socket_data->last_outgoing,
     1858                    (uint32_t) (socket_data->last_outgoing + data_length),
     1859                    (uint32_t) (socket_data->expected + socket_data->treshold)))
    15841860                        break;
    1585                 }
    1586         }
     1861
     1862                copy = tcp_prepare_copy(socket, socket_data, packet,
     1863                    data_length, socket_data->last_outgoing + 1);
     1864                if (!copy)
     1865                        return sending;
     1866                       
     1867                if (!sending) {
     1868                        sending = copy;
     1869                } else if (ERROR_OCCURRED(pq_insert_after(previous, copy))) {
     1870                        pq_release_remote(tcp_globals.net_phone,
     1871                            packet_get_id(copy));
     1872                        return sending;
     1873                }
     1874
     1875                previous = copy;
     1876                packet = pq_next(packet);
     1877                // overflow occurred ?
     1878                if ((!packet) &&
     1879                    (socket_data->last_outgoing > socket_data->next_outgoing)) {
     1880                        printf("gpts overflow\n");
     1881                        // continue from the beginning
     1882                        packet = socket_data->outgoing;
     1883                }
     1884                socket_data->last_outgoing += data_length;
     1885        }
     1886
    15871887        return sending;
    15881888}
    15891889
    1590 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){
     1890packet_t
     1891tcp_send_prepare_packet(socket_core_ref socket, tcp_socket_data_ref socket_data,
     1892    packet_t packet, size_t data_length, size_t sequence_number)
     1893{
    15911894        ERROR_DECLARE;
    15921895
     
    15991902
    16001903        // adjust the pseudo header
    1601         if(ERROR_OCCURRED(ip_client_set_pseudo_header_data_length(socket_data->pseudo_header, socket_data->headerlen, packet_get_data_length(packet)))){
     1904        if (ERROR_OCCURRED(ip_client_set_pseudo_header_data_length(
     1905            socket_data->pseudo_header, socket_data->headerlen,
     1906            packet_get_data_length(packet)))) {
    16021907                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    16031908                return NULL;
     
    16061911        // get the header
    16071912        header = (tcp_header_ref) packet_get_data(packet);
    1608         if(! header){
     1913        if (!header) {
    16091914                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    16101915                return NULL;
     
    16131918
    16141919        // adjust the header
    1615         if(socket_data->next_incoming){
    1616                 header->acknowledgement_number = htonl(socket_data->next_incoming);
     1920        if (socket_data->next_incoming) {
     1921                header->acknowledgement_number =
     1922                    htonl(socket_data->next_incoming);
    16171923                header->acknowledge = 1;
    16181924        }
     
    16211927        // checksum
    16221928        header->checksum = 0;
    1623         checksum = compute_checksum(0, socket_data->pseudo_header, socket_data->headerlen);
    1624         checksum = compute_checksum(checksum, (uint8_t *) packet_get_data(packet), packet_get_data_length(packet));
     1929        checksum = compute_checksum(0, socket_data->pseudo_header,
     1930            socket_data->headerlen);
     1931        checksum = compute_checksum(checksum, (uint8_t *) packet_get_data(packet),
     1932            packet_get_data_length(packet));
    16251933        header->checksum = htons(flip_checksum(compact_checksum(checksum)));
     1934
    16261935        // prepare the packet
    1627         if(ERROR_OCCURRED(ip_client_prepare_packet(packet, IPPROTO_TCP, 0, 0, 0, 0))
    1628         // prepare the timeout
    1629                 || ERROR_OCCURRED(tcp_prepare_timeout(tcp_timeout, socket, socket_data, sequence_number, socket_data->state, socket_data->timeout, true))){
     1936        if (ERROR_OCCURRED(ip_client_prepare_packet(packet, IPPROTO_TCP, 0, 0,
     1937            0, 0)) || ERROR_OCCURRED(tcp_prepare_timeout(tcp_timeout, socket,
     1938            socket_data, sequence_number, socket_data->state,
     1939            socket_data->timeout, true))) {
    16301940                pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    16311941                return NULL;
    16321942        }
     1943
    16331944        return packet;
    16341945}
    16351946
    1636 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){
     1947packet_t
     1948tcp_prepare_copy(socket_core_ref socket, tcp_socket_data_ref socket_data,
     1949    packet_t packet, size_t data_length, size_t sequence_number)
     1950{
    16371951        packet_t copy;
    16381952
     
    16431957        // make a copy of the packet
    16441958        copy = packet_get_copy(tcp_globals.net_phone, packet);
    1645         if(! copy){
     1959        if (!copy)
    16461960                return NULL;
    1647         }
    1648 
    1649         return tcp_send_prepare_packet(socket, socket_data, copy, data_length, sequence_number);
    1650 }
    1651 
    1652 void tcp_send_packets(device_id_t device_id, packet_t packet){
     1961
     1962        return tcp_send_prepare_packet(socket, socket_data, copy, data_length,
     1963            sequence_number);
     1964}
     1965
     1966void tcp_send_packets(device_id_t device_id, packet_t packet)
     1967{
    16531968        packet_t next;
    16541969
    1655         while(packet){
     1970        while (packet) {
    16561971                next = pq_detach(packet);
    1657                 ip_send_msg(tcp_globals.ip_phone, device_id, packet, SERVICE_TCP, 0);
     1972                ip_send_msg(tcp_globals.ip_phone, device_id, packet,
     1973                    SERVICE_TCP, 0);
    16581974                packet = next;
    16591975        }
    16601976}
    16611977
    1662 void tcp_prepare_operation_header(socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, int synchronize, int finalize){
     1978void
     1979tcp_prepare_operation_header(socket_core_ref socket,
     1980    tcp_socket_data_ref socket_data, tcp_header_ref header, int synchronize,
     1981    int finalize)
     1982{
    16631983        assert(socket);
    16641984        assert(socket_data);
     
    16741994}
    16751995
    1676 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){
     1996int
     1997tcp_prepare_timeout(int (*timeout_function)(void *tcp_timeout_t),
     1998    socket_core_ref socket, tcp_socket_data_ref socket_data,
     1999    size_t sequence_number, tcp_socket_state_t state, suseconds_t timeout,
     2000    int globals_read_only)
     2001{
    16772002        tcp_timeout_ref operation_timeout;
    16782003        fid_t fibril;
     
    16832008
    16842009        // prepare the timeout with key bundle structure
    1685         operation_timeout = malloc(sizeof(*operation_timeout) + socket->key_length + 1);
    1686         if(! operation_timeout){
     2010        operation_timeout = malloc(sizeof(*operation_timeout) +
     2011            socket->key_length + 1);
     2012        if (!operation_timeout)
    16872013                return ENOMEM;
    1688         }
     2014
    16892015        bzero(operation_timeout, sizeof(*operation_timeout));
    16902016        operation_timeout->globals_read_only = globals_read_only;
     
    16972023
    16982024        // copy the key
    1699         operation_timeout->key = ((char *) operation_timeout) + sizeof(*operation_timeout);
     2025        operation_timeout->key = ((char *) operation_timeout) +
     2026            sizeof(*operation_timeout);
    17002027        operation_timeout->key_length = socket->key_length;
    17012028        memcpy(operation_timeout->key, socket->key, socket->key_length);
     
    17042031        // prepare the timeouting thread
    17052032        fibril = fibril_create(timeout_function, operation_timeout);
    1706         if(! fibril){
     2033        if (!fibril) {
    17072034                free(operation_timeout);
    17082035                return EPARTY;
    17092036        }
    1710 //      fibril_mutex_lock(&socket_data->operation.mutex);
     2037//      fibril_mutex_lock(&socket_data->operation.mutex);
    17112038        // start the timeouting fibril
    17122039        fibril_add_ready(fibril);
     
    17152042}
    17162043
    1717 int tcp_recvfrom_message(socket_cores_ref local_sockets, int socket_id, int flags, size_t * addrlen){
     2044int
     2045tcp_recvfrom_message(socket_cores_ref local_sockets, int socket_id, int flags,
     2046    size_t * addrlen)
     2047{
    17182048        ERROR_DECLARE;
    17192049
     
    17282058        // find the socket
    17292059        socket = socket_cores_find(local_sockets, socket_id);
    1730         if(! socket){
     2060        if (!socket)
    17312061                return ENOTSOCK;
    1732         }
     2062
    17332063        // get the socket specific data
    1734         if(! socket->specific_data){
     2064        if (!socket->specific_data)
    17352065                return NO_DATA;
    1736         }
     2066
    17372067        socket_data = (tcp_socket_data_ref) socket->specific_data;
    17382068
    17392069        // check state
    1740         if((socket_data->state != TCP_SOCKET_ESTABLISHED) && (socket_data->state != TCP_SOCKET_CLOSE_WAIT)){
     2070        if ((socket_data->state != TCP_SOCKET_ESTABLISHED) &&
     2071            (socket_data->state != TCP_SOCKET_CLOSE_WAIT))
    17412072                return ENOTCONN;
    1742         }
    17432073
    17442074        // send the source address if desired
    1745         if(addrlen){
    1746                 ERROR_PROPAGATE(data_reply(socket_data->addr, socket_data->addrlen));
     2075        if (addrlen) {
     2076                ERROR_PROPAGATE(data_reply(socket_data->addr,
     2077                    socket_data->addrlen));
    17472078                *addrlen = socket_data->addrlen;
    17482079        }
     
    17502081        // get the next received packet
    17512082        packet_id = dyn_fifo_value(&socket->received);
    1752         if(packet_id < 0){
     2083        if (packet_id < 0)
    17532084                return NO_DATA;
    1754         }
    1755         ERROR_PROPAGATE(packet_translate_remote(tcp_globals.net_phone, &packet, packet_id));
     2085
     2086        ERROR_PROPAGATE(packet_translate_remote(tcp_globals.net_phone, &packet,
     2087            packet_id));
    17562088
    17572089        // reply the packets
     
    17652097}
    17662098
    1767 int tcp_send_message(socket_cores_ref local_sockets, int socket_id, int fragments, size_t * data_fragment_size, int flags){
     2099int
     2100tcp_send_message(socket_cores_ref local_sockets, int socket_id, int fragments,
     2101    size_t * data_fragment_size, int flags)
     2102{
    17682103        ERROR_DECLARE;
    17692104
     
    17822117        // find the socket
    17832118        socket = socket_cores_find(local_sockets, socket_id);
    1784         if(! socket){
     2119        if (!socket)
    17852120                return ENOTSOCK;
    1786         }
     2121
    17872122        // get the socket specific data
    1788         if(! socket->specific_data){
     2123        if (!socket->specific_data)
    17892124                return NO_DATA;
    1790         }
     2125
    17912126        socket_data = (tcp_socket_data_ref) socket->specific_data;
    17922127
    17932128        // check state
    1794         if((socket_data->state != TCP_SOCKET_ESTABLISHED) && (socket_data->state != TCP_SOCKET_CLOSE_WAIT)){
     2129        if ((socket_data->state != TCP_SOCKET_ESTABLISHED) &&
     2130            (socket_data->state != TCP_SOCKET_CLOSE_WAIT))
    17952131                return ENOTCONN;
    1796         }
    1797 
    1798         ERROR_PROPAGATE(tl_get_ip_packet_dimension(tcp_globals.ip_phone, &tcp_globals.dimensions, socket_data->device_id, &packet_dimension));
    1799 
    1800         *data_fragment_size = ((packet_dimension->content < socket_data->data_fragment_size) ? packet_dimension->content : socket_data->data_fragment_size);
    1801 
    1802         for(index = 0; index < fragments; ++ index){
     2132
     2133        ERROR_PROPAGATE(tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     2134           &tcp_globals.dimensions, socket_data->device_id, &packet_dimension));
     2135
     2136        *data_fragment_size =
     2137            ((packet_dimension->content < socket_data->data_fragment_size) ?
     2138            packet_dimension->content : socket_data->data_fragment_size);
     2139
     2140        for (index = 0; index < fragments; ++index) {
    18032141                // read the data fragment
    1804                 result = tl_socket_read_packet_data(tcp_globals.net_phone, &packet, TCP_HEADER_SIZE, packet_dimension, socket_data->addr, socket_data->addrlen);
    1805                 if(result < 0){
     2142                result = tl_socket_read_packet_data(tcp_globals.net_phone,
     2143                    &packet, TCP_HEADER_SIZE, packet_dimension,
     2144                    socket_data->addr, socket_data->addrlen);
     2145                if (result < 0)
    18062146                        return result;
    1807                 }
     2147
    18082148                total_length = (size_t) result;
    18092149                // prefix the tcp header
    18102150                header = PACKET_PREFIX(packet, tcp_header_t);
    1811                 if(! header){
     2151                if (!header)
    18122152                        return tcp_release_and_return(packet, ENOMEM);
    1813                 }
     2153
    18142154                tcp_prepare_operation_header(socket, socket_data, header, 0, 0);
    1815                 ERROR_PROPAGATE(tcp_queue_packet(socket, socket_data, packet, 0));
     2155                ERROR_PROPAGATE(tcp_queue_packet(socket, socket_data, packet,
     2156                    0));
    18162157        }
    18172158
     
    18202161        fibril_rwlock_write_unlock(socket_data->local_lock);
    18212162        fibril_rwlock_read_unlock(&tcp_globals.lock);
    1822         if(packet){
     2163
     2164        if (packet) {
    18232165                // send the packet
    18242166                tcp_send_packets(socket_data->device_id, packet);
     
    18282170}
    18292171
    1830 int tcp_close_message(socket_cores_ref local_sockets, int socket_id){
     2172int
     2173tcp_close_message(socket_cores_ref local_sockets, int socket_id)
     2174{
    18312175        ERROR_DECLARE;
    18322176
     
    18372181        // find the socket
    18382182        socket = socket_cores_find(local_sockets, socket_id);
    1839         if(! socket){
     2183        if (!socket)
    18402184                return ENOTSOCK;
    1841         }
     2185
    18422186        // get the socket specific data
    18432187        socket_data = (tcp_socket_data_ref) socket->specific_data;
     
    18452189
    18462190        // check state
    1847         switch(socket_data->state){
    1848                 case TCP_SOCKET_ESTABLISHED:
    1849                         socket_data->state = TCP_SOCKET_FIN_WAIT_1;
    1850                         break;
    1851                 case TCP_SOCKET_CLOSE_WAIT:
    1852                         socket_data->state = TCP_SOCKET_LAST_ACK;
    1853                         break;
    1854 //              case TCP_SOCKET_LISTEN:
    1855                 default:
    1856                         // just destroy
    1857                         if(! ERROR_OCCURRED(socket_destroy(tcp_globals.net_phone, socket_id, local_sockets, &tcp_globals.sockets, tcp_free_socket_data))){
    1858                                 fibril_rwlock_write_unlock(socket_data->local_lock);
    1859                                 fibril_rwlock_write_unlock(&tcp_globals.lock);
    1860                         }
    1861                         return ERROR_CODE;
    1862         }
     2191        switch (socket_data->state) {
     2192        case TCP_SOCKET_ESTABLISHED:
     2193                socket_data->state = TCP_SOCKET_FIN_WAIT_1;
     2194                break;
     2195
     2196        case TCP_SOCKET_CLOSE_WAIT:
     2197                socket_data->state = TCP_SOCKET_LAST_ACK;
     2198                break;
     2199
     2200//      case TCP_SOCKET_LISTEN:
     2201
     2202        default:
     2203                // just destroy
     2204                if (ERROR_NONE(socket_destroy(tcp_globals.net_phone, socket_id,
     2205                    local_sockets, &tcp_globals.sockets,
     2206                    tcp_free_socket_data))) {
     2207                        fibril_rwlock_write_unlock(socket_data->local_lock);
     2208                        fibril_rwlock_write_unlock(&tcp_globals.lock);
     2209                }
     2210                return ERROR_CODE;
     2211        }
     2212
    18632213        // send FIN
    18642214        // TODO should I wait to complete?
    18652215
    18662216        // create the notification packet
    1867         ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket, socket_data, 0, 1));
     2217        ERROR_PROPAGATE(tcp_create_notification_packet(&packet, socket,
     2218            socket_data, 0, 1));
    18682219
    18692220        // send the packet
     
    18742225        fibril_rwlock_write_unlock(socket_data->local_lock);
    18752226        fibril_rwlock_write_unlock(&tcp_globals.lock);
    1876         if(packet){
     2227
     2228        if (packet) {
    18772229                // send the packet
    18782230                tcp_send_packets(socket_data->device_id, packet);
    18792231        }
     2232
    18802233        return EOK;
    18812234}
    18822235
    1883 int tcp_create_notification_packet(packet_t * packet, socket_core_ref socket, tcp_socket_data_ref socket_data, int synchronize, int finalize){
     2236int
     2237tcp_create_notification_packet(packet_t * packet, socket_core_ref socket,
     2238    tcp_socket_data_ref socket_data, int synchronize, int finalize)
     2239{
    18842240        ERROR_DECLARE;
    18852241
     
    18902246
    18912247        // get the device packet dimension
    1892         ERROR_PROPAGATE(tl_get_ip_packet_dimension(tcp_globals.ip_phone, &tcp_globals.dimensions, socket_data->device_id, &packet_dimension));
     2248        ERROR_PROPAGATE(tl_get_ip_packet_dimension(tcp_globals.ip_phone,
     2249            &tcp_globals.dimensions, socket_data->device_id,
     2250            &packet_dimension));
     2251
    18932252        // get a new packet
    1894         *packet = packet_get_4_remote(tcp_globals.net_phone, TCP_HEADER_SIZE, packet_dimension->addr_len, packet_dimension->prefix, packet_dimension->suffix);
    1895         if(! * packet){
     2253        *packet = packet_get_4_remote(tcp_globals.net_phone, TCP_HEADER_SIZE,
     2254            packet_dimension->addr_len, packet_dimension->prefix,
     2255            packet_dimension->suffix);
     2256       
     2257        if (!*packet)
    18962258                return ENOMEM;
    1897         }
     2259
    18982260        // allocate space in the packet
    18992261        header = PACKET_SUFFIX(*packet, tcp_header_t);
    1900         if(! header){
     2262        if (!header)
    19012263                tcp_release_and_return(*packet, ENOMEM);
    1902         }
    1903 
    1904         tcp_prepare_operation_header(socket, socket_data, header, synchronize, finalize);
     2264
     2265        tcp_prepare_operation_header(socket, socket_data, header, synchronize,
     2266            finalize);
     2267
    19052268        return EOK;
    19062269}
    19072270
    1908 int tcp_accept_message(socket_cores_ref local_sockets, int socket_id, int new_socket_id, size_t * data_fragment_size, size_t * addrlen){
     2271int
     2272tcp_accept_message(socket_cores_ref local_sockets, int socket_id,
     2273    int new_socket_id, size_t * data_fragment_size, size_t * addrlen)
     2274{
    19092275        ERROR_DECLARE;
    19102276
     
    19202286        // find the socket
    19212287        socket = socket_cores_find(local_sockets, socket_id);
    1922         if(! socket){
     2288        if (!socket)
    19232289                return ENOTSOCK;
    1924         }
     2290
    19252291        // get the socket specific data
    19262292        socket_data = (tcp_socket_data_ref) socket->specific_data;
     
    19282294
    19292295        // check state
    1930         if(socket_data->state != TCP_SOCKET_LISTEN){
     2296        if (socket_data->state != TCP_SOCKET_LISTEN)
    19312297                return EINVAL;
    1932         }
    1933 
    1934         do{
     2298
     2299        do {
    19352300                socket_id = dyn_fifo_value(&socket->accepted);
    1936                 if(socket_id < 0){
     2301                if (socket_id < 0)
    19372302                        return ENOTSOCK;
    1938                 }
    19392303                socket_id *= -1;
    19402304
    19412305                accepted = socket_cores_find(local_sockets, socket_id);
    1942                 if(! accepted){
     2306                if (!accepted)
    19432307                        return ENOTSOCK;
    1944                 }
     2308
    19452309                // get the socket specific data
    19462310                socket_data = (tcp_socket_data_ref) accepted->specific_data;
    19472311                assert(socket_data);
    19482312                // TODO can it be in another state?
    1949                 if(socket_data->state == TCP_SOCKET_ESTABLISHED){
    1950                         ERROR_PROPAGATE(data_reply(socket_data->addr, socket_data->addrlen));
    1951                         ERROR_PROPAGATE(tl_get_ip_packet_dimension(tcp_globals.ip_phone, &tcp_globals.dimensions, socket_data->device_id, &packet_dimension));
     2313                if (socket_data->state == TCP_SOCKET_ESTABLISHED) {
     2314                        ERROR_PROPAGATE(data_reply(socket_data->addr,
     2315                            socket_data->addrlen));
     2316                        ERROR_PROPAGATE(tl_get_ip_packet_dimension(
     2317                            tcp_globals.ip_phone, &tcp_globals.dimensions,
     2318                            socket_data->device_id, &packet_dimension));
    19522319                        *addrlen = socket_data->addrlen;
    1953                         *data_fragment_size = ((packet_dimension->content < socket_data->data_fragment_size) ? packet_dimension->content : socket_data->data_fragment_size);
    1954                         if(new_socket_id > 0){
    1955                                 ERROR_PROPAGATE(socket_cores_update(local_sockets, accepted->socket_id, new_socket_id));
     2320
     2321                        *data_fragment_size =
     2322                            ((packet_dimension->content <
     2323                            socket_data->data_fragment_size) ?
     2324                            packet_dimension->content :
     2325                            socket_data->data_fragment_size);
     2326       
     2327                        if (new_socket_id > 0) {
     2328                                ERROR_PROPAGATE(socket_cores_update(
     2329                                    local_sockets, accepted->socket_id,
     2330                                    new_socket_id));
    19562331                                accepted->socket_id = new_socket_id;
    19572332                        }
    19582333                }
    19592334                dyn_fifo_pop(&socket->accepted);
    1960         }while(socket_data->state != TCP_SOCKET_ESTABLISHED);
     2335        } while (socket_data->state != TCP_SOCKET_ESTABLISHED);
     2336
    19612337        printf("ret accept %d\n", accepted->socket_id);
    19622338        return accepted->socket_id;
    19632339}
    19642340
    1965 void tcp_free_socket_data(socket_core_ref socket){
     2341void
     2342tcp_free_socket_data(socket_core_ref socket)
     2343{
    19662344        tcp_socket_data_ref socket_data;
    19672345
     
    19742352        assert(socket_data);
    19752353        //free the pseudo header
    1976         if(socket_data->pseudo_header){
    1977                 if(socket_data->headerlen){
     2354        if (socket_data->pseudo_header) {
     2355                if (socket_data->headerlen) {
    19782356                        printf("d pseudo\n");
    19792357                        free(socket_data->pseudo_header);
     
    19842362        socket_data->headerlen = 0;
    19852363        // free the address
    1986         if(socket_data->addr){
    1987                 if(socket_data->addrlen){
     2364        if (socket_data->addr) {
     2365                if (socket_data->addrlen) {
    19882366                        printf("d addr\n");
    19892367                        free(socket_data->addr);
     
    19952373}
    19962374
    1997 int tcp_release_and_return(packet_t packet, int result){
     2375int tcp_release_and_return(packet_t packet, int result)
     2376{
    19982377        pq_release_remote(tcp_globals.net_phone, packet_get_id(packet));
    19992378        return result;
     
    20132392         */
    20142393        ipc_answer_0(iid, EOK);
    2015        
    2016         while(true) {
     2394
     2395        while (true) {
    20172396                ipc_call_t answer;
    20182397                int answer_count;
    2019                
    2020                 /* Clear the answer structure */
     2398
     2399                /*
     2400                   Clear the answer structure
     2401                 */
    20212402                refresh_answer(&answer, &answer_count);
    2022                
    2023                 /* Fetch the next message */
     2403
     2404                /*
     2405                   Fetch the next message
     2406                 */
    20242407                ipc_call_t call;
    20252408                ipc_callid_t callid = async_get_call(&call);
    2026                
    2027                 /* Process the message */
     2409
     2410                /*
     2411                   Process the message
     2412                 */
    20282413                int res = tl_module_message_standalone(callid, &call, &answer,
    20292414                    &answer_count);
    2030                
    2031                 /* End if said to either by the message or the processing result */
    2032                 if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) || (res == EHANGUP))
     2415
     2416                /*
     2417                   End if said to either by the message or the processing result
     2418                 */
     2419                if ((IPC_GET_METHOD(call) == IPC_M_PHONE_HUNGUP) ||
     2420                    (res == EHANGUP))
    20332421                        return;
    2034                
    2035                 /* Answer the message */
     2422
     2423                /*
     2424                   Answer the message
     2425                 */
    20362426                answer_call(callid, res, &answer, answer_count);
    20372427        }
     
    20472437 *
    20482438 */
    2049 int main(int argc, char *argv[])
     2439int
     2440main(int argc, char *argv[])
    20502441{
    20512442        ERROR_DECLARE;
    2052        
    2053         /* Start the module */
     2443
     2444        /*
     2445           Start the module
     2446         */
    20542447        if (ERROR_OCCURRED(tl_module_start_standalone(tl_client_connection)))
    20552448                return ERROR_CODE;
    2056        
     2449
    20572450        return EOK;
    20582451}
Note: See TracChangeset for help on using the changeset viewer.