WebSVN – HelenOS – Diff – /branches/network/uspace/srv/net/tl/tcp/tcp.c


/*
 * Copyright (c) 2008 Lukas Mejdrech
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
/** @addtogroup tcp
 *  @{
 */
 
/** @file
 *  TCP module implementation.
 *  @see tcp.h
 *  \todo
 */
 
#include <assert.h>
#include <async.h>
#include <fibril_sync.h>
#include <malloc.h>
//TODO remove stdio
#include <stdio.h>
 
#include <ipc/ipc.h>
#include <ipc/services.h>
 
#include "../../err.h"
#include "../../messages.h"
#include "../../modules.h"
 
#include "../../structures/dynamic_fifo.h"
#include "../../structures/packet/packet_client.h"
 
#include "../../include/checksum.h"
#include "../../include/in.h"
#include "../../include/in6.h"
#include "../../include/inet.h"
#include "../../include/ip_client.h"
#include "../../include/ip_interface.h"
#include "../../include/ip_protocols.h"
#include "../../include/icmp_client.h"
#include "../../include/icmp_interface.h"
#include "../../include/net_interface.h"
#include "../../include/socket_codes.h"
#include "../../include/socket_errno.h"
#include "../../include/tcp_codes.h"
 
#include "../../socket/socket_core.h"
#include "../../socket/socket_messages.h"
 
#include "../tl_common.h"
#include "../tl_messages.h"
 
#include "tcp.h"
#include "tcp_header.h"
#include "tcp_module.h"
 
/** The TCP window default value.
 */
#define NET_DEFAULT_TCP_WINDOW  10240
 
/** \todo
 */
#define NET_DEFAULT_TCP_INITIAL_TIMEOUT 3000000L
 
/** \todo
 */
#define NET_DEFAULT_TCP_TIME_WAIT_TIMEOUT   2000L
 
/** The initial outgoing sequence number.
 */
#define TCP_INITIAL_SEQUENCE_NUMBER     2999
 
/** Maximum TCP fragment size.
 */
#define MAX_TCP_FRAGMENT_SIZE   65535
 
/** Free ports pool start.
 */
#define TCP_FREE_PORTS_START    1025
 
/** Free ports pool end.
 */
#define TCP_FREE_PORTS_END      65535
 
/** \todo
 */
#define TCP_SYN_SENT_TIMEOUT    1000000L
 
/** The maximum number of timeouts in a row before singaling connection lost.
 */
#define TCP_MAX_TIMEOUTS        8
 
/** The number of acknowledgements before retransmit.
 */
#define TCP_FAST_RETRANSMIT_COUNT   3
 
/** \todo
 */
#define IS_IN_INTERVAL_OVERFLOW( lower, value, higher_equal )   (((( lower ) < ( value )) && ((( value ) <= ( higher_equal )) || (( higher_equal ) < ( lower )))) || ((( value ) <= ( higher_equal )) && (( higher_equal ) < ( lower ))))
 
/** Type definition of the TCP timeout.
 *  @see tcp_timeout
 */
typedef struct tcp_timeout  tcp_timeout_t;
 
/** Type definition of the TCP timeout pointer.
 *  @see tcp_timeout
 */
typedef tcp_timeout_t * tcp_timeout_ref;
 
/** TCP reply timeout data.
 *  Used as a timeouting fibril argument.
 *  @see tcp_timeout()
 */
struct tcp_timeout{
    /** TCP global data are going to be read only.
     */
    int                 globals_read_only;
    /** Socket port.
     */
    int                 port;
    /** Local sockets.
     */
    socket_cores_ref    local_sockets;
    /** Socket identifier.
     */
    int                 socket_id;
    /** Socket state.
     */
    tcp_socket_state_t  state;
    /** Sent packet sequence number.
     */
    int                 sequence_number;
    /** Timeout in microseconds.
     */
    suseconds_t         timeout;
    /** Port map key.
     */
    char *              key;
    /** Port map key length.
     */
    size_t              key_length;
};
 
/** Releases the packet and returns the result.
 *  @param packet The packet queue to be released. Input parameter.
 *  @param result The result to be returned. Input parameter.
 *  @return The result parameter.
 */
int tcp_release_and_return( packet_t packet, int result );
 
 
void    tcp_prepare_operation_header( socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, int synchronize, int finalize );
int tcp_prepare_timeout( int ( * timeout_function )( void * tcp_timeout_t ), socket_core_ref socket, tcp_socket_data_ref socket_data, size_t sequence_number, tcp_socket_state_t state, suseconds_t timeout, int globals_read_only );
void    tcp_free_socket_data( socket_core_ref socket );
int tcp_timeout( void * data );
int tcp_release_after_timeout( void * data );
int tcp_process_packet( device_id_t device_id, packet_t packet, services_t error );
int tcp_connect_core( socket_core_ref socket, socket_cores_ref local_sockets, struct sockaddr * addr, socklen_t addrlen );
int tcp_queue_prepare_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length );
int tcp_queue_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length );
packet_t    tcp_get_packets_to_send( socket_core_ref socket, tcp_socket_data_ref socket_data );
void    tcp_send_packets( device_id_t device_id, packet_t packet );
void    tcp_process_acknowledgement( socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header );
packet_t    tcp_send_prepare_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length, size_t sequence_number );
packet_t    tcp_prepare_copy( socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length, size_t sequence_number );
void    tcp_retransmit_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, size_t sequence_number );
int tcp_create_notification_packet( packet_t * packet, socket_core_ref socket, tcp_socket_data_ref socket_data, int synchronize, int finalize );
void    tcp_refresh_socket_data( tcp_socket_data_ref socket_data );
void    tcp_initialize_socket_data( tcp_socket_data_ref socket_data );
int tcp_process_listen( socket_core_ref listening_socket, tcp_socket_data_ref listening_socket_data, tcp_header_ref header, packet_t packet, struct sockaddr * src, struct sockaddr * dest, size_t addrlen );
int tcp_process_syn_sent( socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet );
int tcp_process_syn_received( socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet );
int tcp_process_established( socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet, int fragments, size_t total_length );
int tcp_queue_received_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, int fragments, size_t total_length );
 
int tcp_received_msg( device_id_t device_id, packet_t packet, services_t receiver, services_t error );
int tcp_process_client_messages( ipc_callid_t callid, ipc_call_t call );
int tcp_listen_message( socket_cores_ref local_sockets, int socket_id, int backlog );
int tcp_connect_message( socket_cores_ref local_sockets, int socket_id, struct sockaddr * addr, socklen_t addrlen );
int tcp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags, size_t * addrlen );
int tcp_send_message( socket_cores_ref local_sockets, int socket_id, int fragments, size_t data_fragment_size, int flags );
int tcp_accept_message( socket_cores_ref local_sockets, int socket_id, size_t * addrlen );
int tcp_close_message( socket_cores_ref local_sockets, int socket_id );
 
 
 
/** TCP global data.
 */
tcp_globals_t   tcp_globals;
 
/** Initializes the module.
 */
int tcp_initialize( async_client_conn_t client_connection ){
    ERROR_DECLARE;
 
    assert( client_connection );
    fibril_rwlock_initialize( & tcp_globals.lock );
    fibril_rwlock_write_lock( & tcp_globals.lock );
    tcp_globals.icmp_phone = icmp_connect_module( SERVICE_ICMP );
    if( tcp_globals.icmp_phone < 0 ){
        return tcp_globals.icmp_phone;
    }
    tcp_globals.ip_phone = ip_bind_service( SERVICE_IP, IPPROTO_TCP, SERVICE_TCP, client_connection, tcp_received_msg );
    if( tcp_globals.ip_phone < 0 ){
        return tcp_globals.ip_phone;
    }
    ERROR_PROPAGATE( socket_ports_initialize( & tcp_globals.sockets ));
    if( ERROR_OCCURRED( packet_dimensions_initialize( & tcp_globals.dimensions ))){
        socket_ports_destroy( & tcp_globals.sockets );
        return ERROR_CODE;
    }
    tcp_globals.last_used_port = TCP_FREE_PORTS_START - 1;
    fibril_rwlock_write_unlock( & tcp_globals.lock );
    return EOK;
}
 
int tcp_received_msg( device_id_t device_id, packet_t packet, services_t receiver, services_t error ){
    ERROR_DECLARE;
 
    if( receiver != SERVICE_TCP ) return EREFUSED;
    fibril_rwlock_write_lock( & tcp_globals.lock );
    if( ERROR_OCCURRED( tcp_process_packet( device_id, packet, error ))){
        fibril_rwlock_write_unlock( & tcp_globals.lock );
    }
    printf( "receive %d \n", ERROR_CODE );
 
    return ERROR_CODE;
}
 
