Subversion Repositories HelenOS

/*

 * 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

 */

#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

/** Initial timeout for new connections.

 */

#define NET_DEFAULT_TCP_INITIAL_TIMEOUT 3000000L

/** Default timeout for closing.

 */

#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

/** Timeout for connection initialization, SYN sent.

 */

#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

/** Returns a value indicating whether the value is in the interval respecting the possible overflow.

 *  The high end and/or the value may overflow, be lower than the low value.

 *  @param[in] lower The last value before the interval.

 *  @param[in] value The value to be checked.

 *  @param[in] high_equal The last value in the interval.

 */

#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[in] packet The packet queue to be released.

 *  @param[in] result The result to be returned.

 *  @return The result parameter.

 */

int tcp_release_and_return( packet_t packet, int result );

void    tcp_prepare_operation_header( socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, int synchronize, int finalize );

int tcp_prepare_timeout( int ( * timeout_function )( void * tcp_timeout_t ), socket_core_ref socket, tcp_socket_data_ref socket_data, size_t sequence_number, tcp_socket_state_t state, suseconds_t timeout, int globals_read_only );

void    tcp_free_socket_data( socket_core_ref socket );

int tcp_timeout( void * data );

int tcp_release_after_timeout( void * data );

int tcp_process_packet( device_id_t device_id, packet_t packet, services_t error );

int tcp_connect_core( socket_core_ref socket, socket_cores_ref local_sockets, struct sockaddr * addr, socklen_t addrlen );

int tcp_queue_prepare_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length );

int tcp_queue_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length );

packet_t    tcp_get_packets_to_send( socket_core_ref socket, tcp_socket_data_ref socket_data );

void    tcp_send_packets( device_id_t device_id, packet_t packet );

void    tcp_process_acknowledgement( socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header );

packet_t    tcp_send_prepare_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length, size_t sequence_number );

packet_t    tcp_prepare_copy( socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, size_t data_length, size_t sequence_number );

void    tcp_retransmit_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, size_t sequence_number );

int tcp_create_notification_packet( packet_t * packet, socket_core_ref socket, tcp_socket_data_ref socket_data, int synchronize, int finalize );

void    tcp_refresh_socket_data( tcp_socket_data_ref socket_data );

void    tcp_initialize_socket_data( tcp_socket_data_ref socket_data );

int tcp_process_listen( socket_core_ref listening_socket, tcp_socket_data_ref listening_socket_data, tcp_header_ref header, packet_t packet, struct sockaddr * src, struct sockaddr * dest, size_t addrlen );

int tcp_process_syn_sent( socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet );

int tcp_process_syn_received( socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet );

int tcp_process_established( socket_core_ref socket, tcp_socket_data_ref socket_data, tcp_header_ref header, packet_t packet, int fragments, size_t total_length );

int tcp_queue_received_packet( socket_core_ref socket, tcp_socket_data_ref socket_data, packet_t packet, int fragments, size_t total_length );

int tcp_received_msg( device_id_t device_id, packet_t packet, services_t receiver, services_t error );

int tcp_process_client_messages( ipc_callid_t callid, ipc_call_t call );

int tcp_listen_message( socket_cores_ref local_sockets, int socket_id, int backlog );

int tcp_connect_message( socket_cores_ref local_sockets, int socket_id, struct sockaddr * addr, socklen_t addrlen );

int tcp_recvfrom_message( socket_cores_ref local_sockets, int socket_id, int flags, size_t * addrlen );

int tcp_send_message( socket_cores_ref local_sockets, int socket_id, int fragments, size_t data_fragment_size, int flags );

int tcp_accept_message( socket_cores_ref local_sockets, int socket_id, 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 ){