WebSVN – Kolibri OS – Diff – /kernel/trunk/network/tcp_input.inc

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;                                                                 ;;
-;; Copyright (C) KolibriOS team 2004-2015. All rights reserved.    ;;
+;; Copyright (C) KolibriOS team 2004-2016. All rights reserved.    ;;
 ;; Distributed under terms of the GNU General Public License       ;;
 ;;                                                                 ;;
 ;;  Part of the TCP/IP network stack for KolibriOS                 ;;
 ;;                                                                 ;;
 ;;   Written by hidnplayr@kolibrios.org                            ;;
 ;;          GNU GENERAL PUBLIC LICENSE                             ;;
 ;;             Version 2, June 1991                                ;;
 ;;                                                                 ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+$Revision: 6476 $
+TCP_BIT_NEEDOUTPUT      = 1 shl 0
+TCP_BIT_TIMESTAMP       = 1 shl 1
+TCP_BIT_DROPSOCKET      = 1 shl 2
-$Revision: 6413 $
+TCP_BIT_FIN_IS_ACKED    = 1 shl 3
 ;-----------------------------------------------------------------;
 ;                                                                 ;
         add     esp, sizeof.TCP_queue_entry - 4
         call    net_buff_free
         ret
+;-----------------------------------------------------------------;
+;                                                                 ;
+; TCP_process_input: Process segments from the incoming TCP queue.;
+;                                                                 ;
+;  IN:  /                                                         ;
+;  OUT: /                                                         ;
 ;                                                                 ;
 ;-----------------------------------------------------------------;
 align 4
 proc tcp_process_input
         DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: size=%u time=%d\n", ecx, [timer_ticks]
-        mov     edx, esi
-        cmp     ebx, LOOPBACK_DEVICE
+        mov     edx, esi
         je      .checksum_ok
 ; Verify the checksum (if not already done by hw)
 ; re-calculate the checksum (if not already done by hw)
         pop     edx ecx
         jne     .drop_no_socket
   .checksum_ok:
+; Verify the data offset
 ; Verify the data offset
         movzx   eax, [edx + TCP_header.DataOffset]
         and     al, 0xf0                        ; Calculate TCP segment header size (throwing away unused reserved bits in TCP header)
         shr     al, 2
         cmp     al, sizeof.TCP_header           ; Now see if it's at least the size of a standard TCP header
         ntohd   [edx + TCP_header.AckNumber]
         ntohw   [edx + TCP_header.Window]
         ntohw   [edx + TCP_header.UrgentPointer]
 ;-----------------------------------------------------------------------------------
+;
+; Find the socket pointer
 ;------------------------
-; Find the socket pointer
+;-----------------------------------------------------------------------------------
         mov     cl, [ebx + TCP_SOCKET.SND_SCALE]
         shl     eax, cl
-        mov     dword [edx + TCP_header.Window], eax    ; word after window is checksum, we dont need checksum anymore
+        mov     dword[edx + TCP_header.Window], eax     ; word after window is checksum, we dont need checksum anymore
         pop     ecx
+;-----------------------------------------------------------------------------------
-;---------------------------------------
+;
+; Accept incoming connections
+;
-; Are we accepting incoming connections?
+;-----------------------------------------------------------------------------------
         test    [ebx + SOCKET.options], SO_ACCEPTCON
+        jz      .no_accept
-        jz      .no_accept
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Accepting new connection\n"
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Accepting new connection\n"
+; Unlock current socket
+        pusha
+        lea     ecx, [ebx + SOCKET.mutex]
-        pusha
+        call    mutex_unlock
-        lea     ecx, [ebx + SOCKET.mutex]
+        popa
         call    mutex_unlock
-        popa
+; Fork it
+        push    ecx edx esi edi
+        call    socket_fork
-        push    ecx edx esi edi
+        pop     edi esi edx ecx
         call    socket_fork
-        pop     edi esi edx ecx
+        test    eax, eax
         mov     [ebx + TCP_SOCKET.t_idle], 0
         mov     [ebx + TCP_SOCKET.timer_keepalive], TCP_time_keep_idle
         or      [ebx + TCP_SOCKET.timer_flags], timer_flag_keepalive
 ;-----------------------------------------------------------------------------------
+;
+; Process TCP options
 ;--------------------
-; Process TCP options
+;-----------------------------------------------------------------------------------
         mov     [ebx + TCP_SOCKET.ts_recent], 0         ; timestamp was invalid, fix it.
   .no_paws:
         jmp     .opt_loop
   .paws_drop:
-        inc     [TCPS_rcvduppack]                       ; update stats
+        inc     [TCPS_rcvduppack]
         add     [TCPS_rcvdupbyte], ecx
         inc     [TCPS_pawsdrop]
         jmp     .drop_after_ack
   .no_options:
+        pop     ecx
+;-----------------------------------------------------------------------------------
-        pop     ecx
+;
 ; Header prediction
 ;-----------------------------------------------------------------------
-; Time to do some header prediction (Original Principle by Van Jacobson)
+;-----------------------------------------------------------------------------------
-; There are two common cases for an uni-directional data transfer.
+; According to Van Jacobson, there are two common cases for an uni-directional data transfer.
 ; check if we are sender in the uni-xfer
 ; If the following 4 conditions are all true, this segment is a pure ACK.
+;
+; - The segment contains no data.
 ; - The segment contains no data.
         test    ecx, ecx
         jnz     .not_sender
+; - The congestion window is greater than or equal to the current send window.
-; - The congestion window is greater than or equal to the current send window.
+;     This test is true only if the window is fully open, that is, the connection is not in the middle of slow start or congestion avoidance.
 ;     This test is true only if the window is fully open, that is, the connection is not in the middle of slow start or congestion avoidance.
         mov     eax, [ebx + TCP_SOCKET.SND_CWND]
         cmp     eax, [ebx + TCP_SOCKET.SND_WND]
+        jb      .not_uni_xfer
         jb      .not_uni_xfer
 ; - The acknowledgment field in the segment is less than or equal to the maximum sequence number sent.
 ; - The acknowledgment field in the segment is less than or equal to the maximum sequence number sent.
         mov     eax, [edx + TCP_header.AckNumber]