int tcp_process_packet( device_id_t device_id, packet_t packet, services_t error ){
    ERROR_DECLARE;
 
    size_t              length;
    size_t              offset;
    int                 result;
    tcp_header_ref      header;
    socket_core_ref     socket;
    tcp_socket_data_ref socket_data;
    packet_t            next_packet;
    size_t              total_length;
    uint32_t            checksum;
    int                 fragments;
    icmp_type_t         type;
    icmp_code_t         code;
    struct sockaddr *   src;
    struct sockaddr *   dest;
    size_t              addrlen;
 
    printf( "p1 \n" );
    if( error ){
        switch( error ){
            case SERVICE_ICMP:
                // process error
                result = icmp_client_process_packet( packet, & type, & code, NULL, NULL );
                if( result < 0 ){
                    return tcp_release_and_return( packet, result );
                }
                length = ( size_t ) result;
                if( ERROR_OCCURRED( packet_trim( packet, length, 0 ))){
                    return tcp_release_and_return( packet, ERROR_CODE );
                }
                break;
            default:
                return tcp_release_and_return( packet, ENOTSUP );
        }
    }
 
    // TODO process received ipopts?
    result = ip_client_process_packet( packet, NULL, NULL, NULL, NULL, NULL );
//  printf("ip len %d\n", result );
    if( result < 0 ){
        return tcp_release_and_return( packet, result );
    }
    offset = ( size_t ) result;
 
    length = packet_get_data_length( packet );
//  printf("packet len %d\n", length );
    if( length <= 0 ){
        return tcp_release_and_return( packet, EINVAL );
    }
    if( length < sizeof( tcp_header_t ) + offset ){
        return tcp_release_and_return( packet, NO_DATA );
    }
 
    // trim all but TCP header
    if( ERROR_OCCURRED( packet_trim( packet, offset, 0 ))){
        return tcp_release_and_return( packet, ERROR_CODE );
    }
 
    // get tcp header
    header = ( tcp_header_ref ) packet_get_data( packet );
    if( ! header ){
        return tcp_release_and_return( packet, NO_DATA );
    }
//  printf( "header len %d, port %d \n", TCP_HEADER_LENGTH( header ), ntohs( header->destination_port ));
 
    result = packet_get_addr( packet, ( uint8_t ** ) & src, ( uint8_t ** ) & dest );
    if( result <= 0 ){
        return tcp_release_and_return( packet, result );
    }
    addrlen = ( size_t ) result;
 
    if( ERROR_OCCURRED( tl_set_address_port( src, addrlen, ntohs( header->source_port )))){
        return tcp_release_and_return( packet, ERROR_CODE );
    }
 
    // find the destination socket
    socket = socket_port_find( & tcp_globals.sockets, ntohs( header->destination_port ), ( const char * ) src, addrlen );
    if( ! socket ){
//      printf("listening?\n");
        // find the listening destination socket
        socket = socket_port_find( & tcp_globals.sockets, ntohs( header->destination_port ), SOCKET_MAP_KEY_LISTENING, 0 );
        if( ! socket ){
            if( tl_prepare_icmp_packet( tcp_globals.net_phone, tcp_globals.icmp_phone, packet, error ) == EOK ){
                icmp_destination_unreachable_msg( tcp_globals.icmp_phone, ICMP_PORT_UNREACH, 0, packet );
            }
            return EADDRNOTAVAIL;
        }
    }
    printf("socket id %d\n", socket->socket_id );
    socket_data = ( tcp_socket_data_ref ) socket->specific_data;
    assert( socket_data );
 
    // some data received, clear the timeout counter
    socket_data->timeout_count = 0;
 
    // count the received packet fragments
    next_packet = packet;
    fragments = 0;
    checksum = 0;
    total_length = 0;
    do{
        ++ fragments;
        length = packet_get_data_length( next_packet );
        if( length <= 0 ){
            return tcp_release_and_return( packet, NO_DATA );
        }
        total_length += length;
        // add partial checksum if set
        if( ! error ){
            checksum = compute_checksum( checksum, packet_get_data( packet ), packet_get_data_length( packet ));
        }
    }while(( next_packet = pq_next( next_packet )));
//  printf( "fragments %d of %d bytes\n", fragments, total_length );
 
//  printf("lock?\n");
    fibril_rwlock_write_lock( socket_data->local_lock );
//  printf("locked\n");
    if( ! error ){
        if( socket_data->state == TCP_SOCKET_LISTEN ){
            if( socket_data->pseudo_header ){
                free( socket_data->pseudo_header );
                socket_data->pseudo_header = NULL;
                socket_data->headerlen = 0;
            }
            if( ERROR_OCCURRED( ip_client_get_pseudo_header( IPPROTO_TCP, src, addrlen, dest, addrlen, total_length, & socket_data->pseudo_header, & socket_data->headerlen ))){
                fibril_rwlock_write_unlock( socket_data->local_lock );
                return tcp_release_and_return( packet, ERROR_CODE );
            }
        }else if( ERROR_OCCURRED( ip_client_set_pseudo_header_data_length( socket_data->pseudo_header, socket_data->headerlen, total_length ))){
            fibril_rwlock_write_unlock( socket_data->local_lock );
            return tcp_release_and_return( packet, ERROR_CODE );
        }
        checksum = compute_checksum( checksum, socket_data->pseudo_header, socket_data->headerlen );
        if( flip_checksum( compact_checksum( checksum ))){
            printf( "checksum err %x -> %x\n", header->checksum, flip_checksum( compact_checksum( checksum )));
            fibril_rwlock_write_unlock( socket_data->local_lock );
            if( ! ERROR_OCCURRED( tl_prepare_icmp_packet( tcp_globals.net_phone, tcp_globals.icmp_phone, packet, error ))){
                // checksum error ICMP
                icmp_parameter_problem_msg( tcp_globals.icmp_phone, ICMP_PARAM_POINTER, (( size_t ) (( void * ) & header->checksum )) - (( size_t ) (( void * ) header )), packet );
            }
            return EINVAL;
        }
    }
 
    fibril_rwlock_read_unlock( & tcp_globals.lock );
 
    // TODO error reporting/handling
//  printf( "st %d\n", socket_data->state );
    switch( socket_data->state ){
        case TCP_SOCKET_LISTEN:
            ERROR_CODE = tcp_process_listen( socket, socket_data, header, packet, src, dest, addrlen );
            break;
        case TCP_SOCKET_SYN_RECEIVED:
            ERROR_CODE = tcp_process_syn_received( socket, socket_data, header, packet );
            break;
        case TCP_SOCKET_SYN_SENT:
            ERROR_CODE = tcp_process_syn_sent( socket, socket_data, header, packet );
            break;
        case TCP_SOCKET_FIN_WAIT_1:
            // ack changing the state to FIN_WAIT_2 gets processed later
        case TCP_SOCKET_FIN_WAIT_2:
            // fin changing state to LAST_ACK gets processed later
        case TCP_SOCKET_LAST_ACK:
            // ack releasing the socket get processed later
        case TCP_SOCKET_CLOSING:
            // ack releasing the socket gets processed later
        case TCP_SOCKET_ESTABLISHED:
            ERROR_CODE = tcp_process_established( socket, socket_data, header, packet, fragments, total_length );
            break;
        default:
            pq_release( tcp_globals.net_phone, packet_get_id( packet ));
    }
 
    if( ERROR_CODE != EOK ){
        printf( "process %d\n", ERROR_CODE );
        fibril_rwlock_write_unlock( socket_data->local_lock );
    }
    return EOK;
}
 
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 ){
    ERROR_DECLARE;
 
    packet_t    next_packet;
    packet_t    tmp_packet;
    uint32_t    old_incoming;
    size_t      order;
    uint32_t    sequence_number;
    size_t      length;
    size_t      offset;
    uint32_t    new_sequence_number;
 
    assert( socket );
    assert( socket_data );
    assert( socket->specific_data == socket_data );
    assert( header );
    assert( packet );
 
    new_sequence_number = ntohl( header->sequence_number );
    old_incoming = socket_data->next_incoming;
 
    if( header->finalize ){
        socket_data->fin_incoming = new_sequence_number;
    }
 
//  printf( "pe %d < %d <= %d\n", new_sequence_number, socket_data->next_incoming, new_sequence_number + total_length );
    // trim begining if containing expected data
    if( IS_IN_INTERVAL_OVERFLOW( new_sequence_number, socket_data->next_incoming, new_sequence_number + total_length )){
        // get the acknowledged offset
        if( socket_data->next_incoming < new_sequence_number ){
            offset = new_sequence_number - socket_data->next_incoming;
        }else{
            offset = socket_data->next_incoming - new_sequence_number;
        }
//      printf( "offset %d\n", offset );
        new_sequence_number += offset;
        total_length -= offset;
        length = packet_get_data_length( packet );
        // trim the acknowledged data
        while( length <= offset ){
            // release the acknowledged packets
            next_packet = pq_next( packet );
            pq_release( tcp_globals.net_phone, packet_get_id( packet ));
            packet = next_packet;
            offset -= length;
            length = packet_get_data_length( packet );
        }
        if(( offset > 0 )
        && ( ERROR_OCCURRED( packet_trim( packet, offset, 0 )))){
            return tcp_release_and_return( packet, ERROR_CODE );
        }
        assert( new_sequence_number == socket_data->next_incoming );
    }
 
    // release if overflowing the window
//  if( IS_IN_INTERVAL_OVERFLOW( socket_data->next_incoming + socket_data->window, new_sequence_number, new_sequence_number + total_length )){
//      return tcp_release_and_return( packet, EOVERFLOW );
//  }
 
/*
    // trim end if overflowing the window
    if( IS_IN_INTERVAL_OVERFLOW( new_sequence_number, socket_data->next_incoming + socket_data->window, new_sequence_number + total_length )){
        // get the allowed data length
        if( socket_data->next_incoming + socket_data->window < new_sequence_number ){
            offset = new_sequence_number - socket_data->next_incoming + socket_data->window;
        }else{
            offset = socket_data->next_incoming + socket_data->window - new_sequence_number;
        }
        next_packet = packet;
        // trim the overflowing data
        while( next_packet && ( offset > 0 )){
            length = packet_get_data_length( packet );
            if( length <= offset ){
                next_packet = pq_next( next_packet );
            }else if( ERROR_OCCURRED( packet_trim( next_packet, 0, length - offset ))){
                return tcp_release_and_return( packet, ERROR_CODE );
            }
            offset -= length;
            total_length -= length - offset;
        }
        // release the overflowing packets
        next_packet = pq_next( next_packet );
        if( next_packet ){
            tmp_packet = next_packet;
            next_packet = pq_next( next_packet );
            pq_insert_after( tmp_packet, next_packet );
            pq_release( tcp_globals.net_phone, packet_get_id( tmp_packet ));
        }
        assert( new_sequence_number + total_length == socket_data->next_incoming + socket_data->window );
    }
*/
    // the expected one arrived?
    if( new_sequence_number == socket_data->next_incoming ){
        printf("expected\n");
        // process acknowledgement
        tcp_process_acknowledgement( socket, socket_data, header );
 
        // remove the header
        total_length -= TCP_HEADER_LENGTH( header );
        if( ERROR_OCCURRED( packet_trim( packet, TCP_HEADER_LENGTH( header ), 0 ))){
            return tcp_release_and_return( packet, ERROR_CODE );
        }
 
        if( total_length ){
            ERROR_PROPAGATE( tcp_queue_received_packet( socket, socket_data, packet, fragments, total_length ));
        }else{
            total_length = 1;
        }
        socket_data->next_incoming = old_incoming + total_length;
        packet = socket_data->incoming;
        while( packet ){
            if( ERROR_OCCURRED( pq_get_order( socket_data->incoming, & order, NULL ))){
                // remove the corrupted packet
                next_packet = pq_detach( packet );
                if( packet == socket_data->incoming ){
                    socket_data->incoming = next_packet;
                }
                pq_release( tcp_globals.net_phone, packet_get_id( packet ));
                packet = next_packet;
                continue;
            }
            sequence_number = ( uint32_t ) order;
            if( IS_IN_INTERVAL_OVERFLOW( sequence_number, old_incoming, socket_data->next_incoming )){
                // move to the next
                packet = pq_next( packet );
            // coninual data?
            }else if( IS_IN_INTERVAL_OVERFLOW( old_incoming, sequence_number, socket_data->next_incoming )){
                // detach the packet
                next_packet = pq_detach( packet );
                if( packet == socket_data->incoming ){
                    socket_data->incoming = next_packet;
                }
                // get data length
                length = packet_get_data_length( packet );
                new_sequence_number = sequence_number + length;
                if( length <= 0 ){
                    // remove the empty packet
                    pq_release( tcp_globals.net_phone, packet_get_id( packet ));
                    packet = next_packet;
                    continue;
                }
                // exactly following
                if( sequence_number == socket_data->next_incoming ){
                    // queue received data
                    ERROR_PROPAGATE( tcp_queue_received_packet( socket, socket_data, packet, 1, packet_get_data_length( packet )));
                    socket_data->next_incoming = new_sequence_number;
                    packet = next_packet;
                    continue;
                // at least partly following data?
                }else if( IS_IN_INTERVAL_OVERFLOW( sequence_number, socket_data->next_incoming, new_sequence_number )){
                    if( socket_data->next_incoming < new_sequence_number ){
                        length = new_sequence_number - socket_data->next_incoming;
                    }else{
                        length = socket_data->next_incoming - new_sequence_number;
                    }
                    if( ! ERROR_OCCURRED( packet_trim( packet, length, 0 ))){
                        // queue received data
                        ERROR_PROPAGATE( tcp_queue_received_packet( socket, socket_data, packet, 1, packet_get_data_length( packet )));
                        socket_data->next_incoming = new_sequence_number;
                        packet = next_packet;
                        continue;
                    }
                }
                // remove the duplicit or corrupted packet
                pq_release( tcp_globals.net_phone, packet_get_id( packet ));
                packet = next_packet;
                continue;
            }else{
                break;
            }
        }
    }else if( IS_IN_INTERVAL( socket_data->next_incoming, new_sequence_number, socket_data->next_incoming + socket_data->window )){
        printf("in window\n");
        // process acknowledgement
        tcp_process_acknowledgement( socket, socket_data, header );
 
        // remove the header
        total_length -= TCP_HEADER_LENGTH( header );
        if( ERROR_OCCURRED( packet_trim( packet, TCP_HEADER_LENGTH( header ), 0 ))){
            return tcp_release_and_return( packet, ERROR_CODE );
        }
 
        next_packet = pq_detach( packet );
        length = packet_get_data_length( packet );
        tmp_packet = pq_add( socket_data->incoming, packet, new_sequence_number, length );
        if( ! tmp_packet ){
            // remove the corrupted packets
            pq_release( tcp_globals.net_phone, packet_get_id( packet ));
            pq_release( tcp_globals.net_phone, packet_get_id( next_packet ));
        }else{
            socket_data->incoming = tmp_packet;
            while( next_packet ){
                new_sequence_number += length;
                tmp_packet = pq_detach( next_packet );
                length = packet_get_data_length( next_packet );
                if( ERROR_OCCURRED( pq_set_order( next_packet, new_sequence_number, length ))
                || ERROR_OCCURRED( pq_insert_after( packet, next_packet ))){
                    pq_release( tcp_globals.net_phone, packet_get_id( next_packet ));
                }
                next_packet = tmp_packet;
            }
        }
    }else{
        printf("unexpected\n");
        // release duplicite or restricted
        pq_release( tcp_globals.net_phone, packet_get_id( packet ));
    }
 
    // change state according to the acknowledging incoming fin
    if( IS_IN_INTERVAL_OVERFLOW( old_incoming, socket_data->fin_incoming, socket_data->next_incoming )){
        switch( socket_data->state ){
            case TCP_SOCKET_FIN_WAIT_1:
            case TCP_SOCKET_FIN_WAIT_2:
            case TCP_SOCKET_CLOSING:
                socket_data->state = TCP_SOCKET_CLOSING;
                break;
            //case TCP_ESTABLISHED:
            default:
                socket_data->state = TCP_SOCKET_CLOSE_WAIT;
                break;
        }
    }
 
    packet = tcp_get_packets_to_send( socket, socket_data );
    if( ! packet ){
        // create the notification packet
        ERROR_PROPAGATE( tcp_create_notification_packet( & packet, socket, socket_data, 0, 0 ));
        ERROR_PROPAGATE( tcp_queue_prepare_packet( socket, socket_data, packet, 1 ));
        packet = tcp_send_prepare_packet( socket, socket_data, packet, 1, socket_data->last_outgoing + 1 );
    }
    fibril_rwlock_write_unlock( socket_data->local_lock );
    // send the packet
    tcp_send_packets( socket_data->device_id, packet );
    return EOK;
}
 
int tcp_queue_received_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, int fragments, size_t total_length ){
    ERROR_DECLARE;
 
    assert( socket );
    assert( socket_data );
    assert( socket->specific_data == socket_data );
    assert( packet );
    assert( fragments >= 1 );
    assert( socket_data->window > total_length );
 
    // queue the received packet
    if( ERROR_OCCURRED( dyn_fifo_push( & socket->received, packet_get_id( packet ), SOCKET_MAX_RECEIVED_SIZE ))){
        return tcp_release_and_return( packet, ERROR_CODE );
    }
 
    // decrease the window size
    socket_data->window -= total_length;
 
    // notify the destination socket
    async_msg_5( socket->phone, NET_SOCKET_RECEIVED, ( ipcarg_t ) socket->socket_id, 0, 0, 0, ( ipcarg_t ) fragments );
    return EOK;
}
 
int tcp_process_syn_sent( socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet ){
    ERROR_DECLARE;
 
    packet_t    next_packet;
 
    assert( socket );
    assert( socket_data );
    assert( socket->specific_data == socket_data );
    assert( header );
    assert( packet );
 
    if( header->synchronize ){
        // process acknowledgement
        tcp_process_acknowledgement( socket, socket_data, header );
 
        socket_data->next_incoming = ntohl( header->sequence_number ) + 1;
        // release additional packets
        next_packet = pq_detach( packet );
        if( next_packet ){
            pq_release( tcp_globals.net_phone, packet_get_id( next_packet ));
        }
        // trim if longer than the header
        if(( packet_get_data_length( packet ) > sizeof( * header ))
        && ERROR_OCCURRED( packet_trim( packet, 0, packet_get_data_length( packet ) - sizeof( * header )))){
            return tcp_release_and_return( packet, ERROR_CODE );
        }
        tcp_prepare_operation_header( socket, socket_data, header, 0, 0 );
        fibril_mutex_lock( & socket_data->operation.mutex );
        socket_data->operation.result = tcp_queue_packet( socket, socket_data, packet, 1 );
        if( socket_data->operation.result == EOK ){
            socket_data->state = TCP_SOCKET_ESTABLISHED;
            packet = tcp_get_packets_to_send( socket, socket_data );
            if( packet ){
                fibril_rwlock_write_unlock( socket_data->local_lock );
                // send the packet
                tcp_send_packets( socket_data->device_id, packet );
                // signal the result
                fibril_condvar_signal( & socket_data->operation.condvar );
                fibril_mutex_unlock( & socket_data->operation.mutex );
                return EOK;
            }
        }
        fibril_mutex_unlock( & socket_data->operation.mutex );
    }
    return tcp_release_and_return( packet, EINVAL );
}
 
