Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset dc94cb2 in mainline


Ignore:
Timestamp:
2010-09-19T13:33:47Z (11 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master
Children:
2a786f9
Parents:
5203efb1 (diff), 7c8267b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Marge from lp:~jakub/helenos/net.

Location:
uspace
Files:
5 edited

Legend:

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

    r5203efb1 rdc94cb2  
    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

    r5203efb1 rdc94cb2  
    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/include/net_err.h

    r5203efb1 rdc94cb2  
    8181#endif
    8282
     83#define ERROR_NONE(value)       !ERROR_OCCURRED((value))
     84
    8385/** Error propagation
    8486 *
  • uspace/lib/socket/packet/packet_client.c

    r5203efb1 rdc94cb2  
    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

    r5203efb1 rdc94cb2  
    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.