+        cmp     eax, [ebx + TCP_SOCKET.SND_MAX]
-        cmp     eax, [ebx + TCP_SOCKET.SND_MAX]
+        ja      .not_uni_xfer
         ja      .not_uni_xfer
 ; - The acknowledgment field in the segment is greater than the largest unacknowledged sequence number.
 ; - The acknowledgment field in the segment is greater than the largest unacknowledged sequence number.
         sub     eax, [ebx + TCP_SOCKET.SND_UNA]
+        jbe     .not_uni_xfer
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Header prediction: we are sender\n"
+;---------------------------------
-        jbe     .not_uni_xfer
+; Packet is a pure ACK, process it
         inc     [TCPS_predack]
         DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Header prediction: we are sender\n"
         inc     [TCPS_rcvackpack]
-;---------------------------------
+        add     [TCPS_rcvackbyte], eax
 ; Packet is a pure ACK, process it
         mov     eax, [ebx + TCP_SOCKET.t_rtt]
         call    tcp_xmit_timer
   .rtt_done:
+; update window pointers
 ; update window pointers
         mov     eax, [edx + TCP_header.AckNumber]
         mov     [ebx + TCP_SOCKET.SND_UNA], eax
 ; Stop retransmit timer
 ; Stop retransmit timer
+        and     [ebx + TCP_SOCKET.timer_flags], not timer_flag_retransmission
         and     [ebx + TCP_SOCKET.timer_flags], not timer_flag_retransmission
 ; Unlock the socket
 ; Unlock the socket
         pusha
         lea     ecx, [ebx + SOCKET.mutex]
+        call    mutex_unlock
-        call    mutex_unlock
+        popa
         popa
 ; Awaken waiting processes
-; Awaken waiting processes
+        mov     eax, ebx
-        mov     eax, ebx
+        call    socket_notify
         call    socket_notify
 ; Generate more output
 ; Generate more output
-        call    tcp_output
+        call    tcp_output
+        jmp     .drop_no_socket
         jmp     .drop_no_socket
 ;-------------------------------------------------
-;-------------------------------------------------
+; maybe we are the receiver in the uni-xfer then..
 ; maybe we are the receiver in the uni-xfer then..
+  .not_sender:
-  .not_sender:
+; - The amount of data in the segment is greater than 0 (data count is in ecx)
-; - The amount of data in the segment is greater than 0 (data count is in ecx)
+; - The acknowledgment field equals the largest unacknowledged sequence number. This means no data is acknowledged by this segment.
         or      [ebx + TCP_SOCKET.t_flags], TF_DELACK   ; Set delayed ack flag
-        jmp     .drop
+        jmp     .drop
+;-----------------------------------------------------------------------------------
+;
-;--------------------------------------------------
+; TCP segment processing, the slow way
 ; Header prediction failed, do it the slow way
+;-----------------------------------------------------------------------------------
   .not_uni_xfer:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Header prediction failed\n"
         DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Header prediction failed\n"
 ; Calculate receive window size
         pop     edx
 ; If we are in listen or syn_sent state, go to that specific code right away
         cmp     [ebx + TCP_SOCKET.t_state], TCPS_LISTEN
-        je      .LISTEN
+        je      .state_listen
+        cmp     [ebx + TCP_SOCKET.t_state], TCPS_SYN_SENT
-        cmp     [ebx + TCP_SOCKET.t_state], TCPS_SYN_SENT
+        je      .state_syn_sent
+;-----------------------------------------------------------------------------------
+;
-        je      .SYN_SENT
+; Trim any data not in window
+;
+;-----------------------------------------------------------------------------------
 ;----------------------------
-; trim any data not in window
+;-------------------------------------------------
 ; Check for duplicate data at beginning of segment
 ; 1. Check for duplicate data at beginning of segment
+; Calculate number of bytes we need to drop
         mov     eax, [ebx + TCP_SOCKET.RCV_NXT]
-; Calculate number of bytes we need to drop
+        sub     eax, [edx + TCP_header.SequenceNumber]
-        mov     eax, [ebx + TCP_SOCKET.RCV_NXT]
+        jle     .no_duplicate
         and     [edx + TCP_header.Flags], not (TH_URG)
   .dup_syn:
         dec     eax
   .no_dup_syn:
+;-----------------------------------
+; Check for entire duplicate segment
 ; 2. Check for entire duplicate segment
         cmp     eax, ecx                ; eax holds number of bytes to drop, ecx is data size
-        jb      .duplicate
+        jb      .no_complete_dup
         jnz     @f
         test    [edx + TCP_header.Flags], TH_FIN
-        jnz     .duplicate
+        jnz     .no_complete_dup
        @@:
+; Any valid FIN must be to the left of the window.
-; Any valid FIN must be to the left of the window.
+; At this point the FIN must be out of sequence or a duplicate, drop it
-; At this point the FIN must be out of sequence or a duplicate, drop it
         and     [edx + TCP_header.Flags], not TH_FIN
 ; send an ACK to resynchronize and drop any data.
-; send an ACK and resynchronize and drop any data.
+; But keep on processing for RST or ACK
+        or      [ebx + TCP_SOCKET.t_flags], TF_ACKNOW
+        mov     eax, ecx
-; But keep on processing for RST or ACK
+        inc     [TCPS_rcvduppack]
-        or      [ebx + TCP_SOCKET.t_flags], TF_ACKNOW
+        add     [TCPS_rcvdupbyte], eax
-        mov     eax, ecx
+        jmp     .dup_processed
   .no_complete_dup:
         inc     [TCPS_rcvpartduppack]
-;;; TODO: update stats
+        add     [TCPS_rcvpartdupbyte], eax
   .dup_processed:
 ;-----------------------------------------------
 ; Remove duplicate data and update urgent offset
-  .duplicate:
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: trimming duplicate data\n"
         DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: trimming duplicate data\n"
 ; Trim data from left side of window
 ; Trim data from left side of window
         add     [dataoffset], eax
+        add     [edx + TCP_header.SequenceNumber], eax
-        add     [edx + TCP_header.SequenceNumber], eax
+        sub     ecx, eax
         sub     ecx, eax
         sub     [edx + TCP_header.UrgentPointer], ax
         jg      @f
         and     [edx + TCP_header.Flags], not (TH_URG)
         mov     [edx + TCP_header.UrgentPointer], 0
        @@:
         mov     eax, ebx
         call    tcp_close
         inc     [TCPS_rcvafterclose]