int tcp_process_listen( socket_core_ref listening_socket, tcp_socket_data_ref listening_socket_data, tcp_header_ref header, packet_t packet, struct sockaddr * src, struct sockaddr * dest, size_t addrlen ){
    ERROR_DECLARE;
 
    packet_t            next_packet;
    socket_core_ref     socket;
    tcp_socket_data_ref socket_data;
    int                 socket_id;
    int                 listening_socket_id = listening_socket->socket_id;
    int                 listening_port = listening_socket->port;
 
    assert( listening_socket );
    assert( listening_socket_data );
    assert( listening_socket->specific_data == listening_socket_data );
    assert( header );
    assert( packet );
 
//  printf( "syn %d\n", header->synchronize );
    if( header->synchronize ){
        socket_data = ( tcp_socket_data_ref ) malloc( sizeof( * socket_data ));
        if( ! socket_data ){
            return tcp_release_and_return( packet, ENOMEM );
        }else{
            tcp_initialize_socket_data( socket_data );
            socket_data->local_lock = listening_socket_data->local_lock;
            socket_data->local_sockets = listening_socket_data->local_sockets;
            socket_data->listening_socket_id = listening_socket->socket_id;
 
            socket_data->next_incoming = ntohl( header->sequence_number );
            socket_data->treshold = socket_data->next_incoming + ntohs( header->window );
 
            socket_data->addrlen = addrlen;
            socket_data->addr = malloc( socket_data->addrlen );
            if( ! socket_data->addr ){
                free( socket_data );
                return tcp_release_and_return( packet, ENOMEM );
            }
            memcpy( socket_data->addr, src, socket_data->addrlen );
 
            socket_data->dest_port = ntohs( header->source_port );
            if( ERROR_OCCURRED( tl_set_address_port( socket_data->addr, socket_data->addrlen, socket_data->dest_port ))){
                free( socket_data->addr );
                free( socket_data );
                pq_release( tcp_globals.net_phone, packet_get_id( packet ));
                return ERROR_CODE;
            }
 
//          printf( "addr %p\n", socket_data->addr, socket_data->addrlen );
            // create a socket
            if( ERROR_OCCURRED( socket_create( socket_data->local_sockets, listening_socket->phone, socket_data, & socket_id ))){
                free( socket_data->addr );
                free( socket_data );
                return tcp_release_and_return( packet, ERROR_CODE );
            }
 
            printf("new_sock %d\n", socket_id);
            socket_data->pseudo_header = listening_socket_data->pseudo_header;
            socket_data->headerlen = listening_socket_data->headerlen;
            listening_socket_data->pseudo_header = NULL;
            listening_socket_data->headerlen = 0;
 
            fibril_rwlock_write_unlock( socket_data->local_lock );
//          printf("list lg\n");
            fibril_rwlock_write_lock( & tcp_globals.lock );
//          printf("list locked\n");
            // find the destination socket
            listening_socket = socket_port_find( & tcp_globals.sockets, listening_port, SOCKET_MAP_KEY_LISTENING, 0 );
            if(( ! listening_socket ) || ( listening_socket->socket_id != listening_socket_id )){
                fibril_rwlock_write_unlock( & tcp_globals.lock );
                // a shadow may remain until app hangs up
                return tcp_release_and_return( packet, EOK/*ENOTSOCK*/ );
            }
//          printf("port %d\n", listening_socket->port );
            listening_socket_data = ( tcp_socket_data_ref ) listening_socket->specific_data;
            assert( listening_socket_data );
 
//          printf("list ll\n");
            fibril_rwlock_write_lock( listening_socket_data->local_lock );
//          printf("list locked\n");
 
            socket = socket_cores_find( listening_socket_data->local_sockets, socket_id );
            if( ! socket ){
                // where is the socket?!?
                fibril_rwlock_write_unlock( & tcp_globals.lock );
                return ENOTSOCK;
            }
            socket_data = ( tcp_socket_data_ref ) socket->specific_data;
            assert( socket_data );
 
//          uint8_t * data = socket_data->addr;
//          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 ] );
 
            ERROR_CODE = socket_port_add( & tcp_globals.sockets, listening_port, socket, ( const char * ) socket_data->addr, socket_data->addrlen );
            assert( socket == socket_port_find( & tcp_globals.sockets, listening_port, ( const char * ) socket_data->addr, socket_data->addrlen ));
            //ERROR_CODE = socket_bind_free_port( & tcp_globals.sockets, socket, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END, tcp_globals.last_used_port );
            //tcp_globals.last_used_port = socket->port;
//          printf("bound %d\n", socket->port );
            fibril_rwlock_write_unlock( & tcp_globals.lock );
            if( ERROR_CODE != EOK ){
                socket_destroy( tcp_globals.net_phone, socket->socket_id, socket_data->local_sockets, & tcp_globals.sockets, tcp_free_socket_data );
                return tcp_release_and_return( packet, ERROR_CODE );
            }
 
            socket_data->state = TCP_SOCKET_LISTEN;
            socket_data->next_incoming = ntohl( header->sequence_number ) + 1;
            // release additional packets
            next_packet = pq_detach( packet );
            if( next_packet ){
                pq_release( tcp_globals.net_phone, packet_get_id( next_packet ));
            }
            // trim if longer than the header
            if(( packet_get_data_length( packet ) > sizeof( * header ))
            && ERROR_OCCURRED( packet_trim( packet, 0, packet_get_data_length( packet ) - sizeof( * header )))){
                socket_destroy( tcp_globals.net_phone, socket->socket_id, socket_data->local_sockets, & tcp_globals.sockets, tcp_free_socket_data );
                return tcp_release_and_return( packet, ERROR_CODE );
            }
            tcp_prepare_operation_header( socket, socket_data, header, 1, 0 );
            if( ERROR_OCCURRED( tcp_queue_packet( socket, socket_data, packet, 1 ))){
                socket_destroy( tcp_globals.net_phone, socket->socket_id, socket_data->local_sockets, & tcp_globals.sockets, tcp_free_socket_data );
                return ERROR_CODE;
            }
            packet = tcp_get_packets_to_send( socket, socket_data );
//          printf("send %d\n", packet_get_id( packet ));
            if( ! packet ){
                socket_destroy( tcp_globals.net_phone, socket->socket_id, socket_data->local_sockets, & tcp_globals.sockets, tcp_free_socket_data );
                return EINVAL;
            }else{
                socket_data->state = TCP_SOCKET_SYN_RECEIVED;
//              printf("unlock\n");
                fibril_rwlock_write_unlock( socket_data->local_lock );
                // send the packet
                tcp_send_packets( socket_data->device_id, packet );
                return EOK;
            }
        }
    }
    return tcp_release_and_return( packet, EINVAL );
}
 
int tcp_process_syn_received( socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet ){
    ERROR_DECLARE;
 
    socket_core_ref     listening_socket;
    tcp_socket_data_ref listening_socket_data;
 
    assert( socket );
    assert( socket_data );
    assert( socket->specific_data == socket_data );
    assert( header );
    assert( packet );
 
    printf("syn_rec\n");
    if( header->acknowledge ){
        // process acknowledgement
        tcp_process_acknowledgement( socket, socket_data, header );
 
        socket_data->next_incoming = ntohl( header->sequence_number );// + 1;
        pq_release( tcp_globals.net_phone, packet_get_id( packet ));
        socket_data->state = TCP_SOCKET_ESTABLISHED;
        listening_socket = socket_cores_find( socket_data->local_sockets, socket_data->listening_socket_id );
        if( listening_socket ){
            listening_socket_data = ( tcp_socket_data_ref ) listening_socket->specific_data;
            assert( listening_socket_data );
 
            // queue the received packet
            if( ! ERROR_OCCURRED( dyn_fifo_push( & listening_socket->accepted, socket->socket_id, listening_socket_data->backlog ))){
                // notify the destination socket
                async_msg_5( socket->phone, NET_SOCKET_ACCEPTED, ( ipcarg_t ) listening_socket->socket_id, 0, 0, 0, ( ipcarg_t ) socket->socket_id );
                fibril_rwlock_write_unlock( socket_data->local_lock );
                return EOK;
            }
        }
        // send FIN
        socket_data->state = TCP_SOCKET_FIN_WAIT_1;
 
        // create the notification packet
        ERROR_PROPAGATE( tcp_create_notification_packet( & packet, socket, socket_data, 0, 1 ));
 
        // send the packet
        ERROR_PROPAGATE( tcp_queue_packet( socket, socket_data, packet, 1 ));
 
        // flush packets
        packet = tcp_get_packets_to_send( socket, socket_data );
        fibril_rwlock_write_unlock( socket_data->local_lock );
        if( packet ){
            // send the packet
            tcp_send_packets( socket_data->device_id, packet );
        }
        return EOK;
    }else{
        return tcp_release_and_return( packet, EINVAL );
    }
    return EINVAL;
}
 
void tcp_process_acknowledgement( socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header ){
    size_t      number;
    size_t      length;
    packet_t    packet;
    packet_t    next;
    packet_t    acknowledged = NULL;
    packet_t    first;
    uint32_t    old;
 
    assert( socket );
    assert( socket_data );
    assert( socket->specific_data == socket_data );
    assert( header );
 
    if( header->acknowledge ){
        number = ntohl( header->acknowledgement_number );
        // if more data acknowledged
        if( number != socket_data->expected ){
            old = socket_data->expected;
            if( IS_IN_INTERVAL_OVERFLOW( old, socket_data->fin_outgoing, number )){
                switch( socket_data->state ){
                    case TCP_SOCKET_FIN_WAIT_1:
                        socket_data->state = TCP_SOCKET_FIN_WAIT_2;
                        break;
                    case TCP_SOCKET_LAST_ACK:
                    case TCP_SOCKET_CLOSING:
                        // fin acknowledged - release the socket in another fibril
                        tcp_prepare_timeout( tcp_release_after_timeout, socket, socket_data, 0, TCP_SOCKET_TIME_WAIT, NET_DEFAULT_TCP_TIME_WAIT_TIMEOUT, true );
                        break;
                    default:
                        break;
                }
            }
            // update the treshold if higher than set
            if( number + ntohs( header->window ) > socket_data->expected + socket_data->treshold ){
                socket_data->treshold = number + ntohs( header->window ) - socket_data->expected;
            }
            // set new expected sequence number
            socket_data->expected = number;
            socket_data->expected_count = 1;
            packet = socket_data->outgoing;
            while( pq_get_order( packet, & number, & length ) == EOK ){
                if( IS_IN_INTERVAL_OVERFLOW(( uint32_t ) old, ( uint32_t )( number + length ), ( uint32_t ) socket_data->expected )){
                    next = pq_detach( packet );
                    if( packet == socket_data->outgoing ){
                        socket_data->outgoing = next;
                    }
                    // add to acknowledged or release
                    first = pq_add( acknowledged, packet, 0, 0 );
                    if( first ){
                        acknowledged = first;
                    }else{
                        pq_release( tcp_globals.net_phone, packet_get_id( packet ));
                    }
                    packet = next;
                }else if( old < socket_data->expected ){
                    break;
                }
            }
            // release acknowledged
            if( acknowledged ){
                pq_release( tcp_globals.net_phone, packet_get_id( acknowledged ));
            }
            return;
        // if the same as the previous time
        }else if( number == socket_data->expected ){
            // increase the counter
            ++ socket_data->expected_count;
            if( socket_data->expected_count == TCP_FAST_RETRANSMIT_COUNT ){
                socket_data->expected_count = 1;
                // TODO retransmit lock
                //tcp_retransmit_packet( socket, socket_data, number );
            }
        }
    }
}
 
int tcp_message( ipc_callid_t callid, ipc_call_t * call, ipc_call_t * answer, int * answer_count ){
    ERROR_DECLARE;
 
    packet_t    packet;
 
    assert( call );
    assert( answer );
    assert( answer_count );
 
    * answer_count = 0;
    switch( IPC_GET_METHOD( * call )){
        case NET_TL_RECEIVED:
            //fibril_rwlock_read_lock( & tcp_globals.lock );
            if( ! ERROR_OCCURRED( packet_translate( tcp_globals.net_phone, & packet, IPC_GET_PACKET( call )))){
                ERROR_CODE = tcp_received_msg( IPC_GET_DEVICE( call ), packet, SERVICE_TCP, IPC_GET_ERROR( call ));
            }
            //fibril_rwlock_read_unlock( & tcp_globals.lock );
            return ERROR_CODE;
        case IPC_M_CONNECT_TO_ME:
            return tcp_process_client_messages( callid, * call );
    }
    return ENOTSUP;
}
 
void tcp_refresh_socket_data( tcp_socket_data_ref socket_data ){
    assert( socket_data );
 
    bzero( socket_data, sizeof( * socket_data ));
    socket_data->state = TCP_SOCKET_INITIAL;
    socket_data->device_id = -1;
    socket_data->window = NET_DEFAULT_TCP_WINDOW;
    socket_data->treshold = socket_data->window;
    socket_data->last_outgoing = TCP_INITIAL_SEQUENCE_NUMBER;
    socket_data->timeout = NET_DEFAULT_TCP_INITIAL_TIMEOUT;
    socket_data->acknowledged = socket_data->last_outgoing;
    socket_data->next_outgoing = socket_data->last_outgoing + 1;
    socket_data->expected = socket_data->next_outgoing;
}
 
void tcp_initialize_socket_data( tcp_socket_data_ref socket_data ){
    assert( socket_data );
 
    tcp_refresh_socket_data( socket_data );
    fibril_mutex_initialize( & socket_data->operation.mutex );
    fibril_condvar_initialize( & socket_data->operation.condvar );
}
 