+        jmp     .respond_seg_reset
-        jmp     .respond_seg_reset
+  .not_terminated:
-;----------------------------------------
-; Remove data beyond right edge of window
+;----------------------------------------
 ; Remove data beyond right edge of window
   .not_terminated:
         mov     eax, [edx + TCP_header.SequenceNumber]
         add     eax, ecx
         sub     eax, [ebx + TCP_SOCKET.RCV_NXT]
         sub     eax, [ebx + TCP_SOCKET.RCV_WND]         ; eax now holds the number of bytes to drop
+        jle     .no_excess_data
         jle     .no_excess_data
         DEBUGF  DEBUG_NETWORK_VERBOSE, "%d bytes beyond right edge of window\n", eax
+        inc     [TCPS_rcvpackafterwin]
+        cmp     eax, ecx
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "%d bytes beyond right edge of window\n", eax
+        jl      .dont_drop_all
-;;; TODO: update stats
+        add     [TCPS_rcvbyteafterwin], ecx
         cmp     eax, ecx
-        jl      .dont_drop_all
+;----------------------------------------------------------------------------------------------------
 ; If a new connection request is received while in TIME_WAIT, drop the old connection and start over,
 ; if the sequence numbers are above the previous ones
         test    [edx + TCP_header.Flags], TH_SYN
         jz      .no_new_request
         mov     esi, [edx + TCP_header.SequenceNumber]
         cmp     esi, [ebx + TCP_SOCKET.RCV_NXT]
         jne     .drop_after_ack
         or      [ebx + TCP_SOCKET.t_flags], TF_ACKNOW
-;;; TODO: update stats
+        inc     [TCPS_rcvwinprobe]
   .dont_drop_all:
-;;; TODO: update stats
+        add     [TCPS_rcvbyteafterwin], eax
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "Trimming %u bytes from the right of the window\n"
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "Trimming %u bytes from the right of the window\n"
+; remove data from the right side of window (decrease data length)
-        sub     ecx, eax        ; remove data from the right side of window (decrease data length)
+        sub     ecx, eax
         and     [edx + TCP_header.Flags], not (TH_PUSH or TH_FIN)
   .no_excess_data:
 ;-----------------------------------------------------------------------------------
+;
+; Record timestamp
 ;-----------------
+;-----------------------------------------------------------------------------------
 ; Record timestamp
 ; If last ACK falls within this segments sequence numbers, record its timestamp
 ; If last ACK falls within this segments sequence numbers, record its timestamp
         test    [temp_bits], TCP_BIT_TIMESTAMP
         jz      .no_timestamp
         mov     eax, [ebx + TCP_SOCKET.last_ack_sent]
         sub     eax, [edx + TCP_header.SequenceNumber]
         jb      .no_timestamp
-        test    [ebx + TCP_header.Flags], TH_SYN or TH_FIN      ; syn and fin occupy one byte
+        test    [edx + TCP_header.Flags], TH_SYN or TH_FIN      ; SYN and FIN occupy one byte
         jz      @f
         dec     eax
         mov     [ebx + TCP_SOCKET.ts_recent_age], eax
         mov     eax, [ebx + TCP_SOCKET.ts_val]
         mov     [ebx + TCP_SOCKET.ts_recent], eax
   .no_timestamp:
+;-----------------------------------------------------------------------------------
-;------------------
+;
+; Process RST flag
+;
-; Process RST flags
+;-----------------------------------------------------------------------------------
         test    [edx + TCP_header.Flags], TH_RST
         jz      .no_rst
         DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Got an RST flag\n"
         mov     eax, [ebx + TCP_SOCKET.t_state]
-        mov     eax, [ebx + TCP_SOCKET.t_state]
+        shl     eax, 2
-        shl     eax, 2
+        jmp     dword [eax + .rst_sw_list]
         jmp     dword [eax + .rst_sw_list]
 ;-----------------------------------------------------------------------------------
         dd      .econnreset     ; TCPS_CLOSE_WAIT
         dd      .econnreset     ; TCPS_FIN_WAIT_1
         dd      .rst_close      ; TCPS_CLOSING
         dd      .rst_close      ; TCPS_LAST_ACK
         dd      .econnreset     ; TCPS_FIN_WAIT_2
-        dd      .rst_close      ; TCPS_TIMED_WAIT
+        dd      .rst_close      ; TCPS_TIME_WAIT
 ;-----------------------------------------------------------------------------------
   .econnrefused:
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Connection refused\n"
         DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Connection refused\n"
         mov     [ebx + SOCKET.errorcode], ECONNREFUSED
+        jmp     .close
         jmp     .close
 ;-----------------------------------------------------------------------------------
-  .econnreset:
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Connection reset\n"
+  .econnreset:
-        mov     [ebx + SOCKET.errorcode], ECONNRESET
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Connection reset\n"
         mov     [ebx + SOCKET.errorcode], ECONNRESET
-  .close:
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Closing connection\n"
+  .close:
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Closing connection\n"
+        mov     [ebx + TCP_SOCKET.t_state], TCPS_CLOSED
+        inc     [TCPS_drops]
         mov     [ebx + TCP_SOCKET.t_state], TCPS_CLOSED
 ;;; TODO: update stats (tcp drops)
         mov     eax, ebx
+        call    tcp_close
-        call    tcp_close
+        jmp     .drop_no_socket
         jmp     .drop_no_socket
 ;-----------------------------------------------------------------------------------
   .rst_close:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Closing with reset\n"
         mov     eax, ebx
-        mov     eax, ebx
+        call    tcp_close
+        jmp     .drop_no_socket
-        call    tcp_close
+;-----------------------------------------------------------------------------------
+  .no_rst:
+;-----------------------------------------------------------------------------------
         jmp     .drop_no_socket
 ; Handle SYN-full and ACK-less segments
   .no_rst:
 ;-----------------------------------------------------------------------------------
 ;--------------------------------------
-; handle SYN-full and ACK-less segments
+; If a SYN is in the window, then this is an error so we send an RST and drop the connection
-        test    [edx + TCP_header.Flags], TH_SYN
-        jz      .not_syn_full
+        test    [edx + TCP_header.Flags], TH_SYN
         jz      .not_syn_full
         mov     eax, ebx
+        mov     eax, ebx
+        mov     ebx, ECONNRESET
+        call    tcp_drop
+        jmp     .drop_with_reset
+  .not_syn_full:
-        mov     ebx, ECONNRESET
+; If ACK bit is off, we drop the segment and return
         call    tcp_drop
-        jmp     .drop_with_reset
+        test    [edx + TCP_header.Flags], TH_ACK
-  .not_syn_full:
+        jz      .drop
         cmp     [ebx + TCP_SOCKET.SND_UNA], eax
         ja      .drop_with_reset
         cmp     eax, [ebx + TCP_SOCKET.SND_MAX]
         ja      .drop_with_reset
-;;; TODO: update stats
+        inc     [TCPS_connects]
         mov     eax, ebx
         call    tcp_reassemble
         mov     eax, [edx + TCP_header.SequenceNumber]
         dec     eax
-        mov     [ebx + TCP_SOCKET.SND_WL1], eax
         mov     [ebx + TCP_SOCKET.SND_WL1], eax
+  .no_syn_rcv:
+;-----------------------------------------------------------------------------------
+;
+; ACK processing for SYN_RECEIVED state and higher
+;
-  .no_syn_rcv:
+;-----------------------------------------------------------------------------------
 ;-------------------------
-; check for duplicate ACKs
+; Check for duplicate ACKs
         mov     eax, [edx + TCP_header.AckNumber]
         cmp     eax, [ebx + TCP_SOCKET.SND_UNA]
-        ja      .not_dup_ack
+        ja      .dup_ack_complete
         test    ecx, ecx
+        jnz     .reset_dupacks
         jnz     .reset_dupacks
         mov     eax, dword[edx + TCP_header.Window]
-        mov     eax, dword [edx + TCP_header.Window]
+        cmp     eax, [ebx + TCP_SOCKET.SND_WND]
-        cmp     eax, [ebx + TCP_SOCKET.SND_WND]
+        jne     .reset_dupacks
         jne     .reset_dupacks
+        inc     [TCPS_rcvdupack]
         DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Processing duplicate ACK\n"
 ; If we have outstanding data, other than a window probe, this is a completely duplicate ACK
-; (window info didnt change) The ACK is the biggest we've seen and we've seen exactly our rexmt threshold of them,
-; assume a packet has been dropped and retransmit it. Kludge snd_nxt & the congestion window so we send only this one packet.
+; (window info didnt change) The ACK is the biggest we've seen and we've seen exactly our rexmt threshold of them,
+; assume a packet has been dropped and retransmit it. Kludge snd_nxt & the congestion window so we send only this one packet.
-        test    [ebx + TCP_SOCKET.timer_flags], timer_flag_retransmission
         jz      @f
         test    [ebx + TCP_SOCKET.timer_flags], timer_flag_retransmission
+        jz      .reset_dupacks
-        mov     eax, [edx + TCP_header.AckNumber]
+        mov     eax, [edx + TCP_header.AckNumber]
+        cmp     eax, [ebx + TCP_SOCKET.SND_UNA]
-        cmp     eax, [ebx + TCP_SOCKET.SND_UNA]
+        jne     .reset_dupacks
         je      .dup_ack
 ; Increment dupplicat ACK counter
         mov     [ebx + TCP_SOCKET.SND_NXT], eax
         mov     eax, [ebx + TCP_SOCKET.t_maxseg]
         mov     [ebx + TCP_SOCKET.SND_CWND], eax
+; Unlock the socket
 ; Unlock the socket
         push    ebx
         lea     ecx, [ebx + SOCKET.mutex]
         call    mutex_unlock
 ; retransmit missing segment
 ; retransmit missing segment
         mov     eax, [esp]
+        call    tcp_output
         call    tcp_output
 ; Lock the socket again
 ; Lock the socket again
         mov     ecx, [esp]
         add     ecx, SOCKET.mutex
+        call    mutex_lock
-        call    mutex_lock
+        pop     ebx
         pop     ebx
 ; Continue processing
 ; Continue processing
         xor     edx, edx
         pop     eax                                     ; <<<<
         cmp     eax, [ebx + TCP_SOCKET.SND_NXT]
         jb      @f
         mov     [ebx + TCP_SOCKET.SND_NXT], eax
        @@:
         jmp     .drop
-  .no_re_xmit:
-        jbe     .not_dup_ack
   .another_lost:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Increasing congestion window\n"
         mov     eax, [ebx + TCP_SOCKET.t_maxseg]
+        add     [ebx + TCP_SOCKET.SND_CWND], eax
         add     [ebx + TCP_SOCKET.SND_CWND], eax
 ; Unlock the socket
 ; Unlock the socket
         push    ebx
+        lea     ecx, [ebx + SOCKET.mutex]
-        lea     ecx, [ebx + SOCKET.mutex]
+        call    mutex_unlock
         call    mutex_unlock
 ; retransmit missing segment, again
-; retransmit missing segment
+        mov     eax, [esp]
-        mov     eax, [esp]
+        call    tcp_output
         call    tcp_output
 ; Lock the socket again
+        mov     ecx, [esp]
-; Lock the socket again
+        add     ecx, SOCKET.mutex
+        call    mutex_lock
+        pop     ebx
-        mov     ecx, [esp]
+; And drop the incoming segment
         add     ecx, SOCKET.mutex
-        call    mutex_lock
+        jmp     .drop
         pop     ebx
         sub     edi, [ebx + TCP_SOCKET.SND_UNA]         ; now we got the number of acked bytes in edi
         inc     [TCPS_rcvackpack]
         add     [TCPS_rcvackbyte], edi
         DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: acceptable ACK for %u bytes\n", edi
+;-----------------------------------------------------------------------------------
 ;------------------------------------------