int tcp_process_client_messages( ipc_callid_t callid, ipc_call_t call ){
    int                     res;
    bool                    keep_on_going = true;
    socket_cores_t          local_sockets;
    int                     app_phone = IPC_GET_PHONE( & call );
    struct sockaddr *       addr;
    size_t                  addrlen;
    fibril_rwlock_t         lock;
    ipc_call_t              answer;
    int                     answer_count;
    tcp_socket_data_ref     socket_data;
    socket_core_ref         socket;
 
    /*
     * Accept the connection
     *  - Answer the first IPC_M_CONNECT_ME_TO call.
     */
    ipc_answer_0( callid, EOK );
 
    socket_cores_initialize( & local_sockets );
    fibril_rwlock_initialize( & lock );
 
    while( keep_on_going ){
        // refresh data
        refresh_answer( & answer, & answer_count );
 
        callid = async_get_call( & call );
//      printf( "message %d\n", IPC_GET_METHOD( * call ));
 
        switch( IPC_GET_METHOD( call )){
            case IPC_M_PHONE_HUNGUP:
                keep_on_going = false;
                res = EOK;
                break;
            case NET_SOCKET:
                socket_data = ( tcp_socket_data_ref ) malloc( sizeof( * socket_data ));
                if( ! socket_data ){
                    res = ENOMEM;
                }else{
                    tcp_initialize_socket_data( socket_data );
                    socket_data->local_lock = & lock;
                    socket_data->local_sockets = & local_sockets;
                    fibril_rwlock_write_lock( & lock );
                    res = socket_create( & local_sockets, app_phone, socket_data, SOCKET_SET_SOCKET_ID( answer ));
                    fibril_rwlock_write_unlock( & lock );
                    if( res == EOK ){
                        * SOCKET_SET_HEADER_SIZE( answer ) = sizeof( tcp_header_t );
                        * SOCKET_SET_DATA_FRAGMENT_SIZE( answer ) = MAX_TCP_FRAGMENT_SIZE;
                        answer_count = 3;
                    }else{
                        free( socket_data );
                    }
                }
                break;
            case NET_SOCKET_BIND:
                res = data_receive(( void ** ) & addr, & addrlen );
                if( res == EOK ){
                    fibril_rwlock_write_lock( & tcp_globals.lock );
                    fibril_rwlock_write_lock( & lock );
                    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 );
                    if( res == EOK ){
                        socket = socket_cores_find( & local_sockets, SOCKET_GET_SOCKET_ID( call ));
                        if( socket ){
                            socket_data = ( tcp_socket_data_ref ) socket->specific_data;
                            assert( socket_data );
                            socket_data->state = TCP_SOCKET_LISTEN;
                        }
                    }
                    fibril_rwlock_write_unlock( & lock );
                    fibril_rwlock_write_unlock( & tcp_globals.lock );
                    free( addr );
                }
                break;
            case NET_SOCKET_LISTEN:
                fibril_rwlock_read_lock( & tcp_globals.lock );
//              fibril_rwlock_write_lock( & tcp_globals.lock );
                fibril_rwlock_write_lock( & lock );
                res = tcp_listen_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), SOCKET_GET_BACKLOG( call ));
                fibril_rwlock_write_unlock( & lock );
//              fibril_rwlock_write_unlock( & tcp_globals.lock );
                fibril_rwlock_read_unlock( & tcp_globals.lock );
                break;
            case NET_SOCKET_CONNECT:
                res = data_receive(( void ** ) & addr, & addrlen );
                if( res == EOK ){
                    // the global lock may released in the tcp_connect_message() function
                    fibril_rwlock_write_lock( & tcp_globals.lock );
                    fibril_rwlock_write_lock( & lock );
                    res = tcp_connect_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), addr, addrlen );
                    if( res != EOK ){
                        fibril_rwlock_write_unlock( & lock );
                        fibril_rwlock_write_unlock( & tcp_globals.lock );
                        free( addr );
                    }
                }
                break;
            case NET_SOCKET_ACCEPT:
                fibril_rwlock_read_lock( & tcp_globals.lock );
                fibril_rwlock_write_lock( & lock );
                res = tcp_accept_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), & addrlen );
                fibril_rwlock_write_unlock( & lock );
                fibril_rwlock_read_unlock( & tcp_globals.lock );
                if( res > 0 ){
                    * SOCKET_SET_SOCKET_ID( answer ) = res;
                    * SOCKET_SET_ADDRESS_LENGTH( answer ) = addrlen;
                    answer_count = 2;
                }
                break;
            case NET_SOCKET_SEND:
                fibril_rwlock_read_lock( & tcp_globals.lock );
                fibril_rwlock_write_lock( & lock );
                res = tcp_send_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), SOCKET_GET_DATA_FRAGMENTS( call ), SOCKET_GET_DATA_FRAGMENT_SIZE( call ), SOCKET_GET_FLAGS( call ));
                if( res != EOK ){
                    fibril_rwlock_write_unlock( & lock );
                    fibril_rwlock_read_unlock( & tcp_globals.lock );
                }
                break;
            case NET_SOCKET_SENDTO:
                res = data_receive(( void ** ) & addr, & addrlen );
                if( res == EOK ){
                    fibril_rwlock_read_lock( & tcp_globals.lock );
                    fibril_rwlock_write_lock( & lock );
                    res = tcp_send_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), SOCKET_GET_DATA_FRAGMENTS( call ), SOCKET_GET_DATA_FRAGMENT_SIZE( call ), SOCKET_GET_FLAGS( call ));
                    if( res != EOK ){
                        fibril_rwlock_write_unlock( & lock );
                        fibril_rwlock_read_unlock( & tcp_globals.lock );
                    }
                    free( addr );
                }
                break;
            case NET_SOCKET_RECV:
                fibril_rwlock_read_lock( & tcp_globals.lock );
                fibril_rwlock_write_lock( & lock );
                res = tcp_recvfrom_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), SOCKET_GET_FLAGS( call ), NULL );
                fibril_rwlock_write_unlock( & lock );
                fibril_rwlock_read_unlock( & tcp_globals.lock );
                if( res > 0 ){
                    * SOCKET_SET_READ_DATA_LENGTH( answer ) = res;
                    answer_count = 1;
                    res = EOK;
                }
                break;
            case NET_SOCKET_RECVFROM:
                fibril_rwlock_read_lock( & tcp_globals.lock );
                fibril_rwlock_write_lock( & lock );
                res = tcp_recvfrom_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ), SOCKET_GET_FLAGS( call ), & addrlen );
                fibril_rwlock_write_unlock( & lock );
                fibril_rwlock_read_unlock( & tcp_globals.lock );
                if( res > 0 ){
                    * SOCKET_SET_READ_DATA_LENGTH( answer ) = res;
                    * SOCKET_SET_ADDRESS_LENGTH( answer ) = addrlen;
                    answer_count = 2;
                    res = EOK;
                }
                break;
            case NET_SOCKET_CLOSE:
                fibril_rwlock_write_lock( & tcp_globals.lock );
                fibril_rwlock_write_lock( & lock );
                res = tcp_close_message( & local_sockets, SOCKET_GET_SOCKET_ID( call ));
                if( res != EOK ){
                    fibril_rwlock_write_unlock( & lock );
                    fibril_rwlock_write_unlock( & tcp_globals.lock );
                }
                break;
            case NET_SOCKET_GETSOCKOPT:
            case NET_SOCKET_SETSOCKOPT:
            default:
                res = ENOTSUP;
                break;
        }
 
//      printf( "res = %d\n", res );
 
        answer_call( callid, res, & answer, answer_count );
    }
 
    printf("release\n");
    // release all local sockets
    socket_cores_release( tcp_globals.net_phone, & local_sockets, & tcp_globals.sockets, tcp_free_socket_data );
 
    return EOK;
}
 
int tcp_timeout( void * data ){
    tcp_timeout_ref     timeout = data;
    int                 keep_write_lock = false;
    socket_core_ref     socket;
    tcp_socket_data_ref socket_data;
 
    assert( timeout );
 
    // sleep the given timeout
    async_usleep( timeout->timeout );
    // lock the globals
    if( timeout->globals_read_only ){
        fibril_rwlock_read_lock( & tcp_globals.lock );
    }else{
        fibril_rwlock_write_lock( & tcp_globals.lock );
    }
    // find the pending operation socket
    socket = socket_port_find( & tcp_globals.sockets, timeout->port, timeout->key, timeout->key_length );
    if( socket && ( socket->socket_id == timeout->socket_id )){
        socket_data = ( tcp_socket_data_ref ) socket->specific_data;
        assert( socket_data );
        if( socket_data->local_sockets == timeout->local_sockets ){
            fibril_rwlock_write_lock( socket_data->local_lock );
            if( timeout->sequence_number ){
                // increase the timeout counter;
                ++ socket_data->timeout_count;
                if( socket_data->timeout_count == TCP_MAX_TIMEOUTS ){
                    // TODO release as connection lost
                    //tcp_refresh_socket_data( socket_data );
                }
                // retransmit
                // TODO enable retransmit
                //tcp_retransmit_packet( socket, socket_data, timeout->sequence_number );
                fibril_rwlock_write_unlock( socket_data->local_lock );
            }else{
                fibril_mutex_lock( & socket_data->operation.mutex );
                // set the timeout operation result if state not changed
                if( socket_data->state == timeout->state ){
                    socket_data->operation.result = ETIMEOUT;
                    // notify the main fibril
                    fibril_condvar_signal( & socket_data->operation.condvar );
                    // keep the global write lock
                    keep_write_lock = true;
                }else{
                    // operation is ok, do nothing
                    // unlocking from now on, so the unlock order does not matter...
                    fibril_rwlock_write_unlock( socket_data->local_lock );
                }
                fibril_mutex_unlock( & socket_data->operation.mutex );
            }
        }
    }
    // unlock only if no socket
    if( timeout->globals_read_only ){
        fibril_rwlock_read_unlock( & tcp_globals.lock );
    }else if( ! keep_write_lock ){
        // release if not desired
        fibril_rwlock_write_unlock( & tcp_globals.lock );
    }
    // release the timeout structure
    free( timeout );
    return EOK;
}
 
int tcp_release_after_timeout( void * data ){
    tcp_timeout_ref     timeout = data;
    socket_core_ref     socket;
    tcp_socket_data_ref socket_data;
    fibril_rwlock_t *   local_lock;
 
    assert( timeout );
 
    // sleep the given timeout
    async_usleep( timeout->timeout );
    // lock the globals
    fibril_rwlock_write_lock( & tcp_globals.lock );
    // find the pending operation socket
    socket = socket_port_find( & tcp_globals.sockets, timeout->port, timeout->key, timeout->key_length );
    if( socket && ( socket->socket_id == timeout->socket_id )){
        socket_data = ( tcp_socket_data_ref ) socket->specific_data;
        assert( socket_data );
        if( socket_data->local_sockets == timeout->local_sockets ){
            local_lock = socket_data->local_lock;
            fibril_rwlock_write_lock( local_lock );
            socket_destroy( tcp_globals.net_phone, timeout->socket_id, timeout->local_sockets, & tcp_globals.sockets, tcp_free_socket_data );
            fibril_rwlock_write_unlock( local_lock );
        }
    }
    // unlock the globals
    fibril_rwlock_write_unlock( & tcp_globals.lock );
    // release the timeout structure
    free( timeout );
    return EOK;
}
 
void tcp_retransmit_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, size_t sequence_number ){
    packet_t    packet;
    packet_t    copy;
    size_t      data_length;
 
    assert( socket );
    assert( socket_data );
    assert( socket->specific_data == socket_data );
 
    // sent packet?
    packet = pq_find( socket_data->outgoing, sequence_number );
    printf("retransmit %d\n", packet_get_id( packet ));
    if( packet ){
        pq_get_order( packet, NULL, & data_length );
        copy = tcp_prepare_copy( socket, socket_data, packet, data_length, sequence_number );
        fibril_rwlock_write_unlock( socket_data->local_lock );
//      printf( "r send %d\n", packet_get_id( packet ));
        if( copy ){
            tcp_send_packets( socket_data->device_id, copy );
        }
    }else{
        fibril_rwlock_write_unlock( socket_data->local_lock );
    }
}
 
int tcp_listen_message( socket_cores_ref local_sockets, int socket_id, int backlog ){
    socket_core_ref     socket;
    tcp_socket_data_ref socket_data;
 
    assert( local_sockets );
 
    if( backlog < 0 ) return EINVAL;
    // find the socket
    socket = socket_cores_find( local_sockets, socket_id );
    if( ! socket ) return ENOTSOCK;
    // get the socket specific data
    socket_data = ( tcp_socket_data_ref ) socket->specific_data;
    assert( socket_data );
    // set the backlog
    socket_data->backlog = backlog;
    return EOK;
}
 
int tcp_connect_message( socket_cores_ref local_sockets, int socket_id, struct sockaddr * addr, socklen_t addrlen ){
    ERROR_DECLARE;
 
    socket_core_ref         socket;
 
    assert( local_sockets );
    assert( addr );
    assert( addrlen > 0 );
 
    // find the socket
    socket = socket_cores_find( local_sockets, socket_id );
    if( ! socket ) return ENOTSOCK;
    if( ERROR_OCCURRED( tcp_connect_core( socket, local_sockets, addr, addrlen ))){
        tcp_free_socket_data( socket );
        // unbind if bound
        if( socket->port > 0 ){
            socket_ports_exclude( & tcp_globals.sockets, socket->port );
            socket->port = 0;
        }
    }
    return ERROR_CODE;
}
 
int tcp_connect_core( socket_core_ref socket, socket_cores_ref local_sockets, struct sockaddr * addr, socklen_t addrlen ){
    ERROR_DECLARE;
 
    tcp_socket_data_ref     socket_data;
    packet_t                packet;
 
    assert( socket );
    assert( addr );
    assert( addrlen > 0 );
 
    // get the socket specific data
    socket_data = ( tcp_socket_data_ref ) socket->specific_data;
    assert( socket_data );
    assert( socket->specific_data == socket_data );
    if(( socket_data->state != TCP_SOCKET_INITIAL )
    && (( socket_data->state != TCP_SOCKET_LISTEN ) || ( socket->port <= 0 ))){
        return EINVAL;
    }
    // get the destination port
    ERROR_PROPAGATE( tl_get_address_port( addr, addrlen, & socket_data->dest_port ));
    if( socket->port <= 0 ){
        // try to find a free port
        ERROR_PROPAGATE( socket_bind_free_port( & tcp_globals.sockets, socket, TCP_FREE_PORTS_START, TCP_FREE_PORTS_END, tcp_globals.last_used_port ));
        // set the next port as the search starting port number
        tcp_globals.last_used_port = socket->port;
    }
    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 ));
 
    // create the notification packet
    ERROR_PROPAGATE( tcp_create_notification_packet( & packet, socket, socket_data, 1, 0 ));
 
    // unlock the globals and wait for an operation
    fibril_rwlock_write_unlock( & tcp_globals.lock );
 
    socket_data->addr = addr;
    socket_data->addrlen = addrlen;
    // send the packet
    if( ERROR_OCCURRED( tcp_queue_packet( socket, socket_data, packet, 1 ))
    || ERROR_OCCURRED( tcp_prepare_timeout( tcp_timeout, socket, socket_data, 0, TCP_SOCKET_INITIAL, NET_DEFAULT_TCP_INITIAL_TIMEOUT, false ))){
        socket_data->addr = NULL;
        socket_data->addrlen = 0;
        fibril_rwlock_write_lock( & tcp_globals.lock );
    }else{
        packet = tcp_get_packets_to_send( socket, socket_data );
        if( packet ){
            fibril_mutex_lock( & socket_data->operation.mutex );
            fibril_rwlock_write_unlock( socket_data->local_lock );
            // send the packet
            printf( "connecting %d\n", packet_get_id( packet ));
            tcp_send_packets( socket_data->device_id, packet );
            // wait for a reply
            fibril_condvar_wait( & socket_data->operation.condvar, & socket_data->operation.mutex );
            ERROR_CODE = socket_data->operation.result;
            if( ERROR_CODE != EOK ){
                socket_data->addr = NULL;
                socket_data->addrlen = 0;
            }
        }else{
            socket_data->addr = NULL;
            socket_data->addrlen = 0;
            ERROR_CODE = EINTR;
        }
    }
 
    fibril_mutex_unlock( & socket_data->operation.mutex );
 
    // return the result
    return ERROR_CODE;
}
 
int tcp_queue_prepare_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length ){
    ERROR_DECLARE;
 
    tcp_header_ref  header;
 
    assert( socket );
    assert( socket_data );
    assert( socket->specific_data == socket_data );
 
    // get tcp header
    header = ( tcp_header_ref ) packet_get_data( packet );
    if( ! header ) return NO_DATA;
    header->destination_port = htons( socket_data->dest_port );
    header->source_port = htons( socket->port );
    header->sequence_number = htonl( socket_data->next_outgoing );
    if( ERROR_OCCURRED( packet_set_addr( packet, NULL, ( uint8_t * ) socket_data->addr, socket_data->addrlen ))){
        return tcp_release_and_return( packet, EINVAL );
    }
    // remember the outgoing FIN
    if( header->finalize ){
        socket_data->fin_outgoing = socket_data->next_outgoing;
    }
    return EOK;
}
 
int tcp_queue_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length ){
    ERROR_DECLARE;
    packet_t        first;
 
    assert( socket );
    assert( socket_data );
    assert( socket->specific_data == socket_data );
 
    ERROR_PROPAGATE( tcp_queue_prepare_packet( socket, socket_data, packet, data_length ));
 
    first = pq_add( socket_data->outgoing, packet, socket_data->next_outgoing, data_length );
    if( ! first ){
        return tcp_release_and_return( packet, EINVAL );
    }
    socket_data->outgoing = first;
    socket_data->next_outgoing += data_length;
    return EOK;
}
 
packet_t tcp_get_packets_to_send( socket_core_ref socket, tcp_socket_data_ref socket_data ){
    ERROR_DECLARE;
 
    packet_t        packet;
    packet_t        copy;
    packet_t        sending = NULL;
    packet_t        previous = NULL;
    size_t          data_length;
 
    assert( socket );
    assert( socket_data );
    assert( socket->specific_data == socket_data );
 
    packet = pq_find( socket_data->outgoing, socket_data->last_outgoing + 1 );
    while( packet ){
        pq_get_order( packet, NULL, & data_length );
        // send only if fits into the window
        // respecting the possible overflow
        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 ))){
            copy = tcp_prepare_copy( socket, socket_data, packet, data_length, socket_data->last_outgoing + 1 );
            if( ! copy ){
                return sending;
            }
            if( ! sending ){
                sending = copy;
            }else{
                if( ERROR_OCCURRED( pq_insert_after( previous, copy ))){
                    pq_release( tcp_globals.net_phone, packet_get_id( copy ));
                    return sending;
                }
            }
            previous = copy;
            packet = pq_next( packet );
            // overflow occurred ?
            if(( ! packet ) && ( socket_data->last_outgoing > socket_data->next_outgoing )){
                printf("gpts overflow\n");
                // continue from the beginning
                packet = socket_data->outgoing;
            }
            socket_data->last_outgoing += data_length;
        }else{
            break;
        }
    }
    return sending;
}
 
packet_t tcp_send_prepare_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length, size_t sequence_number ){
    ERROR_DECLARE;
 
    tcp_header_ref  header;
    uint32_t        checksum;
 
    assert( socket );
    assert( socket_data );
    assert( socket->specific_data == socket_data );
 
    // adjust the pseudo header
    if( ERROR_OCCURRED( ip_client_set_pseudo_header_data_length( socket_data->pseudo_header, socket_data->headerlen, packet_get_data_length( packet )))){
        pq_release( tcp_globals.net_phone, packet_get_id( packet ));
        return NULL;
    }
 
    // get the header
    header = ( tcp_header_ref ) packet_get_data( packet );
    if( ! header ){
        pq_release( tcp_globals.net_phone, packet_get_id( packet ));
        return NULL;
    }
    assert( ntohl( header->sequence_number ) == sequence_number );
 
    // adjust the header
    if( socket_data->next_incoming ){
        header->acknowledgement_number = htonl( socket_data->next_incoming );
        header->acknowledge = 1;
    }
    header->window = htons( socket_data->window );
 
    // checksum
    header->checksum = 0;
    checksum = compute_checksum( 0, socket_data->pseudo_header, socket_data->headerlen );
    checksum = compute_checksum( checksum, ( uint8_t * ) packet_get_data( packet ), packet_get_data_length( packet ));
    header->checksum = htons( flip_checksum( compact_checksum( checksum )));
    // prepare the packet
    if( ERROR_OCCURRED( ip_client_prepare_packet( packet, IPPROTO_TCP, 0, 0, 0, 0 ))
    // prepare the timeout
    || ERROR_OCCURRED( tcp_prepare_timeout( tcp_timeout, socket, socket_data, sequence_number, socket_data->state, socket_data->timeout, true ))){
        pq_release( tcp_globals.net_phone, packet_get_id( packet ));
        return NULL;
    }
    return packet;
}
 
packet_t tcp_prepare_copy( socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length, size_t sequence_number ){
    packet_t        copy;
 
    assert( socket );
    assert( socket_data );
    assert( socket->specific_data == socket_data );
 
    // make a copy of the packet
    copy = packet_get_copy( tcp_globals.net_phone, packet );
    if( ! copy ) return NULL;
 
    return tcp_send_prepare_packet( socket, socket_data, copy, data_length, sequence_number );
}
 
void tcp_send_packets( device_id_t device_id, packet_t packet ){
    packet_t    next;
 
    while( packet ){
        next = pq_detach( packet );
        ip_send_msg( tcp_globals.ip_phone, device_id, packet, SERVICE_TCP, 0 );
        packet = next;
    }
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
void tcp_prepare_operation_header( socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, int synchronize, int finalize ){
    assert( socket );
    assert( socket_data );
    assert( socket->specific_data == socket_data );
    assert( header );
 
    bzero( header, sizeof( * header ));
    header->source_port = htons( socket->port );
    header->source_port = htons( socket_data->dest_port );
    header->header_length = TCP_COMPUTE_HEADER_LENGTH( sizeof( * header ));
    header->synchronize = synchronize;
    header->finalize = finalize;
}
 
int tcp_prepare_timeout( int ( * timeout_function )( void * tcp_timeout_t ), socket_core_ref socket, tcp_socket_data_ref socket_data, size_t sequence_number, tcp_socket_state_t state, suseconds_t timeout, int globals_read_only ){
    tcp_timeout_ref operation_timeout;
    fid_t           fibril;
 
    assert( socket );
    assert( socket_data );
    assert( socket->specific_data == socket_data );
 
    // prepare the timeout with key bundle structure
    operation_timeout = malloc( sizeof( * operation_timeout ) + socket->key_length + 1 );
    if( ! operation_timeout ) return ENOMEM;
    bzero( operation_timeout, sizeof( * operation_timeout ));
    operation_timeout->globals_read_only = globals_read_only;
    operation_timeout->port = socket->port;
    operation_timeout->local_sockets = socket_data->local_sockets;
    operation_timeout->socket_id = socket->socket_id;
    operation_timeout->timeout = timeout;
    operation_timeout->sequence_number = sequence_number;
    operation_timeout->state = state;
 
    // copy the key
    operation_timeout->key = (( char * ) operation_timeout ) + sizeof( * operation_timeout );
    operation_timeout->key_length = socket->key_length;
    memcpy( operation_timeout->key, socket->key, socket->key_length );
    operation_timeout->key[ operation_timeout->key_length ] = '\0';
 
    // prepare the timeouting thread
    fibril = fibril_create( timeout_function, operation_timeout );
    if( ! fibril ){
        free( operation_timeout );
        return EPARTY;
    }
//  fibril_mutex_lock( & socket_data->operation.mutex );
    // start the timeouting fibril
    fibril_add_ready( fibril );
    //socket_data->state = state;
    return EOK;
}
 
int tcp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags, size_t * addrlen ){
    ERROR_DECLARE;
 
    socket_core_ref     socket;
    tcp_socket_data_ref socket_data;
    int                 packet_id;
    packet_t            packet;
    size_t              length;
 
    assert( local_sockets );
 
    // find the socket
    socket = socket_cores_find( local_sockets, socket_id );
    if( ! socket ) return ENOTSOCK;
    // get the socket specific data
    if( ! socket->specific_data ) return NO_DATA;
    socket_data = ( tcp_socket_data_ref ) socket->specific_data;
 
    // check state
    if(( socket_data->state != TCP_SOCKET_ESTABLISHED ) && ( socket_data->state != TCP_SOCKET_CLOSE_WAIT )){
        return ENOTCONN;
    }
 
    // send the source address if desired
    if( addrlen ){
        ERROR_PROPAGATE( data_reply( socket_data->addr, socket_data->addrlen ));
        * addrlen = socket_data->addrlen;
    }
 
    // get the next received packet
    packet_id = dyn_fifo_value( & socket->received );
    if( packet_id < 0 ) return NO_DATA;
    ERROR_PROPAGATE( packet_translate( tcp_globals.net_phone, & packet, packet_id ));
 
    // reply the packets
    ERROR_PROPAGATE( socket_reply_packets( packet, & length ));
 
    // release the packet
    dyn_fifo_pop( & socket->received );
    pq_release( tcp_globals.net_phone, packet_get_id( packet ));
    // return the total length
    return ( int ) length;
}
 
int tcp_send_message( socket_cores_ref local_sockets, int socket_id, int fragments, size_t data_fragment_size, int flags ){
    ERROR_DECLARE;
 
    socket_core_ref         socket;
    tcp_socket_data_ref     socket_data;
    packet_dimension_ref    packet_dimension;
    packet_t                packet;
    size_t                  total_length;
    tcp_header_ref          header;
    int                     index;
    int                     result;
 
    assert( local_sockets );
 
    // find the socket
    socket = socket_cores_find( local_sockets, socket_id );
    if( ! socket ) return ENOTSOCK;
    // get the socket specific data
    if( ! socket->specific_data ) return NO_DATA;
    socket_data = ( tcp_socket_data_ref ) socket->specific_data;
 
    // check state
    if(( socket_data->state != TCP_SOCKET_ESTABLISHED ) && ( socket_data->state != TCP_SOCKET_CLOSE_WAIT )){
        return ENOTCONN;
    }
 
    ERROR_PROPAGATE( tl_get_ip_packet_dimension( tcp_globals.ip_phone, & tcp_globals.dimensions, socket_data->device_id, & packet_dimension ));
 
    // TODO return the device_id + data_fragment_size if different - the client should send it again
    // ( two messages are better than ip fragmentation )
 
    for( index = 0; index < fragments; ++ index ){
        // read the data fragment
        result = tl_socket_read_packet_data( tcp_globals.net_phone, & packet, sizeof( tcp_header_t ), packet_dimension, socket_data->addr, socket_data->addrlen );
        if( result < 0 ) return result;
        total_length = ( size_t ) result;
        // prefix the tcp header
        header = PACKET_PREFIX( packet, tcp_header_t );
        if( ! header ){
            return tcp_release_and_return( packet, ENOMEM );
        }
        tcp_prepare_operation_header( socket, socket_data, header, 0, 0 );
        ERROR_PROPAGATE( tcp_queue_packet( socket, socket_data, packet, 0 ));
    }
 
    // flush packets
    packet = tcp_get_packets_to_send( socket, socket_data );
    fibril_rwlock_write_unlock( socket_data->local_lock );
    fibril_rwlock_read_unlock( & tcp_globals.lock );
    if( packet ){
        // send the packet
        tcp_send_packets( socket_data->device_id, packet );
    }
 
    return EOK;
}
 
int tcp_close_message( socket_cores_ref local_sockets, int socket_id ){
    ERROR_DECLARE;
 
    socket_core_ref         socket;
    tcp_socket_data_ref     socket_data;
    packet_t                packet;
 
    // find the socket
    socket = socket_cores_find( local_sockets, socket_id );
    if( ! socket ) return ENOTSOCK;
    // get the socket specific data
    socket_data = ( tcp_socket_data_ref ) socket->specific_data;
    assert( socket_data );
 
    // check state
    switch( socket_data->state ){
        case TCP_SOCKET_ESTABLISHED:
            socket_data->state = TCP_SOCKET_FIN_WAIT_1;
            break;
        case TCP_SOCKET_CLOSE_WAIT:
            socket_data->state = TCP_SOCKET_LAST_ACK;
            break;
//      case TCP_SOCKET_LISTEN:
        default:
            // just destroy
            if( ! ERROR_OCCURRED( socket_destroy( tcp_globals.net_phone, socket_id, local_sockets, & tcp_globals.sockets, tcp_free_socket_data ))){
                fibril_rwlock_write_unlock( socket_data->local_lock );
                fibril_rwlock_write_unlock( & tcp_globals.lock );
            }
            return ERROR_CODE;
    }
    // send FIN
    // TODO should I wait to complete?
 
    // create the notification packet
    ERROR_PROPAGATE( tcp_create_notification_packet( & packet, socket, socket_data, 0, 1 ));
 
    // send the packet
    ERROR_PROPAGATE( tcp_queue_packet( socket, socket_data, packet, 1 ));
 
    // flush packets
    packet = tcp_get_packets_to_send( socket, socket_data );
    fibril_rwlock_write_unlock( socket_data->local_lock );
    fibril_rwlock_write_unlock( & tcp_globals.lock );
    if( packet ){
        // send the packet
        tcp_send_packets( socket_data->device_id, packet );
    }
    return EOK;
}
 