+; RTT measurements and retransmission timer
+;
-; RTT measurements and retransmission timer
+;-----------------------------------------------------------------------------------
 ; If we have a timestamp, update smoothed RTT
         jbe     .rtt_done_
         mov     eax, [ebx + TCP_SOCKET.t_rtt]
         test    eax, eax
         jz      .rtt_done_
         call    tcp_xmit_timer
   .rtt_done_:
 ; If all outstanding data is acked, stop retransmit timer and remember to restart (more output or persist)
         mov     eax, [ebx + TCP_SOCKET.t_rxtcur]
         mov     [ebx + TCP_SOCKET.timer_retransmission], eax
         or      [ebx + TCP_SOCKET.timer_flags], timer_flag_retransmission
   .no_restart:
+;-----------------------------------------------------------------------------------
 ;-------------------------------------------
+; Open congestion window in response to ACKs
+;
+;-----------------------------------------------------------------------------------
+; If the window gives us less then sstresh packets in flight, open exponentially.
-; Open congestion window in response to ACKs
+; Otherwise, open lineary
-        mov     esi, [ebx + TCP_SOCKET.SND_CWND]
-        mov     eax, [ebx + TCP_SOCKET.t_maxseg]
+        mov     esi, [ebx + TCP_SOCKET.SND_CWND]
         mov     eax, [ebx + TCP_SOCKET.t_maxseg]
         cmp     esi, [ebx + TCP_SOCKET.SND_SSTHRESH]
         jbe     @f
         push    edx
         push    eax
-        mul     eax
+        mul     eax             ; t_maxseg*t_maxseg
-        div     esi
+        div     esi             ; t_maxseg*t_maxseg/snd_cwnd
-        pop     edx
+        pop     edx             ; t_maxseg
-        shr     edx, 3
+        shr     edx, 3          ; t_maxseg/8
-        add     eax, edx
+        add     eax, edx        ; t_maxseg*t_maxseg/snd_cwnd + t_maxseg/8
-        pop     edx
-       @@:
+        pop     edx
        @@:
         add     esi, eax
         jbe     @f
         mov     esi, eax
   @@:
         mov     [ebx + TCP_SOCKET.SND_CWND], esi
+;-----------------------------------------------------------------------------------
 ;------------------------------------------
+; Remove acknowledged data from send buffer
+;
+;-----------------------------------------------------------------------------------
+; If the number of bytes acknowledged exceeds the number of bytes on the send buffer,
+; snd_wnd is decremented by the number of bytes in the send buffer and TCP knows
-; Remove acknowledged data from send buffer
+; that its FIN has been ACKed. (FIN occupies 1 byte in the sequence number space)
+        cmp     edi, [ebx + STREAM_SOCKET.snd.size]
+        jbe     .no_fin_ack
         cmp     edi, [ebx + STREAM_SOCKET.snd.size]
-        jbe     .finiacked
+; Drop all data in output buffer
         push    ecx edx ebx
+        push    ecx edx ebx
         mov     ecx, [ebx + STREAM_SOCKET.snd.size]
-        lea     eax, [ebx + STREAM_SOCKET.snd]
+        sub     [ebx + TCP_SOCKET.SND_WND], ecx
-        sub     [ebx + TCP_SOCKET.SND_WND], ecx
+        lea     eax, [ebx + STREAM_SOCKET.snd]
         call    socket_ring_free
         pop     ebx edx ecx
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: our FIN is acked\n"
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: our FIN is acked\n"
+        or      [temp_bits], TCP_BIT_FIN_IS_ACKED
-        or      [temp_bits], TCP_BIT_FIN_IS_ACKED
+        jmp     .ack_complete
-        jmp     .wakeup
+  .no_fin_ack:
-  .finiacked:
+; Drop acknowledged data
         push    ecx edx ebx
+        mov     ecx, edi
-        mov     ecx, edi
+        lea     eax, [ebx + STREAM_SOCKET.snd]
-        lea     eax, [ebx + STREAM_SOCKET.snd]
+        call    socket_ring_free
-        call    socket_ring_free
         pop     ebx
+        sub     [ebx + TCP_SOCKET.SND_WND], ecx
+        pop     edx ecx
-        sub     [ebx + TCP_SOCKET.SND_WND], ecx
-        pop     edx ecx
+  .ack_complete:
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: our FIN is not acked\n"
+;-----------------------------------------------------------------------------------
+;
 ; Wake up process waiting on send buffer
 ;----------------------------------------
-; Wake up process waiting on send buffer
+;-----------------------------------------------------------------------------------
-  .wakeup:
+        mov     eax, ebx
-        mov     eax, ebx
+        call    socket_notify
-        call    socket_notify
+; Update TCPS
+        mov     eax, [edx + TCP_header.AckNumber]
-; Update TCPS
+        mov     [ebx + TCP_SOCKET.SND_UNA], eax
-        mov     eax, [edx + TCP_header.AckNumber]
+        cmp     eax, [ebx + TCP_SOCKET.SND_NXT]
-        mov     [ebx + TCP_SOCKET.SND_UNA], eax
+        jb      @f
-        cmp     eax, [ebx + TCP_SOCKET.SND_NXT]
+        mov     [ebx + TCP_SOCKET.SND_NXT], eax
-        jb      @f
+       @@:
         mov     [ebx + TCP_SOCKET.SND_NXT], eax
-       @@:
+;-----------------------------------------------------------------------------------
+;
-; General ACK handling complete
+; State specific ACK handeling
         dd      .ack_c          ; TCPS_CLOSING
         dd      .ack_la         ; TCPS_LAST_ACK
         dd      .ack_processed  ; TCPS_FIN_WAIT_2
         dd      .ack_tw         ; TCPS_TIMED_WAIT
 ;-----------------------------------------------------------------------------------
+  .ack_fw1:
+; If our FIN is now acked, enter FIN_WAIT_2
   .ack_fw1:
         test    [temp_bits], TCP_BIT_FIN_IS_ACKED
+        jz      .ack_processed
+; If we can't receive any more data, then closing user can proceed.
+; Starting the timer is contrary to the specification, but if we dont get a FIN,
-        jz      .ack_processed
+; we'll hang forever.
         test    [ebx + SOCKET.state], SS_CANTRCVMORE
         jnz     @f
         mov     eax, ebx
         call    socket_is_disconnected
         mov     [ebx + TCP_SOCKET.timer_timed_wait], TCP_time_max_idle
         or      [ebx + TCP_SOCKET.timer_flags], timer_flag_wait
        @@:
+        mov     [ebx + TCP_SOCKET.t_state], TCPS_FIN_WAIT_2
-        mov     [ebx + TCP_SOCKET.t_state], TCPS_FIN_WAIT_2
+        jmp     .ack_processed
+;-----------------------------------------------------------------------------------
-        jmp     .ack_processed
+  .ack_c:
 ; Enter the TIME_WAIT state if our FIN is acked in CLOSED state.
-  .ack_c:
         test    [temp_bits], TCP_BIT_FIN_IS_ACKED
         jz      .ack_processed
-        mov     [ebx + TCP_SOCKET.t_state], TCPS_TIMED_WAIT
+        mov     [ebx + TCP_SOCKET.t_state], TCPS_TIME_WAIT
         mov     eax, ebx
         call    tcp_cancel_timers
         mov     [ebx + TCP_SOCKET.timer_timed_wait], 2 * TCP_time_MSL
+        or      [ebx + TCP_SOCKET.timer_flags], timer_flag_wait
-        or      [ebx + TCP_SOCKET.timer_flags], timer_flag_wait
+        mov     eax, ebx
+        call    socket_is_disconnected
+        jmp     .ack_processed
-        mov     eax, ebx
+;-----------------------------------------------------------------------------------
-        call    socket_is_disconnected
+  .ack_la:
-        jmp     .ack_processed
+; In LAST_ACK state, we may still be waiting for data to drain and/or to be acked.
 ; If our FIN is acked however, enter CLOSED state and return.
   .ack_la:
         test    [temp_bits], TCP_BIT_FIN_IS_ACKED
-        jz      .ack_processed
         jz      .ack_processed
         push    ebx
+        push    ebx
         lea     ecx, [ebx + SOCKET.mutex]
+        call    mutex_unlock
+        pop     eax
-        call    mutex_unlock
+        call    tcp_close
-        pop     ebx
+        jmp     .drop_no_socket
-        mov     eax, ebx
+;-----------------------------------------------------------------------------------
-        call    tcp_close
-        jmp     .drop_no_socket
+  .ack_tw:
-  .ack_tw:
-        mov     [ebx + TCP_SOCKET.timer_timed_wait], 2 * TCP_time_MSL
+; In TIME_WAIT state the only thing that should arrive is a retransmission of the remote FIN.
-        or      [ebx + TCP_SOCKET.timer_flags], timer_flag_wait
+; Acknowledge it and restart the FINACK timer
-        jmp     .drop_after_ack
+        mov     [ebx + TCP_SOCKET.timer_timed_wait], 2*TCP_time_MSL
-  .reset_dupacks:               ; We got a new ACK, reset duplicate ACK counter
+        or      [ebx + TCP_SOCKET.timer_flags], timer_flag_2msl
-        mov     [ebx + TCP_SOCKET.t_dupacks], 0
+        jmp     .drop_after_ack
         jmp     .ack_processed
         jnz     .drop_with_reset
         test    [edx + TCP_header.Flags], TH_SYN
         jz      .drop
+        inc     [TCPS_accepts]
+;;; TODO: check if it's a broadcast or multicast, and drop if so
         inc     [TCPS_accepts]                          ; update stats
 ;-------------------------------------------
-;;; TODO: check if it's a broadcast or multicast, and drop if so
+; Processing of SYN received in LISTEN state
         push    [edi + IPv4_header.SourceAddress]
         pop     [ebx + IP_SOCKET.RemoteIP]
         push    [edx + TCP_header.SourcePort]
         pop     [ebx + TCP_SOCKET.RemotePort]
         push    [edx + TCP_header.SequenceNumber]
         pop     [ebx + TCP_SOCKET.IRS]
         call    socket_notify
         popa
+        jmp     .trim
-        jmp     .trim
+;-----------------------------------------------------------------------------------
-;------------
+;
-; Active Open
+; Completion of active open?
+;
-align 4
+;-----------------------------------------------------------------------------------
   .SYN_SENT:
   .state_syn_sent:
         jz      .drop
         mov     eax, ebx
         mov     ebx, ECONNREFUSED
-        call    tcp_drop
         call    tcp_drop
         jmp     .drop
+       @@:
+;-----------------------------------------------------------------------------------
+;
+; Process received SYN in response to an active open
+;
-       @@:
+;-----------------------------------------------------------------------------------
-        test    [edx + TCP_header.Flags], TH_SYN
-        jz      .drop
         test    [edx + TCP_header.Flags], TH_SYN
-; at this point, segment seems to be valid
+        jz      .drop
-        test    [edx + TCP_header.Flags], TH_ACK
         jz      .no_syn_ack
         test    [edx + TCP_header.Flags], TH_ACK
-; now, process received SYN in response to an active open
+        jz      @f
         mov     eax, [edx + TCP_header.AckNumber]
-        mov     [ebx + TCP_SOCKET.SND_UNA], eax
-        cmp     eax, [ebx + TCP_SOCKET.SND_NXT]
-        jbe     @f
+        mov     [ebx + TCP_SOCKET.SND_UNA], eax
+        cmp     eax, [ebx + TCP_SOCKET.SND_NXT]
-        mov     [ebx + TCP_SOCKET.SND_NXT], eax
+        jbe     @f
-       @@:
+        mov     [ebx + TCP_SOCKET.SND_NXT], eax
         test    [edx + TCP_header.Flags], TH_ACK
         jz      .simultaneous_open
         DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: active open\n"
+        inc     [TCPS_connects]
 ;;; TODO: update stats
 ; set socket state to connected
 ; set socket state to connected
         push    eax
         mov     eax, ebx
         call    socket_is_connected
+        pop     eax
-        pop     eax
+        mov     [ebx + TCP_SOCKET.t_state], TCPS_ESTABLISHED
         mov     [ebx + TCP_SOCKET.t_state], TCPS_ESTABLISHED
 ; Do window scaling on this connection ?
 ; Do window scaling on this connection ?
         mov     word[ebx + TCP_SOCKET.SND_SCALE], ax
   .no_scaling:
+;;; TODO: reassemble packets queue
+; If we didnt have time to re-transmit the SYN,
-;;; TODO: reassemble packets queue
+; Use its rtt as our initial srtt & rtt var.
         mov     eax, [ebx + TCP_SOCKET.t_rtt]
         test    eax, eax
         je      .trim