int tcp_create_notification_packet( packet_t * packet, socket_core_ref socket, tcp_socket_data_ref socket_data, int synchronize, int finalize ){
    ERROR_DECLARE;
 
    packet_dimension_ref    packet_dimension;
    tcp_header_ref          header;
 
    assert( packet );
 
    // get the device packet dimension
    ERROR_PROPAGATE( tl_get_ip_packet_dimension( tcp_globals.ip_phone, & tcp_globals.dimensions, socket_data->device_id, & packet_dimension ));
    // get a new packet
    * packet = packet_get_4( tcp_globals.net_phone, sizeof( tcp_header_t ), packet_dimension->addr_len, packet_dimension->prefix, packet_dimension->suffix );
    if( ! * packet ) return ENOMEM;
    // allocate space in the packet
    header = PACKET_SUFFIX( * packet, tcp_header_t );
    if( ! header ){
        tcp_release_and_return( * packet, ENOMEM );
    }
 
    tcp_prepare_operation_header( socket, socket_data, header, synchronize, finalize );
    return EOK;
}
 
int tcp_accept_message( socket_cores_ref local_sockets, int socket_id, size_t * addrlen ){
    ERROR_DECLARE;
 
    socket_core_ref     accepted;
    socket_core_ref     socket;
    tcp_socket_data_ref socket_data;
 
    assert( local_sockets );
    assert( addrlen );
 
    // find the socket
    socket = socket_cores_find( local_sockets, socket_id );
    if( ! socket ) return ENOTSOCK;
    // get the socket specific data
    socket_data = ( tcp_socket_data_ref ) socket->specific_data;
    assert( socket_data );
 
    // check state
    if( socket_data->state != TCP_SOCKET_LISTEN ){
        return EINVAL;
    }
 
    do{
        socket_id = dyn_fifo_value( & socket->accepted );
        if( socket_id < 0 ) return ENOTSOCK;
 
        accepted = socket_cores_find( local_sockets, socket_id );
        if( ! accepted ) return ENOTSOCK;
        // get the socket specific data
        socket_data = ( tcp_socket_data_ref ) accepted->specific_data;
        assert( socket_data );
        if( socket_data->state == TCP_SOCKET_ESTABLISHED ){
            ERROR_PROPAGATE( data_reply( socket_data->addr, socket_data->addrlen ));
            * addrlen = socket_data->addrlen;
        }
        dyn_fifo_pop( & socket->accepted );
    }while( socket_data->state != TCP_SOCKET_ESTABLISHED );
    printf("ret accept %d\n", accepted->socket_id );
    return accepted->socket_id;
}
 
void tcp_free_socket_data( socket_core_ref socket ){
    tcp_socket_data_ref     socket_data;
 
    assert( socket );
 
    printf( "destroy_socket %d\n", socket->socket_id );
 
    // get the socket specific data
    socket_data = ( tcp_socket_data_ref ) socket->specific_data;
    assert( socket_data );
    //free the pseudo header
    if( socket_data->pseudo_header ){
        if( socket_data->headerlen ){
            printf("d pseudo\n");
            free( socket_data->pseudo_header );
            socket_data->headerlen = 0;
        }
        socket_data->pseudo_header = NULL;
    }
    socket_data->headerlen = 0;
    // free the address
    if( socket_data->addr ){
        if( socket_data->addrlen ){
            printf("d addr\n");
            free( socket_data->addr );
            socket_data->addrlen = 0;
        }
        socket_data->addr = NULL;
    }
    socket_data->addrlen = 0;
}
 
int tcp_release_and_return( packet_t packet, int result ){
    pq_release( tcp_globals.net_phone, packet_get_id( packet ));
    return result;
}
 
/** @}
 */
 

Rev 4742	Rev 4750
1	/*	1	/*
2	* Copyright (c) 2008 Lukas Mejdrech	2	* Copyright (c) 2008 Lukas Mejdrech
3	* All rights reserved.	3	* All rights reserved.
4	*	4	*
5	* Redistribution and use in source and binary forms, with or without	5	* Redistribution and use in source and binary forms, with or without
6	* modification, are permitted provided that the following conditions	6	* modification, are permitted provided that the following conditions
7	* are met:	7	* are met:
8	*	8	*
9	* - Redistributions of source code must retain the above copyright	9	* - Redistributions of source code must retain the above copyright
10	* notice, this list of conditions and the following disclaimer.	10	* notice, this list of conditions and the following disclaimer.
11	* - Redistributions in binary form must reproduce the above copyright	11	* - Redistributions in binary form must reproduce the above copyright
12	* notice, this list of conditions and the following disclaimer in the	12	* notice, this list of conditions and the following disclaimer in the
13	* documentation and/or other materials provided with the distribution.	13	* documentation and/or other materials provided with the distribution.
14	* - The name of the author may not be used to endorse or promote products	14	* - The name of the author may not be used to endorse or promote products
15	* derived from this software without specific prior written permission.	15	* derived from this software without specific prior written permission.
16	*	16	*
17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	*/	27	*/
28		28
29	/** @addtogroup tcp	29	/** @addtogroup tcp
30	* @{	30	* @{
31	*/	31	*/
32		32
33	/** @file	33	/** @file
34	* TCP module implementation.	34	* TCP module implementation.
35	* @see tcp.h	35	* @see tcp.h
36	* \todo	36	* \todo
37	*/	37	*/
38		38
39	#include <assert.h>	39	#include <assert.h>
40	#include <async.h>	40	#include <async.h>
41	#include <fibril_sync.h>	41	#include <fibril_sync.h>
42	#include <malloc.h>	42	#include <malloc.h>
43	//TODO remove stdio	43	//TODO remove stdio
44	#include <stdio.h>	44	#include <stdio.h>
45		45
46	#include <ipc/ipc.h>	46	#include <ipc/ipc.h>
47	#include <ipc/services.h>	47	#include <ipc/services.h>
48		48
49	#include "../../err.h"	49	#include "../../err.h"
50	#include "../../messages.h"	50	#include "../../messages.h"
51	#include "../../modules.h"	51	#include "../../modules.h"
52		52
53	#include "../../structures/dynamic_fifo.h"	53	#include "../../structures/dynamic_fifo.h"
54	#include "../../structures/packet/packet_client.h"	54	#include "../../structures/packet/packet_client.h"
55		55
56	#include "../../include/checksum.h"	56	#include "../../include/checksum.h"
57	#include "../../include/in.h"	57	#include "../../include/in.h"
58	#include "../../include/in6.h"	58	#include "../../include/in6.h"
59	#include "../../include/inet.h"	59	#include "../../include/inet.h"
60	#include "../../include/ip_client.h"	60	#include "../../include/ip_client.h"
61	#include "../../include/ip_interface.h"	61	#include "../../include/ip_interface.h"
62	#include "../../include/ip_protocols.h"	62	#include "../../include/ip_protocols.h"
63	#include "../../include/icmp_client.h"	63	#include "../../include/icmp_client.h"
64	#include "../../include/icmp_interface.h"	64	#include "../../include/icmp_interface.h"
65	#include "../../include/net_interface.h"	65	#include "../../include/net_interface.h"
66	#include "../../include/socket_codes.h"	66	#include "../../include/socket_codes.h"
67	#include "../../include/socket_errno.h"	67	#include "../../include/socket_errno.h"
68	#include "../../include/tcp_codes.h"	68	#include "../../include/tcp_codes.h"
69		69
70	#include "../../socket/socket_core.h"	70	#include "../../socket/socket_core.h"
71	#include "../../socket/socket_messages.h"	71	#include "../../socket/socket_messages.h"
72		72
73	#include "../tl_common.h"	73	#include "../tl_common.h"
74	#include "../tl_messages.h"	74	#include "../tl_messages.h"
75		75
76	#include "tcp.h"	76	#include "tcp.h"
77	#include "tcp_header.h"	77	#include "tcp_header.h"
78	#include "tcp_module.h"	78	#include "tcp_module.h"
79		79
80	/** The TCP window default value.	80	/** The TCP window default value.
81	*/	81	*/
82	#define NET_DEFAULT_TCP_WINDOW 10240	82	#define NET_DEFAULT_TCP_WINDOW 10240
83		83
84	/** \todo	84	/** \todo
85	*/	85	*/
86	#define NET_DEFAULT_TCP_INITIAL_TIMEOUT 3000000L	86	#define NET_DEFAULT_TCP_INITIAL_TIMEOUT 3000000L
87		87
88	/** \todo	88	/** \todo
89	*/	89	*/
90	#define NET_DEFAULT_TCP_TIME_WAIT_TIMEOUT 2000L	90	#define NET_DEFAULT_TCP_TIME_WAIT_TIMEOUT 2000L
91		91
92	/** The initial outgoing sequence number.	92	/** The initial outgoing sequence number.
93	*/	93	*/
94	#define TCP_INITIAL_SEQUENCE_NUMBER 2999	94	#define TCP_INITIAL_SEQUENCE_NUMBER 2999
95		95
96	/** Maximum TCP fragment size.	96	/** Maximum TCP fragment size.
97	*/	97	*/
98	#define MAX_TCP_FRAGMENT_SIZE 65535	98	#define MAX_TCP_FRAGMENT_SIZE 65535
99		99
100	/** Free ports pool start.	100	/** Free ports pool start.
101	*/	101	*/
102	#define TCP_FREE_PORTS_START 1025	102	#define TCP_FREE_PORTS_START 1025
103		103
104	/** Free ports pool end.	104	/** Free ports pool end.
105	*/	105	*/
106	#define TCP_FREE_PORTS_END 65535	106	#define TCP_FREE_PORTS_END 65535
107		107
108	/** \todo	108	/** \todo
109	*/	109	*/
110	#define TCP_SYN_SENT_TIMEOUT 1000000L	110	#define TCP_SYN_SENT_TIMEOUT 1000000L
111		111
112	/** The maximum number of timeouts in a row before singaling connection lost.	112	/** The maximum number of timeouts in a row before singaling connection lost.
113	*/	113	*/
114	#define TCP_MAX_TIMEOUTS 8	114	#define TCP_MAX_TIMEOUTS 8
115		115
116	/** The number of acknowledgements before retransmit.	116	/** The number of acknowledgements before retransmit.
117	*/	117	*/
118	#define TCP_FAST_RETRANSMIT_COUNT 3	118	#define TCP_FAST_RETRANSMIT_COUNT 3
119		119
120	/** \todo	120	/** \todo
121	*/	121	*/
122	#define IS_IN_INTERVAL_OVERFLOW( lower, value, higher_equal ) (((( lower ) < ( value )) && ((( value ) <= ( higher_equal )) \|\| (( higher_equal ) < ( lower )))) \|\| ((( value ) <= ( higher_equal )) && (( higher_equal ) < ( lower ))))	122	#define IS_IN_INTERVAL_OVERFLOW( lower, value, higher_equal ) (((( lower ) < ( value )) && ((( value ) <= ( higher_equal )) \|\| (( higher_equal ) < ( lower )))) \|\| ((( value ) <= ( higher_equal )) && (( higher_equal ) < ( lower ))))
123		123
124	/** Type definition of the TCP timeout.	124	/** Type definition of the TCP timeout.
125	* @see tcp_timeout	125	* @see tcp_timeout
126	*/	126	*/
127	typedef struct tcp_timeout tcp_timeout_t;	127	typedef struct tcp_timeout tcp_timeout_t;
128		128
129	/** Type definition of the TCP timeout pointer.	129	/** Type definition of the TCP timeout pointer.
130	* @see tcp_timeout	130	* @see tcp_timeout
131	*/	131	*/
132	typedef tcp_timeout_t * tcp_timeout_ref;	132	typedef tcp_timeout_t * tcp_timeout_ref;
133		133
134	/** TCP reply timeout data.	134	/** TCP reply timeout data.
135	* Used as a timeouting fibril argument.	135	* Used as a timeouting fibril argument.
136	* @see tcp_timeout()	136	* @see tcp_timeout()
137	*/	137	*/
138	struct tcp_timeout{	138	struct tcp_timeout{
139	/** TCP global data are going to be read only.	139	/** TCP global data are going to be read only.
140	*/	140	*/
141	int globals_read_only;	141	int globals_read_only;
142	/** Socket port.	142	/** Socket port.
143	*/	143	*/
144	int port;	144	int port;
145	/** Local sockets.	145	/** Local sockets.
146	*/	146	*/
147	socket_cores_ref local_sockets;	147	socket_cores_ref local_sockets;
148	/** Socket identifier.	148	/** Socket identifier.
149	*/	149	*/
150	int socket_id;	150	int socket_id;
151	/** Socket state.	151	/** Socket state.
152	*/	152	*/
153	tcp_socket_state_t state;	153	tcp_socket_state_t state;
154	/** Sent packet sequence number.	154	/** Sent packet sequence number.
155	*/	155	*/
156	int sequence_number;	156	int sequence_number;
157	/** Timeout in microseconds.	157	/** Timeout in microseconds.
158	*/	158	*/
159	suseconds_t timeout;	159	suseconds_t timeout;
160	/** Port map key.	160	/** Port map key.
161	*/	161	*/
162	char * key;	162	char * key;
163	/** Port map key length.	163	/** Port map key length.
164	*/	164	*/
165	size_t key_length;	165	size_t key_length;
166	};	166	};
167		167
168	/** Releases the packet and returns the result.	168	/** Releases the packet and returns the result.
169	* @param packet The packet queue to be released. Input parameter.	169	* @param packet The packet queue to be released. Input parameter.
170	* @param result The result to be returned. Input parameter.	170	* @param result The result to be returned. Input parameter.
171	* @return The result parameter.	171	* @return The result parameter.
172	*/	172	*/
173	int tcp_release_and_return( packet_t packet, int result );	173	int tcp_release_and_return( packet_t packet, int result );
174		174
175	int tcp_get_packet_dimension( device_id_t device_id, packet_dimension_ref * packet_dimension );	-
176	void tcp_prepare_operation_header( socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, int synchronize, int finalize );	175	void tcp_prepare_operation_header( socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, int synchronize, int finalize );
177	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 );	176	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 );
178	void tcp_free_socket_data( socket_core_ref socket );	177	void tcp_free_socket_data( socket_core_ref socket );
179	int tcp_timeout( void * data );	178	int tcp_timeout( void * data );
180	int tcp_release_after_timeout( void * data );	179	int tcp_release_after_timeout( void * data );
181	int tcp_process_packet( device_id_t device_id, packet_t packet, services_t error );	180	int tcp_process_packet( device_id_t device_id, packet_t packet, services_t error );
182	int tcp_connect_core( socket_core_ref socket, socket_cores_ref local_sockets, struct sockaddr * addr, socklen_t addrlen );	181	int tcp_connect_core( socket_core_ref socket, socket_cores_ref local_sockets, struct sockaddr * addr, socklen_t addrlen );
183	int tcp_queue_prepare_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length );	182	int tcp_queue_prepare_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length );
184	int tcp_queue_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length );	183	int tcp_queue_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length );
185	packet_t tcp_get_packets_to_send( socket_core_ref socket, tcp_socket_data_ref socket_data );	184	packet_t tcp_get_packets_to_send( socket_core_ref socket, tcp_socket_data_ref socket_data );
186	void tcp_send_packets( device_id_t device_id, packet_t packet );	185	void tcp_send_packets( device_id_t device_id, packet_t packet );
187	void tcp_process_acknowledgement( socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header );	186	void tcp_process_acknowledgement( socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header );
188	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 );	187	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 );
189	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 );	188	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 );
190	void tcp_retransmit_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, size_t sequence_number );	189	void tcp_retransmit_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, size_t sequence_number );
191	int tcp_create_notification_packet( packet_t * packet, socket_core_ref socket, tcp_socket_data_ref socket_data, int synchronize, int finalize );	190	int tcp_create_notification_packet( packet_t * packet, socket_core_ref socket, tcp_socket_data_ref socket_data, int synchronize, int finalize );
192	void tcp_refresh_socket_data( tcp_socket_data_ref socket_data );	191	void tcp_refresh_socket_data( tcp_socket_data_ref socket_data );
193	void tcp_initialize_socket_data( tcp_socket_data_ref socket_data );	192	void tcp_initialize_socket_data( tcp_socket_data_ref socket_data );
194	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 );	193	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 );
195	int tcp_process_syn_sent( socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet );	194	int tcp_process_syn_sent( socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet );
196	int tcp_process_syn_received( socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet );	195	int tcp_process_syn_received( socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet );
197	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 );	196	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 );
198	int tcp_queue_received_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, int fragments, size_t total_length );	197	int tcp_queue_received_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, int fragments, size_t total_length );
199		198
200	int tcp_received_msg( device_id_t device_id, packet_t packet, services_t receiver, services_t error );	199	int tcp_received_msg( device_id_t device_id, packet_t packet, services_t receiver, services_t error );
201	int tcp_process_client_messages( ipc_callid_t callid, ipc_call_t call );	200	int tcp_process_client_messages( ipc_callid_t callid, ipc_call_t call );
202	int tcp_listen_message( socket_cores_ref local_sockets, int socket_id, int backlog );	201	int tcp_listen_message( socket_cores_ref local_sockets, int socket_id, int backlog );
203	int tcp_connect_message( socket_cores_ref local_sockets, int socket_id, struct sockaddr * addr, socklen_t addrlen );	202	int tcp_connect_message( socket_cores_ref local_sockets, int socket_id, struct sockaddr * addr, socklen_t addrlen );
204	int tcp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags, size_t * addrlen );	203	int tcp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags, size_t * addrlen );
205	int tcp_send_message( socket_cores_ref local_sockets, int socket_id, int fragments, size_t data_fragment_size, int flags );	204	int tcp_send_message( socket_cores_ref local_sockets, int socket_id, int fragments, size_t data_fragment_size, int flags );
206	int tcp_accept_message( socket_cores_ref local_sockets, int socket_id, size_t * addrlen );	205	int tcp_accept_message( socket_cores_ref local_sockets, int socket_id, size_t * addrlen );
207	int tcp_close_message( socket_cores_ref local_sockets, int socket_id );	206	int tcp_close_message( socket_cores_ref local_sockets, int socket_id );
208		207
209	DEVICE_MAP_IMPLEMENT( packet_dimensions, packet_dimension_t );	-
210		-
211	/** TCP global data.	208	/** TCP global data.
212	*/	209	*/
213	tcp_globals_t tcp_globals;	210	tcp_globals_t tcp_globals;
214		211
215	/** Initializes the module.	212	/** Initializes the module.
216	*/	213	*/
217	int tcp_initialize( async_client_conn_t client_connection ){	214	int tcp_initialize( async_client_conn_t client_connection ){
218	ERROR_DECLARE;	215	ERROR_DECLARE;
219		216
220	assert( client_connection );	217	assert( client_connection );
221	fibril_rwlock_initialize( & tcp_globals.lock );	218	fibril_rwlock_initialize( & tcp_globals.lock );
222	fibril_rwlock_write_lock( & tcp_globals.lock );	219	fibril_rwlock_write_lock( & tcp_globals.lock );
223	tcp_globals.icmp_phone = icmp_connect_module( SERVICE_ICMP );	220	tcp_globals.icmp_phone = icmp_connect_module( SERVICE_ICMP );
224	if( tcp_globals.icmp_phone < 0 ){	221	if( tcp_globals.icmp_phone < 0 ){
225	return tcp_globals.icmp_phone;	222	return tcp_globals.icmp_phone;
226	}	223	}
227	tcp_globals.ip_phone = ip_bind_service( SERVICE_IP, IPPROTO_TCP, SERVICE_TCP, client_connection, tcp_received_msg );	224	tcp_globals.ip_phone = ip_bind_service( SERVICE_IP, IPPROTO_TCP, SERVICE_TCP, client_connection, tcp_received_msg );
228	if( tcp_globals.ip_phone < 0 ){	225	if( tcp_globals.ip_phone < 0 ){
229	return tcp_globals.ip_phone;	226	return tcp_globals.ip_phone;
230	}	227	}
231	ERROR_PROPAGATE( socket_ports_initialize( & tcp_globals.sockets ));	228	ERROR_PROPAGATE( socket_ports_initialize( & tcp_globals.sockets ));
232	if( ERROR_OCCURRED( packet_dimensions_initialize( & tcp_globals.dimensions ))){	229	if( ERROR_OCCURRED( packet_dimensions_initialize( & tcp_globals.dimensions ))){
233	socket_ports_destroy( & tcp_globals.sockets );	230	socket_ports_destroy( & tcp_globals.sockets );
234	return ERROR_CODE;	231	return ERROR_CODE;
235	}	232	}
236	tcp_globals.last_used_port = TCP_FREE_PORTS_START - 1;	233	tcp_globals.last_used_port = TCP_FREE_PORTS_START - 1;
237	fibril_rwlock_write_unlock( & tcp_globals.lock );	234	fibril_rwlock_write_unlock( & tcp_globals.lock );
238	return EOK;	235	return EOK;
239	}	236	}
240		237
241	int tcp_received_msg( device_id_t device_id, packet_t packet, services_t receiver, services_t error ){	238	int tcp_received_msg( device_id_t device_id, packet_t packet, services_t receiver, services_t error ){
242	ERROR_DECLARE;	239	ERROR_DECLARE;
243		240
244	if( receiver != SERVICE_TCP ) return EREFUSED;	241	if( receiver != SERVICE_TCP ) return EREFUSED;
245	fibril_rwlock_write_lock( & tcp_globals.lock );	242	fibril_rwlock_write_lock( & tcp_globals.lock );
246	if( ERROR_OCCURRED( tcp_process_packet( device_id, packet, error ))){	243	if( ERROR_OCCURRED( tcp_process_packet( device_id, packet, error ))){
247	fibril_rwlock_write_unlock( & tcp_globals.lock );	244	fibril_rwlock_write_unlock( & tcp_globals.lock );
248	}	245	}
249	printf( "receive %d \n", ERROR_CODE );	246	printf( "receive %d \n", ERROR_CODE );
250		247
251	return ERROR_CODE;	248	return ERROR_CODE;
252	}	249	}
253		250
254	int tcp_process_packet( device_id_t device_id, packet_t packet, services_t error ){	251	int tcp_process_packet( device_id_t device_id, packet_t packet, services_t error ){
255	ERROR_DECLARE;	252	ERROR_DECLARE;
256		253
257	size_t length;	254	size_t length;
258	size_t offset;	255	size_t offset;
259	int result;	256	int result;
260	tcp_header_ref header;	257	tcp_header_ref header;
261	socket_core_ref socket;	258	socket_core_ref socket;
262	tcp_socket_data_ref socket_data;	259	tcp_socket_data_ref socket_data;
263	packet_t next_packet;	260	packet_t next_packet;
264	size_t total_length;	261	size_t total_length;
265	uint32_t checksum;	262	uint32_t checksum;
266	int fragments;	263	int fragments;
267	icmp_type_t type;	264	icmp_type_t type;
268	icmp_code_t code;	265	icmp_code_t code;
269	struct sockaddr * src;	266	struct sockaddr * src;
270	struct sockaddr * dest;	267	struct sockaddr * dest;
271	size_t addrlen;	268	size_t addrlen;
272		269
273	printf( "p1 \n" );	270	printf( "p1 \n" );
274	if( error ){	271	if( error ){
275	switch( error ){	272	switch( error ){
276	case SERVICE_ICMP:	273	case SERVICE_ICMP:
277	// process error	274	// process error
278	result = icmp_client_process_packet( packet, & type, & code, NULL, NULL );	275	result = icmp_client_process_packet( packet, & type, & code, NULL, NULL );
279	if( result < 0 ){	276	if( result < 0 ){
280	return tcp_release_and_return( packet, result );	277	return tcp_release_and_return( packet, result );
281	}	278	}
282	length = ( size_t ) result;	279	length = ( size_t ) result;
283	if( ERROR_OCCURRED( packet_trim( packet, length, 0 ))){	280	if( ERROR_OCCURRED( packet_trim( packet, length, 0 ))){
284	return tcp_release_and_return( packet, ERROR_CODE );	281	return tcp_release_and_return( packet, ERROR_CODE );
285	}	282	}
286	break;	283	break;
287	default:	284	default:
288	return tcp_release_and_return( packet, ENOTSUP );	285	return tcp_release_and_return( packet, ENOTSUP );
289	}	286	}
290	}	287	}
291		288
292	// TODO process received ipopts?	289	// TODO process received ipopts?
293	result = ip_client_process_packet( packet, NULL, NULL, NULL, NULL, NULL );	290	result = ip_client_process_packet( packet, NULL, NULL, NULL, NULL, NULL );
294	// printf("ip len %d\n", result );	291	// printf("ip len %d\n", result );
295	if( result < 0 ){	292	if( result < 0 ){
296	return tcp_release_and_return( packet, result );	293	return tcp_release_and_return( packet, result );
297	}	294	}
298	offset = ( size_t ) result;	295	offset = ( size_t ) result;
299		296
300	length = packet_get_data_length( packet );	297	length = packet_get_data_length( packet );
301	// printf("packet len %d\n", length );	298	// printf("packet len %d\n", length );
302	if( length <= 0 ){	299	if( length <= 0 ){
303	return tcp_release_and_return( packet, EINVAL );	300	return tcp_release_and_return( packet, EINVAL );
304	}	301	}
305	if( length < sizeof( tcp_header_t ) + offset ){	302	if( length < sizeof( tcp_header_t ) + offset ){
306	return tcp_release_and_return( packet, NO_DATA );	303	return tcp_release_and_return( packet, NO_DATA );
307	}	304	}
308		305
309	// trim all but TCP header	306	// trim all but TCP header
310	if( ERROR_OCCURRED( packet_trim( packet, offset, 0 ))){	307	if( ERROR_OCCURRED( packet_trim( packet, offset, 0 ))){
311	return tcp_release_and_return( packet, ERROR_CODE );	308	return tcp_release_and_return( packet, ERROR_CODE );
312	}	309	}
313		310
314	// get tcp header	311	// get tcp header
315	header = ( tcp_header_ref ) packet_get_data( packet );	312	header = ( tcp_header_ref ) packet_get_data( packet );
316	if( ! header ){	313	if( ! header ){
317	return tcp_release_and_return( packet, NO_DATA );	314	return tcp_release_and_return( packet, NO_DATA );
318	}	315	}
319	// printf( "header len %d, port %d \n", TCP_HEADER_LENGTH( header ), ntohs( header->destination_port ));	316	// printf( "header len %d, port %d \n", TCP_HEADER_LENGTH( header ), ntohs( header->destination_port ));
320		317
321	result = packet_get_addr( packet, ( uint8_t ) & src, ( uint8_t ) & dest );	318	result = packet_get_addr( packet, ( uint8_t ) & src, ( uint8_t ) & dest );
322	if( result <= 0 ){	319	if( result <= 0 ){
323	return tcp_release_and_return( packet, result );	320	return tcp_release_and_return( packet, result );
324	}	321	}
325	addrlen = ( size_t ) result;	322	addrlen = ( size_t ) result;
326		323
327	if( ERROR_OCCURRED( tl_set_address_port( src, addrlen, ntohs( header->source_port )))){	324	if( ERROR_OCCURRED( tl_set_address_port( src, addrlen, ntohs( header->source_port )))){
328	return tcp_release_and_return( packet, ERROR_CODE );	325	return tcp_release_and_return( packet, ERROR_CODE );
329	}	326	}
330		327
331	// find the destination socket	328	// find the destination socket
332	socket = socket_port_find( & tcp_globals.sockets, ntohs( header->destination_port ), ( const char * ) src, addrlen );	329	socket = socket_port_find( & tcp_globals.sockets, ntohs( header->destination_port ), ( const char * ) src, addrlen );
333	if( ! socket ){	330	if( ! socket ){
334	// printf("listening?\n");	331	// printf("listening?\n");
335	// find the listening destination socket	332	// find the listening destination socket
336	socket = socket_port_find( & tcp_globals.sockets, ntohs( header->destination_port ), SOCKET_MAP_KEY_LISTENING, 0 );	333	socket = socket_port_find( & tcp_globals.sockets, ntohs( header->destination_port ), SOCKET_MAP_KEY_LISTENING, 0 );
337	if( ! socket ){	334	if( ! socket ){
338	if( tl_prepare_icmp_packet( tcp_globals.net_phone, tcp_globals.icmp_phone, packet, error ) == EOK ){	335	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 );	336	icmp_destination_unreachable_msg( tcp_globals.icmp_phone, ICMP_PORT_UNREACH, 0, packet );
340	}	337	}
341	return EADDRNOTAVAIL;	338	return EADDRNOTAVAIL;
342	}	339	}
343	}	340	}
344	printf("socket id %d\n", socket->socket_id );	341	printf("socket id %d\n", socket->socket_id );
345	socket_data = ( tcp_socket_data_ref ) socket->specific_data;	342	socket_data = ( tcp_socket_data_ref ) socket->specific_data;
346	assert( socket_data );	343	assert( socket_data );
347		344
348	// some data received, clear the timeout counter	345	// some data received, clear the timeout counter
349	socket_data->timeout_count = 0;	346	socket_data->timeout_count = 0;
350		347
351	// count the received packet fragments	348	// count the received packet fragments
352	next_packet = packet;	349	next_packet = packet;
353	fragments = 0;	350	fragments = 0;
354	checksum = 0;	351	checksum = 0;
355	total_length = 0;	352	total_length = 0;
356	do{	353	do{
357	++ fragments;	354	++ fragments;
358	length = packet_get_data_length( next_packet );	355	length = packet_get_data_length( next_packet );
359	if( length <= 0 ){	356	if( length <= 0 ){
360	return tcp_release_and_return( packet, NO_DATA );	357	return tcp_release_and_return( packet, NO_DATA );
361	}	358	}
362	total_length += length;	359	total_length += length;
363	// add partial checksum if set	360	// add partial checksum if set
364	if( ! error ){	361	if( ! error ){
365	checksum = compute_checksum( checksum, packet_get_data( packet ), packet_get_data_length( packet ));	362	checksum = compute_checksum( checksum, packet_get_data( packet ), packet_get_data_length( packet ));
366	}	363	}
367	}while(( next_packet = pq_next( next_packet )));	364	}while(( next_packet = pq_next( next_packet )));
368	// printf( "fragments %d of %d bytes\n", fragments, total_length );	365	// printf( "fragments %d of %d bytes\n", fragments, total_length );
369		366
370	// printf("lock?\n");	367	// printf("lock?\n");
371	fibril_rwlock_write_lock( socket_data->local_lock );	368	fibril_rwlock_write_lock( socket_data->local_lock );
372	// printf("locked\n");	369	// printf("locked\n");
373	if( ! error ){	370	if( ! error ){
374	if( socket_data->state == TCP_SOCKET_LISTEN ){	371	if( socket_data->state == TCP_SOCKET_LISTEN ){
375	if( socket_data->pseudo_header ){	372	if( socket_data->pseudo_header ){
376	free( socket_data->pseudo_header );	373	free( socket_data->pseudo_header );
377	socket_data->pseudo_header = NULL;	374	socket_data->pseudo_header = NULL;
378	socket_data->headerlen = 0;	375	socket_data->headerlen = 0;
379	}	376	}
380	if( ERROR_OCCURRED( ip_client_get_pseudo_header( IPPROTO_TCP, src, addrlen, dest, addrlen, total_length, & socket_data->pseudo_header, & socket_data->headerlen ))){	377	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 );	378	fibril_rwlock_write_unlock( socket_data->local_lock );
382	return tcp_release_and_return( packet, ERROR_CODE );	379	return tcp_release_and_return( packet, ERROR_CODE );
383	}	380	}
384	}else if( ERROR_OCCURRED( ip_client_set_pseudo_header_data_length( socket_data->pseudo_header, socket_data->headerlen, total_length ))){	381	}else if( ERROR_OCCURRED( ip_client_set_pseudo_header_data_length( socket_data->pseudo_header, socket_data->headerlen, total_length ))){
385	fibril_rwlock_write_unlock( socket_data->local_lock );	382	fibril_rwlock_write_unlock( socket_data->local_lock );
386	return tcp_release_and_return( packet, ERROR_CODE );	383	return tcp_release_and_return( packet, ERROR_CODE );
387	}	384	}
388	checksum = compute_checksum( checksum, socket_data->pseudo_header, socket_data->headerlen );	385	checksum = compute_checksum( checksum, socket_data->pseudo_header, socket_data->headerlen );
389	if( flip_checksum( compact_checksum( checksum ))){	386	if( flip_checksum( compact_checksum( checksum ))){
390	printf( "checksum err %x -> %x\n", header->checksum, flip_checksum( compact_checksum( checksum )));	387	printf( "checksum err %x -> %x\n", header->checksum, flip_checksum( compact_checksum( checksum )));
391	fibril_rwlock_write_unlock( socket_data->local_lock );	388	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 ))){	389	if( ! ERROR_OCCURRED( tl_prepare_icmp_packet( tcp_globals.net_phone, tcp_globals.icmp_phone, packet, error ))){
393	// checksum error ICMP	390	// 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 );	391	icmp_parameter_problem_msg( tcp_globals.icmp_phone, ICMP_PARAM_POINTER, (( size_t ) (( void * ) & header->checksum )) - (( size_t ) (( void * ) header )), packet );
395	}	392	}
396	return EINVAL;	393	return EINVAL;
397	}	394	}
398	}	395	}
399		396
400	fibril_rwlock_read_unlock( & tcp_globals.lock );	397	fibril_rwlock_read_unlock( & tcp_globals.lock );
401		398
402	// TODO error reporting/handling	399	// TODO error reporting/handling
403	// printf( "st %d\n", socket_data->state );	400	// printf( "st %d\n", socket_data->state );
404	switch( socket_data->state ){	401	switch( socket_data->state ){
405	case TCP_SOCKET_LISTEN:	402	case TCP_SOCKET_LISTEN:
406	ERROR_CODE = tcp_process_listen( socket, socket_data, header, packet, src, dest, addrlen );	403	ERROR_CODE = tcp_process_listen( socket, socket_data, header, packet, src, dest, addrlen );
407	break;	404	break;
408	case TCP_SOCKET_SYN_RECEIVED:	405	case TCP_SOCKET_SYN_RECEIVED:
409	ERROR_CODE = tcp_process_syn_received( socket, socket_data, header, packet );	406	ERROR_CODE = tcp_process_syn_received( socket, socket_data, header, packet );
410	break;	407	break;
411	case TCP_SOCKET_SYN_SENT:	408	case TCP_SOCKET_SYN_SENT:
412	ERROR_CODE = tcp_process_syn_sent( socket, socket_data, header, packet );	409	ERROR_CODE = tcp_process_syn_sent( socket, socket_data, header, packet );
413	break;	410	break;
414	case TCP_SOCKET_FIN_WAIT_1:	411	case TCP_SOCKET_FIN_WAIT_1:
415	// ack changing the state to FIN_WAIT_2 gets processed later	412	// ack changing the state to FIN_WAIT_2 gets processed later
416	case TCP_SOCKET_FIN_WAIT_2:	413	case TCP_SOCKET_FIN_WAIT_2:
417	// fin changing state to LAST_ACK gets processed later	414	// fin changing state to LAST_ACK gets processed later
418	case TCP_SOCKET_LAST_ACK:	415	case TCP_SOCKET_LAST_ACK:
419	// ack releasing the socket get processed later	416	// ack releasing the socket get processed later
420	case TCP_SOCKET_CLOSING:	417	case TCP_SOCKET_CLOSING:
421	// ack releasing the socket gets processed later	418	// ack releasing the socket gets processed later
422	case TCP_SOCKET_ESTABLISHED:	419	case TCP_SOCKET_ESTABLISHED:
423	ERROR_CODE = tcp_process_established( socket, socket_data, header, packet, fragments, total_length );	420	ERROR_CODE = tcp_process_established( socket, socket_data, header, packet, fragments, total_length );
424	break;	421	break;
425	default:	422	default:
426	pq_release( tcp_globals.net_phone, packet_get_id( packet ));	423	pq_release( tcp_globals.net_phone, packet_get_id( packet ));
427	}	424	}
428		425
429	if( ERROR_CODE != EOK ){	426	if( ERROR_CODE != EOK ){
430	printf( "process %d\n", ERROR_CODE );	427	printf( "process %d\n", ERROR_CODE );
431	fibril_rwlock_write_unlock( socket_data->local_lock );	428	fibril_rwlock_write_unlock( socket_data->local_lock );
432	}	429	}
433	return EOK;	430	return EOK;
434	}	431	}
435		432
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 ){	433	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 ){
437	ERROR_DECLARE;	434	ERROR_DECLARE;
438		435
439	packet_t next_packet;	436	packet_t next_packet;
440	packet_t tmp_packet;	437	packet_t tmp_packet;
441	uint32_t old_incoming;	438	uint32_t old_incoming;
442	size_t order;	439	size_t order;
443	uint32_t sequence_number;	440	uint32_t sequence_number;
444	size_t length;	441	size_t length;
445	size_t offset;	442	size_t offset;
446	uint32_t new_sequence_number;	443	uint32_t new_sequence_number;
447		444
448	assert( socket );	445	assert( socket );
449	assert( socket_data );	446	assert( socket_data );
450	assert( socket->specific_data == socket_data );	447	assert( socket->specific_data == socket_data );
451	assert( header );	448	assert( header );
452	assert( packet );	449	assert( packet );
453		450
454	new_sequence_number = ntohl( header->sequence_number );	451	new_sequence_number = ntohl( header->sequence_number );
455	old_incoming = socket_data->next_incoming;	452	old_incoming = socket_data->next_incoming;
456		453
457	if( header->finalize ){	454	if( header->finalize ){
458	socket_data->fin_incoming = new_sequence_number;	455	socket_data->fin_incoming = new_sequence_number;
459	}	456	}
460		457
461	// printf( "pe %d < %d <= %d\n", new_sequence_number, socket_data->next_incoming, new_sequence_number + total_length );	458	// printf( "pe %d < %d <= %d\n", new_sequence_number, socket_data->next_incoming, new_sequence_number + total_length );
462	// trim begining if containing expected data	459	// trim begining if containing expected data
463	if( IS_IN_INTERVAL_OVERFLOW( new_sequence_number, socket_data->next_incoming, new_sequence_number + total_length )){	460	if( IS_IN_INTERVAL_OVERFLOW( new_sequence_number, socket_data->next_incoming, new_sequence_number + total_length )){
464	// get the acknowledged offset	461	// get the acknowledged offset
465	if( socket_data->next_incoming < new_sequence_number ){	462	if( socket_data->next_incoming < new_sequence_number ){
466	offset = new_sequence_number - socket_data->next_incoming;	463	offset = new_sequence_number - socket_data->next_incoming;
467	}else{	464	}else{
468	offset = socket_data->next_incoming - new_sequence_number;	465	offset = socket_data->next_incoming - new_sequence_number;
469	}	466	}
470	// printf( "offset %d\n", offset );	467	// printf( "offset %d\n", offset );
471	new_sequence_number += offset;	468	new_sequence_number += offset;
472	total_length -= offset;	469	total_length -= offset;
473	length = packet_get_data_length( packet );	470	length = packet_get_data_length( packet );
474	// trim the acknowledged data	471	// trim the acknowledged data
475	while( length <= offset ){	472	while( length <= offset ){
476	// release the acknowledged packets	473	// release the acknowledged packets
477	next_packet = pq_next( packet );	474	next_packet = pq_next( packet );
478	pq_release( tcp_globals.net_phone, packet_get_id( packet ));	475	pq_release( tcp_globals.net_phone, packet_get_id( packet ));
479	packet = next_packet;	476	packet = next_packet;
480	offset -= length;	477	offset -= length;
481	length = packet_get_data_length( packet );	478	length = packet_get_data_length( packet );
482	}	479	}
483	if(( offset > 0 )	480	if(( offset > 0 )
484	&& ( ERROR_OCCURRED( packet_trim( packet, offset, 0 )))){	481	&& ( ERROR_OCCURRED( packet_trim( packet, offset, 0 )))){
485	return tcp_release_and_return( packet, ERROR_CODE );	482	return tcp_release_and_return( packet, ERROR_CODE );
486	}	483	}
487	assert( new_sequence_number == socket_data->next_incoming );	484	assert( new_sequence_number == socket_data->next_incoming );
488	}	485	}
489		486
490	// release if overflowing the window	487	// 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 )){	488	// 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 );	489	// return tcp_release_and_return( packet, EOVERFLOW );
493	// }	490	// }
494		491
495	/*	492	/*
496	// trim end if overflowing the window	493	// 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 )){	494	if( IS_IN_INTERVAL_OVERFLOW( new_sequence_number, socket_data->next_incoming + socket_data->window, new_sequence_number + total_length )){
498	// get the allowed data length	495	// get the allowed data length
499	if( socket_data->next_incoming + socket_data->window < new_sequence_number ){	496	if( socket_data->next_incoming + socket_data->window < new_sequence_number ){
500	offset = new_sequence_number - socket_data->next_incoming + socket_data->window;	497	offset = new_sequence_number - socket_data->next_incoming + socket_data->window;

Subversion Repositories HelenOS

(root)/branches/network/uspace/srv/net/tl/tcp/tcp.c – Rev 4742 → 4750