+        call    tcp_xmit_timer
+        jmp     .trim
-        call    tcp_xmit_timer
+;-----------------------------------------------------------------------------------
+;
+; Simultaneous open (We have received a SYN but no ACK)
         jmp     .trim
-  .simultaneous_open:
+;-----------------------------------------------------------------------------------
+  .simultaneous_open:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: simultaneous open\n"
+        mov     [ebx + TCP_SOCKET.t_state], TCPS_SYN_RECEIVED
-; We have received a syn but no ACK, so we are having a simultaneous open..
+;-----------------------------------------------------------------------------------
+;
+; Common processing for receipt of SYN
+;
-        mov     [ebx + TCP_SOCKET.t_state], TCPS_SYN_RECEIVED
+;-----------------------------------------------------------------------------------
+  .trim:
-;-------------------------------------
+; Advance sequence number to correspond to first data byte.
-; Common processing for receipt of SYN
+; If data, trim to stay within window, dropping FIN if necessary
+        inc     [edx + TCP_header.SequenceNumber]
-  .trim:
+; Drop any received data that doesnt fit in the receive window.
-        inc     [edx + TCP_header.SequenceNumber]
+        cmp     ecx, [ebx + TCP_SOCKET.RCV_WND]
+        jbe     .dont_trim
 ; Drop any received data that doesnt fit in the receive window.
-        cmp     ecx, [ebx + TCP_SOCKET.RCV_WND]
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: received data does not fit in window, trimming %u bytes\n", eax
-        jbe     .dont_trim
+        inc     [TCPS_rcvpackafterwin]
         sub     ecx, [ebx + TCP_SOCKET.RCV_WND]
-        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: received data does not fit in window, trimming %u bytes\n", eax
+        add     [TCPS_rcvbyteafterwin], ecx
+        and     [edx + TCP_header.Flags], not (TH_FIN)
+        mov     ecx, [ebx + TCP_SOCKET.RCV_WND]
+  .dont_trim:
+        mov     eax, [edx + TCP_header.SequenceNumber]
-        mov     ecx, [ebx + TCP_SOCKET.RCV_WND]
+        mov     [ebx + TCP_SOCKET.RCV_UP], eax
-        and     [edx + TCP_header.Flags], not (TH_FIN)
+        dec     eax
-;;; TODO: update stats
+        mov     [ebx + TCP_SOCKET.SND_WL1], eax
   .dont_trim:
-        mov     eax, [edx + TCP_header.SequenceNumber]
+;-----------------------------------------------------------------------------------
+;
+; Update window information (step 6 in RFC793)
         mov     [ebx + TCP_SOCKET.RCV_UP], eax
-        dec     eax
+;-----------------------------------------------------------------------------------
         mov     [ebx + TCP_SOCKET.SND_WL1], eax
   .ack_processed:
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: ACK processed\n"
-  .ack_processed:
+; dont look at window if no ACK
         DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: ACK processed\n"
         test    [edx + TCP_header.Flags], TH_ACK
-;----------------------------------------------
-; check if we need to update window information
+        jz      .no_window_update
+; Does the segment contain new data?
+        mov     eax, [ebx + TCP_SOCKET.SND_WL1]
+        cmp     eax, [edx + TCP_header.SequenceNumber]
+        jb      .update_window
         ja      @f
         test    [edx + TCP_header.Flags], TH_ACK
-        jz      .no_window_update
+; No new data but a new ACK ?
-        mov     eax, [ebx + TCP_SOCKET.SND_WL1]
+        mov     eax, [ebx + TCP_SOCKET.SND_WL2]
+        cmp     eax, [edx + TCP_header.AckNumber]
+        jb      .update_window
+       @@:
+; No new data or ACK but advertised window is larger then current window?
+        mov     eax, [ebx + TCP_SOCKET.SND_WL2]
+        cmp     eax, [edx + TCP_header.AckNumber]
+        jne     .no_window_update
-        cmp     eax, [edx + TCP_header.SequenceNumber]
+        mov     eax, dword[edx + TCP_header.Window]
+        cmp     eax, [ebx + TCP_SOCKET.SND_WND]
-        jb      .update_window
+        jbe     .no_window_update
         ja      @f
-        mov     eax, [ebx + TCP_SOCKET.SND_WL2]
+; Keep track of pure window updates
-        cmp     eax, [edx + TCP_header.AckNumber]
-        jb      .update_window
+  .update_window:
-        ja      .no_window_update
+        test    ecx, ecx
-       @@:
+        jnz     @f
         mov     eax, [ebx + TCP_SOCKET.SND_WL2]
-        mov     eax, dword [edx + TCP_header.Window]
+        cmp     eax, [edx + TCP_header.AckNumber]
-        cmp     eax, [ebx + TCP_SOCKET.SND_WND]
+        jne     @f
-        jbe     .no_window_update
         mov     eax, dword[edx + TCP_header.Window]
-  .update_window:
+        cmp     eax, [ebx + TCP_SOCKET.SND_WND]
+        jbe     @f
+        inc     [TCPS_rcvwinupd]
+       @@:
-;;; TODO: update stats (Keep track of pure window updates)
+        mov     eax, dword[edx + TCP_header.Window]
         mov     [ebx + TCP_SOCKET.SND_WND], eax
-        mov     eax, dword [edx + TCP_header.Window]
+        cmp     eax, [ebx + TCP_SOCKET.max_sndwnd]
-        cmp     eax, [ebx + TCP_SOCKET.max_sndwnd]
+        jbe     @f
-        jbe     @f
+        mov     [ebx + TCP_SOCKET.max_sndwnd], eax
-        mov     [ebx + TCP_SOCKET.max_sndwnd], eax
+       @@:
        @@:
-        mov     [ebx + TCP_SOCKET.SND_WND], eax
+        DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Updating window to %u\n", eax
 ; processing of received urgent pointer
+        ;;; TODO (1051-1093)
+;-----------------------------------------------------------------------------------
-        ;;; TODO (1051-1093)
+;
 ; Process the data
-;---------------------------------------
-; process the data in the segment (1094)
+;
 ;-----------------------------------------------------------------------------------
   .do_data:
   .do_data:
-        cmp     [ebx + TCP_SOCKET.t_state], TCPS_TIMED_WAIT
+        cmp     [ebx + TCP_SOCKET.t_state], TCPS_TIME_WAIT
         jae     .final_processing
         test    [edx + TCP_header.Flags], TH_FIN
+        jnz     @f
         jnz     @f
         test    ecx, ecx
-        test    ecx, ecx
+        jz      .final_processing
-        jz      .final_processing
+       @@:
-       @@:
+; The segment is in order?
-; The segment is in order?
+        mov     eax, [edx + TCP_header.SequenceNumber]
+        cmp     eax, [ebx + TCP_SOCKET.RCV_NXT]
-        mov     eax, [edx + TCP_header.SequenceNumber]
+        jne     .out_of_order
         cmp     eax, [ebx + TCP_SOCKET.RCV_NXT]
-        jne     .out_of_order
+; The reassembly queue is empty?
         cmp     [ebx + TCP_SOCKET.seg_next], 0
-; The reassembly queue is empty?
+        jne     .out_of_order
         cmp     [ebx + TCP_SOCKET.seg_next], 0
-        jne     .out_of_order
+; The connection is established?
         call    socket_ring_write                       ; Add the data to the socket buffer
         add     [ebx + TCP_SOCKET.RCV_NXT], ecx         ; Update sequence number with number of bytes we have copied
         popa
+; Wake up the sleeping process
 ; Wake up the sleeping process
         mov     eax, ebx
         call    socket_notify
         call    tcp_reassemble
+; Generate ACK immediately, to let the other end know that a segment was received out of order,
-; Generate ACK immediately, to let the other end know that a segment was received out of order,
+; and to tell it what sequence number is expected. This aids the fast-retransmit algorithm.
 ; and to tell it what sequence number is expected. This aids the fast-retransmit algorithm.
         or      [ebx + TCP_SOCKET.t_flags], TF_ACKNOW
+  .data_done:
-  .data_done:
+;-----------------------------------------------------------------------------------
+;
 ; Process FIN
 ;---------------
-; FIN processing
+;-----------------------------------------------------------------------------------
         test    [edx + TCP_header.Flags], TH_FIN
         jz      .final_processing
         or      [ebx + TCP_SOCKET.t_flags], TF_ACKNOW
         inc     [ebx + TCP_SOCKET.RCV_NXT]
   .not_first_fin:
-        mov     eax, [ebx + TCP_SOCKET.t_state]
-        shl     eax, 2
+        mov     eax, [ebx + TCP_SOCKET.t_state]
-        jmp     dword [eax + .FIN_sw_list]
+        jmp     dword[.fin_sw_list+eax*4]
-  .FIN_sw_list:
+  .fin_sw_list:
         dd      .final_processing       ; TCPS_CLOSED
         dd      .final_processing       ; TCPS_LISTEN
         dd      .final_processing       ; TCPS_SYN_SENT
         dd      .final_processing       ; TCPS_CLOSING
         dd      .final_processing       ; TCPS_LAST_ACK
         dd      .fin_wait2              ; TCPS_FIN_WAIT_2
         dd      .fin_timed              ; TCPS_TIMED_WAIT
 ;-----------------------------------------------------------------------------------
+  .fin_syn_est:
+; In SYN_RECEIVED and ESTABLISHED state, enter the CLOSE_WAIT state
   .fin_syn_est:
         mov     [ebx + TCP_SOCKET.t_state], TCPS_CLOSE_WAIT
+        jmp     .final_processing
         jmp     .final_processing
+;-----------------------------------------------------------------------------------
+  .fin_wait1:
 ; From FIN_WAIT_1 state, enter CLOSING state (our FIN has not been ACKed)
   .fin_wait1:
+        mov     [ebx + TCP_SOCKET.t_state], TCPS_CLOSING
-        mov     [ebx + TCP_SOCKET.t_state], TCPS_CLOSING
+        jmp     .final_processing
+;-----------------------------------------------------------------------------------
-        jmp     .final_processing
+  .fin_wait2:
 ; From FIN_WAIT_2 state, enter TIME_WAIT state and start the timer
   .fin_wait2:
-        mov     [ebx + TCP_SOCKET.t_state], TCPS_TIMED_WAIT
+        mov     [ebx + TCP_SOCKET.t_state], TCPS_TIME_WAIT
+        mov     eax, ebx
-        mov     eax, ebx
+        call    tcp_cancel_timers
+        call    socket_is_disconnected
         call    tcp_cancel_timers
-        call    socket_is_disconnected
+;-----------------------------------------------------------------------------------
+  .fin_timed:
+; (re)start the 2 MSL timer
-  .fin_timed:
+        mov     [ebx + TCP_SOCKET.timer_timed_wait], 2 * TCP_time_MSL
+        or      [ebx + TCP_SOCKET.timer_flags], timer_flag_wait
-        mov     [ebx + TCP_SOCKET.timer_timed_wait], 2 * TCP_time_MSL
+;-----------------------------------------------------------------------------------
         or      [ebx + TCP_SOCKET.timer_flags], timer_flag_wait
 ; Finally, drop the segment
         DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: dumping\n"
         call    net_buff_free
+        jmp     .loop
+;-----------------------------------------------------------------------------------
+;
+; Drop segment, reply with an RST segment when needed
-        jmp     .loop
+;
-;-----------------
-; Drop the segment
+;-----------------------------------------------------------------------------------
 ;-----------------------------------------------------------------------------------
   .drop_after_ack:
         jnz     .done
         or      [eax + TCP_SOCKET.t_flags], TF_ACKNOW
+        jmp     .need_output
         jmp     .need_output
 ;-----------------------------------------------------------------------------------
   .drop_with_reset:
         DEBUGF  DEBUG_NETWORK_VERBOSE, "TCP_input: Drop with reset\n"
         test    [edx + TCP_header.Flags], TH_SYN
         jnz     .respond_syn
-        jmp     .done
-;---------
-; Respond
+        jmp     .done
   .respond_ack:
         push    ebx
         mov     cl, TH_RST

Subversion Repositories Kolibri OS

(root)/kernel/trunk/network/tcp_input.inc – Rev 6413 → 6476